def main():
global iteration_number
for epoch in range(Config.train_num_epochs):
for triplet in triplets_generator:
anchor, positive, negative = next(triplets_generator)
anchor, positive, negative = Variable(anchor).cuda(), Variable(
positive).cuda(), Variable(negative).cuda()
optimizer.zero_grad()
anchor_emb = net(anchor)
positive_emb = net(positive)
negative_emb = net(negative)
contrastive_loss = criterion(output1, output2, label)
for i, data in enumerate(train_dataloader, 0):
img0, img1, label = data
img0, img1, label = Variable(img0).cuda(), Variable(
img1).cuda(), Variable(label).cuda()
optimizer.zero_grad()
output1, output2 = net(img0, img1)
contrastive_loss = criterion(output1, output2, label)
contrastive_loss.backward()
optimizer.step()
print("training epoch {} / current loss {}".format(
epoch,
contrastive_loss.data.cpu().numpy().item()))
iteration_number += 1
counter.append(iteration_number)
loss_history.append(contrastive_loss.data.cpu().numpy().item())
show_plot(counter, loss_history)
def main():
input_lang, output_lang, pairs = utils.prepare_data(
lang_name=target_language, _dir='data')
encoder = model.EncoderRNN(input_lang.n_words, hidden_size, n_layers)
decoder = model.AttentionDecoderRNN(attn_model,
hidden_size,
output_lang.n_words,
n_layers,
dropout_p=dropout_p)
print("Encoder-Model: ", encoder)
print("Decoder-Model: ", decoder)
# Initialize optimizers and criterion
encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)
decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
criterion = nn.NLLLoss()
start = time.time()
plot_losses = []
print_loss_total = 0 # Reset every print_every
plot_loss_total = 0 # Reset every plot_every
# Begin training
for epoch in range(1, n_epochs + 1):
training_pair = utils.variables_from_pair(random.choice(pairs),
input_lang, output_lang)
input_variable = training_pair[0]
target_variable = training_pair[1]
# Run the train step
epoch_loss = train(input_variable, target_variable, encoder, decoder,
encoder_optimizer, decoder_optimizer, criterion)
print_loss_total += epoch_loss
plot_loss_total += epoch_loss
if epoch % print_every == 0:
print_loss_avg = print_loss_total / print_every
print_loss_total = 0
time_since = utils.time_since(start, epoch / n_epochs)
print('%s (%d %d%%) %.4f' %
(time_since, epoch, epoch / n_epochs * 100, print_loss_avg))
if epoch % plot_every == 0:
plot_loss_avg = plot_loss_total / plot_every
plot_losses.append(plot_loss_avg)
plot_loss_total = 0
save_model(encoder, 'data/encoder_state_' + target_language)
save_model(decoder, 'data/decoder_state_' + target_language)
save_model(decoder.attention,
'data/decoder_attention_state_' + target_language)
utils.show_plot(plot_losses)
def main():
# test = Image.open("./data/1.pgm")
# test.show()
# print (test)
print("Training starts...")
folder_dataset = dset.ImageFolder(root=Config.training_dir)
siamese_dataset = Contrastive_Dataset(imageFolderDataset=folder_dataset,
transform=transforms.Compose([
transforms.Resize((100, 100)),
transforms.ToTensor()
]),
should_invert=False)
train_dataloader = DataLoader(siamese_dataset,
shuffle=True,
num_workers=8,
batch_size=Config.train_batch_size)
net = SiameseNetwork()
criterion = ContrastiveLoss()
optimizer = optim.Adam(net.parameters(), lr=0.0005)
counter = []
loss_history = []
iteration_number = 0
for epoch in range(0, Config.train_number_epochs):
for i, data in enumerate(train_dataloader, 0):
img0, img1, label = data
img0, img1, label = Variable(img0), Variable(img1), Variable(label)
output1, output2 = net(img0, img1)
optimizer.zero_grad()
loss_contrastive = criterion(output1, output2, label)
loss_contrastive.backward()
optimizer.step()
if i % 10 == 0:
print("Epoch number {}\n Current loss {}\n".format(
epoch, loss_contrastive.data[0]))
iteration_number += 10
counter.append(iteration_number)
loss_history.append(loss_contrastive.data[0])
torch.save(net.state_dict(), "trained_weights.pt")
# save_checkpoint({
# 'epoch': epoch + 1,
# })
show_plot(counter, loss_history)
def log_plot(config, n_train, n_test, n_features, prediction, target,
input_horizon):
prec, rec, th = precision_recall_curve(target.ravel(), prediction.ravel())
ap = average_precision_score(target.ravel(), prediction.ravel())
print('threshold: ')
print(th)
show_plot(config, prec, rec, ap, n_features, input_horizon)
fscore = (2 * prec * rec) / (prec + rec)
fscore = np.nan_to_num(fscore)
ix = np.argmax(fscore)
print('Best Threshold=%f, F-Score=%.3f' % (th[ix], fscore[ix]))
log_result(config, n_train, n_test, th[ix], prediction, target,
input_horizon)
def test_overfitting(cifar, momentum):
training = cifar.get_named_batches('data_batch_1').subset(100)
net = Network()
net.add_layer(
layers.Linear(cifar.input_size, 50, 0, initializers.Xavier()))
net.add_layer(layers.ReLU(50))
net.add_layer(
layers.Linear(50, cifar.output_size, 0, initializers.Xavier()))
net.add_layer(layers.Softmax(cifar.output_size))
opt = MomentumSGD(net, initial_learning_rate=0.005, momentum=momentum)
opt.train(training, training, 400)
costs_accuracies_plot(opt.epoch_nums, opt.acc_train, opt.acc_val,
opt.cost_train, opt.cost_val,
'images/overfit_mom{}.png'.format(momentum))
show_plot('images/overfit_mom{}.png'.format(momentum))
def test_vanilla(cifar):
training = cifar.get_named_batches('data_batch_1')
validation = cifar.get_named_batches('data_batch_2')
net = Network()
net.add_layer(
layers.Linear(cifar.input_size, cifar.output_size, 0,
initializers.Xavier()))
net.add_layer(layers.Softmax(cifar.output_size))
opt = VanillaSGD(net,
initial_learning_rate=0.01,
decay_factor=0.99,
shuffle=True)
opt.train(training, validation, 100, 500)
costs_accuracies_plot(opt.epoch_nums, opt.acc_train, opt.acc_val,
opt.cost_train, opt.cost_val,
'images/vanilla.png')
show_plot('images/vanilla.png')
def train():
loss = []
counter = []
iteration_number = 0
for epoch in range(1, config.epochs):
for i, data in enumerate(train_dataloader, 0):
img0, img1, label = data
img0, img1, label = img0.cuda(), img1.cuda(), label.cuda()
optimizer.zero_grad()
output1, output2 = net(img0, img1)
loss_contrastive = criterion(output1, output2, label)
loss_contrastive.backward()
optimizer.step()
print("Epoch {}\n Current loss {}\n".format(epoch,
loss_contrastive.item()))
iteration_number += 10
counter.append(iteration_number)
loss.append(loss_contrastive.item())
show_plot(counter, loss)
return net
def train(net, optimizer, criterion, train_dataloader, args):
counter = []
loss_history = []
iteration_number = 0
# 开始训练
for epoch in range(1, args.epochs + 1):
for i, data in enumerate(train_dataloader, 0):
img0, img1, label = data
# img0维度为torch.Size([32, 1, 100, 100])，32是batch，label为torch.Size([32, 1])
img0, img1, label = img0.cuda(), img1.cuda(), label.cuda(
) # 数据移至GPU
optimizer.zero_grad()
output1, output2 = net(img0, img1)
loss_contrastive = criterion(output1, output2, label)
loss_contrastive.backward()
optimizer.step()
if i % 10 == 0:
iteration_number += 10
counter.append(iteration_number)
loss_history.append(loss_contrastive.item())
print("Epoch number: {} , Current loss: {:.4f}\n".format(
epoch, loss_contrastive.item()))
save_model(net, 'siameseNet' + str(epoch), 'checkpoint/')
show_plot(counter, loss_history)
),
should_invert=False
)
train_dataloader = DataLoader(siamese_dataset,
shuffle=True,
num_workers=8,
batch_size=Config.train_batch_size)
net = SiameseNetwork().cuda()
print(net)
criterion = ContrastiveLoss()
optimizer = optim.Adam(net.parameters(),lr = 0.0005 )
counter = []
loss_history = []
iteration_number= 0
for epoch in range(0,Config.train_number_epochs):
for i, data in enumerate(train_dataloader,0):
img0, img1 , label = data
img0, img1 , label = img0.cuda(), img1.cuda() , label.cuda()
optimizer.zero_grad()
output1,output2 = net(img0,img1)
loss_contrastive = criterion(output1,output2,label)
loss_contrastive.backward()
optimizer.step()
if i %10 == 0 :
print("Epoch number {}\n Current loss {}\n".format(epoch,loss_contrastive.item()))
iteration_number +=10
counter.append(iteration_number)
loss_history.append(loss_contrastive.item())
torch.save(net.state_dict(), "./model.pth")
show_plot(counter,loss_history)
# Binarize the output
y_stream_true1 = label_binarize(y_stream_true, classes=['non-streaming', 'streaming'])
y_stream_preds1 = label_binarize(y_stream_preds, classes=['non-streaming', 'streaming'])
n_classes = y_stream_true1.shape[1]
# Stream/non-stream ROC curve
utils.plot_ROC(y_stream_true1, y_stream_preds1, n_classes, ['non-streaming', 'streaming'], micro=False, macro=False)
conf1 = metrics.confusion_matrix(y_true, y_preds, labels=labels)
conf2 = metrics.confusion_matrix(y_stream_true, y_stream_preds, labels=['non-streaming', 'streaming'])
report = metrics.classification_report(y_true, y_preds, labels=labels)
report2 = metrics.classification_report(y_stream_true, y_stream_preds, labels=['non-streaming', 'streaming'])
except KeyboardInterrupt:
pass
print(namestr)
utils.plot_confusion_matrix(conf1, labels, save=False, title=namestr)
utils.plot_confusion_matrix(conf2, ['non-streaming', 'streaming'], save=False,
title="StreamNoStream_acc{}".format(stream_acc))
print(report)
print(report2)
# utils.plot_metric_graph(x_list=epochs, y_list=valid_accuracy, save=False, x_label="epochs", y_label="Accuracy", title="Accuracy")
# utils.plot_metric_graph(x_list=epochs, y_list=valid_loss, save=False, x_label="epochs", y_label="loss", title="Loss")
# utils.plot_confusion_matrix(conf, labels, save=False, title=namestr)
utils.show_plot()
acc_list = list(map(float, acc_list))
print(acc_list, hidden_units_train)
def train(train_generator,
vocab: Vocab,
model: Seq2Seq,
params: Params,
valid_generator=None):
# variables for plotting
plot_points_per_epoch = max(math.log(params.n_batches, 1.6), 1.)
plot_every = round(params.n_batches / plot_points_per_epoch)
plot_losses, cached_losses = [], []
total_batch_count = 0
plot_val_losses, plot_val_metrics = [], []
total_parameters = sum(parameter.numel()
for parameter in model.parameters()
if parameter.requires_grad)
print("Training %d trainable parameters..." % total_parameters)
model.to(DEVICE)
optimizer = optim.Adam(model.parameters(), lr=params.lr)
criterion = nn.NLLLoss(ignore_index=vocab.PAD)
best_avg_loss, best_epoch_id = float("inf"), None
for epoch_count in range(1, params.n_epochs + 1):
rl_ratio = params.rl_ratio if epoch_count >= params.rl_start_epoch else 0
epoch_loss, epoch_metric = 0, 0
epoch_avg_loss, valid_avg_loss, valid_avg_metric = None, None, None
prog_bar = tqdm(range(1, params.n_batches + 1),
desc='Epoch %d' % epoch_count)
model.train()
for batch_count in prog_bar: # training batches
batch = next(train_generator)
loss, metric = train_batch(batch,
model,
criterion,
optimizer,
pack_seq=params.pack_seq,
forcing_ratio=params.forcing_ratio,
partial_forcing=params.partial_forcing,
rl_ratio=rl_ratio,
vocab=vocab)
epoch_loss += float(loss)
epoch_avg_loss = epoch_loss / batch_count
if metric is not None: # print ROUGE as well if reinforcement learning is enabled
epoch_metric += metric
epoch_avg_metric = epoch_metric / batch_count
prog_bar.set_postfix(loss='%g' % epoch_avg_loss,
rouge='%.4g' % (epoch_avg_metric * 100))
else:
prog_bar.set_postfix(loss='%g' % epoch_avg_loss)
cached_losses.append(loss)
if (total_batch_count + batch_count) % plot_every == 0:
period_avg_loss = sum(cached_losses) / len(cached_losses)
plot_losses.append(period_avg_loss)
cached_losses = []
if valid_generator is not None: # validation batches
valid_loss, valid_metric = 0, 0
prog_bar = tqdm(range(1, params.n_val_batches + 1),
desc='Valid %d' % epoch_count)
model.eval()
for batch_count in prog_bar:
batch = next(valid_generator)
loss, metric = eval_batch(batch,
model,
vocab,
criterion,
pack_seq=params.pack_seq)
valid_loss += loss
valid_metric += metric
valid_avg_loss = valid_loss / batch_count
valid_avg_metric = valid_metric / batch_count
prog_bar.set_postfix(loss='%g' % valid_avg_loss,
rouge='%.4g' % (valid_avg_metric * 100))
plot_val_losses.append(valid_avg_loss)
plot_val_metrics.append(valid_avg_metric)
metric_loss = -valid_avg_metric # choose the best model by ROUGE instead of loss
if metric_loss < best_avg_loss:
best_epoch_id = epoch_count
best_avg_loss = metric_loss
else: # no validation, "best" is defined by training loss
if epoch_avg_loss < best_avg_loss:
best_epoch_id = epoch_count
best_avg_loss = epoch_avg_loss
if params.model_path_prefix:
# save model
filename = '%s.%02d.pt' % (params.model_path_prefix, epoch_count)
torch.save(model, filename)
if not params.keep_every_epoch: # clear previously saved models
for epoch_id in range(1, epoch_count):
if epoch_id != best_epoch_id:
try:
prev_filename = '%s.%02d.pt' % (
params.model_path_prefix, epoch_id)
os.remove(prev_filename)
except FileNotFoundError:
pass
# save training status
torch.save(
{
'epoch': epoch_count,
'train_avg_loss': epoch_avg_loss,
'valid_avg_loss': valid_avg_loss,
'valid_avg_metric': valid_avg_metric,
'best_epoch_so_far': best_epoch_id,
'params': params,
'optimizer': optimizer
}, '%s.train.pt' % params.model_path_prefix)
if rl_ratio > 0:
params.rl_ratio **= params.rl_ratio_power
total_batch_count += params.n_batches
show_plot(plot_losses, plot_every, plot_val_losses, plot_val_metrics,
params.n_batches, params.model_path_prefix)
def train_iters(encoder, decoder, encoder_optimizer, decoder_optimizer,
criterion, pars, pairs, val_pairs):
# Train model on a set of sentence pairs
start = time.time()
plot_losses = []
plot_val_losses = []
print_loss_total = 0 # Reset every print_every
plot_loss_total = 0 # Reset every plot_every
val_loss_total = 0 # Initializing validation loss
print('Starting training...')
print_every = pars.print_every
for epoch in range(1, pars.n_epochs + 1):
# Getting training data for this cycle
training_pair = variables_from_pair(random.choice(pairs), pars)
input_variable = training_pair[0]
target_variable = training_pair[1]
# Running the train function
loss = train(input_variable, target_variable, encoder, decoder,
encoder_optimizer, decoder_optimizer, criterion, pars)
# Keeping track of loss
print_loss_total += loss
plot_loss_total += loss
# Printing missing time to user
if epoch % print_every == 0:
print_loss_avg = print_loss_total / float(print_every)
print_loss_total = 0
print_summary = '%s (%d %d%%) %.4f' % (
time_since(start, epoch / float(pars.n_epochs)), epoch,
epoch / float(pars.n_epochs) * 100, print_loss_avg)
print(print_summary)
# eventually save intermediate models
#save_model(encoder, 'encoder_part')
#save_model(decoder, 'decoder_part')
# Adding validation information to plot
if epoch % pars.plot_every == 0:
val_iter = 10
for _ in range(val_iter):
sentence = variables_from_pair(random.choice(val_pairs), pars)
val_loss_total += validation_loss(sentence[0], sentence[1],
encoder, decoder, criterion,
pars)
val_loss_total /= val_iter
plot_val_losses.append(val_loss_total)
val_loss_total = 0
plot_loss_avg = plot_loss_total / float(pars.plot_every)
plot_losses.append(plot_loss_avg)
plot_loss_total = 0
# Saving model
save_model(encoder, 'encoder')
save_model(decoder, 'decoder')
print('... training ended.')
# Printing validation plot
show_plot(plot_losses, plot_val_losses)
from utils import generate_latent_points
from utils import show_plot
from keras.models import load_model
model = load_model("models/generator.h5")
latent_points = generate_latent_points(100, 100)
X = model.predict(latent_points)
show_plot(X, 10)
for j in tqdm(range(n_batch)):
x_img, y_img = generate_dcm_batch(batch_size, latent_dim, G,
x_train)
d_loss, _ = D.train_on_batch(x_img, y_img)
x_hid, y_hid = generate_gan_batch(batch_size, latent_dim)
g_loss = model.train_on_batch(x_hid,
y_hid) # the D is frozen in gan
# summarize loss on this epoch
print('>%d/%d, disc_loss=%.3f, gan_loss=%.3f' %
(i + 1, n_epochs, d_loss, g_loss))
# show generation
print("origin:")
show_plot(x_img, 5)
print("make:")
show_plot(G.predict(x_hid), 5)
def load_real_samples():
from keras.datasets.mnist import load_data
# load mnist dataset
(trainX, _), (_, _) = load_data()
# expand to 3d, e.g. add channels dimension
X = np.expand_dims(trainX, axis=-1)
# convert from unsigned ints to floats
X = X.astype('float32')
# scale from [0,255] to [0,1]
X = X / 255.0
for row in reader:
dataset.append(row)
dataset = np.asarray(dataset).astype("float")
dataset = dataset.reshape((240, 30, 21, 1))
X = np.asarray(dataset, dtype="uint8")
(trainX, testX, trainY, testY) = train_test_split(X,
Y,
test_size=0.25,
random_state=42)
model = MiniVGGNet.build(21, 30, 1, 4)
sgd = SGD(lr=0.001)
model.compile(loss="categorical_crossentropy",
optimizer=sgd,
metrics=["accuracy"])
H = model.fit(trainX,
trainY,
validation_data=(testX, testY),
epochs=10,
batch_size=24)
predictions = model.predict(testX, batch_size=24)
print(
classification_report(testY.argmax(axis=1),
predictions.argmax(axis=1),
target_names=[str(x) for x in lb.classes_]))
model.save("Conv2.h5")
utils.show_plot(H, 10)
def train(train_generator,
vocab: Vocab,
model: Seq2Seq,
params: Params,
valid_generator=None,
saved_state: dict = None,
losses=None):
# variables for plotting
plot_points_per_epoch = max(math.log(params.n_batches, 1.6), 1.)
plot_every = round(params.n_batches / plot_points_per_epoch)
if losses is None:
plot_losses, cached_losses, plot_val_losses, plot_val_metrics = [], [], [], []
else:
plot_losses, cached_losses, plot_val_losses, plot_val_metrics = losses
# total_parameters = sum(parameter.numel() for parameter in model.parameters()
# if parameter.requires_grad)
# print("Training %d trainable parameters..." % total_parameters)
model.to(DEVICE)
if saved_state is None:
if params.optimizer == 'adagrad':
optimizer = optim.Adagrad(
model.parameters(),
lr=params.lr,
initial_accumulator_value=params.adagrad_accumulator)
else:
optimizer = optim.Adam(model.parameters(), lr=params.lr)
past_epochs = 0
total_batch_count = 0
else:
optimizer = saved_state['optimizer']
past_epochs = saved_state['epoch']
total_batch_count = saved_state['total_batch_count']
if params.lr_decay:
lr_scheduler = optim.lr_scheduler.StepLR(optimizer,
params.lr_decay_step,
params.lr_decay,
past_epochs - 1)
criterion = nn.NLLLoss(ignore_index=vocab.PAD)
best_avg_loss, best_epoch_id = float("inf"), None
for epoch_count in range(1 + past_epochs, params.n_epochs + 1):
if params.lr_decay:
lr_scheduler.step()
rl_ratio = params.rl_ratio if epoch_count >= params.rl_start_epoch else 0
epoch_loss, epoch_metric = 0, 0
epoch_avg_loss, valid_avg_loss, valid_avg_metric = None, None, None
prog_bar = tqdm(range(1, params.n_batches + 1),
desc='Epoch %d' % epoch_count)
model.train()
for batch_count in prog_bar: # training batches
if params.forcing_decay_type:
if params.forcing_decay_type == 'linear':
forcing_ratio = max(
0, params.forcing_ratio -
params.forcing_decay * total_batch_count)
elif params.forcing_decay_type == 'exp':
forcing_ratio = params.forcing_ratio * (
params.forcing_decay**total_batch_count)
elif params.forcing_decay_type == 'sigmoid':
forcing_ratio = params.forcing_ratio * params.forcing_decay / (
params.forcing_decay +
math.exp(total_batch_count / params.forcing_decay))
else:
raise ValueError('Unrecognized forcing_decay_type: ' +
params.forcing_decay_type)
else:
forcing_ratio = params.forcing_ratio
batch = next(train_generator)
loss, metric = train_batch(batch,
model,
criterion,
optimizer,
pack_seq=params.pack_seq,
forcing_ratio=forcing_ratio,
partial_forcing=params.partial_forcing,
sample=params.sample,
rl_ratio=rl_ratio,
vocab=vocab,
grad_norm=params.grad_norm,
show_cover_loss=params.show_cover_loss)
epoch_loss += float(loss)
epoch_avg_loss = epoch_loss / batch_count
if metric is not None: # print ROUGE as well if reinforcement learning is enabled
epoch_metric += metric
epoch_avg_metric = epoch_metric / batch_count
prog_bar.set_postfix(loss='%g' % epoch_avg_loss,
rouge='%.4g' % (epoch_avg_metric * 100))
else:
prog_bar.set_postfix(loss='%g' % epoch_avg_loss)
cached_losses.append(loss)
total_batch_count += 1
if total_batch_count % plot_every == 0:
period_avg_loss = sum(cached_losses) / len(cached_losses)
plot_losses.append(period_avg_loss)
cached_losses = []
if valid_generator is not None: # validation batches
valid_loss, valid_metric = 0, 0
prog_bar = tqdm(range(1, params.n_val_batches + 1),
desc='Valid %d' % epoch_count)
model.eval()
for batch_count in prog_bar:
batch = next(valid_generator)
loss, metric = eval_batch(
batch,
model,
vocab,
criterion,
pack_seq=params.pack_seq,
show_cover_loss=params.show_cover_loss)
valid_loss += loss
valid_metric += metric
valid_avg_loss = valid_loss / batch_count
valid_avg_metric = valid_metric / batch_count
prog_bar.set_postfix(loss='%g' % valid_avg_loss,
rouge='%.4g' % (valid_avg_metric * 100))
plot_val_losses.append(valid_avg_loss)
plot_val_metrics.append(valid_avg_metric)
metric_loss = -valid_avg_metric # choose the best model by ROUGE instead of loss
if metric_loss < best_avg_loss:
best_epoch_id = epoch_count
best_avg_loss = metric_loss
else: # no validation, "best" is defined by training loss
if epoch_avg_loss < best_avg_loss:
best_epoch_id = epoch_count
best_avg_loss = epoch_avg_loss
if params.model_path_prefix:
# save model
filename = '%s.%02d.pt' % (params.model_path_prefix, epoch_count)
torch.save(model, filename)
if not params.keep_every_epoch: # clear previously saved models
for epoch_id in range(1 + past_epochs, epoch_count):
if epoch_id != best_epoch_id:
try:
prev_filename = '%s.%02d.pt' % (
params.model_path_prefix, epoch_id)
os.remove(prev_filename)
except FileNotFoundError:
pass
# save training status
torch.save(
{
'epoch': epoch_count,
'total_batch_count': total_batch_count,
'train_avg_loss': epoch_avg_loss,
'valid_avg_loss': valid_avg_loss,
'valid_avg_metric': valid_avg_metric,
'best_epoch_so_far': best_epoch_id,
'params': params,
'optimizer': optimizer,
'train_loss': plot_losses,
'cached_losses': cached_losses,
'val_loss': plot_val_losses,
'plot_val_metrics': plot_val_metrics
}, '%s.train.pt' % params.model_path_prefix)
if rl_ratio > 0:
params.rl_ratio **= params.rl_ratio_power
show_plot(plot_losses, plot_every, plot_val_losses, plot_val_metrics,
params.n_batches, params.model_path_prefix)
if x>=180:
labels.append(labels_name[3])
labels = np.asarray(labels)
lb = LabelBinarizer()
Y = lb.fit_transform(labels)
f = open('data3.csv', "r", encoding='utf-8')
reader = csv.reader(f, delimiter = ",")
for row in reader:
dataset.append(row)
dataset = np.asarray(dataset).astype("float")
(trainX, testX, trainY, testY) = train_test_split(dataset, Y, test_size=0.25, random_state=42)
model = Sequential()
model.add(Dense(256, input_shape=(dataset.shape[1],), activation="sigmoid"))
model.add(Dense(128, activation="sigmoid"))
model.add(Dense(64, activation="sigmoid"))
model.add(Dense(32, activation="sigmoid"))
#model.add(Dropout(0.25))
model.add(Dense(4, activation="softmax"))
sgd = SGD(0.05, decay=0.05 / 200, nesterov=True)
model.compile(loss="categorical_crossentropy", optimizer=sgd,
metrics=["accuracy"])
H = model.fit(trainX, trainY, validation_data=(testX, testY),
epochs=150, batch_size=24)
predictions = model.predict(testX, batch_size=24)
print(classification_report(testY.argmax(axis=1),
predictions.argmax(axis=1),
target_names=[str(x) for x in lb.classes_]))
model.save("safe_doors_Randomed4.h5")
utils.show_plot(H, 150)
