eclipse / xacc Goto Github PK

From @amccaskey on September 27, 2017 13:54

We should add a method to Compiler that returns the model of quantum computing the Compiler works for. We can then perform a check at Program.build time that validates that the given Compiler and Accelerator are compatible.

Copied from original issue: ORNL-QCI/xacc#57

https://github.com/rigetticomputing/pyquil/blob/master/pyquil/_parser/Quil.g4

When using the XACC Python API, there is no error warning or indication that XACC is uninitialized when calling pyxacc.gate.create() without first initializing XACC using pyxacc.Initialize()

This just occured to me.

Previously we had to name our python module pyxacc because the Pybind11 library had to be pyxacc.so because we already had an xacc.so. Now that we have a wrapper python module script pyxacc.py that imports _pyxacc.so, we can rename this to xacc.py

This xacc install was attempted on an Ubuntu 16.04 running in Virtual Box. The following commands were used

Then I typed sudo make install and the whole thing crashed and burned

This xacc install was attempted on an Ubuntu 16.04 running in Virtual Box. The following commands were used

commands from attempted xacc install on Ubuntu 16-04.docx

From @amccaskey on September 27, 2017 14:9

We could do this in a fairly straightforward way

• Implement python scikit-learn feature extraction vector
• Create large set of random circuits in various languages
• Train feature extraction on that set
• Integrate with xacc::Program.build() and friends

Copied from original issue: ORNL-QCI/xacc#59

we need a method on these interfaces to query the total number of bits they operate on.

This could help with deployment in #30

https://github.com/mrtazz/restclient-cpp

Um... heck yea.

https://github.com/QuantStack/xeus-cling

We need to create binary builds as python wheels to make it easy for users to pip install xacc and friends.

Problem is that currently xacc::error exit()'s the process, killing the jupyter kernel.

This is for apps that are built on XACC. Right now users can only add string key-value options with xacc::addCommandLineOption function.

So create a xacc::addCommandLineOptions(opts : options_description)

From @amccaskey on September 27, 2017 13:56

Sycl is an example in the classical world. It would be cool to program kernels inline with C++ as simple lambdas, then our compiler could pick them up, and leverage the current infrastructure to compile and link.

Copied from original issue: ORNL-QCI/xacc#58

Below are two examples of HTTP status line issues I have encountered in the last 24 hrs.

EX1:
Job Response: RUNNING[2018-04-09 16:51:12.680] [xacc-logger] [info] IBM Accelerator caught exception while calling restClient->get() - Failed to read HTTP status line
[2018-04-09 16:51:12.680] [xacc-logger] [info] Retrying HTTP Get.
Job Response: RUNNINGAssertion failed: (false), function operator[], file /Users/edq/Library/Python/3.6/lib/python/site-packages/xacc-0.1.0-py3.6-macosx-10.11-x86_64.egg/include/rapidjson/include/rapidjson/document.h, line 1103.
Abort trap: 6

EX2:
----> 1 energy = lambda angles: vqe.execute(xaccOp, **{'task':'compute-energy', 'ansatz':IR_fun, 'accelerator':acc, 'vqe-params':str(angles)[1:len(str(angles))-1]
2 })
RuntimeError: Failed to read HTTP status line

Automate setting the default compiler to prevent installation issues as per below: CXX=/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++ python3 setup.py install --user

We made TNQVM for the validation of the XACC programming model. We should add it is a TPL or git submodule of XACC, that way users installing just XACC will always have at least one accelerator and compiler (xacc-py) by default.

From @amccaskey on October 24, 2017 16:57

Copied from original issue: ORNL-QCI/xacc#67

Something like AQCAcceleratorBuffer stores D-Wave specific results. We should provide a map<string, Result> to AcceleratorBuffer and a getResults() function so that users can get sub-type-specific results from the AcceleratorBuffer interface-level.

Wrap this simulator so we can use it https://github.com/QCT-IQC/qpp

something like

$ xacc-framework --credentials ibm --token TOKEN

We need a way to generate a template C++ projects for various xacc extension points. Users can generate these template projects, and fill in pertinent functions to implement what they want. This gets users away from starting up all the boilerplate C++ and CMake code.

From @amccaskey on October 31, 2017 15:16

IR and Function can implement GraphProducer or some name like that.

Copied from original issue: ORNL-QCI/xacc#72

From @amccaskey on October 30, 2017 20:34

Add Accelerator to the generate method of IRGenerator.

Copied from original issue: ORNL-QCI/xacc#70

Without this we can't get any of our Antlr Compilers.

From @amccaskey on October 12, 2017 21:10

Example - Eugene want's to program shor's algorithm with a modular exponentiation gate instruction that can be hit by a TNQVM visitor.

