Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import sys import os import pennylane as qml from pennylane import numpy as np import…

  1. User

    import sys import os import pennylane as qml from pennylane import numpy as np import tensorflow as tf from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.preprocessing import OneHotEncoder import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt from tensorflow.python.keras.layers import Dense from example_utils import get_parser from importance_sampling.training import ConstantTimeImportanceTraining from pennylane.qnn.keras import KerasLayer

    重定向stdout以捕获打印输出

    class Tee(object): def init(self, *files): self.files = files def write(self, obj): for f in self.files: f.write(obj) f.flush() def flush(self): for f in self.files: f.flush()

    output_file = open('output.log', 'w', encoding='utf-8') original_stdout = sys.stdout sys.stdout = Tee(sys.stdout, output_file)

    def save_plot(fig, filename): fig.savefig(filename) plt.close(fig)

    def plot_history(history): # 绘制训练和验证准确率 fig, ax = plt.subplots(figsize=(10, 5)) ax.plot(history.history['accuracy']) ax.plot(history.history['val_accuracy']) ax.set_title('Model Accuracy') ax.set_ylabel('Accuracy') ax.set_xlabel('Epoch') ax.legend(['Train', 'Validation'], loc='upper left') save_plot(fig, 'accuracy_plot.png')

    # 绘制训练和验证损失
    fig, ax = plt.subplots(figsize=(10, 5))
    ax.plot(history.history['loss'])
    ax.plot(history.history['val_loss'])
    ax.set_title('Model Loss')
    ax.set_ylabel('Loss')
    ax.set_xlabel('Epoch')
    ax.legend(['Train', 'Validation'], loc='upper left')
    save_plot(fig, 'loss_plot.png')
    

    def calculate_accuracy_fluctuation(history): val_accuracies = history.history['val_accuracy'] mean_accuracy = np.mean(val_accuracies) fluctuation = np.sum(np.abs(val_accuracies - mean_accuracy)) return mean_accuracy, fluctuation

    新的量子神经网络实现

    定义设备,使用11个量子比特

    dev = qml.device("default.qubit", wires=11)

    def encode_group(control_qubits, data_qubits, angles_q2, angles_q3): """ 模块化方法,用于对一组量子比特进行角度编码。

    参数:
    - control_qubits (list[int]): 控制比特的索引,例如 [0, 1]。
    - data_qubits (dict): 包含 'q2' 和 'q3' 的量子比特索引,例如 {'q2': 2, 'q3': 3}。
    - angles_q2 (list[float]): q2 在不同控制状态下的 Ry 旋转角度。
    - angles_q3 (list[float]): q3 在不同控制状态下的 Ry 旋转角度。
    """
    control_values = [[0, 0], [0, 1], [1, 0], [1, 1]]
    
    for cv, angle_q2, angle_q3 in zip(control_values, angles_q2, angles_q3):
        # 翻转控制比特为0的量子比特,以便使用受控RY门
        for qubit, val in zip(control_qubits, cv):
            if val == 0:
                qml.PauliX(wires=qubit)
    
        # 对 q2 应用受控 RY 旋转
        qml.ctrl(qml.RY, control=control_qubits)(angle_q2, wires=data_qubits['q2'])
    
        # 对 q3 应用受控 RY 旋转
        qml.ctrl(qml.RY, control=control_qubits)(angle_q3, wires=data_qubits['q3'])
    
        # 恢复控制比特的原始状态
        for qubit, val in zip(control_qubits, cv):
            if val == 0:
                qml.PauliX(wires=qubit)
    

    def apply_controlled_swap(swap_qubit, q_swap1, q_swap2): """ 模块化方法,用于应用受控 SWAP 门。

    参数:
    - swap_qubit (int): 作为交换门控制比特的量子比特索引。
    - q_swap1 (int): 受交换操作影响的第一个量子比特索引。
    - q_swap2 (int): 受交换操作影响的第二个量子比特索引。
    """
    # 对 swap_qubit 应用 Hadamard 门
    qml.Hadamard(wires=swap_qubit)
    
    # 应用受控 SWAP 门
    qml.CSWAP(wires=[swap_qubit, q_swap1, q_swap2])
    
    # 再次对 swap_qubit 应用 Hadamard 门以恢复控制比特
    qml.Hadamard(wires=swap_qubit)
    

    定义一个量子节点 (QNode)

    @qml.qnode(dev, interface='tf', diff_method='backprop') def quantum_neural_network(inputs, weights): """ 量子神经网络的 QNode,实现多组数据的编码和交换操作。

    参数:
    - inputs (array[float]): 输入特征向量。
    - weights (array[float]): 量子电路的参数权重。
    
    返回:
    - array[float]: 每组交换控制比特的 Pauli-Z 期望值。
    """
    # 控制比特为 q0 和 q1
    control_qubits = [0, 1]
    
    # 定义各组的量子比特索引和旋转角度
    encoding_data = [
        {
            'data_qubits': {'q2': 2, 'q3': 3},
            'swap_qubit': 4,
            'angles_q2': [1.0, 3.0, 5.0, 7.0],
            'angles_q3': [2.0, 4.0, 6.0, 8.0]
        },
        {
            'data_qubits': {'q2': 5, 'q3': 6},
            'swap_qubit': 7,
            'angles_q2': [1.5, 3.5, 5.5, 7.5],
            'angles_q3': [2.5, 4.5, 6.5, 8.5]
        },
        {
            'data_qubits': {'q2': 8, 'q3': 9},
            'swap_qubit': 10,
            'angles_q2': [2.0, 4.0, 6.0, 8.0],
            'angles_q3': [3.0, 5.0, 7.0, 9.0]
        }
    ]
    
    # 对每组数据进行编码
    for idx, data_set in enumerate(encoding_data):
        data_qubits = data_set['data_qubits']
        angles_q2 = data_set['angles_q2']
        angles_q3 = data_set['angles_q3']
        encode_group(control_qubits, data_qubits, angles_q2, angles_q3)
    
    # 对每组数据应用交换操作
    for idx, data_set in enumerate(encoding_data):
        swap_qubit = data_set['swap_qubit']
        data_qubits = data_set['data_qubits']
        apply_controlled_swap(swap_qubit, data_qubits['q3'], data_qubits['q2'])
    
    # 应用 Rot 层
    # 这里假设 weights 的形状为 (n_layers, n_qubits, 3)
    for layer in range(weights.shape[0]):
        for qubit in range(weights.shape[1]):
            qml.Rot(weights[layer, qubit, 0],
                    weights[layer, qubit, 1],
                    weights[layer, qubit, 2],
                    wires=qubit)
    
    # 测量每个交换控制比特的 Pauli-Z 期望值
    results = [qml.expval(qml.PauliZ(data_set['swap_qubit'])) for data_set in encoding_data]
    
    return results
    

    定义一个量子神经网络层

    class QuantumNeuralNetworkLayer(tf.keras.layers.Layer): def init(self, n_qubits, n_layers, num_classes, **kwargs): super(QuantumNeuralNetworkLayer, self).init(**kwargs) self.n_qubits = n_qubits self.n_layers = n_layers self.num_classes = num_classes

        # Initialize weights
        weights_shape = (n_layers, n_qubits, 3)
        self.weights_qnn = self.add_weight(
            shape=weights_shape,
            initializer=tf.keras.initializers.GlorotUniform(),
            trainable=True,
            name='weights_qnn'
        )
    
    def call(self, inputs):
        return quantum_neural_network(inputs, self.weights_qnn)
    

    定义一个量子神经网络模型

    class QuantumNeuralNetwork(tf.keras.Model): def init(self, n_qubits, n_layers, num_classes, **kwargs): super(QuantumNeuralNetwork, self).init(**kwargs) self.n_qubits = n_qubits self.n_layers = n_layers self.num_classes = num_classes

        # Quantum layer
        self.quantum_layer = QuantumNeuralNetworkLayer(n_qubits, n_layers, num_classes)
    
        # Classical layers
        self.dense = Dense(num_classes, activation='softmax')
    
    def call(self, inputs):
        q_output = self.quantum_layer(inputs)
        return self.dense(q_output)
    

    if name == "main": parser = get_parser("Train model on Iris dataset") args = parser.parse_args()

    iris = load_iris()
    X = iris['data'].astype(np.float32)
    y = iris['target'].reshape(-1, 1)
    
    encoder = OneHotEncoder(sparse_output=False)
    y = encoder.fit_transform(y).astype(np.float32)
    
    x_train, x_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=116
    )
    
    learning_rate = 0.05
    epochs = 100
    batch_size = 8
    num_classes = 3
    n_qubits = 11  # 调整为11个量子比特(0到10)
    n_layers = 2
    
    model = QuantumNeuralNetwork(
        n_qubits=n_qubits,
        n_layers=n_layers,
        num_classes=num_classes
    )
    
    model.compile(
        optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    def is_quantum_model(model):
        for layer in model.layers:
            if isinstance(layer, QuantumNeuralNetworkLayer):
                return True
        return False
    
    if is_quantum_model(model):
        print("The model contains a Quantum Neural Network (QNN) layer.")
    else:
        print("The model does not contain a Quantum Neural Network (QNN) layer.")
    
    print("\nQuantum Circuit Diagram:")
    sample_inputs = np.ones(n_qubits, dtype=np.float32) * 0.0  # 示例输入
    sample_weights = np.zeros((n_layers, n_qubits, 3), dtype=np.float32)  # 示例权重
    print(qml.draw(quantum_neural_network)(sample_inputs, sample_weights))
    
    if args.importance_training:
        wrapped_model = ConstantTimeImportanceTraining(model, score="loss")
        history = wrapped_model.fit(
            x_train, y_train,
            batch_size=batch_size,
            epochs=epochs,
            verbose=1,
            validation_data=(x_test, y_test)
        )
    else:
        history = model.fit(
            x_train, y_train,
            batch_size=batch_size,
            epochs=epochs,
            verbose=1,
            validation_data=(x_test, y_test)
        )
    
    score = model.evaluate(x_test, y_test, verbose=0)
    print('Test loss:', score[0])
    print('Test accuracy:', score[1])
    
    mean_accuracy, fluctuation = calculate_accuracy_fluctuation(history)
    print('Mean validation accuracy:', mean_accuracy)
    print('Accuracy fluctuation:', fluctuation)
    
    plot_history(history)
    
    # 关闭输出文件并恢复stdout
    sys.stdout = original_stdout
    output_file.close()
    

    print("脚本执行完成。查看 'output.log' 获取打印输出,查看当前目录获取保存的图表。") 代码出现报错Traceback (most recent call last): File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\examples\yuanweihua_renew_usesoftmax_NQNN.py", line 270, in history = wrapped_model.fit( File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\training.py", line 132, in fit return self.fit_dataset( File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\training.py", line 273, in fit_dataset loss_value, metrics_results, scores = self.train_batch(x_batch, y_batch, w) File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\training.py", line 336, in train_batch y_pred = self.model.model(x, training=True) File "C:\Users\liuwenjing.conda\envs\pennylane2\lib\site-packages\keras\utils\traceback_utils.py", line 70, in error_handler raise e.with_traceback(filtered_tb) from None File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\examples\yuanweihua_renew_usesoftmax_NQNN.py", line 216, in call return self.dense(q_output) ValueError: Exception encountered when calling layer "quantum_neural_network" " f"(type QuantumNeuralNetwork).

    Input 0 of layer dense is incompatible with the layer: : expected min_ndim=2, found ndim=1. Full shape received: (3,)

    Call arguments received by layer "quantum_neural_network" " f"(type QuantumNeuralNetwork): • inputs=tf.Tensor(shape=(8, 4), dtype=float32) 详细解释原因并且纠正报错

  2. Assistant

    您遇到的错误是由于量子神经网络层(QuantumNeuralNetworkLayer)在处理批量输入时返回了形状不正确的张量。具体来说,Dense 层期望输入的张量至少是二维的(形状为 (batch_size, num_features)),但当前的量子层返回的是一维张量(形状为 (3,)),导致了不兼容的错误。

    错误分析

    根据错误信息:

    ValueError: Exception encountered when calling layer "quantum_neural_network" "(type QuantumNeuralNetwork).
    
    Input 0 of layer dense is incompatible with the layer: : expected min_ndim=2, found ndim=1. Full shape received: (3,)
    

    可以看出,Dense 层接收到的输入形状是 (3,),而它期望的是至少两维的输入(例如 (batch_size, 3))。这表明量子神经网络层在处理批量输入时返回的输出不符合预期的形状。

    问题根源

    在您的代码中,QuantumNeuralNetworkLayer 的 call 方法直接调用了量子节点 quantum_neural_network:

    def call(self, inputs):
        return quantum_neural_network(inputs, self.weights_qnn)
    

    然而,quantum_neural_network 是一个量子节点(@qml.qnode),它在默认情况下只处理单个样本的输入,并返回一个形状为 (3,) 的输出(对应于3个类别的预测)。当 QuantumNeuralNetworkLayer 接收到批量输入(例如形状为 (batch_size, 4) 的张量)时,它将整个批量传递给量子节点,但量子节点并未设计为处理批量输入,从而导致输出形状不匹配。

    解决方案

    为了让量子神经网络层能够正确处理批量输入,您需要修改 QuantumNeuralNetworkLayer,使其能够对批量中的每个样本单独调用量子节点。这可以通过使用 tf.map_fn 或 tf.vectorized_map 来实现,以确保量子节点对每个单独的样本进行处理,并最终返回形状为 (batch_size, num_classes) 的输出。

    以下是具体的修改步骤:

    1. 修改 QuantumNeuralNetworkLayer 的 call 方法:

      使用 tf.map_fn 将量子节点应用到每个样本上,确保输出形状为 (batch_size, 3)。

    2. 确保量子节点能够处理单个样本的输入:

      您可能需要确保输入的每个样本被正确地传递给量子节点,并且输出被正确地汇总。

    具体修改代码

    以下是如何修改您的代码以解决该问题的详细步骤:

    import sys
    import os
    import pennylane as qml
    from pennylane import numpy as np
    import tensorflow as tf
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import OneHotEncoder
    import matplotlib
    matplotlib.use('TkAgg')
    import matplotlib.pyplot as plt
    from tensorflow.python.keras.layers import Dense
    from example_utils import get_parser
    from importance_sampling.training import ConstantTimeImportanceTraining
    from pennylane.qnn.keras import KerasLayer
    
    # 重定向stdout以捕获打印输出
    class Tee(object):
        def __init__(self, *files):
            self.files = files
        def write(self, obj):
            for f in self.files:
                f.write(obj)
                f.flush()
        def flush(self):
            for f in self.files:
                f.flush()
    
    output_file = open('output.log', 'w', encoding='utf-8')
    original_stdout = sys.stdout
    sys.stdout = Tee(sys.stdout, output_file)
    
    def save_plot(fig, filename):
        fig.savefig(filename)
        plt.close(fig)
    
    def plot_history(history):
        # 绘制训练和验证准确率
        fig, ax = plt.subplots(figsize=(10, 5))
        ax.plot(history.history['accuracy'])
        ax.plot(history.history['val_accuracy'])
        ax.set_title('Model Accuracy')
        ax.set_ylabel('Accuracy')
        ax.set_xlabel('Epoch')
        ax.legend(['Train', 'Validation'], loc='upper left')
        save_plot(fig, 'accuracy_plot.png')
    
        # 绘制训练和验证损失
        fig, ax = plt.subplots(figsize=(10, 5))
        ax.plot(history.history['loss'])
        ax.plot(history.history['val_loss'])
        ax.set_title('Model Loss')
        ax.set_ylabel('Loss')
        ax.set_xlabel('Epoch')
        ax.legend(['Train', 'Validation'], loc='upper left')
        save_plot(fig, 'loss_plot.png')
    
    def calculate_accuracy_fluctuation(history):
        val_accuracies = history.history['val_accuracy']
        mean_accuracy = np.mean(val_accuracies)
        fluctuation = np.sum(np.abs(val_accuracies - mean_accuracy))
        return mean_accuracy, fluctuation
    
    # 新的量子神经网络实现
    # 定义设备,使用11个量子比特
    dev = qml.device("default.qubit", wires=11)
    
    def encode_group(control_qubits, data_qubits, angles_q2, angles_q3):
        """
        模块化方法,用于对一组量子比特进行角度编码。
    
        参数:
        - control_qubits (list[int]): 控制比特的索引,例如 [0, 1]。
        - data_qubits (dict): 包含 'q2' 和 'q3' 的量子比特索引,例如 {'q2': 2, 'q3': 3}。
        - angles_q2 (list[float]): q2 在不同控制状态下的 Ry 旋转角度。
        - angles_q3 (list[float]): q3 在不同控制状态下的 Ry 旋转角度。
        """
        control_values = [[0, 0], [0, 1], [1, 0], [1, 1]]
    
        for cv, angle_q2, angle_q3 in zip(control_values, angles_q2, angles_q3):
            # 翻转控制比特为0的量子比特,以便使用受控RY门
            for qubit, val in zip(control_qubits, cv):
                if val == 0:
                    qml.PauliX(wires=qubit)
    
            # 对 q2 应用受控 RY 旋转
            qml.ctrl(qml.RY, control=control_qubits)(angle_q2, wires=data_qubits['q2'])
    
            # 对 q3 应用受控 RY 旋转
            qml.ctrl(qml.RY, control=control_qubits)(angle_q3, wires=data_qubits['q3'])
    
            # 恢复控制比特的原始状态
            for qubit, val in zip(control_qubits, cv):
                if val == 0:
                    qml.PauliX(wires=qubit)
    
    def apply_controlled_swap(swap_qubit, q_swap1, q_swap2):
        """
        模块化方法,用于应用受控 SWAP 门。
    
        参数:
        - swap_qubit (int): 作为交换门控制比特的量子比特索引。
        - q_swap1 (int): 受交换操作影响的第一个量子比特索引。
        - q_swap2 (int): 受交换操作影响的第二个量子比特索引。
        """
        # 对 swap_qubit 应用 Hadamard 门
        qml.Hadamard(wires=swap_qubit)
    
        # 应用受控 SWAP 门
        qml.CSWAP(wires=[swap_qubit, q_swap1, q_swap2])
    
        # 再次对 swap_qubit 应用 Hadamard 门以恢复控制比特
        qml.Hadamard(wires=swap_qubit)
    
    # 定义一个量子节点 (QNode)
    @qml.qnode(dev, interface='tf', diff_method='backprop')
    def quantum_neural_network(inputs, weights):
        """
        量子神经网络的 QNode,实现多组数据的编码和交换操作。
    
        参数:
        - inputs (array[float]): 输入特征向量。
        - weights (array[float]): 量子电路的参数权重。
    
        返回:
        - array[float]: 每组交换控制比特的 Pauli-Z 期望值。
        """
        # 控制比特为 q0 和 q1
        control_qubits = [0, 1]
    
        # 定义各组的量子比特索引和旋转角度
        encoding_data = [
            {
                'data_qubits': {'q2': 2, 'q3': 3},
                'swap_qubit': 4,
                'angles_q2': [1.0, 3.0, 5.0, 7.0],
                'angles_q3': [2.0, 4.0, 6.0, 8.0]
            },
            {
                'data_qubits': {'q2': 5, 'q3': 6},
                'swap_qubit': 7,
                'angles_q2': [1.5, 3.5, 5.5, 7.5],
                'angles_q3': [2.5, 4.5, 6.5, 8.5]
            },
            {
                'data_qubits': {'q2': 8, 'q3': 9},
                'swap_qubit': 10,
                'angles_q2': [2.0, 4.0, 6.0, 8.0],
                'angles_q3': [3.0, 5.0, 7.0, 9.0]
            }
        ]
    
        # 对每组数据进行编码
        for idx, data_set in enumerate(encoding_data):
            data_qubits = data_set['data_qubits']
            angles_q2 = data_set['angles_q2']
            angles_q3 = data_set['angles_q3']
            encode_group(control_qubits, data_qubits, angles_q2, angles_q3)
    
        # 对每组数据应用交换操作
        for idx, data_set in enumerate(encoding_data):
            swap_qubit = data_set['swap_qubit']
            data_qubits = data_set['data_qubits']
            apply_controlled_swap(swap_qubit, data_qubits['q3'], data_qubits['q2'])
    
        # 应用 Rot 层
        # 这里假设 weights 的形状为 (n_layers, n_qubits, 3)
        for layer in range(weights.shape[0]):
            for qubit in range(weights.shape[1]):
                qml.Rot(weights[layer, qubit, 0],
                        weights[layer, qubit, 1],
                        weights[layer, qubit, 2],
                        wires=qubit)
    
        # 测量每个交换控制比特的 Pauli-Z 期望值
        results = [qml.expval(qml.PauliZ(data_set['swap_qubit'])) for data_set in encoding_data]
    
        return results
    
    # 定义一个量子神经网络层
    class QuantumNeuralNetworkLayer(tf.keras.layers.Layer):
        def __init__(self, n_qubits, n_layers, num_classes, **kwargs):
            super(QuantumNeuralNetworkLayer, self).__init__(**kwargs)
            self.n_qubits = n_qubits
            self.n_layers = n_layers
            self.num_classes = num_classes
    
            # Initialize weights
            weights_shape = (n_layers, n_qubits, 3)
            self.weights_qnn = self.add_weight(
                shape=weights_shape,
                initializer=tf.keras.initializers.GlorotUniform(),
                trainable=True,
                name='weights_qnn'
            )
    
        def call(self, inputs):
            # 使用 tf.map_fn 对每个样本应用量子神经网络
            outputs = tf.map_fn(
                lambda x: quantum_neural_network(x, self.weights_qnn),
                inputs,
                dtype=tf.float32
            )
            return outputs
    
    # 定义一个量子神经网络模型
    class QuantumNeuralNetwork(tf.keras.Model):
        def __init__(self, n_qubits, n_layers, num_classes, **kwargs):
            super(QuantumNeuralNetwork, self).__init__(**kwargs)
            self.n_qubits = n_qubits
            self.n_layers = n_layers
            self.num_classes = num_classes
    
            # Quantum layer
            self.quantum_layer = QuantumNeuralNetworkLayer(n_qubits, n_layers, num_classes)
    
            # Classical layers
            self.dense = Dense(num_classes, activation='softmax')
    
        def call(self, inputs):
            q_output = self.quantum_layer(inputs)
            return self.dense(q_output)
    
    if __name__ == "__main__":
        parser = get_parser("Train model on Iris dataset")
        args = parser.parse_args()
    
        iris = load_iris()
        X = iris['data'].astype(np.float32)
        y = iris['target'].reshape(-1, 1)
    
        encoder = OneHotEncoder(sparse_output=False)
        y = encoder.fit_transform(y).astype(np.float32)
    
        x_train, x_test, y_train, y_test = train_test_split(
            X, y, test_size=0.3, random_state=116
        )
    
        learning_rate = 0.05
        epochs = 100
        batch_size = 8
        num_classes = 3
        n_qubits = 11  # 调整为11个量子比特(0到10)
        n_layers = 2
    
        model = QuantumNeuralNetwork(
            n_qubits=n_qubits,
            n_layers=n_layers,
            num_classes=num_classes
        )
    
        model.compile(
            optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate),
            loss='categorical_crossentropy',
            metrics=['accuracy']
        )
    
        def is_quantum_model(model):
            for layer in model.layers:
                if isinstance(layer, QuantumNeuralNetworkLayer):
                    return True
            return False
    
        if is_quantum_model(model):
            print("The model contains a Quantum Neural Network (QNN) layer.")
        else:
            print("The model does not contain a Quantum Neural Network (QNN) layer.")
    
        print("\nQuantum Circuit Diagram:")
        sample_inputs = np.ones(n_qubits, dtype=np.float32) * 0.0  # 示例输入
        sample_weights = np.zeros((n_layers, n_qubits, 3), dtype=np.float32)  # 示例权重
        print(qml.draw(quantum_neural_network)(sample_inputs, sample_weights))
    
        if args.importance_training:
            wrapped_model = ConstantTimeImportanceTraining(model, score="loss")
            history = wrapped_model.fit(
                x_train, y_train,
                batch_size=batch_size,
                epochs=epochs,
                verbose=1,
                validation_data=(x_test, y_test)
            )
        else:
            history = model.fit(
                x_train, y_train,
                batch_size=batch_size,
                epochs=epochs,
                verbose=1,
                validation_data=(x_test, y_test)
            )
    
        score = model.evaluate(x_test, y_test, verbose=0)
        print('Test loss:', score[0])
        print('Test accuracy:', score[1])
    
        mean_accuracy, fluctuation = calculate_accuracy_fluctuation(history)
        print('Mean validation accuracy:', mean_accuracy)
        print('Accuracy fluctuation:', fluctuation)
    
        plot_history(history)
    
        # 关闭输出文件并恢复stdout
        sys.stdout = original_stdout
        output_file.close()
    
    print("脚本执行完成。查看 'output.log' 获取打印输出,查看当前目录获取保存的图表。")
    

    关键修改点

    1. 量子神经网络层的 call 方法:

      def call(self, inputs):
          # 使用 tf.map_fn 对每个样本应用量子神经网络
          outputs = tf.map_fn(
              lambda x: quantum_neural_network(x, self.weights_qnn),
              inputs,
              dtype=tf.float32
          )
          return outputs
      

      通过 tf.map_fn,我们对批量中的每个样本单独调用量子节点 quantum_neural_network,确保输出的形状为 (batch_size, 3),从而满足 Dense 层的输入要求。

    2. 量子节点的输入:

      确保输入传递给量子节点时是单个样本的特征向量,而不是整个批量。

    3. 数据形状的一致性:

      保证所有数据在传递过程中维度的一致性,避免批量和非批量输入混用导致的维度错误。

    测试与验证

    完成上述修改后,建议您进行以下测试:

    1. 单样本测试:

      手动测试单个样本的前向传播,确保量子层和密集层的连接正常。

    2. 批量输入测试:

      使用小批量数据运行模型,检查输出形状是否正确,并确保没有维度不匹配的错误。

    3. 完整训练和评估:

      运行完整的训练和评估流程,确保模型能够正常训练并获得合理的性能指标。

    总结

    通过上述修改,您已确保量子神经网络层能够正确处理批量输入,并输出符合 Dense 层要求的二维张量。这样,训练过程中的形状不匹配错误应得到解决。如果在应用这些修改后仍然遇到问题,请检查其他可能影响形状的操作,或提供更多的错误信息以进一步诊断。