diff --git a/src/qiboml/interfaces/pytorch.py b/src/qiboml/interfaces/pytorch.py index d292ad4..a5f6867 100644 --- a/src/qiboml/interfaces/pytorch.py +++ b/src/qiboml/interfaces/pytorch.py @@ -15,7 +15,7 @@ class QuantumModel(torch.nn.Module): encoding: QuantumEncoding - circuit: Circuit + trainable_circuit: Circuit decoding: QuantumDecoding differentiation_rule: DifferentiationRule = None @@ -24,11 +24,12 @@ def __post_init__( ): super().__init__() - circuit = self.encoding.circuit - params = [p for param in self.circuit.get_parameters() for p in param] + circuit = self.encoding.circuit + self.trainable_circuit + params = [p for param in circuit.get_parameters() for p in param] params = torch.as_tensor(self.backend.to_numpy(x=params)).ravel() params.requires_grad = True - self.circuit_parameters = torch.nn.Parameter(params) + # all trainable parameters + self.trainable_parameters = torch.nn.Parameter(params) def forward(self, x: torch.Tensor): if ( @@ -39,15 +40,15 @@ def forward(self, x: torch.Tensor): x = QuantumModelAutoGrad.apply( x, self.encoding, - self.circuit, + self.trainable_circuit, self.decoding, self.backend, self.differentiation_rule, *list(self.parameters())[0], ) else: - self.circuit.set_parameters(list(self.parameters())[0]) - x = self.encoding(x) + self.circuit + x = self.encoding(x) + self.trainable_circuit + x.set_parameters(list(self.parameters())[0]) x = self.decoding(x) return x @@ -67,6 +68,10 @@ def backend( def output_shape(self): return self.decoding.output_shape + def draw(self): + circuit = self.encoding.circuit + self.trainable_circuit + circuit.draw() + class QuantumModelAutoGrad(torch.autograd.Function): diff --git a/src/qiboml/models/ansatze.py b/src/qiboml/models/ansatze.py index ce10249..54c42e5 100644 --- a/src/qiboml/models/ansatze.py +++ b/src/qiboml/models/ansatze.py @@ -1,23 +1,40 @@ import random +from typing import List, Optional import numpy as np from qibo import Circuit, gates +from qibo.config import raise_error -def ReuploadingCircuit( - nqubits: int, qubits: list[int] = None, nlayers: int = 1 -) -> Circuit: +def entangling_circuit(nqubits: int, entangling_gate: gates.Gate = gates.CNOT): + """Construct entangling layer.""" + if nqubits < 2: + raise_error(ValueError, "This layer cannot be used if nqubits is < 2.") + circuit = Circuit(nqubits) + for q in range(nqubits): + circuit.add(entangling_gate(q0=q % nqubits, q1=(q + 1) % nqubits)) + return circuit + + +def layered_ansatz( + nqubits: int, + nlayers: int = 1, + qubits: list[int] = None, + gates_list: Optional[List[gates.Gate]] = [ + gates.RY, + gates.RZ, + ], # TODO: this has to be a circuit + entanglement: bool = True, +): if qubits is None: qubits = list(range(nqubits)) circuit = Circuit(nqubits) - for _ in range(nlayers): for q in qubits: - circuit.add(gates.RY(q, theta=random.random() * np.pi, trainable=True)) - circuit.add(gates.RZ(q, theta=random.random() * np.pi, trainable=True)) - for i, q in enumerate(qubits[:-2]): - circuit.add(gates.CNOT(q0=q, q1=qubits[i + 1])) - circuit.add(gates.CNOT(q0=qubits[-1], q1=qubits[0])) + for gate in gates_list: + circuit.add(gate(q, theta=random.random(), trainable=True)) + if entanglement and nqubits > 1: + circuit += entangling_circuit(nqubits, gates.CNOT) return circuit diff --git a/src/qiboml/models/encoding.py b/src/qiboml/models/encoding.py index ff9f08d..3ee2745 100644 --- a/src/qiboml/models/encoding.py +++ b/src/qiboml/models/encoding.py @@ -6,6 +6,7 @@ from qibo.config import raise_error from qiboml import ndarray +from qiboml.models.ansatze import layered_ansatz @dataclass @@ -66,3 +67,63 @@ def __call__(self, x: ndarray) -> Circuit: for bit in ones: circuit.add(gates.X(self.qubits[bit])) return circuit + + +@dataclass +class ReuploadingEncoding(QuantumEncoding): + """ + Implementing reuploading scheme alternating encoding U and training V layers. + It follows the scheme V - U - V - U - V (in case of 2 layers), namely upload `nlayers` times x and + and each encoding layer is preceded and followed by a trainable layer V. + The chosen default V layer is a + `qiboml.models.ansatze.layered_ansatz(nqubits, 1, qubits, [RY, RZ], True)`. + """ + + # big TODO: make this model more flexible enabling e.g. lambda function of data and params + + # TODO: rm this and raise error when calling the class + data_shape: tuple = (1,) + nlayers: int = 1 + trainable_ansatz: Circuit = None + encoding_gate: gates.Gate = gates.RX + + def __post_init__( + self, + ): + + super().__post_init__() + + data_dim = np.prod(self.data_shape, axis=0) + + if int(data_dim) % len(self.qubits) != 0: + raise_error( + ValueError, + f"The data dimension has to be equal to the length of the chosen {self.qubits} subset of the {self.nqubits} system.", + ) + + # TODO: use deepcopy to repeat the call creating single elements + if self.trainable_ansatz is None: + self._circuit += layered_ansatz(nqubits=self.nqubits, qubits=self.qubits) + for _ in range(self.nlayers): + for q in self.qubits: + self._circuit.add(self.encoding_gate(q=q, theta=0.0, trainable=False)) + if self.trainable_ansatz is None: + self._circuit += layered_ansatz( + nqubits=self.nqubits, qubits=self.qubits + ) + + def _set_phases(self, x: ndarray): + encoding_gates = [ + g for g in self._circuit.parametrized_gates if g.trainable == False + ] + data_length = len(x.ravel()) + for l in range(self.nlayers): + for gate, phase in zip( + encoding_gates[data_length * l : data_length * l + data_length], + x.ravel(), + ): + gate.parameters = phase + + def __call__(self, x: ndarray) -> Circuit: + self._set_phases(x) + return self._circuit diff --git a/tutorials/model_training.ipynb b/tutorials/model_training.ipynb index 627ee5e..a286d13 100644 --- a/tutorials/model_training.ipynb +++ b/tutorials/model_training.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 21, + "execution_count": 18, "id": "d87dc7df-725c-43fb-90a7-6c6beb597cc4", "metadata": {}, "outputs": [], @@ -23,121 +23,132 @@ "# qiboml models, operations and frontends constructors\n", "from qiboml.models import encoding, ansatze, decoding\n", "from qiboml.operations.differentiation import PSR\n", - "import qiboml.models.pytorch as pytorch_frontend" + "from qiboml.interfaces import pytorch as torch_interface" ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 51, "id": "c24e27f6-af5f-47c7-bee8-d241a6e3fb97", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 57, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from importlib import reload\n", - "reload(ansatze)" + "reload(ansatze)\n", + "reload(encoding)\n", + "reload(decoding)\n", + "reload(torch_interface)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "b7746152-a261-4545-8aaa-1a4dbfbeb30d", + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(42)" ] }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 53, "id": "3bc0c85c-5672-484c-882c-492b06f7be2c", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", - "def generate_data(n, radius=0.3, center=(0.5, 0.5)):\n", - " \"\"\"Generate data in-out a circle.\"\"\"\n", - " data = np.random.rand(n, 2)\n", - " # Calculate distances from each point to the circle center\n", - " distances = np.linalg.norm(data - np.array(center), axis=1)\n", - " # Label as -1 if inside the circle, +1 if outside\n", - " labels = [-1 if dist <= radius else +1 for dist in distances]\n", - " return np.array(data), np.array(labels)\n", + "def generate_data(n, function: callable = lambda x: np.sin(x)):\n", + " \"\"\"Generate data.\"\"\"\n", + " x = np.sort(np.random.uniform(-np.pi, np.pi, n))\n", + " y = function(x) + np.random.normal(0, 0.01, n)\n", + " y = (y - np.min(y)) / (np.max(y) - np.min(y))\n", + " return np.array(x), np.array(y)\n", "\n", "\n", "def train_model(model, data, labels, epochs, nmessage=1):\n", " \"\"\"Train model using Binary Cross Entropy loss without sigmoid activation,\n", " classifying outputs based on positive and negative values.\"\"\"\n", " \n", - " optimizer = torch.optim.Adam(model.parameters(), lr=0.05)\n", - " loss_f = torch.nn.BCEWithLogitsLoss() # Use BCEWithLogitsLoss for raw model outputs\n", - " accuracies = []\n", - "\n", + " # Define the optimizer and the loss function for regression\n", + " optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n", + " loss_f = torch.nn.MSELoss() # Use MSELoss for regression\n", + " mse_losses = []\n", + " \n", " for ep in range(epochs):\n", " avg_loss = 0.0\n", - " correct_predictions = 0\n", - " total_predictions = 0\n", - "\n", + " \n", " for x, y in zip(data, labels):\n", " optimizer.zero_grad()\n", - " prediction = model(x) # Get raw model outputs\n", - "\n", - " # Convert labels from {-1, 1} to {0, 1}\n", - " binary_labels = (y + 1) / 2 # Convert -1 to 0, +1 to 1\n", - "\n", - " # Calculate loss directly from model outputs\n", - " loss = loss_f(prediction.view(-1), binary_labels.view(-1)) # BCE with logits expects raw outputs\n", + " prediction = model(x) # Get model predictions\n", + " \n", + " # Calculate MSE loss\n", + " loss = loss_f(prediction, y) \n", " \n", " # Perform backward pass and optimization step\n", " loss.backward()\n", " optimizer.step()\n", - "\n", + " \n", " avg_loss += loss.item() # Accumulate loss\n", + " \n", + " avg_loss /= len(data) # Calculate average loss for the epoch\n", + " mse_losses.append(avg_loss)\n", + " \n", + " if (ep + 1) % nmessage == 0:\n", + " print(f\"Epoch {ep + 1}: avg MSE loss: {avg_loss:.4f}\")\n", "\n", - " # Convert predictions to binary classification: +1 if >= 0, -1 if < 0\n", - " preds = torch.where(prediction >= 0, torch.tensor(1.0), torch.tensor(-1.0))\n", - " correct_predictions += (preds.view(-1) == y.view(-1)).sum().item()\n", - " total_predictions += preds.size(0) # Update total predictions based on batch size\n", + " return mse_losses\n", "\n", - " avg_loss /= len(data) # Calculate average loss\n", - " accuracy = correct_predictions / total_predictions if total_predictions > 0 else 0\n", - " accuracies.append(accuracy)\n", "\n", - " if (ep + 1) % nmessage == 0:\n", - " print(f\"Epoch {ep + 1}: avg loss: {avg_loss:.4f}, accuracy: {accuracy:.4f}\")\n" + "def predict_sample(model, data):\n", + " predictions = []\n", + " for x in data:\n", + " predictions.append(model(x).detach().numpy()[0])\n", + " return predictions" ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 54, "id": "94c2aebc-7a4f-42db-8e56-54bede994da4", "metadata": {}, "outputs": [], "source": [ - "data, labels = generate_data(50)" + "target = lambda x : np.sin(x)**2 \n", + "data, labels = generate_data(60, target)" ] }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 55, "id": "34cd8312-794d-4f0c-9b3a-7806b6da2a76", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 88, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAAFfCAYAAADNgIIEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxMklEQVR4nO3dfXSUZXo/8G8mLxMCyZCYMDFheJEXkaIQExLD7v4WatzUbrH8sZbS1mSpu60cpGp0FVyF1q7GVXHTA6xZtQtuTxFcW19OdUGaI3qsEXAgW18C2aCShDghMWQmBJIhM/P74+rkjQlkkpl5nud+vp9zcubMk2fIPczL9dz3fd3XHRcIBAIgIiJSiEXrBhAREUUagxsRESmHwY2IiJTD4EZERMphcCMiIuUwuBERkXIY3IiISDkJWjdgLPx+P1pbW5Gamoq4uDitm0NERBoIBALo7u5GTk4OLJbL980MEdxaW1vhcDi0bgYREelAc3Mzpk+fftlzDBHcUlNTAcgTSktL07g1RESkBY/HA4fDMRATLscQwS04FJmWlsbgRkRkcmOZnmJCCRERKYfBjYiIlMPgRkREymFwIyIi5TC4ERGRchjciIhIOYZYCkBEFDV+P9DYCLjdgM0GzJ0LXKH6Belf2K/g+++/j5UrVyInJwdxcXF4/fXXr/iYgwcP4sYbb4TVasXcuXOxa9eucTSViCjCjh0DKiqADRuABx6Q24oKOU6GFnZw6+npweLFi7Fjx44xnf/ll1/i+9//PlasWIG6ujrce++9+NGPfoT9+/eH3VjSMb8faGgAjhyRW79f6xYRXd6xY8BjjwFOJ5CRAcybJ7dOpxxngDO0sIclb731Vtx6661jPr+6uhqzZ8/G1q1bAQDXXXcdPvjgA/ziF79AaWlpuH+e9OjYMeCll4D6eqC3F0hOBq67DigvB/LytG4d0aX8fnnPdnTIezVY8SItTe7X1wO/+Q2weDGHKA0q6q9abW0tSkpKhh0rLS1FbW3tqI/p6+uDx+MZ9kM6xatfMqLGRglg06cPBraguDg5/vnnch4ZUtSDm8vlgt1uH3bMbrfD4/HgwoULIR9TWVkJm8028MMdAXRq5NVvWhoQHz949dvRIVe/HKIkvXG7ZZRh8uTQv09Jkd+73Vf+tzgkr0u6zJbctGkTKioqBu4HK0GTzoRz9Tt/vjZtJArFZpPh854euRgb6fx5+b3Ndvl/h0PyuhX14JadnY22trZhx9ra2pCWloZJkyaFfIzVaoXVao1202iixnL129o6tqtfoliaO1eCkNM5fM4NAAIBoKUFKCiQ80YTHJLv6JALucmTJVg6ncCpU8DmzQxwGor6sGRxcTFqamqGHTtw4ACKi4uj/acp2oZe/YYy1qtfolizWKR3lZkpvS6PB+jvl9v6ejleVjZ6MgmH5HUv7OB27tw51NXVoa6uDoCk+tfV1aGpqQmADCmWlZUNnH/XXXfhiy++wIMPPojjx4/jl7/8JV555RXcd999kXkGpJ3g1W9Li1ztDhW8+l248PJXv0RaycuT3lV+PtDZKcPnnZ3SY7tSr+tyQ/KABLnaWuDAAQY4jYQ9LPnxxx9jxYoVA/eDc2Pl5eXYtWsXvv7664FABwCzZ8/GW2+9hfvuuw//8i//gunTp+PFF1/kMgAVBK9+T50a/KCnpEiPraXlyle/RFrLy5N0/3ArlIw2JN/RIUklnZ3AuXPAli3A737HOTgNxAUCIy+59cfj8cBms8HtdnMnbj0KNam+cKEENn6gSUUNDVLNJCNjMCGlowM4ehS4cAGwWgGfD1iyRAJhZibn4CIgnFigy2xJMpjxXv0SGdXIhBRAAt6FC8DUqYMBLSdHfrgoPOYY3CgyLBam+5N5jByST0uToUirVQJbcrJ8HoLzcVwWE3O8hCBt9PcD+/fLcOb+/XKfyEiGJqR8843Msfl80mO78Ua5DQpnUThFBHtuFHsvvww89RTQ3AxcvAgkJgIOB/Dgg8CaNVq3jmjsgkPyBw5I8khwKHJkBiWXxcQce24UWy+/DNx/P3DypGSa2e1ye/KkHH/5Za1bSBQeiwW45RbgpptC98y4LEYTDG5mF8u6eP390mM7d06ublNSZOFrSorcP3cOePppDlGS8Ux0UThFHIclzSzWdfFqamQoMj09dC3K9HSgqUnO4zpIMprgHFzwM9XaKp+pggIui9EAg5tZaVEXz+WSObbR6oZarUBXl5xHFAl+f2yXqHBZjG4wuJmRVhs1ZmdL8khfnwxFjtTXJ7/Pzo7c3yTz0qpiP5fF6AIvJ8xIq40ab75ZsiLPng1di/LsWWDGDDmPaCK4ia7pMbiZUSQ3agxHQoKk+0+ZIvMR58/LuqDz5+X+lCnAT34i5xGNFyv2ExjczEnLrWrWrAG2bgXmzJG/39Ymt3PnynGuc6OJ0mpkgnSFl8hmFImNGidizRrg9tslK9Llkjm2m29mj40ig5voEhjczEkPW9UkJDDdn6Jj6MhEqMrxrBZiChyWNJvgou3+fglwN94Y/kaNRHrGTXQJ7LmZS6jU6AULgHXrgNxc7dfkxHpNEqlJDyMTpDkGN7MYbdH20aNSFWTzZm3X5mi1JonUxGohpsfgZgZaLdoeKy2qpZD6WC3E1Pgqm4GeU6OHBt4FC2ROpLNTbhcs4JokmphgtZClS+WWgc002HMzA7cbuHBBkkja24GkJOm1BQOdlqnRwcA7eTLw0UdSW7K/X7Ipp06VuUDuYExEYWJwM4PTp2V47w9/kPvBwDF/vkyua5ka7XZL7+ybb6S25OTJ8tPfL8c9Hmkj1yQRURjYR1fdsWPArl0SLPr7pcdmtUrgOHpUenJapkanpkpbenok4CYmSo8yMVHunz8vv09NjX3biMiwGNxUFpzP+uYboKhIaje63TKflZYmm4MeOgRcdZU+UqNDrUkiIhoHBjeVDU0kycqSBdtZWYDXK8N9CQny88MfapeN2N0tw44pKTLf5vVKUPZ65X5Kivy+u1ub9hGRIXHOTWUja+xlZkovze2W4BEfD5w5I0kbWrHZpF1ZWTI32NUlQ5EJCcC0aUBOjvTgWCqJVMKCBVHH4KayUDX24uJkLguQ3tukSdoGjqFFnG+6Sdrk9Q5mdB4/Ht0izkSxxoIFMcFLBZUZocZesFRSZqYEMosFSE+X+cAjR+SD/zd/w6taUgM3UY0ZfmOobGjgqK+XXlF/v9zW1+unxl6wVFJ+PvDVV8A770iiS0eHBLl/+zd+6Mn4uIlqTHFYUlXBMf1g9f9335WekV5r7OXlSZs/+0yC7vTpgN0u828sw0UqCKdSEAsWTBiDm4r0Xv0/FL9femi9vUBhof7qXxJNFDdRjSl+S6hmtDH9o0cl4CUk6LPGnp7rXxJFwtAEr1C4iWpE6ewbjibEyGP6Y7mq7e3lVS0NF9x898gRudXjezvICAleCuGwpEqG9n6AwfVswbR6PY/ph1q2MBSvamkko6XUcxPVmGJwU0mw93PhAvDpp5dW2J8zR7+9n6Hr3YbuOQcMXtVyvRsFGXUPQG6iGjMMbiqx2aSn9vHHgM93aYX9s2cBh0OfvR9e1dJY6X3z3SvhJqoxweCmkmuukZ6ZxyNlq4If+sRE+QC1tsq2Mtdco207R8OrWhoLFVLqg5uoUtQwuKnkiy8kGKSlyU4AVqsENotlcC7LapXz9PrB4lUtXQlT6mkMGNxUMjSBpKtLenCA3LfbgUWLZGhS7x96XtXS5TD5iMaAl8MqOX0aaG6W7WHsdlmwnZUlH/T+/sGMMn7oyciYUk9jwOCmCr9fSmwlJsratsREGYJMTZVkjN5e4JNP5EuBH3oyMqPUTCVN8dVXRWOj1I68/nrZxmbkxp8+H3DxIrB8OT/0ZHxDi213dsr7v7NTko/0ugyAYopzbqoITrLPmycT7Q0Nwzf+tNulJ6flxqREkcTkI7oMBjdVDJ1kH7njdlKSpEifPcv5NlILk49oFLzEUcXISfbgjtvTpklAO32ak+xEZBoMbqrgJDsR0QB+06mEk+xERADGGdx27NiBWbNmITk5GUVFRTh8+PBlz6+qqsK1116LSZMmweFw4L777kNvb++4GkxXkJcHPPsssG0b8Mwzcrt1KwMbEZlK2Akle/fuRUVFBaqrq1FUVISqqiqUlpbixIkTmDZt2iXn7969Gxs3bsSvf/1rLFu2DA0NDfjhD3+IuLg4PPvssxF5EjSCipPsfj+z4ohozOICgZFL/C+vqKgIS5cuxfbt2wEAfr8fDocDGzZswMaNGy85/+6770Z9fT1qamoGjt1///04dOgQPvjgg5B/o6+vD319fQP3PR4PHA4H3G430kKV2yG1GW3fLiKKCo/HA5vNNqZYENalr9frhdPpRElJyeA/YLGgpKQEtbW1IR+zbNkyOJ3OgaHLL774Am+//Tb+9E//dNS/U1lZCZvNNvDjcDjCaSapJLhvl9MJZGTIOr6MDLn/2GPyeyKiEcIKbh0dHfD5fLDb7cOO2+12uFyukI/5q7/6Kzz22GP49re/jcTERMyZMwfLly/Hww8/POrf2bRpE9xu98BPc3NzOM0kVYzctystTUqLBfft6uiQfbv8fq1bSkQ6E/VJi4MHD+KJJ57AL3/5Sxw9ehT/+Z//ibfeegv//M//POpjrFYr0tLShv2QCYWzbxcR0RBhJZRkZmYiPj4ebW1tw463tbUhOzs75GMeffRR3HHHHfjRj34EALj++uvR09ODv/u7v8NPf/pTWJgUQKPhvl1ENE5hRZakpCTk5+cPSw7x+/2oqalBcXFxyMecP3/+kgAWHx8PAAgzl4VG4/dLLckjR+RWlWG6oSXFQuG+XUQ0irCXAlRUVKC8vBwFBQUoLCxEVVUVenp6sHbtWgBAWVkZcnNzUVlZCQBYuXIlnn32WeTl5aGoqAiNjY149NFHsXLlyoEgRxOgciZhsKSY0ym3Q4cmg/t2FRSwpBgRXSLs4LZ69Wq0t7dj8+bNcLlcWLJkCfbt2zeQZNLU1DSsp/bII48gLi4OjzzyCE6fPo2srCysXLkSjz/+eOSehVkFMwk7OmT+afJk6eU4ncCpU8avShIsKXbq1ODcW0qK9NhaWlhSjIhGFfY6Ny2Es7bBNPx+oKJi9F5Nfb30arZuNf6Xf6je6cKFEtiMHLyJLoeFCy4RTizgljdGFU4modGrlXDfLjIblacbYoTBzajMlkmoYkkxolBUn26IEV76GhUzCYnUw8IFEcPgZlQjNycdKphJyM1JiYyFhQsihsHNqLg5KZmBqms4RzOW6YbeXnWmG6KIc25GFtycNDjx3NoqQ5EFBcwkJOMzY1LF0OmGUNmAnG4YMwY3o2MmIanIrEkVLFwQMQxuKmAmIalkZFJF8As+mFRRXy9JFYsXq3cRx8IFEcP/ISLSF7MnVQSnG/Lzgc5OeZ6dndJjU7XHGgXsuRGRvphtDWconG6YMAY3ItIXJlUITjdMCC8DiEhfuIaTIoDBjYj0hWs4KQL47iAi/WFSBU0Q59yMpr8fqKkBXC4gOxu4+WYggS8jKYhJFTQB/FY0kpdfBp56CmhuBi5eBBITAYcDePBBYM0arVtHFHlMqqBxYnAzipdfBu6/Hzh3DkhPB6xWoK8POHlSjgMMcERE/4f9eyPo75ce27lzQE6OrPOJj5fbnBw5/vTTch4RETG4GUJNjQxFpqeHrtiQng40Ncl5RETE4GYILpfMsVmtoX9vtcrvXa7YtouISKcY3IwgO1uSR/r6Qv++r09+n50d23YREekUg5sR3HyzZEWePRu6YsPZs8CMGXIeERExuBlCQoKk+0+ZIgVjz58HfD65bW2V4z/5Cde7ERH9H34bGkUwzT+4zq2rS4Yi586VwMZlAEREAxjcjGTNGuD221mhhIjoCvitaDQJCUBpqdatICLSNc65ERGRchjciIhIOQxuRESkHAY3IiJSDoMbEREph8GNiIiUw+BGRETKYXAjIiLlMLgREZFyGNyIiEg5DG5ERKQcBjciIlIOgxsRESmHwY2IiJTD4EZERMphcCMiIuUwuBERkXK4E7ce+f1AYyPgdgM2GzB3LmDhdQgR0ViN6xtzx44dmDVrFpKTk1FUVITDhw9f9vyuri6sX78eV199NaxWK+bPn4+33357XA1W3rFjQEUFsGED8MADcltRIceJiGhMwu657d27FxUVFaiurkZRURGqqqpQWlqKEydOYNq0aZec7/V6ccstt2DatGl49dVXkZubi1OnTmHq1KmRaL9ajh0DHnsM6OgApk8HJk8GenoApxM4dQrYvBnIy9O6lUREuhcXCAQC4TygqKgIS5cuxfbt2wEAfr8fDocDGzZswMaNGy85v7q6Gk8//TSOHz+OxMTEcTXS4/HAZrPB7XYjLS1tXP+G7vn90kNzOoHrrgPi4gZ/FwgA9fVAQQGwdSuHKInIlMKJBWF9S3q9XjidTpSUlAz+AxYLSkpKUFtbG/Ixb775JoqLi7F+/XrY7XYsWrQITzzxBHw+36h/p6+vDx6PZ9iP8hobJYBNnz48sAFyf/p04PPP5TwiIrqssIJbR0cHfD4f7Hb7sON2ux0ulyvkY7744gu8+uqr8Pl8ePvtt/Hoo49i69at+NnPfjbq36msrITNZhv4cTgc4TTTmNxuoLdXhiJDSUmR37vdsW0XEZEBRX18y+/3Y9q0aXj++eeRn5+P1atX46c//Smqq6tHfcymTZvgdrsHfpqbm6PdTO3ZbEByssyxhXL+vPzeZottu4iIDCishJLMzEzEx8ejra1t2PG2tjZkZ2eHfMzVV1+NxMRExMfHDxy77rrr4HK54PV6kZSUdMljrFYrrFZrOE0zvrlzZa5ttDm3lhaZc5s7V7s2EhEZRFg9t6SkJOTn56OmpmbgmN/vR01NDYqLi0M+5lvf+hYaGxvh9/sHjjU0NODqq68OGdhMy2IBysuBzEyZe/N4gP5+ua2vl+NlZUwmISIag7C/KSsqKvDCCy/gpZdeQn19PdatW4eenh6sXbsWAFBWVoZNmzYNnL9u3Tp0dnbinnvuQUNDA9566y088cQTWL9+feSehSry8iTdPz8f6OyU5JHOTumxcRkAEdGYhb3ObfXq1Whvb8fmzZvhcrmwZMkS7Nu3byDJpKmpCZYhvQuHw4H9+/fjvvvuww033IDc3Fzcc889eOihhyL3LFSSlwcsXswKJUREExD2OjctmGKdG0UXS5oRGV44sYC1JUl9x44BL70kc5e9vZJ1et11MsfJoV4iJTG4kdpY0ozMgqMTwzC4kbr8fumxdXQMX16Rlib36+uB3/xG5jhN/CVACuDoxCX4iSZ1saQZmUFwdMLpBDIygHnz5NbplOMm3VGEwY3UxZJmpLqRoxNpaUB8/ODoREeHjE4MWWdsFgxupC6WNCPVcXRiVAxupK5gSbOWFilhNlSwpNnChSxpRsbF0YlRMbiRuljSjFTH0YlR8VNNamNJM1IZRydGxaUApD6WNCNVBUcnTp0anHtLSZEeW0uLqUcnWH6LzIeLXUk1oda5LVwogU2h0QmW3yIaDRe7koo4OnEJBjcyD5biIpVZLMD8+Vq3QjfMG9bJXLjYlchUGNzIHLjYlchUGNzIHLjYlchUGNzIHLjYlchUGNzIHLjYlchUGNzIHFiKi8hU+Ekm82ApLiLT4Do3MhcudiUyBQY3Mh8udiVSHi9XiYhIOey5aYkFfImIooLBTSss4EtEFDUMblpgAV8ioqjiGFissYAvEVHUMbjFGgv4EhFFHYNbrLGALxFR1DG4xRoL+BIRRR2DW6yxgC8RUdQxuMUaC/gSEUUdv0G1wAK+RERRxXVuWmEBXyKiqGFw0xIL+BIRRQW7CUREpBwGNyIiUg6DGxERKYfBjYiIlMPgRkREymG2JBFFFjfhJR1gcCOiyOEmvKQTDG5EFBnchJd0hGMFRDRx3ISXdIbBjYgmjpvwks6MK7jt2LEDs2bNQnJyMoqKinD48OExPW7Pnj2Ii4vDqlWrxvNniUivuAkv6UzYwW3v3r2oqKjAli1bcPToUSxevBilpaU4c+bMZR/31Vdf4YEHHsB3vvOdcTeWiHSKm/CSzoQd3J599ln8+Mc/xtq1a7Fw4UJUV1cjJSUFv/71r0d9jM/nw1//9V/jn/7pn3DNNddMqMFEpEPchJd0Jqzg5vV64XQ6UVJSMvgPWCwoKSlBbW3tqI977LHHMG3aNNx5551j+jt9fX3weDzDfohIx7gJL+lMWO+0jo4O+Hw+2O32YcftdjtcLlfIx3zwwQf413/9V7zwwgtj/juVlZWw2WwDPw6HI5xmEpEWFi+WADd9OtDcDPzhD9yElzQT1XVu3d3duOOOO/DCCy8gMzNzzI/btGkTKioqBu57PB4GOCI9G7p4+8IFOZaTA/zlXwK33cYeG8VcWMEtMzMT8fHxaGtrG3a8ra0N2dnZl5x/8uRJfPXVV1i5cuXAMf//rXNJSEjAiRMnMGfOnEseZ7VaYbVaw2kaEWlltMXbLS0S8GbOZK+NYi6sy6mkpCTk5+ejpqZm4Jjf70dNTQ2Ki4svOX/BggX45JNPUFdXN/Bz2223YcWKFairq2NvjMjouHibdCrsYcmKigqUl5ejoKAAhYWFqKqqQk9PD9auXQsAKCsrQ25uLiorK5GcnIxFixYNe/zUqVMB4JLjRGRA4Szenj9fmzaSKYUd3FavXo329nZs3rwZLpcLS5Yswb59+waSTJqammDh+DqROYxl8XZrKxdv640Jdm6ICwRGLkrRH4/HA5vNBrfbjbS0NK2bQ0RBDQ3Ahg1ARoYMRY7k8UjG5LZt7LnphYF3bggnFqgVqokotrh421iCyT9Op1yQzJsnt06nHD92TOsWRgyDGxFNzPLlkkRy9KgMc3Hxtj6ZLPmH+7kR0fgMHd7q7pYvx/Z2CWiZmbJ4u6xM90NdpmGy5B8GNyIK39C1bbm5cvWfkQF8/TUwZQqwbh0Xb+uNyZJ/GNyIKDxDh7eysoDPPgO6umQ4Mj4eOHsW+O1vJbiRfgzduSFUMoZiOzfwsoqIwhMc3po8WXpw7e1AUpJ8YVqtgNcLHDgAvPmm1i2loUyW/MPgRkThcbulfmRLi9ympEhvrr9fglxGBtDXB7zyijLJCUow2c4NHJYkovDYbBK0XC7g4kXg3Dm5b7FIcJs8WQJeU5MyyQnKyMuTHRqCiUCtrTIUqWDyD4NbtJigAgCZ1Ny5EsDcbiAhQQJaQoIMbfX2ytxNbq683xVJTlBKXp5sT6T49xODWzQYuAIA0ZgkJsptICA/cXHD53F8PqWSE5RjsSjfo2Zwi7TRtv9wOoFTp7hpIxlfY6MkjeTkyPvc55O5G4sFmDRJftxu+b0iyQlkPGr1Q7VmsgoAZFJutySM5OXJUoCUFEkiycoCpk4dXBJQUqLcUBcZB995kRROBQAiowqul5o0CcjPB7Kz5f3d2ys9OptNahYWFmrdUjIxDktGkskqAJBJBddLOZ1yW1ws72mvV+biWluBpUs5JEmaYs8tkoZWAAhFsQoAZFIj10t1d0vJreRkKb+VlaXUeikyJr77IslkFQDIxILrpfLzZb+2xka5LShg0hTpAoclIyl4RXvq1ODcW0qK9NhaWpSrAEAm5vfL8PuaNVJXcupUID1dyfVSZEwMbpFmogoAZFKXW8fJwEY6weAWDSapAEAmxHWc6lKsqhKDW7SYoAIAmczIdZzB5S7BdZz19bKOc/FiQ38pmpKCVZX4DiSiseE6TjUFe+NOpyzGnzdPbp1OOX7smNYtHBcGt0jy+4GGBuDIEbllJRJSyVjWcfb2ch2nkShcVYnDkpGiYLeeaBiT7eRsCuH0xg02zcKeWyQo2q0nGobrONWjcG+cwW2iFO7WEw1jsp2cTUHhqkp8F04UJ9nJTFiZRC0K98Y55zZRLJZMZsN1nOpQuKoSg9tEcZKdzIjrONWhaFUlBreJGrn9x9ChyWC3vqDAkN16IjIJBXvjDG4TpXC3nohMRLHeOL9xI4GT7EREusKeW6Qo2K0nIjIqBrdIUqxbT0RkVOxWEBGRchjciIhIOQxuRESkHAY3IiJSDhNKiIgoNL/fsBngDG5ERHQpg+9RyeBGRETDBfeo7OiQqkuTJ0v9XKdTqjEZoDiFMfqXREQUG4rsUcngRkREgxTZo5LBjYiIBo1lj8reXt3vUcngRkREg4buURmKQfaoZHAjIqJBwT0qW1pkT8qhgntULlyo+z0qGdyIiGhQcI/KzEyZe/N4gP5+ua2vN8weleNq3Y4dOzBr1iwkJyejqKgIhw8fHvXcF154Ad/5zneQnp6O9PR0lJSUXPZ8IiLSmAJ7VIa9zm3v3r2oqKhAdXU1ioqKUFVVhdLSUpw4cQLTpk275PyDBw9izZo1WLZsGZKTk/Hzn/8c3/ve9/DZZ58hNzc3Ik+CiIgizOB7VMYFAiMHVS+vqKgIS5cuxfbt2wEAfr8fDocDGzZswMaNG6/4eJ/Ph/T0dGzfvh1lZWUhz+nr60NfX9/AfY/HA4fDAbfbjbS0tHCaS0REivB4PLDZbGOKBWGFYK/XC6fTiZKSksF/wGJBSUkJamtrx/RvnD9/HhcvXkRGRsao51RWVsJmsw38OByOcJpJREQmF1Zw6+jogM/ng91uH3bcbrfD5XKN6d946KGHkJOTMyxAjrRp0ya43e6Bn+bm5nCaSUREJhfT2pJPPvkk9uzZg4MHDyI5OXnU86xWK6xWawxbRkREKgkruGVmZiI+Ph5tbW3Djre1tSE7O/uyj33mmWfw5JNP4r//+79xww03hN9SIj0z8NYgRCoKK7glJSUhPz8fNTU1WLVqFQBJKKmpqcHdd9896uOeeuopPP7449i/fz8KCgom1GAi3TH41iBEKgp7WLKiogLl5eUoKChAYWEhqqqq0NPTg7Vr1wIAysrKkJubi8rKSgDAz3/+c2zevBm7d+/GrFmzBubmpkyZgilTpkTwqRBpQIGtQYhUFHZwW716Ndrb27F582a4XC4sWbIE+/btG0gyaWpqgmXIcMxzzz0Hr9eLH/zgB8P+nS1btuAf//EfJ9Z6Ii2N3BokWEE9uDVIfb1sDbJ4MYcoiWIs7HVuWghnbQNRzDQ0ABs2ABkZEtBG8nikqsO2bcD8+bFvH5FiorbOjYiGUGRrECIVMbgRjddoW4MEAkBXF9DcDPh8QGqqJs0jMjMGN6LxCrU1SEcHUFsL/M//AIcOSYB77jlJPCGimInpIm4ipQS3Bjl1SpJHJk+W2/Pn5ffp6cCCBcDRo0BTEzMniWKIPbex8vslgeDIEbn1+7VuEelBcGuQG2+UwNbVBVitQHa2bBcyc6b07jo6JHOS7xuimGDPbSy4SJcuJy8PmDRJ1rYtWCA9trS0waUBcXGyBu7zz6WKCTMnyegMUJGHwe1KuEiXxqK7G4iPBxwOuR0pJQVobWXmJBmfQS729RVq9aa/H6iqAr78EsjJkay3+PjBRbocaqKg0TIng86fl9/bbLFtF1EkBS/2nU5Z3zlvntw6nXJcR4lTDG6jOXYMuPNO4K23gNOngQ8/lCy4jg75/cihJjK3UJmTQYGAHF+4UM4jMqKRFXnS0nR9sc/gFkrw6uT3v5dx5PR0SRLo6JDMt2CA4yJdCgpmTmZmynCNxyM9f49H7mdmAmVlupuXIBqzxkZ5L0+fPjifHKTDi31+0kYaenUyf74ENZ8PSEwEpk6VYNbQIFfjHGqioYKZk/n5UnarsVFuCwo4N0vGZ7CKPEwoGWno1UlqqgS09nYJbnFx8sJ2dckL2NoqX1wcaqKgvDwplKzzTDKisA2dVw5V11FnF/v8xI009OokLk56b5MmSUDzeuVLqrcXOHGCQ00UmsUi75ulS+WW7w9SgcHmlfmpG2lk1ltmpizQzcqS4NbVJS/kkiUcaiIi8zDYvDKHJUcKXp04nYN7dGVmAlddJYGtoUEC24svAgn87yMiEwnOKwfXubW2SmegoEACm44u9vntPNLIeoHTp8tE6fnzwNdfA7NnA/fcw8BGROZkkHllblY6mlCr8Bcu1N3VCRGR5mJUjiucWMDux1AjX6BnngG++ELXVydERJrSaTkuBregy71AS5dq3ToiIv3Rce1ddkMAQ9VLIyLSBZ2X42Jw0/kLRESkSzovx8XgpvMXiIhIl3RejovBTecvEBGRLg0teBEIyDrgM2cGC11oXI6LCSXBF+jcObnv9QJJSYM7KeusXhoRkS4EC168955UKunqktuEBKnJm5AALF+uWTkuBre5c6X6yHvvSTDz+QZfnHnzpGgyiyMTEQ1nsQBFRcArr0jnID1dis339Umm5JQpQGGhZsunOCz5+99L5ZHeXnlRJk2SHQBcLgl4CQm6qpdGRKQLfj9w6BBgtwMzZsj97m65nTFDjh8+rFkynrl7bsFMyf5+4LvfBf7wh8GutdUq48Y5OVJqhkgVMaomQYoLJuMtWCA9No9n+LROd/dgMt78+TFvnrmD29BMybQ0KZDsdg++QHFxshRAoxeHKOJ0Wk2CDGjk9mAj8xJSUqSwskbJeOYObiMzJePiZK4tqL9fhiyZKUkq0HE1CTIgnW9eau6xiJF7t43ETElSBYsVUKTpfPNScwc3nb84pBi/X/YDPHJEbmMZSFisgCJN55uXmntY8nJ7t7W0aP7ikEK0nusaS7ECDedHyKB0vHmpuYMboOsXhxShh7kunc+PkIFdbvNSDTNzzRvcuHcbxcLIua7gkGBwrqu+Xua6Fi+O7vstOATvdA5vBzA4BM9iBTReFsulGeUaj1aYM7hx7zaKlXDmuqK53IRD8BRLOhitMN87mXu3USzpqTB3cAg+Px/o7JSA2tkpPTYuA6BIGTlakZoqC7p7e4Grr5aShjHIzDVXz00vQ0RkHnqb67rc/AhRJAwdrfjmG8kMPntWyhtaLHJB198f9dEKc72jmQ5NsRbr5SZjWW4QnB9ZulRuGdgokoKjFRcuAEePSpJed7dcyHk8cv/3v5eCy1Fkrp4b06Ep1mI516X1cgMiQEYDrNbBtW9e7+BuK4mJ0mvr7QWefx649VYZJo8Cc12ysSIJaSEWc12cSya9mDtX5tba2iSQ+XxSqzc+XkbI/H7pYHR3A9u2RW3uzVw9N6ZDk1aiOdcVnEtubwdyc2VuIxDgXDJpw2IBbrkFePNNGZpMSpLjfj9w8aIEufR06WQcPx61uTdzBTemQ5OWQq0FGosrLYRtaJC9B4O9wri4wQ1358+P3XIDoqDCQnnfnTwp71+fT96zwZGx+HgZuvT5ojYNZK7gBrAiCRnLlebRjh0DNm4EPv1Uzk9MlC+NKVMkK/jcOemxxWq5AREgF2A33iidhtRUCWYWy2AvrqtLRhbS06M2DWSO4DbyynfxYuDZZ5kOTfp2pYWwf/EXwN69QF2d9NaSk+W2r0/mOjIzJajV1wMzZ3IumWLHYgH+4R+ADz6Q4fKsLLnwunhR3sNWq4ya/dEfRW0aSP3gxgwyMqIrrcn8/HPgqafkSyQhAZg0Sb44kpLki6OvTy7cpk4FzpwBios5l0yxlZ8P/OxnwCOPyJB5QoK8N9PSJLDNmhXVaaBx/as7duzArFmzkJycjKKiIhw+fPiy5//2t7/FggULkJycjOuvvx5vv/32uBobNmaQkVFdaU2mzQY0N0tQ8/sliMXHD0+77u2VVOz4eKCkhCMTFHtr1sh6tttuA+bMkSzKmTOB5cujXhUn7J7b3r17UVFRgerqahQVFaGqqgqlpaU4ceIEpk2bdsn5H374IdasWYPKykr82Z/9GXbv3o1Vq1bh6NGjWLRoUUSeREisRkJGdqU1mfHx0lOzWiWQJSTIMKTbPZgt6fPJ43NyZIKfSAv5+cDOnTGfBooLBEaWTbi8oqIiLF26FNu3bwcA+P1+OBwObNiwARs3brzk/NWrV6Onpwf/9V//NXDspptuwpIlS1BdXR3yb/T19aGvr2/gvsfjgcPhgNvtRlqoEkahNDQAGzZITy3UYzwe6Spv28YMMtKfK71/W1qAQ4eAoiKgqUnmNaZOld9dvCgB7uJF6fn9v/8HbN3KizgyPI/HA5vNNqZYENa73ev1wul0oqSkZPAfsFhQUlKC2trakI+pra0ddj4AlJaWjno+AFRWVsJmsw38OByOcJop9FSwlihcVyrb5XYDDofczpsnw5NdXRLQEhIkuCUkyDlc3kImFNY7vqOjAz6fD3a7fdhxu90Ol8sV8jEulyus8wFg06ZNcLvdAz/Nzc3hNFOwGgkZWXBNZmbmYBmj/n65ra+X7LMHH5Tb9nbg2muBq66S97XLJcPwy5cDW7YwcYpMSZfZklarFVardWL/CKuRkNGNZU3mggWDv7/qKlk35HAAq1fLJD57bGRSYQW3zMxMxMfHo62tbdjxtrY2ZGdnh3xMdnZ2WOdHDKuRkAquVLaLW9gQhRTWJyApKQn5+fmoqakZOOb3+1FTU4Pi4uKQjykuLh52PgAcOHBg1PMjipszkgqutEUNt7AhukTYw5IVFRUoLy9HQUEBCgsLUVVVhZ6eHqxduxYAUFZWhtzcXFRWVgIA7rnnHnz3u9/F1q1b8f3vfx979uzBxx9/jOeffz6yz2Q0vLIlIjKdsIPb6tWr0d7ejs2bN8PlcmHJkiXYt2/fQNJIU1MTLEMCx7Jly7B792488sgjePjhhzFv3jy8/vrr0V3jNtJ4C9YSEZEhhb3OTQvhrG0gIiI1RW2dGxERkREwuBERkXIY3IiISDkMbkREpBwGNyIiUo4uy2+NFEzo9Hg8GreEiIi0EowBY0nyN0Rw6+7uBoDx7Q5ARERK6e7uhu0KRe8Nsc7N7/ejtbUVqampiBu5K3EYgvvCNTc3K79ejs9VTXyuauJzHZtAIIDu7m7k5OQMKxYSiiF6bhaLBdOnT4/Yv5eWlqb8GyiIz1VNfK5q4nO9siv12IKYUEJERMphcCMiIuWYKrhZrVZs2bJl4huhGgCfq5r4XNXE5xp5hkgoISIiCoepem5ERGQODG5ERKQcBjciIlIOgxsRESmHwY2IiJRj2uB22223YcaMGUhOTsbVV1+NO+64A62trVo3K+K++uor3HnnnZg9ezYmTZqEOXPmYMuWLfB6vVo3LSoef/xxLFu2DCkpKZg6darWzYm4HTt2YNasWUhOTkZRUREOHz6sdZMi7v3338fKlSuRk5ODuLg4vP7661o3KWoqKyuxdOlSpKamYtq0aVi1ahVOnDihdbOi4rnnnsMNN9wwUJmkuLgYv/vd76L290wb3FasWIFXXnkFJ06cwH/8x3/g5MmT+MEPfqB1syLu+PHj8Pv9+NWvfoXPPvsMv/jFL1BdXY2HH35Y66ZFhdfrxe23345169Zp3ZSI27t3LyoqKrBlyxYcPXoUixcvRmlpKc6cOaN10yKqp6cHixcvxo4dO7RuStS99957WL9+PT766CMcOHAAFy9exPe+9z309PRo3bSImz59Op588kk4nU58/PHH+OM//mP8+Z//OT777LPo/MEABQKBQOCNN94IxMXFBbxer9ZNibqnnnoqMHv2bK2bEVU7d+4M2Gw2rZsRUYWFhYH169cP3Pf5fIGcnJxAZWWlhq2KLgCB1157TetmxMyZM2cCAALvvfee1k2JifT09MCLL74YlX/btD23oTo7O/Hv//7vWLZsGRITE7VuTtS53W5kZGRo3QwKg9frhdPpRElJycAxi8WCkpIS1NbWatgyiiS32w0Ayn8+fT4f9uzZg56eHhQXF0flb5g6uD300EOYPHkyrrrqKjQ1NeGNN97QuklR19jYiG3btuHv//7vtW4KhaGjowM+nw92u33YcbvdDpfLpVGrKJL8fj/uvfdefOtb38KiRYu0bk5UfPLJJ5gyZQqsVivuuusuvPbaa1i4cGFU/pZSwW3jxo2Ii4u77M/x48cHzv/JT36CY8eO4Z133kF8fDzKysrGtMOrHoT7XAHg9OnT+JM/+RPcfvvt+PGPf6xRy8M3nudKZDTr16/Hp59+ij179mjdlKi59tprUVdXh0OHDmHdunUoLy/H559/HpW/pVRtyfb2dnzzzTeXPeeaa65BUlLSJcdbWlrgcDjw4YcfRq2bHEnhPtfW1lYsX74cN910E3bt2nXFjf70ZDyv665du3Dvvfeiq6sryq2LDa/Xi5SUFLz66qtYtWrVwPHy8nJ0dXUpO+oQFxeH1157bdhzVtHdd9+NN954A++//z5mz56tdXNipqSkBHPmzMGvfvWriP/bhtisdKyysrKQlZU1rsf6/X4AQF9fXySbFDXhPNfTp09jxYoVyM/Px86dOw0V2ICJva6qSEpKQn5+Pmpqaga+6P1+P2pqanD33Xdr2zgat0AggA0bNuC1117DwYMHTRXYAHkPR+s7V6ngNlaHDh3CkSNH8O1vfxvp6ek4efIkHn30UcyZM8cQvbZwnD59GsuXL8fMmTPxzDPPoL29feB32dnZGrYsOpqamtDZ2Ymmpib4fD7U1dUBAObOnYspU6Zo27gJqqioQHl5OQoKClBYWIiqqir09PRg7dq1Wjctos6dO4fGxsaB+19++SXq6uqQkZGBGTNmaNiyyFu/fj12796NN954A6mpqQPzpzabDZMmTdK4dZG1adMm3HrrrZgxYwa6u7uxe/duHDx4EPv374/OH4xKDqbO/e///m9gxYoVgYyMjIDVag3MmjUrcNdddwVaWlq0blrE7dy5MwAg5I+KysvLQz7Xd999V+umRcS2bdsCM2bMCCQlJQUKCwsDH330kdZNirh333035GtYXl6uddMibrTP5s6dO7VuWsT97d/+bWDmzJmBpKSkQFZWVuDmm28OvPPOO1H7e0rNuREREQGKZUsSEREBDG5ERKQgBjciIlIOgxsRESmHwY2IiJTD4EZERMphcCMiIuUwuBERkXIY3IiISDkMbkREpBwGNyIiUs7/B6+DKJSGrqtsAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -148,13 +159,12 @@ ], "source": [ "plt.figure(figsize=(5,4))\n", - "plt.scatter(data[labels == -1].T[0], data[labels == -1].T[1], color=\"red\", alpha=0.6)\n", - "plt.scatter(data[labels == +1].T[0], data[labels == +1].T[1], color=\"blue\", alpha=0.6)" + "plt.scatter(data, labels, color=\"red\", alpha=0.6)" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 56, "id": "3b5ddbb6-971c-49d4-87b4-7f8fb61dd831", "metadata": {}, "outputs": [], @@ -165,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 57, "id": "0a1cdd92-27d6-47dd-b943-31fc6867abc5", "metadata": {}, "outputs": [ @@ -173,42 +183,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Qibo 0.2.13|INFO|2024-11-01 11:16:31]: Using pytorch backend on cpu\n" + "[Qibo 0.2.14|INFO|2024-11-06 11:17:15]: Using numpy backend on /CPU:0\n" ] } ], "source": [ "# This is quite ambiguous\n", - "qibo.set_backend(\"pytorch\")\n", - "backend = PyTorchBackend()\n", - "frontend = pytorch_frontend" + "qibo.set_backend(\"numpy\")\n", + "backend = NumpyBackend()\n", + "frontend = torch_interface" ] }, { "cell_type": "code", - "execution_count": 91, - "id": "67ac9ee6-629a-42a3-88a0-a16f228656e0", - "metadata": {}, - "outputs": [], - "source": [ - "np.random.seed(42)" - ] - }, - { - "cell_type": "code", - "execution_count": 92, + "execution_count": 58, "id": "31472918-0ae2-422b-a752-548e2fb47241", "metadata": {}, "outputs": [], "source": [ - "ndim = 2\n", - "nqubits = 2\n", - "nshots = None" + "ndim = 1\n", + "nqubits = 1\n", + "qubits = [0]\n", + "nshots = 100" ] }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 59, "id": "e7008958-55a2-49fd-9295-75a8fa455b64", "metadata": {}, "outputs": [], @@ -218,59 +219,123 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 60, "id": "ed1c000d-d458-43ca-a74f-c5655f0bb859", "metadata": {}, "outputs": [], "source": [ - "encoding_layer = encoding.PhaseEncoding(nqubits=nqubits, qubits=[0,1])\n", - "training_layer = ansatze.ReuploadingCircuit(nqubits=nqubits, qubits=[0,1], nlayers=3) \n", + "encoding_layer = encoding.ReuploadingEncoding(\n", + " nqubits = nqubits,\n", + " nlayers = 3,\n", + " qubits = qubits,\n", + " data_shape = (1,)\n", + ")\n", + "training_layer = ansatze.layered_ansatz(\n", + " nqubits = nqubits,\n", + " qubits = qubits,\n", + " entanglement=False,\n", + ") \n", "decoding_layer = decoding.Expectation(\n", " nqubits=nqubits,\n", - " qubits=[0,1],\n", + " qubits=qubits,\n", " backend=backend,\n", " observable=obs,\n", - " nshots=None,\n", + " nshots=nshots,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "fec125ff-6727-4d8e-950e-cc3c9fd19c1c", + "metadata": {}, + "outputs": [], + "source": [ + "q_model = frontend.QuantumModel(\n", + " encoding=encoding_layer, \n", + " trainable_circuit=training_layer, \n", + " decoding=decoding_layer,\n", + " differentiation_rule=PSR(),\n", ")" ] }, { "cell_type": "code", - "execution_count": 95, - "id": "48828599-9662-46af-812c-f6bb20fdaeda", + "execution_count": 62, + "id": "be62c834-4341-4a93-b473-af98ea528c19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Parameter containing:\n", + "tensor([0.5702, 0.8267, 0.0026, 0.2165, 0.7609, 0.5752, 0.1297, 0.9711, 0.7524,\n", + " 0.1197], requires_grad=True)" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q_model.trainable_parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "45ab2dfb-a826-4968-aad8-bcf7e5889d0a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "q0: ─RY─RZ─X─RY─RZ─X─RY─RZ─X─\n", - "q1: ─RY─RZ─o─RY─RZ─o─RY─RZ─o─\n" + "q0: ─RY─RZ─RX─RY─RZ─RX─RY─RZ─RX─RY─RZ─RY─RZ─\n" ] } ], "source": [ - "training_layer.draw()" + "q_model.draw()" ] }, { "cell_type": "code", - "execution_count": 96, - "id": "fec125ff-6727-4d8e-950e-cc3c9fd19c1c", + "execution_count": 64, + "id": "27412de8-ce6f-4225-ba60-21da85522ec1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "q_model = frontend.QuantumModel(\n", - " encoding=encoding_layer, \n", - " circuit=training_layer, \n", - " decoding=decoding_layer,\n", - " differentiation_rule=None,\n", - ")" + "preds = predict_sample(q_model, data)\n", + "plt.plot(data, preds, marker=\"o\", color=\"blue\", alpha=0.6)\n", + "plt.plot(data, labels, marker=\"o\", color=\"red\", alpha=0.6)" ] }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 65, "id": "47e9e5a9-1845-46bd-a749-4c1c55099ede", "metadata": {}, "outputs": [ @@ -278,18 +343,143 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1: avg loss: 0.6506, accuracy: 0.6800\n" + "Epoch 1: avg MSE loss: 0.6877\n", + "Epoch 2: avg MSE loss: 0.6068\n", + "Epoch 3: avg MSE loss: 0.5659\n", + "Epoch 4: avg MSE loss: 0.5095\n", + "Epoch 5: avg MSE loss: 0.4963\n", + "Epoch 6: avg MSE loss: 0.4478\n", + "Epoch 7: avg MSE loss: 0.4609\n", + "Epoch 8: avg MSE loss: 0.3800\n", + "Epoch 9: avg MSE loss: 0.3692\n", + "Epoch 10: avg MSE loss: 0.3422\n", + "Epoch 11: avg MSE loss: 0.3407\n", + "Epoch 12: avg MSE loss: 0.3165\n", + "Epoch 13: avg MSE loss: 0.2834\n", + "Epoch 14: avg MSE loss: 0.2834\n", + "Epoch 15: avg MSE loss: 0.2413\n", + "Epoch 16: avg MSE loss: 0.2566\n", + "Epoch 17: avg MSE loss: 0.2411\n", + "Epoch 18: avg MSE loss: 0.2181\n", + "Epoch 19: avg MSE loss: 0.2048\n", + "Epoch 20: avg MSE loss: 0.1715\n", + "Epoch 21: avg MSE loss: 0.1397\n", + "Epoch 22: avg MSE loss: 0.1321\n", + "Epoch 23: avg MSE loss: 0.1237\n", + "Epoch 24: avg MSE loss: 0.1057\n", + "Epoch 25: avg MSE loss: 0.1058\n", + "Epoch 26: avg MSE loss: 0.0902\n", + "Epoch 27: avg MSE loss: 0.0670\n", + "Epoch 28: avg MSE loss: 0.0667\n", + "Epoch 29: avg MSE loss: 0.0632\n", + "Epoch 30: avg MSE loss: 0.0603\n", + "Epoch 31: avg MSE loss: 0.0514\n", + "Epoch 32: avg MSE loss: 0.0529\n", + "Epoch 33: avg MSE loss: 0.0427\n", + "Epoch 34: avg MSE loss: 0.0387\n", + "Epoch 35: avg MSE loss: 0.0370\n", + "Epoch 36: avg MSE loss: 0.0296\n", + "Epoch 37: avg MSE loss: 0.0272\n", + "Epoch 38: avg MSE loss: 0.0285\n", + "Epoch 39: avg MSE loss: 0.0277\n", + "Epoch 40: avg MSE loss: 0.0216\n", + "Epoch 41: avg MSE loss: 0.0248\n", + "Epoch 42: avg MSE loss: 0.0164\n", + "Epoch 43: avg MSE loss: 0.0231\n", + "Epoch 44: avg MSE loss: 0.0183\n", + "Epoch 45: avg MSE loss: 0.0153\n", + "Epoch 46: avg MSE loss: 0.0175\n", + "Epoch 47: avg MSE loss: 0.0160\n", + "Epoch 48: avg MSE loss: 0.0187\n", + "Epoch 49: avg MSE loss: 0.0159\n", + "Epoch 50: avg MSE loss: 0.0136\n" ] } ], "source": [ - "losses = train_model(model=q_model, data=data, labels=labels, epochs=1, nmessage=1)" + "losses = train_model(model=q_model, data=data, labels=labels, epochs=50, nmessage=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "24a70a64-dd41-4b8a-b3ef-afff035dc4e0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, color=\"blue\", alpha=0.7)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "8d5fa4ee-3b7f-48d1-9fe6-594639fbedf6", + "metadata": {}, + "outputs": [], + "source": [ + "d = q_model(data[0])" ] }, { - "cell_type": "markdown", - "id": "05a83fd0-3151-494d-b0b0-c4a4cec21f1f", + "cell_type": "code", + "execution_count": 68, + "id": "226bc52b-6560-4551-86a7-1ecdaf58bd6a", "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "preds = predict_sample(q_model, data)\n", + "plt.plot(data, preds, marker=\"o\", color=\"blue\", alpha=0.6)\n", + "plt.plot(data, labels, marker=\"o\", color=\"red\", alpha=0.6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f34ddf60-eba3-4cdf-ae7d-124a74454abd", + "metadata": {}, + "outputs": [], "source": [] } ],