linear_input_size = convw * convh * 32 self.fullconnected = nn.Linear(linear_input_size, 16) self.head = nn.Linear(16, 3) def forward(self, x): x = F.relu(self.bn1(self.conv1(self.pool(x)))) x = F.relu(self.bn2(self.conv2(x))) x = F.relu(self.bn3(self.conv3(x))) x = x.view(x.size(0), -1) x = F.relu(self.fullconnected(x)) return self.head(x) resize = T.Compose( [T.ToPILImage(), T.Resize(40, interpolation=Image.CUBIC), T.ToTensor()]) def get_screen(): screen = cd.pygame.surfarray.array3d(cd.screen) screen = screen.transpose((2, 0, 1)) screen = np.ascontiguousarray(screen, dtype=np.float32) / 255 screen = torch.from_numpy(screen) screen = resize(screen).unsqueeze(0).to(device) return screen init_screen = get_screen() _, _, screen_height, screen_width = init_screen.shape
import onnxruntime as ort import numpy as np from sklearn.metrics import classification_report from torch.utils.data import DataLoader from torchvision import datasets, transforms data_dir = "data" input_size = [224, 224] batch_size = 1 if __name__ == "__main__": ort_session = ort.InferenceSession('app/models/banknote_best.onnx') data_transforms = { 'validation': transforms.Compose([ transforms.Resize(input_size), transforms.CenterCrop(input_size), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['validation']} dataloaders_dict = {x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['validation']} outputs = [] labels = [] for inputs, label in dataloaders_dict["validation"]: output = ort_session.run(None, {'input.1': inputs.numpy()}) output = np.argmax(output[0], axis=1)[0] outputs.append(output) labels.append(label.data.tolist()) labels = sum(labels, [])
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9, weight_decay=5e-4) # training dataset # transform_train = transforms.Compose([ # transforms.Resize((600,200)), # 保持长宽比不变,最短边为400,(h,w) # transforms.RandomRotation(10), # transforms.RandomCrop((540,180), padding=0), # 先四周填充0,在吧图像随机裁剪成h*w # transforms.RandomHorizontalFlip(), #图像一半的概率翻转,一半的概率不翻转 # transforms.ToTensor(), # transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), #R,G,B每层的归一化用到的均值和方差 # ]) transform_train = transforms.Compose([ transforms.Resize((600, 200)), # 保持长宽比不变,最短边为400,(h,w) transforms.RandomRotation(10), transforms.RandomCrop((576, 192), padding=0), # 先四周填充0,在吧图像随机裁剪成h*w transforms.RandomHorizontalFlip(), #图像一半的概率翻转,一半的概率不翻转 transforms.ToTensor(), # transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), #R,G,B每层的归一化用到的均值和方差 ]) train_dataset = AsoctDataset(root=path, train=True, transform=transform_train) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) # transform_test = transforms.Compose([ # transforms.Resize((540,180)), # transforms.ToTensor(), # transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision.datasets import MNIST import torchvision.transforms as transforms from collections import OrderedDict import os import matplotlib.pyplot as plt device = "cuda" if torch.cuda.is_available() else "cpu" transform = transforms.Compose([ transforms.CenterCrop(32), transforms.Resize(32), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) BATCH_SIZE = 8 LEARNING_RATE = 0.001 NUM_EPOCH = 10 PRINT_EVERY = 1000 SAVE_EVERY = 1 save_path = "./model/" trainset = MNIST(root='../data/cifar', train=True, download=True, transform=transform) testset = MNIST(root='../data/cifar', train=False,
if opt.cuda: torch.cuda.manual_seed_all(opt.manualSeed) cudnn.benchmark = True if torch.cuda.is_available() and not opt.cuda: print("WARNING: You have a CUDA device, " "so you should probably run with --cuda") device = 'cuda' if opt.cuda else 'cpu' if opt.dataset in ['imagenet', 'folder', 'lfw']: # folder dataset dataset = dset.ImageFolder(root=opt.dataroot, transform=transforms.Compose([ transforms.Resize(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) elif opt.dataset == 'lsun': dataset = dset.LSUN(root=opt.dataroot, classes=['bedroom_train'], transform=transforms.Compose([ transforms.Resize(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]))
import urllib.request from collections import OrderedDict from enum import Enum from typing import Tuple import numpy as np import torch from PIL import Image from torch import nn from torchvision import models, transforms # Declare Image Transformation Constants for Inference NORMAL_MEANS = (0.485, 0.456, 0.406) NORMAL_STD_DEVIATIONS = (0.229, 0.224, 0.225) TRANSFORM_TEST_VALIDATION = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(NORMAL_MEANS, NORMAL_STD_DEVIATIONS)]) class NetworkArchitectures(Enum): """ Enum representing the network architectures available to the neural network class. """ VGG11 = 'vgg11' VGG13 = 'vgg13' VGG16 = 'vgg16' VGG19 = 'vgg19'
def __init__(self, data_partition, map_version, sampling_rate, sample_stride=1, use_scene=True, scene_size=(64, 64), ploss_type=None, intrinsic_rate=2, max_distance=56, num_workers=None, cache_file=None, multi_agent=True): """ data_dir: Dataset root directory data_parititon: Dataset Parition (train | val | test_obs) map_version: Map data version (1.3 | 2.0) sampling_rate: Physical sampling rate of processed trajectory (Hz) intrinsic_rate: Physical sampling rate of raw trajectory (Hz, eg., Argo:10, Nuscene:2) sample_stride: The interval between the reference frames in a single episode min_past_obv_len: Minimum length of the agent's past trajectory to encode min_future_obv_len: Minimum length of the agent's past trajectory to decode min_future_pred_len: Minimum length of the agent's future trajectory to decode max_distance: Maximum physical distance from the ROI center to an agent's current position multi_agent: Boolean flag for including multiple agent setting """ super(NuscenesDataset, self).__init__() self.data_dir = _data_dir self.data_partition = data_partition if num_workers: self.num_workers = num_workers else: self.num_workers = mp.cpu_count() # Sampling Interval = "intrinsic sampling rate" / sampling rate self.intrinsic_rate = intrinsic_rate if intrinsic_rate % sampling_rate: raise ValueError( "Intrinsic sampling rate must be evenly divisble by sampling rate.\n Intrinsic SR: {:d}, Given SR: {:d}" .format(10, sampling_rate)) self.sampling_interval = int(self.intrinsic_rate // sampling_rate) self.max_obsv_len = int(self.intrinsic_rate * 2 // self.sampling_interval) self.max_pred_len = int(self.intrinsic_rate * 3 // self.sampling_interval) self.sample_stride = sample_stride self.min_past_obv_len = self.sampling_interval + 1 self.min_future_obv_len = int(1 * self.intrinsic_rate) self.min_future_pred_len = int(1.5 * self.intrinsic_rate) self.max_distance = max_distance self.use_scene = use_scene self.scene_size = scene_size self.multi_agent = multi_agent if map_version == '1.3' or map_version == '2.0' or map_version == '2.1': self.map_version = map_version else: raise ("Invalid map: v1.3 | v2.0 | v2.1 are valid") if map_version == '1.3': self.img_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), transforms.Resize(self.scene_size) ]) elif map_version == '2.0': self.img_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([23.0582], [27.3226]) ]) elif map_version == '2.1': # self.img_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([23.0582, -0.922, -0.926], [27.3226, 0.384, 0.370]) ]) self.ploss_type = ploss_type if ploss_type == 'map': self.p_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([23.0582], [27.3226]), transforms.Lambda(lambda x: F.log_softmax(x.reshape(-1), dim=0) .reshape(x.shape[1:])) ]) # Extract Data: if cache_file is None: cache_dir = "./nuscenes_{}_cache.pkl".format(self.data_partition) if os.path.isfile(cache_dir): self.load_cache(cache_dir) else: self.get_data(save_cache_dir=cache_dir) else: if os.path.isfile(cache_file): self.load_cache(cache_file) else: self.get_data(save_cache_dir=cache_file)
else: model = getattr(models, args.base_model)(pretrained=True) # remove the last layer feature_map = list(model.children()) feature_map.pop() extractor = nn.Sequential(*feature_map) # multi-gpu extractor = torch.nn.DataParallel(extractor.cuda()) extractor.eval() cudnn.benchmark = True #--- data pre-processing if args.base_model == 'c3d': data_transform = transforms.Compose([ transforms.Resize(112), transforms.CenterCrop(112), transforms.ToTensor(), ]) elif args.base_model == 'i3d': # data_transform = transforms.Compose([ # VT.Resize(256), # VT.RandomCrop(224), # VT.RandomHorizontalFlip() # ]) data_transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor() ]) else:
import os import numpy as np import torch import torch.nn.functional as F from PIL import Image import torchvision.transforms as tvt from CUB.utils.gradcam import GradCAM from CUB.utils.util import visualize_cam, Normalize from torchvision.utils import make_grid, save_image from CUB.net.Orderextractor import OEmbeddingNetwork ToPil = lambda x:Image.open(x).convert('RGB') transforms = tvt.Compose([ tvt.Resize((224,224)), tvt.ToTensor(), tvt.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) resnet = OEmbeddingNetwork().cuda() resnet.load_state_dict(torch.load( './models/closs_high.pkl')) resnet.eval() cam_dict = dict() resnet_model_dict = dict(type='resnet', arch=resnet, layer_name='layer4', input_size=(224, 224)) gradcam = GradCAM(resnet_model_dict, True) imgpaths = [] #All_images_path root = '/home/ws/datasets/CUB_200_2011/images/' newroot = '/home/ws/datasets/CUB_temp' os.makedirs(newroot, exist_ok=True) for root,file,items in os.walk(root): if items != []:
return x, y, z #%% if __name__ == "__main__": num_epochs = 10 in_channel = 2 batch_size = 16 lr = 0.001 directory = '../shopee/train.csv' or_to_new_hash, new_to_or_hash = preprocess_data(directory) my_transforms = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((128, 128)), transforms.ToTensor(), # range [0, 255] -> [0.0, 0.1] transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # load images data images_dataset = shopeeImageDataset(csv_file='new_train.csv', root_dir='train_images', tokenizer=tokenizer, transform=my_transforms) train_set, test_set = torch.utils.data.random_split( images_dataset, [30000, 4250]) train_loader = DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True)
if __name__ == '__main__': save_path = './temp_eval_classifier_celeba' #save_path = os.path.join('/mnt/fs2/2019/Takamuro/m2_research/weather_transferV2/results/eval_classifier', 'CelebA', # args.cp_path.split('/')[-2], # args.cp_path.split('/')[-1].split('_')[-2]) print(save_path) os.makedirs(save_path, exist_ok=True) df = pd.read_pickle(args.pkl_path) df = df[df['mode'] == 'test'] print('{} train data were loaded'.format(len(df))) # torch >= 1.7 transform = nn.Sequential( transforms.CenterCrop((178, 178)), transforms.Resize((args.input_size, ) * 2), # torch >= 1.7 transforms.ConvertImageDtype(torch.float32), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])) dataset = CelebALoader(root_path=args.image_root, df=df, transform=transform) loader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, drop_last=True, num_workers=8) num_classes = dataset.num_classes cols = dataset.cols
def __init__(self, root, split='train', transform=None): std = 1. / 255. means = [109.97 / 255., 127.34 / 255., 123.88 / 255.] split_list = open(os.path.join(root, 'train_test_split.txt')).readlines() self.idx2name = [] classes = open(os.path.join(root, 'classes.txt')).readlines() self._imgpath = [] self._imglabel = [] self.transform = None for c in classes: idx, name = c.strip().split() self.idx2name.append(name) if transform is None and split.lower() == 'train': self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(448), transforms.RandomCrop([448, 448]), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=means, std=[std] * 3) ]) elif transform is None and split.lower() == 'test': self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(448), transforms.CenterCrop(448), transforms.ToTensor(), transforms.Normalize(mean=means, std=[std] * 3) ]) else: print( " [*] Warning: transform is not None, Recomend to use defualt") pass train_list = [] test_list = [] for line in split_list: idx, is_train = line.strip().split() if int(is_train) == 1: train_list.append(int(idx) - 1) else: test_list.append(int(idx) - 1) image_list = open(os.path.join(root, 'images.txt')).readlines() image_list = np.array(image_list) label_list = open(os.path.join(root, 'image_class_labels.txt')).readlines() label_list = np.array(label_list) if split.lower() == 'train': train_images = image_list[train_list] train_labels = label_list[train_list] for i, fname in enumerate(train_images): idx, path = fname.strip().split() self._imgpath.append(os.path.join(root, 'images', path)) idx, label = train_labels[i].strip().split() self._imglabel.append(int(label) - 1) else: test_images = image_list[test_list] test_labels = label_list[test_list] for i, fname in enumerate(test_images): idx, path = fname.strip().split() self._imgpath.append(os.path.join(root, 'images', path)) idx, label = test_labels[i].strip().split() self._imglabel.append(int(label) - 1)
def load_image(fname, image_size=128): transform = transforms.Compose([transforms.Resize((image_size, image_size)), transforms.ToTensor()]) image = Image.open(fname).convert('RGB') image = transform(image) return image
classifier_state_dict = { str.replace(k, 'module.', ''): v for k, v in checkpoint['classifier_state_dict'].items() } model.load_state_dict(model_state_dict) object_idt.load_state_dict(obj_state_dict) classifier.load_state_dict(classifier_state_dict) model.eval() object_idt.eval() classifier.eval() model.cuda() object_idt.cuda() classifier.cuda() # load the image transformer centre_crop = trn.Compose([ trn.Resize((256, 256)), trn.CenterCrop(224), trn.ToTensor(), trn.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) if (args.dataset == 'places'): data_dir = '/data/cenj/places365_train' valdir = os.path.join(data_dir, 'val') elif (args.dataset == 'sun'): data_dir = sun_dir valdir = os.path.join(data_dir, 'test') elif (args.dataset == 'vpc'): data_dir = vpc_dir home_dir = os.path.join(data_dir, 'data_' + args.hometype) valdir = os.path.join(home_dir, args.floortype)
out_x.append(xx) out_y.append(yy) return out_x, out_y batch_size = 1 workers = 0 if os.name == 'nt' else 8 dataset_dir = r'facebank' cropped_dataset = r'dataset' device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') mtcnn = MTCNN(image_size=(300, 300), margin=20, min_face_size=20, thresholds=[0.6, 0.7, 0.7], factor=0.709, post_process=True, device=device) dataset = datasets.ImageFolder(dataset_dir, transform=transforms.Resize((512, 512))) dataset.samples = [(p, p.replace(dataset_dir, cropped_dataset)) for p, _ in dataset.samples] loader = DataLoader(dataset, num_workers=workers, batch_size=batch_size, collate_fn=collate_pil) for i, (x, y) in enumerate(loader): x = mtcnn(x, save_path=y, save_landmarks=True)
def main(): global args, best_acc1 args = parser.parse_args() if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) # 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.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda(args.gpu) optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] 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') valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = 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) val_loader = 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) if args.evaluate: validate(val_loader, model, criterion) return for epoch in range(args.start_epoch, args.epochs): epoch_start = time.time() if args.distributed: train_sampler.set_epoch(epoch) adjust_learning_rate(optimizer, epoch) # train for one epoch train(train_loader, model, criterion, optimizer, epoch) print('Epoch {} took time: {}'.format(epoch, time.time() - epoch_start)) # evaluate on validation set acc1 = validate(val_loader, model, criterion) # remember best acc@1 and save checkpoint is_best = acc1 > best_acc1 best_acc1 = max(acc1, best_acc1) save_checkpoint({ 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer' : optimizer.state_dict(), }, is_best)
device = 'cuda' if torch.cuda.is_available() else 'cpu' args = load_args() _, _, txt_encoder, _, _ = train_retrieval.load_model( args.retrieval_model, device) txt_encoder = txt_encoder.eval().to(device) ckpt_args, _, netG, _, _, _ = train_cookgan.load_model( args.ckpt_path, device) netG = netG.eval().to(device) inception = load_patched_inception_v3() inception = nn.DataParallel(inception).eval().to(device) imsize = ckpt_args.base_size * (2**(ckpt_args.levels - 1)) train_transform = transforms.Compose([ transforms.Resize(int(imsize * 76 / 64)), transforms.CenterCrop(imsize) ]) dataset = FoodDataset(recipe_file=ckpt_args.recipe_file, img_dir=ckpt_args.img_dir, levels=ckpt_args.levels, part='val', food_type=ckpt_args.food_type, base_size=ckpt_args.base_size, transform=train_transform) dataset_name = 'Recipe1M' if ckpt_args.food_type: dataset_name += f'_{ckpt_args.food_type}' loader = DataLoader(dataset, batch_size=args.batch_size, num_workers=4)
# Load up pretrained Resnet-18 model = models.resnet18(pretrained=True) # Chop last fc layer model = nn.Sequential(*list(model.children())[:-1]) # Data loader img_dir = os.path.join(args.data) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) img_loader = torch.utils.data.DataLoader(CustomImageFolder( img_dir, transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=False) model.eval() imgs = [int(x[0][-9:-4]) - 1 for x in img_loader.dataset.imgs] features = np.zeros([np.max(imgs) + 1, 512], np.float32) print(features.shape)
if __name__ == "__main__": args = arguments() logger = SummaryWriter(os.path.join("./logs/", args.name)) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) prepro = transforms.Compose([ transforms.RandomResizedCrop(256), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) prepro_val = transforms.Compose( [transforms.Resize((350, 350)), transforms.ToTensor(), normalize]) end = time.time() print("Initializing network ...", end=" ") if args.resume: # Resume previous learning checkpoint = torch.load(args.resume, map_location=lambda storage, loc: storage) join_emb = joint_embedding(checkpoint["args_dict"]) join_emb.load_state_dict(checkpoint["state_dict"]) join_emb = torch.nn.DataParallel(join_emb.cuda()) last_epoch = checkpoint["epoch"] opti = checkpoint["optimizer"] print("Load from epoch :", last_epoch)
from torchvision import transforms from torchvision import models import os import sys sys.path.append("..") import d2lzh_pytorch as d2l device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(device) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) #默认的值 test_augs = transforms.Compose([ transforms.Resize(size=256), transforms.CenterCrop(size=224), transforms.ToTensor(), normalize ]) test_iter = DataLoader(ImageFolder("testimg", transform=test_augs), 1) PATH = '1591349252.4838984.pth' # PATH = '1591345605.9707272.pth' model = models.resnet18(pretrained=False, num_classes=2) model.load_state_dict(torch.load(PATH)) net = model with torch.no_grad(): device = None for X, y in test_iter:
def main(args): # Setup Logger log_file_path = os.path.join(os.getcwd(), 'logs') if not os.path.exists(log_file_path): os.makedirs(log_file_path) start_time = time.ctime() logging.basicConfig(filename=os.path.join( log_file_path, "training_log_" + str(start_time).replace(':', '').replace(' ', ' ').replace(' ', '_') + ".log"), format='%(asctime)s - %(message)s', level=logging.INFO) # Create model directory if not os.path.exists(args.model_path): os.makedirs(args.model_path) data_augmentations = get_augmentations(args.crop_size) # Image preprocessing, normalization for the pretrained resnet transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((args.crop_size, args.crop_size)), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) train_coco = COCO(args.train_caption_path) val_coco = COCO(args.val_caption_path) # Load vocabulary wrapper with open(args.vocab_path, 'rb') as f: vocab = pickle.load(f) # Build data loader train_dataloader = get_loader(args.train_dir, train_coco, vocab, transform, data_augmentations, args.batch_size, shuffle=True, num_workers=args.num_workers) validation_dataloader = get_loader(args.val_dir, val_coco, vocab, transform, None, args.batch_size, shuffle=False, num_workers=args.num_workers) # Load word embeddings fasttext_wv = load_fasttext(args.train_caption_path) print("Loaded FastText word embeddings") embed_dim = fasttext_wv.vectors_vocab.shape[1] embedding_weights = np.zeros((len(vocab), embed_dim)) for idx, word in enumerate(vocab.word2idx): embedding_weights[idx] = fasttext_wv[word] # Build the models encoder = EncoderCNN().to(device) decoder = DecoderRNN(args.lstm1_size, args.lstm2_size, args.att_size, vocab, args.embed_size, embedding_weights, feature_size=args.feature_size).to(device) # Metrics train_metrics = [Accuracy(), RougeBleuScore(train_coco, vocab)] val_metrics = [Accuracy(), RougeBleuScore(val_coco, vocab)] # Loss and optimizer loss = nn.CrossEntropyLoss(ignore_index=0) for p in encoder.parameters(): p.requires_grad = False optimizer = torch.optim.Adam([{ 'params': encoder.parameters(), 'lr': 0.5 * args.learning_rate }, { 'params': decoder.parameters() }], lr=args.learning_rate) # optimizer = torch.optim.Adam(encoder.parameters(), lr=args.learning_rate) scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, 10, T_mult=1, eta_min=0) encoder_unfreeze_epoch = 2 train_model( train_dataloader=train_dataloader, validation_dataloader=validation_dataloader, model=[encoder, decoder], loss=loss, train_metrics=train_metrics, val_metrics=val_metrics, optimizer=optimizer, scheduler=scheduler, batch_size=args.batch_size, num_epochs=args.num_epochs, encoder_unfreeze_epoch=encoder_unfreeze_epoch, device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"), logger=logging, verbose=True, model_save_path=os.path.join(os.getcwd(), 'model'), plots_save_path=os.path.join(os.getcwd(), 'plots'))
'train': transforms.Compose([ transforms.RandomResizedCrop(299), transforms.RandomHorizontalFlip(), transforms.RandomRotation(60), transforms.RandomRotation(45), transforms.ColorJitter(brightness=0.4, saturation=0.4, contrast=0.4, hue=0.3), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'valid': transforms.Compose([ transforms.Resize(299), transforms.RandomHorizontalFlip(), transforms.RandomRotation(60), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } print("Initializing Datasets and Dataloaders...") image_datasets = { x: ImageFolder(os.path.join(path, x), data_transforms[x]) for x in ['train', 'valid'] } dataloaders = { x: torch.utils.data.DataLoader(image_datasets[x], batch_size=8,
def main(): global args, best_prec1 args = parser.parse_args() if args.smoke_test: args.batch_size = 4 print('Smoke testing, setting batch size to {}'.format(args.batch_size)) args.lr = 0.1 * (args.batch_size / 256) args.workers = int(4 * (args.batch_size / 256)) if args.data == '': bird_or_bicycle.get_dataset('train') bird_or_bicycle.get_dataset('test') bird_or_bicycle.get_dataset('extras') args.data = bird_or_bicycle.dataset.default_data_root() if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') # create model model = getattr(models, args.arch)(num_classes=2, pretrained=args.pretrained) # prepend a BN layer w/o learnable params to perform data normalization # as we disabled data normalization in data iter in order to make the # interface compatible with attack APIs that requires data in [0.0, 1.0] # range. model = nn.Sequential(nn.BatchNorm2d(num_features=3, affine=False), model) if args.gpu is not None: model = model.cuda(args.gpu) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda(args.gpu) optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) lr_scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, milestones=[30, 60, 80], gamma=0.2) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(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 traindirs = [os.path.join(args.data, partition) for partition in ['extras']] # Use train as validation because it is IID with the test set valdir = os.path.join(args.data, 'train') # this normalization is NOT used, as the attack API requires # the images to be in [0, 1] range. So we prepend a BatchNorm # layer to the model instead of normalizing the images in the # data iter. _unused_normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = [datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), # _unused_normalize, ])) for traindir in traindirs] if len(train_dataset) == 1: train_dataset = train_dataset[0] else: train_dataset = torch.utils.data.ConcatDataset(train_dataset) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), # _unused_normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: if not args.resume: print('WARNING: evaluating without loading a checkpoint, use --resume ' 'to load a previously trained checkpoint if needed.') evaluate(model) return for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch train_epoch(train_loader, model, criterion, optimizer, epoch) lr_scheduler.step() # evaluate on validation set prec1 = validate_epoch(val_loader, model, criterion) if args.smoke_test: break # smoke test train with only 1 epoch # 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)
x_1 = self.m1(secret) mid = torch.cat((x_1, cover), 1) x_2, x_2_noise = self.m2(mid) x_3 = self.m3(x_2_noise) return x_2, x_3 # Creates net object net = Net() # Creates training set train_loader = torch.utils.data.DataLoader( datasets.ImageFolder( TRAIN_PATH, transforms.Compose([ transforms.Resize(256), #transforms.Scale(256), transforms.RandomCrop(224), transforms.ToTensor(), transforms.Normalize(mean=mean, std=std) ])), batch_size=batch_size, num_workers=1, pin_memory=True, shuffle=True, drop_last=True) # Creates test set test_loader = torch.utils.data.DataLoader( datasets.ImageFolder( TEST_PATH, transforms.Compose([ transforms.Resize(256), #transforms.Scale(256),
from torch.autograd import Variable from torchvision.datasets.mnist import MNIST from torch.utils.data import DataLoader from PIL import Image from time import time from models.lenet import LeNet from models.noisy_lenet import NoisyLeNet data_test = MNIST('./data/mnist', train=False, download=True, transform=transforms.Compose([ transforms.Resize((32, 32)), transforms.ToTensor()])) data_test_loader = DataLoader(data_test, batch_size=1024, num_workers=8) preprocess = transforms.Compose([ transforms.Resize((32, 32)), transforms.ToTensor() ]) criterion = nn.CrossEntropyLoss() def test_on_data(): net = torch.load('trained-lenet.pt') print(net) total_correct = 0
def __len__(self): # return size of dataset return len(self.filelist) def __getitem__(self, idx): image = Image.open(self.filelist[idx]).convert("RGB") image = self.transform(image) label = self.filelist[idx].split('/')[-2] label = self.classes.index(label) return image, label transform = transforms.Compose( [transforms.Resize((img_size, img_size)), transforms.ToTensor()]) train_dataset = FlowerDataset( os.path.join("../../../data/flower_photos/train"), transform) val_dataset = FlowerDataset( os.path.join("../../../data/flower_photos/validation"), transform) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
def train(args): device = torch.device("cuda" if args.cuda else "cpu") np.random.seed(args.seed) torch.manual_seed(args.seed) transform = transforms.Compose([ transforms.Resize(args.image_size), transforms.CenterCrop(args.image_size), transforms.ToTensor(), transforms.Lambda(lambda x: x.mul(255)) ]) train_dataset = datasets.ImageFolder(args.dataset, transform) train_loader = DataLoader(train_dataset, batch_size=args.batch_size) transformer = TransformerNet().to(device) optimizer = Adam(transformer.parameters(), args.lr) mse_loss = torch.nn.MSELoss() vgg = Vgg16(requires_grad=False).to(device) style_transform = transforms.Compose( [transforms.ToTensor(), transforms.Lambda(lambda x: x.mul(255))]) style = utils.load_image(args.style_image, size=args.style_size) style = style_transform(style) style = style.repeat(args.batch_size, 1, 1, 1).to(device) features_style = vgg(utils.normalize_batch(style)) gram_style = [utils.gram_matrix(y) for y in features_style] for e in range(args.epochs): transformer.train() agg_content_loss = 0. agg_style_loss = 0. count = 0 for batch_id, (x, _) in enumerate(train_loader): n_batch = len(x) count += n_batch optimizer.zero_grad() x = x.to(device) y = transformer(x) y = utils.normalize_batch(y) x = utils.normalize_batch(x) features_y = vgg(y) features_x = vgg(x) content_loss = args.content_weight * mse_loss( features_y.relu2_2, features_x.relu2_2) style_loss = 0. for ft_y, gm_s in zip(features_y, gram_style): gm_y = utils.gram_matrix(ft_y) style_loss += mse_loss(gm_y, gm_s[:n_batch, :, :]) style_loss *= args.style_weight total_loss = content_loss + style_loss total_loss.backward() optimizer.step() agg_content_loss += content_loss.item() agg_style_loss += style_loss.item() if (batch_id + 1) % args.log_interval == 0: mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format( time.ctime(), e + 1, count, len(train_dataset), agg_content_loss / (batch_id + 1), agg_style_loss / (batch_id + 1), (agg_content_loss + agg_style_loss) / (batch_id + 1)) print(mesg) if args.checkpoint_model_dir is not None and ( batch_id + 1) % args.checkpoint_interval == 0: transformer.eval().cpu() ckpt_model_filename = "ckpt_epoch_" + str( e) + "_batch_id_" + str(batch_id + 1) + ".pth" ckpt_model_path = os.path.join(args.checkpoint_model_dir, ckpt_model_filename) torch.save(transformer.state_dict(), ckpt_model_path) transformer.to(device).train() # save model transformer.eval().cpu() save_model_filename = "epoch_" + str(args.epochs) + "_" + str( time.ctime()).replace(' ', '_') + "_" + str( args.content_weight) + "_" + str(args.style_weight) + ".model" save_model_path = os.path.join(args.save_model_dir, save_model_filename) torch.save(transformer.state_dict(), save_model_path) print("\nDone, trained model saved at", save_model_path)
def main(): """ Main function. """ # Training settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--img_size', type=int, default=28, help="size of image (default: 28)") parser.add_argument('--batch-size', type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=14, metavar='N', help='number of epochs to train (default: 14)') parser.add_argument('--lr', type=float, default=1.0, metavar='LR', help='learning rate (default: 1.0)') parser.add_argument('--gamma', type=float, default=0.7, metavar='M', help='Learning rate step gamma (default: 0.7)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--dry-run', action='store_true', default=False, help='quickly check a single pass') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument( '--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') parser.add_argument('--save_dir', default="experiments") parser.add_argument('--log_file', default="log.o") parser.add_argument('--ckpt_path') # for compatibility args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'batch_size': args.batch_size} if use_cuda: kwargs.update({ 'num_workers': 1, 'pin_memory': True, 'shuffle': True }, ) transform = transforms.Compose([ transforms.Resize(args.img_size), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]) dataset1 = datasets.MNIST('./data', train=True, download=True, transform=transform) dataset2 = datasets.MNIST('./data', train=False, transform=transform) train_loader = torch.utils.data.DataLoader(dataset1, **kwargs) test_loader = torch.utils.data.DataLoader(dataset2, **kwargs) model = Net(args.img_size).to(device) optimizer = optim.Adadelta(model.parameters(), lr=args.lr) scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma) for epoch in range(1, args.epochs + 1): train(args, model, device, train_loader, optimizer, epoch) test(args, model, device, test_loader) scheduler.step() if args.save_model: torch.save( model.state_dict(), os.path.join(args.save_dir, "mnist_cnn_%d.pt" % args.img_size))
epochs = 20 batch_size = 64 learning_rate = 0.001 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") dataset_root_dir = os.path.join("datasets", "imagenette2") dataset_train_dir = os.path.join(dataset_root_dir, "train") dataset_valid_dir = os.path.join(dataset_root_dir, "val") normalization = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalization ]) valid_transform = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), normalization ]) train_dataset = ds.ImageFolder(root=dataset_train_dir, transform=train_transform) valid_dataset = ds.ImageFolder(root=dataset_valid_dir, transform=valid_transform) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=False) net = AlexNet(num_classes=10).to(device) optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) ceriation = nn.CrossEntropyLoss() meter = meters.AccuracyMeter((1, 5)) for epoch in range(epochs): logging.info(f"training on epoch {epoch}..") net.train()
if torch.cuda.is_available(): model = model.cuda() model2 = model2.cuda() if torch.cuda.device_count() > 1: model = nn.DataParallel(model) model2 = nn.DataParallel(model2) model.to(device) model2.to(device) model.load_state_dict(k) model2.encoder.load_state_dict(hufu) model2.decoder.load_state_dict(ufuh) transform = transforms.Compose([transforms.Resize(32), transforms.ToTensor()]) batch_size = 64 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform2 = transforms.Compose([transforms.ToTensor()]) batch_size2 = 500 train_dataset2 = torchvision.datasets.MNIST(root='./data',