def Pretrained_HO_RCNN(cfg): K.set_image_dim_ordering('th') weights = False modelPrs = AlexNet((3, 227, 227), weights, cfg.nb_classes, include='fc') modelObj = AlexNet((3, 227, 227), weights, cfg.nb_classes, include='fc') modelPar = PairWiseStream(input_shape=(2,64,64), nb_classes = cfg.nb_classes, include='fc') my_actual_weights_path = cfg.my_weights_path cfg.my_weights_path = cfg.prs_weights_path cfg.my_weights = cfg.prs_weights modelPrs = _final_stop(modelPrs.input, modelPrs.output, cfg) cfg.my_weights_path = cfg.obj_weights_path cfg.my_weights = cfg.obj_weights modelObj = _final_stop(modelObj.input, modelObj.output, cfg) cfg.my_weights_path = cfg.par_weights_path cfg.my_weights = cfg.par_weights modelPar = _final_stop(modelPar.input, modelPar.output, cfg) cfg.my_weights_path = my_actual_weights_path cfg.my_weights = None models = [modelPrs, modelObj, modelPar] outputs = [model.layers[-2].output for model in models] outputs = Add()(outputs) inputs = [model.input for model in models] final_model = _final_stop(inputs, outputs, cfg) return final_model
def alexnet(): if not valid_request(request, UPLOAD_FOLDER): return redirect(request.url) # hard coded image as orig.png model = AlexNet(pretrained=True) model.eval() image = Image.open(os.path.join(UPLOAD_FOLDER, 'orig.png')) image = image.convert('RGB') out = topk_to_rank_string(*model(image)) return render_template('/pages/alexnet.html', out=Markup(out[:-2]))
def restore_model(file_path: str): info = torch.load(file_path) arch: str = info['hparams'].arch batch_norm = info['hparams'].batch_norm dataset: str = info['hparams'].dataset hidden_layers: int = info['hparams'].hidden_layers hidden_size: int = info['hparams'].hidden_size if arch == 'mlp' and dataset == 'mnist': model: nn.Module = MLP(input_size=784, hidden_size=hidden_size, num_hidden_layers=hidden_layers, batch_norm=batch_norm) elif arch == 'alexnet': model: nn.Module = AlexNet() else: model: nn.Module = MLP(hidden_size=hidden_size, num_hidden_layers=hidden_layers, batch_norm=batch_norm) model.load_state_dict(info['model_state_dict']) lr = info['hparams'].lr momentum = info['hparams'].momentum weight_decay = info['hparams'].weight_decay optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay) optimizer.load_state_dict(info['optimizer_state_dict']) # model.eval() return model, optimizer, info['hparams']
def configure_model(self): """ :return: """ arch: str = self.hparams.arch batch_norm = self.hparams.batch_norm dataset: str = self.hparams.dataset hidden_layers: int = self.hparams.hidden_layers hidden_size: int = self.hparams.hidden_size if arch == 'mlp': if dataset == 'mnist': return MLP(input_size=784, hidden_size=hidden_size, num_hidden_layers=hidden_layers, batch_norm=batch_norm) elif dataset == 'cifar10': return MLP(hidden_size=hidden_size, num_hidden_layers=hidden_layers, batch_norm=batch_norm) else: raise ValueError('invalid dataset specification!') elif arch == 'alexnet': return AlexNet() elif arch == 'vgg11': return VGG(vgg_name='VGG11') elif arch == 'vgg13': return VGG(vgg_name='VGG13') elif arch == 'resnet18': return ResNet18() elif arch == 'resnet34': return ResNet34() else: raise ValueError('Unsupported model!')
def Fast_HO_RCNN(cfg): K.set_image_dim_ordering('tf') if cfg.backbone == 'vgg': print('Use VGG16 backbone') weights = VGG16_Weights_notop( cfg) if cfg.pretrained_weights == True else False modelShr = VGG16((None, None, cfg.cdim), weights, cfg.nb_classes, include='basic') else: print('Use Alexnet backbone') weights = AlexNet_Weights_notop( cfg) if cfg.pretrained_weights == True else False modelShr = AlexNet((None, None, cfg.cdim), weights, cfg.nb_classes, include='basic') prsRoI = input_rois() objRoI = input_rois() modelPrs = fastClassifier(modelShr.output, prsRoI, cfg, nb_classes=cfg.nb_classes) modelObj = fastClassifier(modelShr.output, objRoI, cfg, nb_classes=cfg.nb_classes) modelPar = fastPairWiseStream(input_shape=(None, 64, 64, 2), nb_classes=cfg.nb_classes, include='fc') if cfg.backbone == 'vgg': # Only train from conv3_1 for i, layer in enumerate(modelShr.layers): layer.trainable = False if i > 6: break outputs = [modelPrs, modelObj, modelPar.output] outputs = [outputs[i] for i in range(len(outputs)) if cfg.inputs[i]] if sum(cfg.inputs) == 1: outputs = outputs[0] else: outputs = Add()(outputs) inputs = [prsRoI, objRoI, modelPar.input] inputs = [inputs[i] for i in range(len(inputs)) if cfg.inputs[i]] if cfg.inputs[0] or cfg.inputs[1]: inputs = [modelShr.input] + inputs final_model = _final_stop(inputs, outputs, cfg) return final_model
def main(): train_images = tf.data.TextLineDataset( '/home/caique/datasets/caltech101/caltech101_train.txt' ) train_labels = tf.data.TextLineDataset( '/home/caique/datasets/caltech101/caltech101_train_labels.txt' ) valid_images = tf.data.TextLineDataset( '/home/caique/datasets/caltech101/caltech101_test.txt' ) valid_labels = tf.data.TextLineDataset( '/home/caique/datasets/caltech101/caltech101_test_labels.txt' ) drop_data = tf.data.Dataset.zip((train_images, train_labels)) drop_data = drop_data.map(get_parser(False)).batch(1) valid_data = tf.data.Dataset.zip((valid_images, valid_labels)) valid_data = valid_data.map(get_parser(False)).batch(120) train_data = tf.data.Dataset.zip((train_images, train_labels)) train_data = train_data.map(get_parser(True)).shuffle(3030).batch(101) session = tf.Session() model = AlexNet(101) saver = tf.train.Saver() saver.restore(session, './variables/alexnet-caltech101-finetunned-2-2') # dropped_filters = drop_filters( # session, model, drop_data, valid_data, drop_total=500, # drop_n=20 # ) # model.train(session, train_data, valid_data, # epochs=40, # lr=0.00001, # # dropped_filters=dropped_filters, # # train_layers=['fc8'], # # weights_path='alexnet_weights.npy', # variables_path='./variables/alexnet-caltech101-finetunned-33', # model_name='alexnet-caltech101-finetunned-2') session.run(model.iterator.make_initializer(valid_data)) print('final eval: {}'.format(model.eval(session))) session.close()
def HO_RCNN(cfg): K.set_image_dim_ordering('th') weights = AlexNet_Weights_th(cfg) if cfg.pretrained_weights == True else False modelPrs = AlexNet((3, 227, 227), weights, cfg.nb_classes, include='fc') modelObj = AlexNet((3, 227, 227), weights, cfg.nb_classes, include='fc') modelPar = PairWiseStream(input_shape=(2,64,64), nb_classes = cfg.nb_classes, include='fc') models = [modelPrs, modelObj, modelPar] models = [models[i] for i in range(len(models)) if cfg.inputs[i]] assert len(models)>0, 'minimum one model must be included in method' if len(models) == 1: outputs = models[0].output else: outputs = Add()([model.output for model in models]) inputs = [model.input for model in models] final_model = _final_stop(inputs, outputs, cfg) return final_model
def init_server(args): model = AlexNet() gradient_warehouse = GradientWarehouse(worker_num=args.world_size, lock=threading.Lock()) threads_num = 2 threads = [] for i in range(threads_num): th = GradientServer(model=model, gradient_warehouse=gradient_warehouse, rank=i) threads.append(th) th.start() for t in threads: t.join()
def construct_model(self, model_name='r1', lr=1e-6): self.model_name = model_name tf.summary.image('image_angle_0', self.images, 1) with open(self.save_path + '/setup.txt', 'a') as self.out: self.out.write('Architecture: ' + str(model_name)+ '\n') self.out.write('number of channels: ' + str(self.n_channels) + '\n') self.out.write('img dimensionality: ' + str(self.img_dimens) + '\n') if model_name == 'r3': self.model = Regressor_3(self.images, self.counts, lr=lr) if model_name == 'alexnet': self.model = AlexNet(self.images, self.counts, lr=0.003) if model_name == 'lstm': self.model = CRNN(self.images, self.counts, lr=0.003) self.loss = self.model.loss() tf.summary.scalar("loss", self.loss) with tf.name_scope('train'): self.train_step = tf.train.AdamOptimizer(lr).minimize(self.loss) tf.add_to_collection(name='saved', value=self.loss) tf.add_to_collection(name='saved', value=self.model.pred_counts) if self.model_name == 'lstm': tf.add_to_collection(name='saved', value=self.reconstruction) tf.add_to_collection(name='placeholder', value=self.x) tf.add_to_collection(name='placeholder', value=self.y) tf.add_to_collection(name='placeholder', value=self.images) tf.add_to_collection(name='placeholder', value=self.counts) tf.add_to_collection(name='placeholder', value=self.model.keep_prob) tf.add_to_collection(name='placeholder', value=self.model.is_training) tf.add_to_collection(name='placeholder', value=self.iterator.initializer) self.summaries = tf.summary.merge_all() self.saver = tf.train.Saver() self.writer = tf.summary.FileWriter(self.save_path+'/logs/train') self.writer_test = tf.summary.FileWriter(self.save_path+'/logs/test')
def get_model(model_name, num_classes): if model_name == "create_new_model": return create_new_model(num_classes) elif model_name == "AlexNet": return AlexNet(num_classes) elif model_name == "LeNet5": return LeNet5(num_classes) elif model_name == "VGG16": return VGG16(num_classes) elif model_name == "ResNet50": return ResNet50(num_classes) elif model_name == "InceptionV3": return InceptionV3(num_classes) elif model_name == "DeepFace": return DeepFace(num_classes)
def get_model(name, device): """ Returns required classifier and autoencoder :param name: :return: Autoencoder, Classifier """ if name == 'lenet': model = LeNet(in_channels=channels).to(device) elif name == 'alexnet': model = AlexNet(channels=channels, num_classes=10).to(device) elif name == 'vgg': model = VGG(in_channels=channels, num_classes=10).to(device) autoencoder = CAE(in_channels=channels).to(device) return model, autoencoder
def model_fn(input_images, num_classes, is_training, keep_prob): if model_name == 'alexnet': model = AlexNet(input_images, keep_prob, num_classes, weight_decay=0.0005) elif model_name == 'binary_connect_mlp': model = binaryconnect.MLP(input_images, is_training, 1.0, num_classes, binary, stochastic) elif model_name == 'binary_connect_cnn': # Paper settings: 500 epochs, batch size 50 model = binaryconnect.CNN(input_images, is_training, num_classes, binary, stochastic) return model
def __init__(self, model,dataset_index=0,video_target = None): if args.video == None: self.video_target = video_target customset_train = CustomDataset(path = args.dataset_path,subset_type="training",dataset_index=dataset_index,video_target = video_target) customset_test = CustomDataset(path = args.dataset_path,subset_type="testing",dataset_index=dataset_index, video_target = video_target) self.trainloader = torch.utils.data.DataLoader(dataset=customset_train,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers) self.testloader = torch.utils.data.DataLoader(dataset=customset_test,batch_size=args.batch_size,shuffle=False,num_workers=args.num_workers) else: video_dataset = VideoDataset(video=args.video, batch_size=args.batch_size, frame_skip=int(args.frame_skip),image_folder=args.extract_frames_path, use_existing=args.use_existing_frames) self.videoloader = torch.utils.data.DataLoader(dataset=video_dataset, batch_size=1,shuffle=False,num_workers=args.num_workers) if (model == "alex"): self.model = AlexNet() elif (model == "vgg"): self.model = VGG() elif (model == "resnet"): self.model = ResNet() if args.pretrained_model != None: if args.pretrained_finetuning == False: self.model.load_state_dict(torch.load(args.pretrained_model)) else: print "DEBUG : Make it load only part of the resnet model" #print(self.model) #self.model.load_state_dict(torch.load(args.pretrained_model)) #for param in self.model.parameters(): # param.requires_grad = False self.model.fc = nn.Linear(512, 1000) #print(self.model) self.model.load_state_dict(torch.load(args.pretrained_model)) self.model.fc = nn.Linear(512,3) #print(self.model) self.model.cuda() print "Using weight decay: ",args.weight_decay self.optimizer = optim.SGD(self.model.parameters(), weight_decay=float(args.weight_decay),lr=0.01, momentum=0.9,nesterov=True) self.criterion = nn.CrossEntropyLoss().cuda()
def __init__(self, model,dataset_index=0, path = None): self.sampler = self.weighted_sampling(dataset_index=dataset_index,path=path) customset_train = CustomDatasetViewpoint(path = path,subset_type="training",dataset_index=dataset_index) customset_test = CustomDatasetViewpoint(path = path,subset_type="testing",dataset_index=dataset_index) self.trainloader = torch.utils.data.DataLoader(pin_memory=True,dataset=customset_train,sampler=self.sampler,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers) self.trainloader_acc = torch.utils.data.DataLoader(dataset=customset_train,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers) self.testloader_acc = torch.utils.data.DataLoader(dataset=customset_test,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers) if (model == "alex"): self.model = AlexNet() elif (model == "vgg"): self.model = VGG(num_classes=2) elif (model == "resnet"): self.model = ResNet() if args.pretrained_model != None: if args.pretrained_same_architecture: self.model.load_state_dict(torch.load(args.pretrained_model)) else: if args.arch == "vgg": self.model.soft = None classifier = list(self.model.classifier.children()) classifier.pop() classifier.append(torch.nn.Linear(4096,1000)) new_classifier = torch.nn.Sequential(*classifier) self.model.classifier = new_classifier self.model.load_state_dict(torch.load(args.pretrained_model)) classifier = list(self.model.classifier.children()) classifier.pop() classifier.append(torch.nn.Linear(4096,2)) new_classifier = torch.nn.Sequential(*classifier) self.model.classifier = new_classifier self.model.soft = nn.LogSoftmax() else: self.model.fc = nn.Linear(512, 1000) self.model.load_state_dict(torch.load(args.pretrained_model)) self.model.fc = nn.Linear(512,2) self.optimizer = optim.Adam(self.model.parameters(), weight_decay=float(args.weight_decay), lr=0.0001)
def main(datasets_path='/home/caique/datasets/caltech101', variables_path='./variables/alexnet-caltech101-78'): train_images = tf.data.TextLineDataset(datasets_path + '/caltech101_train.txt') train_labels = tf.data.TextLineDataset(datasets_path + '/caltech101_train_labels.txt') valid_images = tf.data.TextLineDataset(datasets_path + '/caltech101_valid.txt') valid_labels = tf.data.TextLineDataset(datasets_path + '/caltech101_valid_labels.txt') # drop_data = tf.data.Dataset.zip((train_images, train_labels)) # drop_data = drop_data.map(get_parser(False)).batch(1) valid_data = tf.data.Dataset.zip((valid_images, valid_labels)) valid_data = valid_data.map(get_parser(False)).batch(120) train_data = tf.data.Dataset.zip((train_images, train_labels)) train_data = train_data.map(get_parser(True)).shuffle(3030).batch(101) model = AlexNet(101, keep_prob=1.0) drop_filters(model, train_data, valid_data, variables_path)
def __init__(self, model, dataset_index=0, path=None, viewpoints=3): if (model == "alex"): self.model = AlexNet() elif (model == "vgg"): self.model = VGG(num_classes=2) elif (model == "resnet"): self.model = ResNet() elif (model == "ED"): self.model_ED = EncoderDecoderViewpoints() self.model_vgg = VGG_viewpoints(num_classes=3).cuda() self.model_ed = EncoderDecoderViewpoints().cuda() self.model_vgg = nn.DataParallel(self.model_vgg, device_ids=[0, 1, 2, 3]).cuda() self.model_vgg.load_state_dict( torch.load( "./results/viewpoint_models/vgg_viewpoint_ED_prepared/model_epoch_2.pth" )) mod = list(self.model_vgg.module.classifier.children()) mod.pop() mod.pop() mod.pop() new_classifier = torch.nn.Sequential(*mod) self.model_vgg.module.new_classifier = new_classifier print self.model_vgg # Trained ED loading, comment to disable self.model_ed.load_state_dict( torch.load( "./results/viewpoint_models/vgg_viewpoint_ED_disjointed/model_ed_epoch_20.pth" )) print self.model_ed
# Dataloaders batch_size = 128 train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, sampler=train_sampler) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, sampler=valid_sampler) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, sampler=test_sample) # GPU setup device = torch.device('cuda') net = AlexNet(in_channel=2, classes=10).to(device=device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=0.001) #, momentum=0.9) # Train loop num_epochs = 25 for epoch in range(num_epochs): print("Epoch: {} - Train".format(epoch)) net.train() running_loss = 0. # Train: for batch_index, (signals, labels) in enumerate(tqdm(train_loader)): signals, labels = signals.to(device=device), labels.to(device=device)
# fix the random seed # 0 999 333 111 123 SEED = 0 torch.manual_seed(SEED) np.random.seed(SEED) # hyperparameters PATHS = stock_data_paths() MODEL_PATH = "weights/cnn/try" BATCH_SIZE = 100 N_EPOCHS = 1 N_LAGS = 25 Y_DAYS = 1 NUM_FEA = 1 LR = 0.01 # load the dataset X_train, y_train, X_test, y_test = create_input_data(PATHS, N_LAGS, Y_DAYS) train_dataset = StockDataset(X_train, y_train) train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE) test_dataset = StockDataset(X_test, y_test) test_loader = DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE) net = AlexNet(N_LAGS, Y_DAYS).to(device) train(net, N_EPOCHS, train_loader, LR, MODEL_PATH) eval(net, MODEL_PATH, test_loader=test_loader) #plot_one_stock(X_test, y_test, net, MODEL_PATH, length=1000) #The MSE is 0.002010555131915416 #The MSE is 0.004173629942736138
from models import LeNet, AlexNet, VGG13, ResNet34, TestNet from keras.models import load_model from keras import optimizers from prepare_data import load_data from utils import CLASS_NUM, IMG_SIZE import os train_X, test_X, train_y, test_y = load_data(class_num=CLASS_NUM, img_size=IMG_SIZE) if not os.path.exists('autogta.h5'): autogta = AlexNet(train_X[0].shape) autogta.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) autogta.fit(x=train_X, y=train_y, epochs=10, batch_size=16) autogta.save('autogta.h5') else: autogta = load_model('autogta.h5') loss, accu = autogta.evaluate(x=test_X, y=test_y) print('loss\t{}\naccuracy\t{}'.format(loss, accu))
def init_server(args): model = AlexNet() server = ParameterServer(model=model) server.run()
import matplotlib.pyplot as plt import matplotlib.image as mpimg import cv2 import torch from models import AlexNet from torch.autograd import Variable import warnings warnings.simplefilter("ignore") # Detect all faces in an image # load in a haar cascade cassifier fro detecting frontal faces face_cascade = cv2.CascadeClassifier( './detectors/haarcascade_frontalface_default.xml') net = AlexNet() # loading the best saved model parameters net.load_state_dict( torch.load('./saved_models/keypoints_model_AlexNet_50epochs.pth')) # perepate the net for testing mode net.eval() # image = cv2.imread('imgs/10.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) faces = face_cascade.detectMultiScale(image, 1.2, 2) # make a copy of the original image to plot detections on image_with_detections = image.copy()
def main(): global args, best_prec1 args = parser.parse_args() print(args) # Set # classes if args.data == 'UCF101': num_classes = 101 else: num_classes = 0 print('Specify the dataset to use ') # Create model if args.pretrained: print("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True) else: print("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch]() if args.arch.startswith('alexnet'): model = AlexNet(num_classes=num_classes) model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # Modify last layer of the model model_ft = models.resnet18(pretrained=True) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, 101) model = model_ft.cuda() model = torch.nn.DataParallel(model).cuda() # Using one GPU (device_ids = 1) # print(model) # Define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # Optionally resume from a checkpoint if args.resume: checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code traindir = os.path.join(args.data, 'train') testdir = os.path.join(args.data, 'test') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_loader = torch.utils.data.DataLoader( datasets.ImageFolder(traindir, transforms.Compose([ transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])), batch_size = args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True ) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(testdir, transforms.Compose([ transforms.Scale(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size = args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True ) if args.evaluate: validate(val_loader, model, criterion) return for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # Train for one epoch train(train_loader, model, criterion, optimizer, epoch) # # Evaluate on validation set prec1 = validate(val_loader, model, criterion) # Remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint({ 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best)
if __name__ == '__main__': writer = SummaryWriter('runs/histo_run_AlexNet_lr_1e-4') df = pd.read_csv(data.train_csv) train_df, val_df = train_test_split(df, test_size=0.15) train_dataset = HistoDataset(train_df, data.train_dir) val_dataset = HistoDataset(val_df, data.train_dir) test_df = pd.read_csv(data.test_csv) test_dataset = HistoDataset(test_df, data.test_dir, flag=HistoDataset.TEST_SET) train_loader = DataLoader(train_dataset, batch_size=4) val_loader = DataLoader(val_dataset, batch_size=4) model = AlexNet.AlexNet() img, label = next(iter(train_loader)) writer.add_graph(model, img) optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=2, verbose=True) loss_fn = torch.nn.BCEWithLogitsLoss() device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = train_model(model, train_loader, val_loader, optimizer, scheduler, 20, loss_fn, device, writer) torch.save(model.state_dict(), 'models/AlexNet.pt') predictions = predict(model, test_dataset, device)
help='feature extraction model') parser.add_argument('--feature_name', default='conv_3', type=str, help='feature extraction layer') parser.add_argument('--allsubj', action='store_true', help='whether or not to use all subjects') parser.add_argument('--l2', default=0, type=float, help='L2 regularization weight') args = parser.parse_args() if args.feature_extractor == 'alexnet': feat_extractor = AlexNet(args.feature_name) elif args.feature_extractor == 'vgg16': feat_extractor = VGG16(args.feature_name) else: raise ValueError('unimplemented feature extractor: {}'.format( args.feature_extractor)) if torch.cuda.is_available(): feat_extractor.cuda() subj_file = 'subjall.npy' if args.allsubj else 'subj1.npy' voxels, stimuli = voxel_data(os.path.join(args.bold5000_folder, subj_file), args.roi) voxel_pcs = PCA(n_components=voxels.shape[1]).fit_transform(voxels) stimuli = [ os.path.join(args.bold5000_folder, 'stimuli', s) for s in stimuli
import os import numpy as np import torch from tqdm import tqdm from sklearn.decomposition import PCA from sklearn.cross_decomposition import CCA from sklearn.model_selection import KFold from models import CCAEncoder, PCAEncoder, AlexNet import utils n_components = 10 roi = 'PPA' bold5000_folder = '/home/eelmozn1/datasets/adversarial_tms/bold5000' feat_extractor = AlexNet('conv_3') def voxel_data(subj_file, roi): voxels = np.load(subj_file, allow_pickle=True).item() voxels = {c: v[roi] for c, v in voxels.items()} return voxels def condition_features(stimuli_folder, model): print('Extracting features') stimuli = os.listdir(stimuli_folder) condition_features = {} batch_size = 32 for i in tqdm(range(0, len(stimuli), batch_size)): batch_names = stimuli[i:i + batch_size] batch = [ utils.image_to_tensor(os.path.join(stimuli_folder, n),
worker_init_fn (callable, 可选) --- 如果不是 None,那么将在每个工人子进程上使用 worker id(在 [0,num_workers - 1] 中的 int)作为输入,在 seeding 和加载数据之前调用这个子进程。(默认:无) ''' # 测试数据的获取 # 首先设置测试数据的路径 test_path = 'D:/dataset/dogs-vs-cats/test1' # 从测试数据集的存储路径中提取测试数据集 test_path = GetData(test_path, test=True) # 将测试数据转换成 mini-batch 形式 loader_test = data.DataLoader(test_dataset, batch_size=3, shuffle=True, num_workers=1) # --------------------------- 1.加载数据 end ---------------------------------------------------------------- # --------------------------- 2.构建 CNN 模型 start ---------------------------------------------------------------- # 调用我们现成的 AlexNet() 模型 cnn = AlexNet() # 将模型打印出来观察一下 print(cnn) # --------------------------- 2.构建 CNN 模型 end ------------------------------------------------------------------ # --------------------------- 3.设置相应的优化器和损失函数 start ------------------------------------------------------------------ ''' 1、torch.optim 是一个实现各种优化算法的软件包。 比如我们这里使用的就是 Adam() 这个方法 class torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False) 这个类就实现了 adam 算法。 params(iterable) --- 可迭代的参数来优化或取消定义参数组 lr(float, 可选) --- 学习率(默认值 1e-3) beta(Tuple[float, float], 可选) --- 用于计算梯度及其平方的运行平均值的系数(默认值:(0.9,0.999)) eps (float, 可选) ---- 添加到分母以提高数值稳定性(默认值:1e-8)
traindir = '/opt/data/kaggle/playground/dogs-vs-cats/sample_train' train_dataset = DogCat(traindir, train=True) loader_train = data.DataLoader(train_dataset, batch_size=20, shuffle=True, num_workers=1) testdir = '/opt/data/kaggle/playground/dogs-vs-cats/sample_test' test_dataset = DogCat(testdir, train=True) loader_test = data.DataLoader(test_dataset, batch_size=3, shuffle=True, num_workers=1) # 2. 创建 CNN 模型 cnn = AlexNet() print(cnn) # 3. 设置优化器和损失函数 optimizer = torch.optim.Adam(cnn.parameters(), lr=0.005, betas=(0.9, 0.99)) # optimize all cnn parameters loss_func = nn.CrossEntropyLoss() # the target label is not one-hotted # 4. 训练模型 EPOCH = 10 # train the training data n times, to save time, we just train 1 epoch # training and testing for epoch in range(EPOCH): num = 0 # gives batch data, normalize x when iterate train_loader for step, (x, y) in enumerate(loader_train): b_x = Variable(x) # batch x b_y = Variable(y) # batch y
writer.add_scalar('train/acc', acc, n_iter) writer.add_scalar('val/loss', val_loss, n_iter) writer.add_scalar('val/acc', val_acc, n_iter) # dataloader train_loader, test_loader = getDataloader(root=dataset, batchsize=batchsize, worker=worker_num) # model select # If you want to change the details of the model, please go to the models folder # to edit the model. # model select if modelName == 'AlexNet': from models.AlexNet import * model = AlexNet() elif modelName == "SqueezeNet": from models.SqueezeNet import * model = SqueezeNet() elif modelName == "VGG16": from models.VGG16 import * model = VGG16() elif modelName == "GoogLeNet": from models.GoogLeNet import * model = GoogLeNet() elif modelName == "ResNet18": from models.ResNet18 import * model = ResNet18() elif modelName == "DenseNet121": from models.DenseNet import * model = DenseNet121()
def main(args): logs = [] transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) trainloader, testloader = get_dataset(args, transform) net = AlexNet() if args.no_distributed: optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.0) else: optimizer = DownpourSGD(net.parameters(), lr=args.lr, n_push=args.num_push, n_pull=args.num_pull, model=net) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=1, verbose=True, min_lr=1e-3) # train net.train() if args.cuda: net = net.cuda() for epoch in range(args.epochs): # loop over the dataset multiple times print("Training for epoch {}".format(epoch)) for i, data in enumerate(trainloader, 0): # get the inputs inputs, labels = data if args.cuda: inputs, labels = inputs.cuda(), labels.cuda() # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = F.cross_entropy(outputs, labels) loss.backward() optimizer.step() _, predicted = torch.max(outputs, 1) accuracy = accuracy_score(predicted, labels) log_obj = { 'timestamp': datetime.now(), 'iteration': i, 'training_loss': loss.item(), 'training_accuracy': accuracy, } if i % args.log_interval == 0 and i > 0: # print every n mini-batches log_obj['test_loss'], log_obj['test_accuracy']= evaluate( net, testloader, args) print("Timestamp: {timestamp} | " "Iteration: {iteration:6} | " "Loss: {training_loss:6.4f} | " "Accuracy : {training_accuracy:6.4f} | " "Test Loss: {test_loss:6.4f} | " "Test Accuracy: {test_accuracy:6.4f}".format(**log_obj)) logs.append(log_obj) val_loss, val_accuracy = evaluate(net, testloader, args, verbose=True) scheduler.step(val_loss) df = pd.DataFrame(logs) print(df) if args.no_distributed: if args.cuda: df.to_csv('log/gpu.csv', index_label='index') else: df.to_csv('log/single.csv', index_label='index') else: df.to_csv('log/node{}.csv'.format(dist.get_rank()), index_label='index') print('Finished Training')
loader_train = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) loader_test = torch.utils.data.DataLoader( datasets.ImageFolder(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) # Load the pretrained model net = AlexNet() net.load_state_dict(torch.load('/home/choong/.torch/models/alexnet-owt-4df8aa71.pth'), strict=False) if torch.cuda.is_available(): print('CUDA enabled.') net.cuda() print("--- Pretrained network loaded ---") # test(net, loader_test) # prune the weights masks = weight_prune(net, param['pruning_perc']) net.set_masks(masks) net = nn.DataParallel(net) print("--- {}% parameters pruned ---".format(param['pruning_perc'])) test(net, loader_test)
filewriter_path = 'cifar100_history/' checkpoint_path = 'checkpoints/' IMAGE_SIZE = 24 OUTPUT_FILE_NAME = 'train_output.txt' decay_steps = int(len(target_train_data) / batch_size) learning_rate_decay_factor = 0.95 if not os.path.isdir(filewriter_path): os.mkdir(filewriter_path) if not os.path.isdir(checkpoint_path): os.mkdir(checkpoint_path) x = tf.placeholder(tf.float32, [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3]) y = tf.placeholder(tf.float32, [None, num_classes]) model = AlexNet(x, num_classes) score = model.fc5 var_list = [ v for v in tf.trainable_variables() if v.name.split('/')[0] in train_layers ] initial_x_batch = tf.placeholder(tf.float32, [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3]) dist_x_batch = distorted_batch(initial_x_batch, IMAGE_SIZE) with tf.name_scope("cross_ent"): loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=score, labels=y)) with tf.name_scope('train'):
def main(): use_cuda = torch.cuda.is_available() and not args.no_cuda device = torch.device('cuda' if use_cuda else 'cpu') print(device) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if use_cuda: torch.cuda.manual_seed(args.seed) torch.backends.cudnn.deterministic = True rgb = False if args.mode == 'rgb': rgb = True if args.gray_scale: rgb = False if args.tracking_data_mod is True: args.input_size = 192 # DATALOADER train_dataset = GesturesDataset(model=args.model, csv_path='csv_dataset', train=True, mode=args.mode, rgb=rgb, normalization_type=1, n_frames=args.n_frames, resize_dim=args.input_size, transform_train=args.train_transforms, tracking_data_mod=args.tracking_data_mod) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.n_workers) validation_dataset = GesturesDataset(model=args.model, csv_path='csv_dataset', train=False, mode=args.mode, rgb=rgb, normalization_type=1, n_frames=args.n_frames, resize_dim=args.input_size, tracking_data_mod=args.tracking_data_mod) validation_loader = DataLoader(validation_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.n_workers) # paramteri per la rete in_channels = args.n_frames if not rgb else args.n_frames * 3 n_classes = args.n_classes if args.model == 'LeNet': model = LeNet(input_channels=in_channels, input_size=args.input_size, n_classes=n_classes).to(device) elif args.model == 'AlexNet': model = AlexNet(input_channels=in_channels, input_size=args.input_size, n_classes=n_classes).to(device) elif args.model == 'AlexNetBN': model = AlexNetBN(input_channels=in_channels, input_size=args.input_size, n_classes=n_classes).to(device) elif args.model == "Vgg16": model = Vgg16(input_channels=in_channels, input_size=args.input_size, n_classes=n_classes).to(device) elif args.model == "Vgg16P": model = models.vgg16(pretrained=args.pretrained) for params in model.parameters(): params.requires_grad = False model.features._modules['0'] = nn.Conv2d(in_channels=in_channels, out_channels=64, kernel_size=(3, 3), stride=1, padding=1) model.classifier._modules['6'] = nn.Linear(4096, n_classes) # model.fc = torch.nn.Linear(model.fc.in_features, n_classes) model = model.to(device) elif args.model == "ResNet18P": model = models.resnet18(pretrained=args.pretrained) for params in model.parameters(): params.requires_grad = False model._modules['conv1'] = nn.Conv2d(in_channels, 64, 7, stride=2, padding=3) model.fc = torch.nn.Linear(model.fc.in_features, n_classes) model = model.to(device) elif args.model == "ResNet34P": model = models.resnet34(pretrained=args.pretrained) for params in model.parameters(): params.requires_grad = False model._modules['conv1'] = nn.Conv2d(in_channels, 64, 7, stride=2, padding=3) model.fc = torch.nn.Linear(model.fc.in_features, n_classes) model = model.to(device) elif args.model == "DenseNet121P": model = models.densenet121(pretrained=args.pretrained) for params in model.parameters(): params.requires_grad = False model.features._modules['conv0'] = nn.Conv2d(in_channels=in_channels, out_channels=64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3)) model.classifier = nn.Linear(in_features=1024, out_features=n_classes, bias=True) model = model.to(device) elif args.model == "DenseNet161P": model = models.densenet161(pretrained=args.pretrained) # for params in model.parameters(): # params.requires_grad = False model.features._modules['conv0'] = nn.Conv2d(in_channels=in_channels, out_channels=96, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3)) model.classifier = nn.Linear(in_features=2208, out_features=n_classes, bias=True) model = model.to(device) elif args.model == "DenseNet169P": model = models.densenet169(pretrained=args.pretrained) for params in model.parameters(): params.requires_grad = False model.features._modules['conv0'] = nn.Conv2d(in_channels=in_channels, out_channels=64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3)) model.classifier = nn.Linear(in_features=1664, out_features=n_classes, bias=True) model = model.to(device) elif args.model == "DenseNet201P": model = models.densenet201(pretrained=args.pretrained) for params in model.parameters(): params.requires_grad = False model.features._modules['conv0'] = nn.Conv2d(in_channels=in_channels, out_channels=64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3)) model.classifier = nn.Linear(in_features=1920, out_features=n_classes, bias=True) model = model.to(device) # RNN elif args.model == 'LSTM' or args.model == 'GRU': model = Rnn(rnn_type=args.model, input_size=args.input_size, hidden_size=args.hidden_size, batch_size=args.batch_size, num_classes=args.n_classes, num_layers=args.n_layers, final_layer=args.final_layer).to(device) # C3D elif args.model == 'C3D': if args.pretrained: model = C3D(rgb=rgb, num_classes=args.n_classes) # modifico parametri print('ok') model.load_state_dict(torch.load('c3d_weights/c3d.pickle', map_location=device), strict=False) # # for params in model.parameters(): # # params.requires_grad = False model.conv1 = nn.Conv3d(1 if not rgb else 3, 64, kernel_size=(3, 3, 3), padding=(1, 1, 1)) # tolgo fc6 perchè 30 frames model.fc6 = nn.Linear(16384, 4096) # num classes 28672 (112*200) model.fc7 = nn.Linear(4096, 4096) # num classes model.fc8 = nn.Linear(4096, n_classes) # num classes model = model.to(device) # Conv-lstm elif args.model == 'Conv-lstm': model = ConvLSTM(input_size=(args.input_size, args.input_size), input_dim=1 if not rgb else 3, hidden_dim=[64, 64, 128], kernel_size=(3, 3), num_layers=args.n_layers, batch_first=True, ).to(device) elif args.model == 'DeepConvLstm': model = DeepConvLstm(input_channels_conv=1 if not rgb else 3, input_size_conv=args.input_size, n_classes=12, n_frames=args.n_frames, batch_size=args.batch_size).to(device) elif args.model == 'ConvGRU': model = ConvGRU(input_size=40, hidden_sizes=[64, 128], kernel_sizes=[3, 3], n_layers=2).to(device) else: raise NotImplementedError if args.opt == 'SGD': optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) # optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, momentum=args.momentum) elif args.opt == 'Adam': optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) loss_function = nn.CrossEntropyLoss().to(device) start_epoch = 0 if args.resume: checkpoint = torch.load("/projects/fabio/weights/gesture_recog_weights/checkpoint{}.pth.tar".format(args.model)) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) start_epoch = checkpoint['epoch'] print("Resuming state:\n-epoch: {}\n{}".format(start_epoch, model)) #name experiment personal_name = "{}_{}_{}".format(args.model, args.mode, args.exp_name) info_experiment = "{}".format(personal_name) log_dir = "/projects/fabio/logs/gesture_recog_logs/exps" weight_dir = personal_name log_file = open("{}/{}.txt".format("/projects/fabio/logs/gesture_recog_logs/txt_logs", personal_name), 'w') log_file.write(personal_name + "\n\n") if personal_name: exp_name = (("exp_{}_{}".format(time.strftime("%c"), personal_name)).replace(" ", "_")).replace(":", "-") else: exp_name = (("exp_{}".format(time.strftime("%c"), personal_name)).replace(" ", "_")).replace(":", "-") writer = SummaryWriter("{}".format(os.path.join(log_dir, exp_name))) # add info experiment writer.add_text('Info experiment', "model:{}" "\n\npretrained:{}" "\n\nbatch_size:{}" "\n\nepochs:{}" "\n\noptimizer:{}" "\n\nlr:{}" "\n\ndn_lr:{}" "\n\nmomentum:{}" "\n\nweight_decay:{}" "\n\nn_frames:{}" "\n\ninput_size:{}" "\n\nhidden_size:{}" "\n\ntracking_data_mode:{}" "\n\nn_classes:{}" "\n\nmode:{}" "\n\nn_workers:{}" "\n\nseed:{}" "\n\ninfo:{}" "".format(args.model, args.pretrained, args.batch_size, args.epochs, args.opt, args.lr, args.dn_lr, args.momentum, args.weight_decay, args.n_frames, args.input_size, args.hidden_size, args.tracking_data_mod, args.n_classes, args.mode, args.n_workers, args.seed, info_experiment)) trainer = Trainer(model=model, loss_function=loss_function, optimizer=optimizer, train_loader=train_loader, validation_loader=validation_loader, batch_size=args.batch_size, initial_lr=args.lr, device=device, writer=writer, personal_name=personal_name, log_file=log_file, weight_dir=weight_dir, dynamic_lr=args.dn_lr) print("experiment: {}".format(personal_name)) start = time.time() for ep in range(start_epoch, args.epochs): trainer.train(ep) trainer.val(ep) # display classes results classes = ['g0', 'g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'g7', 'g8', 'g9', 'g10', 'g11'] for i in range(args.n_classes): print('Accuracy of {} : {:.3f}%%'.format( classes[i], 100 * trainer.class_correct[i] / trainer.class_total[i])) end = time.time() h, rem = divmod(end - start, 3600) m, s, = divmod(rem, 60) print("\nelapsed time (ep.{}):{:0>2}:{:0>2}:{:05.2f}".format(args.epochs, int(h), int(m), s)) # writing accuracy on file log_file.write("\n\n") for i in range(args.n_classes): log_file.write('Accuracy of {} : {:.3f}%\n'.format( classes[i], 100 * trainer.class_correct[i] / trainer.class_total[i])) log_file.close()