def main(argv=None): model = CNN( train_images_dir='data/train/', val_images_dir='data/val/', test_images_dir='data/test/', num_epochs=40, train_batch_size=1000, val_batch_size=1000, test_batch_size=10000, height_of_image=28, width_of_image=28, num_channels=1, num_classes=10, learning_rate=0.001, base_dir='results', max_to_keep=2, model_name="CNN", model='CNN' ) model.create_network() model.initialize_network() if True: model.train_model(1, 1, 1, 4) else: model.test_model()
def main(argv=None): model = CNN(train_images_dir=FLAGS.train_images_dir, val_images_dir=FLAGS.val_images_dir, test_images_dir=FLAGS.test_images_dir, inference_dir=FLAGS.inference_dir, num_epochs=FLAGS.num_epochs, train_batch_size=FLAGS.train_batch_size, val_batch_size=FLAGS.val_batch_size, height_of_image=FLAGS.height_of_image, width_of_image=FLAGS.width_of_image, num_channels=FLAGS.num_channels, num_classes=FLAGS.num_classes, learning_rate=FLAGS.learning_rate, base_dir=FLAGS.base_dir, max_to_keep=FLAGS.max_to_keep, model_name=FLAGS.model_name, keep_prob=FLAGS.keep_prob) model.create_network() model.initialize_network() if FLAGS.train: model.train_model(FLAGS.display_step, FLAGS.validation_step, FLAGS.checkpoint_step, FLAGS.summary_step) else: model.test_model()
def main(epochs=5, learning_rate=1e-3): # use GPU device = torch.device('cuda') # get data loaders training = get_dataloader(train=True) testing = get_dataloader(train=False) # model model = CNN().to(device) info('Model') print(model) # cost function cost = torch.nn.BCELoss() # optimizers optimizer = optim.Adam(model.parameters(), lr=learning_rate) for epoch in range(1, epochs + 1): info('Epoch {}'.format(epoch)) train(model, device, training, cost, optimizer, epoch) test(model, device, testing, cost) # save model info('Saving Model') save_model(model, device, 'model.onnx') print('Saving PyTorch Model as model.pth') torch.save(model.state_dict(), 'model.pth')
def __init__(self, _hparams): self.test_loader = get_test_loader(_hparams) self.encoder = CNN().to(DEVICE) self.decoder = RNN(fea_dim=_hparams.fea_dim, embed_dim=_hparams.embed_dim, hid_dim=_hparams.hid_dim, max_sen_len=_hparams.max_sen_len, vocab_pkl=_hparams.vocab_pkl).to(DEVICE) self.test_cap = _hparams.test_cap
def bilstm_train(self, numEpochs, batch_size, save_file, lr): print('training .....') # set up loss function -- 'SVM Loss' a.k.a ''Cross-Entropy Loss loss_func = nn.CrossEntropyLoss() net = CNN(embed_dim=100) # net.load_state_dict(torch.load('model_50.pth')) # SGD used for optimization, momentum update used as parameter update optimization = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9) net.cuda() loss_func.cuda() train_losses = [] test_losses = [] for epoch in range(0,numEpochs): # training set -- perform model training epoch_training_loss = 0.0 num_batches = 0 pbar = tqdm(range(0, len(self.train_seqs), batch_size)) for batch_num in pbar: # 'enumerate' is a super helpful function # split training data into inputs and labels if batch_num+batch_size>len(self.train_seqs): end = len(self.action_seqs) else: end = batch_num+batch_size raw_inputs, labels_ = self.train_seqs[batch_num:end], self.train_labels[batch_num:end] # 'training_batch' is a list inputs_ = self.get_embedding(raw_inputs) inputs = torch.from_numpy(inputs_).float().cuda() labels = torch.from_numpy(labels_).cuda() # wrap data in 'Variable' inputs, labels = torch.autograd.Variable(inputs), torch.autograd.Variable(labels) # Make gradients zero for parameters 'W', 'b' optimization.zero_grad() # forward, backward pass with parameter update forward_output = net(inputs) loss = loss_func(forward_output, labels) loss.backward() optimization.step() # calculating loss epoch_training_loss += loss.data.item() num_batches += 1 # print(loss.data.item()) pbar.set_description("processing batch %s" % str(batch_num)) print("epoch: ", epoch, ", loss: ", epoch_training_loss / num_batches) # train_loss = self.test(net, batch_size=256, test_data=self.train_seqs, test_label=self.train_labels) test_loss = self.test(net, batch_size=256, test_data=self.test_seqs, test_label=self.test_labels) # train_losses.append(train_loss) test_losses.append(test_loss) # if epoch%10 == 0: # save_path = save_file+'model3_' +str(epoch)+'.pth' # torch.save(net.state_dict(), save_path) # with open('train_loss_1.p','wb') as fin: # pickle.dump(train_losses,fin) # fin.close() with open('test_loss_1.p','wb') as fin: pickle.dump(test_losses,fin) fin.close()
def build(self, is_train): self.model = CNN(self.config) self.loss_fn = self.config.loss_fn() if is_train: self.model.train() self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr) else: self.model.eval()
def check_model(self, X_train, X_val, y_train, y_val, X_test, y_test, raw_seq): """ Funtion used to navigate to the specific model. The is defined when initialising the class. Reads the self.model_type Each statement does the following: - Calls function to format data for the model - Calls funtion to train the model - Calls funtion to plot the MSE graph - Calls funtion to test the model - Returns the accuarcy as R2 score""" if self.model_type == 'CNN': X_train, X_val, y_train, n_input, n_output, ytrain1, ytrain2, ytrain3, ytrain4 = CNN.data_format( X_train, X_val, y_train) history = CNN.CNN_train_model(self, X_train, X_val, y_train, y_val, self.verbose, n_input, n_output, ytrain1, ytrain2, ytrain3, ytrain4) Models.plotting(history) yhat = CNN.CNN_test_model(self, X_test, self.verbose, y_test) Models.accuracy(self, yhat, y_test, X_test, self.model_type) if self.model_type == 'MLP': X_train, X_val, y_train, n_input, n_output, ytrain1, ytrain2, ytrain3, ytrain4 = MLP.data_format( X_train, X_val, y_train) history = MLP.MLP_train_model(self, X_train, X_val, y_train, y_val, self.verbose, n_input, n_output, ytrain1, ytrain2, ytrain3, ytrain4) # Models.plotting(history) yhat, final_cols = MLP.MLP_test_model(X_test, self.verbose, y_test) Models.accuracy(self, yhat, y_test, final_cols, self.model_type) if self.model_type == 'KNN': X_train, X_val, y_train, X_test = KNN.data_format( X_train, X_val, y_train, X_test) yhat, final_cols = KNN.KNN_train_model(self, X_train, X_val, y_train, y_val, X_test, y_test, raw_seq) Models.accuracy(self, yhat, y_test, final_cols, self.model_type) if self.model_type == 'LSTM': history, model = LSTMs.LSTM_train_model(self, X_train, X_val, y_train, y_val, self.verbose) Models.plotting(history) yhat = LSTMs.LSTM_test_model(X_test, model, self.verbose, y_test) Models.accuracy(self, yhat, y_test, X_test, self.model_type) if self.model_type == 'BASELINE': n_input, X_train, n_output = BaseLine.data_format(X_train, y_train) model = BaseLine.baseline_train(self, X_train, y_train, n_input, n_output) yhat, final_cols = BaseLine.baseline_test(X_test, n_input, model) Models.accuracy(self, yhat, y_test, final_cols, self.model_type)
def test_pl_model(): mnist = mnist_data() cnn = CNN(num_channels=mnist.dims[0], num_classes=mnist.num_classes) # Architecture BaseLitModel(datamodule=mnist, backbone=cnn, lr=1e-3, flood_height=0) # Lightning model cnn = CNN(num_channels=mnist.dims[0], num_classes=mnist.num_classes, maxpool=False) BaseLitModel(datamodule=mnist, backbone=cnn, lr=1e-3, flood_height=0)
def train(): fluid.enable_dygraph(device) processor = SentaProcessor(data_dir=args.data_dir, vocab_path=args.vocab_path, random_seed=args.random_seed) num_labels = len(processor.get_labels()) num_train_examples = processor.get_num_examples(phase="train") max_train_steps = args.epoch * num_train_examples // args.batch_size // dev_count train_data_generator = processor.data_generator( batch_size=args.batch_size, padding_size=args.padding_size, places=device, phase='train', epoch=args.epoch, shuffle=False) eval_data_generator = processor.data_generator( batch_size=args.batch_size, padding_size=args.padding_size, places=device, phase='dev', epoch=args.epoch, shuffle=False) if args.model_type == 'cnn_net': model = CNN(args.vocab_size, args.batch_size, args.padding_size) elif args.model_type == 'bow_net': model = BOW(args.vocab_size, args.batch_size, args.padding_size) elif args.model_type == 'gru_net': model = GRU(args.vocab_size, args.batch_size, args.padding_size) elif args.model_type == 'bigru_net': model = BiGRU(args.vocab_size, args.batch_size, args.padding_size) optimizer = fluid.optimizer.Adagrad(learning_rate=args.lr, parameter_list=model.parameters()) inputs = [Input([None, None], 'int64', name='doc')] labels = [Input([None, 1], 'int64', name='label')] model.prepare(optimizer, CrossEntropy(), Accuracy(topk=(1, )), inputs, labels, device=device) model.fit(train_data=train_data_generator, eval_data=eval_data_generator, batch_size=args.batch_size, epochs=args.epoch, save_dir=args.checkpoints, eval_freq=args.eval_freq, save_freq=args.save_freq)
def run(args): if not os.path.exists(args.logdir): os.makedirs(args.logdir) logger = get_logger(os.path.join(args.logdir, 'main.log')) logger.info(args) # data source_transform = transforms.Compose([ # transforms.Grayscale(), transforms.ToTensor()] ) target_transform = transforms.Compose([ transforms.Resize(32), transforms.ToTensor(), transforms.Lambda(lambda x: x.repeat(3, 1, 1)) ]) source_dataset_train = SVHN( './input', 'train', transform=source_transform, download=True) target_dataset_train = MNIST( './input', train=True, transform=target_transform, download=True) target_dataset_test = MNIST( './input', train=False, transform=target_transform, download=True) source_train_loader = DataLoader( source_dataset_train, args.batch_size, shuffle=True, drop_last=True, num_workers=args.n_workers) target_train_loader = DataLoader( target_dataset_train, args.batch_size, shuffle=True, drop_last=True, num_workers=args.n_workers) target_test_loader = DataLoader( target_dataset_test, args.batch_size, shuffle=False, num_workers=args.n_workers) # train source CNN source_cnn = CNN(in_channels=args.in_channels).to(args.device) if os.path.isfile(args.trained): print("load model") c = torch.load(args.trained) source_cnn.load_state_dict(c['model']) logger.info('Loaded `{}`'.format(args.trained)) else: print("not load model") # train target CNN target_cnn = CNN(in_channels=args.in_channels, target=True).to(args.device) target_cnn.load_state_dict(source_cnn.state_dict()) discriminator = Discriminator(args=args).to(args.device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam( target_cnn.encoder.parameters(), lr=args.lr, betas=args.betas, weight_decay=args.weight_decay) d_optimizer = optim.Adam( discriminator.parameters(), lr=args.lr, betas=args.betas, weight_decay=args.weight_decay) train_target_cnn( source_cnn, target_cnn, discriminator, criterion, optimizer, d_optimizer, source_train_loader, target_train_loader, target_test_loader, args=args)
def character_classification(): print('Loading data...') x, y = load_data_chars() print('Processing data..') print('Training data shape: ', x.shape) print('Test data shape: ', y.shape) plots.plot_filters(x[0]) SVM.svm(x, y) Naive_Bayes.naive_bayes(x, y) KNN.knn(x, y) CNN.fit_cnn(x, y, trials=1, network_type='simple')
class Tester: """ 测试 """ def __init__(self, _hparams): self.test_loader = get_test_loader(_hparams) self.encoder = CNN().to(DEVICE) self.decoder = RNN(fea_dim=_hparams.fea_dim, embed_dim=_hparams.embed_dim, hid_dim=_hparams.hid_dim, max_sen_len=_hparams.max_sen_len, vocab_pkl=_hparams.vocab_pkl).to(DEVICE) self.test_cap = _hparams.test_cap def testing(self, save_path, test_path): """ 测试 :param save_path: 模型的保存地址 :param test_path: 保存测试过程生成句子的路径 :return: """ print('*' * 20, 'test', '*' * 20) self.load_models(save_path) self.set_eval() sen_json = [] with torch.no_grad(): for val_step, (img, img_id) in tqdm(enumerate(self.test_loader)): img = img.to(DEVICE) features = self.encoder.forward(img) sens, _ = self.decoder.sample(features) sen_json.append({'image_id': int(img_id), 'caption': sens[0]}) with open(test_path, 'w') as f: json.dump(sen_json, f) result = coco_eval(self.test_cap, test_path) for metric, score in result: print(metric, score) def load_models(self, save_path): ckpt = torch.load(save_path, map_location={'cuda:2': 'cuda:0' }) # 映射是因为解决保存模型的卡与加载模型的卡不一致的问题 encoder_state_dict = ckpt['encoder_state_dict'] self.encoder.load_state_dict(encoder_state_dict) decoder_state_dict = ckpt['decoder_state_dict'] self.decoder.load_state_dict(decoder_state_dict) def set_eval(self): self.encoder.eval() self.decoder.eval()
def main(): parser = argparse.ArgumentParser(description="FGSM") parser.add_argument("--device", type=str, default="cuda") parser.add_argument("--data_root", type=str, default="./data") parser.add_argument("--data_name", type=str, default="mnist") parser.add_argument("--image_size", type=int, default=32) parser.add_argument("--image_channels", type=int, default=1) parser.add_argument("--epsilon", type=int, default=0.1) opt = parser.parse_args() model = CNN(opt.image_size, opt.image_channels).to(opt.device) model.load_state_dict(torch.load("./weights/cnn.pth")) test(model, opt)
def build(self, is_train): if torch.cuda.is_available(): self.model = nn.DataParallel(CNN(self.config)).cuda() else: self.model = CNN(self.config) self.loss_fn = self.config.loss_fn() if is_train: self.model.train() self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr) else: if torch.cuda.is_available(): self.model = self.model.module self.model.eval()
def __init__(self, ckpt_path): super().__init__() self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(256), transforms.ToTensor() ]) self.checkpoint = torch.load(ckpt_path) self.model = CNN() self.model.load_state_dict(state_dict=self.checkpoint['state_dict']) self.use_cuda = False self.model.eval() if torch.cuda.is_available(): self.model.cuda() self.use_cuda = True
def main(args): train, test = datasets.get_mnist(withlabel=True, ndim=3) train_iter = iterators.SerialIterator(train, args.batchsize) test_iter = iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) model = L.Classifier(CNN()) if args.gpu >= 0: cuda.check_cuda_available() cuda.get_device(args.gpu).use() model.to_gpu() optimizer = optimizers.Adam() optimizer.setup(model) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epochs, 'epoch')) trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) trainer.extend(extensions.LogReport()) # Default log report trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy' ])) trainer.extend(extensions.ProgressBar()) trainer.run()
def _train(self, train_images, train_labels, test_images, test_labels): # PARAMETERS epoch = 1000 batch_size = 512 early = EarlyStopping(monitor='loss', min_delta=0, patience=300, verbose=1, mode='auto') # BUILD MODEL self.model = CNN.get_model() #%%time hist = self.model.fit(train_images, train_labels, epochs=epoch, batch_size=batch_size, validation_data=(test_images[:-2000], test_labels[:-2000]), verbose=1, callbacks=[early]) # plot loss and test scatter self._plot(hist, test_images[-2000:], test_labels[-2000:]) # save model h5_file = os.path.join(self.temp_path, 'model.h5') self.model.save(h5_file)
def slicing_window(img, model_weights): stride_width = 5 stride_height = 5 width = 20 height = 20 network = CNN.CNN(num_classes=27, sample=img[0, 0:0 + height, 0:0 + height], model_weights=model_weights, network_type='simple') predictions = [] for i in range(0, img.shape[1] - height, stride_height): for j in range(0, img.shape[2] - width, stride_width): predicted_prob = network.predict_character(img[:, i:i + height, j:j + width]) if np.amax(predicted_prob) > 0.7 and np.argmax( predicted_prob) != 0 and check_if_all_zero( img[:, i:i + height, j:j + width]): predictions.append([np.argmax(predicted_prob), j, i]) print(str(chr(96 + np.argmax(predicted_prob))), j, i) fig, ax = plt.subplots(1) ax.imshow(img[0, :, :, 0], cmap='gray') for i in range(len(predictions)): rect = patches.Rectangle((predictions[i][1], predictions[i][2]), 20, 20, linewidth=1, edgecolor='r', facecolor='none') # Add the patch to the Axes ax.add_patch(rect) plt.show()
def infer(): fluid.enable_dygraph(device) processor = SentaProcessor(data_dir=args.data_dir, vocab_path=args.vocab_path, random_seed=args.random_seed) infer_data_generator = processor.data_generator( batch_size=args.batch_size, padding_size=args.padding_size, places=device, phase='infer', epoch=1, shuffle=False) if args.model_type == 'cnn_net': model_infer = CNN(args.vocab_size, args.batch_size, args.padding_size) elif args.model_type == 'bow_net': model_infer = BOW(args.vocab_size, args.batch_size, args.padding_size) elif args.model_type == 'gru_net': model_infer = GRU(args.vocab_size, args.batch_size, args.padding_size) elif args.model_type == 'bigru_net': model_infer = BiGRU(args.vocab_size, args.batch_size, args.padding_size) print('Do inferring ...... ') inputs = [Input([None, None], 'int64', name='doc')] model_infer.prepare(None, CrossEntropy(), Accuracy(topk=(1, )), inputs, device=device) model_infer.load(args.checkpoints, reset_optimizer=True) preds = model_infer.predict(test_data=infer_data_generator) preds = np.array(preds[0]).reshape((-1, 2)) if args.output_dir: with open(os.path.join(args.output_dir, 'predictions.json'), 'w') as w: for p in range(len(preds)): label = np.argmax(preds[p]) result = json.dumps({ 'index': p, 'label': label, 'probs': preds[p].tolist() }) w.write(result + '\n') print('Predictions saved at ' + os.path.join(args.output_dir, 'predictions.json'))
def main(): parser = argparse.ArgumentParser(description="CNN") parser.add_argument("--num_epoch", type=int, default=30) parser.add_argument("--batch_size", type=int, default=64) parser.add_argument("--device", type=str, default="cuda") parser.add_argument("--data_root", type=str, default="./data") parser.add_argument("--data_name", type=str, default="mnist") parser.add_argument("--image_size", type=int, default=32) parser.add_argument("--image_channels", type=int, default=1) opt = parser.parse_args() model = CNN(opt.image_size, opt.image_channels).to(opt.device) for epoch in range(opt.num_epoch): loss = train(model, opt) print("loss: {:.6f}".format(loss)) torch.save(model.state_dict(), "./weights/cnn.pth")
def test_SimSiam(): cnn = CNN(num_channels=1, num_classes=10, maxpool=False, wpool=5, p_dropout=0.0) simsiam = SimSiam(backbone=cnn, p_dropout=0.0) return simsiam
def main(): dataset = 'new' # Which dataset to use batch_size = 12 epochs = 50 model = net.create_model() current_dir = os.path.dirname(__file__) training_dir = os.path.join(current_dir, 'datasets/', dataset, 'training/') validation_dir = os.path.join(current_dir, 'datasets/', dataset, 'validation/') # Calculate training & validation steps num_images = 0 for folder in ['true/', 'false/']: dir = os.path.join(training_dir, folder) num_images += len(os.listdir(dir)) train_steps = num_images / batch_size num_images = 0 for folder in ['true/', 'false/']: dir = os.path.join(validation_dir, folder) num_images += len(os.listdir(dir)) val_steps = num_images / batch_size print('Dataset: ' + dataset) print('batch_size: ' + str(batch_size)) print('train_steps: ' + str(train_steps)) print('val_steps: ' + str(val_steps)) print('epochs: ' + str(epochs)) # All images will be rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1. / 255) valid_datagen = ImageDataGenerator(rescale=1. / 255) # Flow training images in batches of 20 using train_datagen generator train_generator = train_datagen.flow_from_directory( training_dir, # This is the source directory for training images target_size=(150, 150), # All images will be resized to 150x150 batch_size=batch_size, # Since we use binary_crossentropy loss, we need binary labels class_mode='binary') # Flow validation images in batches of 20 using test_datagen generator validation_generator = valid_datagen.flow_from_directory( validation_dir, target_size=(150, 150), batch_size=batch_size, class_mode='binary') # Train model history = model.fit_generator(train_generator, steps_per_epoch=train_steps, epochs=epochs, validation_data=validation_generator, validation_steps=val_steps, verbose=2) evaluate(history)
def predict(img_dir='./data/test'): transforms = Compose([Resize(height, weight), ToTensor()]) dataset = CaptchaData(img_dir, transform=transforms) cnn = CNN() if torch.cuda.is_available(): cnn = cnn.cuda() cnn.eval() cnn.load_state_dict(torch.load(model_path)) for k, (img, target) in enumerate(dataset): img = img.view(1, 3, height, weight).cuda() target = target.view(1, 4 * 36).cuda() output = cnn(img) output = output.view(-1, 36) target = target.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) target = torch.argmax(target, dim=1) output = output.view(-1, 4)[0] target = target.view(-1, 4)[0] print('pred: ' + ''.join([alphabet[i] for i in output.cpu().numpy()])) print('true: ' + ''.join([alphabet[i] for i in target.cpu().numpy()])) plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy()) plot.show() if k >= 10: break
def post_predict(): text = "failure" if request.method == 'POST': file = request.get_data() img = Image.open(BytesIO(file)).convert('RGB') print('宽:%d,高:%d' % (img.size[0], img.size[1])) width = img.size[0] height = img.size[1] transform = Compose([Resize(height, width), ToTensor()]) img = transform(img) cnn = CNN() if torch.cuda.is_available(): cnn = cnn.cuda() cnn.eval() cnn.load_state_dict(torch.load(model_path, map_location='cpu')) img = img.view(1, 3, height, width).cuda() output = cnn(img) output = output.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) output = output.view(-1, 4)[0] text = ''.join([alphabet[i] for i in output.cpu().numpy()]) # print('pred: '+text) # plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy()) # plot.show() return text
def predict(img_dir=Path('./captcha')): transforms = Compose([ToTensor()]) for i in img_dir.glob("*png"): print(i.name) img = img_loader('./captcha/%s' % i.name) img = transforms(img) cnn = CNN() cnn.load_state_dict(torch.load(model_path)) img = img.view(1, 3, 36, 120) output = cnn(img) output = output.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) output = output.view(-1, num_class)[0] pred = ''.join([alphabet[i] for i in output.cpu().numpy()]) print(pred)
def train(model_type, epochs, batch_size, logdir): ds_train, ds_test = tfds.load('cifar10', split=['train', 'test'], as_supervised=True) num_samples = 50000 num_samples_test = 10000 ds_train = ds_train.shuffle(num_samples)\ .batch(batch_size)\ .map(preprocess, num_parallel_calls=tf.data.experimental.AUTOTUNE)\ .repeat(epochs)\ .prefetch(buffer_size=tf.data.experimental.AUTOTUNE) ds_test = ds_test.batch(batch_size)\ .map(preprocess, num_parallel_calls=tf.data.experimental.AUTOTUNE)\ .repeat(epochs)\ .prefetch(buffer_size=tf.data.experimental.AUTOTUNE) kl_div_fn = (lambda q, p, _: tfd.kl_divergence(q, p) / num_samples) if model_type == 'normal': model = CNN(num_classes=10) elif model_type == 'reparam': model = ReparamCNN(num_classes=10, kernel_divergence_fn=kl_div_fn) else: model = FlipOutCNN(num_classes=10, kernel_divergence_fn=kl_div_fn) # Set input_shape explicitly (before compile) to instantiate model.losses model.build(input_shape=[None, 32, 32, 3]) optimizer = optimizers.Adam() loss_fn = losses.SparseCategoricalCrossentropy(from_logits=True) metrics = [tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy')] model.compile(optimizer, loss=loss_fn, metrics=metrics) callbacks = [tf.keras.callbacks.TensorBoard(log_dir=logdir)] model.fit(ds_train, epochs=epochs, callbacks=callbacks, validation_data=ds_test, steps_per_epoch=num_samples // batch_size, validation_steps=num_samples_test // batch_size) return None
def __init__(self, paths, batch_size=6, iterations=50, initial_lr=0.003, hidden_size=256, dropout=0.2, kernel_sz=3): self.use_cuda = torch.cuda.is_available() self.device = torch.device('cuda:0' if self.use_cuda else 'cpu') self.data = DataReader(paths) self.data.set_training_data(batch_size, ('cuda:0' if self.use_cuda else 'cpu')) self.train_batch_loader = BatchGenerator(self.data.train_data, 'Sentence', 'Label') self.val_batch_loader = BatchGenerator(self.data.val_data, 'Sentence', 'Label') self.test_batch_loader = BatchGenerator(self.data.test_data, 'Sentence', 'Label') # Store hyperparameters self.batch_size = batch_size self.iterations = iterations self.initial_lr = initial_lr self.kernel_sz = kernel_sz # Create Model emb_size, emb_dim = self.data.TEXT.vocab.vectors.size() self.cnn_model = CNN(emb_size=emb_size, emb_dimension=emb_dim, n_out=len(self.data.LABEL.vocab), dropout=dropout, kernel_sz=kernel_sz, stride=1, padding=0, out_filters=hidden_size, pretrained_emb=self.data.TEXT.vocab.vectors) if self.use_cuda: self.cnn_model.cuda()
def main(args): print('[*] Arguments: %s' % args) print('[*] Read MNIST...') num_test_images = args.num_test_images images, labels = load_mnist('test', path='./data', max_ind=num_test_images) images, labels = images[:num_test_images, :, :], labels[:num_test_images] images = images.astype(np.float32) images = images / 255. print('[*] The shape of image: %s' % str(images.shape)) print('[*] Load the network...') if args.network == 'mlp': # Lab 2 if args.quantized: print('[!] MLP does not support quantization') return model_path = os.path.join('./pretrained_weights', 'mlp_iter_10000.caffemodel') net = MLP(model_path, args) elif args.network == 'cnn': if args.quantized: # Lab 14 model_path = os.path.join('./pretrained_weights', 'quantized_cnn_weights.txt') else: # Lab 11 model_path = os.path.join('./pretrained_weights', 'cnn_weights.txt') net = CNN(model_path, args) else: raise print('[*] Run tests...') test_images = [images[i, :, :].copy() for i in xrange(num_test_images)] n_correct = 0 start_time = time.time() for i in xrange(num_test_images): X = test_images[i] X = X.reshape((28 * 28)) # 28x28->784 logit = net.inference(X) prediction = np.argmax(logit) label = labels[i, ] n_correct += (label == prediction) print('[*] Statistics...') model_stats = { 'total_time': time.time() - start_time, 'total_image': num_test_images, 'accuracy': float(n_correct) / num_test_images, 'avg_num_call': net.total_num_call[0] / num_test_images, 'm_size': net.m_size, 'v_size': net.v_size, } pp.pprint(model_stats)
def __init__(self, _hparams): utils.set_seed(_hparams.fixed_seed) self.train_loader = get_train_loader(_hparams) self.val_loader = get_val_loader(_hparams) self.encoder = CNN().to(DEVICE) self.decoder = RNN(fea_dim=_hparams.fea_dim, embed_dim=_hparams.embed_dim, hid_dim=_hparams.hid_dim, max_sen_len=_hparams.max_sen_len, vocab_pkl=_hparams.vocab_pkl).to(DEVICE) self.loss_fn = nn.CrossEntropyLoss() self.optimizer = torch.optim.Adam(self.get_params(), lr=_hparams.lr) self.writer = SummaryWriter() self.max_sen_len = _hparams.max_sen_len self.val_cap = _hparams.val_cap self.ft_encoder_lr = _hparams.ft_encoder_lr self.ft_decoder_lr = _hparams.ft_decoder_lr self.best_CIDEr = 0
def run_forrest_run(dataset_list, activation_list, modelname): for dataset_name in dataset_list: for name in activation_list: for model in modelname: if model == "DNN": dataset = Datasets() if (dataset_name == 'MNIST'): x_train, x_test, y_train, y_test = dataset.get_mnist( "DNN") num_classes = dataset.num_classes input_shape = dataset.input_shape elif (dataset_name == 'Fashion-MNIST'): x_train, x_test, y_train, y_test = dataset.get_fashion_mnist( "DNN") num_classes = dataset.num_classes input_shape = dataset.input_shape dnn = DNN(name) score, history = dnn.run_model(input_shape, x_train, x_test, y_train, y_test, 1) else: dataset = Datasets() if (dataset_name == 'MNIST'): x_train, x_test, y_train, y_test = dataset.get_mnist( "CNN") elif (dataset_name == 'Fashion-MNIST'): x_train, x_test, y_train, y_test = dataset.get_fashion_mnist( "CNN") num_classes = dataset.num_classes input_shape = dataset.input_shape if model == "CNN": cnn = CNN(name) score, history = cnn.run_model(input_shape, x_train, x_test, y_train, y_test) elif model == "CAE": cae = CAE(name) score, history = cae.run_model(input_shape, x_train, x_test, y_train, y_test) score, history = cnn.run_model(input_shape, x_train, x_test, y_train, y_test) plot_model(history, name, model, dataset_name)