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',
