def main(): IMAGE_PATH = "/home/gonken2019/Desktop/subProject/images" # LABELS_PATH = "/home/gonken2019/Desktop/subProject/labels/" # BATCH_SIZE = 512 #BATCH_SIZE = 10 #RuntimeError: size mismatch, m1: [10 x 12544], m2: [9216 x 4096] at /pytorch/aten/src/TH/generic/THTensorMath.cpp:197 #9216×4096=37748736 #37748736÷12544=3009.306122449 #4096=2**12 #BATCH_SIZE = 8 #RuntimeError: size mismatch, m1: [8 x 12544], m2: [9216 x 4096] at /pytorch/aten/src/TH/generic/THTensorMath.cpp:197 NUM_EPOCH = 50 #多くて20~30 if torch.cuda.is_available(): device = "cuda" print("[Info] Use CUDA") else: device = "cpu" model = AlexNet() dataloaders = Dataloaders(IMAGE_PATH, LABELS_PATH, BATCH_SIZE) # optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4) optimizer = torch.optim.AdamW(model.parameters(), lr=0.001, weight_decay=5e-4) #lossがnanになるのはよくあるので、こういうときはoptimizerを変えるか学習率変えるかするといい trainer = MyTrainer(model, dataloaders, optimizer, device) trainer.run(NUM_EPOCH) #
def main(): IMAGE_PATH = "/home/gonken2019/Desktop/subProject/dataset45" #"/home/gonken2019/Desktop/subProject/images"# LABELS_PATH = "/home/gonken2019/Desktop/subProject/poseData45/" #"/home/gonken2019/Desktop/subProject/labels/"# BATCH_SIZE = 256 #こことsubmodel.py 85行目と113行目の最初の引数を変える NUM_EPOCH = 20 #多くて20~30 if torch.cuda.is_available(): device = "cuda" print("[Info] Use CUDA") else: device = "cpu" model1 = AlexNet() model2 = PositionNet() dataloaders = Dataloaders(IMAGE_PATH, LABELS_PATH, BATCH_SIZE) # optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4) optimizer1 = torch.optim.AdamW(model1.parameters(), lr=0.00001, weight_decay=5e-4) optimizer2 = torch.optim.AdamW(model2.parameters(), lr=0.0001, weight_decay=5e-4) #lossがnanになるのはよくあるので、こういうときはoptimizerを変えるか学習率変えるかするといい trainer1 = MyTrainer(model1, dataloaders, optimizer1, device, "Classification") trainer2 = MyTrainer(model2, dataloaders, optimizer2, device, "Regression") trainer1.run(NUM_EPOCH) trainer2.run(NUM_EPOCH)
def main(): with open("config.json", "r") as f: config = json.load(f) # Load Cifar data = DataLoader(config) # Create AlexNet model net = AlexNet(config) # pdb.set_trace() # Create trainer trainer = Trainer(net.model, data, config) # Train model trainer.train() # Save model weights trainer.save_model() # Load weights net.model = trainer.load_model(config["load_model"]) # Evaluation test set trainer.evaluate()
def eval(args): device = torch.device(f"cuda:{args.device_id}") model = AlexNet(n_cls = 100) model.to(device) model.load_state_dict(torch.load(args.pretrained_path)) model.eval() test_loader = getLoaders(split="eval", batch_size = args.batch_size, num_workers=args.num_workers ) pred_arr = [] label_arr = [] with torch.no_grad(): for idx, (img, label) in tqdm(enumerate(test_loader),total= len(test_loader)): img = img.to(device) pred = model.pred(img) # mean of softmax prob from 10 different aug pred = pred.view(-1, 10, 100) pred = pred.mean(dim = 1) pred_arr.append(pred.detach().cpu().numpy()) label_arr.append(label.detach().numpy()) pred_np = np.concatenate(pred_arr) label_np = np.concatenate(label_arr) top_1 = utils.top_k_acc(k = 1, pred = pred_np, label= label_np) top_5 = utils.top_k_acc(k = 5, pred = pred_np, label= label_np) confusion = utils.confusion_matrix(100, pred_np, label_np) torch.save({ "top_1": top_1, "top_5": top_5, "confusion": confusion, }, "result.pth") print(f"top_1: {top_1*100:.2f}, top_5: {top_5*100:.2f}")
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") data_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # load image img_path = "/home/zhongsy/datasets/imgs_2/2.jpg" assert os.path.exists(img_path), "file: '{}' dose not exist.".format( img_path) img = Image.open(img_path) plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) # read class_indict json_path = './class_indices.json' assert os.path.exists(json_path), "file: '{}' dose not exist.".format( json_path) json_file = open(json_path, "r") class_indict = json.load(json_file) # create model model = AlexNet(num_classes=2).to(device) # load model weights weights_path = "./AlexNet.pth" # assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path) # model.load_state_dict(torch.load(weights_path)) model = torch.load(weights_path) model.eval() with torch.no_grad(): # predict class output = torch.squeeze(model(img.to(device))).cpu() predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print_res = "class: {} prob: {:.3}".format( class_indict[str(predict_cla)], predict[predict_cla].numpy()) plt.title(print_res) print(print_res) plt.show()
def load_model(self): if self.cuda: self.device = torch.device('cuda:0') cudnn.benchmark = True else: self.device = torch.device('cpu') # self.model = LeNet().to(self.device) self.model = AlexNet().to(self.device) self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr) self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer, milestones=[75, 150], gamma=0.5) self.criterion = nn.CrossEntropyLoss().to(self.device)
def main(): start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch # Data print('==> Preparing dataset %s' % args.dataset) transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) if args.dataset == 'cifar10': dataloader = datasets.CIFAR10 num_classes = 10 else: dataloader = datasets.CIFAR100 num_classes = 100 trainset = dataloader(root=args.dataroot, train=True, download=True, transform=transform_train) trainloader = data.DataLoader(dataset=trainset, batch_size=args.train_batch, shuffle=False) testset = dataloader(root=args.dataroot, train=False, download=False, transform=transform_test) testloader = data.DataLoader(testset, batch_size=args.test_batch, shuffle=False, num_workers=args.workers) # Model print("==> creating model '{}'".format("Alexnet")) model = AlexNet(num_classes=num_classes) model = model.cuda() print('Model on cuda') cudnn.benchmark = True print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters())/1000000.0)) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # Train and val for epoch in range(start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) train_loss, train_acc = train(trainloader, model, criterion, optimizer, epoch, use_cuda) test_loss, test_acc = test(testloader, model, criterion, epoch, use_cuda) print('Epoch[{}/{}]: LR: {:.3f}, Train loss: {:.5f}, Test loss: {:.5f}, Train acc: {:.2f}, Test acc: {:.2f}.'.format(epoch+1, args.epochs, state['lr'], train_loss, test_loss, train_acc, test_acc))
def main(): _, _, test_x, test_y, label2name = cifar_10_data(FLAGS.data_dir) test_x = test_x[0:1000] test_y = test_y[0:1000] with tf.name_scope("input_data"): X = tf.placeholder(tf.float32, [None, 32, 32, 3], name='input') predict = AlexNet(X) with tf.name_scope("output_data"): Y = tf.placeholder(tf.int32, [None]) Y_onehot = tf.cast(tf.one_hot(Y, 10, 1, 0), tf.float32) istrue = tf.equal(tf.argmax(predict, 1), tf.argmax(Y_onehot, 1)) accuary = tf.reduce_mean(tf.cast(istrue, tf.float32)) loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y_onehot, logits=predict)) with tf.Session() as sess: saver = tf.train.Saver(tf.global_variables(), max_to_keep=3) ckpt = tf.train.get_checkpoint_state("checkpoint/") if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) var_test_acc, var_predict, var_loss = sess.run([accuary, predict, loss], feed_dict={X: test_x, Y: test_y}) print('acc: %.5f' % var_test_acc) print(var_predict, var_loss)
def main(): parser = argparse.ArgumentParser(description="cifar-10 with PyTorch") parser.add_argument('--lr', default=0.001, type=float, help='learning rate') parser.add_argument('--epoch', default=200, type=int, help='number of epochs tp train for') parser.add_argument('--trainBatchSize', default=100, type=int, help='training batch size') parser.add_argument('--testBatchSize', default=100, type=int, help='testing batch size') parser.add_argument('--cuda', default=torch.cuda.is_available(), type=bool, help='whether cuda is in use') args = parser.parse_args() # fc 2layer # prune_all_fc_layers(args) solver = Solver(args) solver.load_data() solver.model = AlexNet() _, acc, _ = solver.test() print(acc)
def main(): print(f"Train numbers:{len(dataset)}") # first train run this line model = AlexNet().to(device) # Load model # if device == 'cuda': # model = torch.load(MODEL_PATH + MODEL_NAME).to(device) # else: # model = torch.load(MODEL_PATH + MODEL_NAME, map_location='cpu') # cast cast = torch.nn.CrossEntropyLoss().to(device) # Optimization optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=1e-8) step = 1 for epoch in range(1, NUM_EPOCHS + 1): model.train() # cal one epoch time start = time.time() for images, labels in dataset_loader: images = images.to(device) labels = labels.to(device) # Forward pass outputs = model(images) loss = cast(outputs, labels) # Backward and optimize optimizer.zero_grad() loss.backward() optimizer.step() print(f"Step [{step * BATCH_SIZE}/{NUM_EPOCHS * len(dataset)}], " f"Loss: {loss.item():.8f}.") step += 1 # cal train one epoch time end = time.time() print(f"Epoch [{epoch}/{NUM_EPOCHS}], " f"time: {end - start} sec!") # Save the model checkpoint torch.save(model, MODEL_PATH + '/' + MODEL_NAME) print(f"Model save to {MODEL_PATH + '/' + MODEL_NAME}.")
def main(): args = check_args() # prepare dataset c10_train, c10_test = chainer.datasets.cifar.get_cifar10() train = CIFAR10Datset(c10_train, random=True) test = CIFAR10Datset(c10_test, random=False) train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize) test_iter = chainer.iterators.MultiprocessIterator(test, args.batchsize, repeat=False, shuffle=False) # setup model alexnet = AlexNet() serializers.load_npz('data/bvlc_alexnet.npz', alexnet) model = SSDH(alexnet, n_units=args.units) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() eval_model = model.copy() eval_model.train = False # setup optimizer optimizer = chainer.optimizers.MomentumSGD(lr=0.001, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005)) # setup trainer updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(extensions.Evaluator(test_iter, eval_model, device=args.gpu)) trainer.extend(extensions.snapshot()) trainer.extend(extensions.snapshot_object( model, 'model_{.updater.epoch}.npz')) trainer.extend(extensions.LogReport()) trainer.extend(extensions.PrintReport( ['epoch', 'main/cls-loss', 'validation/main/cls-loss', 'main/binary-loss', 'validation/main/binary-loss', 'main/50%-loss', 'validation/main/50%-loss', 'main/accuracy', 'validation/main/accuracy'])) trainer.extend(extensions.ProgressBar()) # lr_policy: "step", stepsize=25000, gamma=0.1 shifts = [(25000, 0.0001)] trainer.extend(StepShift('lr', shifts, optimizer)) if args.resume: chainer.serializers.load_npz(args.resume, trainer) # start training trainer.run()
def test(): if torch.cuda.device_count() > 1: model = torch.nn.parallel.DataParallel( AlexNet(num_classes=opt.num_classes)) else: model = AlexNet(num_classes=opt.num_classes) model.load_state_dict( torch.load(MODEL_PATH, map_location=lambda storage, loc: storage)) model.to(device) # init value correct1 = 0. correct5 = 0. total = len(test_dataloader.dataset) with torch.no_grad(): for i, data in enumerate(test_dataloader): # get the inputs; data is a list of [inputs, labels] inputs, targets = data inputs = inputs.to(device) targets = targets.to(device) outputs = model(inputs) # cal top 1 accuracy prec1 = outputs.argmax(dim=1) correct1 += torch.eq(prec1, targets).sum().item() # cal top 5 accuracy maxk = max((1, 2)) targets_resize = targets.view(-1, 1) _, prec5 = outputs.topk(maxk, 1, True, True) correct5 += torch.eq(prec5, targets_resize).sum().item() return correct1 / total, correct5 / total
def test(imageFolder): #测试部分 is_paramatter = False #置False为导入整个模型,置True为导入参数文件 if (is_paramatter): net = AlexNet() model = torch.load('./model_parameter.pth', map_location=torch.device(device)) #模型参数文件 net.load_state_dict(model) else: net = torch.load('./model.pkl', map_location=torch.device(device)) net = net.to(device) torch.set_grad_enabled(False) torch.no_grad() net.eval() data_num = MyDataSet(imageFolder).__len__() for i in range(data_num): img, ori, name = MyDataSet(imageFolder, data_transform).__getitem__(i) out = net(img.to(device, torch.float)) predict = out.argmax(dim=1) #预测的label probability = out[:, predict] #该label的概率 s = 'Predict result: This is a ' if predict == 0: s += 'CAT' else: s += 'DOG' s += ' with the probability of ' s += str(round(float(probability), 4)) plt.title(s) plt.imshow(ori) plt.savefig("./result/" + name.replace('.jpg', '') + ".png", dpi=300) #将结果保存在result文件夹内 plt.show() #显示图片 print(name + ' Success!')
def main(): train_x, train_y, test_x, test_y, label2name = cifar_10_data( FLAGS.data_dir) test_x = test_x[0:200] test_y = test_y[0:200] with tf.name_scope("input_data"): X = tf.placeholder(tf.float32, [None, 32, 32, 3], name='input') # predict = ResNet34(X) predict = AlexNet(X) with tf.name_scope("output_data"): Y = tf.placeholder(tf.int32, [None]) Y_onehot = tf.cast(tf.one_hot(Y, 10, 1, 0), tf.float32) loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=Y_onehot, logits=predict)) optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(loss) istrue = tf.equal(tf.argmax(predict, 1), tf.argmax(Y_onehot, 1)) accuary = tf.reduce_mean(tf.cast(istrue, tf.float32)) with tf.Session() as sess: saver = tf.train.Saver(tf.global_variables(), max_to_keep=2) ckpt = tf.train.get_checkpoint_state("checkpoint/") if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) starttime = time() for ep in range(0, FLAGS.train_iter): cur_loss = 0 cur_acc = 0 for images, labels in getbatch(train_x, train_y, FLAGS.batch_size): var_loss, var_pred = sess.run([loss, predict], feed_dict={ X: images, Y: labels }) cur_loss += var_loss var_train_acc = sess.run(accuary, feed_dict={ X: images, Y: labels }) cur_acc += var_train_acc var_test_acc = sess.run(accuary, feed_dict={X: test_x, Y: test_y}) if ep % FLAGS.show_step == 0: print(time() - starttime) starttime = time() print( 'loss: %.5f train acc: %.5f acc: %.5f' % (cur_loss / train_x.shape[0] * FLAGS.batch_size, cur_acc / train_x.shape[0] * FLAGS.batch_size, var_test_acc))
def main(): gpus = tf.config.experimental.list_physical_devices("GPU") if gpus: try: for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) except RuntimeError as e: print(e) exit(-1) data_root = tf.keras.utils.get_file( 'flower_photos', 'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz', untar=True) train_ds = tf.keras.preprocessing.image_dataset_from_directory( str(data_root), validation_split=0.2, subset="training", seed=123, image_size=(224, 224), batch_size=32) val_ds = tf.keras.preprocessing.image_dataset_from_directory( str(data_root), validation_split=0.2, subset="validation", seed=123, image_size=(224, 224), batch_size=32) class_names = np.array(train_ds.class_names) # create direction for saving weights if not os.path.exists("save_weights"): os.makedirs("save_weights") # # create model model = AlexNet() model.compile( optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['acc']) history = model.fit(train_ds, epochs=10, validation_data=(val_ds)) model.save("./save_weights/AlexNet_model") # 评估模型 plt.plot(history.history['accuracy'], label='accuracy') plt.plot(history.history['val_accuracy'], label='val_accuracy') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.ylim([0.5, 1]) plt.legend(loc='lower right') plt.show()
def main(args=None): logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG) logging.info('Arquitetura AlexNet') parser = argparse.ArgumentParser() parser.add_argument('--num_classes', help='Num. de classes.', type=int, default=1000) parser.add_argument('--pretrained', help='Serão utilizados pesos pré-treinados.', type=bool, default=True) parser.add_argument('--model_url', help='Caminho para os pesos.', default="./pesos/alexnet-owt-4df8aa71.pth") opt = parser.parse_args(args) # Dados proc = Preprocessador() imagem_url = "./imagens/raposa.jpg" imagem = Image.open(imagem_url) imagem = proc.executa(imagem) #https://jhui.github.io/2018/02/09/PyTorch-Basic-operations/ imagem = imagem.unsqueeze(0) # Instancia do modelo model = AlexNet(opt.num_classes) model.eval() # Caso deseje utilizar os pesos pré-treinados if opt.pretrained: checkpoint = torch.load(opt.model_url) model.load_state_dict(checkpoint) # Utiliza a GPU se existir no computador if torch.cuda.is_available(): model.to('cuda') with torch.no_grad(): saida = model(imagem) # Obtem o indice melhor ranqueado index = np.argmax(saida[0]).item() acuracia = torch.max(saida).item() print(getLabel(index), acuracia)
def _main(data_dir, batch_size, learning_rate, n_epoch): ''' main function ''' # Create dataloader dataloaders_dict = create_dataloader(data_dir, batch_size) # Detect if we have a GPU available device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Create model model = AlexNet() model = model.to(device) # Observe that all parameters are being optimized optimizer_ft = optim.Adam(model.parameters(), lr=learning_rate) criterion = nn.CrossEntropyLoss() model = train_model(model, dataloaders_dict, criterion, optimizer_ft, device, n_epoch) torch.save(model, 'model.pt')
def main(): start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch # Data print('==> Preparing dataset %s' % args.dataset) transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) if args.dataset == 'cifar10': dataloader = datasets.CIFAR10 num_classes = 10 else: dataloader = datasets.CIFAR100 num_classes = 100 trainset = dataloader(root=args.dataroot, train=True, download=True, transform=transform_train) sampler = torch.utils.data.distributed.DistributedSampler(trainset,num_replicas=hvd.size(), rank=hvd.rank()) trainloader = data.DataLoader(dataset=trainset, batch_size=args.train_batch * world_size, shuffle=False, sampler=sampler) testset = dataloader(root=args.dataroot, train=False, download=False, transform=transform_test) testloader = data.DataLoader(testset, batch_size=args.test_batch * world_size, shuffle=False, num_workers=args.workers) # Model print("==> creating model '{}'".format("Alexnet")) model = AlexNet(num_classes=num_classes) device = torch.device('cuda', local_rank) model = model.to(device) # model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[local_rank], output_device=local_rank) print('Model on cuda:%d' % local_rank) print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters())/1000000.0)) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # 用horovod封装优化器 optimizer = hvd.DistributedOptimizer(optimizer, named_parameters=model.named_parameters()) # 广播参数 hvd.broadcast_parameters(model.state_dict(), root_rank=0) # Train and val for epoch in range(start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) train_loss, train_acc = train(trainloader, model, criterion, optimizer, epoch, use_cuda) test_loss, test_acc = test(testloader, model, criterion, epoch, use_cuda) print('Rank:{} Epoch[{}/{}]: LR: {:.3f}, Train loss: {:.5f}, Test loss: {:.5f}, Train acc: {:.2f}, Test acc: {:.2f}.'.format(local_rank,epoch+1, args.epochs, state['lr'], train_loss, test_loss, train_acc, test_acc))
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") data_transform = transforms.Compose( # 首先对图片预处理: resize+toTensor+normalize [ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # load image img_path = ".\\pytorch_classification\\Test2_alexnet.\\dandelion.jpg" # 载入图片 assert os.path.exists(img_path), "file: '{}' dose not exist.".format( img_path) img = Image.open(img_path) plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) # ^ .unsqueeze 扩充一个维度(batch维度) # ^ .squeeze() 对数据的维度进行压缩,去掉维数为1的的维度 # read class_indict json_path = './class_indices.json' # 读取json文件,即索引对应的类别名称 assert os.path.exists(json_path), "file: '{}' dose not exist.".format( json_path) json_file = open(json_path, "r") class_indict = json.load(json_file) # create model model = AlexNet(num_classes=5).to(device) # 初始化网络并放入设备中 # load model weights weights_path = "./AlexNet.pth" assert os.path.exists(weights_path), "file: '{}' dose not exist.".format( weights_path) model.load_state_dict(torch.load(weights_path)) # 载入权重 model.eval() # 进入测试模式(包含dropout操作) with torch.no_grad(): # with torch.no_grad() 禁止参数跟踪:验证中不计算损失梯度 # predict class output = torch.squeeze(model( img.to(device))).cpu() # torch.squeeze压缩了维数为1的的维度(batch维度) predict = torch.softmax(output, dim=0) # 通过softmax变成概率分布 predict_cla = torch.argmax(predict).numpy() # 获得概率最大的那个索引值,并将其转化为numpy print_res = "class: {} prob: {:.3}".format( class_indict[str(predict_cla)], # 打印类别名称和预测概率 predict[predict_cla].numpy()) plt.title(print_res) print(print_res) plt.show()
def main(): # load model model = AlexNet() print('Loading pretrained model from {0}'.format(MODEL_PATH)) chainer.serializers.load_hdf5(MODEL_PATH, model) # prepare net input print('Loading image from {0}'.format(IMAGE_PATH)) img = scipy.misc.imread(IMAGE_PATH, mode='RGB') img = scipy.misc.imresize(img, (227, 227)) img_in = img.copy() img = img[:, :, ::-1] # RGB -> BGR img = img.astype(np.float32) mean_bgr = np.array([104, 117, 123], dtype=np.float32) img -= mean_bgr x_data = np.array([img.transpose(2, 0, 1)]) x = chainer.Variable(x_data, volatile='ON') # infer model(x) score = model.score.data[0] # visualize result likelihood = np.exp(score) / np.sum(np.exp(score)) argsort = np.argsort(score) print('Loading label_names from {0}'.format(SYNSET_PATH)) with open(SYNSET_PATH, 'r') as f: label_names = np.array([line.strip() for line in f.readlines()]) print('Likelihood of top5:') top5 = argsort[::-1][:5] for index in top5: print(' {0:5.1f}%: {1}'.format(likelihood[index] * 100, label_names[index])) img_viz = draw_image_classification_top5(img_in, label_names[top5], likelihood[top5]) plt.imshow(img_viz) plt.axis('off') plt.tight_layout() plt.show()
def main(): parser = argparse.ArgumentParser(description='AlexNet for MNIST') parser.add_argument('--batch_size', '-b', type=int, default=100) parser.add_argument('--epoch', '-e', type=int, default=30) parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--out', '-o', type=str, default='result') args = parser.parse_args() train_ds, test_ds = chainer.datasets.get_mnist(ndim=3) train_iter = iterators.SerialIterator(train_ds, args.batch_size) test_iter = iterators.SerialIterator(test_ds, args.batch_size, repeat=False, shuffle=False) model = L.Classifier(AlexNet()) if args.gpu >= 0: model.to_gpu(args.gpu) optimizer = optimizers.Adam(alpha=0.0001) optimizer.setup(model) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) trainer.extend(extensions.LogReport()) trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png')) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ])) trainer.extend(extensions.ProgressBar()) trainer.run()
def get_prediction(image_bytes): # 异常处理:防止传入非图片的东西 try: weights_path = "./Alexnet.pth" class_json_path = "./class_indices.json" assert os.path.exists(weights_path), "weights path does not exist..." assert os.path.exists(class_json_path), "class json path does not exist..." # select device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) # create model model = AlexNet(num_classes=5) # load model weights model.load_state_dict(torch.load(weights_path, map_location=device)) model.to(device) model.eval() # load class info json_file = open(class_json_path, 'rb') class_indict = json.load(json_file) tensor = transform_image(image_bytes=image_bytes) outputs = torch.softmax(model.forward(tensor).squeeze(), dim=0) # detach去除梯度信息 prediction = outputs.detach().cpu().numpy() # < 左对齐 template = "class:{:<15} probability:{:.3f}" index_pre = [(class_indict[str(index)], float(p)) for index, p in enumerate(prediction)] # sort probability index_pre.sort(key=lambda x: x[1], reverse=True) text = [template.format(k, v) for k, v in index_pre] return_info = {"result": text} except Exception as e: return_info = {"result": [str(e)]} return return_info
def main(): global actor_critic, directory, weight num_cls = args.wave_num * args.k + 1 # 所有的路由和波长选择组合,加上啥都不选 if args.append_route.startswith("True"): channel_num = args.wave_num+args.k else: channel_num = args.wave_num # 解析weight if args.weight.startswith('None'): weight = None else: weight = args.weight # CNN学习模式下,osb的shape应该是CHW assert args.mode.startswith('learning') # 模型初始化 if args.cnn.startswith('mobilenetv2'): actor_critic = MobileNetV2(in_channels=channel_num, num_classes=num_cls, t=6) elif args.cnn.startswith('simplenet'): actor_critic = SimpleNet(in_channels=channel_num, num_classes=num_cls) elif args.cnn.startswith('simplestnet'): actor_critic = SimplestNet(in_channels=channel_num, num_classes=num_cls) elif args.cnn.startswith('alexnet'): actor_critic = AlexNet(in_channels=channel_num, num_classes=num_cls) elif args.cnn.startswith('squeezenet'): actor_critic = SqueezeNet(in_channels=channel_num, num_classes=num_cls, version=1.0) else: raise NotImplementedError times = 1 # 重复次数 prefix = "trained_models" directory = os.path.join(prefix, 'a2c', args.cnn, args.step_over) if args.comp.startswith("states"): all_states_comp() elif args.comp.startswith("random"): random_comp(times=times) elif args.comp.startswith("None"): raise ValueError("Wrong call for this script") else: raise NotImplementedError
def __init__(self): self._input_shape = (224, 224, 3) self._output_dim = 2 model = AlexNet(self._input_shape, self._output_dim).get_model() optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=optimizer, metrics=["accuracy"]) reduce_lro_n_plat = ReduceLROnPlateau(monitor='val_loss', factor=0.8, patience=10, verbose=1, mode='auto', min_delta=0.0001, cooldown=5, min_lr=1e-10) early = EarlyStopping(monitor="val_loss", mode="min", patience=20) data_gen = ImageDataGenerator() train_it = data_gen.flow_from_directory('data/all/train/', target_size=(224, 224)) val_it = data_gen.flow_from_directory('data/all/validation/', target_size=(224, 224)) callbacks_list = [early, reduce_lro_n_plat] try: model.fit(train_it, batch_size=32, epochs=10000, validation_data=val_it, callbacks=callbacks_list, verbose=1) except KeyboardInterrupt: pass model.save_weights("data/model.h5") tfjs.converters.save_keras_model(model, "data/model")
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") data_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # /home/xulei/数据集大本营/5_flower_data img_path = "/home/xulei/数据集大本营/5_flower_data/predict/rose01.jpeg" assert os.path.exists(img_path), "file: '{}' dose not exist.".format( img_path) img = Image.open(img_path) plt.imshow(img) img = data_transform(img) img = torch.unsqueeze(img, dim=0) json_path = './class_idices.json' assert os.path.exists(json_path), "file '{}' dose not exist.".format( json_path) json_file = open(json_path, 'r') class_indict = json.load(json_file) model = AlexNet(num_classes=5).to(device) # load model weights weights_path = "./AlexNet.pth" assert os.path.exists(weights_path), "file '{}' dose not exists.".format( weights_path) model.load_state_dict(torch.load(weights_path)) model.eval() with torch.no_grad(): output = torch.squeeze(model(img.to(device))).cpu() predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print_res = "class: {} prob: {:.3f}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy()) plt.title(print_res) print(print_res) plt.show()
def loadModel(self): """载入指定的模型""" default_dir = os.getcwd() modelPath = askopenfilename( title='选择一个模型文件', initialdir=(os.path.expanduser(default_dir)), filetypes=[('pth文件', '*.pth'), ('All Files', '*')]) if modelPath == "": return try: self.label_info.config(text="载入模型中……") model = AlexNet(num_classes=5) model.load_state_dict(torch.load(modelPath)) model.eval() self.model = model except Exception as e: self.label_info.config(text="模型载入出错") finally: self.button_loadImage.config(state=tk.NORMAL) self.label_info.config(text="请打开一张图片")
def model_retrain(number_class): model = AlexNet(number_class) model = model.to(device) return model
from losss import BatchHardTripletLoss ################## config ################ device = torch.device("cuda:7") date = time.strftime("%m-%d", time.localtime()) #date = "03-14" model_path = "/home/lxd/checkpoints/" + date model_name = sys.argv[1] if model_name == "vgg16": model = Vgg16Net() elif model_name == "mobile": model = MobileNet() elif model_name == "alexnet": model = AlexNet() elif model_name == "res50": model = ResNet50() elif model_name == "res34": model = ResNet34() elif model_name == "vgg11": model = Vgg11Net() else: print("Moddel Wrong") model.to(device) # train/test loss_name = sys.argv[2] batch = sys.argv[3] model.eval()
fine_tuner = PrunningFineTuner_CNN(model) opt = optim.SGD(model.parameters(), lr=0.1, momentum=0.9) fine_tuner.train(optimizer = opt, epoches = 10) opt = optim.SGD(model.parameters(), lr=0.01, momentum=0.9) fine_tuner.train(optimizer = opt, epoches = 15) opt = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) fine_tuner.train(optimizer = opt, epoches = 15) torch.save(model, "model") """ # # model = torch.load("model").cuda() # fine_tuner = PrunningFineTuner_CNN(model) # Acc, Layers_Prunned = fine_tuner.prune() model = AlexNet().cuda() model2 = CNN().cuda() model_dict = load_model_dict('./best_model_new.pkl') _, test = list(model.features._modules.items())[0] print(type(test)) print(test.weight.data.cpu().numpy().shape) # fine_tuner = PrunningFineTuner_CNN(model2) # acc, layers_pruned = fine_tuner.prune() # print(acc, layers_pruned) """ net = torch.load('model_prunned') device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net.to(device) testloader = dataset.testloader()
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("using {} device.".format(device)) data_transform = { "train": transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]), "val": transforms.Compose([ transforms.Resize((224, 224)), # cannot 224, must (224, 224) transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) } data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path assert os.path.exists(image_path), "{} path does not exist.".format( image_path) train_dataset = datasets.ImageFolder(root=os.path.join( image_path, "train"), transform=data_transform["train"]) train_num = len(train_dataset) # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} flower_list = train_dataset.class_to_idx cla_dict = dict((val, key) for key, val in flower_list.items()) # write dict into json file json_str = json.dumps(cla_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) batch_size = 32 nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using {} dataloader workers every process'.format(nw)) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw) validate_dataset = datasets.ImageFolder(root=os.path.join( image_path, "val"), transform=data_transform["val"]) val_num = len(validate_dataset) validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=4, shuffle=False, num_workers=nw) print("using {} images for training, {} images for validation.".format( train_num, val_num)) # test_data_iter = iter(validate_loader) # test_image, test_label = test_data_iter.next() # # def imshow(img): # img = img / 2 + 0.5 # unnormalize # npimg = img.numpy() # plt.imshow(np.transpose(npimg, (1, 2, 0))) # plt.show() # # print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4))) # imshow(utils.make_grid(test_image)) net = AlexNet(num_classes=5, init_weights=True) net.to(device) loss_function = nn.CrossEntropyLoss() # pata = list(net.parameters()) optimizer = optim.Adam(net.parameters(), lr=0.0002) epochs = 10 save_path = './AlexNet.pth' best_acc = 0.0 train_steps = len(train_loader) for epoch in range(epochs): # train net.train() running_loss = 0.0 train_bar = tqdm(train_loader) for step, data in enumerate(train_bar): images, labels = data optimizer.zero_grad() outputs = net(images.to(device)) loss = loss_function(outputs, labels.to(device)) loss.backward() optimizer.step() # print statistics running_loss += loss.item() train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format( epoch + 1, epochs, loss) # validate net.eval() acc = 0.0 # accumulate accurate number / epoch with torch.no_grad(): val_bar = tqdm(validate_loader) for val_data in val_bar: val_images, val_labels = val_data outputs = net(val_images.to(device)) predict_y = torch.max(outputs, dim=1)[1] acc += torch.eq(predict_y, val_labels.to(device)).sum().item() val_accurate = acc / val_num print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' % (epoch + 1, running_loss / train_steps, val_accurate)) if val_accurate > best_acc: best_acc = val_accurate torch.save(net.state_dict(), save_path) print('Finished Training')