Hi everyone,
We are trying to build a trainable Quantum Convolutional Neural Network.
To this end we are trying to create a new subclass QuantumConvolutionalLayer of the class keras.Layer.
How we are trying this now:
In the initialization we use the add_weight function to add the trainable_parameters as a weight. Then we create (still in the initialization) a quantum circuit (on 4 qubits) with pennylane that takes 4 classical inputs and the trainable weights that will be called upon.
In the call function (for the forward pass):
a 2x2 grid is moved over the entire image (mnist in our case) and everytime the 2x2 grid is processed using the quantum circuit defined in the initialization.
The outcome of the processing with this quantum circuit of such a 2x2 grid [measurement_results] is stored in a tensorflow tensor object and we aim to then store all these in one big tensor [out]. To do this we use the tensor_scatter_nd_update. Unfortunately when we look at the resulting out tensor it has all zero values, even though when we print the measurement_results of the small grids we get non zero values. Any ideas on how this can be solved?
Many thanks in advance for your help!
Odiel
PS: Below you can find our code so far:
# Library installation
!pip install qiskit
!pip install pennylane 

# General imports
import pennylane as qml
import numpy as np
from numpy import pi, sqrt
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import backend
from tensorflow.keras.layers import Layer
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer, assemble, visualization

# Dataset
from keras.datasets import mnist

# Embedding imports
from pennylane.templates import QAOAEmbedding

# Build function to load train and test dataset
def load_dataset():
    # load dataset
    (trainX, trainY), (testX, testY) = mnist.load_data()
    # reshape dataset to have a single channel
    trainX = trainX.reshape((trainX.shape[0], 28, 28, 1))
    testX = testX.reshape((testX.shape[0], 28, 28, 1))
    # one hot encode target values
    trainY = tf.keras.utils.to_categorical(trainY)
    testY = tf.keras.utils.to_categorical(testY)
    return trainX, trainY, testX, testY

# Load train and test dataset
X_train, Y_train, X_test, Y_test = load_dataset()
num_images = 10 # set to -1 in order to keep all images
X_train = X_train[0:num_images]
X_test = X_test[0:num_images]
Y_train = Y_train[0:num_images]
Y_test = Y_test[0:num_images]

# Build a class for the trainable quantum convolutional layer that is a subclass of the keras.Layer class

class QuantumConvolutionalLayer(Layer):
  def __init__(self, device = "default.qubit", stride = 2, wires = 4, layers = 1, n_measurements = 4):
    
    # Inherits the initialization of the keras.Layer class
    super(QuantumConvolutionalLayer, self).__init__() 

    # Initialize the device
    self.wires = wires
    self.dev = qml.device(device, wires = self.wires)

    # Initialize the quantum circuit
    self.layers = layers
    self.stride = stride
    self.n_measurements = n_measurements
    self.trainable_parameters = self.add_weight("trainable_parameters", shape = QAOAEmbedding.shape(n_layers=layers, n_wires=wires), initializer = tf.keras.initializers.RandomNormal())
    
    # To this end, build the quantum circuit (for 1 square of stride x stride)
    @qml.qnode(device = self.dev, interface = "tf")
    def quantum_circuit(inputs, trainable_parameters = self.trainable_parameters):
      QAOAEmbedding(features = inputs, weights = trainable_parameters, wires = range(wires))
      return [qml.expval(qml.PauliZ(j)) for j in range(n_measurements)]

    #weight_shapes = {"trainable_parameters": QAOAEmbedding.shape(n_layers=self.layers, n_wires=self.wires)}
    #self.quantum_circuit = qml.qnn.KerasLayer(quantum_circuit, weight_shapes = weight_shapes, output_dim = self.n_measurements)
    self.quantum_circuit = quantum_circuit

    dtype = tf.float32 if tf.keras.backend.floatx() == tf.float32 else tf.float64

    if self.quantum_circuit.diff_method != "backprop" or self.quantum_circuit.diff_method_change:
      self.quantum_circuit.to_tf(dtype=dtype)

  def build(self, input_shape):
    super().build(input_shape)

  def call(self, inputs):
    # define forward pass
    num_images=inputs.shape[0]
    h_in, w_in, ch_in = inputs.shape[1:]  # inputs.shape  (28, 28, 1) for MNIST
    h_out, w_out, ch_out = h_in // self.stride, w_in // self.stride, ch_in * self.n_measurements # (14, 14, 4) for MNIST and our quantum circuit filter
    out = tf.zeros((num_images, h_out, w_out, ch_out))
    for img_idx in range(num_images):
      # print(tf.rank(out))
      for j in range(0, h_in, self.stride):
        for k in range(0, w_in, self.stride):
          grid = [inputs[img_idx, j, k, 0], inputs[img_idx, j, k + 1, 0], inputs[img_idx, j + 1, k, 0], inputs[img_idx, j + 1, k + 1, 0]]
          measurement_results = self.quantum_circuit(inputs = grid, trainable_parameters = self.trainable_parameters)
          print(measurement_results)
          for ch in range(self.n_measurements):
              tf.tensor_scatter_nd_update(out[img_idx], tf.constant([[j//2, k//2, ch]]), [measurement_results[ch]])
    return out

quanv = QuantumConvolutionalLayer()
quanv(np.array([X_train[0]]))