cr fixes

Author: TomerGoldfriend

algorithms/qml/qsvm/qsvm.ipynb

@@ -52,12 +52,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "## Classiq imports\n",
-    "\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
-    "\n",
-    "## svm imports for train and validate\n",
     "from sklearn.svm import SVC\n",
     "\n",
     "from classiq import *"
@@ -199,12 +195,12 @@
     "\n",
     "A feature map is a way to encode classical data into quantum.\n",
     "Here, we chose to encode the data onto the surface of the bloch sphere.\n",
-    "Behind the scenes, this can be translated to:\n",
+    "This can be defined as:\n",
     "```\n",
     "R_X(x[0] / 2)\n",
     "R_Z(x[1])\n",
     "```\n",
-    "Where `x` is the 2D input vector, and the circuit takes a single qubit per data-point. We define a quantum function that generalizes the Bloch sphere mapping to input vector of any dimension (also known as \"dense angle encoding\" in the field of Quantum Nueral Networks)."
+    "Where `x` is the 2D input vector, and the circuit takes a single qubit per data-point. This creates a state which is:  $\\cos(x[0]/4)|0\\rangle + e^{x[1]/4}\\sin(x[0]/4)|1\\rangle$ (up to a global phase). We define a quantum function that generalizes the Bloch sphere mapping to input vector of any dimension (also known as \"dense angle encoding\" in the field of Quantum Nueral Networks): each pair of entries in the vector is mapped to a Bloch sphere, in the case of odd size we apply a single RX gate on an extra qubit."
    ]
   },
   {
@@ -218,7 +214,7 @@
     "\n",
     "\n",
     "@qfunc\n",
-    "def my_bloch_feature_map(data: CArray[CReal], qba: QArray[QBit]):\n",
+    "def bloch_feature_map(data: CArray[CReal], qba: QArray[QBit]):\n",
     "    repeat(ceiling(data.len / 2), lambda i: RX(data[2 * i] / 2, qba[i]))\n",
     "    repeat(floor(data.len / 2), lambda i: RZ(data[(2 * i) + 1], qba[i]))"
    ]
@@ -256,7 +252,7 @@
    "metadata": {},
    "source": [
     "### Construct a model\n",
-    "We can now construct the QSVM model using the `my_bloch_feature_map` function, and its inverse:"
+    "We can now construct the QSVM model using the `bloch_feature_map` function, and its inverse:"
    ]
   },
   {
@@ -277,21 +273,11 @@
     "):\n",
     "\n",
     "    allocate(ceiling(data1.len / 2), qba)\n",
-    "    my_bloch_feature_map(data1, qba)\n",
-    "    invert(lambda: my_bloch_feature_map(data2, qba))\n",
+    "    bloch_feature_map(data1, qba)\n",
+    "    invert(lambda: bloch_feature_map(data2, qba))\n",
     "\n",
     "\n",
-    "QSVM_BLOCH_SHPERE = create_model(main, out_file=\"qsvm\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "d9497b62-577d-4d27-bcdb-1be89bad4546",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "write_qmod(QSVM_BLOCH_SHPERE, \"qsvm\")"
+    "QSVM_BLOCH_SHPERE_qmod = create_model(main, out_file=\"qsvm\")"
    ]
   },
   {
@@ -306,20 +292,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "c9cdefbe",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Opening: https://platform.classiq.io/circuit/2rJdx2JxqcGgCHGbmSKSaxKLZg2?version=0.64.0\n"
+      "Opening: https://platform.classiq.io/circuit/2rMZUsGqPxLANP3DjFBG3cYMIq7?version=0.65.1\n"
      ]
     }
    ],
    "source": [
-    "qprog = synthesize(QSVM_BLOCH_SHPERE)\n",
+    "qprog = synthesize(QSVM_BLOCH_SHPERE_qmod)\n",
     "show(qprog)"
    ]
   },
@@ -338,35 +324,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "id": "48f3a4bd",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def set_execution_params(data1, data2=None, train=False):\n",
+    "def get_execution_params(data1, data2=None):\n",
     "    \"\"\"\n",
     "    Generate execution parameters based on the mode (train or validate).\n",
     "\n",
     "    Parameters:\n",
     "    - data1: First dataset (used for both training and validation).\n",
