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)