Copied from original issue: ORNL-QCI/xacc#65

Think about replacing large boost dependency with

• https://github.com/wjakob/filesystem
• https://github.com/jarro2783/cxxopts

This method searches for available xacc plugins and installs them to the cppmicroservices framework.

We need to set this up to not be dependent on the installation directory, as that may not be there in the case of a wheel install.

Currently we search for external plugins in $HOME/.xacc/plugins, and this is fine. But how to load the internal xacc-quantum-{gate,aqc} plugins that are in the installation directory?

My first thought is that we have xacc-framework create a internal $HOME/.xacc/.internal_plugins file that contains the path from

os.path.dirname(os.path.realpath(pyxacc.__file__))

This would require that users run

xacc-framework --initialize 

before using the framework.

ServiceRegistry could start by searching for this .internal_plugins file, and then if not found or invalid, throw an exception that explains to the user that they must run the above initialization command. If found, the plugins are loaded and the the rest of the plugins are loaded.

Now if we start using pip install for plugin wheels, then we must require our users to go through the xacc-framework executable. They would then run

xacc-framework --install tnqvm

which would try to pip install the wheel, and if successful would add the path to the library to the .internal_plugins file. If not successful, then it would be do a custom build and install to .xacc/plugins/

Add a map to ServiceRegistry that keeps track of installed plugins so we don't try to reinstal plugins that have been installed.

Provide a pip install mechanism for xacc.

This will probably require storing some .xacc_plugins cache file that keeps track of the plugins installed. Read that in and update those plugins when the framework has changed.

From @amccaskey on October 4, 2017 21:22

Copied from original issue: ORNL-QCI/xacc#62

imagine something like Rx(-2.0 * theta)

Right now InstructionVisitors are created as needed and clients always know which ones they are using. We should make them an extension point in the framework. Then we can use them for IR-to-source translation.

From @amccaskey on September 28, 2017 14:48

We need to expose at the AcceleratorBuffer level the ability to return all measurement strings to the user.

Add this to xacc-python as well.

Copied from original issue: ORNL-QCI/xacc#60

From @amccaskey on October 24, 2017 20:32

Copied from original issue: ORNL-QCI/xacc#68

Expose counts map in the python accelerator buffer

From @amccaskey on October 9, 2017 19:35

This will make us polymorphic in HUBO's, then we can make a general D-Wave application.

Copied from original issue: ORNL-QCI/xacc#63

kernel.nParameters() and kernel.getName() lead to segmentation faults in pyxacc

From @amccaskey on June 30, 2017 16:2

What do we do if our InstructionParameter string is something like

"0.5 * theta"

A search and replace on theta, which is what we do now, won't work.

Copied from original issue: ORNL-QCI/xacc#40

BAD ->

def f(theta):
   Rx(t,0)

GOOD->

def f(t):
   Rx(t,0)

Hello,

I have a segmentation fault from getMeasurementStrings and getMeasurementCounts.
I installed XACC and plugings with pip on Docker images.
I am attaching the printing of a simple script and the script.

import pyxacc as xacc
import sys

def hello(acc="ibm",backendinput="ibmq_qasm_simulator"):
xacc.Initialize(["--compiler","quil"])
accelerator = acc
backend = backendinput

qpu = xacc.getAccelerator(accelerator)
nqbits = 2

xacc.setOption(acc+"-backend",backend)
# code commented is for setting
# the number of trials one run the circuit (default 1024)
# One can set any option that come with the accelerator
# xacc.setOption("ibm-shots","1024")
# xacc.setOption("rigetti-trial","1024")

qreg = qpu.createBuffer("qreg",nqbits)

src = """__qpu__ bell(AcceleratorBuffer b){
H 0
CNOT 0 1
MEASURE 0 [0]
MEASURE 1 [1]
}
"""

program = xacc.Program(qpu,src)
program.build()

k = program.getKernel("bell")
k.execute(qreg,[])

print(qreg.getMeasurementStrings())
print(qreg.getMeasurementCounts())
xacc.Finalize()

if name == "main":

if len(sys.argv) == 3:
    hello(sys.argv[1],sys.argv[2])
else:
    hello()

From @amccaskey on November 13, 2017 17:27

Copied from original issue: ORNL-QCI/xacc#73

From @amccaskey on October 31, 2017 14:57

We should be able to execute kernels both synchronously and asynchronously, where the latter returns futures or promises.

Copied from original issue: ORNL-QCI/xacc#71

Antlr will not build without GCC 5+

From @amccaskey on October 20, 2017 19:45

AlgorithmGenerator maybe should take as input an AcceleratorBuffer and a vector of InstructionParameters

Copied from original issue: ORNL-QCI/xacc#66