qiskit-advocate / qamp-spring-22 Goto Github PK
View Code? Open in Web Editor NEWQiskit advocate mentorship program (QAMP) spring 22 cohort (Mar - Jun 2022)
Qiskit advocate mentorship program (QAMP) spring 22 cohort (Mar - Jun 2022)
Qiskit's circuit library is a collection of important quantum circuits we can use to build algorithms, applications and investigate quantum advantages. By using it we can quickly set up more complicated workflows and we can use circuits in our algorithms that have proven to be efficient in practice.
However, it's not clear to everyone what is available in the circuit library and users might be missing out on a lot of features that would make their life easier! On top, there are many open, recurring questions on circuits: what ansatz is the best for my variational algorithm? And why?
In this project, our goal is to produce material that allows everyone to use the circuit library efficiently. We will write a Qiskit tutorial, and potentially other resources like a Medium blogpost, which explain
Qiskit tutorial and possibly other resources (open to the mentee!)
1
See Qiskit/qiskit#7727.
Fix Qiskit/qiskit#7727.
1
qiskit-alt is a high-performance Julia backend for Qiskit with a Python frontend. It is quite new and experimental. It is not distributed as part of Qiskit. The main application is computing a qubit Hamiltonian from the specification of an electronic structure problem.
There are a number of projects available, small and large. The appropriate project depends on the experience of the mentee. There are a number of issues in the qiskit-alt repo. But, the project is divided into several other repos, most of which are hosted here. These repos have their own issues. A major part of the effort is improving deployment options of Julia with the Python project. These issues are in julia_project
Note that much of the work happens on the Python side. So, if you know some Python, but don't yet know Julia, you can still contribute.
Open a pull request that closes an issue and work through getting it merged. Alternatively, start by opening a new issue; for instance as a sub-issue of a more open ended one.
2
Implement the feature requested at Qiskit/qiskit#7628. Description copied below:
Qiskit uses the little endian convention for ordering the factors in a tensor product. For example, the statevector for a 3-qubit state would use the ordering Q2 ⊗ Q1 ⊗ Q0
. It would be useful to add support for specifying the tensor product order. This could be used, for example, to request a state vector using the common big endian ordering.
This can be implemented by adding a qubit_order
argument to all functions that implicitly rely on a choice of tensor product ordering. This argument would be a list of the qubit indices in the desired tensor product order. So for the example above, it would be [2, 1, 0]
to get the state in big-endian order.
The following is a non-exhaustive list of functions that would be affected:
Result.get_statevector
Result.get_counts
Operator
SparsePauliOp
Statevector
quantum_info
moduleIssue Qiskit/qiskit#7628 is resolved.
1
retworkx is a high-performance graph library used internally by Qiskit, PennyLane, and other projects. retworkx contains efficient implementations of graph algorithms, and Qiskit Terra leverages those algorithms to efficiently manipulate quantum circuits internally.
This project is about implementing Exact and practical pattern matching for quantum circuit optimization by Iten et al. using retworkx. Qiskit Terra has an implementation of Pattern Matching (https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/transpiler/passes/optimization/template_matching/template_matching.py) which is built on top of DAGDependency (https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/dagcircuit/dagdependency.py).
Ideally we'd be able to replace most of current implementation with a retworkx function, such that the transpile pass can be executed faster and included as a default in Qiskit Terra. We note that maybe not all of the Python code can be ported, hence using Cython or mypyc might also became part of the project if desired.
1
The Lanczos algorithm is a numerical method that can be used to calculate time-evolution of closed quantum system. It is a computationally efficient method for large systems and can be useful to speed up the simulation of closed-system dynamics.
PR to Qiskit dynamics repo to add the feature
1
Qiskit Runtime is a new architecture offered by IBM Quantum that streamlines computations requiring many iterations of circuit executions and classical processing. In simple terms, this means that for iterative (repetitive) computations, the time spent queuing processes is reduced, so the overall execution time becomes significantly faster. For example, IBM researchers achieved a 120x speedup in a lithium hydride molecule simulation.
Qiskit Runtime allows to design custom runtime programs to run experiments in the remote runtime server, as well as runtime clients to interface with these programs from the user side. Quantum neural network training is a good example of iterative problem, where a training loop is defined, and multiple forward and backward passes are performed on each training step. This is why qiskit-machine-learning
recently incorporated TorchRuntime
, a runtime program that leverages the PyTorch machine learning library to streamline training and inference with quantum neural networks in the cloud 🎉.
Thanks to its use of PyTorch, TorchRuntime
is extremely flexible in the kind of quantum machine learning problems it can tackle. The user can define any dataset or network architecture they want, be it a fully quantum, hybrid or even classical network, and customize the training hyper-parameters using the concept of hooks. While the core functionality of TorchRuntime
is explained in the following tutorial, the examples are quite basic, and it can be difficult for inexperienced users to know how to implement more complex workflows.
This long introduction leads to the main goal of the project: Creating a new torch runtime tutorial that shows a more realistic usage with complex examples. One idea could be showing how to perform classification on the MNIST dataset using a hybrid quantum-classical neural network and TorchRuntime
, but it can also be a chance to experiment with different QML problems and datasets.
With my help, you could dive deep into the realm of Qiskit Machine Learning, Qiskit Runtime and the mysteries of PyTorch (and with it, data serialization- the most mysterious of all). If you have found this description interesting, or would like to actually understand what I have been writing about, this might be the project for you.
While the main deliverable will be the tutorial notebook, any issues found on the way could lead to side contributions to the source code of TorchRuntime
.
A tutorial, jupyter notebook in Qiskit Machine Learning repository, explaining the advanced functionality of TorchRuntime
.
1
Required:
Nice to have:
The cx
gate is crucial for quantum computing. However, any physical implementation will be imperfect in some way. Some measure of fidelity for any proposed or implemented cx
is therefore an important benchmark.
In the era of fault-tolerant quantum computation, most cx
gates applied on physical qubits will be dedicated to implementing quantum error correction (QEC). This therefore motivates the characterization of cx
imperfects in the context of QEC.
In this project we will look at the effect of having a single imperfect cx
within an otherwise perfect QEC protocol. The aim is to define a new QEC-inspired measure of fidelity that can be calculated from theoretically derived or experimentally measured tomography of a candidate cx
.
The aim is to define a new QEC-inspired measure of fidelity that can be calculated from theoretically derived or experimentally measured tomography of a candidate cx
.
The results of this work should hopefully be included in a paper. In this case, it will hopefully be possible for the mentee to be an author.
1
When using Qiskit Metal, after components are added to the design, Rebuild has to happen to populate the Pandas tables. These tables are QGeometry tables and NetInformation tables. They are used to render to different tools i.e. Metal GUI, GDS file, Ansys
The Pandas tables have to be accurate.
The rebuild can waste time when rebuilding components that have not been changed. The project is to add some logic to determine which components can avoid the need to rebuilt.
Start a way to identify ways to reduce the number of components that need to be rebuilt. Mentors can help with that, and the logic needs to be implemented in Metal back-end code.
1
The proposal of this project is to generate a quantum circuit that can represent a Quantum RNN and make the connection with a classical model with the purpose of making a prediction of sotck prices. For this purpose we consider as reference the papers ref1, ref2.
Develop the implementation of an RNN in Qiskit.
Prepare a draft for possible submission to a journal.
1
Aim of our project is to build hands-on tutorials for implementing quantum machine learning algorithms with real world data sets using Qiskit. This tutorial should give learners a taste of what QML is really about. We are planning to work with various QML techniques such as Quantum Naive Bayes, Quantum k-nearest neighbor methods, Quantum Support Vector Machine and Quantum Bayesian networks.
We will be working on some of the real datasets for Prediction of student learning outcomes, Prediction of rising global surface temperature and Prediction of credit card fraud detection.
Output will be in the form of jupyter notebooks and journal paper.
Name: Dr. Manjula Gandhi.S
GitHubID: ManjulaGandhi
What they do: Associate Professor (Computer Science Faculty), Coimbatore Institute of Technology
Name: Balaji Seetharaman
GitHubID: bala-ceg
What they do: Software Engineer at Extreme Networks and Final year Master’s student at BITS Pilani
2
Mentee
Required
Nice to have
Qiskit includes a Numpy simulator backend called BasicAer. It suffers from issues in several areas, including performance, usability, and documentation. This project aims to address those issues.
Fix the following issues:
1
Within Qiskit Metal, we have automatic routing software using a modified A* algorithm within QRoute code. This sometimes has collisions; need to have additional checks.
Add additional checks and logic for the modified A* QRoute algorithm.
1
One of the major obstacles in solving multiphysics problems on quantum devices, like the computational fluid dynamics for example, include the non-linearity of corresponding partial diff. equations describing the particular physical process. In order to be able to harvest full potential of the quantum space in solving this complex multiphysics problems, implementation of adequate algorithm is required. One of the approaches for solving non-linear PDF is proposed by J.P. Liu et. al. in paper entitled “Efficient quantum algorithm for dissipative nonlinear differential equations”, where the Carleman linearization in combination with the linear solver is described. Implementation of this algorithm on quantum devices and testing on some practical examples using Qiskit framework is the major goal of this project.
Quantum algorithm for solving particular set of non-linear diff. equations using the Qiskit simulator backend.
1
This project aims to investigate what happens in idling of qubits by conducting Interleaved Randomized Benchmarking (InterleavedRB) of gates with delay instructions using qiskit-experiment (c.f. qiskit-experiments/tutorials).
For example, we may examine how much the spectator qubit (q2) affects CNOT gate (on q0 and q1) fidelity by 3-qubit InterleavedRB of CNOT(q0,q1)+Delay(q2). And investigating if the fidelity can be estimated by the results from the normal 2-qubit InterleavedRB of CNOT(q1, q2) and 1-qubit InterleavedRB of Delay(q2).
The above is just an example. If you think of more interesting experimental scenario, let's pursue it!
Unfortunately, the current InterleavedRB has no full capability to conduct complicated experiments like the above experiment. So you'll have to upgrade it so that you can
A jupyter notebook investigating the results of RB of gates with delays.
Advanced: Pull requests to enhance the RB module in qiskit-experiments.
1 or 2
Currently, artists who would like to work with Qiskit must figure out how to integrate Qiskit into their creative workflow. This often means translating their work to different programming languages or finding unofficial workarounds, depending on the creative environment. We propose a project to have Qiskit integrated more natively into creative environments (such as Processing). This project would require determining which creative environments are the most used by generative artists and then figuring out how to integrate Qiskit into those environments.
Having Qiskit integrated into a creative environment (such as Processing) so that generative artists can work natively work with Qiskit directly.
2
The variational quantum eigensolver (VQE) is a near-term suitable algorithm to minimize the expectation value of a quantum mechanical system -- and it has a huge range of applications! In a VQE we select an ansatz circuit, which we can execute well on today's devices, and then tune it's parameters so that the ansatz approaches the ground state of the system as good as possible. This parameter optimization however can be challenging!
In this project, we implement an optimization scheme that promises to use quantum resources more efficiently than our current optimizers. The idea is to adaptive select with how many shots we measure the expectation values and is described in this paper: https://arxiv.org/abs/1909.09083.
Depending on how quickly we finish this first task, we can then decide together in which direction we want to move. Do we want to benchmark this new optimizer and compare it to others? Are there other optimizers we'd like to include? Maybe you even came up with your own idea to improve the VQE!
This project can be worked on by 1-2 persons with some Python knowledge 🙂
A new optimizer or VQE class that is contributed to Qiskit Terra by the end of the project.
1-2
We have draft written documentation written in Overleaf LaTex called
Qiskit Metal: A quantum device design framework and library.
We would like to have "professional" type diagrams and figures for the document.
Contributor would need to understand the flow of the python code and work with various developers to create diagrams that are meaningful.
Diagrams added to the latTex document.
1
Quantum neural networks (QNNs) are promising candidates to replace classical feedforward neural networks (Please see work by Abbas et al.). However, it is still unknown if or when this can happen. Understanding the potential of QNNs requires us to investigate how they perform under many noise effects that we observe on NISQ devices. In this project, we will benchmark several QNNs under different levels of noise (readout assignment error, cnot errors, depolarizing noise, etc.) and see the effect of noise and if widely used error mitigation techniques can allow us to recover the performance.
Performance benchmarks of QNNs under noise with and without error mitigation.
2
Interest in Quantum Machine Learning.
Interest in Error Mitigation and Noisy Quantum Simulations.
Quantum machine learning is gaining momentum and becoming more and more popular across machine learning researchers. This project aims facilitating smooth transition from classical to quantum machine learning algorithms for those who are already proficient in classical ML. The goal of this project is to pick up a small classical machine learning dataset and an ML problem, e.g. classification, regression, then build up a quantum model that will produce similar results. The dataset should be small enough to be processed by a quantum computer or a simulator, but in the same time it should be widely known by ML practitioners. A classical iris
dataset may be a good candidate. The tutorial itself should be as close as possible to a real life Qiskit Machine Learning use case. This tutorial should be a good starting point for everybody.
A tutorial, jupyter notebook in Qiskit Machine Learning repository, explaining how to move from a classical algorithm an analogous quantum one.
Anton Dekusar, @adekusar-drl
Research Software Engineer / Qiskit Machine Learning contributor
1
What is required:
Qiskit Applications (Optimization, Finance, Nature, ML) have some performance benchmarks implemented. By performance we understand various metrics like executing time, required memory and other specific metrics, e.g. score, that may arise in the benchmarks. Currently a few on them were added Qiskit Machine Learning, benchmarks for quantum neural networks. This project aims at building a set of such benchmarks for QuantumKernel
.
In the project we want to do:
QuantumKernel
code/features for potential benchmarks, e.g. tutorials and unit tests may be good places for a search for candidates.Current benchmarks are available here: https://qiskit.github.io/qiskit-app-benchmarks.
Performance benchmarks for QuantumKernel
.
1
What is required:
Protein folding is the newest sampling problem released in Qiskit nature 0.2.0 (https://github.com/Qiskit/qiskit-nature/tree/main/qiskit_nature/problems/sampling/protein_folding). We would like to implement some convenience tools and extend the implementation to allow for better result interpretation and visualization of the final output.
Related issues from qiskit-nature:
qiskit-community/qiskit-nature#313
qiskit-community/qiskit-nature#235
qiskit-community/qiskit-nature#236
Implementation for Qiskit nature. A PR related to this would be a tangible deliverable.
1
We have a open source repository for Qiskit Metal at https://github.com/Qiskit/qiskit-metal/tree/main
We would like to update CI workflow testing to use python 3.10. As part of that, we would need to update Metal for 3.10 compatibility. Would need to use Metal to confirm that all features are working as expected.
Update Metal to be compatible with python 3.10
Add the updated code to CI testing to include python 3.10.
1
During CI, offer user method to reformat file to be yapf. We require all files to be formatted by yapf so the code "looks" similar. If the file is not formattted, the CI will fail. So, it would be nice to offer to reformat for the user. There are some files that have code which developers don't want to be reformatted to yapf. The solution of this project needs to address developer's wishes.
If CI fails due to non-formatted yapf file, provide a user-friendly solution.
1
Web3 is a term used to describe the decentralized and token-based economics, provided by blockchain technology. Since its emergence many years ago via popular coins and platforms, Bitcoin, Ethereum, etc. lots of development has grown out of this technology. Nowadays more and more commercial applications and companies are getting into Web3.
For this project we would like to see if there are any potential areas where we can see how to integrate Qiskit, and quantum computing in general, to the Web3 area, asides from the already popular cryptography topic, which everyone is already writing and reading about. :)
Here's a short list of topics to consider as an example:
As a deliverable ideally we would like to complete the following:
4
In the seminal article by Lamport, Shostak and Marshal, it was proven that no classical solution with less than 3⋅𝑚+1 generals can face 𝑚 traitors. A quantum solution for 3 generals using qutrits is described here and can be done with qubits entangled in such a way that they emulate qutrits as shown here and here.
In this project, the cases of 3 and 4 generals are solved by algorithms based respectively on entangled qutrits and entangled ququatrits. These qu-n-its are emulated by adequately entangled qubits. I tested successfully these algorithm for qutrits in Qiskit on qasm_simulator and FakeCasablanca or other mock backgrounds. For ququatrits, the algorithm passes the test on qasm simulator, or on a modified mock background (FakeSydney with gate errors and read out errors all set to their observed average across qubits).
This project seems quite close to completion for the mentees, who may be frustrated. It is therefore probably preferable that I play myself the role of the mentee if I find a mentor interested in this issue.
Call for a mentor (or co-author of the project) who could review the notebook, see if there are some flaws, accompany me in the verification on hardware, and help me with the publication.
I will be the mentee, but, why not, the mentor. The main point is to form a team interested by the quantum solutions of the Byzantine agreement problem.
Those who are interested can DM me on Slack @PierreDC. I shall transmit the current state of the notebook which includes a more complete description of the project in introduction.
1
(and of mentor)
The AdaptVQE
algorithm, originally implemented in Qiskit Aqua as the outcome of the Qiskit Hackathon Europe 2019, link. Since then, it has been refactored multiple times, most recently during the QAMP Fall 2021 to leverage Qiskit Terra's gradient
framework link.
This time around, we would like to take the algorithm one step further by decoupling it from Qiskit Nature and migrate it to Qiskit Terra, making it more widely available. More details will be provided soon.
Migrate the AdaptVQE
algorithm from Qiskit Nature to Terra.
1
AdaptVQE
VariationalAlgorithm
interfaceGroundStateEigensolver
interfaceThis project will be continued from qiskit-advocate/qamp-fall-21#5 by @fs1132429
We want to continue creating reusable web components for our Qiskit web projects, like Qiskti.org and the New Textbook.
We already starting developing some and want to continue creating them in https://github.com/qiskit/web-components/.
The goal is to create more Qiskit web components.
1
Quirk is a famous circuit composer and simulator, written by Craig Gidney. It is super flexible and it wold be great to have some sort of integration with Qiskit. Here are some ideas:
a python package (called qiskit-quirk
?) with some of the integrations.
1
Close as many Transpiler issues as possible.
Will also approach @kdk about this mentorship
5
Recently a new extension was introduced in Qiskit's transpiler - a unitary synthesis plugin API (https://qiskit.org/documentation/apidoc/transpiler_plugins.html). This API provides a hook point for external python packages to implement their own synthesis techniques and have them seamlessly exposed as opt-in options to users when they run. The aim of this project is to write a new tutorial that explains the plugin API and a particular implementation of this plugin, approximate quantum compiler (https://qiskit.org/documentation/apidoc/synthesis_aqc.html) that was introduced at the same time as the plugin API. The proposed tutorial should give a comprehensive point of view to unitary synthesis, API, and AQC from an end-user point of view and from a Qiskit developer perspective.
A tutorial, jupyter notebook for Qiskit Terra that covers three main topics: unitary syntheis, plugin API and approximate quantum compiler.
Anton Dekusar, @adekusar-drl
Research Software Engineer / Qiskit Machine Learning contributor
1
What is required:
A recent paper on near-term, quantum-enhanced machine learning (of which I am an author) studied a theoretical bottleneck to using quantum kernels (similarity measures) in practice for ML applications involving the generation of data points. Because new data is being created in the application, there is a need to send not only that new data, but also all of the old data, to a quantum system in order to evaluate the kernel.
The paper showed how classical matrix completion can be used to alleviate that need. It also indicated that the amount of old data which needs to be sent relates to a property of the kernel matrix representing all pairwise similarity measures; namely, its rank.
While the paper successfully identified and proposed a solution to this bottleneck, it did not study what it would mean to operationalize the solution in practice. That is, it did not consider the relevant latencies and timescales for a workflow involving both quantum computation of some kernel values and classical computation to fill in the rest.
This QAMP project would study exactly this. We would study how, in practice, this quantum-enhanced ML workflow would work. We would also perform a numerical investigation workflow's timescales. In particular, we would be especially interested to look at the tradeoff between how much classical compute time is needed for the matrix completion versus the total round-trip time for the quantum kernel algorithm.
As part of this project, I hope we would leverage the Qiskit Runtime and any existing programs compatible with it. I do not envision we would write our own Runtime programs.
Paper: Kernel Matrix Completion for Offline Quantum-Enhanced Machine Learning
2
Recommended mentee background:
The qiskit-neko project: https://github.com/mtreinish/qiskit-neko is a new effort to add a proper integration test suite to the overall qiskit project. It's designed to be run in CI to ensure that a proposed change to any qiskit project doesn't break backwards compatibility or break an interface that another qiskit project is currently using. The idea behind the project is to provide feedback before we merge a pull request if an interface is potentially broken by a change and to prevent that from being merged (so it is never released). However, this project is still in it's early stages and needs to be expanded and put into CI configurations for qiskit projects. This project is to help expand the test coverage in qiskit-neko so that we have a representative set of tests and then to potentially help get it properly running in CI for all of qiskit.
Pull requests to qiskit-neko and potentially to other qiskit projects to start getting qiskit-neko running in CI.
3
When taking the matrix exponential of an Hermitean matrix M
(for example to compute the time evolution operator from the Hamiltonian of a closed system) it is sometimes faster to first diagonalize the matrix M = V D V^{dagger}
and then exponentiate the diagonal matrix D
(which is given by exponentiating the diagonal elements) instead of using the built-in method in scipy expm
directly on the matrix M
.
Since fixed-step solvers are meant to work for arbitrary generators (even ones that cannot be diagonalized) but this method is faster for diagonalizable generators (in particular anti-hermitian), then it would be worth adding this implementation as an option for the user and to choose this option automatically in some higher level interfaces (e.g. when using a Solver instance that only has Hamiltonian information).
There is an open issue which aims at implementing this feature here
Implement the feature for Qiskit dynamics through a PR.
1
See Qiskit/qiskit#7720. Description copied below.
QuantumCircuit.draw
should support drawing the circuit with vertical wires instead of horizontal. This is useful when the length of the circuit exceeds the width of the display area. With horizontal wires, this situation results in line wrapping, but with vertical wires no wrapping would be needed because one can scroll, and it's easier to read the circuit contents that way.
Fix and close Qiskit/qiskit#7720.
1
The Amazon Braket Python SDK is an open source library that provides a framework that you can use to interact with quantum computing hardware devices through Amazon Braket.
This project is aimed to create Qiskit-Braket plugin to execute Qiskit programs against AWS Braket devices.
1
There are several proposals to solve optimization problems using Quantum Algorithms, some examples can be found in the Qiskit textbook, were an application of the Quantum Approximate Optimization Algorithm (QAOA) is presented and described. When we need to take into account the spatial dimension in an optimization problem, we are in the realm of Regional Sciences. In these problems, we work on grouping regions based on an objective function, merging adjacent locations into a homogenous regional cluster.
In this QAMP we are looking forward to explore the application of Quantum Computing to the Regional Science field, where several optimization formulations have been proposed and solved using heuristic methods that approximate an optimal solution.
1
The aim of this project is to make code contributions to Qiskit.
We will solve the issues around operators (opflow, quantum_info.operators, nature.operators). For example,
As above, there are easy to hard issues.
Code contribution (creating PRs. to Qiskit Terra or Nature)
3
The Qiskit Metal project aims towards developing an open-source end-to-end toolchain for Superconducting quantum device design. This requires an in-built GUI to render the components of the chip as well as a connection to a FEM solver to obtain parasitic capacitance matrix and/or electromagnetic fields associated with the on-chip components, and. then use them to tune the component parameters for best real-world performance.
Presently Qiskit Metal only connects to the Ansys Q3D and HFSS backends, which are not open-source and thus, cannot be accessed by everyone.
The goal of this project is to pick an open-source FEM solver (like FreeFEM, Elmer, etc) or generic PDE solvers (like FEniCS Project), and develop a connection interface to Qiskit Metal to make superconducting device design more accessible with a fully open-source design pipeline!
2
Qiskit.org is the main landing page for Qiskit, build in Nuxt using Vue.js and TypeScript.
The goal is to increase the testing coverage this web project.
1
The goal of this project is for you to gain the knowledge of the full workflow of running VQE on a IBM Quantum system.
You will learn the VQE basics and several techniques that can be implemented to improve the fidelity of the outcomes when running the circuits on a near-term quantum computer by building your own VQE example to execute on an IBM Quantum system.
You will understand the purpose of the variational algorithm for a near-term quantum computer, how to construct a parametrized circuit to measure energy expectation value for a given Hamiltonian, apply Mapomatic (https://github.com/Qiskit-Partners/mapomatic) to find a good compiled circuit with the lowest noise, understand the need for a particular optimization algorithm like SPSA when running on a real quantum computer. We will also utilize measurement mitigation techniques in several versions, full, tensored and finally M3 (https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.2.040326), (https://github.ibm.com/IBM-Q-Software/mthree) and understand the reasons for these different approaches.
A jupyter notebook that can be a tutorial
1
retworkx is a high performance general purpose graph library for python3 written in Rust to take advantage of the performance and safety that Rust provides. It was built as a replacement for Qiskit's previous networkx usage (hence the name) but is designed to provide a high performance general purpose graph library for any python application. The project was originally started to build a faster directed graph to use as the underlying data structure for the DAG at the center of qiskit-terra's transpiler, but it has since grown to cover all the graph usage in Qiskit and other applications. We use retworkx at the core of many of Qiskit's algorithms and functions (including the transpiler) when a graph representation is needed.
The full list of good first issues in retworkx can be found here.
The project is to work through good first issues on retworkx. So ideally pull requests and reviews of others pull requests on retworkx are the deliverable for this project. However, as it is a fairly open ended project to get involved in the development of retworkx the exact deliverables aren't set in stone. In previous iterations mentees have helped opened pull requests to other projects using retworkx along with other related tasks
5
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.