qml-for-conspicuity-detection-in-production.ipynb

{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":8975319,"sourceType":"datasetVersion","datasetId":5403982},{"sourceId":8976758,"sourceType":"datasetVersion","datasetId":5405083},{"sourceId":9141894,"sourceType":"datasetVersion","datasetId":5521441}],"dockerImageVersionId":30746,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This cell is added by sphinx-gallery\n# It can be customized to whatever you like\n%matplotlib inline","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T10:26:14.497023Z","iopub.execute_input":"2024-08-09T10:26:14.497384Z","iopub.status.idle":"2024-08-09T10:26:14.503715Z","shell.execute_reply.started":"2024-08-09T10:26:14.497358Z","shell.execute_reply":"2024-08-09T10:26:14.502491Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install pennylane --upgrade","metadata":{"execution":{"iopub.status.busy":"2024-08-09T15:56:58.972840Z","iopub.execute_input":"2024-08-09T15:56:58.973316Z","iopub.status.idle":"2024-08-09T15:57:20.458550Z","shell.execute_reply.started":"2024-08-09T15:56:58.973276Z","shell.execute_reply":"2024-08-09T15:57:20.457044Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Task 1: Pennylane Codebook","metadata":{"execution":{"iopub.status.busy":"2024-08-09T10:11:25.488787Z","iopub.execute_input":"2024-08-09T10:11:25.489161Z","iopub.status.idle":"2024-08-09T10:11:25.517099Z","shell.execute_reply.started":"2024-08-09T10:11:25.489130Z","shell.execute_reply":"2024-08-09T10:11:25.515896Z"}}},{"cell_type":"code","source":"import pennylane as qml\nfrom pennylane import numpy as np","metadata":{"execution":{"iopub.status.busy":"2024-08-09T10:27:13.465772Z","iopub.execute_input":"2024-08-09T10:27:13.466184Z","iopub.status.idle":"2024-08-09T10:27:13.471451Z","shell.execute_reply.started":"2024-08-09T10:27:13.466154Z","shell.execute_reply":"2024-08-09T10:27:13.470210Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We have learned to create a simple quantum simulator in Pennylane on a single circuit.","metadata":{}},{"cell_type":"code","source":"U = np.array([[1, 1], [1, -1]]) / np.sqrt(2)\n\n\ndef initialize_state():\n    \"\"\"Prepare a qubit in state |0>.\n\n    Returns:\n        np.array[float]: the vector representation of state |0>.\n    \"\"\"\n    return np.array([1, 0])\n\n\ndef apply_u(state):\n    \"\"\"Apply a quantum operation.\"\"\"\n    return np.dot(U, state)\n\n\ndef measure_state(state, num_meas):\n    \"\"\"Measure a quantum state num_meas times.\"\"\"\n    p_alpha = np.abs(state[0]) ** 2\n    p_beta = np.abs(state[1]) ** 2\n    meas_outcome = np.random.choice([0, 1], p=[p_alpha, p_beta], size=num_meas)\n    return meas_outcome\n\n\ndef quantum_algorithm():\n    \"\"\"\n    Returns:\n        np.array[int]: the measurement results after running the algorithm 100 times\n    \"\"\"\n    # PREPARE THE STATE, APPLY U, THEN TAKE 100 MEASUREMENT SAMPLES\n    state = initialize_state()\n    state = apply_u(state)\n    meas = measure_state(state, 100)\n    return meas\n","metadata":{"execution":{"iopub.status.busy":"2024-08-09T10:27:37.469175Z","iopub.execute_input":"2024-08-09T10:27:37.469625Z","iopub.status.idle":"2024-08-09T10:27:37.479682Z","shell.execute_reply.started":"2024-08-09T10:27:37.469591Z","shell.execute_reply":"2024-08-09T10:27:37.478389Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We can construct a QNode using a decorator or a function: ","metadata":{}},{"cell_type":"code","source":"# This creates a device with three wires on which PennyLane can run computations\ndev = qml.device(\"default.qubit\", wires=3)\n\n\ndef my_circuit(theta, phi, omega):\n\n    # IMPLEMENT THE CIRCUIT BY ADDING THE GATES\n\n    # Here are two examples, so you can see the format:\n    # qml.CNOT(wires=[0, 1])\n    qml.RX(theta, wires=0)\n    qml.RY(phi, wires=1)\n    qml.RZ(omega, wires=2)\n    qml.CNOT(wires=[0, 1])\n    qml.CNOT(wires=[1, 2])\n    qml.CNOT(wires=[2, 0])\n\n\n    return qml.probs(wires=[0, 1, 2])\n\n\n# This creates a QNode, binding the function and device\nmy_qnode = qml.QNode(my_circuit, dev)\n\n# We set up some values for the input parameters\ntheta, phi, omega = 0.1, 0.2, 0.3\n\n# Now we can execute the QNode by calling it like we would a regular function\nmy_qnode(theta, phi, omega)\n\n#==========================\n\ndev = qml.device(\"default.qubit\", wires=3)\n\n# DECORATE THE FUNCTION BELOW TO TURN IT INTO A QNODE\ndev = qml.device(\"default.qubit\", wires=3)\n@qml.qnode(dev)\n\ndef my_circuit(theta, phi, omega):\n    qml.RX(theta, wires=0)\n    qml.RY(phi, wires=1)\n    qml.RZ(omega, wires=2)\n    qml.CNOT(wires=[0, 1])\n    qml.CNOT(wires=[1, 2])\n    qml.CNOT(wires=[2, 0])\n    return qml.probs(wires=[0, 1, 2])\n\n\ntheta, phi, omega = 0.1, 0.2, 0.3\n\nres = my_circuit(theta, phi, omega)\n\nprint(f\"Probabilities: {res}\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Applying unitary operations to the qubit, and also applying parameterization:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n\nU = np.array([[1, 1], [1, -1]]) / np.sqrt(2)\n\n\n@qml.qnode(dev)\ndef apply_u():\n\n    # USE QubitUnitary TO APPLY U TO THE QUBIT\n    qml.QubitUnitary(U, wires=0)\n\n    # Return the state\n    return qml.state()\n#======================\ndev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef apply_u_as_rot(phi, theta, omega):\n\n    # APPLY A ROT GATE USING THE PROVIDED INPUT PARAMETERS\n    qml.Rot(phi, theta, omega, wires=0)\n    # RETURN THE QUANTUM STATE VECTOR\n    return qml.state()\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Here we can use RZ and RX gates to act equivalent to a Hadamard gate and synthesize circuits, like this one: ![image.png](attachment:f237145e-8ce2-40a1-8185-9c6552e8be85.png)","metadata":{},"attachments":{"f237145e-8ce2-40a1-8185-9c6552e8be85.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAFUAAAAMCAYAAAATdPFlAAADrklEQVRYCe2XX0iTURTADwRRQQWbD2FIL4GWlqLBSi2mwWY+6IjGYAMlNkK0PWjgBuZDgj3bW86HJIURwibzwQdni/APM5GNTQWXo2k9+AcUFyIHxDhf+z7uvn1r1woh6MLlnnt3zrnn/nbOvXwAv98q6uvrv3R0dMR4ellZWRwAzrLbFRQUhHlsSae9vT1WWFj4irVXqVSPzGZzgteHyWQKsPYkq9XqoN1uj/J2jUbzRu7jb84rfD5f8ujoCHl6V1dXBlSj0ejnsSWdw8NDLC8vf80eID8/37SwsJBz/5GREUGnpaUlwtqTXFtb+443BtKrq6vzyH0ozS/KFs8BwBnZmtL0n4Aai8XQ5XJhMBjEk4R6n6oAAB4AgAYATgPAQyWKsrUMqH6/H5eWloSsCAQCGIlEpCw6iUyNRqO4t7eH4XAYZ2ZmhOyen5/H/v5+rkzd3NzEvr4+nJiYEPR3d3ext7cX19fXpXPwZipBdaaAPQWACwBglAFUmmZAdTgcmEgkhAC6u7txZWVFCoYX6tDQEAIA9vT04NrammTPU/6Li4uCfmdnJ4ZCIUGemprCwcFBQebJVLfbjcPDw4I+/UkEmr0ejgP1ZYqaFQCuAsB1ALiWWrsCAFqF/sTn831nN2xoaEDKUOoks785HI5vAKBn/TQ2Nn5idba3t6Wsortyf39f8kFQi4uLfay9SqV6oXSn6nQ6yY78z87OCnOr1brK2pNcVVX1no3h4OAA9Xo9EtCNjY00P6Sn1Wo/yn3I5veIG2XqsxRAe+qFJpB0JVC7DAB3FPpjFiqVXWtrqxDEzs4O2my2tICcTufX1OaSL4PBMMceiGTKVMpS+TpBLSkp8bJxqNXq53KoyWQSLRZLhj35s9lsn1l7kqurqzMeS4PBgPF4XNFHTU3NB7kP2fw2QSOo5wHgFgDc/MkR7qbGXw1p5e/1etHj8QiBjI2NCXBYMDzlL14dBJbKlrXnKX/SHx8fFx4m1laUecqfdJuamtL2Fu1pPE75s/DooaIHK1eToNK9Q/fW5OQkbm1t4cDAgHTZiwHlgkqlT2VL92lpaSkuLy+nHYwHKj2S9IeMjo4iVYu4tzjyQJ2enhYqjuIR7diRFyo9TGwjqDxNgspumk3OBTWbnbjOA1XUzTbyQM1mK67zQuUBqKTzH6oSlT9cu9TW1hbi/bxrbm6mV/MUu6dOp3Pz2pOe2Wy2sPZFRUU3jmPvcrnSvsjIV15e3hzvZy7pVVZWvmVjUJJ/AIYFv9hHXrWXAAAAAElFTkSuQmCC"}}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n#Hadamard\n# ADJUST THE VALUES OF PHI, THETA, AND OMEGA\nphi, theta, omega = np.pi/2, np.pi/2, np.pi/2\n\n@qml.qnode(dev)\ndef hadamard_with_rz_rx():\n    qml.RZ(phi, wires=0)\n    qml.RX(theta, wires=0)\n    qml.RZ(omega, wires=0)\n    return qml.state()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef convert_to_rz_rx():\n\n    # IMPLEMENT THE CIRCUIT IN THE PICTURE USING ONLY RZ AND RX\n    qml.RZ(np.pi/2,wires=0)\n    qml.RX(-np.pi/2,wires=0)\n    qml.RZ(np.pi/4,wires=0)\n\n    return qml.state()\n","metadata":{"execution":{"iopub.status.busy":"2024-08-09T10:27:45.930823Z","iopub.execute_input":"2024-08-09T10:27:45.931216Z","iopub.status.idle":"2024-08-09T10:27:45.940297Z","shell.execute_reply.started":"2024-08-09T10:27:45.931186Z","shell.execute_reply":"2024-08-09T10:27:45.938898Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Quantum circuit synthesis using universal H and T gates:","metadata":{}},{"cell_type":"markdown","source":"![image.png](attachment:cf2df825-0254-4574-990c-461bfce48939.png)","metadata":{},"attachments":{"cf2df825-0254-4574-990c-461bfce48939.png":{"image/png":"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"}}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef unitary_with_h_and_t():\n\n    # APPLY ONLY H AND T TO PRODUCE A CIRCUIT THAT EFFECTS THE GIVEN MATRIX\n    qml.Hadamard(wires=0)\n    qml.T(wires=0)\n    qml.Hadamard(wires=0)\n    qml.T(wires=0)\n    qml.T(wires=0)\n    qml.Hadamard(wires=0)\n\n    return qml.state()\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Pauli-Z, Z-Rotation, S and T gates:","metadata":{}},{"cell_type":"markdown","source":"![image.png](attachment:457e7d03-11cd-428d-a579-c9ca6a60a5c7.png)","metadata":{},"attachments":{"457e7d03-11cd-428d-a579-c9ca6a60a5c7.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"![image.png](attachment:0535a159-1b65-4732-a523-1c49c7cfc35d.png)","metadata":{},"attachments":{"0535a159-1b65-4732-a523-1c49c7cfc35d.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAABwAAAAMCAYAAABx290PAAAA9klEQVQ4Ec2UMQqDQBBF9wweRbCKh7BWEMFOG/ESlrbxAMbSwkq2EMEmhaROWmt7/SCGFRGUVReSQBam2JlhHvP/soQcHEmS7p7nvURD0zR6MO68pKrqbRxHiIZt24/zqQcdfwEMwxBpmqIoCriui7quFwW+vuEwDMiybALEcYwgCBYYk10UqBJCuKEoCuX5l+c5fN9fwVifaZrPvVlz/sIc5MJYngesqgqO40ywpmlWUFHg7rPZPhrml2VZYNK2bYuyLFdAUUmFgH3fwzAMUEqRJAl0XUfXdb8D8rzc5r664XY47/4xUJblq+i3xvqiKIp2/ZkLb4Cd+wzV2atLAAAAAElFTkSuQmCC"}}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef apply_z_to_plus():\n    \"\"\"Write a circuit that applies PauliZ to the |+> state and returns\n    the state.\n\n    Returns:\n        np.array[complex]: The state of the qubit after the operations.\n    \"\"\"\n\n    # CREATE THE |+> STATE\n    qml.Hadamard(wires=0)\n    # APPLY PAULI Z\n    qml.PauliZ(wires=0)\n    # RETURN THE STATE\n    return qml.state()\n\n\n\nprint(apply_z_to_plus())\n#=============================\ndev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef many_rotations():\n    \"\"\"Implement the circuit depicted above and return the quantum state.\n\n    Returns:\n        np.array[complex]: The state of the qubit after the operations.\n    \"\"\"\n\n    # IMPLEMENT THE CIRCUIT\n    qml.Hadamard(wires=0)\n    qml.S(wires=0)\n    qml.adjoint(qml.T)(wires=0)\n    qml.RZ(0.3, wires=0)\n    qml.adjoint(qml.S)(wires=0)\n\n    # RETURN THE STATE\n\n    return qml.state()\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Plotting RX and RY:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef apply_rx(theta, state):\n    \"\"\"Apply an RX gate with an angle of theta to a particular basis state.\n\n    Args:\n        theta (float): A rotation angle.\n        state (int): Either 0 or 1. If 1, initialize the qubit to state |1>\n            before applying other operations.\n\n    Returns:\n        np.array[complex]: The state of the qubit after the operations.\n    \"\"\"\n    if state == 1:\n        qml.PauliX(wires=0)\n\n    # APPLY RX(theta) AND RETURN THE STATE\n    qml.RX(theta, wires=0)\n\n    return qml.state()\n\n\n# Code for plotting\nangles = np.linspace(0, 4 * np.pi, 200)\noutput_states = np.array([apply_rx(t, 0) for t in angles])\n\nplot = plotter(angles, output_states)\n\n#================\n\ndev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef apply_ry(theta, state):\n    \"\"\"Apply an RY gate with an angle of theta to a particular basis state.\n\n    Args:\n        theta (float): A rotation angle.\n        state (int): Either 0 or 1. If 1, initialize the qubit to state |1>\n            before applying other operations.\n\n    Returns:\n        np.array[complex]: The state of the qubit after the operations.\n    \"\"\"\n    if state == 1:\n        qml.PauliX(wires=0)\n\n\n    # APPLY RY(theta) AND RETURN THE STATE\n    qml.RY(theta, wires=0)\n    \n    return qml.state()\n\n\n# Code for plotting\nangles = np.linspace(0, 4 * np.pi, 200)\noutput_states = np.array([apply_ry(t, 0) for t in angles])\n\nplot = plotter(angles, output_states)\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"State preparation with gates or Mottonen:","metadata":{}},{"cell_type":"code","source":"#Gates\n\ndev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef prepare_state():\n    theta = 2 * np.arccos(np.sqrt(3) / 2)\n    # APPLY OPERATIONS TO PREPARE THE TARGET STATE\n    qml.RY(theta, wires=0)\n    qml.RZ(-np.pi / 2, wires=0)\n    return qml.state()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![image.png](attachment:97770054-85b5-4b26-b05d-44c892721aa4.png)","metadata":{},"attachments":{"97770054-85b5-4b26-b05d-44c892721aa4.png":{"image/png":"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"}}},{"cell_type":"code","source":"#Mottonen State Preparation\nv = np.array([0.52889389 - 0.14956775j, 0.67262317 + 0.49545818j])\n\n# CREATE A DEVICE\ndev = qml.device(\"default.qubit\", wires=1)\n# CONSTRUCT A QNODE THAT USES qml.MottonenStatePreparation\n# TO PREPARE A QUBIT IN STATE V, AND RETURN THE STATE\n\n@qml.qnode(dev)\ndef prepare_state(state=v):\n    qml.MottonenStatePreparation(state, wires=0)\n    return qml.state()\n\n\n# This will draw the quantum circuit and allow you to inspect the output gates\nprint(prepare_state(v))\nprint()\nprint(qml.draw(prepare_state, expansion_strategy=\"device\")(v))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![image.png](attachment:9c076154-7bd8-407c-b38f-a4115f6f0db2.png)","metadata":{},"attachments":{"9c076154-7bd8-407c-b38f-a4115f6f0db2.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"Measuring a superposition:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef apply_h_and_measure(state):\n    \"\"\"Complete the function such that we apply the Hadamard gates\n    and measure in the computational basis.\n\n    Args:\n        state (int): Either 0 or 1. If 1, prepare the qubit in state |1>,\n            otherwise leave it in state 0.\n\n    Returns:\n        np.array[float]: The measurement outcome probabilities.\n    \"\"\"\n    if state == 1:\n        qml.PauliX(wires=0)\n\n    # APPLY HADAMARD AND MEASURE\n    qml.Hadamard(wires=0)\n    return qml.probs(wires=0)\n\n\nprint(apply_h_and_measure(0))\nprint(apply_h_and_measure(1))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Measurement in the Y-basis","metadata":{}},{"cell_type":"code","source":"# WRITE A QUANTUM FUNCTION THAT PREPARES (1/2)|0> + i(sqrt(3)/2)|1>\ndef prepare_psi():\n    state = np.array([1/2, 1j*np.sqrt(3)/2])\n    qml.MottonenStatePreparation(state_vector= state, wires=0)\n    \n\n\n# WRITE A QUANTUM FUNCTION THAT SENDS BOTH |0> TO |y_+> and |1> TO |y_->\ndef y_basis_rotation():\n    qml.Hadamard(wires=0)\n    qml.S(wires=0)\n\ndev = qml.device(\"default.qubit\", wires=1)\n\n\n@qml.qnode(dev)\ndef measure_in_y_basis():\n\n    # PREPARE THE STATE\n    prepare_psi()\n\n    # PERFORM THE ROTATION BACK TO COMPUTATIONAL BASIS\n    qml.adjoint(qml.S)(wires=0)\n    qml.adjoint(qml.Hadamard)(wires=0)\n\n    # RETURN THE MEASUREMENT OUTCOME PROBABILITIES\n\n    return qml.probs(wires=0) \n\n\nprint(measure_in_y_basis())\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Sampling and processing quantum measurement outcomes:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1, shots=100000)\n\n\n@qml.qnode(dev)\ndef circuit():\n    qml.RX(np.pi / 4, wires=0)\n    qml.Hadamard(wires=0)\n    qml.PauliZ(wires=0)\n\n    # RETURN THE MEASUREMENT SAMPLES OF THE CORRECT OBSERVABLE\n    return qml.sample(qml.PauliY(wires=0))\n\n\ndef compute_expval_from_samples(samples):\n    \"\"\"Compute the expectation value of an observable given a set of\n    sample outputs. You can assume that there are two possible outcomes,\n    1 and -1.\n\n    Args:\n        samples (np.array[float]): 100000 samples representing the results of\n            running the above circuit.\n\n    Returns:\n        float: the expectation value computed based on samples.\n    \"\"\"\n\n    estimated_expval = np.mean(samples)\n\n    # USE THE SAMPLES TO ESTIMATE THE EXPECTATION VALUE\n\n    return estimated_expval\n\n\nsamples = circuit()\nprint(compute_expval_from_samples(samples))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Variance of sample measurements\n\ndef variance_experiment(n_shots):\n    \"\"\"Run an experiment to determine the variance in an expectation\n    value computed with a given number of shots.\n\n    Args:\n        n_shots (int): The number of shots\n\n    Returns:\n        float: The variance in expectation value we obtain running the\n        circuit 100 times with n_shots shots each.\n    \"\"\"\n\n    # To obtain a variance, we run the circuit multiple times at each shot value.\n    n_trials = 100\n\n    # CREATE A DEVICE WITH GIVEN NUMBER OF SHOTS\n    dev = qml.device(\"default.qubit\", wires=1, shots=n_shots)\n\n    # DECORATE THE CIRCUIT BELOW TO CREATE A QNODE\n    @qml.qnode(dev)\n    def circuit():\n        qml.Hadamard(wires=0)\n        return qml.expval(qml.PauliZ(wires=0))\n\n    # RUN THE QNODE N_TRIALS TIMES AND RETURN THE VARIANCE OF THE RESULTS\n    results = np.array([circuit() for _ in range(n_trials)])\n\n    return np.var(results)\n\n\ndef variance_scaling(n_shots):\n    \"\"\"Once you have determined how the variance in expectation value scales\n    with the number of shots, complete this function to programmatically\n    represent the relationship.\n\n    Args:\n        n_shots (int): The number of shots\n\n    Returns:\n        float: The variance in expectation value we expect to see when we run\n        an experiment with n_shots shots.\n    \"\"\"\n\n    estimated_variance = 1/ n_shots\n\n    # ESTIMATE THE VARIANCE BASED ON SHOT NUMBER\n\n    return estimated_variance\n\n\n# Various numbers of shots; you can change this\nshot_vals = [10, 20, 40, 100, 200, 400, 1000, 2000, 4000]\n\n# Used to plot your results\nresults_experiment = [variance_experiment(shots) for shots in shot_vals]\nresults_scaling = [variance_scaling(shots) for shots in shot_vals]\nplot = plotter(shot_vals, results_experiment, results_scaling)\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"CNOT Operations with Bell State:","metadata":{}},{"cell_type":"markdown","source":"![image.png](attachment:d2f85dba-0337-43b3-bc99-7a4d166e7a57.png)","metadata":{},"attachments":{"d2f85dba-0337-43b3-bc99-7a4d166e7a57.png":{"image/png":"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"}}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=2)\n\n\n@qml.qnode(dev)\ndef apply_h_cnot():\n    qml.Hadamard(wires=0)\n    qml.CNOT(wires=[0,1])\n    return qml.state()\n\n\nprint(apply_h_cnot())\n\n##################\n# YOUR CODE HERE #\n##################\n\n# SET THIS AS 'separable' OR 'entangled' BASED ON YOUR OUTCOME\nstate_status = \"entangled\"\n","metadata":{"execution":{"iopub.status.busy":"2024-08-09T14:22:30.793380Z","iopub.execute_input":"2024-08-09T14:22:30.793890Z","iopub.status.idle":"2024-08-09T14:22:31.280453Z","shell.execute_reply.started":"2024-08-09T14:22:30.793852Z","shell.execute_reply":"2024-08-09T14:22:31.278419Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Controlled Rotations:","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=3)\n\n\n@qml.qnode(dev)\ndef controlled_rotations(theta, phi, omega):\n    \"\"\"Implement the circuit above and return measurement outcome probabilities.\n\n    Args:\n        theta (float): A rotation angle\n        phi (float): A rotation angle\n        omega (float): A rotation angle\n\n    Returns:\n        np.array[float]: Measurement outcome probabilities of the 3-qubit\n        computational basis states.\n    \"\"\"\n\n    qml.Hadamard(wires=0)\n    qml.CRX(theta, wires=[0,1])\n    qml.CRY(phi, wires=[1,2])\n    qml.CRZ(omega, wires=[2,0])\n\n    # APPLY THE OPERATIONS IN THE CIRCUIT AND RETURN MEASUREMENT PROBABILITIES\n\n    return qml.probs(wires=[0, 1, 2])\n\n\ntheta, phi, omega = 0.1, 0.2, 0.3\nprint(controlled_rotations(theta, phi, omega))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![image.png](attachment:13532be5-fe5d-4259-835b-6d3703b861f0.png)","metadata":{},"attachments":{"13532be5-fe5d-4259-835b-6d3703b861f0.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"CZ with built-in function and with other gates:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=2)\n\n# Prepare a two-qubit state; change up the angles if you like\nphi, theta, omega = 1.2, 2.3, 3.4\n\n\n@qml.qnode(device=dev)\ndef true_cz(phi, theta, omega):\n    prepare_states(phi, theta, omega)\n\n    # IMPLEMENT THE REGULAR CZ GATE HERE\n\n    qml.CZ(wires=[0, 1])\n\n    return qml.state()\n\n\n@qml.qnode(dev)\ndef imposter_cz(phi, theta, omega):\n    prepare_states(phi, theta, omega)\n\n    # IMPLEMENT CZ USING ONLY H AND CNOT\n    qml.Hadamard(wires=1)  # Target\n    qml.CNOT(wires=[0, 1])  \n    qml.Hadamard(wires=1) \n    return qml.state()\n\n\nprint(f\"True CZ output state {true_cz(phi, theta, omega)}\")\nprint(f\"Imposter CZ output state {imposter_cz(phi, theta, omega)}\")\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"SWAP Gate with built-in function and with CNOT gates:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=2)\n\n# Prepare a two-qubit state; change up the angles if you like\nphi, theta, omega = 1.2, 2.3, 3.4\n\n\n@qml.qnode(dev)\ndef apply_swap(phi, theta, omega):\n    prepare_states(phi, theta, omega)\n\n    # IMPLEMENT THE REGULAR SWAP GATE HERE\n    qml.SWAP(wires=[0, 1])\n\n    return qml.state()\n\n\n@qml.qnode(dev)\ndef apply_swap_with_cnots(phi, theta, omega):\n    prepare_states(phi, theta, omega)\n\n    # IMPLEMENT THE SWAP GATE USING A SEQUENCE OF CNOTS\n    qml.CNOT(wires=[0, 1])\n    qml.CNOT(wires=[1, 0])\n    qml.CNOT(wires=[0, 1])\n    \n    return qml.state()\n\n\nprint(f\"Regular SWAP state = {apply_swap(phi, theta, omega)}\")\nprint(f\"CNOT SWAP state = {apply_swap_with_cnots(phi, theta, omega)}\")\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Four qubit MCX:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=4)\n\n\n@qml.qnode(dev)\ndef four_qubit_mcx():\n    ##################\n    # Apply Hadamard gates to the control qubits\n    qml.Hadamard(wires=0)\n    qml.Hadamard(wires=1)\n    qml.Hadamard(wires=2)\n\n    # IMPLEMENT THE CIRCUIT ABOVE USING A 4-QUBIT MULTI-CONTROLLED X\n    qml.MultiControlledX(control_wires=[0, 1, 2], wires=3, control_values=\"001\")\n    return qml.state()\n\n\nprint(four_qubit_mcx())\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Four bell states implemented:","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=2)\n\n@qml.qnode(dev)\ndef prepare_psi_plus():\n    qml.Hadamard(wires=0)\n    qml.CNOT(wires=[0, 1])\n    return qml.state()\n\n@qml.qnode(dev)\ndef prepare_psi_minus():\n    qml.Hadamard(wires=0)\n    qml.CNOT(wires=[0, 1])\n    qml.PauliZ(wires=1)  \n    return qml.state()\n\n@qml.qnode(dev)\ndef prepare_phi_plus():\n    qml.Hadamard(wires=0)\n    qml.CNOT(wires=[0, 1])\n    qml.PauliX(wires=1)\n    return qml.state()\n\n@qml.qnode(dev)\ndef prepare_phi_minus():\n    qml.Hadamard(wires=0)\n    qml.CNOT(wires=[0, 1])\n    qml.PauliZ(wires=1)  \n    qml.PauliX(wires=1)  \n    return qml.state()\n\npsi_plus = prepare_psi_plus()\npsi_minus = prepare_psi_minus()\nphi_plus = prepare_phi_plus()\nphi_minus = prepare_phi_minus()\n\n# Uncomment to print results\nprint(f\"|ψ_+> = {psi_plus}\")\nprint(f\"|ψ_-> = {psi_minus}\")\nprint(f\"|ϕ_+> = {phi_plus}\")\nprint(f\"|ϕ_-> = {phi_minus}\")\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Task 2: Variational classifier\n======================\nHere, we are implementing variatonal quantum classifiers using PennyLane: we train quantum circuits from labelled data for classification of new data samples. The two examples used are inspired by\ntwo of the first papers that proposed variational circuits as supervised\nmachine learning models: [Farhi and Neven\n(2018)](https://arxiv.org/abs/1802.06002) as well as [Schuld et al.\n(2018)](https://arxiv.org/abs/1804.00633).\n","metadata":{}},{"cell_type":"markdown","source":"More precisely, the first example shows that a variational circuit can\nbe optimized to emulate the parity function\n\n$$\\begin{aligned}\nf: x \\in \\{0,1\\}^{\\otimes n} \\rightarrow y =\n\\begin{cases} 1 \\text{  if uneven number of 1's in } x \\\\ 0\n\\text{ else}. \\end{cases}\n\\end{aligned}$$\n\nIt demonstrates how to encode binary inputs into the initial state of\nthe variational circuit, which is simply a computational basis state\n(*basis encoding*). In other words, we encode classical binary data into a quantum state. For example, \nthe binary string x=0101 would be encoded into the quantum state ∣0101⟩.\n\nThe second example shows how to encode real vectors as amplitude vectors\ninto quantum states (*amplitude encoding*) and how to train a\nvariational circuit to recognize the first two classes of flowers in the\nIris dataset. Again, amplitude encoding is the process of encoding real-valued vectors into quantum states by mapping the real values to the amplitudes of the computational basis states of the quantum state, ensuring that the state is normalized.\n\n## 1. Fitting the parity function\n\n\nImports\n-------\n\nWe start by importing PennyLane, the PennyLane-provided version of\nNumPy, and an optimizer.\n","metadata":{}},{"cell_type":"code","source":"import pennylane as qml\nfrom pennylane import numpy as np\nfrom pennylane.optimize import NesterovMomentumOptimizer","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-07T11:59:06.071843Z","iopub.execute_input":"2024-08-07T11:59:06.072207Z","iopub.status.idle":"2024-08-07T11:59:06.077686Z","shell.execute_reply.started":"2024-08-07T11:59:06.072180Z","shell.execute_reply":"2024-08-07T11:59:06.076375Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Quantum and classical nodes\n\nWe then create a quantum device that will run our circuits.\n","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\")","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-07T11:59:07.501947Z","iopub.execute_input":"2024-08-07T11:59:07.502330Z","iopub.status.idle":"2024-08-07T11:59:07.508383Z","shell.execute_reply.started":"2024-08-07T11:59:07.502279Z","shell.execute_reply":"2024-08-07T11:59:07.507065Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Inspired by neuron layers from classical machine learning, variational classifiers consist of \"layers\" or \"blocks\": repeats of elementary circuit architecture that combine to form the full variational circuit.\n\nOur circuit layer will use four qubits, or wires, and consists of an\narbitrary rotation on every qubit, as well as a ring of CNOTs that\nentangles each qubit with its neighbour. Again, borrowing from machine\nlearning, we call the parameters of the layer `weights`. These adjustable parameters determine the circuit performance. Our goal here is to find the optimal parameters to minimize the cost function for classification.\n","metadata":{}},{"cell_type":"code","source":"def layer(layer_weights):\n    for wire in range(4):\n        qml.Rot(*layer_weights[wire], wires=wire)\n\n    for wires in ([0, 1], [1, 2], [2, 3], [3, 0]):\n        qml.CNOT(wires)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-07T11:59:10.097186Z","iopub.execute_input":"2024-08-07T11:59:10.097607Z","iopub.status.idle":"2024-08-07T11:59:10.103872Z","shell.execute_reply.started":"2024-08-07T11:59:10.097567Z","shell.execute_reply":"2024-08-07T11:59:10.102770Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"To make sure that the measured outputs are controlled by the inputs, we need a method to encode data inputs $x$. The process in this first example is quite simple: we have bitstrings as inputs, encoded into the state of the qubits.\nThe quantum state $\\psi$ after state preparation is a computational basis\nstate that has 1s where $x$ has 1s, for example\n\n$$x = 0101 \\rightarrow |\\psi \\rangle = |0101 \\rangle .$$\n\nThe `~pennylane.BasisState`{.interpreted-text role=\"class\"} function\nprovided by PennyLane is made to do just this. It expects `x` to be a\nlist of zeros and ones, i.e. `[0,1,0,1]`.\nWe can imagine this process as building our \"brick\".","metadata":{}},{"cell_type":"code","source":"def state_preparation(x):\n    qml.BasisState(x, wires=[0, 1, 2, 3])","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-07T11:59:13.532081Z","iopub.execute_input":"2024-08-07T11:59:13.532482Z","iopub.status.idle":"2024-08-07T11:59:13.538589Z","shell.execute_reply.started":"2024-08-07T11:59:13.532451Z","shell.execute_reply":"2024-08-07T11:59:13.537375Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Now we are ready to define our variational circuit and its building blocks as this state preparation routine, followed by repetitions of this layer structure. In other words, we utilize the function above for creating blocks, in the function below for layering blocks:","metadata":{}},{"cell_type":"code","source":"@qml.qnode(dev)\ndef circuit(weights, x):\n    state_preparation(x)\n\n    for layer_weights in weights:\n        layer(layer_weights)\n    #print(\"Circuit\")\n   \n\n    return qml.expval(qml.PauliZ(0))","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-07T12:40:10.416703Z","iopub.execute_input":"2024-08-07T12:40:10.418399Z","iopub.status.idle":"2024-08-07T12:40:10.426556Z","shell.execute_reply.started":"2024-08-07T12:40:10.418351Z","shell.execute_reply":"2024-08-07T12:40:10.425388Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We are almost ready to define our complete variational classifier function. However, we have to consider bias here just as we do for classical machine learning for better fitting. If we want to add a \"classical\" bias parameter, the variational quantum\nclassifier also needs some post-processing. We define the full model as\na sum of the output of the quantum circuit, plus the trainable bias.\n","metadata":{}},{"cell_type":"code","source":"def variational_classifier(weights, bias, x):\n    print(\"VE\",circuit(weights, x))\n    return circuit(weights, x) + bias","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-07T11:59:19.941767Z","iopub.execute_input":"2024-08-07T11:59:19.942151Z","iopub.status.idle":"2024-08-07T11:59:19.947721Z","shell.execute_reply.started":"2024-08-07T11:59:19.942121Z","shell.execute_reply":"2024-08-07T11:59:19.946503Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":" ##Cost\n \nIn supervised learning, the cost function that is used to evaluate model performance is generally the sum of a loss function and a regularizer. For simplicity, we restrict ourselves to the standard square\nloss (mean squared error) that measures the distance between target labels and model\npredictions, reducing large deviations in predictions.\n","metadata":{}},{"cell_type":"code","source":"def square_loss(labels, predictions):\n    # We use a call to qml.math.stack to allow subtracting the arrays directly\n    return np.mean((labels - qml.math.stack(predictions)) ** 2)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:04:38.611125Z","iopub.execute_input":"2024-08-09T16:04:38.611570Z","iopub.status.idle":"2024-08-09T16:04:38.617509Z","shell.execute_reply.started":"2024-08-09T16:04:38.611536Z","shell.execute_reply":"2024-08-09T16:04:38.616269Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"To monitor how many inputs the current classifier predicted correctly,\nwe also define the accuracy, or the proportion of predictions that agree\nwith a set of target labels.\n","metadata":{}},{"cell_type":"code","source":"def accuracy(labels, predictions):\n    acc = sum(abs(l - p) < 1e-5 for l, p in zip(labels, predictions))\n    acc = acc / len(labels)\n    return acc","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:04:35.851413Z","iopub.execute_input":"2024-08-09T16:04:35.851796Z","iopub.status.idle":"2024-08-09T16:04:35.858056Z","shell.execute_reply.started":"2024-08-09T16:04:35.851767Z","shell.execute_reply":"2024-08-09T16:04:35.856767Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Now we move on to defining our cost function. For learning tasks, the cost depends on the data - here the features and\nlabels considered in the iteration of the optimization routine in order to minimize this function.\n","metadata":{}},{"cell_type":"code","source":"def cost(weights, bias, X, Y):\n    predictions = [variational_classifier(weights, bias, x) for x in X]\n    return square_loss(Y, predictions)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:04:33.574737Z","iopub.execute_input":"2024-08-09T16:04:33.575116Z","iopub.status.idle":"2024-08-09T16:04:33.581452Z","shell.execute_reply.started":"2024-08-09T16:04:33.575087Z","shell.execute_reply":"2024-08-09T16:04:33.580127Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Optimization\n\nLet's now load and preprocess some data.\n\n> **_NOTE:_** The parity dataset's\n[train](https://raw.githubusercontent.com/XanaduAI/qml/master/_static/demonstration_assets/variational_classifier/data/parity_train.txt)\nand\n[test](https://raw.githubusercontent.com/XanaduAI/qml/master/_static/demonstration_assets/variational_classifier/data/parity_test.txt)\nsets can be downloaded and should be placed in the subfolder `variational_classifier/data`.\n","metadata":{}},{"cell_type":"code","source":"data = np.loadtxt(\"/kaggle/input/d/nazcet/parity/parity_train.txt\", dtype=int)\nX = np.array(data[:, :-1])\nY = np.array(data[:, -1])\nY = Y * 2 - 1  # shift label from {0, 1} to {-1, 1}\n\nfor x,y in zip(X, Y):\n    print(f\"x = {x}, y = {y}\")","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:03:02.257902Z","iopub.execute_input":"2024-08-09T16:03:02.258355Z","iopub.status.idle":"2024-08-09T16:03:02.276754Z","shell.execute_reply.started":"2024-08-09T16:03:02.258319Z","shell.execute_reply":"2024-08-09T16:03:02.275329Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We initialize the variables randomly (but fix a seed for\nreproducibility). Remember that one of the variables is used as a bias,\nwhile the rest is fed into the gates of the variational circuit.\n","metadata":{}},{"cell_type":"code","source":"np.random.seed(0)\nnum_qubits = 4\nnum_layers = 2\nweights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)\nbias_init = np.array(0.0, requires_grad=True)\n\nprint(\"Weights:\", weights_init)\nprint(\"Bias: \", bias_init)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:04:15.133464Z","iopub.execute_input":"2024-08-09T16:04:15.133873Z","iopub.status.idle":"2024-08-09T16:04:15.143598Z","shell.execute_reply.started":"2024-08-09T16:04:15.133840Z","shell.execute_reply":"2024-08-09T16:04:15.142321Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Next we create an optimizer instance and choose a batch size...\n","metadata":{}},{"cell_type":"code","source":"opt = NesterovMomentumOptimizer(0.5)\nbatch_size = 5","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:04:18.205607Z","iopub.execute_input":"2024-08-09T16:04:18.206030Z","iopub.status.idle":"2024-08-09T16:04:18.211605Z","shell.execute_reply.started":"2024-08-09T16:04:18.205997Z","shell.execute_reply":"2024-08-09T16:04:18.210282Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"...and run the optimizer to train our model. We track the accuracy - the\nshare of correctly classified data samples. For this we compute the\noutputs of the variational classifier and turn them into predictions in\n$\\{-1,1\\}$ by taking the sign of the output.\n","metadata":{}},{"cell_type":"code","source":"weights = weights_init\nbias = bias_init\nfor it in range(100):\n\n    # Update the weights by one optimizer step, using only a limited batch of data\n    batch_index = np.random.randint(0, len(X), (batch_size,))\n    X_batch = X[batch_index]\n    Y_batch = Y[batch_index]\n    weights, bias = opt.step(cost, weights, bias, X=X_batch, Y=Y_batch)\n\n    # Compute accuracy\n    predictions = [np.sign(variational_classifier(weights, bias, x)) for x in X]\n\n    current_cost = cost(weights, bias, X, Y)\n    acc = accuracy(Y, predictions)\n\n    print(f\"Iter: {it+1:4d} | Cost: {current_cost:0.7f} | Accuracy: {acc:0.7f}\")","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:04:23.952133Z","iopub.execute_input":"2024-08-09T16:04:23.952580Z","iopub.status.idle":"2024-08-09T16:04:24.216652Z","shell.execute_reply.started":"2024-08-09T16:04:23.952546Z","shell.execute_reply":"2024-08-09T16:04:24.214566Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As we can see, the variational classifier learned to classify all bit\nstrings from the training set correctly.\n\nBut unlike optimization, in machine learning the goal is to generalize\nfrom limited data to *unseen* examples. Even if the variational quantum\ncircuit was perfectly optimized with respect to the cost, it might not\ngeneralize, a phenomenon known as *overfitting*. The art of (quantum)\nmachine learning is to create models and learning procedures that tend\nto find \\\"good\\\" minima, or those that lead to models which generalize\nwell.\n\nWith this in mind, let\\'s look at a test set of examples we have not\nused during training:\n","metadata":{}},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"data = np.loadtxt(\"/kaggle/input/d/nazcet/parity/parity_test.txt\", dtype=int)\nX_test = np.array(data[:, :-1])\nY_test = np.array(data[:, -1])\nY_test = Y_test * 2 - 1  # shift label from {0, 1} to {-1, 1}\n    \npredictions_test = [np.sign(variational_classifier(weights, bias, x)) for x in X_test]\n\nfor x,y,p in zip(X_test, Y_test, predictions_test):\n    print(f\"x = {x}, y = {y}, pred={p}\")\n    \nacc_test = accuracy(Y_test, predictions_test)\nprint(\"Accuracy on unseen data:\", acc_test)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T16:03:27.690919Z","iopub.execute_input":"2024-08-09T16:03:27.691363Z","iopub.status.idle":"2024-08-09T16:03:27.769154Z","shell.execute_reply.started":"2024-08-09T16:03:27.691326Z","shell.execute_reply":"2024-08-09T16:03:27.767469Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The quantum circuit has also learnt to predict all unseen examples\nperfectly well! This is actually remarkable, since the encoding strategy\ncreates quantum states from the data that have zero overlap \\-- and\nhence the states created from the test set have no overlap with the\nstates created from the training set. There are many functional\nrelations the variational circuit could learn from this kind of\nrepresentation, but the classifier chooses to label bit strings\naccording to our ground truth, the parity function.\n\nLet\\'s look at the second example, in which we use another encoding\nstrategy.\n\n## 2. Iris classification\n\nWe now move on to classifying data points from the Iris dataset, which\nare no longer simple bitstrings but represented as real-valued vectors.\nThe vectors are 2-dimensional, but we will add some \\\"latent\ndimensions\\\" and therefore encode inputs into 2 qubits.\n\nQuantum and classical nodes\n---------------------------\n\nState preparation is not as simple as when we represent a bitstring with\na basis state. Every input x has to be translated into a set of angles\nwhich can get fed into a small routine for state preparation. To\nsimplify things a bit, we will work with data from the positive\nsubspace, so that we can ignore signs (which would require another\ncascade of rotations around the Z-axis).\n\nThe circuit is coded according to the scheme in [Möttönen, et al.\n(2004)](https://arxiv.org/abs/quant-ph/0407010), or---as presented for\npositive vectors only---in [Schuld and Petruccione\n(2018)](https://link.springer.com/book/10.1007/978-3-319-96424-9). We\nalso decomposed controlled Y-axis rotations into more basic gates,\nfollowing [Nielsen and Chuang\n(2010)](http://www.michaelnielsen.org/qcqi/).\n","metadata":{}},{"cell_type":"code","source":"def get_angles(x):\n    beta0 = 2 * np.arcsin(np.sqrt(x[1] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12))\n    beta1 = 2 * np.arcsin(np.sqrt(x[3] ** 2) / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12))\n    beta2 = 2 * np.arcsin(np.linalg.norm(x[2:]) / np.linalg.norm(x))\n\n    return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])\n\n\ndef state_preparation(a):\n    qml.RY(a[0], wires=0)\n\n    qml.CNOT(wires=[0, 1])\n    qml.RY(a[1], wires=1)\n    qml.CNOT(wires=[0, 1])\n    qml.RY(a[2], wires=1)\n\n    qml.PauliX(wires=0)\n    qml.CNOT(wires=[0, 1])\n    qml.RY(a[3], wires=1)\n    qml.CNOT(wires=[0, 1])\n    qml.RY(a[4], wires=1)\n    qml.PauliX(wires=0)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:10:40.345808Z","iopub.execute_input":"2024-08-02T15:10:40.346658Z","iopub.status.idle":"2024-08-02T15:10:40.355960Z","shell.execute_reply.started":"2024-08-02T15:10:40.346618Z","shell.execute_reply":"2024-08-02T15:10:40.354573Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Let's test if this routine actually works.\n","metadata":{}},{"cell_type":"code","source":"x = np.array([0.53896774, 0.79503606, 0.27826503, 0.0], requires_grad=False)\nang = get_angles(x)\n\n\n@qml.qnode(dev)\ndef test(angles):\n    state_preparation(angles)\n\n    return qml.state()\n\n\nstate = test(ang)\n\nprint(\"x               : \", np.round(x, 6))\nprint(\"angles          : \", np.round(ang, 6))\nprint(\"amplitude vector: \", np.round(np.real(state), 6))","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:10:43.344851Z","iopub.execute_input":"2024-08-02T15:10:43.345787Z","iopub.status.idle":"2024-08-02T15:10:43.365373Z","shell.execute_reply.started":"2024-08-02T15:10:43.345741Z","shell.execute_reply":"2024-08-02T15:10:43.363897Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The method computed the correct angles to prepare the desired state!\n\n> **_NOTE:_** \n> The `default.qubit` simulator provides a shortcut to\n> `state_preparation` with the command `qml.StatePrep(x, wires=[0, 1])`.\n> On state simulators, this just replaces the quantum state with our\n> (normalized) input. On hardware, the operation implements more\n> sophisticated versions of the routine used above.\n","metadata":{}},{"cell_type":"markdown","source":"Since we are working with only 2 qubits now, we need to update the\n`layer` function. In addition, we redefine the `cost` function to pass\nthe full batch of data to the state preparation of the circuit\nsimultaneously, a technique similar to NumPy broadcasting.\n","metadata":{}},{"cell_type":"code","source":"def layer(layer_weights):\n    for wire in range(2):\n        qml.Rot(*layer_weights[wire], wires=wire)\n    qml.CNOT(wires=[0, 1])\n\n\ndef cost(weights, bias, X, Y):\n    # Transpose the batch of input data in order to make the indexing\n    # in state_preparation work\n    predictions = variational_classifier(weights, bias, X.T)\n    return square_loss(Y, predictions)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:10:57.784973Z","iopub.execute_input":"2024-08-02T15:10:57.785919Z","iopub.status.idle":"2024-08-02T15:10:57.793439Z","shell.execute_reply.started":"2024-08-02T15:10:57.785873Z","shell.execute_reply":"2024-08-02T15:10:57.791988Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":" ## Data\n\nWe load the Iris data set. There is a bit of preprocessing to do in\norder to encode the inputs into the amplitudes of a quantum state. We\nwill augment the data points by two so-called \\\"latent dimensions\\\",\nmaking the size of the padded data point match the size of the state\nvector in the quantum device. We then need to normalize the data points,\nand finally, we translate the inputs x to rotation angles using the\n`get_angles` function we defined above.\n\nData preprocessing should always be done with the problem in mind; for\nexample, if we do not add any latent dimensions, normalization erases\nany information on the length of the vectors and classes separated by\nthis feature will not be distinguishable.\n\n> **_NOTE:_** \nThe Iris dataset can be downloaded\n`<a href=\"https://raw.githubusercontent.com/XanaduAI/qml/master/_static/demonstration_assets/variational_classifier/data/iris_classes1and2_scaled.txt\"\ndownload=parity.txt target=\"_blank\">here</a>`{.interpreted-text\nrole=\"html\"} and should be placed in the subfolder\n`variational_classifer/data`.\n","metadata":{}},{"cell_type":"code","source":"data = np.loadtxt(\"/kaggle/input/iris-vqc/iris_classes1and2_scaled.txt\")\nX = data[:, 0:2]\nprint(f\"First X sample (original)  : {X[0]}\")\n\n# pad the vectors to size 2^2=4 with constant values\npadding = np.ones((len(X), 2)) * 0.1\nX_pad = np.c_[X, padding]\nprint(f\"First X sample (padded)    : {X_pad[0]}\")\n\n# normalize each input\nnormalization = np.sqrt(np.sum(X_pad**2, -1))\nX_norm = (X_pad.T / normalization).T\nprint(f\"First X sample (normalized): {X_norm[0]}\")\n\n# the angles for state preparation are the features\nfeatures = np.array([get_angles(x) for x in X_norm], requires_grad=False)\nprint(f\"First features sample      : {features[0]}\")\n\nY = data[:, -1]","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:11:01.785056Z","iopub.execute_input":"2024-08-02T15:11:01.785432Z","iopub.status.idle":"2024-08-02T15:11:01.874743Z","shell.execute_reply.started":"2024-08-02T15:11:01.785405Z","shell.execute_reply":"2024-08-02T15:11:01.873599Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"These angles are our new features, which is why we have renamed X to\n\"features\" above. Let's plot the stages of preprocessing and play around\nwith the dimensions (dim1, dim2). Some of them still separate the\nclasses well, while others are less informative.\n","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.figure()\nplt.scatter(X[:, 0][Y == 1], X[:, 1][Y == 1], c=\"b\", marker=\"o\", ec=\"k\")\nplt.scatter(X[:, 0][Y == -1], X[:, 1][Y == -1], c=\"r\", marker=\"o\", ec=\"k\")\nplt.title(\"Original data\")\nplt.show()\n\nplt.figure()\ndim1 = 0\ndim2 = 1\nplt.scatter(X_norm[:, dim1][Y == 1], X_norm[:, dim2][Y == 1], c=\"b\", marker=\"o\", ec=\"k\")\nplt.scatter(X_norm[:, dim1][Y == -1], X_norm[:, dim2][Y == -1], c=\"r\", marker=\"o\", ec=\"k\")\nplt.title(f\"Padded and normalised data (dims {dim1} and {dim2})\")\nplt.show()\n\nplt.figure()\ndim1 = 0\ndim2 = 3\nplt.scatter(features[:, dim1][Y == 1], features[:, dim2][Y == 1], c=\"b\", marker=\"o\", ec=\"k\")\nplt.scatter(features[:, dim1][Y == -1], features[:, dim2][Y == -1], c=\"r\", marker=\"o\", ec=\"k\")\nplt.title(f\"Feature vectors (dims {dim1} and {dim2})\")\nplt.show()","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:11:05.425062Z","iopub.execute_input":"2024-08-02T15:11:05.425477Z","iopub.status.idle":"2024-08-02T15:11:06.265936Z","shell.execute_reply.started":"2024-08-02T15:11:05.425444Z","shell.execute_reply":"2024-08-02T15:11:06.264826Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This time we want to generalize from the data samples. This means that\nwe want to train our model on one set of data and test its performance\non a second set of data that has not been used in training. To monitor\nthe generalization performance, the data is split into training and\nvalidation set.\n","metadata":{}},{"cell_type":"code","source":"np.random.seed(0)\nnum_data = len(Y)\nnum_train = int(0.75 * num_data)\nindex = np.random.permutation(range(num_data))\nfeats_train = features[index[:num_train]]\nY_train = Y[index[:num_train]]\nfeats_val = features[index[num_train:]]\nY_val = Y[index[num_train:]]\n\n# We need these later for plotting\nX_train = X[index[:num_train]]\nX_val = X[index[num_train:]]","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:11:14.066058Z","iopub.execute_input":"2024-08-02T15:11:14.066489Z","iopub.status.idle":"2024-08-02T15:11:14.075013Z","shell.execute_reply.started":"2024-08-02T15:11:14.066457Z","shell.execute_reply":"2024-08-02T15:11:14.073814Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Optimization\n============\n\nFirst we initialize the variables.\n","metadata":{}},{"cell_type":"code","source":"num_qubits = 2\nnum_layers = 6\n\nweights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)\nbias_init = np.array(0.0, requires_grad=True)","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:11:19.145322Z","iopub.execute_input":"2024-08-02T15:11:19.145714Z","iopub.status.idle":"2024-08-02T15:11:19.151484Z","shell.execute_reply.started":"2024-08-02T15:11:19.145686Z","shell.execute_reply":"2024-08-02T15:11:19.150333Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Again we minimize the cost, using the imported optimizer.\n","metadata":{}},{"cell_type":"code","source":"opt = NesterovMomentumOptimizer(0.01)\nbatch_size = 5\n\n# train the variational classifier\nweights = weights_init\nbias = bias_init\nfor it in range(60):\n    # Update the weights by one optimizer step\n    batch_index = np.random.randint(0, num_train, (batch_size,))\n    feats_train_batch = feats_train[batch_index]\n    Y_train_batch = Y_train[batch_index]\n    weights, bias, _, _ = opt.step(cost, weights, bias, feats_train_batch, Y_train_batch)\n\n    # Compute predictions on train and validation set\n    predictions_train = np.sign(variational_classifier(weights, bias, feats_train.T))\n    predictions_val = np.sign(variational_classifier(weights, bias, feats_val.T))\n\n    # Compute accuracy on train and validation set\n    acc_train = accuracy(Y_train, predictions_train)\n    acc_val = accuracy(Y_val, predictions_val)\n\n    if (it + 1) % 2 == 0:\n        _cost = cost(weights, bias, features, Y)\n        print(\n            f\"Iter: {it + 1:5d} | Cost: {_cost:0.7f} | \"\n            f\"Acc train: {acc_train:0.7f} | Acc validation: {acc_val:0.7f}\"\n        )","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:11:21.855168Z","iopub.execute_input":"2024-08-02T15:11:21.856216Z","iopub.status.idle":"2024-08-02T15:11:28.474620Z","shell.execute_reply.started":"2024-08-02T15:11:21.856175Z","shell.execute_reply":"2024-08-02T15:11:28.473375Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We can plot the continuous output of the variational classifier for the\nfirst two dimensions of the Iris data set.\n","metadata":{}},{"cell_type":"code","source":"plt.figure()\ncm = plt.cm.RdBu\n\n# make data for decision regions\nxx, yy = np.meshgrid(np.linspace(0.0, 1.5, 30), np.linspace(0.0, 1.5, 30))\nX_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())]\n\n# preprocess grid points like data inputs above\npadding = 0.1 * np.ones((len(X_grid), 2))\nX_grid = np.c_[X_grid, padding]  # pad each input\nnormalization = np.sqrt(np.sum(X_grid**2, -1))\nX_grid = (X_grid.T / normalization).T  # normalize each input\nfeatures_grid = np.array([get_angles(x) for x in X_grid])  # angles are new features\npredictions_grid = variational_classifier(weights, bias, features_grid.T)\nZ = np.reshape(predictions_grid, xx.shape)\n\n# plot decision regions\nlevels = np.arange(-1, 1.1, 0.1)\ncnt = plt.contourf(xx, yy, Z, levels=levels, cmap=cm, alpha=0.8, extend=\"both\")\nplt.contour(xx, yy, Z, levels=[0.0], colors=(\"black\",), linestyles=(\"--\",), linewidths=(0.8,))\nplt.colorbar(cnt, ticks=[-1, 0, 1])\n\n# plot data\nfor color, label in zip([\"b\", \"r\"], [1, -1]):\n    plot_x = X_train[:, 0][Y_train == label]\n    plot_y = X_train[:, 1][Y_train == label]\n    plt.scatter(plot_x, plot_y, c=color, marker=\"o\", ec=\"k\", label=f\"class {label} train\")\n    plot_x = (X_val[:, 0][Y_val == label],)\n    plot_y = (X_val[:, 1][Y_val == label],)\n    plt.scatter(plot_x, plot_y, c=color, marker=\"^\", ec=\"k\", label=f\"class {label} validation\")\n\nplt.legend()\nplt.show()","metadata":{"collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-02T15:11:38.111381Z","iopub.execute_input":"2024-08-02T15:11:38.112226Z","iopub.status.idle":"2024-08-02T15:11:39.440552Z","shell.execute_reply.started":"2024-08-02T15:11:38.112188Z","shell.execute_reply":"2024-08-02T15:11:39.439376Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We find that the variational classifier learnt a separating line between\nthe datapoints of the two different classes, which allows it to classify\neven the unseen validation data with perfect accuracy.\n","metadata":{}},{"cell_type":"markdown","source":"# Task 3: Quanvolutional Neural Networks (QNNs)","metadata":{"execution":{"iopub.status.busy":"2024-08-01T23:19:24.804039Z","iopub.execute_input":"2024-08-01T23:19:24.804528Z","iopub.status.idle":"2024-08-01T23:19:24.810314Z","shell.execute_reply.started":"2024-08-01T23:19:24.804489Z","shell.execute_reply":"2024-08-01T23:19:24.809108Z"}}},{"cell_type":"markdown","source":"## Classical convolution\nThe convolutional neural network (CNN) is a standard model in classical machine learning which is particularly suitable for processing images. The model is based on the idea of a convolution layer where, instead of processing the full input data with a global function, a local convolution is applied.\n\nIf the input is an image, small local regions are sequentially processed with the same kernel. The results obtained for each region are usually associated to different channels of a single output pixel. The union of all the output pixels produces a new image-like object, which can be further processed by additional layers.","metadata":{}},{"cell_type":"markdown","source":"## Quantum convolution\nOne can extend the same idea also to the context of quantum variational circuits. A possible approach is given by the following procedure which is very similar to the one used in Ref. [1]. The scheme is also represented in the figure at the top of this tutorial.\n\nA small region of the input image, in our example a  \n2\n×\n2\n  square, is embedded into a quantum circuit. In this demo, this is achieved with parametrized rotations applied to the qubits initialized in the ground state.\n\nA quantum computation, associated to a unitary  \nU\n , is performed on the system. The unitary could be generated by a variational quantum circuit or, more simply, by a random circuit as proposed in Ref. [1].\n\nThe quantum system is finally measured, obtaining a list of classical expectation values. The measurement results could also be classically post-processed as proposed in Ref. [1] but, for simplicity, in this demo we directly use the raw expectation values.\n\nAnalogously to a classical convolution layer, each expectation value is mapped to a different channel of a single output pixel.\n\nIterating the same procedure over different regions, one can scan the full input image, producing an output object which will be structured as a multi-channel image.\n\nThe quantum convolution can be followed by further quantum layers or by classical layers.\n\nThe main difference with respect to a classical convolution is that a quantum circuit can generate highly complex kernels whose computation could be, at least in principle, classically intractable.\n\n> **_NOTE:_** In this tutorial we follow the approach of Ref. [1] in which a fixed non-trainable quantum circuit is used as a “quanvolution” kernel, while the subsequent classical layers are trained for the classification problem of interest. However, by leveraging the ability of PennyLane to evaluate gradients of quantum circuits, the quantum kernel could also be trained.","metadata":{"execution":{"iopub.status.busy":"2024-08-01T23:21:30.548353Z","iopub.execute_input":"2024-08-01T23:21:30.548780Z","iopub.status.idle":"2024-08-01T23:21:30.578072Z","shell.execute_reply.started":"2024-08-01T23:21:30.548742Z","shell.execute_reply":"2024-08-01T23:21:30.576456Z"}}},{"cell_type":"markdown","source":"This Python code requires PennyLane with the TensorFlow interface and the plotting library matplotlib.\n\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T23:22:34.593255Z","iopub.execute_input":"2024-08-01T23:22:34.593639Z","iopub.status.idle":"2024-08-01T23:22:34.601542Z","shell.execute_reply.started":"2024-08-01T23:22:34.593612Z","shell.execute_reply":"2024-08-01T23:22:34.599776Z"}}},{"cell_type":"code","source":"!pip install pennylane","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import pennylane as qml\nfrom pennylane import numpy as np\nfrom pennylane.templates import RandomLayers\nimport tensorflow as tf\nfrom tensorflow import keras\nimport matplotlib.pyplot as plt","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:11:49.105026Z","iopub.execute_input":"2024-08-02T15:11:49.105441Z","iopub.status.idle":"2024-08-02T15:12:01.885200Z","shell.execute_reply.started":"2024-08-02T15:11:49.105412Z","shell.execute_reply":"2024-08-02T15:12:01.883962Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Setting of the main hyper-parameters of the model\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T23:23:02.707083Z","iopub.execute_input":"2024-08-01T23:23:02.707484Z","iopub.status.idle":"2024-08-01T23:23:02.715905Z","shell.execute_reply.started":"2024-08-01T23:23:02.707453Z","shell.execute_reply":"2024-08-01T23:23:02.714743Z"}}},{"cell_type":"code","source":"n_epochs = 30   # Number of optimization epochs\nn_layers = 1    # Number of random layers\nn_train = 50    # Size of the train dataset\nn_test = 30     # Size of the test dataset\n\nSAVE_PATH = \"/kaggle/working/\"  # Data saving folder\nPREPROCESS = True           # If False, skip quantum processing and load data from SAVE_PATH\nnp.random.seed(0)           # Seed for NumPy random number generator\ntf.random.set_seed(0)       # Seed for TensorFlow random number generator","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:12:50.345512Z","iopub.execute_input":"2024-08-02T15:12:50.345887Z","iopub.status.idle":"2024-08-02T15:12:50.352870Z","shell.execute_reply.started":"2024-08-02T15:12:50.345858Z","shell.execute_reply":"2024-08-02T15:12:50.351631Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Loading of the MNIST dataset\nWe import the MNIST dataset from Keras. To speedup the evaluation of this demo we use only a small number of training and test images. Obviously, better results are achievable when using the full dataset.\n\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T23:23:34.242571Z","iopub.execute_input":"2024-08-01T23:23:34.242995Z","iopub.status.idle":"2024-08-01T23:23:34.248561Z","shell.execute_reply.started":"2024-08-01T23:23:34.242962Z","shell.execute_reply":"2024-08-01T23:23:34.247296Z"}}},{"cell_type":"code","source":"mnist_dataset = keras.datasets.mnist\n(train_images, train_labels), (test_images, test_labels) = mnist_dataset.load_data()\n\n# Reduce dataset size\ntrain_images = train_images[:n_train]\ntrain_labels = train_labels[:n_train]\ntest_images = test_images[:n_test]\ntest_labels = test_labels[:n_test]\n\n# Normalize pixel values within 0 and 1\ntrain_images = train_images / 255\ntest_images = test_images / 255\n\n# Add extra dimension for convolution channels\ntrain_images = np.array(train_images[..., tf.newaxis], requires_grad=False)\ntest_images = np.array(test_images[..., tf.newaxis], requires_grad=False)","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:12:53.584966Z","iopub.execute_input":"2024-08-02T15:12:53.585408Z","iopub.status.idle":"2024-08-02T15:12:54.145632Z","shell.execute_reply.started":"2024-08-02T15:12:53.585372Z","shell.execute_reply":"2024-08-02T15:12:54.144336Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Quantum circuit as a convolution kernel\n\nWe follow the scheme described in the introduction and represented in the figure at the top of this demo.\n\nWe initialize a PennyLane default.qubit device, simulating a system of  \n4\n  qubits. The associated qnode represents the quantum circuit consisting of:\n\nan embedding layer of local  \nR\ny\n  rotations (with angles scaled by a factor of  \nπ\n );\n\na random circuit of n_layers;\n\na final measurement in the computational basis, estimating  \n4\n  expectation values.","metadata":{}},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=4)\n# Random circuit parameters\nrand_params = np.random.uniform(high=2 * np.pi, size=(n_layers, 4))\n\n@qml.qnode(dev)\ndef circuit(phi):\n    # Encoding of 4 classical input values\n    for j in range(4):\n        qml.RY(np.pi * phi[j], wires=j)\n\n    # Random quantum circuit\n    RandomLayers(rand_params, wires=list(range(4)))\n\n    # Measurement producing 4 classical output values\n    return [qml.expval(qml.PauliZ(j)) for j in range(4)]","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:13:02.865306Z","iopub.execute_input":"2024-08-02T15:13:02.865669Z","iopub.status.idle":"2024-08-02T15:13:02.875285Z","shell.execute_reply.started":"2024-08-02T15:13:02.865643Z","shell.execute_reply":"2024-08-02T15:13:02.873892Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The next function defines the convolution scheme:\n\nthe image is divided into squares of  \n2\n×\n2\n  pixels;\n\neach square is processed by the quantum circuit;\n\nthe  \n4\n  expectation values are mapped into  \n4\n  different channels of a single output pixel.\n  \n\n> **_NOTE:_**  This process halves the resolution of the input image. In the standard language of CNN, this would correspond to a convolution with a  \n2\n×\n2\n  kernel and a stride equal to  \n2\n .\n\n","metadata":{}},{"cell_type":"code","source":"def quanv(image):\n    \"\"\"Convolves the input image with many applications of the same quantum circuit.\"\"\"\n    out = np.zeros((14, 14, 4))\n\n    # Loop over the coordinates of the top-left pixel of 2X2 squares\n    for j in range(0, 28, 2):\n        for k in range(0, 28, 2):\n            # Process a squared 2x2 region of the image with a quantum circuit\n            q_results = circuit(\n                [\n                    image[j, k, 0],\n                    image[j, k + 1, 0],\n                    image[j + 1, k, 0],\n                    image[j + 1, k + 1, 0]\n                ]\n            )\n            # Assign expectation values to different channels of the output pixel (j/2, k/2)\n            for c in range(4):\n                out[j // 2, k // 2, c] = q_results[c]\n    return out","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:13:12.584952Z","iopub.execute_input":"2024-08-02T15:13:12.585340Z","iopub.status.idle":"2024-08-02T15:13:12.593331Z","shell.execute_reply.started":"2024-08-02T15:13:12.585288Z","shell.execute_reply":"2024-08-02T15:13:12.591888Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Quantum pre-processing of the dataset\n\nSince we are not going to train the quantum convolution layer, it is more efficient to apply it as a “pre-processing” layer to all the images of our dataset. Later an entirely classical model will be directly trained and tested on the pre-processed dataset, avoiding unnecessary repetitions of quantum computations.\n\nThe pre-processed images will be saved in the folder SAVE_PATH. Once saved, they can be directly loaded by setting PREPROCESS = False, otherwise the quantum convolution is evaluated at each run of the code.","metadata":{"execution":{"iopub.status.busy":"2024-08-01T23:25:40.734292Z","iopub.execute_input":"2024-08-01T23:25:40.735331Z","iopub.status.idle":"2024-08-01T23:25:40.748453Z","shell.execute_reply.started":"2024-08-01T23:25:40.735286Z","shell.execute_reply":"2024-08-01T23:25:40.746900Z"}}},{"cell_type":"code","source":"if PREPROCESS == True:\n    q_train_images = []\n    print(\"Quantum pre-processing of train images:\")\n    for idx, img in enumerate(train_images):\n        print(\"{}/{}        \".format(idx + 1, n_train), end=\"\\r\")\n        q_train_images.append(quanv(img))\n    q_train_images = np.asarray(q_train_images)\n\n    q_test_images = []\n    print(\"\\nQuantum pre-processing of test images:\")\n    for idx, img in enumerate(test_images):\n        print(\"{}/{}        \".format(idx + 1, n_test), end=\"\\r\")\n        q_test_images.append(quanv(img))\n    q_test_images = np.asarray(q_test_images)\n\n    # Save pre-processed images\n    np.save(SAVE_PATH + \"q_train_images.npy\", q_train_images)\n    np.save(SAVE_PATH + \"q_test_images.npy\", q_test_images)\n\n\n# Load pre-processed images\nq_train_images = np.load(SAVE_PATH + \"q_train_images.npy\")\nq_test_images = np.load(SAVE_PATH + \"q_test_images.npy\")","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:13:15.225026Z","iopub.execute_input":"2024-08-02T15:13:15.225454Z","iopub.status.idle":"2024-08-02T15:15:12.545497Z","shell.execute_reply.started":"2024-08-02T15:13:15.225422Z","shell.execute_reply":"2024-08-02T15:15:12.544343Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Let us visualize the effect of the quantum convolution layer on a batch of samples:\n\n","metadata":{}},{"cell_type":"code","source":"n_samples = 4\nn_channels = 4\nfig, axes = plt.subplots(1 + n_channels, n_samples, figsize=(10, 10))\nfor k in range(n_samples):\n    axes[0, 0].set_ylabel(\"Input\")\n    if k != 0:\n        axes[0, k].yaxis.set_visible(False)\n    axes[0, k].imshow(train_images[k, :, :, 0], cmap=\"gray\")\n\n    # Plot all output channels\n    for c in range(n_channels):\n        axes[c + 1, 0].set_ylabel(\"Output [ch. {}]\".format(c))\n        if k != 0:\n            axes[c, k].yaxis.set_visible(False)\n        axes[c + 1, k].imshow(q_train_images[k, :, :, c], cmap=\"gray\")\n\nplt.tight_layout()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:15:16.425056Z","iopub.execute_input":"2024-08-02T15:15:16.425487Z","iopub.status.idle":"2024-08-02T15:15:18.536239Z","shell.execute_reply.started":"2024-08-02T15:15:16.425453Z","shell.execute_reply":"2024-08-02T15:15:18.535035Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Below each input image, the  \n4\n  output channels generated by the quantum convolution are visualized in gray scale.\n\nOne can clearly notice the downsampling of the resolution and some local distortion introduced by the quantum kernel. On the other hand the global shape of the image is preserved, as expected for a convolution layer.","metadata":{}},{"cell_type":"markdown","source":"## Hybrid quantum-classical model\nAfter the application of the quantum convolution layer we feed the resulting features into a classical neural network that will be trained to classify the  \n10\n  different digits of the MNIST dataset.\n\nWe use a very simple model: just a fully connected layer with 10 output nodes with a final softmax activation function.\n\nThe model is compiled with a stochastic-gradient-descent optimizer, and a cross-entropy loss function.\n\n","metadata":{}},{"cell_type":"code","source":"def MyModel():\n    \"\"\"Initializes and returns a custom Keras model\n    which is ready to be trained.\"\"\"\n    model = keras.models.Sequential([\n        keras.layers.Flatten(),\n        keras.layers.Dense(10, activation=\"softmax\")\n    ])\n\n    model.compile(\n        optimizer='adam',\n        loss=\"sparse_categorical_crossentropy\",\n        metrics=[\"accuracy\"],\n    )\n    return model","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:15:23.935365Z","iopub.execute_input":"2024-08-02T15:15:23.935775Z","iopub.status.idle":"2024-08-02T15:15:23.941551Z","shell.execute_reply.started":"2024-08-02T15:15:23.935741Z","shell.execute_reply":"2024-08-02T15:15:23.940453Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Training\nWe first initialize an instance of the model, then we train and validate it with the dataset that has been already pre-processed by a quantum convolution.","metadata":{}},{"cell_type":"code","source":"q_model = MyModel()\n\nq_history = q_model.fit(\n    q_train_images,\n    train_labels,\n    validation_data=(q_test_images, test_labels),\n    batch_size=4,\n    epochs=n_epochs,\n    verbose=2,\n)","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:15:26.704979Z","iopub.execute_input":"2024-08-02T15:15:26.705416Z","iopub.status.idle":"2024-08-02T15:15:30.143503Z","shell.execute_reply.started":"2024-08-02T15:15:26.705382Z","shell.execute_reply":"2024-08-02T15:15:30.142195Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"In order to compare the results achievable with and without the quantum convolution layer, we initialize also a “classical” instance of the model that will be directly trained and validated with the raw MNIST images (i.e., without quantum pre-processing).\n\n","metadata":{}},{"cell_type":"code","source":"c_model = MyModel()\n\nc_history = c_model.fit(\n    train_images,\n    train_labels,\n    validation_data=(test_images, test_labels),\n    batch_size=4,\n    epochs=n_epochs,\n    verbose=2,\n)","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:15:32.905252Z","iopub.execute_input":"2024-08-02T15:15:32.906345Z","iopub.status.idle":"2024-08-02T15:15:36.443067Z","shell.execute_reply.started":"2024-08-02T15:15:32.906283Z","shell.execute_reply":"2024-08-02T15:15:36.441740Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Results\n\nWe can finally plot the test accuracy and the test loss with respect to the number of training epochs.\n\n","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.style.use(\"seaborn\")\nfig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 9))\n\nax1.plot(q_history.history[\"val_accuracy\"], \"-ob\", label=\"With quantum layer\")\nax1.plot(c_history.history[\"val_accuracy\"], \"-og\", label=\"Without quantum layer\")\nax1.set_ylabel(\"Accuracy\")\nax1.set_ylim([0, 1])\nax1.set_xlabel(\"Epoch\")\nax1.legend()\n\nax2.plot(q_history.history[\"val_loss\"], \"-ob\", label=\"With quantum layer\")\nax2.plot(c_history.history[\"val_loss\"], \"-og\", label=\"Without quantum layer\")\nax2.set_ylabel(\"Loss\")\nax2.set_ylim(top=2.5)\nax2.set_xlabel(\"Epoch\")\nax2.legend()\nplt.tight_layout()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-02T15:15:38.585269Z","iopub.execute_input":"2024-08-02T15:15:38.586311Z","iopub.status.idle":"2024-08-02T15:15:39.073991Z","shell.execute_reply.started":"2024-08-02T15:15:38.586257Z","shell.execute_reply":"2024-08-02T15:15:39.072716Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Task 4: Code for Sine Function","metadata":{}},{"cell_type":"code","source":"!pip install pennylane --upgrade","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:40:05.762520Z","iopub.execute_input":"2024-08-07T20:40:05.762959Z","iopub.status.idle":"2024-08-07T20:40:18.344575Z","shell.execute_reply.started":"2024-08-07T20:40:05.762926Z","shell.execute_reply":"2024-08-07T20:40:18.343273Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import pennylane as qml\nfrom pennylane import numpy as np\nfrom pennylane.optimize import NesterovMomentumOptimizer","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:24:19.192274Z","iopub.execute_input":"2024-08-09T16:24:19.193109Z","iopub.status.idle":"2024-08-09T16:24:19.198111Z","shell.execute_reply.started":"2024-08-09T16:24:19.193071Z","shell.execute_reply":"2024-08-09T16:24:19.196918Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dev = qml.device(\"default.qubit\", wires=1)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:24:21.601007Z","iopub.execute_input":"2024-08-09T16:24:21.601424Z","iopub.status.idle":"2024-08-09T16:24:21.607868Z","shell.execute_reply.started":"2024-08-09T16:24:21.601389Z","shell.execute_reply":"2024-08-09T16:24:21.606429Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"qml.qnode(dev)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:22:30.032758Z","iopub.execute_input":"2024-08-09T16:22:30.033161Z","iopub.status.idle":"2024-08-09T16:22:30.040444Z","shell.execute_reply.started":"2024-08-09T16:22:30.033128Z","shell.execute_reply":"2024-08-09T16:22:30.039278Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def layer(layer_weights):\n    qml.Rot(*layer_weights[0], wires=0)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:24:24.800977Z","iopub.execute_input":"2024-08-09T16:24:24.801412Z","iopub.status.idle":"2024-08-09T16:24:24.807752Z","shell.execute_reply.started":"2024-08-09T16:24:24.801380Z","shell.execute_reply":"2024-08-09T16:24:24.806409Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def state_preparation(x):\n    #qml.BasisState(x, wires=[0, 1])\n    #print(x)\n    qml.templates.AngleEmbedding(features=x, wires=range(2),rotation='Y')","metadata":{"execution":{"iopub.status.busy":"2024-08-09T17:21:51.277447Z","iopub.execute_input":"2024-08-09T17:21:51.278691Z","iopub.status.idle":"2024-08-09T17:21:51.284681Z","shell.execute_reply.started":"2024-08-09T17:21:51.278624Z","shell.execute_reply":"2024-08-09T17:21:51.283276Z"},"trusted":true},"execution_count":183,"outputs":[]},{"cell_type":"code","source":"\ndef circuit(weights, x):\n    #print(\"inside circuit\")\n    state_preparation(x)\n    #print(x)\n    print(weights)\n\n    for layer_weights in weights:\n        #print(layer_weights)\n        layer(layer_weights)\n    #print(\"Circuit\")\n    #print(qml.expval(qml.PauliZ(0)))\n\n    return qml.expval(qml.PauliZ(0))","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:48:18.712172Z","iopub.execute_input":"2024-08-09T16:48:18.712877Z","iopub.status.idle":"2024-08-09T16:48:18.718871Z","shell.execute_reply.started":"2024-08-09T16:48:18.712841Z","shell.execute_reply":"2024-08-09T16:48:18.717698Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def variational_classifier(weights, bias, x):\n    #print(\"inside variational_classifier\")\n    print(\"VE\",circuit(weights, x))\n    return circuit(weights, x) + bias","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:34:12.209359Z","iopub.execute_input":"2024-08-09T16:34:12.209728Z","iopub.status.idle":"2024-08-09T16:34:12.215642Z","shell.execute_reply.started":"2024-08-09T16:34:12.209698Z","shell.execute_reply":"2024-08-09T16:34:12.214379Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def square_loss(labels, predictions):\n    #print(\"inside square_loss\")\n    # We use a call to qml.math.stack to allow subtracting the arrays directly\n    return np.mean((labels - qml.math.stack(predictions)) ** 2)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:34:10.367785Z","iopub.execute_input":"2024-08-09T16:34:10.368177Z","iopub.status.idle":"2024-08-09T16:34:10.373986Z","shell.execute_reply.started":"2024-08-09T16:34:10.368143Z","shell.execute_reply":"2024-08-09T16:34:10.372720Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def accuracy(labels, predictions):\n   # print(\"inside accuracy\")\n    acc = sum(abs(l - p) < 1e-5 for l, p in zip(labels, predictions))\n    acc = acc / len(labels)\n    return acc","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:34:08.590236Z","iopub.execute_input":"2024-08-09T16:34:08.590617Z","iopub.status.idle":"2024-08-09T16:34:08.597001Z","shell.execute_reply.started":"2024-08-09T16:34:08.590588Z","shell.execute_reply":"2024-08-09T16:34:08.595687Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def cost(weights, bias, X, Y):\n    #print(\"inside cost\")\n    predictions = [variational_classifier(weights, bias, x) for x in X]\n    #print(square_loss(Y, predictions))\n    return square_loss(Y, predictions)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:45:40.423401Z","iopub.execute_input":"2024-08-09T16:45:40.423784Z","iopub.status.idle":"2024-08-09T16:45:40.429868Z","shell.execute_reply.started":"2024-08-09T16:45:40.423753Z","shell.execute_reply":"2024-08-09T16:45:40.428601Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"num_of_data = 64\ntheta =  np.random.randint(10, size=(num_of_data,1))\nsin_theta = np.sin(theta[:,0]) # Learn sin (x)\nfor x,y in zip(theta, sin_theta):\n    print(f\"x = {x}, y = {y}\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:50:02.630538Z","iopub.execute_input":"2024-08-09T16:50:02.630944Z","iopub.status.idle":"2024-08-09T16:50:02.645725Z","shell.execute_reply.started":"2024-08-09T16:50:02.630914Z","shell.execute_reply":"2024-08-09T16:50:02.644223Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"theta","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:31:51.856106Z","iopub.execute_input":"2024-08-09T16:31:51.857060Z","iopub.status.idle":"2024-08-09T16:31:51.865571Z","shell.execute_reply.started":"2024-08-09T16:31:51.857024Z","shell.execute_reply":"2024-08-09T16:31:51.864410Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sin_theta","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:31:54.859921Z","iopub.execute_input":"2024-08-09T16:31:54.860850Z","iopub.status.idle":"2024-08-09T16:31:54.870543Z","shell.execute_reply.started":"2024-08-09T16:31:54.860812Z","shell.execute_reply":"2024-08-09T16:31:54.869273Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# data = np.loadtxt(\"/kaggle/input/parity/parity_train.txt\", dtype=int)\ndata = np.loadtxt(\"/kaggle/input/d/nazcet/parity/parity_train.txt\", dtype=int)\nX = np.array(data[:, :-1])\nY = np.array(data[:, -1])\nY = Y * 2 - 1  # shift label from {0, 1} to {-1, 1}\n\nfor x,y in zip(X, Y):\n    print(f\"x = {x}, y = {y}\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:31:58.803251Z","iopub.execute_input":"2024-08-09T16:31:58.804296Z","iopub.status.idle":"2024-08-09T16:31:58.823566Z","shell.execute_reply.started":"2024-08-09T16:31:58.804243Z","shell.execute_reply":"2024-08-09T16:31:58.822397Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:32:02.336573Z","iopub.execute_input":"2024-08-09T16:32:02.336949Z","iopub.status.idle":"2024-08-09T16:32:02.344812Z","shell.execute_reply.started":"2024-08-09T16:32:02.336920Z","shell.execute_reply":"2024-08-09T16:32:02.343630Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Y","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:32:04.754782Z","iopub.execute_input":"2024-08-09T16:32:04.755159Z","iopub.status.idle":"2024-08-09T16:32:04.762650Z","shell.execute_reply.started":"2024-08-09T16:32:04.755130Z","shell.execute_reply":"2024-08-09T16:32:04.761514Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# np.random.seed(0)\n# num_qubits = 1\n# num_layers = 0\n# weights_init = 0.01 * np.random.randn( 1,num_qubits, 3, requires_grad=True)\n# bias_init = np.array(0.0, requires_grad=True)\n\nnp.random.seed(0)\nnum_qubits = 4\nnum_layers = 1\nweights_init = 0.01 * np.random.randn(num_layers,num_qubits, 3, requires_grad=True)\nbias_init = np.array(0.0, requires_grad=True)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:58:21.424999Z","iopub.execute_input":"2024-08-09T16:58:21.425990Z","iopub.status.idle":"2024-08-09T16:58:21.432488Z","shell.execute_reply.started":"2024-08-09T16:58:21.425949Z","shell.execute_reply":"2024-08-09T16:58:21.431294Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(\"Weights:\", weights_init)\nprint(\"Bias: \", bias_init)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:58:24.365092Z","iopub.execute_input":"2024-08-09T16:58:24.365530Z","iopub.status.idle":"2024-08-09T16:58:24.372884Z","shell.execute_reply.started":"2024-08-09T16:58:24.365492Z","shell.execute_reply":"2024-08-09T16:58:24.371639Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"opt = NesterovMomentumOptimizer(0.5)\nbatch_size = 5","metadata":{"execution":{"iopub.status.busy":"2024-08-09T16:58:26.280312Z","iopub.execute_input":"2024-08-09T16:58:26.280730Z","iopub.status.idle":"2024-08-09T16:58:26.285854Z","shell.execute_reply.started":"2024-08-09T16:58:26.280695Z","shell.execute_reply":"2024-08-09T16:58:26.284741Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## debug","metadata":{}},{"cell_type":"code","source":"weights = weights_init\nbias = bias_init\nfor it in range(100):\n    #print(\"weights\")\n    #print(weights)\n\n    #Update the weights by one optimizer step, using only a limited batch of data\n#     batch_index = np.random.randint(0, len(theta), (batch_size,))\n#     X_batch = theta[batch_index]\n#     Y_batch = sin_theta[batch_index]\n    weights, bias = opt.step(cost, weights, bias, X=theta, Y=sin_theta)\n    #weights, bias = opt.step(cost, weights, bias, X=None, Y=None)\n    \n\n    # Compute accuracy\n    predictions = [np.sign(variational_classifier(weights, bias, x)) for x in X]\n\n    current_cost = cost(weights, bias, X, Y)\n    acc = accuracy(Y, predictions)\n\n    print(f\"Iter: {it+1:4d} | Cost: {current_cost:0.7f} | Accuracy: {acc:0.7f}\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T17:21:56.630718Z","iopub.execute_input":"2024-08-09T17:21:56.631143Z","iopub.status.idle":"2024-08-09T17:21:56.877526Z","shell.execute_reply.started":"2024-08-09T17:21:56.631106Z","shell.execute_reply":"2024-08-09T17:21:56.875376Z"},"trusted":true},"execution_count":184,"outputs":[{"name":"stdout","text":"Autograd ArrayBox with value [[[ 0.01764052  0.00400157  0.00978738]\n  [ 0.02240893  0.01867558 -0.00977278]\n  [ 0.00950088 -0.00151357 -0.00103219]\n  [ 0.00410599  0.00144044  0.01454274]]]\nVE expval(Z(0))\nAutograd ArrayBox with value [[[ 0.01764052  0.00400157  0.00978738]\n  [ 0.02240893  0.01867558 -0.00977278]\n  [ 0.00950088 -0.00151357 -0.00103219]\n  [ 0.00410599  0.00144044  0.01454274]]]\n","output_type":"stream"},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","Cell \u001b[0;32mIn[184], line 11\u001b[0m\n\u001b[1;32m      2\u001b[0m bias \u001b[38;5;241m=\u001b[39m bias_init\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m it \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m100\u001b[39m):\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;66;03m#print(\"weights\")\u001b[39;00m\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;66;03m#print(weights)\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;66;03m#     X_batch = theta[batch_index]\u001b[39;00m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m#     Y_batch = sin_theta[batch_index]\u001b[39;00m\n\u001b[0;32m---> 11\u001b[0m     weights, bias \u001b[38;5;241m=\u001b[39m \u001b[43mopt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcost\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweights\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mY\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msin_theta\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     12\u001b[0m     \u001b[38;5;66;03m#weights, bias = opt.step(cost, weights, bias, X=None, Y=None)\u001b[39;00m\n\u001b[1;32m     13\u001b[0m     \n\u001b[1;32m     14\u001b[0m \n\u001b[1;32m     15\u001b[0m     \u001b[38;5;66;03m# Compute accuracy\u001b[39;00m\n\u001b[1;32m     16\u001b[0m     predictions \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39msign(variational_classifier(weights, bias, x)) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m X]\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/pennylane/optimize/gradient_descent.py:93\u001b[0m, in \u001b[0;36mGradientDescentOptimizer.step\u001b[0;34m(self, objective_fn, grad_fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m     75\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstep\u001b[39m(\u001b[38;5;28mself\u001b[39m, objective_fn, \u001b[38;5;241m*\u001b[39margs, grad_fn\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m     76\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Update trainable arguments with one step of the optimizer.\u001b[39;00m\n\u001b[1;32m     77\u001b[0m \n\u001b[1;32m     78\u001b[0m \u001b[38;5;124;03m    Args:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     90\u001b[0m \u001b[38;5;124;03m        If single arg is provided, list [array] is replaced by array.\u001b[39;00m\n\u001b[1;32m     91\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m---> 93\u001b[0m     g, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjective_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad_fn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgrad_fn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     94\u001b[0m     new_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mapply_grad(g, args)\n\u001b[1;32m     96\u001b[0m     \u001b[38;5;66;03m# unwrap from list if one argument, cleaner return\u001b[39;00m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/pennylane/optimize/nesterov_momentum.py:77\u001b[0m, in \u001b[0;36mNesterovMomentumOptimizer.compute_grad\u001b[0;34m(self, objective_fn, args, kwargs, grad_fn)\u001b[0m\n\u001b[1;32m     74\u001b[0m         shifted_args[index] \u001b[38;5;241m=\u001b[39m args[index] \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmomentum \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maccumulation[index]\n\u001b[1;32m     76\u001b[0m g \u001b[38;5;241m=\u001b[39m get_gradient(objective_fn) \u001b[38;5;28;01mif\u001b[39;00m grad_fn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m grad_fn\n\u001b[0;32m---> 77\u001b[0m grad \u001b[38;5;241m=\u001b[39m \u001b[43mg\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mshifted_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     78\u001b[0m forward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(g, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mforward\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m     80\u001b[0m grad \u001b[38;5;241m=\u001b[39m (grad,) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(trainable_indices) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m grad\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/pennylane/_grad.py:166\u001b[0m, in \u001b[0;36mgrad.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    163\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fun(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    164\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m ()\n\u001b[0;32m--> 166\u001b[0m grad_value, ans \u001b[38;5;241m=\u001b[39m \u001b[43mgrad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m    167\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward \u001b[38;5;241m=\u001b[39m ans\n\u001b[1;32m    169\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m grad_value\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/wrap_util.py:20\u001b[0m, in \u001b[0;36munary_to_nary.<locals>.nary_operator.<locals>.nary_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     19\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(args[i] \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m argnum)\n\u001b[0;32m---> 20\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43munary_operator\u001b[49m\u001b[43m(\u001b[49m\u001b[43munary_f\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mnary_op_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mnary_op_kwargs\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/pennylane/_grad.py:184\u001b[0m, in \u001b[0;36mgrad._grad_with_forward\u001b[0;34m(fun, x)\u001b[0m\n\u001b[1;32m    178\u001b[0m \u001b[38;5;129m@staticmethod\u001b[39m\n\u001b[1;32m    179\u001b[0m \u001b[38;5;129m@unary_to_nary\u001b[39m\n\u001b[1;32m    180\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_grad_with_forward\u001b[39m(fun, x):\n\u001b[1;32m    181\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"This function is a replica of ``autograd.grad``, with the only\u001b[39;00m\n\u001b[1;32m    182\u001b[0m \u001b[38;5;124;03m    difference being that it returns both the gradient *and* the forward pass\u001b[39;00m\n\u001b[1;32m    183\u001b[0m \u001b[38;5;124;03m    value.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 184\u001b[0m     vjp, ans \u001b[38;5;241m=\u001b[39m \u001b[43m_make_vjp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# pylint: disable=redefined-outer-name\u001b[39;00m\n\u001b[1;32m    186\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m vspace(ans)\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m    187\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m    188\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGrad only applies to real scalar-output functions. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    189\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTry jacobian, elementwise_grad or holomorphic_grad.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    190\u001b[0m         )\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/core.py:10\u001b[0m, in \u001b[0;36mmake_vjp\u001b[0;34m(fun, x)\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmake_vjp\u001b[39m(fun, x):\n\u001b[1;32m      9\u001b[0m     start_node \u001b[38;5;241m=\u001b[39m VJPNode\u001b[38;5;241m.\u001b[39mnew_root()\n\u001b[0;32m---> 10\u001b[0m     end_value, end_node \u001b[38;5;241m=\u001b[39m  \u001b[43mtrace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstart_node\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m end_node \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     12\u001b[0m         \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvjp\u001b[39m(g): \u001b[38;5;28;01mreturn\u001b[39;00m vspace(x)\u001b[38;5;241m.\u001b[39mzeros()\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/tracer.py:10\u001b[0m, in \u001b[0;36mtrace\u001b[0;34m(start_node, fun, x)\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m trace_stack\u001b[38;5;241m.\u001b[39mnew_trace() \u001b[38;5;28;01mas\u001b[39;00m t:\n\u001b[1;32m      9\u001b[0m     start_box \u001b[38;5;241m=\u001b[39m new_box(x, t, start_node)\n\u001b[0;32m---> 10\u001b[0m     end_box \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstart_box\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m isbox(end_box) \u001b[38;5;129;01mand\u001b[39;00m end_box\u001b[38;5;241m.\u001b[39m_trace \u001b[38;5;241m==\u001b[39m start_box\u001b[38;5;241m.\u001b[39m_trace:\n\u001b[1;32m     12\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m end_box\u001b[38;5;241m.\u001b[39m_value, end_box\u001b[38;5;241m.\u001b[39m_node\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/wrap_util.py:15\u001b[0m, in \u001b[0;36munary_to_nary.<locals>.nary_operator.<locals>.nary_f.<locals>.unary_f\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     14\u001b[0m     subargs \u001b[38;5;241m=\u001b[39m subvals(args, \u001b[38;5;28mzip\u001b[39m(argnum, x))\n\u001b[0;32m---> 15\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msubargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n","Cell \u001b[0;32mIn[160], line 3\u001b[0m, in \u001b[0;36mcost\u001b[0;34m(weights, bias, X, Y)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcost\u001b[39m(weights, bias, X, Y):\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;66;03m#print(\"inside cost\")\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m     predictions \u001b[38;5;241m=\u001b[39m [variational_classifier(weights, bias, x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m X]\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;66;03m#print(square_loss(Y, predictions))\u001b[39;00m\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m square_loss(Y, predictions)\n","Cell \u001b[0;32mIn[160], line 3\u001b[0m, in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcost\u001b[39m(weights, bias, X, Y):\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;66;03m#print(\"inside cost\")\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m     predictions \u001b[38;5;241m=\u001b[39m [\u001b[43mvariational_classifier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mweights\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m X]\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;66;03m#print(square_loss(Y, predictions))\u001b[39;00m\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m square_loss(Y, predictions)\n","Cell \u001b[0;32mIn[142], line 4\u001b[0m, in \u001b[0;36mvariational_classifier\u001b[0;34m(weights, bias, x)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvariational_classifier\u001b[39m(weights, bias, x):\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;66;03m#print(\"inside variational_classifier\")\u001b[39;00m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mVE\u001b[39m\u001b[38;5;124m\"\u001b[39m,circuit(weights, x))\n\u001b[0;32m----> 4\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcircuit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mweights\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/numpy/numpy_boxes.py:34\u001b[0m, in \u001b[0;36mArrayBox.__radd__\u001b[0;34m(self, other)\u001b[0m\n\u001b[0;32m---> 34\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__radd__\u001b[39m(\u001b[38;5;28mself\u001b[39m, other): \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43manp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madd\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[43mother\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/tracer.py:44\u001b[0m, in \u001b[0;36mprimitive.<locals>.f_wrapped\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     42\u001b[0m parents \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(box\u001b[38;5;241m.\u001b[39m_node \u001b[38;5;28;01mfor\u001b[39;00m _     , box \u001b[38;5;129;01min\u001b[39;00m boxed_args)\n\u001b[1;32m     43\u001b[0m argnums \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(argnum    \u001b[38;5;28;01mfor\u001b[39;00m argnum, _   \u001b[38;5;129;01min\u001b[39;00m boxed_args)\n\u001b[0;32m---> 44\u001b[0m ans \u001b[38;5;241m=\u001b[39m \u001b[43mf_wrapped\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margvals\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     45\u001b[0m node \u001b[38;5;241m=\u001b[39m node_constructor(ans, f_wrapped, argvals, kwargs, argnums, parents)\n\u001b[1;32m     46\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m new_box(ans, trace, node)\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/autograd/tracer.py:48\u001b[0m, in \u001b[0;36mprimitive.<locals>.f_wrapped\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     46\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m new_box(ans, trace, node)\n\u001b[1;32m     47\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 48\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mf_raw\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/pennylane/numpy/tensor.py:155\u001b[0m, in \u001b[0;36mtensor.__array_ufunc__\u001b[0;34m(self, ufunc, method, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    151\u001b[0m args \u001b[38;5;241m=\u001b[39m [i\u001b[38;5;241m.\u001b[39munwrap() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(i, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124munwrap\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m i \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m inputs]\n\u001b[1;32m    153\u001b[0m \u001b[38;5;66;03m# call the ndarray.__array_ufunc__ method to compute the result\u001b[39;00m\n\u001b[1;32m    154\u001b[0m \u001b[38;5;66;03m# of the vectorized ufunc\u001b[39;00m\n\u001b[0;32m--> 155\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__array_ufunc__\u001b[49m\u001b[43m(\u001b[49m\u001b[43mufunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    157\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(res, Operator):\n\u001b[1;32m    158\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m res\n","\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'ExpectationMP' and 'float'"],"ename":"TypeError","evalue":"unsupported operand type(s) for +: 'ExpectationMP' and 'float'","output_type":"error"}]},{"cell_type":"code","source":"# Define the variational form V and observable M and combine them into a QNode.\nqml.qnode(dev, diff_method=\"parameter-shift\", max_diff=2)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:22.961438Z","iopub.execute_input":"2024-08-07T20:22:22.961836Z","iopub.status.idle":"2024-08-07T20:22:22.969001Z","shell.execute_reply.started":"2024-08-07T20:22:22.961806Z","shell.execute_reply":"2024-08-07T20:22:22.967922Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"num_of_data = 64\nX =  np.random.uniform(high=2 * np.pi, size=(num_of_data,1))\nY = np.sin(X[:,0]) # Learn sin (x)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:28.684869Z","iopub.execute_input":"2024-08-07T20:22:28.685224Z","iopub.status.idle":"2024-08-07T20:22:28.691423Z","shell.execute_reply.started":"2024-08-07T20:22:28.685197Z","shell.execute_reply":"2024-08-07T20:22:28.690020Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nnp.random.seed(0)\nn_qubits = 2\nnum_layers = 2\nweights_init = 0.01 * np.random.randn(num_layers, n_qubits, 3, requires_grad=True)\nbias_init = np.array(0.0, requires_grad=True)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:35.877337Z","iopub.execute_input":"2024-08-07T20:22:35.878456Z","iopub.status.idle":"2024-08-07T20:22:35.884564Z","shell.execute_reply.started":"2024-08-07T20:22:35.878410Z","shell.execute_reply":"2024-08-07T20:22:35.883460Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"weights_init","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:38.631098Z","iopub.execute_input":"2024-08-07T20:22:38.631492Z","iopub.status.idle":"2024-08-07T20:22:38.638942Z","shell.execute_reply.started":"2024-08-07T20:22:38.631462Z","shell.execute_reply":"2024-08-07T20:22:38.637839Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"var_init","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:45.912232Z","iopub.execute_input":"2024-08-07T20:22:45.912631Z","iopub.status.idle":"2024-08-07T20:22:45.939610Z","shell.execute_reply.started":"2024-08-07T20:22:45.912596Z","shell.execute_reply":"2024-08-07T20:22:45.938035Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Data encoding and variational ansatz\ndef quantum_neural_net(features, para):\n    print('features')\n    print(features)\n    print('para')\n    print(para)\n    qml.templates.AngleEmbedding(features=features, wires=range(n_qubits),rotation='Y')\n    qml.templates.StronglyEntanglingLayers(weights=para, wires=range(n_qubits))\n    print(qml)\n    x=qml.expval(qml.PauliZ(0))\n    print('Value')\n    print(x)\n    return qml.expval(qml.PauliZ(0))","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:43.264017Z","iopub.execute_input":"2024-08-07T20:22:43.264415Z","iopub.status.idle":"2024-08-07T20:22:43.272082Z","shell.execute_reply.started":"2024-08-07T20:22:43.264383Z","shell.execute_reply":"2024-08-07T20:22:43.270713Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def variational_classifier(para, bias, features):\n    print(\"xyz134\")\n    x=quantum_neural_net(features, para)\n    print(\"xyz134\")\n    print(x)\n    return x+bias","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:48.423018Z","iopub.execute_input":"2024-08-07T20:22:48.423400Z","iopub.status.idle":"2024-08-07T20:22:48.428626Z","shell.execute_reply.started":"2024-08-07T20:22:48.423369Z","shell.execute_reply":"2024-08-07T20:22:48.427447Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def mse(observed,predictions):\n    loss = 0.0\n    for l, p in zip(observed, predictions):\n        print(\"xyz1\")\n        loss +=(l - p) ** 2\n        print(\"xyz2\")\n        \n    loss = loss / len(observed)\n    return np.mean(np.array(loss))","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:50.361702Z","iopub.execute_input":"2024-08-07T20:22:50.362075Z","iopub.status.idle":"2024-08-07T20:22:50.369393Z","shell.execute_reply.started":"2024-08-07T20:22:50.362044Z","shell.execute_reply":"2024-08-07T20:22:50.368415Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def cost(para, bias, features, labels):\n    predictions = [variational_classifier(para, bias, f) for f in features]\n    return mse(labels, predictions)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:53.221618Z","iopub.execute_input":"2024-08-07T20:22:53.222030Z","iopub.status.idle":"2024-08-07T20:22:53.227766Z","shell.execute_reply.started":"2024-08-07T20:22:53.221998Z","shell.execute_reply":"2024-08-07T20:22:53.226337Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"opt = qml.GradientDescentOptimizer(stepsize=0.01)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:22:58.365184Z","iopub.execute_input":"2024-08-07T20:22:58.365757Z","iopub.status.idle":"2024-08-07T20:22:58.371589Z","shell.execute_reply.started":"2024-08-07T20:22:58.365719Z","shell.execute_reply":"2024-08-07T20:22:58.370179Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"batch_size = 5\n\n# train the variational classifier\nweights = weights_init\nbias = bias_init","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:00.819236Z","iopub.execute_input":"2024-08-07T20:23:00.819950Z","iopub.status.idle":"2024-08-07T20:23:00.824794Z","shell.execute_reply.started":"2024-08-07T20:23:00.819907Z","shell.execute_reply":"2024-08-07T20:23:00.823457Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X =  np.random.uniform(high=2 * np.pi, size=(num_of_data,1))\nY = np.sin(X[:,0]) # Learn sin (x)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:02.379419Z","iopub.execute_input":"2024-08-07T20:23:02.379787Z","iopub.status.idle":"2024-08-07T20:23:02.386695Z","shell.execute_reply.started":"2024-08-07T20:23:02.379760Z","shell.execute_reply":"2024-08-07T20:23:02.384759Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:04.348984Z","iopub.execute_input":"2024-08-07T20:23:04.349856Z","iopub.status.idle":"2024-08-07T20:23:04.358777Z","shell.execute_reply.started":"2024-08-07T20:23:04.349822Z","shell.execute_reply":"2024-08-07T20:23:04.357659Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Y","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:06.984783Z","iopub.execute_input":"2024-08-07T20:23:06.985153Z","iopub.status.idle":"2024-08-07T20:23:06.994200Z","shell.execute_reply.started":"2024-08-07T20:23:06.985123Z","shell.execute_reply":"2024-08-07T20:23:06.993079Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = X[0:50]\nY_train =Y[0:50]\n","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:08.798479Z","iopub.execute_input":"2024-08-07T20:23:08.798888Z","iopub.status.idle":"2024-08-07T20:23:08.804051Z","shell.execute_reply.started":"2024-08-07T20:23:08.798854Z","shell.execute_reply":"2024-08-07T20:23:08.802856Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Y_train","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:10.378851Z","iopub.execute_input":"2024-08-07T20:23:10.379239Z","iopub.status.idle":"2024-08-07T20:23:10.388549Z","shell.execute_reply.started":"2024-08-07T20:23:10.379207Z","shell.execute_reply":"2024-08-07T20:23:10.387347Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"batch_size = 5\n\n# train the variational classifier\nweights = weights_init\nbias = bias_init\n\nnum_train=50","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:12.291893Z","iopub.execute_input":"2024-08-07T20:23:12.292240Z","iopub.status.idle":"2024-08-07T20:23:12.297316Z","shell.execute_reply.started":"2024-08-07T20:23:12.292212Z","shell.execute_reply":"2024-08-07T20:23:12.296138Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"for it in range(100):\n\n    # Update the weights by one optimizer step\n    batch_index = np.random.randint(0, num_train, (batch_size,))\n    x_train_batch = X_train[batch_index]\n    y_train_batch = Y_train[batch_index]\n    (weights,bias,_,_), _cost = opt.step_and_cost(cost, weights,bias,x_train_batch,y_train_batch)\n    #print(weights)\n\n    # Compute predictions on train and validation set\n    predictions_train = [np.sign(variational_classifier(weights, bias, f)) for f in x_train]","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:14.072593Z","iopub.execute_input":"2024-08-07T20:23:14.073126Z","iopub.status.idle":"2024-08-07T20:23:14.263522Z","shell.execute_reply.started":"2024-08-07T20:23:14.073091Z","shell.execute_reply":"2024-08-07T20:23:14.261890Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"hist_cost = []\nvar = var_init\nfor it in range(50):\n    t1 = time.time() \n    var, _cost = opt.step_and_cost(lambda v: cost(v, X, Y), var)\n    t2 = time.time() \n    elapsed_time = t2-t1\n    print(\"Iter:\"+str(it)+\", cost=\"+str(_cost.numpy()))\n    print(f\"Time：{elapsed_time}\")\n    hist_cost.append(_cost)","metadata":{"execution":{"iopub.status.busy":"2024-08-07T20:23:20.407022Z","iopub.execute_input":"2024-08-07T20:23:20.407421Z","iopub.status.idle":"2024-08-07T20:23:20.440138Z","shell.execute_reply.started":"2024-08-07T20:23:20.407389Z","shell.execute_reply":"2024-08-07T20:23:20.438514Z"},"trusted":true},"execution_count":null,"outputs":[]}]}