by: Kevin Broløs & Tom Jelen
(Feyn version 1.4 or newer)
A Feyn tour around the block
Welcome to this quick guided tour. We'll get you set up and taking advantage of your shiny new
QLattice in no time.
Feyn is a
Python library available for installation using
pip, for your favourite OS (if your favourite is either
OS X 10.14+,
richard@feyn:~$ pip3 install feyn
Once installed, go to your preferred
Python environment and follow along with this example.
Connect to your QLattice
You're going to need access to a
QLattice to get started. Don't have one? Sign up!
import feyn qlattice = feyn.QLattice(qlattice="<Your qlattice>", api_token="<Your API token>")
Here's a guide on how to get your URL and API token.
Load an example dataset
To introduce the core concepts of building a
Feyn graph, we will pick a simple classification problem from
sklearn, and load it with
import sklearn.datasets import pandas as pd from feyn.tools import split breast_cancer = sklearn.datasets.load_breast_cancer() input_columns = breast_cancer.feature_names # Load into a pandas dataframe data = pd.DataFrame(breast_cancer.data, columns=input_columns) data['target'] = pd.Series(breast_cancer.target) # Split into train & test train, test = split(data, ratio=(0.67, 0.33))
Communicating with the QLattice
Starting out, the
QLattice won't know your problem domain or have any concept of what features to connect. We teach it this by fitting
QGraphs and updating the
QLattice with the best model(s). The
QGraph is an endless collection of possible graphs describing the relationship between your inputs and output.
So, to get started, we'll have to define our problem type as either a
classification problem. For this one, we'll get a classifier, using the names of your input features and target output.
# Get a QGraph of graphs between your inputs and output from the remote QLattice. qgraph = qlattice.get_classifier(data.columns, output='target')
You'll see the classifier is just a
QGraph that knows how to treat the output node.
Now you have a
QGraph that's ready to fit your problem, and the
QLattice will start generating graphs that relate to your problem.
How to fit your QGraph
Everytime you fit the graphs in your
QGraph, it'll filter out the useless graphs and pull some fresh ones from the
A single fit looks like this:
# Now fit a subset of the QGraph with your local data qgraph.fit(train)
While this might, for simple cases, come up with a good solution already, you should run this iteratively and update the
QLattice with the best graph(s). This will teach the
QLattice about what best describes your problem based on your learnings, and narrow the search space of the
QLattice. This allows it to get better at suggesting new useful graphs.
An update loop could look like this:
no_updates = 10 for _ in range(no_updates): # Fit a subset of the QGraph with your local data. qgraph.fit(train) # Select the best performing graphs from our fitted QGraph best_graphs = qgraph.best() # Feed the experience back to the QLattice so it gets smarter for subsequent calls. qlattice.update(best_graphs)
Repeat until convergence happens - just as you would in regular machine learning applications.
Notice, that while the
QLattice lives remotely on the
Abzu cluster, it never sees your local data. You train locally, and the resulting structure of the graphs is what is transmitted to the
Finally, use the resulting single graph and evaluate the results on the test dataset.
Here, we explicitly state the input columns, but
Feyn would also filter away the target column if it was included (as it's not being used as input to the graph). Nifty, huh?
# Selection of best graph best_graph = best_graphs predictions = best_graph.predict(test[input_columns]) # Round off the results to discretize to 0 or 1 for classification. predictions = predictions.round() feyn.plots.plot_confusion_matrix(y_true=test['target'], y_pred=predictions, title="Evaluation Results")
However the same code is wrapped up in the following method:
Of course we've got way more in store for you, so take a dive off the deep end of the pool with the rest of our documentation, starting with an introduction to the basic workflow!