def __train_manual(self): # 手动训练 optimizer = optimizers.Adam(learning_rate=0.001) # 使用 Adam 优化器,恒定学习率 acc_meter = metrics.Accuracy() # 使用准确率评价器 epochs = 10 # 使用 10 个Epoch steps = 500 # 每个 Epoch 训练 500 步 for epoch in range(epochs): with trange(steps, desc="Epoch {}: ".format(epoch)) as t: for step in t: with tf.GradientTape() as tape: train_x = tf.reshape(self.train_x, (-1, 28 * 28)) # 将输入的图像转换为一维向量 out = self.model(train_x) # 获得经过模型的输出 loss = tf.reduce_mean( tf.square(out - self.train_y)) # 使用简单的 MSE 损失函数 # 计算准确度 acc_meter.update_state(tf.argmax(out, axis=1), tf.argmax(self.train_y, axis=1)) # 更新准确度和损失信息 info_part_1 = "Loss: {:.4f} Acc:{:.2f}% ".format( loss, acc_meter.result().numpy() * 100) # 更新输出,这里使用了进度条输出,更加好看一点 t.set_postfix_str(info_part_1) # 计算梯度 grads = tape.gradient(loss, self.model.trainable_variables) # 进行梯度下降 optimizer.apply_gradients( zip(grads, self.model.trainable_variables)) # 每个 Epoch 的最后在测试集上进行测试 if step == steps - 1: # 获取经过神经网络的输出 out = self.model(self.test_x) loss = tf.reduce_mean(tf.square(out - self.test_y)) # 计算准确度 test_acc_meter = metrics.Accuracy() test_acc_meter.update_state( tf.argmax(out, axis=1), tf.argmax(self.test_y, axis=1)) # 计算输出信息 info_part_2 = "In test dataset, Loss: {:.4f}," \ " Acc: {:.2f}%".format(float(loss), test_acc_meter.result().numpy() * 100) # 更新输出信息 t.set_postfix_str(info_part_1 + info_part_2)
def train_epoch(epoch, train_dataset, model, optimizer): summary_writer = tf.summary.create_file_writer(logdir='log') loss_meter = metrics.Mean() acc_meter = metrics.Accuracy() for step, (x, y) in enumerate(train_dataset): #记录下所有可训练变量的梯度,以便下一步更新 with tf.GradientTape() as tape: x = tf.reshape(x, (-1, 28 * 28)) out = model(x) acc_meter.update_state(y, out) #计算单个方差 loss = tf.square(out - y) #张量求和,也就是计算所有图片的均方误差和,计算均方差 loss = tf.reduce_mean(loss) loss_meter.update_state(float(loss)) #获取每个变量对应的梯度值 grads = tape.gradient(loss, model.trainable_variables) #根据每个变量的梯度值,更新相关变量的模型参数 optimizer.apply_gradients(zip(grads, model.trainable_variables)) with summary_writer.as_default(): tf.summary.scalar('train-loss', loss_meter.result(), step=100) tf.summary.scalar('test-acc', acc_meter.result(), step=100) #显示每训练100张图片之后的loss值 if (step % 100 == 0): print(epoch, step, 'loss:', loss) return model
def sfd_model(optimizer, learning_rate): ''' nvidia self driving car inspired architecture. ''' if optimizer == 'adagrad': optimizer = Adagrad(lr=learning_rate) elif optimizer == 'sgd': optimizer = SGD(lr=learning_rate) elif optimizer == 'rmsprop': optimizer = RMSprop(lr=learning_rate) else: optimizer = Adam(lr=learning_rate) model = Sequential() model.add(Conv2D(24, 5, 2, input_shape=(66, 200, 3), activation='elu')) model.add(Conv2D(36, 5, 2, activation='elu')) model.add(Conv2D(48, 5, 2, activation='elu')) model.add(Conv2D(64, 3, activation='elu')) model.add(Conv2D(64, 3, activation='elu')) # model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(128, activation='elu')) # model.add(Dropout(0.5)) model.add(Dense(64, activation='elu')) model.add(Dropout(0.5)) model.add(Dense(16, activation='elu')) model.add(Dropout(0.5)) model.add(Dense(1)) model.compile(loss='mse', optimizer=optimizer, metrics=metrics.Accuracy(name='Accuracy')) return model
def confusion_matrix_other_metric(self): return [ metrics.Accuracy(name='acc'), metrics.Precision(name='precision'), metrics.Recall(name='recall'), metrics.AUC(name='auc'), ]
def data_init(): #数据预处理 (x_train, y_train), (x_test, y_test) = datasets.mnist.load_data() x_train = 2 * tf.convert_to_tensor(x_train, dtype=tf.float32) / 255 - 1 x_test = 2 * tf.convert_to_tensor(x_test, dtype=tf.float32) / 255 - 1 y_train = tf.convert_to_tensor(y_train, dtype=tf.int32) y_test = tf.convert_to_tensor(y_test, dtype=tf.int32) '''手写数字集用作神经网络训练数据集进行分类,由于是多分类,将分类结果分成10种,将分类结果用一个一维数组表示:即为onehot编码, 例如分类结果为6,onehot编码结果【0,0,0,0,0,0,1,0,0,0】 ''' y_train = tf.one_hot(y_train, depth=10, on_value=None, off_value=None) y_test = tf.one_hot(y_test, depth=10, on_value=None, off_value=None) # print(y_train.shape[0] , y_train.shape[0]) train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)) ##将训练数据分为200片,每片300张图片进行并行训练 ##每片执行一次后再执行一次 train_dataset = train_dataset.batch(200) test_dataset = test_dataset.batch(200) ##设置学习率,随机梯度下降 optimizer = optimizers.SGD(learning_rate=0.001) #建立测量尺,计算精度函数 acc_meter = metrics.Accuracy() return train_dataset, x_train, x_test, y_test, optimizer, acc_meter
def __init__(self): super(kerasModel, self).__init__() self.layersList = [] self.layersList.append( kl.Dense(9, activation="relu", input_shape=(4, ), use_bias=False, kernel_initializer=ki.VarianceScaling(), name="dense_1")) self.layersList.append( kl.Dense(1, activation="sigmoid", kernel_initializer=ki.VarianceScaling(), use_bias=False, name="out")) self.loss = discountedLoss() self.optimizer = ko.Adam(lr=1e-2) self.train_loss = kme.Mean(name='train_loss') self.validation_loss = kme.Mean(name='val_loss') self.metric = kme.Accuracy(name="accuracy") @tf.function() def predict(x): """ This is where we run through our whole dataset and return it, when training and testing. """ for l in self.layersList: x = l(x) return x self.predict = predict @tf.function() def train_step(x, labels, adv): """ This is a TensorFlow function, run once for each epoch for the whole input. We move forward first, then calculate gradients with Gradient Tape to move backwards. """ with tf.GradientTape() as tape: predictions = self.predict(x) loss = self.loss.call(y_true=labels, y_pred=predictions, adv=adv) gradients = tape.gradient(loss, self.trainable_variables) self.optimizer.apply_gradients( zip(gradients, self.trainable_variables)) self.train_loss(loss) return loss self.train_step = train_step
def main(): # 加载MNIST数据集 (x, y), (x_val, y_val) = datasets.mnist.load_data() # 转换为浮点张量,并缩放到-1~1 x = 2 * tf.convert_to_tensor(x, dtype=tf.float32) / 255. - 1 # 构建数据集对象 train_dataset = tf.data.Dataset.from_tensor_slices((x, y)) # 批量训练 train_dataset = train_dataset.batch(512) # 网络搭建 # 利用Sequential容器封装3个网络层,前网络层的输出默认作为下一层的输入 # 3个非线性层的嵌套模型 model = Sequential([ # 隐藏层1 layers.Dense(256, activation="relu"), # 隐藏层2 layers.Dense(128, activation="relu"), # 输出层,输出节点数为10 layers.Dense(10) ]) # 构建网络模型,规定输入样本形状 model.build(input_shape=(4, 28 * 28)) # 打印网络模型信息 model.summary() # 优化器 optimizer = optimizers.SGD(lr=0.01) # 度量准确度 acc = metrics.Accuracy() for step, (x, y) in enumerate(train_dataset): # 构建梯度记录环境 with tf.GradientTape() as tape: # 打平数据,[b, 28, 28] => [b, 784] x = tf.reshape(x, (-1, 28 * 28)) # 得到模型输出 out = model(x) y_onehot = tf.one_hot(y, depth=10) # 计算差的平方和 loss = tf.square(out - y_onehot) # 计算每个样本的平均误差 loss = tf.reduce_sum(loss) / x.shape[0] # 更新准确度 acc.update_state(tf.argmax(out, axis=1), y) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) if step % 20 == 0: # 输出损失并计算准确度 print(step, 'loss:', float(loss), 'acc:', acc.result().numpy()) # 重置准确度 acc.reset_states()
def build_simple_model(dataset='Fashion Mnist', opt='sgd', hidden=None, funcs=None, loss=None, metrics_list=None): model = models.Sequential() if dataset == 'CIFAR-10': model.add(layers.Flatten(input_shape=[32, 32, 3])) elif ('Fashion Mnist'): model.add(layers.Flatten(input_shape=[28, 28])) for i in hidden.keys(): model.add(layers.Dense(hidden[i], activation=funcs[i].lower())) model.add(layers.Dense(10, activation="softmax")) loss_dict = { 'Categorical Crossentropy': 'categorical_crossentropy', 'Binary Crossentropy': 'binary_crossentropy', 'Categorical Hinge': 'categorical_hinge', 'Huber loss': 'huber_loss' } metrics_dict = { 'auc': metrics.AUC(), 'recall': metrics.Recall(), 'accuracy': metrics.CategoricalAccuracy() if loss.startswith('Categorical') else metrics.Accuracy(), 'precision': metrics.Precision(), 'categorical Hinge': metrics.CategoricalHinge(), 'squared Hinge': metrics.SquaredHinge(), 'Kullback-Leibler divergence': metrics.KLDivergence(), 'mean absolute error': metrics.MeanAbsoluteError(), 'mean squared error': metrics.MeanSquaredError() } if metrics_list is not None and len(metrics_list) > 0: metrics_list = [metrics_dict.get(m, m) for m in metrics_list] else: metrics_list = ['accuracy'] loss_f = loss_dict.get(loss) model.compile(loss=loss_f, optimizer=opt, metrics=metrics_list) return model
def __get_metric(self, metric): if metric == "auc": return m.AUC() elif metric == "accuracy": return m.Accuracy() elif metric == "binary_accuracy": return m.BinaryAccuracy() elif metric == "categorical_accuracy": return m.CategoricalAccuracy() elif metric == "binary_crossentropy": return m.BinaryCrossentropy() elif metric == "categorical_crossentropy": return m.CategoricalCrossentropy() elif metric == "sparse_categorical_crossentropy": return m.SparseCategoricalCrossentropy() elif metric == "kl_divergence": return m.KLDivergence() elif metric == "poisson": return m.Poission() elif metric == "mse": return m.MeanSquaredError() elif metric == "rmse": return m.RootMeanSquaredError() elif metric == "mae": return m.MeanAbsoluteError() elif metric == "mean_absolute_percentage_error": return m.MeanAbsolutePercentageError() elif metric == "mean_squared_logarithm_error": return m.MeanSquaredLogarithmError() elif metric == "cosine_similarity": return m.CosineSimilarity() elif metric == "log_cosh_error": return m.LogCoshError() elif metric == "precision": return m.Precision() elif metric == "recall": return m.Recall() elif metric == "true_positive": return m.TruePositives() elif metric == "true_negative": return m.TrueNegatives() elif metric == "false_positive": return m.FalsePositives() elif metric == "false_negative": return m.FalseNegatives() else: raise Exception("specified metric not defined")
def load_simple_model(model_path='', weights_path='', opt='sgd', loss=None, metrics_list=None): model = models.load_model(model_path) model.load_weights(weights_path) loss_dict = { 'Categorical Crossentropy': 'categorical_crossentropy', 'Binary Crossentropy': 'binary_crossentropy', 'Categorical Hinge': 'categorical_hinge', 'Huber loss': 'huber_loss' } metrics_dict = { 'auc': metrics.AUC(), 'recall': metrics.Recall(), 'accuracy': metrics.CategoricalAccuracy() if loss.startswith('Categorical') else metrics.Accuracy(), 'precision': metrics.Precision(), 'categorical Hinge': metrics.CategoricalHinge(), 'squared Hinge': metrics.SquaredHinge(), 'Kullback-Leibler divergence': metrics.KLDivergence(), 'mean absolute error': metrics.MeanAbsoluteError(), 'mean squared error': metrics.MeanSquaredError() } if metrics_list is not None and len(metrics_list) > 0: metrics_list = [metrics_dict.get(m, m) for m in metrics_list] else: metrics_list = ['accuracy'] loss_f = loss_dict.get(loss) model.compile(loss=loss_f, optimizer=opt, metrics=metrics_list) return model
def create_evaluator(self): acc = metrics.Accuracy() @tf.function def evaluate(engine, batch): x, y = batch out = tf.reshape( x, (-1, reduce((lambda a, b: a * b), self.args.img_shape))) for net in self.nets: out = net(out) acc(tf.argmax(out, axis=1), y) evaluator = Engine(evaluate) @evaluator.on(Events.EPOCH_COMPLETED) def summary_per_epoch(engine): tf.summary.scalar('testing/acc', acc.result(), engine.iteration) print(f'Accuracy: {acc.result()}') acc.reset_states() return evaluator
layers.ReLU(), # 激活函数 layers.Conv2D(16, kernel_size=3, strides=1), # 第二个卷积层,16个3*3*6卷积核 layers.MaxPooling2D(pool_size=2, strides=2), # 池化层 layers.ReLU(), # 激活函数 layers.Flatten(), # 拉直,方便全连接层处理 layers.Dense(120, activation='relu'), # 全连接层,120个节点 layers.Dense(84, activation='relu'), # 全连接层,84个节点 layers.Dense(10) # 输出层,10个节点 ]) network.build(input_shape=(None, 28, 28, 1)) # 定义输入,batch_size=32,输入图片大小是28*28,通道数为1。 network.summary() # 显示出每层的待优化参数量 # 3.模型训练(计算梯度,迭代更新网络参数) optimizer = optimizers.SGD(lr=0.01) # 声明采用批量随机梯度下降方法,学习率=0.01 acc_meter = metrics.Accuracy() # 新建accuracy测量器 for step, (x, y) in enumerate(train_dataset): # 一次输入batch组数据进行训练 with tf.GradientTape() as tape: # 构建梯度记录环境 x = tf.reshape(x, (32, 28, 28, 1)) # 将输入拉直,[b,28,28]->[b,784] # x = tf.extand_dims(x, axis=3) out = network(x) # 输出[b, 10] y_onehot = tf.one_hot(y, depth=10) # one-hot编码 loss = tf.square(out - y_onehot) loss = tf.reduce_sum(loss) / 32 # 定义均方差损失函数,注意此处的32对应为batch的大小 grads = tape.gradient(loss, network.trainable_variables) # 计算网络中各个参数的梯度 optimizer.apply_gradients(zip(grads, network.trainable_variables)) # 更新网络参数 acc_meter.update_state(tf.argmax(out, axis=1), y) # 比较预测值与标签,并计算精确度(写入数据,进行求精度)
x = Conv1D(filters=64,kernel_size=27,strides=1,padding='SAME',activation='relu')(encoded) x = UpSampling1D(size = 3)(x) x = Conv1D(filters=32,kernel_size=25,strides=1,padding='SAME',activation='relu')(x) x = UpSampling1D(size = 3)(x) x = Conv1D(filters=16,kernel_size=23,strides=1,padding='SAME',activation='relu')(x) x = UpSampling1D(size = 3)(x) x = Conv1D(filters=4,kernel_size=21,strides=1,padding='SAME',activation='relu')(x) x = UpSampling1D(size = 3)(x) decoded = Conv1D(filters=1, kernel_size=19, strides=1, padding='SAME', activation='sigmoid')(x) ''' autoencoder = Model(input_signal, decoded) #autoencoder.compile(optimizer='adadelta',loss='binary_crossentropy',metrics=['accuracy']) autoencoder.compile(optimizer='sgd', loss='mse', metrics=[metrics.MeanSquaredError(), metrics.Accuracy()]) #autoencoder.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=[metrics.Accuracy()]) #print(noised_nsr,noised_af) X_noisy = np.concatenate((noised_af, noised_nsr), axis=0) X_original = np.concatenate((original_af, original_nsr), axis=0) print('noised X:', X_noisy) print('original X:', X_original) #X_noisy = np.random.shuffle(X_noisy).reshape((1280,)) #X_original = np.random.shuffle(X_original) #print(X_noisy) #print(X_original) serialization('whole noised dataset', X_noisy)
db_test = tf.data.Dataset.from_tensor_slices( (x_test, y_test)).map(preprocess).batch(batchsz) network = Sequential([ layers.Dense(256, activation=tf.nn.relu), layers.Dense(128, activation=tf.nn.relu), layers.Dense(64, activation=tf.nn.relu), layers.Dense(32, activation=tf.nn.relu), layers.Dense(10) ]) network.build(input_shape=[None, 28 * 28]) network.summary() optimizer = optimizers.Adam(learning_rate=1e-2) acc_metrics = metrics.Accuracy() loss_metrics = metrics.Mean() for step, (x, y) in enumerate(db): with tf.GradientTape() as tape: x = tf.reshape(x, [-1, 28 * 28]) out = network(x) y_onehot = tf.one_hot(y, depth=10) pred = tf.nn.softmax(out) loss = tf.reduce_mean( tf.losses.categorical_crossentropy(y_onehot, pred)) loss_metrics.update_state(loss) grads = tape.gradient(loss, network.trainable_variables) optimizer.apply_gradients(zip(grads, network.trainable_variables)) if step % 100 == 0: print(step, "loss:", loss) # 第100步的结果
print("Data Prepared!") # %% class LogisticRegression(models.Model): def __init__(self): super(LogisticRegression, self).__init__() self.d = layers.Dense(1, input_shape=(784, ), activation='sigmoid') def call(self, x): return self.d(x) # Create an instance of the model model = LogisticRegression() loss_object = losses.BinaryCrossentropy() metric = metrics.Accuracy() optimizer = optimizers.Adam() # %% for epoch in range(EPOCHS): epoch_loss, val_loss, val_acc = 0, 0, 0 for batch_x, batch_y in train_ds: with tf.GradientTape() as tape: predictions = model(batch_x, training=True) loss = loss_object(batch_y, predictions) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) epoch_loss += loss for batch_x, batch_y in test_ds:
def train(args): vocab, model_inst, loss_func, opt_inst, target_step = setup_train(args) if args.step == "sup" or args.step == "at": suffix = "lab" mode = "part" else: suffix = "all" mode = "semi" dataset_trn = build_dataset_from_tfrecord(mode,suffix,args.data,args.batch_size1,args.batch_size2\ ,args.buffer_size1,args.buffer_size2,False) dataset_eval = build_dataset_from_tfrecord("eval", suffix, args.data, 128, None, None, None, False) dataset_test = build_dataset_from_tfrecord("test", suffix, args.data, 128, None, None, None, False) ### custom train step 부분 trn_loss_metric = metrics.Mean() # Train loss trn_acc_metric = metrics.Accuracy() # Train Accuracy ckpt_dir = f"model_log/{args.data}/{args.step}/{args.model}" os.makedirs(ckpt_dir, exist_ok=True) log_dir = ckpt_dir + "/train_log.csv" logger_pipe = open(log_dir, "w") logger_pipe.write("epoch,train_loss,train_acc,eval_loss,eval_acc\n") ckpt_manager = tf.train.CheckpointManager(tf.train.Checkpoint(model=model_inst)\ ,directory=ckpt_dir,max_to_keep=1) eval_acc_best = -1e-1 eval_loss_best = 1e10 for epoch in range(args.epochs): pbar = tqdm(dataset_trn) for batch in pbar: if args.step == "sup": func_args = [model_inst, opt_inst, loss_func, batch] elif args.step == "pi": weight = lin_weight(args.start_weight, args.start_weight, 0.05, 0, epoch) func_args = [model_inst, opt_inst, loss_func, batch, weight] elif args.step == "at" or args.step == "vat" or args.step == "both": weight = lin_weight(args.start_weight, args.start_weight, 0.05, 0, epoch) func_args = [ model_inst, opt_inst, loss_func, batch, args.eta, weight ] loss_val, logit, gs = target_step(*func_args) trn_loss_metric.update_state(loss_val) # metrics for training trn_acc_metric.update_state(tf.argmax(batch["lab"]["y"], 1), tf.argmax(logit, 1)) current_loss = trn_loss_metric.result().numpy() current_acc = trn_acc_metric.result().numpy() current_step = gs.numpy() pbar.set_description( f"Epoch {epoch}, Step {current_step:d}, Loss {current_loss:.5f}, Acc {current_acc:.5f}" ) trn_loss_metric.reset_states() trn_acc_metric.reset_states() eval_loss, eval_acc = evaluate(model_inst, dataset_eval, loss_func) print("------[Eval] Loss {:.5f}, Acc {:.5f}".format( eval_loss, eval_acc)) if eval_acc_best < eval_acc: ckpt_manager.save(epoch) eval_acc_best = eval_acc eval_loss_best = eval_loss elif eval_acc_best == eval_acc: if eval_loss_best < eval_loss: pass else: ckpt_manager.save(epoch) eval_acc_best = eval_acc eval_loss_best = eval_loss # https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals logger_pipe.write( f"{epoch!s},{current_loss!s},{current_acc!s},{eval_loss!s},{eval_acc!s}\n" ) ckpt_manager.restore_or_initialize() test_loss, test_acc = evaluate(model_inst, dataset_test, loss_func) print("On test set, Loss {:.5f}, Acc {:.5f}".format(test_loss, test_acc)) logger_pipe.write(f"OnTest,-,-,{test_loss!s},{test_acc!s}\n") logger_pipe.close() return 0
# 第一层 输出维度是128。kernel(即w)为[256, 128] layers.Dense(128, activation=tf.nn.relu), # [b, 256] -> [b,128] layers.Dense(64, activation=tf.nn.relu), # [b, 128] -> [b,64] layers.Dense(32, activation=tf.nn.relu), # [b, 64] -> [b,32] layers.Dense(10) # [b, 32] -> [b,10] ]) # 输入的维度,28*28=784,即和上面的第一层联系起来 network.build(input_shape=[None, 28 * 28]) network.summary() # 调试功能 # 声明优化器 # 他的作用是更新优化参数,即w = w - lr*grad这样更新 optimizer = optimizers.Adam(lr=0.01) # 第一步,新建meter acc_meter = metrics.Accuracy() # 新建一个准确度的meter loss_meter = metrics.Mean() # 新建一个平均值(损失值)的meter # 遍历数据集.由于db一共是60k个数据,而batch是128,所以一共循环60k/128次 for step, (x, y) in enumerate(db): # x:[b, 28, 28],其中b=128,因为batch是128 # y:[b] with tf.GradientTape() as tape: # 对x进行维度变换 x = tf.reshape(x, [-1, 28 * 28]) # [b, 28, 28] -> [b, 784] # 将x传递给构造好的全连接层,这样x[b, 784]->[b, 10] out = network(x) y_onehot = tf.one_hot(y, depth=10)
train_dataset = tf.data.Dataset.from_tensor_slices((x, y)) # 构建数据集对象 train_dataset = train_dataset.batch(32).repeat( 10) # 设置批量训练的batch为32,要将训练集重复训练10遍 # 2.网络搭建 network = Sequential([ layers.Dense(256, activation='relu'), # 第一层 layers.Dense(128, activation='relu'), # 第二层 layers.Dense(10) # 输出层 ]) network.build(input_shape=(None, 28 * 28)) # 输入 # network.summary() # 3.模型训练(计算梯度,迭代更新网络参数) optimizer = optimizers.SGD(lr=0.01) # 声明采用批量随机梯度下降方法,学习率=0.01 acc_meter = metrics.Accuracy() # 创建准确度测量器 for step, (x, y) in enumerate(train_dataset): # 一次输入batch组数据进行训练 with tf.GradientTape() as tape: # 构建梯度记录环境 x = tf.reshape(x, (-1, 28 * 28)) # 将输入拉直,[b,28,28]->[b,784] out = network(x) # 输出[b, 10] y_onehot = tf.one_hot(y, depth=10) # one-hot编码 loss = tf.square(out - y_onehot) loss = tf.reduce_sum(loss) / 32 # 定义均方差损失函数,注意此处的32对应为batch的大小 grads = tape.gradient(loss, network.trainable_variables) # 计算网络中各个参数的梯度 optimizer.apply_gradients(zip(grads, network.trainable_variables)) # 更新网络参数 acc_meter.update_state(tf.argmax(out, axis=1), y) # 比较预测值与标签,并计算精确度 if step % 200 == 0: # 每200个step,打印一次结果 print('Step', step, ': Loss is: ', float(loss), ' Accuracy: ', acc_meter.result().numpy())
def unet_sep(param, input_shape=(1024, 1024, 3), roi_pool_size=[10, 10], chan_num=3, weight_ccpf=[1, 1, 1, 1, 1], projection_dim=100, transformer_layers=4, num_heads=4, is_comp=True, lr=1e-3): num_bbox = param["num_bbox"] input_img = layers.Input(shape=input_shape) input_bbox = layers.Input(shape=(num_bbox, 4)) ## get unet stem model just_unet = strde_unet_xcept_gn_shallow() # just_unet = strde_unet_xcept_gn_deep() # just_unet = strde_sepconv_unet_xcept_gn_shallow() # just_unet = strde_sepconv_unet_xcept_gn_deep() # just_unet = res_unet() ## and classifier model just_trnsf = classify_branch(num_bbox=num_bbox, crypt_class=param['crypt_class']) ## crate instances of models inst_cr, inst_fm = just_unet(input_img) if param['crypt_class']: inst_cl, inst_pa, inst_fu, inst_crcls = just_trnsf( [inst_fm, input_bbox]) ## combine into final model final_model = Model( inputs=[input_img, input_bbox], outputs=[inst_cr, inst_cl, inst_pa, inst_fu, inst_crcls]) losses = { 'crypt': "binary_crossentropy", 'cpf': "binary_crossentropy", 'cpf_1': "binary_crossentropy", 'cpf_2': "binary_crossentropy", 'cpf_3': "binary_crossentropy" } lossWeights = { 'crypt': weight_ccpf[0], 'cpf': weight_ccpf[1], 'cpf_1': weight_ccpf[2], 'cpf_2': weight_ccpf[3], 'cpf_3': weight_ccpf[4] } metrics_use = { 'crypt': metrics.Accuracy(), 'cpf': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ], 'cpf_1': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ], 'cpf_2': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ], 'cpf_3': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ] } else: inst_cl, inst_pa, inst_fu = just_trnsf([inst_fm, input_bbox]) ## combine into final model final_model = Model(inputs=[input_img, input_bbox], outputs=[inst_cr, inst_cl, inst_pa, inst_fu]) losses = { 'crypt': "binary_crossentropy", 'cpf': "binary_crossentropy", 'cpf_1': "binary_crossentropy", 'cpf_2': "binary_crossentropy" } lossWeights = { 'crypt': weight_ccpf[0], 'cpf': weight_ccpf[1], 'cpf_1': weight_ccpf[2], 'cpf_2': weight_ccpf[3] } metrics_use = { 'crypt': metrics.Accuracy(), 'cpf': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ], 'cpf_1': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ], 'cpf_2': [ metrics.TruePositives(), metrics.FalseNegatives(), metrics.FalsePositives(), metrics.TrueNegatives() ] } if is_comp: # compile final_model.compile(optimizer=Adam(lr=lr), loss=losses, loss_weights=lossWeights, metrics=metrics_use) return final_model, just_trnsf, just_unet
def __init__(self): super().__init__( loss=losses.CategoricalCrossentropy(), optimizer=optimizers.Adam(0.001), metrics=[metrics.Accuracy()], )
def train( data: tuple[np.ndarray, np.ndarray], layers: Literal["lstm", "mlp"] | list[tuple[str, dict]] = "mlp", epochs: int = 100, load_trained_model: bool = True, update_trained_model: bool = True, save_model: bool = True, saved_model_path_string: str = "stored_models", optimizer: str = "adam", loss: str = "mse", summary: bool = False, verbose=0, used_metrics="accuracy", timedistributed=False, batch_size=64, ): """Tensorflow model. Neural nets - LSTM or MLP (dense layers). Layers are customizable with arguments. Args: data (tuple[np.ndarray, np.ndarray]) - Tuple (X, y) of input train vectors X and train outputs y layers (Literal["lstm", "mlp"] | list[tuple[str, dict]], optional) - List of tuples of layer name (e.g. 'lstm') and layer params dict e.g. (("lstm", {"units": 7, "activation": "relu"})). Check default layers list here for example. There are also some predefined architectures. You can use 'lstm' or 'mlp'. Defaults to 'mlp'. epochs (int, optional): Number of epochs to evaluate. Defaults to 100. load_trained_model (bool, optional): If True, load model from disk. Most of time is spend on training, so if loaded and not updated, it's very fast. Defaults to True. update_trained_model (bool, optional): Whether load_trained_model, it's updated with new input. Defaults to True. save_model (str, optional): If True, save model on disk on saved_model_path_string. Defaults to True. saved_model_path_string (str, optional): Full path to saved model with name. E.g. '/home/dan/mymodel.h5. If 'stored_models', then it's save to library folder models/stored_models. Defaults to 'stored_models'. optimizer (str, optional): Used optimizer. Defaults to 'adam'. loss (str, optional): Loss function. Defaults to 'mse'. summary (int, optional): Display model details table. Defaults to 0. verbose (int, optional): Whether display progress bar. Defaults to 0. used_metrics (str, optional): Used metrics. 'accuracy' or 'mape' Defaults to 'accuracy'. timedistributed (bool, optional): Whether add time distributed layer. Defaults to False. batch_size (int, optional): Used batch size. Defaults to 64. Returns: model: Trained model object. """ if not importlib.util.find_spec("tensorflow"): raise ModuleNotFoundError( mylogging.return_str( "Tensorflow model configured, but tensorflow library not installed. It's not " "in general requirements, because very big and not work everywhere. If you " "want to use tensorflow model, install it via \n\n`pip install tensorflow`" ) ) import tensorflow as tf from tensorflow.keras import Sequential from tensorflow.keras import layers as tf_layers from tensorflow.keras import metrics as tf_metrics from tensorflow.keras import models as tf_models from tensorflow.keras import Model as tf_model_type X, y = get_inputs(data) X_ndim = X.ndim models = { "dense": tf_layers.Dense, "lstm": tf_layers.LSTM, "mlp": tf_layers.Dense, "gru": tf_layers.GRU, "conv2d": tf_layers.Conv2D, "rnn": tf_layers.SimpleRNN, "convlstm2d": tf_layers.ConvLSTM2D, "dropout": tf_layers.Dropout, "batchnormalization": tf_layers.BatchNormalization, } if used_metrics == "accuracy": metrics = [tf_metrics.Accuracy()] elif used_metrics == "mape": metrics = [tf_metrics.MeanAbsolutePercentageError()] else: raise ValueError("metrics has to be one from ['accuracy', 'mape']") if saved_model_path_string == "stored_models": saved_model_path_string = str(Path(__file__).resolve().parent / "stored_models" / "tensorflow.h5") if load_trained_model: try: model = tf_models.load_model(saved_model_path_string) model = cast(tf_model_type, model) model.load_weights(saved_model_path_string) except Exception: raise NameError("Model is not saved, first save_model = 1 in config") if update_trained_model: model.fit(X, y, epochs=epochs, batch_size=batch_size, verbose=verbose) else: if isinstance(layers, str): if layers == "lstm": layers = [ ("lstm", {"units": 32, "activation": "relu", "return_sequences": 1}), ("dropout", {"rate": 0.1}), ("lstm", {"units": 7, "activation": "relu"}), ] elif layers == "mlp": layers = [ ("dense", {"units": 32, "activation": "relu"}), ("dropout", {"rate": 0.1}), ("dense", {"units": 7, "activation": "relu"}), ] else: raise ValueError( mylogging.return_str("Only possible predefined layers are 'lstm' and 'mlp'.") ) layers = cast(list[tuple[str, dict[str, Any]]], layers) if layers[0][0] == "lstm": if X.ndim == 2: X = X.reshape(X.shape[0], X.shape[1], 1) layers[0][1]["input_shape"] = (X.shape[1], X.shape[2]) elif layers[0][0] == "dense": layers[0][1]["input_shape"] = (X.shape[1],) if X.ndim > 2: raise ValueError( mylogging.return_str( "For dense first layer only univariate data supported (e.g. shape = (n_samples, n_features))" "if ndim > 2: serialize first." ) ) model = Sequential() for i in layers: model.add(models[i[0]](**i[1])) if timedistributed == 1: model.add(tf_layers.TimeDistributed(tf_layers.Dense(y.shape[1]))) else: model.add(tf_layers.Dense(y.shape[1])) model.compile(optimizer=optimizer, loss=loss, metrics=metrics) if summary: model.summary() model.fit(X, y, epochs=epochs, batch_size=batch_size, verbose=verbose) if save_model == 1: model.save(saved_model_path_string) model.layers_0_0 = layers[0][0] model.X_ndim = X_ndim model.y_shape_1 = y.shape[1] return model
layers.Dense(256, activation=tf.nn.relu), layers.Dense(192, activation=tf.nn.relu), layers.Dense(128, activation=tf.nn.relu), layers.Dense(96, activation=tf.nn.relu), layers.Dense(64, activation=tf.nn.relu), layers.Dense(42, activation=tf.nn.relu), layers.Dense(32, activation=tf.nn.relu), layers.Dense(10) ]) model.build(input_shape=[None, inputShape]) model.summary() optimizer = optimizers.Adam(lr=1e-3) lossMean = metrics.Mean() accuracy = metrics.Accuracy() def main(): for epoch in range(20): for step, (x, y) in enumerate(db): x = tf.reshape(x, (-1, inputShape)) y_onehot = tf.one_hot(y, depth=10) with tf.GradientTape() as tape: logits = model(x) loss = tf.losses.categorical_crossentropy(y_onehot, logits, from_logits=True) loss = tf.reduce_sum(loss) lossMean.update_state(loss) gradient = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradient, model.trainable_variables))
layers.Dropout(rate=0.5), # 7th layer layers.Dense(128, activation='relu'), layers.Dropout(rate=0.5), # 8th layer(output) layers.Dense(5) ]) network.build(input_shape=(32, 224, 224, 3)) network.summary() # In[ ]: # training optimizer = optimizers.SGD( lr=0.01) # Batch Gradient Descent Learning rate=0.01 acc_meter = metrics.Accuracy() x_step = [] y_accuracy = [] for step, (x, y) in enumerate(db): with tf.GradientTape() as tape: x = tf.reshape(x, (-1, 224, 224, 3)) # input[b, 224, 224, 3] out = network(x) # output[b, 5] y_onehot = tf.one_hot(y, depth=5) # one-hot loss = tf.square(out - y_onehot) loss = tf.reduce_sum(loss) / 32 # batch=32,Mean Square Error Loss grads = tape.gradient(loss, network.trainable_variables) # compute gradient optimizer.apply_gradients(zip( grads, network.trainable_variables)) # update parameters acc_meter.update_state(tf.argmax(out, axis=1), y) # compare labels if step % 10 == 0: # 每200个step,打印一次结果
def __train(self): """训练的具体过程""" optimizer = optimizers.Adam(lr=self.lr) # 使用 Adam 优化器 acc_meter = metrics.Accuracy() # 定义准确率计算器 for epoch in range(self.epochs): with trange(50000 // 128) as t: iter_data = iter(self.train_db) # 将训练数据集转换为迭代器 for step in t: # 使用 tqdm 优化输出 t.set_description( # 修改表头显示,增加时间和epoch显示 time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) + " Epoch {}".format(epoch)) (x, y) = next(iter_data) # 获取一个训练的batch with tf.GradientTape() as tape: # 记录梯度 result = self.model(x) # 通过网络得到的结果 y_label = tf.one_hot(y, depth=10) # 转化获得对应的标签,用于计算准确率 # 计算准确率 acc_meter.update_state(tf.argmax(result, axis=1), tf.argmax(y_label, axis=1)) # 计算损失函数,使用交叉熵函数 loss = tf.losses.categorical_crossentropy( y_label, result, from_logits=True) loss = tf.reduce_mean(loss) # 计算正则化损失函数,叠加得到最后的损失 regularization_list = [ tf.nn.l2_loss(par) for par in self.model.trainable_variables ] loss += self.lambda_val * tf.reduce_sum( tf.stack(regularization_list)) # 计算梯度,并且应用,进行 BP grads = tape.gradient(loss, self.model.trainable_variables) optimizer.apply_gradients( zip(grads, self.model.trainable_variables)) # 规范化输出信息 info = "Step: {}, Loss: {:.4f}, ACC: {:.2f}% " \ "".format(step, float(loss), acc_meter.result().numpy() * 100) # 在每个 epoch 的最后,计算在测试集上的 ACC if step == 50000 // 128 - 1: total_num = 0 total_correct = 0 for x, y in self.test_db: # 计算正确预测的样本数量 result = self.model(x) prob = tf.nn.softmax(result, axis=1) pred = tf.argmax(prob, axis=1) pred = tf.cast(pred, dtype=tf.int32) correct = tf.cast(tf.equal(pred, y), dtype=tf.int32) correct = tf.reduce_sum(correct) total_num += x.shape[0] total_correct += int(correct) acc = total_correct / total_num info += "ACC in Test Data: {:.2f}%".format(acc * 100) t.set_postfix_str(info) if step % 100 == 0: t.write("") # 每执行 100 此迭代,进行换行