--- a +++ b/Code/All Qiskit, PennyLane QML Nov 23/37a Data-Reuploading 90.6% kkawchak.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "bPJ9-Bl6wup5" + }, + "outputs": [], + "source": [ + "# This cell is added by sphinx-gallery\n", + "# It can be customized to whatever you like\n", + "%matplotlib inline\n", + "# !pip install pennylane" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "X6qyuFCrwup7" + }, + "source": [ + "Data-reuploading classifier {#data_reuploading_classifier}\n", + "===========================\n", + "\n", + "::: {.meta}\n", + ":property=\\\"og:description\\\": Implement a single-qubit universal quantum\n", + "classifier using PennyLane. :property=\\\"og:image\\\":\n", + "<https://pennylane.ai/qml/_images/universal_dnn1.png>\n", + ":::\n", + "\n", + "::: {.related}\n", + "tutorial\\_variational\\_classifier Variational classifier\n", + "tutorial\\_multiclass\\_classification Multiclass margin classifier\n", + "tutorial\\_expressivity\\_fourier\\_series Quantum models as Fourier series\n", + ":::\n", + "\n", + "*Author: Shahnawaz Ahmed --- Posted: 11 October 2019. Last updated: 19\n", + "January 2021.*\n", + "\n", + "A single-qubit quantum circuit which can implement arbitrary unitary\n", + "operations can be used as a universal classifier much like a single\n", + "hidden-layered Neural Network. As surprising as it sounds,\n", + "[Pérez-Salinas et al. (2019)](https://arxiv.org/abs/1907.02085) discuss\n", + "this with their idea of \\'data reuploading\\'. It is possible to load a\n", + "single qubit with arbitrary dimensional data and then use it as a\n", + "universal classifier.\n", + "\n", + "In this example, we will implement this idea with Pennylane - a python\n", + "based tool for quantum machine learning, automatic differentiation, and\n", + "optimization of hybrid quantum-classical computations.\n", + "\n", + "Background\n", + "----------\n", + "\n", + "We consider a simple classification problem and will train a\n", + "single-qubit variational quantum circuit to achieve this goal. The data\n", + "is generated as a set of random points in a plane $(x_1, x_2)$ and\n", + "labeled as 1 (blue) or 0 (red) depending on whether they lie inside or\n", + "outside a circle. The goal is to train a quantum circuit to predict the\n", + "label (red or blue) given an input point\\'s coordinate.\n", + "\n", + "\n", + "\n", + "### Transforming quantum states using unitary operations\n", + "\n", + "A single-qubit quantum state is characterized by a two-dimensional state\n", + "vector and can be visualized as a point in the so-called Bloch sphere.\n", + "Instead of just being a 0 (up) or 1 (down), it can exist in a\n", + "superposition with say 30% chance of being in the $|0 \\rangle$ and 70%\n", + "chance of being in the $|1 \\rangle$ state. This is represented by a\n", + "state vector\n", + "$|\\psi \\rangle = \\sqrt{0.3}|0 \\rangle + \\sqrt{0.7}|1 \\rangle$ -the\n", + "probability \\\"amplitude\\\" of the quantum state. In general we can take a\n", + "vector $(\\alpha, \\beta)$ to represent the probabilities of a qubit being\n", + "in a particular state and visualize it on the Bloch sphere as an arrow.\n", + "\n", + "\n", + "\n", + "### Data loading using unitaries\n", + "\n", + "In order to load data onto a single qubit, we use a unitary operation\n", + "$U(x_1, x_2, x_3)$ which is just a parameterized matrix multiplication\n", + "representing the rotation of the state vector in the Bloch sphere. E.g.,\n", + "to load $(x_1, x_2)$ into the qubit, we just start from some initial\n", + "state vector, $|0 \\rangle$, apply the unitary operation $U(x_1, x_2, 0)$\n", + "and end up at a new point on the Bloch sphere. Here we have padded 0\n", + "since our data is only 2D. Pérez-Salinas et al. (2019) discuss how to\n", + "load a higher dimensional data point ($[x_1, x_2, x_3, x_4, x_5, x_6]$)\n", + "by breaking it down in sets of three parameters\n", + "($U(x_1, x_2, x_3), U(x_4, x_5, x_6)$).\n", + "\n", + "### Model parameters with data re-uploading\n", + "\n", + "Once we load the data onto the quantum circuit, we want to have some\n", + "trainable nonlinear model similar to a neural network as well as a way\n", + "of learning the weights of the model from data. This is again done with\n", + "unitaries, $U(\\theta_1, \\theta_2, \\theta_3)$, such that we load the data\n", + "first and then apply the weights to form a single layer\n", + "$L(\\vec \\theta, \\vec x) = U(\\vec \\theta)U(\\vec x)$. In principle, this\n", + "is just application of two matrix multiplications on an input vector\n", + "initialized to some value. In order to increase the number of trainable\n", + "parameters (similar to increasing neurons in a single layer of a neural\n", + "network), we can reapply this layer again and again with new sets of\n", + "weights,\n", + "$L(\\vec \\theta_1, \\vec x) L(\\vec \\theta_2, , \\vec x) ... L(\\vec \\theta_L, \\vec x)$\n", + "for $L$ layers. The quantum circuit would look like the following:\n", + "\n", + "\n", + "\n", + "### The cost function and \\\"nonlinear collapse\\\"\n", + "\n", + "So far, we have only performed linear operations (matrix\n", + "multiplications) and we know that we need to have some nonlinear\n", + "squashing similar to activation functions in neural networks to really\n", + "make a universal classifier (Cybenko 1989). Here is where things gets a\n", + "bit quantum. After the application of the layers, we will end up at some\n", + "point on the Bloch sphere due to the sequence of unitaries implementing\n", + "rotations of the input. These are still just linear transformations of\n", + "the input state. Now, the output of the model should be a class label\n", + "which can be encoded as fixed vectors (Blue = $[1, 0]$, Red = $[0, 1]$)\n", + "on the Bloch sphere. We want to end up at either of them after\n", + "transforming our input state through alternate applications of data\n", + "layer and weights.\n", + "\n", + "We can use the idea of the \\\"collapse\\\" of our quantum state into one or\n", + "other class. This happens when we measure the quantum state which leads\n", + "to its projection as either the state 0 or 1. We can compute the\n", + "fidelity (or closeness) of the output state to the class label making\n", + "the output state jump to either $| 0 \\rangle$ or $|1\\rangle$. By\n", + "repeating this process several times, we can compute the probability or\n", + "overlap of our output to both labels and assign a class based on the\n", + "label our output has a higher overlap. This is much like having a set of\n", + "output neurons and selecting the one which has the highest value as the\n", + "label.\n", + "\n", + "We can encode the output label as a particular quantum state that we\n", + "want to end up in and use Pennylane to find the probability of ending up\n", + "in that state after running the circuit. We construct an observable\n", + "corresponding to the output label using the\n", + "[Hermitian](https://pennylane.readthedocs.io/en/latest/code/ops/qubit.html#pennylane.ops.qubit.Hermitian)\n", + "operator. The expectation value of the observable gives the overlap or\n", + "fidelity. We can then define the cost function as the sum of the\n", + "fidelities for all the data points after passing through the circuit and\n", + "optimize the parameters $(\\vec \\theta)$ to minimize the cost.\n", + "\n", + "$$\\texttt{Cost} = \\sum_{\\texttt{data points}} (1 - \\texttt{fidelity}(\\psi_{\\texttt{output}}(\\vec x, \\vec \\theta), \\psi_{\\texttt{label}}))$$\n", + "\n", + "Now, we can use our favorite optimizer to maximize the sum of the\n", + "fidelities over all data points (or batches of datapoints) and find the\n", + "optimal weights for classification. Gradient-based optimizers such as\n", + "Adam (Kingma et. al., 2014) can be used if we have a good model of the\n", + "circuit and how noise might affect it. Or, we can use some gradient-free\n", + "method such as L-BFGS (Liu, Dong C., and Nocedal, J., 1989) to evaluate\n", + "the gradient and find the optimal weights where we can treat the quantum\n", + "circuit as a black-box and the gradients are computed numerically using\n", + "a fixed number of function evaluations and iterations. The L-BFGS method\n", + "can be used with the PyTorch interface for Pennylane.\n", + "\n", + "### Multiple qubits, entanglement and Deep Neural Networks\n", + "\n", + "The Universal Approximation Theorem declares that a neural network with\n", + "two or more hidden layers can serve as a universal function\n", + "approximator. Recently, we have witnessed remarkable progress of\n", + "learning algorithms using Deep Neural Networks.\n", + "\n", + "Pérez-Salinas et al. (2019) make a connection to Deep Neural Networks by\n", + "describing that in their approach the \\\"layers\\\"\n", + "$L_i(\\vec \\theta_i, \\vec x )$ are analogous to the size of the\n", + "intermediate hidden layer of a neural network. And the concept of deep\n", + "(multiple layers of the neural network) relates to the number of qubits.\n", + "So, multiple qubits with entanglement between them could provide some\n", + "quantum advantage over classical neural networks. But here, we will only\n", + "implement a single qubit classifier.\n", + "\n", + "\n", + "\n", + "\\\"Talk is cheap. Show me the code.\\\" - Linus Torvalds\n", + "-----------------------------------------------------\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 388 + }, + "id": "RJadEWtGwup9", + "outputId": "c0ba3988-cf45-4801-d838-06105077821d" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 400x400 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import pennylane as qml\n", + "from pennylane import numpy as np\n", + "from pennylane.optimize import AdamOptimizer, GradientDescentOptimizer\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Set a random seed\n", + "np.random.seed(42)\n", + "\n", + "\n", + "# Make a dataset of points inside and outside of a circle\n", + "def circle(samples, center=[0.0, 0.0], radius=np.sqrt(2 / np.pi)):\n", + " \"\"\"\n", + " Generates a dataset of points with 1/0 labels inside a given radius.\n", + "\n", + " Args:\n", + " samples (int): number of samples to generate\n", + " center (tuple): center of the circle\n", + " radius (float: radius of the circle\n", + "\n", + " Returns:\n", + " Xvals (array[tuple]): coordinates of points\n", + " yvals (array[int]): classification labels\n", + " \"\"\"\n", + " Xvals, yvals = [], []\n", + "\n", + " for i in range(samples):\n", + " x = 2 * (np.random.rand(2)) - 1\n", + " y = 0\n", + " if np.linalg.norm(x - center) < radius:\n", + " y = 1\n", + " Xvals.append(x)\n", + " yvals.append(y)\n", + " return np.array(Xvals, requires_grad=False), np.array(yvals, requires_grad=False)\n", + "\n", + "\n", + "def plot_data(x, y, fig=None, ax=None):\n", + " \"\"\"\n", + " Plot data with red/blue values for a binary classification.\n", + "\n", + " Args:\n", + " x (array[tuple]): array of data points as tuples\n", + " y (array[int]): array of data points as tuples\n", + " \"\"\"\n", + " if fig == None:\n", + " fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n", + " reds = y == 0\n", + " blues = y == 1\n", + " ax.scatter(x[reds, 0], x[reds, 1], c=\"red\", s=20, edgecolor=\"k\")\n", + " ax.scatter(x[blues, 0], x[blues, 1], c=\"blue\", s=20, edgecolor=\"k\")\n", + " ax.set_xlabel(\"$x_1$\")\n", + " ax.set_ylabel(\"$x_2$\")\n", + "\n", + "\n", + "Xdata, ydata = circle(500)\n", + "fig, ax = plt.subplots(1, 1, figsize=(4, 4))\n", + "plot_data(Xdata, ydata, fig=fig, ax=ax)\n", + "plt.show()\n", + "\n", + "\n", + "# Define output labels as quantum state vectors\n", + "def density_matrix(state):\n", + " \"\"\"Calculates the density matrix representation of a state.\n", + "\n", + " Args:\n", + " state (array[complex]): array representing a quantum state vector\n", + "\n", + " Returns:\n", + " dm: (array[complex]): array representing the density matrix\n", + " \"\"\"\n", + " return state * np.conj(state).T\n", + "\n", + "\n", + "label_0 = [[1], [0]]\n", + "label_1 = [[0], [1]]\n", + "state_labels = np.array([label_0, label_1], requires_grad=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V7G5KnMrwup-" + }, + "source": [ + "Simple classifier with data reloading and fidelity loss\n", + "=======================================================\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "Qa4S7lBSwup-" + }, + "outputs": [], + "source": [ + "dev = qml.device(\"lightning.qubit\", wires=1)\n", + "# Install any pennylane-plugin to run on some particular backend\n", + "\n", + "\n", + "@qml.qnode(dev, interface=\"autograd\")\n", + "def qcircuit(params, x, y):\n", + " \"\"\"A variational quantum circuit representing the Universal classifier.\n", + "\n", + " Args:\n", + " params (array[float]): array of parameters\n", + " x (array[float]): single input vector\n", + " y (array[float]): single output state density matrix\n", + "\n", + " Returns:\n", + " float: fidelity between output state and input\n", + " \"\"\"\n", + " for p in params:\n", + " qml.Rot(*x, wires=0)\n", + " qml.Rot(*p, wires=0)\n", + " return qml.expval(qml.Hermitian(y, wires=[0]))\n", + "\n", + "\n", + "def cost(params, x, y, state_labels=None):\n", + " \"\"\"Cost function to be minimized.\n", + "\n", + " Args:\n", + " params (array[float]): array of parameters\n", + " x (array[float]): 2-d array of input vectors\n", + " y (array[float]): 1-d array of targets\n", + " state_labels (array[float]): array of state representations for labels\n", + "\n", + " Returns:\n", + " float: loss value to be minimized\n", + " \"\"\"\n", + " # Compute prediction for each input in data batch\n", + " loss = 0.0\n", + " dm_labels = [density_matrix(s) for s in state_labels]\n", + " for i in range(len(x)):\n", + " f = qcircuit(params, x[i], dm_labels[y[i]])\n", + " loss = loss + (1 - f) ** 2\n", + " return loss / len(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aFRr7XOQwup_" + }, + "source": [ + "Utility functions for testing and creating batches\n", + "==================================================\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "pvQPJp9Xwup_" + }, + "outputs": [], + "source": [ + "def test(params, x, y, state_labels=None):\n", + " \"\"\"\n", + " Tests on a given set of data.\n", + "\n", + " Args:\n", + " params (array[float]): array of parameters\n", + " x (array[float]): 2-d array of input vectors\n", + " y (array[float]): 1-d array of targets\n", + " state_labels (array[float]): 1-d array of state representations for labels\n", + "\n", + " Returns:\n", + " predicted (array([int]): predicted labels for test data\n", + " output_states (array[float]): output quantum states from the circuit\n", + " \"\"\"\n", + " fidelity_values = []\n", + " dm_labels = [density_matrix(s) for s in state_labels]\n", + " predicted = []\n", + "\n", + " for i in range(len(x)):\n", + " fidel_function = lambda y: qcircuit(params, x[i], y)\n", + " fidelities = [fidel_function(dm) for dm in dm_labels]\n", + " best_fidel = np.argmax(fidelities)\n", + "\n", + " predicted.append(best_fidel)\n", + " fidelity_values.append(fidelities)\n", + "\n", + " return np.array(predicted), np.array(fidelity_values)\n", + "\n", + "\n", + "def accuracy_score(y_true, y_pred):\n", + " \"\"\"Accuracy score.\n", + "\n", + " Args:\n", + " y_true (array[float]): 1-d array of targets\n", + " y_predicted (array[float]): 1-d array of predictions\n", + " state_labels (array[float]): 1-d array of state representations for labels\n", + "\n", + " Returns:\n", + " score (float): the fraction of correctly classified samples\n", + " \"\"\"\n", + " score = y_true == y_pred\n", + " return score.sum() / len(y_true)\n", + "\n", + "\n", + "def iterate_minibatches(inputs, targets, batch_size):\n", + " \"\"\"\n", + " A generator for batches of the input data\n", + "\n", + " Args:\n", + " inputs (array[float]): input data\n", + " targets (array[float]): targets\n", + "\n", + " Returns:\n", + " inputs (array[float]): one batch of input data of length `batch_size`\n", + " targets (array[float]): one batch of targets of length `batch_size`\n", + " \"\"\"\n", + " for start_idx in range(0, inputs.shape[0] - batch_size + 1, batch_size):\n", + " idxs = slice(start_idx, start_idx + batch_size)\n", + " yield inputs[idxs], targets[idxs]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UXDm5DPGwuqA" + }, + "source": [ + "Train a quantum classifier on the circle dataset\n", + "================================================\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "7qWNg8VnwuqA", + "outputId": "c555dc59-d769-43bc-bf2d-f9a74c6821a4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch: 0 | Cost: 0.415535 | Train accuracy: 0.460000 | Test Accuracy: 0.448500\n", + "Epoch: 1 | Loss: 0.129385 | Train accuracy: 0.835000 | Test accuracy: 0.788500\n", + "Epoch: 2 | Loss: 0.142299 | Train accuracy: 0.810000 | Test accuracy: 0.802500\n", + "Epoch: 3 | Loss: 0.128128 | Train accuracy: 0.810000 | Test accuracy: 0.798000\n", + "Epoch: 4 | Loss: 0.112116 | Train accuracy: 0.845000 | Test accuracy: 0.809500\n", + "Epoch: 5 | Loss: 0.131754 | Train accuracy: 0.805000 | Test accuracy: 0.796500\n", + "Epoch: 6 | Loss: 0.110758 | Train accuracy: 0.870000 | Test accuracy: 0.832500\n", + "Epoch: 7 | Loss: 0.103004 | Train accuracy: 0.890000 | Test accuracy: 0.849000\n", + "Epoch: 8 | Loss: 0.114638 | Train accuracy: 0.840000 | Test accuracy: 0.816000\n", + "Epoch: 9 | Loss: 0.107868 | Train accuracy: 0.875000 | Test accuracy: 0.845000\n", + "Epoch: 10 | Loss: 0.097695 | Train accuracy: 0.930000 | Test accuracy: 0.906000\n" + ] + } + ], + "source": [ + "# Generate training and test data\n", + "num_training = 200\n", + "num_test = 2000\n", + "\n", + "Xdata, y_train = circle(num_training)\n", + "X_train = np.hstack((Xdata, np.zeros((Xdata.shape[0], 1), requires_grad=False)))\n", + "\n", + "Xtest, y_test = circle(num_test)\n", + "X_test = np.hstack((Xtest, np.zeros((Xtest.shape[0], 1), requires_grad=False)))\n", + "\n", + "\n", + "# Train using Adam optimizer and evaluate the classifier\n", + "num_layers = 3\n", + "learning_rate = 0.48\n", + "epochs = 10\n", + "batch_size = 32\n", + "\n", + "opt = AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999)\n", + "\n", + "# initialize random weights\n", + "params = np.random.uniform(size=(num_layers, 3), requires_grad=True)\n", + "\n", + "predicted_train, fidel_train = test(params, X_train, y_train, state_labels)\n", + "accuracy_train = accuracy_score(y_train, predicted_train)\n", + "\n", + "predicted_test, fidel_test = test(params, X_test, y_test, state_labels)\n", + "accuracy_test = accuracy_score(y_test, predicted_test)\n", + "\n", + "# save predictions with random weights for comparison\n", + "initial_predictions = predicted_test\n", + "\n", + "loss = cost(params, X_test, y_test, state_labels)\n", + "\n", + "print(\n", + " \"Epoch: {:2d} | Cost: {:3f} | Train accuracy: {:3f} | Test Accuracy: {:3f}\".format(\n", + " 0, loss, accuracy_train, accuracy_test\n", + " )\n", + ")\n", + "\n", + "for it in range(epochs):\n", + " for Xbatch, ybatch in iterate_minibatches(X_train, y_train, batch_size=batch_size):\n", + " params, _, _, _ = opt.step(cost, params, Xbatch, ybatch, state_labels)\n", + "\n", + " predicted_train, fidel_train = test(params, X_train, y_train, state_labels)\n", + " accuracy_train = accuracy_score(y_train, predicted_train)\n", + " loss = cost(params, X_train, y_train, state_labels)\n", + "\n", + " predicted_test, fidel_test = test(params, X_test, y_test, state_labels)\n", + " accuracy_test = accuracy_score(y_test, predicted_test)\n", + " res = [it + 1, loss, accuracy_train, accuracy_test]\n", + " print(\n", + " \"Epoch: {:2d} | Loss: {:3f} | Train accuracy: {:3f} | Test accuracy: {:3f}\".format(\n", + " *res\n", + " )\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2gr-eItywuqA" + }, + "source": [ + "Results\n", + "=======\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 399 + }, + "id": "S2h1poLxwuqB", + "outputId": "2f0ed1d7-661e-42b8-94d6-9d338c088b38" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cost: 0.097695 | Train accuracy 0.930000 | Test Accuracy : 0.906000\n", + "Learned weights\n", + "Layer 0: [-0.62681342 1.51725171 -0.03264028]\n", + "Layer 1: [1.05060607 0.3071905 0.09788492]\n", + "Layer 2: [ 2.09110374 -1.36448046 0.32099704]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x300 with 3 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "print(\n", + " \"Cost: {:3f} | Train accuracy {:3f} | Test Accuracy : {:3f}\".format(\n", + " loss, accuracy_train, accuracy_test\n", + " )\n", + ")\n", + "\n", + "print(\"Learned weights\")\n", + "for i in range(num_layers):\n", + " print(\"Layer {}: {}\".format(i, params[i]))\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(10, 3))\n", + "plot_data(X_test, initial_predictions, fig, axes[0])\n", + "plot_data(X_test, predicted_test, fig, axes[1])\n", + "plot_data(X_test, y_test, fig, axes[2])\n", + "axes[0].set_title(\"Predictions with random weights\")\n", + "axes[1].set_title(\"Predictions after training\")\n", + "axes[2].set_title(\"True test data\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e1r3N05JwuqB" + }, + "source": [ + "References\n", + "==========\n", + "\n", + "\\[1\\] Pérez-Salinas, Adrián, et al. \\\"Data re-uploading for a universal\n", + "quantum classifier.\\\" arXiv preprint arXiv:1907.02085 (2019).\n", + "\n", + "\\[2\\] Kingma, Diederik P., and Ba, J. \\\"Adam: A method for stochastic\n", + "optimization.\\\" arXiv preprint arXiv:1412.6980 (2014).\n", + "\n", + "\\[3\\] Liu, Dong C., and Nocedal, J. \\\"On the limited memory BFGS method\n", + "for large scale optimization.\\\" Mathematical programming 45.1-3 (1989):\n", + "503-528.\n", + "\n", + "About the author\n", + "================\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file