from future import printfunction import os os.environ['TFUSELEGACYKERAS'] = '1' from…
- User
from future import print_function import os os.environ['TF_USE_LEGACY_KERAS'] = '1' from tensorflow.python.keras.models import Sequential from tensorflow.python.keras.layers import Dense, Activation import tensorflow as tf from tensorflow.python.keras.regularizers import l2 from tensorflow.python.keras import backend as K from tensorflow.python.keras.optimizer_v2.adam import Adam from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.preprocessing import OneHotEncoder from sklearn.metrics import roc_curve, auc import numpy as np import matplotlib.pyplot as plt
from importance_sampling.training import ConstantTimeImportanceTraining from example_utils import get_parser
def plot_history(history): plt.figure(figsize=(12, 5))
# 绘制训练集和验证集的准确率 plt.subplot(121) plt.plot(history.history['accuracy']) plt.plot(history.history['val_accuracy']) plt.title('Model accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Validation'], loc='upper left') # 绘制训练集和验证集的损失 plt.subplot(122) plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Validation'], loc='upper left') plt.tight_layout() plt.show()def plot_roc_curve(y_test, y_pred): n_classes = y_test.shape[1] fpr = dict() tpr = dict() roc_auc = dict()
for i in range(n_classes): fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_pred[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) # Compute micro-average ROC curve and ROC area fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_pred.ravel()) roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) plt.figure() plt.plot(fpr["micro"], tpr["micro"], label='micro-average ROC curve (area = {0:0.2f})' ''.format(roc_auc["micro"])) for i in range(n_classes): plt.plot(fpr[i], tpr[i], label='ROC curve of class {0} (area = {1:0.2f})' ''.format(i, roc_auc[i])) plt.plot([0, 1], [0, 1], 'k--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver Operating Characteristic (ROC) Curve') plt.legend(loc="lower right") plt.show()def calculate_accuracy_fluctuation(history): # 获取每个 epoch 的验证集准确率 val_accuracies = history.history['val_accuracy']
# 计算平均准确率 mean_accuracy = np.mean(val_accuracies) # 计算每个 epoch 的准确率波动(与均值的绝对差值) fluctuation = np.sum(np.abs(val_accuracies - mean_accuracy)) return mean_accuracy, fluctuationif name == "main": parser = get_parser("Train a model on Iris dataset") args = parser.parse_args()
# 导入数据,分别为输入特征和标签 iris = datasets.load_iris() x_data = iris.data y_data = iris.target.reshape(-1, 1) # 使用OneHotEncoder进行标签的独热编码 encoder = OneHotEncoder(sparse_output=False) y_data = encoder.fit_transform(y_data) # 分割数据集为训练集和测试集 x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.3, random_state=116) # 定义神经网络的超参数 learning_rate = 0.1 epochs = 100 batch_size = 8 num_classes = 3 # 鸢尾花数据集有3个类别 # 定义神经网络模型 model = Sequential() model.add(Dense(10, activation='relu', input_shape=(4,), kernel_regularizer=l2(1e-5))) model.add(Dense(num_classes, kernel_regularizer=l2(1e-5))) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer=Adam(learning_rate=learning_rate), metrics=['accuracy']) # 在初始化 ConstantTimeImportanceTraining 之前构建模型 model.predict(np.zeros((1, 4))) # 这里用模型的输入形状(1, 4) # 使用重要性采样训练或常规训练 if args.importance_training: wrapped = ConstantTimeImportanceTraining(model) else: wrapped = model history = wrapped.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) # 计算预测概率 y_pred = model.predict(x_test) # 绘制ROC曲线 plot_roc_curve(y_test, y_pred)上述代码调用class ConstantTimeImportanceTraining(_UnbiasedImportanceTraining): """主要目的是通过保持每次迭代的时间常量的同时,提高梯度的质量来加速模型训练。
Arguments --------- model: The Keras model to train score: {"gnorm", "loss", "full_gnorm"}, the importance metric to use for importance sampling layer: None or int or Layer, the layer to compute the gnorm with """ def __init__(self, model, backward_time=2.0, score="gnorm", layer=None): self._backward_time = backward_time super(ConstantTimeImportanceTraining, self).__init__( model, score, layer ) def sampler(self, dataset, batch_size, steps_per_epoch, epochs): return ConstantTimeSampler( dataset, self.reweighting, self.model, backward_time=self._backward_time )class _UnbiasedImportanceTraining(_BaseImportanceTraining): def init(self, model, score="gnorm", layer=None): self._reweighting = BiasedReweightingPolicy(1.0) # no bias
super(_UnbiasedImportanceTraining, self).__init__(model, score, layer) @property def reweighting(self): return self._reweightingclass _BaseImportanceTraining(object): def init(self, model, score="gnorm", layer=None): """Abstract base class for training a model using importance sampling.
Arguments --------- model: The Keras model to train """ # Wrap and transform the model so that it outputs the importance scores # and can be used in an importance sampling training scheme self._check_model(model) self.original_model = model self.model = OracleWrapper( model, self.reweighting, score=score, layer=layer ) self.original_model.optimizer = self.model.optimizer signal("is.sample").connect(self._on_sample) signal("is.score").connect(self._on_scores) def _on_sample(self, event): self._latest_sample_event = event def _on_scores(self, scores): self._latest_scores = scores def _check_model(self, model): """Check if the model uses Dropout and BatchNorm and warn that it may affect the importance calculations.""" if any( isinstance(l, (tf.keras.layers.BatchNormalization, Dropout)) for l in model.layers ): sys.stderr.write(("[NOTICE]: You are using BatchNormalization " "and/or Dropout.\nThose layers may affect the " "importance calculations and you are advised " "to exchange them for LayerNormalization or " "BatchNormalization in test mode and L2 " "regularization.\n")) @property def reweighting(self): """The reweighting policy that controls the bias of the estimation when using importance sampling.""" raise NotImplementedError() def sampler(self, dataset, batch_size, steps_per_epoch, epochs): """Create a new sampler to sample from the given dataset using importance sampling.""" raise NotImplementedError() def fit(self, x, y, batch_size=32, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, steps_per_epoch=None, on_sample=None, on_scores=None): """Create an `InMemoryDataset` instance with the given data and train the model using importance sampling for a given number of epochs. Arguments --------- x: Numpy array of training data or list of numpy arrays y: Numpy array of target data batch_size: int, number of samples per gradient update epochs: int, number of times to iterate over the entire training set verbose: {0, >0}, whether to employ the progress bar Keras callback or not callbacks: list of Keras callbacks to be called during training validation_split: float in [0, 1), percentage of data to use for evaluation validation_data: tuple of numpy arrays, Data to evaluate the trained model on without ever training on them steps_per_epoch: int or None, number of gradient updates before considering an epoch has passed on_sample: callable that accepts the sampler, idxs, w, scores on_scores: callable that accepts the sampler and scores Returns ------- A Keras `History` object that contains information collected during training. """ # Create two data tuples from the given x, y, validation_* if validation_data is not None: x_train, y_train = x, y x_test, y_test = validation_data elif validation_split > 0: assert validation_split < 1, "100% of the data used for testing" n = int(round(validation_split * len(x))) idxs = np.arange(len(x)) np.random.shuffle(idxs) x_train, y_train = x[idxs[n:]], y[idxs[n:]] x_test, y_test = x[idxs[:n]], y[idxs[:n]] else: x_train, y_train = x, y x_test, y_test = np.empty(shape=(0, 1)), np.empty(shape=(0, 1)) # Make the dataset to train on dataset = InMemoryDataset( x_train, y_train, x_test, y_test, categorical=False # this means use the targets as is ) return self.fit_dataset( dataset=dataset, batch_size=batch_size, epochs=epochs, steps_per_epoch=steps_per_epoch, verbose=verbose, callbacks=callbacks, on_sample=on_sample, on_scores=on_scores ) def fit_generator(self, train, steps_per_epoch=None, batch_size=32, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, on_sample=None, on_scores=None): """Create a GeneratorDataset instance and train the model using importance sampling for a given number of epochs. Arguments --------- train: A generator or iterable that returns tuples (inputs, targets) steps_per_epoch: int, number of gradient updates before considering an epoch has passed batch_size: int, the number of samples per gradient update epochs: int, multiplied by steps_per_epoch denotes the total number of gradient updates verbose: {0, >0}, whether to use the progress bar Keras callback validation_data: generator, iterable or tuple (inputs, targets) validation_steps: None or int, used only if validation_data is a generator on_sample: callable that accepts the sampler, idxs, w, scores on_scores: callable that accepts the sampler and scores """ def infinite_iterator(iterable): while True: yield from iterable # 创建验证数据集 if validation_data is not None: if isinstance(validation_data, (tuple, list)): test = validation_data test_len = None elif isinstance(validation_data, Iterable): test = infinite_iterator(validation_data) try: test_len = len(validation_data) * batch_size except TypeError: test_len = validation_steps * batch_size if validation_steps else None else: test = validation_data test_len = validation_steps * batch_size if validation_steps else None else: test = (np.empty(shape=(0, 1)), np.empty(shape=(0, 1))) test_len = None logging.info("No validation data provided") # 设置训练数据和每个 epoch 的步数 if isinstance(train, Iterable): if steps_per_epoch is None: try: steps_per_epoch = len(train) except TypeError: raise ValueError("steps_per_epoch must be set when using a generator without a __len__ method") train = infinite_iterator(train) elif steps_per_epoch is None: raise ValueError("steps_per_epoch is not set") dataset = GeneratorDataset(train, test, test_len) try: print("dataset.train_data=", len(dataset.train_data)) except Exception as e: print(f"Exception occurred: {e}") return self.fit_dataset( dataset=dataset, batch_size=batch_size, epochs=epochs, steps_per_epoch=steps_per_epoch, verbose=verbose, callbacks=callbacks, on_sample=on_sample, on_scores=on_scores ) def fit_dataset(self, dataset, steps_per_epoch=None, batch_size=32, epochs=1, verbose=1, callbacks=None, on_sample=None, on_scores=None): """Train the model on the given dataset for a given number of epochs. Arguments --------- dataset: Instance of `BaseDataset` that provides the data to train on. steps_per_epoch: int or None, number of gradient updates before considering an epoch has passed. If None it is set to be `len(dataset.train_data) / batch_size`. batch_size: int, number of samples per gradient update epochs: int, number of times to iterate `steps_per_epoch` times verbose: {0, >0}, whether to employ the progress bar Keras callback or not callbacks: list of Keras callbacks to be called during training on_sample: callable that accepts the sampler, idxs, w, scores on_scores: callable that accepts the sampler and scores """ try: if len(dataset.train_data) < batch_size: raise ValueError(("The model cannot be trained with " "batch_size > training set")) except RuntimeError as e: assert "no size" in str(e) # Set steps_per_epoch properly if steps_per_epoch is None: steps_per_epoch = len(dataset.train_data) // batch_size # Create the callbacks list # 这段代码的目的是配置和初始化训练过程中将要使用的一组回调函数(callbacks)。 # 回调函数是在训练的不同阶段被自动调用的函数,用于执行特定的任务,如记录训练指标、 # 保存模型、早停(early stopping)等 self.history = History() # History是一个回调(Callback),用于在训练过程中记录各种指标(如损失、准确率等)的值 callbacks = [BaseLogger()] + (callbacks or []) + [self.history] if verbose > 0: # 添加 ProgbarLogger 回调。ProgbarLogger 用于在终端输出一个进度条,显示训练过程的进度。 callbacks += [ProgbarLogger(count_mode="steps")] callbacks = CallbackList(callbacks) callbacks.set_model(self.original_model) callbacks.set_params({ # 设置训练过程的参数 "epochs": epochs, # 总共的训练轮数 "steps": steps_per_epoch, # 每个 epoch 的步数 "verbose": verbose, # 详细程度 "do_validation": len(dataset.test_data) > 0, # 是否进行验证 "metrics": self.metrics_names + [ # 评估指标 "val_" + n for n in self.metrics_names ] }) # 创建采样器 sampler = self.sampler(dataset, batch_size, steps_per_epoch, epochs) # Start the training loop epoch = 0 self.original_model.stop_training = False callbacks.on_train_begin() while epoch < epochs: # 在每个 epoch 开始时执行一些操作 , # 它会遍历所有在 CallbackList 中注册的回调函数,并调用它们的 on_epoch_begin 方法。 callbacks.on_epoch_begin(epoch) for step in range(steps_per_epoch): # epoch中的每一step都需要做如下循环 batch_logs = {"batch": step, "size": batch_size} # 存储当前批次(batch)训练过程中的相关信息。 callbacks.on_batch_begin(step, batch_logs) # Importance sampling is done here idxs, (x, y), w = sampler.sample(batch_size) # 返回被采样的样本 # Train on the sampled data loss, metrics, scores = self.model.train_batch(x, y, w) # Update the sampler sampler.update(idxs, scores) values = map(lambda x: x.mean(), [loss] + metrics) for l, o in zip(self.metrics_names, values): batch_logs[l] = o callbacks.on_batch_end(step, batch_logs) if on_scores is not None and hasattr(self, "_latest_scores"): on_scores( sampler, self._latest_scores ) if on_sample is not None: on_sample( sampler, self._latest_sample_event["idxs"], self._latest_sample_event["w"], self._latest_sample_event["predicted_scores"] ) if self.original_model.stop_training: break # Evaluate now that an epoch passed epoch_logs = {} if len(dataset.test_data) > 0: val = self.model.evaluate( *dataset.test_data[:], batch_size=batch_size ) epoch_logs = { "val_" + l: o for l, o in zip(self.metrics_names, val) } callbacks.on_epoch_end(epoch, epoch_logs) if self.original_model.stop_training: break epoch += 1 callbacks.on_train_end() return self.history @property def metrics_names(self): def name(x): if isinstance(x, str): return x if hasattr(x, "name"): return x.name if hasattr(x, "__name__"): return x.__name__ return str(x) metrics = self.original_model.metrics or [] return ( ["loss"] + [name(m) for m in metrics] + ["score"] )class OracleWrapper(ModelWrapper): AVG_LOSS = 0 LOSS = 1 WEIGHTED_LOSS = 2 SCORE = 3 METRIC0 = 4
FUSED_ACTIVATION_WARNING = ("[WARNING]: The last layer has a fused " "activation i.e. Dense(..., " "activation=\"sigmoid\").\nIn order for the " "preactivation to be automatically extracted " "use a separate activation layer (see " "examples).\n") def __init__(self, model, reweighting, score="loss", layer=None): self.reweighting = reweighting self.layer = self._gnorm_layer(model, layer) # Augment the model with reweighting, scoring etc # Save the new model and the training functions in member variables self._augment_model(model, score, reweighting) def _gnorm_layer(self, model, layer): # If we were given a layer then use it directly if isinstance(layer, Layer): return layer # If we were given a layer index extract the layer if isinstance(layer, int): return model.layers[layer] try: # Get the last or the previous to last layer depending on wether # the last has trainable weights skip_one = not bool(model.layers[-1].trainable_weights) last_layer = -2 if skip_one else -1 # If the last layer has trainable weights that means that we cannot # automatically extract the preactivation tensor so we have to warn # them because they might be missing out or they might not even # have noticed if last_layer == -1: config = model.layers[-1].get_config() if config.get("activation", "linear") != "linear": sys.stderr.write(self.FUSED_ACTIVATION_WARNING) return model.layers[last_layer] except: # In case of an error then probably we are not using the gnorm # importance return None def _augment_model(self, model, score, reweighting): # Extract some info from the model loss = model.loss optimizer = model.optimizer.__class__(**model.optimizer.get_config()) output_shape = model.get_output_shape_at(0)[1:] if isinstance(loss, str) and loss.startswith("sparse"): output_shape = output_shape[:-1] + (1,) # Make sure that some stuff look ok assert not isinstance(loss, list) # We need to create two more inputs # 1. the targets # 2. the predicted scores y_true = Input(shape=output_shape) pred_score = Input(shape=(reweighting.weight_size,)) # Create a loss layer and a score layer loss_tensor = LossLayer(loss)([y_true, model.get_output_at(0)]) score_tensor = _get_scoring_layer( score, y_true, model.get_output_at(0), loss, self.layer, model ) # Create the sample weights weights = reweighting.weight_layer()([score_tensor, pred_score]) # Create the output weighted_loss = weighted_loss_model = multiply([loss_tensor, weights]) for l in model.losses: weighted_loss += l weighted_loss_mean = K.mean(weighted_loss) # Create the metric layers metrics = model.metrics or [] metrics = [ MetricLayer(metric)([y_true, model.get_output_at(0)]) for metric in metrics ] # Create a model for plotting and providing access to things such as # trainable_weights etc. new_model = Model( inputs=_tolist(model.get_input_at(0)) + [y_true, pred_score], outputs=[weighted_loss_model] ) # Build separate on_batch keras functions for scoring and training updates = optimizer.get_updates( weighted_loss_mean, new_model.trainable_weights ) metrics_updates = [] if hasattr(model, "metrics_updates"): metrics_updates = model.metrics_updates learning_phase = [] if weighted_loss_model._uses_learning_phase: learning_phase.append(K.learning_phase()) inputs = _tolist(model.get_input_at(0)) + [y_true, pred_score] + \ learning_phase outputs = [ weighted_loss_mean, loss_tensor, weighted_loss, score_tensor ] + metrics train_on_batch = K.function( inputs=inputs, outputs=outputs, updates=updates + model.updates + metrics_updates ) evaluate_on_batch = K.function( inputs=inputs, outputs=outputs, updates=model.state_updates + metrics_updates ) self.model = new_model self.optimizer = optimizer self.model.optimizer = optimizer self._train_on_batch = train_on_batch self._evaluate_on_batch = evaluate_on_batch上述代码报错Traceback (most recent call last): File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\examples\yuanweihua.py", line 264, in wrapped = ConstantTimeImportanceTraining(model) File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\training.py", line 466, in init super(ConstantTimeImportanceTraining, self).init( File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\training.py", line 363, in init super(_UnbiasedImportanceTraining, self).init(model, score, layer) File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\training.py", line 40, in init self.model = OracleWrapper( File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\model_wrappers.py", line 172, in init self._augment_model(model, score, reweighting) File "C:\代码备份库\importance-sampling-master-yuanweihua-QNN-pennylane\importance_sampling\model_wrappers.py", line 228, in _augment_model loss_tensor = LossLayer(loss)([y_true, model.get_output_at(0)]) File "C:\Users\liuwenjing.conda\envs\pennylane_qiskit\lib\site-packages\tensorflow\python\keras\engine\base_layer.py", line 2055, in get_output_at return self._get_node_attribute_at_index(node_index, 'output_tensors', File "C:\Users\liuwenjing.conda\envs\pennylane_qiskit\lib\site-packages\tensorflow\python\keras\engine\base_layer.py", line 2613, in _get_node_attribute_at_index raise RuntimeError('The layer has never been called ' RuntimeError: The layer has never been called and thus has no defined output. 如何进行解决
- Assistant
The error you're encountering is due to the way the model is being defined and built. Specifically, when you call
model.get_output_at(0), Keras expects the model to have been built in such a way that it knows its outputs. In your code, the model is defined using the Sequential API, and although you attempted to build it by callingmodel.predict(np.zeros((1, 4))), it seems this is not enough to register the model's output in the way required byget_output_at(0).The
ConstantTimeImportanceTrainingclass, and specifically theOracleWrapperwithin it, expects a model that has been built using the Functional API. This is because the Functional API creates a computational graph where inputs and outputs are explicitly defined, allowing methods likeget_output_at(0)to work properly.To resolve the issue, you should redefine your model using the Functional API instead of the Sequential API. Here's how you can modify your code:
# Import necessary modules from tensorflow.keras from tensorflow.keras.layers import Input, Dense, Activation from tensorflow.keras.models import Model # Define the model using Functional API inputs = Input(shape=(4,)) x = Dense(10, activation='relu', kernel_regularizer=l2(1e-5))(inputs) x = Dense(num_classes, kernel_regularizer=l2(1e-5))(x) outputs = Activation('softmax')(x) # Create the Model object model = Model(inputs=inputs, outputs=outputs) # Compile the model as before model.compile(loss='categorical_crossentropy', optimizer=Adam(learning_rate=learning_rate), metrics=['accuracy']) # The model is now properly built and can be used with ConstantTimeImportanceTraining # No need to call model.predict or model.build explicitlyBy defining the model using the Functional API, you ensure that the model's inputs and outputs are properly connected and recognized by Keras. This should resolve the error you're encountering when
get_output_at(0)is called within theOracleWrapper.Here's the updated main part of your script with the model defined using the Functional API:
if __name__ == "__main__": # ... (previous code remains the same) # Define the model using Functional API inputs = Input(shape=(4,)) x = Dense(10, activation='relu', kernel_regularizer=l2(1e-5))(inputs) x = Dense(num_classes, kernel_regularizer=l2(1e-5))(x) outputs = Activation('softmax')(x) model = Model(inputs=inputs, outputs=outputs) # Compile the model model.compile(loss='categorical_crossentropy', optimizer=Adam(learning_rate=learning_rate), metrics=['accuracy']) # Now initialize ConstantTimeImportanceTraining without any issues wrapped = ConstantTimeImportanceTraining(model) # Proceed with the rest of your code history = wrapped.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) # ... (rest of your code)With these changes, your model should be compatible with the
ConstantTimeImportanceTrainingclass, and the error should be resolved. This approach ensures that the model's computational graph is fully defined, and methods likeget_output_at(0)can successfully retrieve the model's outputs.Explanation:
- Why the error occurs: The error message indicates that the model hasn't been called and therefore doesn't have a defined output. This happens because the
Sequentialmodel doesn't have explicit input and output tensors until it's built by being called on some input. - Why the Functional API works: In the Functional API, you define the model by specifying the input and output tensors explicitly, so Keras knows the computational graph from the beginning.
- Why
model.predict(np.zeros((1, 4)))didn't help: While this line attempts to build the model by calling it, it doesn't always properly register the model outputs for use with methods likeget_output_at(0), especially in the context of model wrappers and custom training loops that expect models built using the Functional API. - Conclusion: By defining the model using the Functional API, you provide the necessary structure and explicitly define the input and output tensors, resolving the error.
- Why the error occurs: The error message indicates that the model hasn't been called and therefore doesn't have a defined output. This happens because the