def train_model_epochs(num_epochs, gpu=True):
""" Trains the model for a given number of epochs on the training set. """
for epoch in range(num_epochs):
length = len(train_loader) // 10
running_loss = 0.0
for i, data in enumerate(train_loader, 0):
images, labels = data
if gpu:
images = images.to(device)
labels = labels.to(device)
# Zero the parameter gradients means to reset them from
# any previous values. By default, gradients accumulate!
optimizer.zero_grad()
# Passing inputs to the model calls the forward() function of
# the Module class, and the outputs value contains the return value
# of forward()
outputs = model(images)
# Compute the loss based on the true labels
loss = criterion(outputs, labels)
# Backpropagate the error with respect to the loss
loss.backward()
# Updates the parameters based on current gradients and update rule;
# in this case, defined by SGD()
optimizer.step()
# Print our loss
running_loss += loss.item()
if i % length == length - 1: # print every 1000 mini-batches
print('Epoch / Batch [%d / %d] - Loss: %.3f' %
(epoch + 1, i + 1, running_loss / length))
running_loss = 0.0
with torch.no_grad():
for data_val in validation_loader:
images_val, labels_val = data_val
images_val = images_val.to(device)
labels_val = labels_val.to(device)
outputs_val = model(images_val)
loss_val = criterion(outputs_val, labels_val)
running_loss_val += loss_val.item()
_, predicted = torch.max(outputs_val.data, 1)
print('- val_loss:%.3f' % (running_loss_val / len(validation_loader)))
running_loss_val = 0
def run_iter(batch, is_training):
model.train(is_training)
sent = batch['sent'].to(DEVICE)
tag = batch['tag'].to(DEVICE)
pos1 = batch['pos1'].to(DEVICE)
pos2 = batch['pos2'].to(DEVICE)
length = batch['length'].to(DEVICE)
label = batch['label'].to(DEVICE)
id = batch['id']
scope = batch['scope']
logits = model(sent, tag, length)
loss = criterion(input=logits, target=label)
label_pred = logits.max(1)[1]
if is_training:
optimizer.zero_grad()
loss.backward()
clip_grad_norm_(parameters=params, max_norm=5)
optimizer.step()
return loss, label_pred.cpu()
def train(model, dataset, optimizer):
net = model()
net.compile(
optimizer=optimizer,
loss=loss_fn,
metrics=['accuracy'])
net.fit(
x_train, y_train, # 告知训练集的输入以及标签，
batch_size=BATCH_SIZE, # 每一批batch的大小为32，
epochs=EPOCHS, # 迭代次数
validation_split=0.2, # 从测试集中划分80%给训练集
validation_freq=20 # 测试的间隔次数为20
)
for x, y in dataset:
with tf.GradientTape() as tape:
prediction = model(x, training=True)
loss = loss_fn(prediction, y)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
def run_iter(batch):
sent = batch['sent'].to(DEVICE)
tag = batch['tag'].to(DEVICE)
length = batch['length'].to(DEVICE)
scope = batch['scope']
logit = model(sent, tag, length, scope)
return logit.cpu()
def main(_):
FLAGS.agent = model(params=FLAGS)
FLAGS.environment = get_env(FLAGS)
FLAGS.act = action()
FLAGS.step_max = FLAGS.environment.data_len()
FLAGS.train_freq = 40
FLAGS.update_q_freq = 50
FLAGS.gamma = 0.97
FLAGS.show_log_freq = 5
FLAGS.memory = [] #Experience(FLAGS.memory_size)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
#创建用于保存模型的目录
if not os.path.exists(FLAGS.model_dir):
os.makedirs(FLAGS.model_dir)
start = time.time()
with tf.Session() as sess:
sess.run(init)
eval = evaluation(FLAGS, sess)
ckpt = tf.train.get_checkpoint_state(FLAGS.model_dir)
if ckpt:
print('Loading Model...')
saver.restore(sess, ckpt.model_checkpoint_path)
total_step = 1
print('\t'.join(
map(str, [
"epoch", "epsilon", "total_step", "rewardPerEpoch", "profits",
"lossPerBatch", "elapsed_time"
])))
for epoch in range(FLAGS.epoch_num):
avg_loss_per_batch, total_reward, total_step, profits = run_epch(
FLAGS, sess, total_step)
# total_rewards.append(total_reward)
# total_losses.append(total_loss)
if (epoch + 1) % FLAGS.show_log_freq == 0:
# log_reward = sum(total_rewards[((epoch+1)-FLAGS.show_log_freq):])/FLAGS.show_log_freq
# log_loss = sum(total_losses[((epoch+1)-FLAGS.show_log_freq):])/FLAGS.show_log_freq
elapsed_time = time.time() - start
#print('\t'.join(map(str, [epoch+1, FLAGS.act.epsilon, total_step, log_reward, log_loss, elapsed_time])))
print('\t'.join(
map(str, [
epoch + 1, FLAGS.act.epsilon, total_step, total_reward,
profits, avg_loss_per_batch, elapsed_time
])))
start = time.time()
saver.save(
sess,
FLAGS.model_dir + '\model-' + str(epoch + 1) + '.ckpt')
eval.eval()
def train():
tb_path = Path(c.TB_DIR, settings.run_name())
if tb_path.exists():
print("TensorBoard logdir", tb_path, "already exists. Overwrite [y/N]")
r = input()
if r.lower()[0] == "y":
shutil.rmtree(str(tb_path))
else:
return
print("Loading model...")
model = network.model()
opts = tf.RunOptions(report_tensor_allocations_upon_oom=True)
model.compile(optimizer='adam', loss=settings.loss(), options=opts)
video_folders = list(Path(c.DATA_DIR).glob("[0-9][0-9]"))
train_split = int(c.TRAIN_SPLIT * len(video_folders))
validation_split = int(c.VALIDATION_SPLIT * train_split)
train_folders = video_folders[:train_split][:-validation_split]
validation_folders = video_folders[:train_split][-validation_split:]
seq = lambda x: KerasSequenceWrapper(DreyeveExamples, c.BATCH_SIZE, x)
train_examples = seq(train_folders)
validation_examples = seq(validation_folders)
callbacks = [
TerminateOnNaN(),
ModelCheckpoint(c.CHECKPOINT_DIR + "/" + settings.run_name() +
"_epoch_{epoch:02d}_loss_{val_loss:.2f}.h5",
save_weights_only=True,
period=2),
TensorBoard(
log_dir=str(tb_path),
#histogram_freq=10,
batch_size=c.BATCH_SIZE,
write_images=True,
write_graph=True)
]
history = model.fit_generator(train_examples,
steps_per_epoch=c.TRAIN_STEPS,
epochs=c.EPOCHS,
callbacks=callbacks,
validation_data=validation_examples,
validation_steps=c.VALIDATION_STEPS,
use_multiprocessing=c.USE_MULTIPROCESSING,
workers=c.WORKERS)
print("Saving weights and history")
model.save_weights("weights_" + settings.run_name() + ".h5")
pkl_xz.save(history.history, "history_" + settings.run_name() + ".pkl.xz")
def run_iter(batch):
sent = batch['sent'].to(DEVICE)
tag = batch['tag'].to(DEVICE)
length = batch['length'].to(DEVICE)
scope = batch['scope']
logit, word_attn, tree_order, sent_attn = model(sent,
tag,
length,
scope,
verbose_output=True)
return logit.cpu(), word_attn.cpu(), tree_order, sent_attn
def run_iter(batch):
sent = batch['sent'].to(DEVICE)
tag = batch['tag'].to(DEVICE)
length = batch['length'].to(DEVICE)
label = batch['label']
id = batch['id']
scope = batch['scope']
logits = model(sent, tag, length, scope)
logits = F.softmax(logits, dim=1)
label_pred = logits.max(1)[1]
return id, label, logits.detach().cpu(), label_pred.detach().cpu()
def run_iter(batch):
sent = batch['sent'].to(DEVICE)
tag = batch['tag'].to(DEVICE)
pos1 = batch['pos1'].to(DEVICE)
pos2 = batch['pos2'].to(DEVICE)
length = batch['length'].to(DEVICE)
label = batch['label']
id = batch['id']
scope = batch['scope']
logits = model(sent, tag, length)
label_pred = logits.max(1)[1]
return label_pred.cpu()
# Model
if FLAGS.vgg:
print('\nEncoder model from VGG16.\n')
x = tf.stack([x, x, x], axis=3)
x = tf.reshape(x, [FLAGS.batch_size, sx, sy, 3])
x_aug = tf.stack([x_aug, x_aug, x_aug], axis=3)
x_aug = tf.reshape(x_aug, [FLAGS.batch_size, sx, sy, 3])
with tf.variable_scope("siamese") as scope:
yab, vgg16_conv_layers = network.model_vgg(x, True, True)
scope.reuse_variables()
yab_s, vgg16_conv_layers_s = network.model_vgg(x_aug, True, True)
else:
print('\nEncoder model ala Izuka et al.\n')
with tf.variable_scope("siamese") as scope:
yab = network.model(x, True, True)
scope.reuse_variables()
yab_s = network.model(x_aug, True, True)
print('Model size = %d weights\n' % network.count_all_vars())
# Compose final image
ya, yb = tf.unstack(yab, axis=3)
ya = tf.reshape(ya, [FLAGS.batch_size, int(sx / 2), int(sy / 2), 1])
yb = tf.reshape(yb, [FLAGS.batch_size, int(sx / 2), int(sy / 2), 1])
yabf = tf.image.resize_images(yab,
size=[sx, sy],
method=tf.image.ResizeMethod.BILINEAR)
yaf, ybf = tf.unstack(yabf, axis=3)
ylab = color_transform.deprocess_lab(y_l, yaf, ybf)
y = color_transform.lab_to_rgb(ylab)
type=str,
default="../checkpoints/chair_15.pth",
help='checkpoint path')
parser.add_argument('--save_dir',
type=str,
default="104256_meta_handle",
help='save dir')
parser.add_argument('--num_basis',
type=int,
default=15,
help='number of basis vectors')
return parser.parse_args()
opt = parse_args()
net = network.model(opt.num_basis).cuda()
net = torch.nn.DataParallel(net)
try:
checkpoint = torch.load(opt.checkpoint)
net.load_state_dict(checkpoint['model_state_dict'])
print('Use pretrain model')
except:
print('Error! No existing model!')
exit(-1)
net.eval()
src_pc, _, _ = load_obj("%s/pc_4096.obj" % opt.src_shape)
tar_pc, _, _ = load_obj("%s/pc_4096.obj" % opt.tar_shape)
key_pts, _, _ = load_obj("%s/key_point_50.obj" % opt.src_shape)
_, src_faces, _ = load_obj("%s/manifold.obj" % opt.src_shape)
def runInference(input_data, input_labels, input_file=None):
ACC_DIFF = 0.00001
input_data = torch.from_numpy(input_data)
input_data = input_data.type(torch.FloatTensor)
input_labels = torch.from_numpy(input_labels)
input_labels = input_labels.type(torch.FloatTensor)
# Load networks
MODELS_DIR = os.path.join('../', 'models/')
network1 = network.model()
network1.load_state_dict(
torch.load(os.path.join(MODELS_DIR, 'network1.torch')))
network2 = network.model()
network2.load_state_dict(
torch.load(os.path.join(MODELS_DIR, 'network2.torch')))
network3 = network.model()
network3.load_state_dict(
torch.load(os.path.join(MODELS_DIR, 'network3.torch')))
network4 = network.model()
network4.load_state_dict(
torch.load(os.path.join(MODELS_DIR, 'network4.torch')))
network5 = network.model()
network5.load_state_dict(
torch.load(os.path.join(MODELS_DIR, 'network5.torch')))
network6 = network.model()
network6.load_state_dict(
torch.load(os.path.join(MODELS_DIR, 'network6.torch')))
correct = np.zeros((6, 1))
predicted = np.empty((0, 6))
labels = np.empty((0, 6))
for data, label in zip(input_data, input_labels):
output1 = network1(data)
output2 = network2(data)
output3 = network3(data)
output4 = network4(data)
output5 = network5(data)
output6 = network6(data)
predicted = np.append(predicted,
np.array([[
output1.item(),
output2.item(),
output3.item(),
output4.item(),
output5.item(),
output6.item()
]]),
axis=0)
labels = np.append(labels,
np.array([[
label[0], label[1], label[2], label[3],
label[4], label[5]
]]),
axis=0)
correct[0] = correct[0] + 1 if output1.item(
) - label[0] < ACC_DIFF else correct[0]
correct[1] = correct[1] + 1 if output2.item(
) - label[1] < ACC_DIFF else correct[1]
correct[2] = correct[2] + 1 if output3.item(
) - label[2] < ACC_DIFF else correct[2]
correct[3] = correct[3] + 1 if output4.item(
) - label[3] < ACC_DIFF else correct[3]
correct[4] = correct[4] + 1 if output5.item(
) - label[4] < ACC_DIFF else correct[4]
correct[5] = correct[5] + 1 if output6.item(
) - label[5] < ACC_DIFF else correct[5]
np.savetxt('../inference_results/test_predictions.csv',
predicted,
fmt='%10.10f',
delimiter=',')
np.savetxt('../inference_results/test_labels.csv',
labels,
fmt='%10.10f',
delimiter=',')
print('Inference Results: {}'.format(
np.divide(correct, len(input_data)) * 100))
# Single frame
frames = [FLAGS.im_dir]
# If directory is supplied, get names of all files in the path
if os.path.isdir(FLAGS.im_dir):
frames = [os.path.join(FLAGS.im_dir, name)
for name in sorted(os.listdir(FLAGS.im_dir))
if os.path.isfile(os.path.join(FLAGS.im_dir, name))]
# Placeholder for image input
x = tf.placeholder(tf.float32, shape=[1, sy, sx, 3])
# HDR reconstruction autoencoder model
print_("Network setup:\n")
net = network.model(x)
# The CNN prediction (this also includes blending with input image x)
y = network.get_final(net, x)
# TensorFlow session for running inference
sess = tf.InteractiveSession()
# Load trained CNN weights
print_("\nLoading trained parameters from '%s'..." % FLAGS.params)
load_params = tl.files.load_npz(name=FLAGS.params)
tl.files.assign_params(sess, load_params, net)
print_("\tdone\n")
if not os.path.exists(FLAGS.out_dir):
os.makedirs(FLAGS.out_dir)
def main(): # images=tf.placeholder(tf.float32,[None,64,64,3]) # labels=tf.placeholder(tf.int32,[None]) net=model() net.train()
y_b = tf.image.resize_images(y_b, size=[int(sx/2),int(sy/2)], method=tf.image.ResizeMethod.BILINEAR)
x = tf.reshape(y_l, [FLAGS.batch_size, sy, sx, 1])
# HDR reconstruction autoencoder model
print_("Network setup:\n")
if FLAGS.vgg:
print_('\nEncoder model from VGG16.\n')
x = tf.stack([x,x,x], axis=3)
x = tf.reshape(x, [FLAGS.batch_size,sy,sx,3])
with tf.variable_scope("siamese") as scope:
yab = network.model_vgg(x, False, True)
else:
print_('\nEncoder model ala Izuka et al.\n')
with tf.variable_scope("siamese") as scope:
yab = network.model(x, False, True)
scope.reuse_variables()
yab_s = network.model(x, False, True)
#yab = network.model(x, False, True)
# Compose final image
ya, yb = tf.unstack(yab, axis=3)
ya = tf.reshape(ya, [FLAGS.batch_size, int(sy/2), int(sx/2), 1])
yb = tf.reshape(yb, [FLAGS.batch_size, int(sy/2), int(sx/2), 1])
yabf = tf.image.resize_images(yab, size=[sy,sx], method=tf.image.ResizeMethod.BILINEAR)
yaf, ybf = tf.unstack(yabf, axis=3)
ylab = color_transform.deprocess_lab(y_l, yaf, ybf)
y = color_transform.lab_to_rgb(ylab)
saver = tf.train.Saver()
for x, y in dataset:
with tf.GradientTape() as tape:
prediction = model(x, training=True)
loss = loss_fn(prediction, y)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
if __name__ == '__main__':
model_save_path = ""
train_data_path = "train_data.txt"
print("开始加载数据")
X, label = get_data(train_data_path, )
print(type(X))
print(X)
print(type(label))
print(label)
print("数据加载完毕")
net = model()
net.build(input_shape=(256, 256, 3))
print(net.summary())
# history = net.fit_generator(train_loader,
# steps_per_epoch=trainX.shape[0] / batch_size,
# validation_data=val_generator,
# epochs=EPOCHS,
# validation_steps=valX.shape[0] / batch_size,
# callbacks=[checkpointer, reduce],
# verbose=1,
# shuffle=True)
net.save(model_save_path)
name=None)
NUM_EPOCHS = 999999
DATA_SIZE = 4000
BATCH_SIZE = 1
LABELS = list(range(DATA_SIZE))
oldLoss = 999999
totalLoss = 0
pastLoss = 999999
# IMG-LDR
curr_LDR = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 320, 320, 3])
# IMG-HDR
curr_HDR = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 320, 320, 3])
y_input, y_actual = getTransform(curr_LDR, curr_HDR)
my_net = network.model(y_input)
y_pred = network.get_final(my_net, y_input)
# Loss functions
meanSquareLoss = tf.losses.mean_squared_error(labels=y_actual,
predictions=y_pred)
absDevLoss = tf.losses.absolute_difference(labels=y_actual, predictions=y_pred)
huberLoss = tf.losses.huber_loss(labels=y_actual, predictions=y_pred)
train_step = tf.train.AdamOptimizer(LEARNING_RATE).minimize(huberLoss)
correct_prediction = tf.equal(tf.argmax(y_actual, 1), tf.argmax(y_pred, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Initialize the saver to save the model
saver = tf.train.Saver()
enqueue_op_frames = q_frames.enqueue([input_frame])
dequeue_op_frames = q_frames.dequeue()
# For multi-threaded queueing of training images
input_data = tf.placeholder(tf.float32, shape=[sy, sx, 3])
input_target = tf.placeholder(tf.float32, shape=[sy, sx, 3])
q_train = tf.FIFOQueue(FLAGS.buffer_size, [tf.float32, tf.float32],
shapes=[[sy, sx, 3], [sy, sx, 3]])
enqueue_op_train = q_train.enqueue([input_target, input_data])
y_, x = q_train.dequeue_many(FLAGS.batch_size)
#=== Network ==================================================================
# Setup the network
print("Network setup:\n")
net, vgg16_conv_layers = network.model(x, FLAGS.batch_size, True)
y = net.outputs
train_params = net.all_params
# The TensorFlow session to be used
sess = tf.InteractiveSession()
#=== Loss function formulation ================================================
# For masked loss, only using information near saturated image regions
thr = 0.05 # Threshold for blending
msk = tf.reduce_max(y_, reduction_indices=[3])
msk = tf.minimum(1.0, tf.maximum(0.0, msk - 1.0 + thr) / thr)
msk = tf.reshape(msk, [-1, sy, sx, 1])
msk = tf.tile(msk, [1, 1, 1, 3])
def main(args):
# 建立文件夹
output_path = "output_test/"+args.name
txt_path = 'data/txt'+str(args.cv_index)
result_path = os.path.join(output_path, "result")
best_path = os.path.join(output_path, "best_weights")
log_path = os.path.join(result_path, "Log.txt")
check_dir(best_path)
check_dir(output_path)
check_dir(result_path)
# 保存parser设置
logger = logging.getLogger()
logger.setLevel(logging.INFO)
fh = logging.FileHandler((os.path.join(result_path, 'Setting_Log.txt')), mode='w')
logger.addHandler(fh)
logger.info(args)
# 加载数据
train_set = MySet(txt_path, mode="train", is_debug=args.smoke_test)
val_set = MySet(txt_path, mode="val", is_debug=args.smoke_test)
train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True,
num_workers=20 if not args.smoke_test else 0)
val_loader = DataLoader(val_set, batch_size=args.batch_size, num_workers=20 if not args.smoke_test else 0)
# 定义模型
net = model().cuda()
# 多GPU
if len(args.gpu_id) > 1:
torch.distributed.init_process_group(
backend="nccl", init_method='tcp://localhost:8000', rank=0, world_size=1)
net = torch.nn.parallel.DistributedDataParallel(net)
# 损失以及优化器
cost = torch.nn.CrossEntropyLoss()
if args.optimizer == "Adam":
optimizer = torch.optim.Adam(net.parameters(), lr=args.lr, weight_decay=args.weight_decay)
if args.optimizer == "SGD":
optimizer = torch.optim.SGD(net.parameters(), lr=args.lr, weight_decay=args.weight_decay)
# 训练结果记录
train_loss_list, train_acc_list, val_loss_list, val_acc_list = [], [], [], []
save = savebest_weights(args.num_model_to_save, best_path)
t0 = time.time()
# epoch循环
for epoch in trange(args.num_epoch):
train_loss, train_acc = train(net, train_loader, optimizer, cost)
val_loss, val_acc = val(net, val_loader, cost)
train_loss_list.append(train_loss)
train_acc_list.append(train_acc)
val_loss_list.append(val_loss)
val_acc_list.append(val_acc)
save.save_weight(net, val_acc, epoch)
# 画出训练集和验证集的loss及acc
plot(train_loss_list, 'train_loss', val_loss_list, 'val_loss',
x_label="epoch", y_label="loss", title="Loss Curve-epoch", save_path=result_path)
plot(train_acc_list, 'train_acc', val_acc_list, 'val_acc',
x_label="epoch", y_label="acc", title="Acc Curve-epoch", save_path=result_path)
info = [str(epoch).zfill(3), train_loss, val_acc]
logtxt = open(log_path, "a")
logtxt.write("Epoch: {} | Train Loss: {:.4f} Val ACC: {:.4f}\n".format(*info))
print("\rEpoch: {} | Train Loss: {:.4f} Val ACC: {:.4f}".format(*info))
logtxt.close()
t2 = time.time()
print("Optimization Finished! Cost time:{:.1f} minutes".format((t2-t0)/60))
print("Start test in best val model...")
test_acc_list = []
test_set = MySet(txt_path, mode="test", is_debug=args.smoke_test)
test_loader = DataLoader(test_set, batch_size=args.batch_size, num_workers=20 if not args.smoke_test else 0)
best_weight = os.listdir(best_path)
for i in range(args.num_model_to_save):
# 模型
net.load_state_dict(torch.load(os.path.join(best_path, best_weight[i])))
test_acc, tn, fp, fn, tp = test(net, test_loader)
test_acc_list.append(test_acc)
tp_list.append(tp)
tn_list.append(tn)
fp_list.append(fp)
fn_list.append(fn)
tp = tp_list[np.argmax(test_acc_list)]
tn = tn_list[np.argmax(test_acc_list)]
fp = fp_list[np.argmax(test_acc_list)]
fn = fn_list[np.argmax(test_acc_list)]
precision = tp/(tp+fp)
sensitive = tp/(tp+fn)
specificity = tn/(tn+fp)
F1score = 2*tp/(2*tp+fp+fn)
logtxt = open(log_path, "a")
logtxt.write("Test ACC: {} ,|sensitive:{:.2f}|specificity:{:.2f}|precision:{:.2f}|F1score:{:.2f}| the best: {:4f} and the weight name: {}\n".format(
test_acc_list, np.max(test_acc_list), sensitive*100, specificity*100, precision*100, F1score*100, best_weight[np.argmax(test_acc_list)]))
print("The test acc:{}, the best: {} and the weight name: {}\n".format(
test_acc_list, np.max(test_acc_list), sensitive*100, specificity*100, precision*100, F1score*100, best_weight[np.argmax(test_acc_list)]))
logtxt.close()
data = data.cuda()
y = net(data)
predict = y.data.cpu().numpy()
label = label.data.numpy()
predicts.extend(np.argmax(predict, axis=1))
labels.extend(label)
acc = accuracy_score(labels, predicts)
tn, fp, fn, tp = confusion_matrix(labels, predicts).ravel()
return acc, tn, fp, fn, tp
name = ''
txt_path = 'data/txt'
os.environ['CUDA_VISIBLE_DEVICES'] = '4'
# 模型
output_path = "output_test/"+name
best_path = os.path.join(output_path, "best_weights")
best_weight = os.path.join(best_path, '15_0_2_0.9074.pth.gz')
net = model().cuda()
net.load_state_dict(torch.load(best_weight))
# 数据
test_set = MySet(txt_path, mode="test")
test_loader = DataLoader(test_set, batch_size=10, num_workers=20)
# 测试
test_acc, tn, fp, fn, tp = test(net, test_loader)
precision = tp/(tp+fp)
sensitive = tp/(tp+fn)
specificity = tn/(tn+fp)
F1score = 2*tp/(2*tp+fp+fn)
print("The test acc:{}".format(test_acc))
print("The precision:{}|sensitive:{}|specificity:{}|F1score:{}".format(precision, sensitive, specificity, F1score)
def trainNetworks(train_data, train_labels, epochs=5, learning_rate=0.001):
"""
Trains 6 networks on the data using the hyperparameters provided.
Saves the final model as in the models directory with timestamp as the name.
Input is same for all 6 networks. The prediction of each network is for its corresponding
joint. The labels data structure is divided into
:param train_data: Numpy array with training data points
:param val_data: Numpy array with validation data points
:param steps: Number of training steps
:param learning_rate: Learning rate used for training
"""
on_gpu = False
if torch.cuda.is_available():
on_gpu = True
network1 = network.model()
network2 = network.model()
network3 = network.model()
network4 = network.model()
network5 = network.model()
network6 = network.model()
data_length = len(train_data)
train_data = torch.from_numpy(train_data)
train_data = train_data.type(torch.FloatTensor)
train_labels = torch.from_numpy(train_labels)
train_labels = train_labels.type(torch.FloatTensor)
if on_gpu:
network1 = network.model().cuda()
network2 = network.model().cuda()
network3 = network.model().cuda()
network4 = network.model().cuda()
network5 = network.model().cuda()
network6 = network.model().cuda()
#train_data = train_data.cuda()
#train_labels = train_labels.cuda()
optimiser1 = torch.optim.Adam(network1.parameters(), learning_rate)
optimiser2 = torch.optim.Adam(network2.parameters(), learning_rate)
optimiser3 = torch.optim.Adam(network3.parameters(), learning_rate)
optimiser4 = torch.optim.Adam(network4.parameters(), learning_rate)
optimiser5 = torch.optim.Adam(network5.parameters(), learning_rate)
optimiser6 = torch.optim.Adam(network6.parameters(), learning_rate)
criterion = torch.nn.MSELoss()
avg_train_loss = np.empty((0, 6))
avg_val_loss = np.empty((0, 6))
print("Starting training!!!")
# SGD Implementation
for epoch in range(epochs):
index = 0
train_loss = np.empty((0, 6))
val_loss = np.empty((0, 6))
# Shuffle train_data randomly
random_perm = np.random.permutation(data_length)
train_data1 = train_data[random_perm]
train_labels1 = train_labels[random_perm]
# Split into train and val
val_data = train_data1[:int(0.2*data_length),:]
val_labels = train_labels1[:int(0.2*data_length),:]
if on_gpu:
val_data = val_data.cuda()
val_labels = val_labels.cuda()
train_data1 = train_data1[int(0.2*data_length):,:]
train_labels1 = train_labels1[int(0.2*data_length):,:]
for data, label in zip(train_data1, train_labels1):
# data = torch.from_numpy(data)
# data = data.type(torch.FloatTensor)
# label = torch.from_numpy(label)
# label = label.type(torch.FloatTensor)
#print(data)
if on_gpu:
data = data.cuda()
label = label.cuda()
output1 = network1(data)
output2 = network2(data)
output3 = network3(data)
output4 = network4(data)
output5 = network5(data)
output6 = network6(data)
# Each label frame consists of 6 values corresponding to each joint
loss1 = criterion(output1, label[0])
loss2 = criterion(output2, label[1])
loss3 = criterion(output3, label[2])
loss4 = criterion(output4, label[3])
loss5 = criterion(output5, label[4])
loss6 = criterion(output6, label[5])
# Backpropagate loss through each network and take gradient step
optimiser1.zero_grad()
loss1.backward()
optimiser1.step()
optimiser2.zero_grad()
loss2.backward()
optimiser2.step()
optimiser3.zero_grad()
loss3.backward()
optimiser3.step()
optimiser4.zero_grad()
loss4.backward()
optimiser4.step()
optimiser5.zero_grad()
loss5.backward()
optimiser5.step()
optimiser6.zero_grad()
loss6.backward()
optimiser6.step()
with torch.no_grad():
print("Progress: {}/{}".format(index+1, len(train_data1)), end="\r", flush=True)
index += 1
train_loss = np.append(train_loss, np.array([[loss1.item(), loss2.item(), loss3.item(), loss4.item(), loss5.item(), loss6.item()]]), axis=0)
for data, label in zip(val_data, val_labels):
output1 = network1(data)
output2 = network2(data)
output3 = network3(data)
output4 = network4(data)
output5 = network5(data)
output6 = network6(data)
loss1 = criterion(output1, label[0])
loss2 = criterion(output2, label[1])
loss3 = criterion(output3, label[2])
loss4 = criterion(output4, label[3])
loss5 = criterion(output5, label[4])
loss6 = criterion(output6, label[5])
val_loss = np.append(val_loss, np.array([[loss1.item(), loss2.item(), loss3.item(), loss4.item(), loss5.item(), loss6.item()]]), axis=0)
# Log progress
print('Epoch: {}'.format(epoch+1))
mean_train_loss = np.mean(train_loss, axis=0)
mean_val_loss = np.mean(val_loss, axis=0)
avg_train_loss = np.append(avg_train_loss, np.array([mean_train_loss]), axis=0)
avg_val_loss = np.append(avg_val_loss, np.array([mean_val_loss]), axis=0)
print('Avg Train Loss: \n{}'.format(mean_train_loss))
print('Avg Val Loss : \n{}\n'.format(mean_val_loss))
# Save the models after training
MODELS_DIR = os.path.join('..' + '/models')
print('Saving models to: {}'.format(MODELS_DIR))
np.savetxt('../train_results/avg_train_loss.csv', avg_train_loss, fmt='%10.10f', delimiter=',')
np.savetxt('../train_results/avg_val_loss.csv', avg_val_loss, fmt='%10.10f', delimiter=',')
torch.save(network1.state_dict(), os.path.join(MODELS_DIR, 'network1.torch'))
torch.save(network2.state_dict(), os.path.join(MODELS_DIR, 'network2.torch'))
torch.save(network3.state_dict(), os.path.join(MODELS_DIR, 'network3.torch'))
torch.save(network4.state_dict(), os.path.join(MODELS_DIR, 'network4.torch'))
torch.save(network5.state_dict(), os.path.join(MODELS_DIR, 'network5.torch'))
torch.save(network6.state_dict(), os.path.join(MODELS_DIR, 'network6.torch'))
#Load the network that has been driven
#the model properties must be the same of the learning one
model.load_weights("results/netCheckpoint-v1-1.27.h5")
#The sentence you want to start with
seed = "i have no idea how to"
#Load the properties of your dataset
char2int = pickle.load(open("char2int.pickle", "rb"))
int2char = pickle.load(open("int2char.pickle", "rb"))
# building the model
sequence_length = 100
n_unique_chars = len(char2int)
model = model(n_unique_chars, sequence_length)
# generate 1000 characters
generated = ""
for i in tqdm.trange(1000):
# make the input sequence
X = np.zeros((1, sequence_length, n_unique_chars))
for t, char in enumerate(seed):
#Convert the input into numeric values
X[0, (sequence_length - len(seed)) + t, char2int[char]] = 1
#prediction
predicted = model.predict(X, verbose=0)[0]
#take the index of the 'most important' value
next_index = np.argmax(predicted)
#match of the selected predicted value
next_char = int2char[next_index]
model_train = model.fit(digits_train,
encoded_titles_train,
validation_data=(digits_train_cross,
encoded_titles_train_cross),
epochs=epochs,
batch_size=batch_size,
verbose=verbose)
# Final evaluation of the model
scores = model.evaluate(digits_test, encoded_titles_test, verbose=verbose)
print("Large CNN Error: %.2f%%" % (100 - scores[1] * 100))
else:
print("Training CNN model")
# Build the model
model = model(pixels, classes, dropout)
# Train model with 20 epochs that updates every 200 images and a verbose of 2 is used to format and reduce the output line
model_train = model.fit(digits_train,
encoded_titles_train,
validation_data=(digits_train_cross,
encoded_titles_train_cross),
batch_size=batch_size,
epochs=epochs,
verbose=verbose)
print("\nSaving model for webapp")
model_save_path = "output"
tensorflowjs.converters.save_keras_model(model, model_save_path)
# training the model and saving metrics in history
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import network
import joblib
import numpy as np
model = network.model()
features = joblib.load('features.jbl')
labels = joblib.load('labels.jbl').astype(int)
features = features.reshape(features.shape[0], 1,
features.shape[1],
features.shape[2])
print('feature shape = {}'.format(features.shape))
print('labels shape = {}'.format(labels.shape))
exp_labels = np.zeros((labels.shape[0], 10, 3))
exp_labels[np.arange(exp_labels.shape[0])[:, None], labels, np.arange(3)[None, :]] = 1
exp_labels = exp_labels.transpose((0, 2, 1))
print(features.shape)
print(exp_labels.shape)
#
model.fit(features, exp_labels, batch_size=2, verbose=True)
data = pd.read_csv(
'C:\\Users\\jaide\\OneDrive\\Documents\\VSCODE\\NeuralNets\\Housing.csv')
columns = [
'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
'PTR', 'B', 'LSTAT', 'MEDB'
]
data = data.values
features = []
labels = []
for x in data:
lt = []
for y in x[0].split(' '):
if y != '':
lt.append(float(y))
features.append(lt[:-1])
labels.append([lt[13]])
features = np.array(features)
labels = np.array(labels)
x_train, y_train, x_test, y_test = features[:400], labels[:400], features[
400:], labels[400:]
model(x_train, y_train, x_test, y_test)