-    "    - data2: Second dataset (only required for validation when train=False).\n",
-    "    - train: Boolean flag. If True, generates symmetric pairs for training.\n",
+    "    - data2: Second dataset (only required for validation).\n",
     "\n",
     "    Returns:\n",
     "    - A list of dictionaries with execution parameters.\n",
     "    \"\"\"\n",
-    "    if train:\n",
-    "        # Training mode (symmetric pairs, data2 is ignored)\n",
+    "    if data2 is None:\n",
+    "        # Training mode (symmetric pairs of data1)\n",
     "        return [\n",
     "            {\"data1\": data1[k], \"data2\": data1[j]}\n",
     "            for k in range(len(data1))\n",
     "            for j in range(k, len(data1))  # Avoid symmetric pairs\n",
     "        ]\n",
     "    else:\n",
-    "        # Validation mode\n",
-    "        assert (\n",
-    "            data2 is not None\n",
-    "        ), \"For validation, data2 must be provided explicitly or set equal to data1.\"\n",
+    "        # Prediction mode\n",
     "        return [\n",
     "            {\"data1\": data1[k], \"data2\": data2[j]}\n",
     "            for k in range(len(data1))\n",
@@ -376,7 +358,7 @@
     "\n",
     "def construct_kernel_matrix(matrix_size, res_batch, train=False):\n",
     "    \"\"\"\n",
-    "    Construct a kernel matrix from `res_batch`, depending on whether it's for training or validation.\n",
+    "    Construct a kernel matrix from `res_batch`, depending on whether it's for training or predicting.\n",
     "\n",
     "    Parameters:\n",
     "    - matrix_size: Tuple of (number of rows, number of columns) for the matrix.\n",
@@ -387,7 +369,7 @@
     "    - A kernel matrix as a NumPy array.\n",
     "    \"\"\"\n",
     "    rows, cols = matrix_size\n",
-    "    my_kernel_matrix = np.zeros((rows, cols))\n",
+    "    kernel_matrix = np.zeros((rows, cols))\n",
     "\n",
     "    num_shots = res_batch[0].num_shots\n",
     "    num_output_qubits = len(next(iter(res_batch[0].counts)))\n",
@@ -400,19 +382,19 @@
     "                value = (\n",
     "                    res_batch[count].counts.get(\"0\" * num_output_qubits, 0) / num_shots\n",
     "                )\n",
-    "                my_kernel_matrix[k, j] = value\n",
-    "                my_kernel_matrix[j, k] = value  # Use symmetry\n",
+    "                kernel_matrix[k, j] = value\n",
+    "                kernel_matrix[j, k] = value  # Use symmetry\n",
     "                count += 1\n",
     "    else:\n",
     "        # Non-symmetric matrix (validation)\n",
     "        for k in range(rows):\n",
     "            for j in range(cols):\n",
-    "                my_kernel_matrix[k, j] = (\n",
+    "                kernel_matrix[k, j] = (\n",
     "                    res_batch[count].counts.get(\"0\" * num_output_qubits, 0) / num_shots\n",
     "                )\n",
     "                count += 1\n",
     "\n",
-    "    return my_kernel_matrix\n",
+    "    return kernel_matrix\n",
     "\n",
     "\n",
     "def train_svm(es, train_data, train_labels):\n",
@@ -422,13 +404,13 @@
     "    Parameters:\n",
     "    - es: ExecutionSession object to process batch execution for kernel computation.\n",
     "    - train_data: List of data points for training.\n",
-    "    - train_labels: List of labels corresponding to the training data.\n",
+    "    - train_labels: List of binary labels corresponding to the training data.\n",
     "\n",
     "    Returns:\n",
     "    - svm_model: A trained SVM model using the precomputed kernel.\n",
     "    \"\"\"\n",
     "    train_size = len(train_data)\n",
-    "    train_execution_params = set_execution_params(train_data, train=True)\n",
+    "    train_execution_params = get_execution_params(train_data)\n",
     "    res_train_batch = es.batch_sample(train_execution_params)  # execute batch\n",
     "    # generate kernel matrix for train\n",
     "    kernel_train = construct_kernel_matrix(\n",
