feat: Final code to run multimode circuit with tf backend (#5)

* chore: refactor probabilities and tested sampling

* chore: integrated optimization

* chore: integrated optimization

* chore: plotting probs

* chores: added plotting

* chores: intregate plotting

* chore: executed results

* chore: results with larger codewords

* chores: added tf

* chores: added tf and sampling shots

* chores: tested tf

* chores: passed tests tf

* chores: results with tf

* chores: computed tf probs

* chore: removed unused imports

* chores: added pickle

* chores: run experiments

* refactor: add circuit and engine

* chore: added results

* chore: results

* chore: added results

* chores: refactor engine and circuit

* chores: fix tf with refactor

* chore: added results optimized two params

* chores: results from one layer and disp + squezz

* chores: added interferometer

* chores: added universal multimode

* chores: fixed typo

* chore: added batch and codeword classes

* feat: added multimode architecture

* chores: computed marginal probability

* chore: implemented multimode
probability

* chores: tested for one mode probabilities

* build: removing mypy

* chore: tested probs 1 mode (fock, gaus)

* chores: testing tf

* chore: fixed for tf

* chore: fixed typing

* chore: printing title to plots

* feat: implemented parallel processing

* chore: allocate necessary gpu memory only

* chore: remove timing

* chore: limit parallel based on gpu memory

* chore: result fock 1 mode squeezing

* chore: result fock 1 mode no squeezing

* chore: parallel results

* chore: tf mode 2 s:true result

* chore: plotting computation time

* chore: added tf in parallel

* chore: tf result in parallel

* chore: fock results

* chores: using batches size as only the possible words combinations

* fix: using random word flag correctly

* chores: increased learning rate for smaller alphas

* chores: removed specific learning rate

* chores: pHom for n modes

* chore: added number_modes

* chores: cutoff variable of alpha

* chores: fix creation var

* chores: cutoff variable for all backends

* chores: updated parallel experiment

* feat: added global results

* chores: add global path

* chores: add alphas path

* chores: global results prep

* chores: global results

* chores: added plots

* chores: results

* chores: load results

* chores: 3 mode results

* chores: using params correct names

* chores: plotting results with squeezing

* chores: add squeezing

* chores: official results modes=1

* chores: l.steps and cutoff for dim>3

* chors: results from modes 2

* chores: fix name creation

* chores: added ancillas to the circuit creation

* chores: added ancillas to plots

* chores: assign paramaters to a circuit with ancilla modes

* chores: create input and output batches and codewords

* chores: using input and output codewords

* feat: implemented ancilla architecture with one input mode

* feat: add guess strategy move noise to ancillas

* refactor: using cutoff, l_rate, l_steps with 3 options

* chores: prepared to launch

* chores: tested with no ancilla 1 mode

* chores: updated ignore

* chores: tested with ancillas measurement

* chores: selecting results based on minimum distance to homodyne

* chores: print a nice squared value

* chores: estimated remaining time

* chores: results plotes from ancillas

* chores: plotting correctly with ancillas

* chores: add one alpha

* chores: adding one specific alpha

* chores: filter to only new results

* chores: results with 5 modes

* chores: added 5 mode results

* chores: plotting line styles for fixed alphas

* chores: added colours

* chores: plotting helstrom

* feat: added interactive plot

* chores: plotting interactive results and aligned colours

* chore: prepared results in a notebook

* chores: restyling plots

* chores: plotted results

* fix: computed remaining time

* chores: starting high values at 0.6

* fix: typo on title

* chores: updated helstrom and logs

* chores: updated helstrom and log without abs

* chores: not limit set

* chores: plotting phels with several modes

* chore: interactive one alpha

* feat: coded tf sampling

* chores: initial changes from testing tape

* chores: using minimize

* chores: fix more tf operators

* chores: computes without crash

* chores: some checks

* chores: using again tape

* chores: watching all vars but still with a warning

* chores: computing prob from mean_photons (WIP)

* chores: using mean photons

* feat: computing mean photons error

* feat: train & test implementation

* chores: initial results

* chores: removed logging

* fix: set seconds < 1

* chores: train & test for tf probabilities

* chores: tested with probs and sampling

* feat: launching one mode experiments

* feat: using sampling with mixed scipy & tf backend

* chores: testing the theory

* chores: implemented manual mesurement

* chores: starting the testing

* chores: tested with one mode

* chores: backing up results from fock_prob

* chores: results

* chores: updated instructions

* chores: upload results

* chores: added mode 6 and ancillas up to 3

* chores: adjusted plots w/ legend right and squezzing

* chores: updated results

* initial commit

* build: setup ssl web api

* build: pass local http calls

* chores: added jupyterlab

* chores: added jupyterdata

* build: added new requirements

* build: set library on root

* chores: updated to sf 0.21 api

* chores: updated to sf 0.21 api

* build: added new requirement

* build: add cuda support

* build:  using ubuntu:20.04

* feat: added ddbb model structures

* feat: added ddbb structure

* chores: implemented add and get instances from database

* feat: added get execution results

* wip: ddbb

* feat: added codebooks

* chores: fixed max channel computation

* feat: implemented codebooks

* fix: using a fix to solve sf bug when using tf with a batch of 1

* using helstrom instead of homodyne to compare results

* results from codebooks

* fix: accepting batches with len=1

* fix: using output with the same size than input

* chores: fix computing the output matrices for input codebooks

* chores: scale probabilities to the input codebooks possible

* chores: using all possible codebooks from a batch

* chores: set function call inside the inner loop

* feat: using ancillas with codebooks

* chores: added remaining time for codebooks

* chores: updated exp

* chores: set a better remaining time plot

* feat: added a maximum number of codebook combinations

* chores: results with codebooks

* fix: set correct color name

* feat: new results

* feat: implemented linear codes

* chores: log max & min prob

* chores: filtering information bits > 0

* chores: continue to next iteration when codebooks size is 0

* chores: remove print

* chores: updated branch

* chores: removed cuda from jupyterlab

* chore: printing current codebook

* chores: results from linear codes

* feat: added binary code to codeword

* feat: computed ideal homodyne and helstrom taking into account linear codes

* feat: implemented top5 best codeboooks

* chore: using measurements

* feat: build a top5 best codebooks

* feat: write best codebook to global results file

* chores: fix plot when no probs are computed

* feat: plotting best codewords results

* feat: using train & test again

* chores: added m5 results

* chores: reestructured results to train & testing

* refactor: using train and testing results

* refactor: created results for train & test separately

* results from testing modes 5

* perf: added optimized parameters as the resulting cvs file

* feat: printing best circuit to output and file

* chores: updated directory name

* writing testing and training results

* chores: fix success probability

* add circuit tex directory and  execution plots

* setting testing default to True

* fix printing

* chores: new results with optimized parameters

* chores: added training directory

* fix: plotting correctly homo & helstrom probs

* chores: results from 2 to 5 modes from training and testing

* fix: correcting circuit with squeezing=False

* fix: computing maximum likelihood with linear codes

* chores: added example

* feat: computing maximum likelihood from a batch

* feat: adapted to maximum likelihood

* chores: created new utils directory to avoid circular import

* fix: 🐛 guessed codeword is the best output codeword associated with the input

* perf:

* fix: 📝 storing best measurements as a dict

* chore: using testing when creating a circuit

* chore: creating codebooks

* feat: testing directly from optimized parameters

* fix: printing optimized parameters as dict

* test: added more testing

* fix: batch_sizre

* chore: add results

* added black config

* added latest results

* add support for 8 modes

* feat: add polar codes direct train&test

* using polar codes

* chore: simulate all codebooks or using linear codes

* left only the library as a service

* removed file

* added instructions for running the simulation

.gitignore

@@ -127,3 +127,15 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+examples/logs
+output.txt
+tf*output.txt
+*bak*
+logs*
+examples/results/globals/alphas*
+data/certbot
+jupyterdata
+circuit_tex
+examples/testing_results/plot_*
+examples/training_results/plot_*

README.md

@@ -44,3 +44,28 @@ Find the mathematica file and a screenshot where you can take the expressions of
 
 ![Mathematica Screenshot](./doc/images/mathematica.png)
 
+## Running the simulation
+
+There are several ways to run the simulation, all of them are available at the `examples` folder. From all of them, you need first to install the library by running on the project base directory:
+
+```sh
+pip install .
+```
+
+Then you can execute the `parallel_experiments.py` editing the file and selecting the option you desire to run:
+
+```python
+list_number_input_modes = [2]
+list_squeezing = [False]
+number_ancillas = 0
+max_combinations = 0
+```
+
+* list_number_input_modes: specify the list of input number of modes.
+* list_squeezing: specify if you want to simulate with squeezing layer, True or False. It can be both if you want a simulation for either one.
+* number_ancillas: specify the number of ancillas to use
+* max_combinations: when using all possible combination of codebooks, specify the number of maximum combinations to train. If you set this parameter to `0`, then it will apply the linear codes technique.
+
+Once your simulation has finished, you should run `process_results.py` to consolidate all your results into a single results `csv` file and plot the results.
+
+Then, you can run the jupyter notebook `plot_testing_results.ipynb` or `plot_testing_best_results.ipynb` that will read from that `csv` file to plot interactive results.