def main(): import json import os import time timers = {} STAT_REPEAT = os.environ.get('STAT_REPEAT', '') if STAT_REPEAT == '' or STAT_REPEAT == None: STAT_REPEAT = 50 STAT_REPEAT = int(STAT_REPEAT) """ Call model construction function and run model multiple times. """ model = vgg16() test_x = np.random.rand(224, 224, 3) config = tf.ConfigProto() # config.gpu_options.allow_growth = True # config.gpu_options.allocator_type = 'BFC' config.gpu_options.per_process_gpu_memory_fraction = float( os.getenv('CK_TF_GPU_MEMORY_PERCENT', 33)) / 100.0 sess = tf.Session(config=config) keras.backend.set_session(sess) dt = time.time() for _ in range(STAT_REPEAT): model.predict(np.array([test_x])) t = (time.time() - dt) / STAT_REPEAT timers['execution_time_classify'] = t timers['execution_time'] = t with open('tmp-ck-timer.json', 'w') as ftimers: json.dump(timers, ftimers, indent=2)
def train_model(image_dir='data/data_road/training/image_2', label_dir='data/data_road/training/gt_image_2', job_dir='/tmp/semantic_segmenter', **args): # set the logging path for ML Engine logging to Storage bucket logs_path = job_dir + '/logs/' + datetime.now().isoformat() print('Using logs_path located at {}'.format(logs_path)) train_generator, validate_generator = create_generators(image_dir, label_dir, batch_size=batch_size, target_size=target_size) model = vgg16(dropout=0.2, target_size=target_size) model.summary() model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['accuracy']) #tensorboard = TensorBoard(log_dir="logs/{}".format(time())) history = model.fit_generator( train_generator, validation_data=validate_generator, epochs=epochs, steps_per_epoch=850/batch_size, validation_steps=150/batch_size, verbose=1) #callbacks=[tensorboard]) # Save the model locally model.save('model.h5') # Save the model to the Cloud Storage bucket's jobs directory with file_io.FileIO('model.h5', mode='rb') as input_f: with file_io.FileIO(job_dir + '/model.h5', mode='w+') as output_f: output_f.write(input_f.read())
def __init__(self, input_shape=(448, 448, 3), model=None, grid_size=(7, 7), bounding_boxes=2, number_classes=20, dropout=0.1): ## array (3, 2) => hauteur 3, largeur 2 self.Sx = grid_size[1] # separate image in cell (per line/column) self.Sy = grid_size[0] # separate image in cell (per line/column) self.B = bounding_boxes # number of bounding boxes per cell self.C = number_classes # number of classes self.output_shape = (self.Sy, self.Sx, self.B * 5 + self.C) self.lambda_coord = 5 self.lambda_noobj = 0.5 self.resize_shape = input_shape if model == 'vgg16': self.model = vgg16(input_shape=input_shape, grid_size=(self.Sy, self.Sx), bounding_boxes=self.B, num_class=self.C) self.model.summary() if model == 'mobilenet': self.model = mobilenet_yolo(input_shape=input_shape, grid_size=(self.Sy, self.Sx), bounding_boxes=self.B, num_class=self.C, dropout=dropout) self.model.summary() self.class_to_number = None
def _setup(self): h, w = self.face_size self.x = sm.Tensor() self.mask = sm.Tensor() self.feat, ho, wo, co = vgg16(self.x, h, w) self.embed = facenet_head(self.feat, ho, wo, co) self.loss, self.dis = facenet_loss(self.embed, self.alpha, self.mask)
def __init__(self, config): if not isinstance(config, str): self.config = config else: assert os.path.exists(config) self.config = json.load(open(config)) assert 'name' in self.config assert 'data_path' in self.config assert 'balanced' in self.config assert 'num_samples' in self.config os.environ["CUDA_VISIBLE_DEVICES"] = self.config['gpu_ids'] self.date = time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime()) # create project folder if not os.path.exists(os.path.join('./results/', self.config['name'])): os.makedirs(os.path.join('./results/', self.config['name'])) if self.config['model']['name'] == 'resnet50': self.model = resnet50( pretrained=True, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'resnet101': self.model = resnet101( pretrained=True, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'inception_v3': self.model = inception_v3( pretrained=True, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'vgg16': self.model = vgg16(pretrained=True, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'vgg19_bn': self.model = vgg19_bn( pretrained=True, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'ws_dan_resnet50': self.model = ws_dan_resnet50( pretrained=True, num_classes=self.config['model']['num_classes'], num_attentions=self.config['model']['num_attentions']) self.model.cuda() if len(self.config['gpu_ids']) > 1: self.model = nn.DataParallel(self.model) #self.criterion = nn.CrossEntropyLoss() self.criterion = nn.CrossEntropyLoss(weight=torch.FloatTensor( [1.0, 3.0]).cuda()) #数据不均衡时可修改损失函数权重 self.criterion_attention = nn.MSELoss() self.optimizer = optim.SGD(self.model.parameters(), lr=self.config['model']['init_lr'], momentum=0.9, weight_decay=1e-4) # self.exp_lr_schedler = lr_scheduler.MultiStepLR(self.optimizer, milestones=self.config['model']['milestones'], gamma=0.1) # self.exp_lr_schedler = lr_scheduler.StepLR(self.optimizer, step_size=2, gamma=0.9) self.exp_lr_schedler = lr_scheduler.StepLR(self.optimizer, step_size=10, gamma=0.6)
def load_state(self, _type='test'): if self.config['model']['name'] == 'resnet50': self.model = resnet50( pretrained=False, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'resnet101': self.model = resnet101( pretrained=False, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'inception_v3': self.model = inception_v3( pretrained=False, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'vgg16': self.model = vgg16(pretrained=False, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'vgg19_bn': self.model = vgg19_bn( pretrained=False, num_classes=self.config['model']['num_classes']) elif self.config['model']['name'] == 'ws_dan_resnet50': self.model = ws_dan_resnet50( pretrained=True, num_classes=self.config['model']['num_classes'], num_attentions=self.config['model']['num_attentions']) if _type == 'test': # checkpoints = os.path.join('./zhongshan/new_test_file_20200119', self.config['name'], 'checkpoints', # self.config['test']['checkpoint']) checkpoints = os.path.join('.', self.config['test']['checkpoint']) elif _type == 'test_batch': checkpoints = self.config['test']['checkpoint'] else: checkpoints = os.path.join('./results', self.config['name'], 'checkpoints', self.config['inference']['checkpoint']) self.model.load_state_dict(torch.load(checkpoints)['state_dict']) self.model.cuda() if len(self.config['gpu_ids']) > 1: self.model = nn.DataParallel(self.model)
def objective(params): """ Objective function to be minimized. Parameters ---------- `params` [list] Hyperparameters to be set in optimization iteration. - Managed by hyperdrive. """ kernel1 = int(params[0]) kernel2 = int(params[1]) # kernel3 = int(params[2]) # kernel4 = int(params[3]) # kernel5 = int(params[4]) # kernel6 = int(params[5]) # batch_size = int(params[6]) # model = vgg16(kernel1=kernel1, kernel2=kernel2, kernel3=kernel3, # kernel4=kernel4, kernel5=kernel5, kernel6=kernel6) model = vgg16(kernel1=kernel1, kernel2=kernel2) model.compile(optimizer=keras.optimizers.rmsprop(lr=0.0001, decay=1e-6), loss='categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_val, y_val), shuffle=True) # Score trained model. scores = model.evaluate(x_val, y_val, verbose=1) print('Validation loss:', scores[0]) print('Validation accuracy:', scores[1]) return scores[0]
# -- Note: Use validation set and disable the flipped to enable faster loading. input_dir = os.path.join('./data/results', args.train_id, 'model', args.model_name) if not os.path.exists(input_dir): raise Exception('There is no input directory for loading network from ' + input_dir) pascal_classes = np.asarray(['__background__', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']) # initilize the network here. if args.net == 'vgg16': fasterRCNN = vgg16(pascal_classes, pretrained=False, class_agnostic=args.class_agnostic, args=args) else: print("network is not defined") pdb.set_trace() fasterRCNN.create_architecture() print("load checkpoint %s" % (input_dir)) checkpoint = torch.load(input_dir) fasterRCNN.load_state_dict(checkpoint['model']) if 'pooling_mode' in checkpoint.keys(): args.POOLING_MODE = checkpoint['pooling_mode'] print('load model successfully!') # initilize the tensor holder here.
import matplotlib.pyplot as plt from model import vgg16 use_cuda = torch.cuda.is_available() train_dataset = ImageFolder(root=(sys.argv[1] + '/train'), transform=transforms.ToTensor()) valid_dataset = ImageFolder(root=(sys.argv[1] + '/valid'), transform=transforms.ToTensor()) batch_size = 32 train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=1) net = vgg16(pretrained=False) if use_cuda: net = net.cuda() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=1e-4) loss_list, acc_list = [], [] def train(epoch): net.train() for i, (images, labels) in enumerate(train_loader): if use_cuda: images, labels = images.cuda(), labels.cuda() #print(images, labels) optimizer.zero_grad()
import tensorflow as tf import numpy as np from scipy import ndimage import apriori import cv2 import sys from misc import find_item, bbox_plot from model import vgg16 im_dir = sys.argv[1] features, pred_vec = vgg16(im_dir) td = {} d = {} test = {} lis = [] j = 0 for feat in features: for i in range(512): td[j, i], d[j, i] = find_item(feat[:, :, i]) j += 1 feature_map = tf.concat((features[0, :, :, :], features[1, :, :]), axis=2) li = [i for i in td.values() if i] pixel = {} for i in range(len(li)): pixel[i] = li[i] freq = apriori.run(pixel, 20) # print (freq)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=test_transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2) # Define a Convolution Neural Network net = model.vgg16(num_classes=10) if gpu_statue: net = net.cuda() print('*' * 26, '使用gpu', '*' * 26) else: print('*' * 26, '使用cpu', '*' * 26) # Define a Loss function and optimizer criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9) tr_acc, ts_acc, loss_p, time_p = [], [], [], [] # Train and test the network start_time = time.time()
def main(): """ Call model construction function and run model multiple times. """ model = vgg16() test_x = np.random.rand(224, 224, 3) for _ in range(50): model.predict(np.array([test_x]))
def train(epochs): """ 训练模型 :param epochs: :return: """ vgg = vgg16((None, 224, 224, 3), 102) resnet = resnet50((None, 224, 224, 3), 102) densenet = densenet121((None, 224, 224, 3), 102) models = [vgg, resnet, densenet] train_db, valid_db = load_db(32) his = [] for model in models: variables = model.trainable_variables optimizers = tf.keras.optimizers.Adam(1e-4) for epoch in range(epochs): # training total_num = 0 total_correct = 0 training_loss = 0 for step, (x, y) in enumerate(train_db): with tf.GradientTape() as tape: # train out = model(x) loss = tf.losses.categorical_crossentropy( y, out, from_logits=False) loss = tf.reduce_mean(loss) training_loss += loss grads = tape.gradient(loss, variables) optimizers.apply_gradients(zip(grads, variables)) # training accuracy y_pred = tf.cast(tf.argmax(out, axis=1), dtype=tf.int32) y_true = tf.cast(tf.argmax(y, axis=1), dtype=tf.int32) correct = tf.reduce_sum( tf.cast(tf.equal(y_pred, y_true), dtype=tf.int32)) total_num += x.shape[0] total_correct += int(correct) if step % 100 == 0: print("loss is {}".format(loss)) training_accuracy = total_correct / total_num # validation total_num = 0 total_correct = 0 for (x, y) in valid_db: out = model(x) y_pred = tf.argmax(out, axis=1) y_pred = tf.cast(y_pred, dtype=tf.int32) y_true = tf.argmax(y, axis=1) y_true = tf.cast(y_true, dtype=tf.int32) correct = tf.cast(tf.equal(y_pred, y_true), dtype=tf.int32) correct = tf.reduce_sum(correct) total_num += x.shape[0] total_correct += int(correct) validation_accuracy = total_correct / total_num print( "epoch:{}, training loss:{:.4f}, training accuracy:{:.4f}, validation accuracy:{:.4f}" .format(epoch, training_loss, training_accuracy, validation_accuracy)) his.append({ 'accuracy': training_accuracy, 'val_accuracy': validation_accuracy }) return his
def train(FLAGS): """training model """ batch_size = FLAGS.batch_size num_classes = FLAGS.num_classes train_tfrecords_file = FLAGS.train_tfrecords_file valid_tfrecords_file = FLAGS.valid_tfrecords_file tensorboard_dir = FLAGS.tensorboard_dir saver_dir = FLAGS.saver_dir image_height, image_width, image_channel = (FLAGS.image_height, FLAGS.image_width, FLAGS.image_channel) mode = FLAGS.mode base_learning_rate = FLAGS.base_learning_rate max_steps = FLAGS.max_steps valid_steps = FLAGS.valid_steps keep_prob = FLAGS.keep_prob train_loss, train_acc = [], [] valid_loss, valid_acc = [], [] with tf.Graph().as_default(): # define image and label placehold images_pl = tf.placeholder(tf.float32, shape=[batch_size, image_height, image_width, image_channel]) labels_pl = tf.placeholder(tf.int32, shape=[batch_size, num_classes]) is_training_pl = tf.placeholder(tf.bool, name='is_training') # keep_prob_pl = tf.placeholder(tf.float32) # get training image with batch train_tf_image, train_tf_label = read_tfrecords(train_tfrecords_file, shape=(image_height, image_width, image_channel)) train_tf_image = preprocessing_image(train_tf_image, mode=mode) train_tf_image_batch, train_tf_label_batch = generate_image_label_batch(train_tf_image, train_tf_label, batch_size, num_classes) # validation image with batch valid_tf_image, valid_tf_label = read_tfrecords(valid_tfrecords_file, shape=(image_height, image_width, image_channel)) valid_tf_image = preprocessing_image(valid_tf_image, mode=mode) valid_tf_image_batch, valid_tf_label_batch = generate_image_label_batch(valid_tf_image, valid_tf_label, batch_size, num_classes) # compute logits from model logits = vgg16(images_pl, num_classes, keep_prob, is_training_pl) # get global steps global_steps = tf.Variable(0, trainable=False) # compute loss, accucracy and predictions loss, accuracy, _ = calc_loss_acc(labels_pl, logits) # training operator to update model params training_op = train_op(loss, global_steps, base_learning_rate, option='SGD') # define the model saver saver = tf.train.Saver(tf.global_variables()) # define a summary operation summary_op = tf.summary.merge_all() with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) # start queue runner coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # set up summary file writer train_writer = tf.summary.FileWriter(tensorboard_dir + 'train', sess.graph) valid_writer = tf.summary.FileWriter(tensorboard_dir + 'valid') for step in range(max_steps): # load image and label with batch size train_image_batch, train_label_batch = sess.run([train_tf_image_batch, train_tf_label_batch]) # define training feed dict train_feed_dict = {images_pl: train_image_batch, labels_pl: train_label_batch, is_training_pl: True} _, _loss, _acc, _summary_op = sess.run([training_op, loss, accuracy, summary_op], feed_dict=train_feed_dict) # store loss and accuracy value train_loss.append(_loss) train_acc.append(_acc) # print loss and acc # print("Iteration " + str(step) + ", Mini-batch Loss= " + "{:.6f}".format(_loss) + ", Training Accuracy= " + "{:.5f}".format(_acc)) # if step%10 == 0: # _logits = sess.run(logits, feed_dict=train_feed_dict) # print('Per class accuracy by logits in training time', per_class_acc(train_label_batch, _logits)) print("Iteration " + str(step) + ", Mini-batch Loss= " + "{:.6f}".format(_loss) + ", Training Accuracy= " + "{:.5f}".format(_acc)) train_writer.add_summary(_summary_op, step) train_writer.flush() if step%5 == 0: print('start validation process') _valid_loss, _valid_acc = [], [] for valid_step in range(valid_steps): valid_image_batch, valid_label_batch = sess.run([valid_tf_image_batch, valid_tf_label_batch]) valid_feed_dict = {images_pl: valid_image_batch, labels_pl: valid_label_batch, is_training_pl: True} _loss, _acc, _summary_op = sess.run([loss, accuracy, summary_op], feed_dict = valid_feed_dict) valid_writer.add_summary(_summary_op, valid_step) valid_writer.flush() _valid_loss.append(_loss) _valid_acc.append(_acc) valid_loss.append(np.mean(_valid_loss)) valid_acc.append(np.mean(_valid_acc)) print("Iteration {}: Train Loss {:6.3f}, Train Acc {:6.3f}, Val Loss {:6.3f}, Val Acc {:6.3f}".format(step, train_loss[-1], train_acc[-1], valid_loss[-1], valid_acc[-1])) checkpoint_path = os.path.join(saver_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) coord.request_stop() coord.join(threads)
def build_rpn(**kwargs): backbone = model.vgg16(**kwargs) rpn_head = model.RPNHead() network = nn.Sequential(backbone, rpn_head) return network
im_info = im_info.cuda() num_boxes = num_boxes.cuda() gt_boxes = gt_boxes.cuda() # make variable im_data = Variable(im_data) im_info = Variable(im_info) num_boxes = Variable(num_boxes) gt_boxes = Variable(gt_boxes) if args.cuda: args.CUDA = True # initilize the network here. if args.net == 'vgg16': fasterRCNN = vgg16(pd.classes, args, pretrained=True, \ class_agnostic=args.class_agnostic) else: print("network is not defined") # pdb.set_trace() fasterRCNN.create_architecture() lr = args.lr params = [] for key, value in dict(fasterRCNN.named_parameters()).items(): if value.requires_grad: if 'bias' in key: params += [{'params': [value], 'lr': lr * (args.DOUBLE_BIAS + 1), \ 'weight_decay': args.BIAS_DECAY and args.WEIGHT_DECAY \ or 0}]
num_boxes = num_boxes.cuda() gt_boxes = gt_boxes.cuda() # make variable if True: im_data = Variable(im_data) im_info = Variable(im_info) num_boxes = Variable(num_boxes) gt_boxes = Variable(gt_boxes) if args.cuda: args.CUDA = True # initilize the network here. if args.net == 'vgg16': basenet = vgg16(pd_test.classes, args, pretrained=True) elif args.net == 'res50': basenet = res50(pd_test.classes, args, pretrained=True) else: print("network is not defined") basenet.create_architecture() load_name = os.path.join('./data/results', args.train_id, 'model', args.model_name) print("loading checkpoint %s" % load_name) checkpoint = torch.load(load_name) basenet.load_state_dict(checkpoint['model']) print("loaded checkpoint %s" % load_name) if args.cuda: basenet.cuda()
def main(): args = parse_args() # Params epochs = args.epoch sample_output = args.sample_output sample_nums = args.sample_nums batch_size = args.batch_size gpu_n = args.gpu pretrain_epochs = min(25, int(epochs / 4)) torch.cuda.set_device(gpu_n) sample_interval = epochs // sample_nums # Hyperparams learning_rate_d = 1e-3 learning_rate_g = 1e-3 # Class names class_names = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"] # CIFAR dataset transform = transforms.Compose([transforms.CenterCrop(32), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # https://github.com/kuangliu/pytorch-cifar/issues/19 #transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) #transform = transforms.Compose([transforms.ToTensor()]) train_dataset = datasets.CIFAR10("./data", train=True, transform=transform, download=True) test_dataset = datasets.CIFAR10("./data", train=False, transform=transform, download=True) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False) # Build model #_d = model.D2(3, 11) _d = model.vgg16(11) _d.cuda() _g = model.CCNN() _g.cuda() # Loss and optimizer criterion_d = nn.CrossEntropyLoss().cuda() optimizer_d = torch.optim.Adam(_d.classifier.parameters(), lr=learning_rate_d) criterion_g = nn.CrossEntropyLoss().cuda() optimizer_g = torch.optim.Adam(_g.parameters(), lr=learning_rate_g) total_batches = len(train_dataset) _i = 1 for epoch in range(pretrain_epochs): _d.train() for i, (images, labels) in enumerate(train_loader): current_batch_size = len(images) fake_batch_size = max(1, int(current_batch_size / 8)) print("Training batch: %d / %d" % (i, total_batches), end="\r") sys.stdout.flush() # Prepare images and labels images = Variable(images.cuda()) # Put labels to GPU labels = Variable(labels.cuda()) #print(labels) # Train D network optimizer_d.zero_grad() outputs_d = _d(images) real_loss = criterion_d(outputs_d, labels) real_loss.backward() optimizer_d.step() # Log and outputs _d.eval() correct_d = 0 total_d = 0 for images, labels in test_loader: images = Variable(images).cuda() outputs = _d(images) _, predicted = torch.max(outputs.data, 1) total_d += labels.size(0) correct_d += (predicted.cpu() == labels).sum() print("Pretrain Epoch [%d/%d], Iter [%d/%d] D loss:%.5f D accuracy: %.2f%%" % ( epoch + 1, pretrain_epochs, i + 1, len(train_dataset) // batch_size, real_loss.data[0], (100 * correct_d / total_d) )) optimizer_d = torch.optim.Adam(_d.classifier.parameters(), lr=learning_rate_d) for epoch in range(epochs): _d.train() for i, (images, labels) in enumerate(train_loader): current_batch_size = len(images) fake_batch_size = max(1, int(current_batch_size / 8)) print("Training batch: %d / %d" % (i, total_batches), end="\r") sys.stdout.flush() # Prepare images and labels images = Variable(images.cuda()) # Put labels to GPU labels = Variable(labels.cuda()) #print(labels) # Train D network optimizer_d.zero_grad() outputs_d = _d(images) real_loss = criterion_d(outputs_d, labels) real_loss.backward() #print(outputs_d) # Generate fake labels noise = Variable(torch.cuda.FloatTensor(fake_batch_size, 3, 32, 32).normal_()) fake_labels = np.zeros(fake_batch_size) + 10 fake_labels_d = Variable(torch.from_numpy(fake_labels).long().cuda()) #print(fake_labels) #input() # Generate fake images and classify fake_labels_g = np.random.randint(0, 10, fake_batch_size) labels_fake_onehot = torch.from_numpy(one_hot(fake_labels_g)).float().cuda() labels_fake_onehot = Variable(labels_fake_onehot) fake_images = _g(labels_fake_onehot, noise) std = torch.cuda.FloatTensor(fake_batch_size, 3, 32, 32) std[:,0,:,:] += 0.247 std[:,1,:,:] += 0.243 std[:,2,:,:] += 0.261 mean = torch.cuda.FloatTensor(fake_batch_size, 3, 32, 32) mean[:,0,:,:] += 0.4914 mean[:,1,:,:] += 0.4822 mean[:,2,:,:] += 0.4465 fake_images = (fake_images - Variable(mean)) / Variable(std) fake_outputs= _d(fake_images.detach()) # Calculate loss fake_loss = criterion_d(fake_outputs, fake_labels_d) fake_loss.backward() loss_d = real_loss + fake_loss #loss_d = real_loss optimizer_d.step() # Train G network optimizer_g.zero_grad() noise = Variable(torch.cuda.FloatTensor(current_batch_size, 3, 32, 32).normal_()) fake_labels = np.random.randint(0, 10, current_batch_size) labels_fake_onehot = torch.from_numpy(one_hot(fake_labels)).float().cuda() labels_fake_onehot = Variable(labels_fake_onehot) fake_labels = torch.from_numpy(fake_labels) fake_labels = Variable(fake_labels.cuda()) images_g = _g(labels_fake_onehot, noise) std = torch.cuda.FloatTensor(current_batch_size,3, 32, 32) std[:,0,:,:] += 0.247 std[:,1,:,:] += 0.243 std[:,2,:,:] += 0.261 mean = torch.cuda.FloatTensor(current_batch_size, 3, 32, 32) mean[:,0,:,:] += 0.4914 mean[:,1,:,:] += 0.4822 mean[:,2,:,:] += 0.4465 images_g = (images_g - Variable(mean)) / Variable(std) truth = _d(images_g.detach()) loss_g = criterion_g(truth, fake_labels) loss_g.backward() optimizer_g.step() if i % 100 == 99: print("Epoch [%d/%d], Iter [%d/%d] D loss:%.5f G loss:%.5f" % ( epoch + 1, epochs, i + 1, len(train_dataset) // batch_size, loss_d.data[0], loss_g.data[0] )) # Log and outputs _d.eval() correct_d = 0 total_d = 0 for images, labels in test_loader: images = Variable(images).cuda() outputs = _d(images) _, predicted = torch.max(outputs.data, 1) total_d += labels.size(0) correct_d += (predicted.cpu() == labels).sum() print("Epoch [%d/%d], Iter [%d/%d] D loss:%.5f D accuracy: %.2f%% G loss:%.5f" % ( epoch + 1, epochs, i + 1, len(train_dataset) // batch_size, loss_d.data[0], (100 * correct_d / total_d), loss_g.data[0] )) if _i == sample_interval: _i = 1 print("Generating images: ", end="\r") generate_batch_images(_g, 5, start=0, end=9, prefix="training-epoch-%d" % (epoch + 1), figure_path=sample_output, labels=class_names) sys.stdout.flush() print("Generated images for epoch %d" % (epoch + 1)) else: _i += 1 return 0
import torchvision from torchvision import transforms from collections import OrderedDict from torch.autograd import Variable from torchvision.datasets import ImageFolder from model import vgg16 import torch import numpy as np import sys import matplotlib.pyplot as plt from model import vgg16 import cv2 use_cuda = torch.cuda.is_available() net = vgg16() if use_cuda: net = net.cuda() net.load_state_dict(torch.load('vgg16.pt')) net.eval() criterion = nn.CrossEntropyLoss() loss_list, acc_list = [], [] def test(image): h, w, c = image.shape transform1 = transforms.Compose([ transforms.ToTensor(), ]) images = transform1(image).view(1, c, h, w) print(images.numpy().shape)
if args.model not in check: print("Error: Chosen Model not in", check) exit() import tensorflow as tf import data import model print("Loading data...") x_train, y_train, x_test, y_test = data.load() if args.new == True: if args.model == "diyModel": model = model.diyModel() elif args.model == "VGG16": model = model.vgg16() elif args.model == "VGG19": model = model.vgg19() elif args.model == "ResNet50": model = model.resnet50() elif args.model == "ResNet101": model = model.resnet101() else: model = tf.keras.models.load_model("./" + str(args.model) + ".h5") model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=args.epochs, batch_size=args.batch_size)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=test_transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2) # Define a Convolution Neural Network net = vgg16(num_classes=10) if gpu_statue: net = net.cuda() print('*' * 26, '使用gpu', '*' * 26) else: print('*' * 26, '使用cpu', '*' * 26) # Define a Loss function and optimizer criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9) tr_acc, ts_acc, loss_p, time_p = [], [], [], [] # Train and test the network start_time = time.time()
mean = np.array([[[0.485, 0.456, 0.406]]]) img = img * std + mean return (img * 255).astype(np.uint8) if __name__ == '__main__': reload(dataset) parser = argparse.ArgumentParser() parser.add_argument('--data', default='/mnt/external/Data/BSR/BSDS500/data/images') parser.add_argument('--batch-size', default=5, type=int) parser.add_argument('--num-thread', default=4, type=int) args = parser.parse_args() vgg = model.vgg16(pretrained=True) # vgg.cuda() # # # Data loading code # transform = transforms.Compose([ # transforms.CenterCrop(224), # transforms.RandomHorizontalFlip(), # transforms.ToTensor(), # transforms.Normalize(mean = [ 0.485, 0.456, 0.406 ], # std = [ 0.229, 0.224, 0.225 ]), # ]) # # testdir = os.path.join(args.data, 'test') # test_set = dataset.BSDS500(testdir, transform) # test_loader = torch.utils.data.DataLoader( # test_set,
# torch.backends.cudnn.enabled = False torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False torch.manual_seed(random_seed) # -----------------------loading the dataset------------------------ dataSet = "cifar" # train_loader, val_loader = mnist_loaders(batch_train, random_seed, show_sample=True) train_loader, val_loader = cifar_loaders(batch_train, random_seed, show_sample=True) # ------------------------------------------------------------------ # ------------------------initialize network------------------------ modelName = "vgg16" net = model.vgg16() net.train().cuda() # -----------------------------optimiser---------------------------- criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=5e-4) start_ts = time.time() losses = [] print( f"--------------------------------{dataSet}_{modelName}--------------------------------" )
from model import vgg16 import torch.nn as nn from torchvision.transforms import ToTensor, ToPILImage from PIL import Image to_tensor = ToTensor() to_pil = ToPILImage img1 = Image.open(r'D:\Data\ship_data\data\ship_saliency\Ship_Data2\imgs\000000.jpg') #img1.show() input = to_tensor(img1).unsqueeze(0) print(input.size()) base = {'352': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512]} vgg = nn.ModuleList(vgg16(base['352'],3)) for layer in vgg: input = layer(input) out = input print(out.size())