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 此迭代，进行换行