def main(): parser = argparse.ArgumentParser() parser.add_argument("img_path", type=str, help="path to the RGB image input") parser.add_argument("focal_len", type=float, help="focal length of the camera") args = parser.parse_args() # switching to GPU if possible use_gpu = torch.cuda.is_available() print("\nusing GPU:", use_gpu) # loading models print("\nLoading models...") model_de = net.get_model(output="depth", use_gpu=use_gpu) if use_gpu: model_de = model_de.cuda() model_seg = net.get_model(output="seg", use_gpu=use_gpu) if use_gpu: model_seg = model_seg.cuda() # setting models to evaluation mode model_de.eval() model_seg.eval() print("Done.") # reading image img = torch.Tensor(load_img(args.img_path)) # running model on the image if use_gpu: img = img.cuda() print("Plotting...") output_de = model_de(img) output_seg = model_seg(img) # bilinear upsampling output_de = F.interpolate(output_de, size=(320, 320), mode="bilinear", align_corners=True) output_seg = F.interpolate(output_seg, size=(320, 320), mode="bilinear", align_corners=True) # softmax for semantic segmentation output_seg = F.softmax(output_seg, dim=1) # plotting the results output_de = output_de.cpu()[0].data.numpy() output_seg = output_seg.cpu()[0].data.numpy() img = img.cpu()[0].data.numpy() show_img_preds(img, output_de, output_seg, uc_th=0.9, apply_depth_mask=True) # visualize the points in 3D show_point_cloud(img, output_de, output_seg, args.focal_len, uc_th=0.9, apply_depth_mask=True) print("Done")
def train(): args = get_args() train_input = args.train test_input = args.test epochs = args.epochs batch_size = args.batch_size model = net.get_model() model.compile(loss='categorical_crossentropy', optimizer=Adam(1e-3, amsgrad=True), metrics=['accuracy']) h5f_train = h5py.File(train_input, 'r') h5f_test = h5py.File(test_input, 'r') x_train = h5f_train['input'] y_train = h5f_train['label'] x_test = h5f_test['input'] y_test = h5f_test['label'] tensorboard = TensorBoard(log_dir="./log/", write_images=True) checkpoint = ModelCheckpoint( filepath="./log/checkpoint-{epoch:02d}-{val_loss:.4f}.hdf5", monitor='val_loss', verbose=1, save_best_only=True) model.fit(x_train, [y_train[0], y_train[1], y_train[2], y_train[3]], validation_data=(x_test, [y_test[0], y_test[1], y_test[2], y_test[3]]), epochs=epochs, batch_size=batch_size, shuffle='batch', callbacks=[checkpoint, tensorboard])
def deal_with_data(self): ''' 处理数据,没有可不写。 :return: ''' csv_path = os.path.join(DATA_PATH, 'TBDetection', 'train.csv') df = pd.read_csv(csv_path) img_file_list = list(df['image_path'].values) xml_file_list = list(df['xml_path'].values) transform = transforms.Compose( [transforms.RandomHorizontalFlip(0.5), transforms.ToTensor()]) train_data = MyDataset(os.path.join(DATA_PATH, 'TBDetection'), img_file_list, xml_file_list, transforms=transform, data_generate=data_generate) self.train_loader = DataLoader(dataset=train_data, batch_size=args.BATCH, shuffle=True, collate_fn=collate_fn) self.model = get_model() #self.model.load_state_dict(torch.load('./model/best.pth')) self.model.to(device) print('deal with data done...')
def load_model(self): ''' 模型初始化,必须在此方法中加载模型 ''' self.model = get_model() print('load from best.pth...') self.model.load_state_dict(torch.load(os.path.join(MODEL_PATH, 'best.pth'))) self.model.to(device) print('load model done...')
import torch.nn as nn device = torch.device("cuda" if torch.cuda.is_available() else "cpu") import random import scipy.ndimage.filters import multiprocessing from multiprocessing import Process from multiprocessing import Queue import time from net import get_model import sys if __name__ == "__main__": assert len(sys.argv) == 2, "Enter the Image path that you want to process" model_name = "best_model.pth" model = get_model(model_name) model = model.to(device) img = np.array(Image.open(sys.argv[1])) img = np.rollaxis(img, 2) img = torch.tensor(img).unsqueeze(0).to(device).float() / 255 with torch.no_grad(): res = model(img) res = res.cpu().numpy()[0][0] res[res >= .5] = 1 res[res < .5] = 0 plt.imshow(res) plt.show()
num_workers=args.num_workers) # , drop_last=True) for x in ['train', 'val'] } dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} # images, indices, labels, ids, cams, names = next(iter(dataloaders['train'])) num_label = len(attributes.labels) # image_datasets['train'].num_label() # num_id = image_datasets['train'].num_id() # labels_list = image_datasets['train'].labels() ###################################################################### # Model and Optimizer # ------------------ model = get_model(model_name, num_label) if use_gpu: model = model.cuda() # loss criterion_bce = nn.BCELoss() criterion_ce = nn.CrossEntropyLoss() # optimizer ignored_params = list(map(id, model.features.parameters())) classifier_params = filter(lambda p: id(p) not in ignored_params, model.parameters()) optimizer = torch.optim.SGD([ { 'params': model.features.parameters(), 'lr': 0.01
self.train_object.save_model( str(iters // len(self.dataobject) + offset)) print(iters, end=" ") self.train_object.train(data) for p in arr: p.join() if __name__ == "__main__": assert len(sys.argv) <= 2, "Enter the the model number to resume from" last_model = 0 if (len(sys.argv) == 2): last_model = sys.argv[1] model = get_model("model" + str(last_model) + ".pth") else: model = get_model() data_object = dataloader(paths) T = trainer(model) multi = multiprocess_control(data_object, workers=2, produce_func=producer, shared_Q=Q, epochs_desired=30, train_object=T, offset=last_model) multi.start_training()
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} # images, indices, labels, ids, cams, names = next(iter(dataloaders['train'])) num_label = image_datasets['train'].num_label() num_id = image_datasets['train'].num_id() labels_list = image_datasets['train'].labels() print("-->num label :", num_label) print("-->num id :", num_id) print("-->labels_list:", labels_list) ###################################################################### # Model and Optimizer # ------------------ model = get_model(model_name, num_label, args.use_id, num_id=num_id) if use_gpu: model = model.cuda() # loss criterion_bce = nn.BCELoss() criterion_ce = nn.CrossEntropyLoss() # optimizer ignored_params = list(map(id, model.features.parameters())) classifier_params = filter(lambda p: id(p) not in ignored_params, model.parameters()) optimizer = torch.optim.SGD([ { 'params': model.features.parameters(), 'lr': 0.01
if __name__ == '__main__': param = { 'phase': 'train', 'batch_size': 3, 'eval_n_crop': 4, 'learning_rate': 1e-3, 'momentum': 0.9, 'weight_decay': 0, 'epochs': 40, 'mode': 'sord_ent_weighted' # sord, sord_ent_weighted, sord_min_local_ent, sord_weighted_minent, sord_align_grad, classification, regression, reg_of_cls } restore_file = "experiments/train_lr_1e-03_momentum_0.9_wd_0_epoch_30_mode_sord_pretrained_DeepLabV3+_PascalVOC_crop_375*513/best.pth.tar" model_dir = 'refine_CADC_depth_aggregated_new_sord_weighted_sigmoid_16x16_lr_1e-03_momentum_0.9_wd_0_epoch_30_mode_sord_pretrained_DeepLabV3+_Kitti_crop_513*513' train_type = 'refine' # refine or continue model = net.get_model(param['mode']) model.cuda() ## Pretrained on Pascal semantic segmentation, retrain on Kitti depth estimation # last_layer = ['classifier.classifier.4.weight', 'classifier.classifier.4.bias'] # last_layer_params = list(map(lambda x: x[1], list(filter(lambda kv: kv[0] in last_layer, model.named_parameters())))) # base_params = list(map(lambda x: x[1], list(filter(lambda kv: kv[0] not in last_layer, model.named_parameters())))) # # optimizer = torch.optim.SGD([ # {'params': base_params, 'lr': param['learning_rate']}, # {'params': last_layer_params, 'lr': param['learning_rate'] * 10} # ], momentum=param['momentum'], weight_decay=param['weight_decay'], nesterov=True) # scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=1) optimizer = torch.optim.SGD(params=model.parameters(), lr=param['learning_rate'], momentum=param['momentum'], weight_decay=param['weight_decay'], nesterov=True) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=2)
from net import get_model from data import train_val_dataset from util import cross_entropy, seed_everything, smooth_one_hot root = './data' #'/content/datasets' batch_size = 192 num_epochs = 20 lr = 0.1 m = 0.9 w_d = 0.1 fineturning = True #model = Resnet50(pretrained=True) #model = get_model(2, pretrained=True) model = get_model('resnet50', pretrained=True) model = model.to(device) optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=m, weight_decay=w_d) # and a learning rate scheduler #lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1) #lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[18,25,25,], gamma=0.1) #22 lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, 'min', patience=2, min_lr=1e-6) # 似乎在fineturning时不利于训练 #cross_entropy = nn.CrossEntropyLoss(reduction='sum').to(device) #weight=torch.tensor([1.,1.]),
min_delta=0, patience=config.es_patience, verbose=1, mode='auto', baseline=None, restore_best_weights=False) reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_acc', factor=0.1, patience=config.lr_patience, min_lr=0.000001) callbacks.append(EarlyStopping) callbacks.append(reduce_lr) callbacks.append(ModelCheckpoint) from net import get_model model, base_model = get_model() optimizer = keras.optimizers.adam(lr=0.001, decay=0) if config.num_class == 2: loss_name = "binary_crossentropy" else: loss_name = "categorical_crossentropy" if not config.onehot: loss_name = "sparse_" + loss_name model.compile(optimizer=optimizer, loss=loss_name, metrics=["acc"]) print(model.summary()) model.fit_generator( train_generator, steps_per_epoch=steps_per_epoch, epochs=args.EPOCHS,
train_dst = MyDataset(x_train, y_train, transform=transforms['train']) valid_dst = MyDataset(x_val, y_val, transform=transforms['val']) train_loader = torch.utils.data.DataLoader(train_dst, batch_size=cfg.bs, shuffle=True, pin_memory=True) valid_loader = torch.utils.data.DataLoader(valid_dst, batch_size=cfg.bs, shuffle=False, pin_memory=True) # 得到均值方差 print(utils.get_mean_and_std(train_dst)) # 使用多模型融合 models_list = get_model(cfg.model_names) for i, cur_cnn in enumerate(models_list): cnn = cur_cnn # 因为要保存model name = cfg.model_names[i] + '.pkl' cnn.to(device) # 训练数据 loss_fn = nn.CrossEntropyLoss() # loss_fn = utils.LabelSmoothingCrossEntropy() optimizer = optim.Adam(cnn.parameters(), lr=cfg.lr, weight_decay=1e-4) # optimizer = optim.SGD(cnn.parameters(), lr=cfg.lr, momentum=0.9, nesterov=True) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', patience=3, verbose=True) print("训练中的模型 %s" % name)
param = torch.load(model_dir).copy() param['eval_n_crop'] = 10 param['batch_size'] = 3 param.pop('state_dict') param.pop('optim_dict') param.pop('sched_dict', None) param.pop('restore_file', None) param.pop('model_dir', None) # data_gen_test = DataGenerator('/home/datasets/Kitti/', phase='test') data_gen_test = DataGenerator('/home/datasets/CADC/cadcd/', '/home/datasets_mod/CADC/cadcd/', phase='inference', cam=0, depth_mode='dror') print('val or test data size:', len(data_gen_test.dataset)) dataloader_test = data_gen_test.create_data(batch_size=param['batch_size']) data = next(iter(dataloader_test)) print('img shape:', data['img'].shape) print('depth shape:', data['depth'].shape) model = net.get_model(param['mode'], pretrained=False) model.cuda() utils.load_checkpoint(model_dir, model) print('Load model parameters done') inference(model, dataloader_test, param) # fig = plt.figure() # plt.hist(t_inference, bins=20) # plt.show() # print('inference time average: %.3f\ninference time variance: %.3f' % (np.mean(t_inference), np.var(t_inference)))
help='ip address for pastalog (default: None)') if __name__ == '__main__': args = p.parse_args() print('... Prepare directories') dirs = prepare_dirs(args.rootdir, args.name) if args.model_path: from keras.models import model_from_json from net import load_model print('... Load network from: {}'.format(args.model_path)) model = load_model(args.model_path) else: from net import get_model model = get_model(args.img_size, args.beta, args.kernel_size, args.nb_filters) model_definition_file = dirs.modelsdir / 'model.json' print( '... Save model architecture to: {}'.format(model_definition_file)) import json with model_definition_file.open('w') as f: json.dump(json.loads(model.to_json()), f) if args.weights_path: print('... Load parameters from: {}'.format(args.weights_path)) model.load_weights(args.weights_path) print('... Compile model') model.compile(optimizer=Adam(lr=args.lr), loss='categorical_crossentropy', metrics=['accuracy'])
# #### Training # Initialize the model. Possible Values for the task block type: MLP, LSTM, GRU, TempConv # In[3]: params = { 'name': 'test', 'type_': 'MLP', 'lr': 3e-4, 'n_h': 128, 'p': 0.5, 'seq_len': 1 } model, opt = get_model(params) # In[4]: device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = model.to(device) # get the data loader. get mini data gets only a subset of the training data, on which we can try if the model is able to overfit # In[5]: train_dl, valid_dl = get_data(data_path, model.params.seq_len, batch_size=16) # train_dl, valid_dl = get_mini_data(data_path, model.params.seq_len, batch_size=16, l=4000) # uncomment the next cell if the feature extractor should also be trained
def get_results(x_train, x_valid, x_test, y_train, y_valid, y_test, idx2vec, emb_dim, valid, lang, emb_src, model, k, nn_dims): """Get the clasiification results by the model(knn, net).""" vectors = _get_vectors(x_train, x_valid, x_test, idx2vec) if model == 'knn': database = vectors[0] if valid: queries = vectors[1] else: queries = vectors[3] y_pred = _classify(np.vstack(database), np.vstack(queries), emb_dim, k, y_train) elif model == 'nn': X_train, X_valid, X_test = np.vstack(vectors[0]), np.vstack(vectors[1]),\ np.vstack(vectors[2]) num_classes = np.unique(y_test).shape[0] y_train = np.vstack(y_train) y_train = np.squeeze(np.eye(num_classes)[y_train.reshape(-1)]) y_valid = np.vstack(y_valid) y_valid = np.squeeze(np.eye(num_classes)[y_valid.reshape(-1)]) model = get_model(emb_dim, nn_dims, num_classes) # print(model.summary()) model.fit(X_train, y_train, validation_data=(X_valid, y_valid), callbacks=[ EarlyStopping(monitor='val_loss', patience=5, mode='min', verbose=0), ModelCheckpoint( '../data/checkpoints/best_model_{}_{}.h5'.format( lang, emb_src), monitor='val_accuracy', mode='max', verbose=0, save_best_only=True) ], verbose=0, epochs=100) if valid: y_pred = model.predict(X_valid) else: y_pred = model.predict(X_test) y_pred = np.argmax(y_pred, axis=1) y_valid = np.argmax(y_valid, axis=1) if valid: accuracy = accuracy_score(y_valid, y_pred) else: accuracy = accuracy_score(y_test, y_pred) # if np.unique(y_test).shape[0] == 2: # avg = 'binary' # else: # avg = 'macro' # f1_value = f1_score(y_test, y_pred, average=avg) f1_value = 0 return accuracy, f1_value