def get_recognition_model(): from model import model model = model.WaterMeterModel() checkpoint = torch.load('./models/water_meter_recognition.pth', map_location='cpu') state_dict = checkpoint['state_dict'] model.load_state_dict(state_dict) model.eval() return model
def predict(json_map, checkpoint, image_path, model, topk, processor): #''' Predict the class (or classes) of an image using a trained deep learning model.''' # Test out your network! if processor == 'CPU': checkpoint_information = torch.load(checkpoint, map_location='cpu') else: checkpoint_information = torch.load(checkpoint) model.load_state_dict(checkpoint_information['state_dict']) model.eval() a = process_image(image_path) y = np.expand_dims(a, axis=0) if processor == 'CPU': img = torch.from_numpy(y) else: img = torch.from_numpy(y).cuda() output = model.double()(Variable(img, volatile=True)) ps = torch.exp(output) ps_top5 = torch.topk(ps, topk) probs = ps_top5[0] classes = ps_top5[1] import json with open(json_map, 'r') as f: cat_to_name = json.load(f) data_dir = 'flowers' train_dir = data_dir + '/train' train_transforms = transforms.Compose([ transforms.RandomRotation(25), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) train_data = datasets.ImageFolder(train_dir, transform=train_transforms) xx = train_data.class_to_idx class_to_idx_dict = train_data.class_to_idx key_value_exchange_dict = dict((v, k) for k, v in xx.items()) probabilities = probs.data.cpu().numpy().tolist()[0] plant_classes = classes.data.cpu().numpy().tolist()[0] for i in range(len(probabilities)): plant_classes[i] = key_value_exchange_dict[plant_classes[i]] return probabilities, plant_classes, cat_to_name
def main(): model = Net() if torch.cuda.is_available(): model.cuda() else: pass model.apply(weights_init) if args.resume: if isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'" .format(args.resume)) else: print("=> no checkpoint found at '{}'".format(args.resume)) # 数据处理 # 直接在train里面处理 # dataParser = DataParser(batch_size) loss_function = nn.L1Loss() optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4) # train_scheduler = optim.lr_scheduler.MultiStepLR(optimizer,milestones=settings.MILESTONES,gamma=0.2)#learning rate decay scheduler = lr_scheduler.StepLR(optimizer, step_size=args.stepsize, gamma=args.gamma) log = Logger(join(TMP_DIR, '%s-%d-log.txt' % ('Adam', args.lr))) sys.stdout = log train_loss = [] train_loss_detail = [] for epoch in range(args.start_epoch, args.maxepoch): if epoch == 0: print("Performing initial testing...") # 暂时空着 tr_avg_loss, tr_detail_loss = train(model = model,optimizer = optimizer,epoch= epoch,save_dir=join(TMP_DIR, 'epoch-%d-training-record' % epoch)) test() log.flush() # Save checkpoint save_file = os.path.join(TMP_DIR, 'checkpoint_epoch{}.pth'.format(epoch)) save_checkpoint({'epoch': epoch, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict()}) scheduler.step() # 自动调整学习率 train_loss.append(tr_avg_loss) train_loss_detail += tr_detail_loss
def main(): """Run inference.""" from model import model parser = argparse.ArgumentParser( description='PyTorch RNN Anomaly Detection Model') parser.add_argument('--prediction_window_size', type=int, default=10, help='prediction_window_size') parser.add_argument( '--data', type=str, default='ecg', help= 'type of the dataset (ecg, gesture, power_demand, space_shuttle, respiration, nyc_taxi' ) parser.add_argument('--filename', type=str, default='chfdb_chf13_45590.pkl', help='filename of the dataset') parser.add_argument('--save_fig', action='store_true', help='save results as figures') parser.add_argument( '--compensate', action='store_true', help='compensate anomaly score using anomaly score esimation') parser.add_argument('--beta', type=float, default=1.0, help='beta value for f-beta score') parser.add_argument('--device', type=str, default='cuda', help='cuda or cpu') args_ = parser.parse_args() print('-' * 89) print("=> loading checkpoint ") if args_.device == 'cpu': checkpoint = torch.load(str( Path('save', args_.data, 'checkpoint', args_.filename).with_suffix('.pth')), map_location=torch.device('cpu')) else: checkpoint = torch.load( str( Path('save', args_.data, 'checkpoint', args_.filename).with_suffix('.pth'))) args = checkpoint['args'] args.prediction_window_size = args_.prediction_window_size args.beta = args_.beta args.save_fig = args_.save_fig args.compensate = args_.compensate args.device = args_.device print("=> loaded checkpoint") # Set the random seed manually for reproducibility. torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) ############################################################################### # Load data ############################################################################### TimeseriesData = preprocess_data.PickleDataLoad(data_type=args.data, filename=args.filename, augment_test_data=False) train_dataset = TimeseriesData.batchify( args, TimeseriesData.trainData[:TimeseriesData.length], bsz=1) test_dataset = TimeseriesData.batchify(args, TimeseriesData.testData, bsz=1) ############################################################################### # Build the model ############################################################################### nfeatures = TimeseriesData.trainData.size(-1) model = model.RNNPredictor(rnn_type=args.model, enc_inp_size=nfeatures, rnn_inp_size=args.emsize, rnn_hid_size=args.nhid, dec_out_size=nfeatures, nlayers=args.nlayers, res_connection=args.res_connection).to( args.device) model.load_state_dict(checkpoint['state_dict']) scores, predicted_scores, precisions, recalls, f_betas = list(), list( ), list(), list(), list() targets, mean_predictions, oneStep_predictions, Nstep_predictions = list( ), list(), list(), list() try: # For each channel in the dataset for channel_idx in range(nfeatures): ''' 1. Load mean and covariance if they are pre-calculated, if not calculate them. ''' # Mean and covariance are calculated on train dataset. if 'means' in checkpoint.keys() and 'covs' in checkpoint.keys(): print('=> loading pre-calculated mean and covariance') mean, cov = checkpoint['means'][channel_idx], checkpoint[ 'covs'][channel_idx] else: print('=> calculating mean and covariance') mean, cov = fit_norm_distribution_param( args, model, train_dataset, channel_idx=channel_idx) ''' 2. Train anomaly score predictor using support vector regression (SVR). (Optional) ''' # An anomaly score predictor is trained # given hidden layer output and the corresponding anomaly score on train dataset. # Predicted anomaly scores on test dataset can be used for the baseline of the adaptive threshold. if args.compensate: print('=> training an SVR as anomaly score predictor') train_score, _, _, hiddens, _ = anomalyScore( args, model, train_dataset, mean, cov, channel_idx=channel_idx) score_predictor = GridSearchCV(SVR(), cv=5, param_grid={ "C": [1e0, 1e1, 1e2], "gamma": np.logspace(-1, 1, 3) }) score_predictor.fit( torch.cat(hiddens, dim=0).numpy(), train_score.cpu().numpy()) else: score_predictor = None ''' 3. Calculate anomaly scores''' # Anomaly scores are calculated on the test dataset # given the mean and the covariance calculated on the train dataset print('=> calculating anomaly scores') score, sorted_prediction, sorted_error, _, predicted_score = anomalyScore( args, model, test_dataset, mean, cov, score_predictor=score_predictor, channel_idx=channel_idx) ''' 4. Evaluate the result ''' # The obtained anomaly scores are evaluated by measuring precision, recall, and f_beta scores # The precision, recall, f_beta scores are are calculated repeatedly, # sampling the threshold from 1 to the maximum anomaly score value, either equidistantly or logarithmically. print('=> calculating precision, recall, and f_beta') precision, recall, f_beta = get_precision_recall( args, score, num_samples=1000, beta=args.beta, label=TimeseriesData.testLabel.to(args.device)) print('data: ', args.data, ' filename: ', args.filename, ' f-beta (no compensation): ', f_beta.max().item(), ' beta: ', args.beta) if args.compensate: precision, recall, f_beta = get_precision_recall( args, score, num_samples=1000, beta=args.beta, label=TimeseriesData.testLabel.to(args.device), predicted_score=predicted_score) print('data: ', args.data, ' filename: ', args.filename, ' f-beta (compensation): ', f_beta.max().item(), ' beta: ', args.beta) target = preprocess_data.reconstruct( test_dataset.cpu()[:, 0, channel_idx], TimeseriesData.mean[channel_idx], TimeseriesData.std[channel_idx]).numpy() mean_prediction = preprocess_data.reconstruct( sorted_prediction.mean(dim=1).cpu(), TimeseriesData.mean[channel_idx], TimeseriesData.std[channel_idx]).numpy() oneStep_prediction = preprocess_data.reconstruct( sorted_prediction[:, -1].cpu(), TimeseriesData.mean[channel_idx], TimeseriesData.std[channel_idx]).numpy() Nstep_prediction = preprocess_data.reconstruct( sorted_prediction[:, 0].cpu(), TimeseriesData.mean[channel_idx], TimeseriesData.std[channel_idx]).numpy() sorted_errors_mean = sorted_error.abs().mean(dim=1).cpu() sorted_errors_mean *= TimeseriesData.std[channel_idx] sorted_errors_mean = sorted_errors_mean.numpy() score = score.cpu() scores.append(score), targets.append( target), predicted_scores.append(predicted_score) mean_predictions.append( mean_prediction), oneStep_predictions.append( oneStep_prediction) Nstep_predictions.append(Nstep_prediction) precisions.append(precision), recalls.append( recall), f_betas.append(f_beta) if args.save_fig: save_dir = Path( 'result', args.data, args.filename).with_suffix('').joinpath('fig_detection') save_dir.mkdir(parents=True, exist_ok=True) plt.plot(precision.cpu().numpy(), label='precision') plt.plot(recall.cpu().numpy(), label='recall') plt.plot(f_beta.cpu().numpy(), label='f1') plt.legend() plt.xlabel('Threshold (log scale)') plt.ylabel('Value') plt.title('Anomaly Detection on ' + args.data + ' Dataset', fontsize=18, fontweight='bold') plt.savefig( str( save_dir.joinpath('fig_f_beta_channel' + str(channel_idx)).with_suffix( '.png'))) plt.close() fig, ax1 = plt.subplots(figsize=(15, 5)) ax1.plot(target, label='Target', color='black', marker='.', linestyle='--', markersize=1, linewidth=0.5) ax1.plot(mean_prediction, label='Mean predictions', color='purple', marker='.', linestyle='--', markersize=1, linewidth=0.5) ax1.plot(oneStep_prediction, label='1-step predictions', color='green', marker='.', linestyle='--', markersize=1, linewidth=0.5) ax1.plot(Nstep_prediction, label=str(args.prediction_window_size) + '-step predictions', color='blue', marker='.', linestyle='--', markersize=1, linewidth=0.5) ax1.plot(sorted_errors_mean, label='Absolute mean prediction errors', color='orange', marker='.', linestyle='--', markersize=1, linewidth=1.0) ax1.legend(loc='upper left') ax1.set_ylabel('Value', fontsize=15) ax1.set_xlabel('Index', fontsize=15) ax2 = ax1.twinx() ax2.plot( score.numpy().reshape(-1, 1), label= 'Anomaly scores from \nmultivariate normal distribution', color='red', marker='.', linestyle='--', markersize=1, linewidth=1) if args.compensate: ax2.plot(predicted_score, label='Predicted anomaly scores from SVR', color='cyan', marker='.', linestyle='--', markersize=1, linewidth=1) ax2.legend(loc='upper right') ax2.set_ylabel('anomaly score', fontsize=15) plt.title('Anomaly Detection on ' + args.data + ' Dataset', fontsize=18, fontweight='bold') plt.tight_layout() plt.xlim([0, len(test_dataset)]) plt.savefig( str( save_dir.joinpath('fig_scores_channel' + str(channel_idx)).with_suffix( '.png'))) plt.close() except KeyboardInterrupt: print('-' * 89) print('Exiting from training early') print('=> saving the results as pickle extensions') save_dir = Path('result', args.data, args.filename).with_suffix('') save_dir.mkdir(parents=True, exist_ok=True) pickle.dump(targets, open(str(save_dir.joinpath('target.pkl')), 'wb')) pickle.dump(mean_predictions, open(str(save_dir.joinpath('mean_predictions.pkl')), 'wb')) pickle.dump(oneStep_predictions, open(str(save_dir.joinpath('oneStep_predictions.pkl')), 'wb')) pickle.dump(Nstep_predictions, open(str(save_dir.joinpath('Nstep_predictions.pkl')), 'wb')) pickle.dump(scores, open(str(save_dir.joinpath('score.pkl')), 'wb')) pickle.dump(predicted_scores, open(str(save_dir.joinpath('predicted_scores.pkl')), 'wb')) pickle.dump(precisions, open(str(save_dir.joinpath('precision.pkl')), 'wb')) pickle.dump(recalls, open(str(save_dir.joinpath('recall.pkl')), 'wb')) pickle.dump(f_betas, open(str(save_dir.joinpath('f_beta.pkl')), 'wb')) print('-' * 89)
eval_dataset = dsets.ImageFolder(EVAL_DATA_PATH, transform=preprocessing.transform) train_dataset = dsets.ImageFolder(TRAIN_DATA_PATH, transform=preprocessing.transform) eval_dataloader = DataLoader(eval_dataset, batch_size=BATCH_SIZE, shuffle=True) train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True) #使用交叉熵为 loss,使用 SGD 优化方法 criterion = NN.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) #载入上次训练 model.load_state_dict(torch.load("./chkpoint_res.bin")) #开始训练 for epoch in range(0, 100): model.train() with tqdm(train_dataloader, unit="batch") as tepoch: #进度条 correct = 0 batch = 0 for data, target in tepoch: batch += 1 tepoch.set_description(f"Epoch {epoch}") data, target = data.cuda(), target.cuda() #数据载入 GPU optimizer.zero_grad() #梯度归零 output = model(data) #前向计算 loss = criterion(output, target) #计算 loss
X, y = sklearn.datasets.make_moons(2000, noise=0.1) def predict_fn(data,model): print('Predicting class labels for the input data...') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") data = torch.from_numpy(X.astype('float32')) data = data.to(device) model.eval() # Compute the result of applying the model to the input data. out = model(data) # The variable `result` should be a numpy array; a single value 0-1 result = out.cpu().detach().numpy() return result if __name__ == '__main__': model.load_state_dict(torch.load('model/model.pth')) model.eval() x = torch.from_numpy(X).type(torch.FloatTensor) ans = model.predict(x) print(ans.numpy()) print(accuracy_score(model.predict(x), y)) tp = np.logical_and(y, ans).sum() fp = np.logical_and(1 - y, ans).sum() tn = np.logical_and(1 - y, 1 - ans).sum() fn = np.logical_and(y, 1 - ans).sum() recall = tp / (tp + fn) precision = tp / (tp + fp) accuracy = (tp + tn) / (tp + fp + tn + fn) print(pd.crosstab(y, ans, rownames=['actuals'], colnames=['predictions'])) print("\n{:<11} {:.3f}".format('Recall:', recall))
#!/usr/bin/env python # coding: utf-8 from utils import testPaths, dataIter, DataIter, srcIndex, \ trgIndex,mu,sig,homeDirectory, averageFilter, handleAngleData import torch import codecs import csv from model import model,device import matplotlib.pyplot as plt import numpy as np import copy import time model.load_state_dict(torch.load(homeDirectory+'my-model-test.pt')) for n in range(len(testPaths)): locationData = np.load(homeDirectory+'dataset/'+ testPaths[n]) locationFilePath = homeDirectory + 'predictionData/locations' +testPaths[n][:-4] + '.csv' file = codecs.open(locationFilePath, 'w', 'gbk') writer = csv.writer(file) for i in range(0, np.shape(locationData)[0]): writer.writerow(locationData[i,trgIndex]) file.close() angleFilePath = homeDirectory + 'predictionData/angle' +testPaths[n][:-4] + '.csv' angleFile = codecs.open(angleFilePath, 'w', 'gbk') angleWriter = csv.writer(angleFile) predictionFilePath = homeDirectory + 'predictionData/predictions' +testPaths[n][:-4] + '.csv' file = codecs.open(predictionFilePath, 'w', 'gbk') writer = csv.writer(file) # 获取中心点,并将数据进行归一化
'--model', type=str, metavar='M', help="the model file to be evaluated. Usually it is of the form model_X.pth" ) parser.add_argument('--outfile', type=str, default='experiment/kaggle.csv', metavar='D', help="name of the output csv file") args = parser.parse_args() use_cuda = torch.cuda.is_available() state_dict = torch.load(args.model) model.load_state_dict(state_dict) model.eval() if use_cuda: print('Using GPU') model.cuda() else: print('Using CPU') from data import data_transforms test_dir = args.data + '/test_images/mistery_category' def pil_loader(path): # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835) with open(path, 'rb') as f:
train_dataset = TimeseriesData.batchify(args,TimeseriesData.trainData[:TimeseriesData.length], bsz=1) test_dataset = TimeseriesData.batchify(args,TimeseriesData.testData, bsz=1) ############################################################################### # Build the model ############################################################################### nfeatures = TimeseriesData.trainData.size(-1) model = model.RNNPredictor(rnn_type = args.model, enc_inp_size=nfeatures, rnn_inp_size = args.emsize, rnn_hid_size = args.nhid, dec_out_size=nfeatures, nlayers = args.nlayers, res_connection=args.res_connection).to(args.device) model.load_state_dict(checkpoint['state_dict']) #del checkpoint scores, predicted_scores, precisions, recalls, f_betas = list(), list(), list(), list(), list() targets, mean_predictions, oneStep_predictions, Nstep_predictions = list(), list(), list(), list() try: # For each channel in the dataset for channel_idx in range(nfeatures): ''' 1. Load mean and covariance if they are pre-calculated, if not calculate them. ''' # Mean and covariance are calculated on train dataset. if 'means' in checkpoint.keys() and 'covs' in checkpoint.keys(): print('=> loading pre-calculated mean and covariance') mean, cov = checkpoint['means'][channel_idx], checkpoint['covs'][channel_idx] else: print('=> calculating mean and covariance') mean, cov = fit_norm_distribution_param(args, model, train_dataset, channel_idx=channel_idx)
### read train & test input and output def read_input(): data_inputs = [] data_outputs = [] with open("../data/data.txt") as f: content = f.readlines() for i in content: i = i.strip("\n") i = i.split() i = [float(x) for x in i] temp = [] temp_box_x = int(i[4]) - int(i[2]) temp_box_y = int(i[5]) - int(i[3]) temp.append(i[0]) temp.append(min(temp_box_x, temp_box_y)) data_outputs.append(i[1:2]) data_inputs.append(temp) return data_inputs, data_outputs if __name__ == '__main__': m = m() m.load_state_dict(torch.load('model_1.pt')) train_inputs, train_outputs = read_input() for i in range(len(train_inputs)): print(m(train_inputs[i])) print(train_outputs[i]) print("****")
shuffle=False, num_workers=args.workers, pin_memory=False, drop_last=False) # 4.4 load model model_dir = './imageset/label/model_ir_se50.pth' pretrained_dict = torch.load(model_dir) model = model.Backbone(num_layers=50, drop_ratio=0.6, mode='ir') model_dict = model.state_dict() pretrained_dict = { k: v for k, v in pretrained_dict.items() if k in model_dict } model_dict.update(pretrained_dict) # update parameter model.load_state_dict(pretrained_dict) model = torch.nn.DataParallel(model).to(args.device) # 4.5 set loss_function loss_function_A = torch.nn.MarginRankingLoss().to(args.device) loss_function_B = torch.nn.MSELoss().to(args.device) # 4.6 choose optimizer optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[30, 60, 100], gamma=0.1, last_epoch=-1)
parser = argparse.ArgumentParser(description='Pass in an image, it will show you its class') parser.add_argument('-i','--path', type = str, dest = 'img_path', help = 'Image file path') parser.add_argument('-m','--model', type = str, help = 'Model file path (*.bin)', default = './chkpoint.bin') parser.add_argument('-v','--verbose',type = bool, help = 'Show model structure and full output', default = False) args = parser.parse_args() torch.cuda.set_device(0) #使用 GPU from preprocessing import transform image = Image.open(args.img_path) x = transform(image) x.unsqueeze_(0) x = x.cuda() from model import model model = model.cuda() model.load_state_dict(torch.load(args.model)) model.eval() output = model(x) if args.verbose == True: print(model) print(output) else: predictions = output.argmax(dim=1, keepdim=True).squeeze() print(predictions)
#!/usr/bin/env ipython import sys import numpy as np import torch import tqdm from model import NUM_FEAT, model, seq_len from util import remove_outliers device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("Device", device) model.load_state_dict(torch.load("model.pt")) model.to(device) model.eval() def predict_step(model, inputs): inputs = inputs.to(device) src_mask = model.generate_square_subsequent_mask(inputs.size(0)).to(device) return model.forward( inputs, src_mask=src_mask, ) def predict(model, seq_len, steps, context): seq = context n_context = context.shape[0]
for k, v in checkpoint.items(): if 'module' in k: name = k[7:] else: name = k new_state_dcit[name] = v model_dict = model.state_dict() pretrained_dict = { k: v for k, v in new_state_dcit.items() if k in model_dict } for k, v in model_dict.items(): if k not in pretrained_dict: print(k) model.load_state_dict(pretrained_dict, strict=True) else: print("===> no models found at '{}'".format(args.pretrained)) print("===> Setting Optimizer") optimizer = optim.Adam(model.parameters(), lr=args.lr) def train(epoch): model.train() utils.adjust_learning_rate(optimizer, epoch, args.step_size, args.lr, args.gamma) print('epoch =', epoch, 'lr = ', optimizer.param_groups[0]['lr']) for iteration, (lr_tensor, hr_tensor) in enumerate(training_data_loader,
def train_model(model, device, train_data_loader, valid_data_loader, criterion, optimizer, scheduler, num_epochs=5): """ training Parameters -------------- model : DogClassificationModel Network model to be trained. device : device cuda or cpu train_data_loader : dataloader dataloader for training valid_data_loader : dataloader dataloader for validation criterion : Loss function. optimizer : Optimizer. scheduler : Learning rate scheduler. num_epochs : int The number of epochs. Returns -------------- model : DogClassificationModel Trained model. """ since = time.time() model = model.to(device) best_model_wts = copy.deepcopy(model.state_dict()) best_acc = 0.0 for epoch in range(num_epochs): bar = tqdm(total=len(train_data_loader)) bar.set_description("Epoch: {}/{}".format(epoch + 1, num_epochs)) """ Training Phase """ model.train() running_loss = 0.0 running_corrects = 0 for j, (inputs, labels) in enumerate(train_data_loader): optimizer.zero_grad() tmp_loss_item = 0.0 # training with torch.set_grad_enabled(True): outputs = model(inputs.to(device)) torch.cuda.empty_cache() _, preds = torch.max(outputs, 1) loss = criterion(outputs, labels.to(device)) # backward + optimize only if in training phase loss.backward() optimizer.step() tmp_loss_item = loss.item() # statistics running_loss += tmp_loss_item * inputs.size(0) running_corrects += torch.sum(preds.to('cpu') == labels.data) # progress bar bar.update(1) tmp_loss = float(running_loss / (j + 1)) / 32 # 32: mini-batch size tmp_acc = float(running_corrects // (j + 1)) / 32 bar.set_postfix(OrderedDict(loss=tmp_loss, acc=tmp_acc)) # update learning rate scheduler scheduler.step() dataset_size = len(train_data_loader.dataset) epoch_loss = running_loss / dataset_size epoch_acc = running_corrects.double() / dataset_size """ Validation Phase """ model.eval() # Set model to validation mode val_running_loss = 0.0 val_running_corrects = 0 # Iterate over data. for inputs, labels in valid_data_loader: val_inputs = inputs.to(device) val_labels = labels.to(device) # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.no_grad(): val_outputs = model(val_inputs) _, preds = torch.max(val_outputs, 1) loss = criterion(val_outputs, val_labels) # statistics val_running_loss += loss.item() * val_inputs.size(0) val_running_corrects += torch.sum(preds == val_labels.data) dataset_size = len(valid_data_loader.dataset) val_epoch_loss = val_running_loss / dataset_size val_epoch_acc = val_running_corrects.double() / dataset_size print('VALIDATION Loss: {:.4f} Acc: {:.4f}'.format( val_epoch_loss, val_epoch_acc)) print("Elapsed time: {} [sec]".format(time.time() - since)) # deep copy the model if val_epoch_acc > best_acc: best_acc = val_epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) time_elapsed = time.time() - since print('Training complete in {:.0f}m {:.0f}s'.format( time_elapsed // 60, time_elapsed % 60)) print('Best val Acc: {:4f}'.format(best_acc)) # load best model weights model.load_state_dict(best_model_wts) return model
print(opt) cuda = opt.cuda device = torch.device('cuda' if cuda else 'cpu') filepath = opt.test_hr_folder filelist = utils.get_list(filepath, ext='.png') + utils.get_list(filepath, ext='.JPG') psnr_list = np.zeros(len(filelist)) ssim_list = np.zeros(len(filelist)) time_list = np.zeros(len(filelist)) model = model.model_rtc(upscale=opt.upscale_factor) model_dict = utils.load_state_dict(opt.checkpoint) model.load_state_dict(model_dict, strict=True) i = 0 start = torch.cuda.Event(enable_timing=True) end = torch.cuda.Event(enable_timing=True) for imname in filelist: # im_gt = cv2.imread(imname, cv2.IMREAD_COLOR)[:, :, [2, 1, 0]] # BGR to RGB im_gt = sio.imread(imname) # RGB im_gt = utils.modcrop(im_gt, opt.upscale_factor) # im_l = cv2.imread(opt.test_lr_folder + imname.split('/')[-1].split('.')[0] + 'x' + str(opt.upscale_factor) + ext, cv2.IMREAD_COLOR)[:, :, [2, 1, 0]] # BGR to RGB # im_l = cv2.imread(opt.test_lr_folder + imname.split('/')[-1].split('.')[0] + ext, cv2.IMREAD_COLOR)[:, :, [2, 1, 0]] # BGR to RGB im_l = sio.imread(opt.test_lr_folder + '/' + imname.split('/')[-1]) # RGB if len(im_gt.shape) < 3: im_gt = im_gt[..., np.newaxis] im_gt = np.concatenate([im_gt] * 3, 2)
from model import model import torch import torch.nn as nn from config import config from dataset.data_preprocess import ImageDataProcess device = config.device model_path = "saved/model/model.pth" #--------Load the Model and run as GPU Mode---------------------# model = model.LeNet(config.train_class_num).to(device) model.load_state_dict(torch.load(model_path)) model.eval() #-------------------Process Photo--------------------------------# image_tensor_list = [] image_dir = "data/test/santapepe.jpg" image_tensor = ImageDataProcess.image_normalize(image_dir) #image to Tensor image_tensor_list.append(torch.unsqueeze(image_tensor, 0)) input_tensor = torch.cat(tuple(image_tensor_list), dim=0) # +1 Dimension input_tensor = input_tensor.cuda() #------------------Softmax the result to probability--------------# outputs_tensor = model(input_tensor) m_softmax = nn.Softmax(dim=1) outputs_tensor = m_softmax(outputs_tensor) #------------------Print the Result--------------# print(outputs_tensor)
train_dataset = TimeseriesData.batchify( args, TimeseriesData.trainData[:TimeseriesData.length], bsz=1) test_dataset = TimeseriesData.batchify(args, TimeseriesData.testData, bsz=1) ############################################################################### # Build the model ############################################################################### nfeatures = TimeseriesData.trainData.size(-1) model = model.RNNPredictor(rnn_type=args.model, enc_inp_size=nfeatures, rnn_inp_size=args.emsize, rnn_hid_size=args.nhid, dec_out_size=nfeatures, nlayers=args.nlayers, res_connection=args.res_connection).to(args.device) model.load_state_dict(checkpoint['state_dict']) #del checkpoint scores, predicted_scores, precisions, recalls, f_betas = list(), list(), list( ), list(), list() targets, mean_predictions, oneStep_predictions, Nstep_predictions = list( ), list(), list(), list() try: # For each channel in the dataset for channel_idx in range(nfeatures): ''' 1. Load mean and covariance if they are pre-calculated, if not calculate them. ''' # Mean and covariance are calculated on train dataset. if 'means' in checkpoint.keys() and 'covs' in checkpoint.keys(): print('=> loading pre-calculated mean and covariance') mean, cov = checkpoint['means'][channel_idx], checkpoint['covs'][ channel_idx]
def __init__(self, x): self.data = torch.from_numpy(x) def __len__(self): return len(self.data) def __getitem__(self, idx): return self.data[idx] device = torch.device("cuda" if torch.cuda.is_available() else "cpu") testset = Test_Dataset(test_data) test_loader = DataLoader(dataset=testset, batch_size=1, shuffle=False) model = model() model.load_state_dict(torch.load("./model.pth")) model = model.to(device) def inference(test_loader, device, model, ans_list): model.eval() with torch.no_grad(): for data in test_loader: data = data.to(device) predict = model(data) ans = torch.argmax(predict, dim=1) ans_list.append(ans.item()) ans_list = [] inference(test_loader, device, model, ans_list)