@@ -457,7 +439,7 @@
     "    \"\"\"\n",
     "    predict_size = len(data)\n",
     "    train_size = len(train_data)\n",
-    "    predict_execution_params = set_execution_params(data, train_data, train=False)\n",
+    "    predict_execution_params = get_execution_params(data, train_data)\n",
     "    res_predict_batch = es.batch_sample(predict_execution_params)  # execute batch\n",
     "    kernel_predict = construct_kernel_matrix(\n",
     "        matrix_size=(predict_size, train_size), res_batch=res_predict_batch, train=False\n",
@@ -479,7 +461,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "id": "2a05189f-5875-45f2-9aef-63e2e65a621c",
    "metadata": {},
    "outputs": [],
@@ -510,7 +492,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "id": "6d4b68fc",
    "metadata": {},
    "outputs": [
@@ -536,7 +518,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "id": "a0c29c77-fa68-4d74-87ae-10a40af9af31",
    "metadata": {},
    "outputs": [
@@ -566,7 +548,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "id": "00db178e-4d49-4e55-8144-ba424b3fe833",
    "metadata": {},
    "outputs": [

algorithms/qml/qsvm/qsvm.qmod

@@ -1,4 +1,4 @@
-qfunc my_bloch_feature_map(data: real[], qba: qbit[]) {
+qfunc bloch_feature_map(data: real[], qba: qbit[]) {
   repeat (i: ceiling(data.len / 2)) {
     RX(data[2 * i] / 2, qba[i]);
   }
@@ -9,8 +9,8 @@ qfunc my_bloch_feature_map(data: real[], qba: qbit[]) {
 
 qfunc main(data1: real[2], data2: real[2], output qba: qnum) {
   allocate(ceiling(data1.len / 2), qba);
-  my_bloch_feature_map(data1, qba);
+  bloch_feature_map(data1, qba);
   invert {
-    my_bloch_feature_map(data2, qba);
+    bloch_feature_map(data2, qba);
   }
 }

algorithms/qml/qsvm/qsvm.synthesis_options.json

@@ -7,28 +7,28 @@
     "machine_precision": 8,
     "custom_hardware_settings": {
       "basis_gates": [
-        "y",
-        "sxdg",
-        "z",
-        "cz",
-        "r",
-        "rz",
-        "u1",
-        "sdg",
-        "x",
-        "sx",
         "h",
-        "cx",
-        "p",
-        "tdg",
         "ry",
-        "id",
-        "cy",
+        "sxdg",
         "u2",
+        "cy",
+        "sdg",
+        "u",
+        "u1",
+        "p",
+        "cx",
+        "cz",
+        "sx",
+        "y",
         "rx",
         "t",
-        "s",
-        "u"
+        "x",
+        "tdg",
+        "z",
+        "r",
+        "rz",
+        "id",
+        "s"
       ],
       "is_symmetric_connectivity": true
     },
@@ -39,6 +39,6 @@
     "pretty_qasm": true,
     "transpilation_option": "auto optimize",
     "timeout_seconds": 300,
-    "random_seed": 3946466952
+    "random_seed": 3405390845
   }
 }

algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.ipynb

@@ -7,28 +7,28 @@
     "machine_precision": 8,
     "custom_hardware_settings": {
       "basis_gates": [
-        "cz",
-        "z",
+        "p",
+        "id",
+        "t",
+        "u1",
+        "u",
         "rx",
+        "cy",
         "x",
-        "id",
-        "sx",
+        "sdg",
         "sxdg",
         "cx",
-        "tdg",
-        "ry",
-        "sdg",
-        "t",
+        "cz",
         "u2",
         "h",
         "rz",
+        "ry",
         "r",
-        "u",
-        "cy",
-        "p",
+        "y",
+        "sx",
+        "z",
         "s",
-        "u1",
-        "y"
+        "tdg"
       ],
       "is_symmetric_connectivity": true
     },
@@ -39,6 +39,6 @@
     "pretty_qasm": true,
     "transpilation_option": "auto optimize",
     "timeout_seconds": 300,
-    "random_seed": 3890233038
+    "random_seed": 3398128133
   }
 }