D.weight_init(0.0, 0.02)
optimizer_G = torch.optim.Adam(G.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(D.parameters(), lr=lr, betas=(0.5, 0.999))
criterion = nn.BCELoss()
# the labels used in G (1 * 10 * 1 * 1)
labels_G = torch.zeros(10, 10)
labels_G = labels_G.scatter_(1, torch.LongTensor(list(range(10))).reshape(10, 1), 1).reshape(10, 10, 1, 1)
# the labels used in D (1 * 10 * 32 * 32)
labels_D = torch.zeros([10, 10, 32, 32])
for i in range(10):
labels_D[i, i, :, :] = 1
transform = tfs.Compose([
tfs.Resize(32),
tfs.ToTensor(),
tfs.Normalize(mean=[0.5], std=[0.5])
])
# 100 fixed samples
fixed_noise = torch.randn(100, 100).reshape(-1, 100, 1, 1)
fixed_y = []
for i in range(10):
fixed_y += [i] * 10
fixed_y = torch.LongTensor(fixed_y).reshape(-1, 1)
fixed_label_G = labels_G[fixed_y].reshape(-1, 10, 1, 1)
fixed_noise_var = Variable(fixed_noise.cuda())
fixed_y_label_var = Variable(fixed_label_G.cuda())
beta = 4
save_iter = 20
shape = (28, 28)
n_obs = shape[0] * shape[1]
# create DAE and ß-VAE and their training history
dae = DAE(n_obs, num_epochs, batch_size, 1e-3, save_iter, shape)
beta_vae = BetaVAE(n_obs, num_epochs, batch_size, 1e-4, beta, save_iter, shape)
history = History()
# fill autoencoder training history with examples
print('Filling history...', end='', flush=True)
transformation = transforms.Compose([
transforms.ColorJitter(),
transforms.ToTensor()
])
dataset = MNIST('data', transform=transformation)
dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
for data in dataloader:
img, _ = data
img = img.view(img.size(0), -1).numpy().tolist()
history.store(img)
print('DONE')
# train DAE
dae.train(history)
# train ß-VAE
import torchvision.datasets
import torchvision.transforms as transforms
from src.data.utils import *
root_dir = './data/'
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = torchvision.datasets.MNIST(
root_dir,
train=True,
transform=transform,
download=True,
)
test_dataset = torchvision.datasets.MNIST(
root_dir,
train=False,
transform=transform,
download=True,
)
def niid(params):
num_user = params['Trainer']['n_clients']
s = params['Dataset']['s']
dataset_split = split_dataset_by_percent(train_dataset, test_dataset, s, num_user)
testset_dict = {
'train': None,
'test': test_dataset,
out = out.view(out.size(0), -1)
out = self.linear(out)
return out
def ResNet18():
return ResNet(BasicBlock, [2, 2, 2, 2])
# setup dataset
data_dir = os.getenv('DATA_DIR')
train_transform = transforms.Compose([
# transforms.RandomRotation(degrees=[0, 360]),
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
cifar_train = ImageDataCLS(root=data_dir,
train=True,
transform=train_transform)
# use for infer uncertainty, dont apply transform
cifar_infer = ImageDataCLS(root=data_dir, train=True, transform=test_transform)
img = self.transform(img)
mask = Image.open(self.df.iloc[index, 1]).convert('L')
mask = self.transform(mask)
return {
'image': img,
'mask': mask
}
def __len__(self):
return len(self.df)
train_transform = transforms.Compose([
transforms.Resize([321, 321]),
transforms.ToTensor(),
])
if __name__ == '__main__':
dir_img = "/home/muyun99/Desktop/supervisely/train/"
dir_mask = "/home/muyun99/Desktop/supervisely/train_mask/"
scale = 1.0
val_percent = 0.1
batch_size = 8
train_dataset = BasicDataset(file_csv="/home/muyun99/Desktop/supervisely/csv_25/train.csv",
transform=train_transform)
val_dataset = BasicDataset(file_csv="/home/muyun99/Desktop/supervisely/csv_25/valid.csv",
transform=train_transform)
test_dataset = BasicDataset(file_csv="/home/muyun99/Desktop/supervisely/csv_25/test.csv",
transform=train_transform)
return center_offset,point_form
if __name__ == '__main__':
# Placing above line is required to solve the issue:
# https://github.com/pytorch/pytorch/issues/5858
resnet_features = ResNet18Reduced()
resnet_features.load_state_dict(torch.load('weights/resnet18reduced.pth'))
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder('images', transforms.Compose([
transforms.RandomSizedCrop(400),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=1, shuffle=True,
num_workers=1, pin_memory=True)
for a,b in train_loader:
break
#res_res = resnet_features(a)
net = JanuaryNet(resnet_features, 3)
net.init(weight_init)
loc,conf = net(a)
import util.loader.transform as tr from util.loader.loader import DAVIS2016 from util.metrics import runningScore from util.loss import * from util.utils import * from util.helpers import * from PIL import Image img_rows = 256 img_cols = 512 batch_size = 4 lr = 1e-4 ttransforms = transforms.Compose([tr.ScaleNRotate(), tr.RandomHorizontalFlip(), tr.Resize([img_rows, img_cols]), tr.ToTensor()]) tdataset = DAVIS2016(root='../dataset/davis.pkl', split='train', transform=ttransforms) tdataloader = torch.utils.data.DataLoader(tdataset, batch_size=batch_size, shuffle=True, num_workers=8) vtransforms = transforms.Compose([tr.Resize([img_rows, img_cols]), tr.ToTensor()]) vdataset = DAVIS2016(root='../dataset/davis.pkl', split='val', transform=vtransforms) vdataloader = torch.utils.data.DataLoader(vdataset, batch_size=1, shuffle=False, num_workers=8) # Setup Metrics running_metrics = runningScore(pspnet_specs['n_classes']) # setup Model base_net = BaseNet() class_net = ClassNet() base_net.cuda()
import matplotlib.patches as patches
#사이즈 지정
IMG_SIZE = 480
THRESHOLD = 0.95
#모델 가져오기 ( 다운로드 받아둠)
model = models.detection.keypointrcnn_resnet50_fpn(pretrained=True).eval()
IMG_SIZE = 480
THRESHOLD = 0.95
#img load
img = Image.open('img_data.jpg')
img = img.resize((IMG_SIZE, int(img.height * IMG_SIZE / img.width)))
plt.figure(figsize=(16, 16))
trf = T.Compose([T.ToTensor()])
input_img = trf(img)
out = model([input_img])[0]
#박스, 라벨, 점수, 키포인트 키포인트 스코어 점수 가 out에 딕셔너리로 저장.
codes = [Path.MOVETO, Path.LINETO, Path.LINETO]
fig, ax = plt.subplots(1, figsize=(16, 16))
ax.imshow(img)
for box, score, keypoints in zip(out['boxes'], out['scores'],
out['keypoints']):
score = score.detach().numpy()
if score < THRESHOLD:
def main():
global best_acc
if not os.path.isdir(args.out):
mkdir_p(args.out)
# Data
print(f'==> Preparing cifar10')
transform_train = transforms.Compose([
dataset.RandomPadandCrop(32),
dataset.RandomFlip(),
dataset.ToTensor(),
])
transform_val = transforms.Compose([
dataset.ToTensor(),
])
train_labeled_set, train_unlabeled_set, val_set, test_set = dataset.get_cifar10(
'./data',
args.n_labeled,
transform_train=transform_train,
transform_val=transform_val)
labeled_trainloader = data.DataLoader(train_labeled_set,
batch_size=args.batch_size,
shuffle=True,
num_workers=0,
drop_last=True)
unlabeled_trainloader = data.DataLoader(train_unlabeled_set,
batch_size=args.batch_size,
shuffle=True,
num_workers=0,
drop_last=True)
val_loader = data.DataLoader(val_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=0)
test_loader = data.DataLoader(test_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=0)
# Model
print("==> creating WRN-28-2")
def create_model(ema=False):
model = models.WideResNet(num_classes=10)
model = model.cuda()
if ema:
for param in model.parameters():
param.detach_()
return model
model = create_model()
ema_model = create_model(ema=True)
cudnn.benchmark = True
print(' Total params: %.2fM' %
(sum(p.numel() for p in model.parameters()) / 1000000.0))
train_criterion = SemiLoss()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=args.lr)
ema_optimizer = WeightEMA(model, ema_model, alpha=args.ema_decay)
start_epoch = 0
# Resume
title = 'noisy-cifar-10'
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(
args.resume), 'Error: no checkpoint directory found!'
args.out = os.path.dirname(args.resume)
checkpoint = torch.load(args.resume)
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
ema_model.load_state_dict(checkpoint['ema_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.out, 'log.txt'),
title=title,
resume=True)
else:
logger = Logger(os.path.join(args.out, 'log.txt'), title=title)
logger.set_names([
'Train Loss', 'Train Loss X', 'Train Loss U', 'Valid Loss',
'Valid Acc.', 'Test Loss', 'Test Acc.'
])
writer = SummaryWriter(args.out)
step = 0
test_accs = []
# Train and val
for epoch in range(start_epoch, args.epochs):
print('\nEpoch: [%d | %d] LR: %f' %
(epoch + 1, args.epochs, state['lr']))
train_loss, train_loss_x, train_loss_u = train(
labeled_trainloader, unlabeled_trainloader, model, optimizer,
ema_optimizer, train_criterion, epoch, use_cuda)
_, train_acc = validate(labeled_trainloader,
ema_model,
criterion,
epoch,
use_cuda,
mode='Train Stats')
val_loss, val_acc = validate(val_loader,
ema_model,
criterion,
epoch,
use_cuda,
mode='Valid Stats')
test_loss, test_acc = validate(test_loader,
ema_model,
criterion,
epoch,
use_cuda,
mode='Test Stats ')
step = args.val_iteration * (epoch + 1)
writer.add_scalar('losses/train_loss', train_loss, step)
writer.add_scalar('losses/valid_loss', val_loss, step)
writer.add_scalar('losses/test_loss', test_loss, step)
writer.add_scalar('accuracy/train_acc', train_acc, step)
writer.add_scalar('accuracy/val_acc', val_acc, step)
writer.add_scalar('accuracy/test_acc', test_acc, step)
# append logger file
logger.append([
train_loss, train_loss_x, train_loss_u, val_loss, val_acc,
test_loss, test_acc
])
# save model
is_best = val_acc > best_acc
best_acc = max(val_acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'ema_state_dict': ema_model.state_dict(),
'acc': val_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
}, is_best)
test_accs.append(test_acc)
logger.close()
writer.close()
print('Best acc:')
print(best_acc)
print('Mean acc:')
print(np.mean(test_accs[-20:]))
import matplotlib.pyplot as plt
import torch
import numpy as np
import argparse
from torch import nn
from torch import optim
import torch.nn.functional as F
from torchvision import datasets, transforms, models
train_transforms = transforms.Compose([
transforms.RandomRotation(30),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
valid_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
test_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
import os
from torchvision import datasets, transforms
import torch
import matplotlib.pyplot as plt
import sys
size = 128
cropped_size = 128
train_transforms = transforms.Compose([
transforms.Resize(size),
transforms.CenterCrop(size),
transforms.ToTensor()
])
test_transforms = transforms.Compose([
transforms.Resize(size),
transforms.CenterCrop(size),
transforms.ToTensor()
])
# data_dir = "./dogImages"
data_dir = "./dogImagesSample"
# Pass transforms in here, then run the next cell to see how the transforms look
train_data = datasets.ImageFolder(data_dir + '/train',
transform=train_transforms)
test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)
valid_data = datasets.ImageFolder(data_dir + '/valid',
transform=test_transforms)
trainloader = torch.utils.data.DataLoader(train_data, batch_size=64)
def main():
global BEST_ACC, LR_STATE
start_epoch = cfg.CLS.start_epoch # start from epoch 0 or last checkpoint epoch
# Create ckpt folder
if not os.path.isdir(cfg.CLS.ckpt):
mkdir_p(cfg.CLS.ckpt)
if args.cfg_file is not None and not cfg.CLS.evaluate:
shutil.copyfile(args.cfg_file, os.path.join(cfg.CLS.ckpt, args.cfg_file.split('/')[-1]))
# Dataset and Loader
normalize = transforms.Normalize(mean=cfg.pixel_mean, std=cfg.pixel_std)
if cfg.CLS.train_crop_type == 'center':
train_aug = [
transforms.Resize(cfg.CLS.base_size),
transforms.CenterCrop(cfg.CLS.crop_size),
transforms.RandomHorizontalFlip(),
]
elif cfg.CLS.train_crop_type == 'random_resized':
train_aug = [transforms.RandomResizedCrop(cfg.CLS.crop_size),
transforms.RandomHorizontalFlip()]
else:
train_aug = [transforms.RandomHorizontalFlip()]
if len(cfg.CLS.rotation) > 0:
train_aug.append(transforms.RandomRotation(cfg.CLS.rotation))
if len(cfg.CLS.pixel_jitter) > 0:
train_aug.append(RandomPixelJitter(cfg.CLS.pixel_jitter))
if cfg.CLS.grayscale > 0:
train_aug.append(transforms.RandomGrayscale(cfg.CLS.grayscale))
train_aug.append(transforms.ToTensor())
train_aug.append(normalize)
val_aug = [
transforms.Resize(cfg.CLS.base_size),
transforms.CenterCrop(cfg.CLS.crop_size),
transforms.ToTensor(),
normalize, ]
if os.path.isfile(cfg.CLS.train_root):
# if cfg.CLS.have_data_list:
train_datasets = CustomData(img_path=cfg.CLS.data_root,
txt_path=cfg.CLS.train_root,
data_transforms=transforms.Compose(train_aug))
val_datasets = CustomData(img_path=cfg.CLS.data_root,
txt_path=cfg.CLS.val_root,
data_transforms=transforms.Compose(val_aug))
# else:
elif os.path.isdir(cfg.CLS.data_root + cfg.CLS.train_root):
traindir = os.path.join(cfg.CLS.data_root, cfg.CLS.train_root)
train_datasets = datasets.ImageFolder(traindir, transforms.Compose(train_aug))
valdir = os.path.join(cfg.CLS.data_root, cfg.CLS.val_root)
val_datasets = datasets.ImageFolder(valdir, transforms.Compose(val_aug))
train_loader = torch.utils.data.DataLoader(train_datasets,
batch_size=cfg.CLS.train_batch, shuffle=False,
sampler=RandomIdentitySampler(train_datasets,num_instances=4),
num_workers=cfg.workers, pin_memory=True,drop_last=True)
print(type(train_loader))
if cfg.CLS.validate or cfg.CLS.evaluate:
val_loader = torch.utils.data.DataLoader(val_datasets,
batch_size=cfg.CLS.test_batch, shuffle=False,
num_workers=cfg.workers, pin_memory=True,drop_last=True)
# Create model
model = models.__dict__[cfg.CLS.arch]()
print(model)
# Calculate FLOPs & Param
n_flops, n_convops, n_params = measure_model(model, cfg.CLS.crop_size, cfg.CLS.crop_size)
print('==> FLOPs: {:.4f}M, Conv_FLOPs: {:.4f}M, Params: {:.4f}M'.
format(n_flops / 1e6, n_convops / 1e6, n_params / 1e6))
del model
model = models.__dict__[cfg.CLS.arch]()
# Load pre-train model
if cfg.CLS.pretrained:
print("==> Using pre-trained model '{}'".format(cfg.CLS.pretrained))
pretrained_dict = torch.load(cfg.CLS.pretrained)
try:
pretrained_dict = pretrained_dict['state_dict']
except:
pretrained_dict = pretrained_dict
model_dict = model.state_dict()
updated_dict, match_layers, mismatch_layers = weight_filler(pretrained_dict, model_dict)
model_dict.update(updated_dict)
model.load_state_dict(model_dict)
else:
print("==> Creating model '{}'".format(cfg.CLS.arch))
# Define loss function (criterion) and optimizer
#criterion = nn.CrossEntropyLoss().cuda()
criterion = TripletLoss(margin=args.margin).cuda()
if cfg.CLS.pretrained:
def param_filter(param):
return param[1]
new_params = map(param_filter, filter(lambda p: p[0] in mismatch_layers, model.named_parameters()))
base_params = map(param_filter, filter(lambda p: p[0] in match_layers, model.named_parameters()))
model_params = [{'params': base_params}, {'params': new_params, 'lr': cfg.CLS.base_lr * 10}]
else:
model_params = model.parameters()
model = torch.nn.DataParallel(model).cuda()
cudnn.benchmark = True
optimizer = optim.SGD(model_params, lr=cfg.CLS.base_lr, momentum=cfg.CLS.momentum,
weight_decay=cfg.CLS.weight_decay)
# Evaluate model
if cfg.CLS.evaluate:
print('\n==> Evaluation only')
test_loss, test_top1, test_top5 = test(val_loader, model, criterion, start_epoch, USE_CUDA)
print('==> Test Loss: {:.8f} | Test_top1: {:.4f}% | Test_top5: {:.4f}%'.format(test_loss, test_top1, test_top5))
return
# Resume training
title = 'Pytorch-CLS-' + cfg.CLS.arch
if cfg.CLS.resume:
# Load checkpoint.
print("==> Resuming from checkpoint '{}'".format(cfg.CLS.resume))
assert os.path.isfile(cfg.CLS.resume), 'Error: no checkpoint directory found!'
checkpoint = torch.load(cfg.CLS.resume)
BEST_ACC = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(cfg.CLS.ckpt, 'log.txt'), title=title, resume=True)
else:
logger = Logger(os.path.join(cfg.CLS.ckpt, 'log.txt'), title=title)
#logger.set_names(['Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.', 'Valid Acc.'])
logger.set_names(['Learning Rate', 'Train Loss', 'Train Acc.'])
# Train and val
for epoch in range(start_epoch, cfg.CLS.epochs):
print('\nEpoch: [{}/{}] | LR: {:.8f}'.format(epoch + 1, cfg.CLS.epochs, LR_STATE))
train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, USE_CUDA)
# top1 = train_acc
# BEST_ACC = max(top1, BEST_ACC)
if cfg.CLS.validate:
#test_loss, test_top1, test_top5 = test(val_loader, model, criterion, epoch, USE_CUDA)
top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val)
best_acc = max(top1, BEST_ACC)
print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'.
format(epoch, top1, best_acc))
#else:
#test_loss, test_top1, test_top5 = 0.0, 0.0, 0.0
# Append logger file
#logger.append([LR_STATE, train_loss, test_loss, train_acc, test_top1])
logger.append([LR_STATE, train_loss , train_acc])
# Save model
save_checkpoint(model, optimizer, train_acc, epoch)
# Draw curve
try:
draw_curve(cfg.CLS.arch, cfg.CLS.ckpt)
print('==> Success saving log curve...')
except:
print('==> Saving log curve error...')
logger.close()
try:
savefig(os.path.join(cfg.CLS.ckpt, 'log.eps'))
shutil.copyfile(os.path.join(cfg.CLS.ckpt, 'log.txt'), os.path.join(cfg.CLS.ckpt, 'log{}.txt'.format(
datetime.datetime.now().strftime('%Y%m%d%H%M%S'))))
except:
print('Copy log error.')
print('==> Training Done!')
print('==> Best acc: {:.4f}%'.format(best_top1))
def train_correspondence_block(json_file, cls, gpu, synthetic, epochs=50, batch_size=64, val_ratio=0.2,
save_model=True, iter_print=10):
"""
Training a UNnet for each class using real train and/or synthetic data
Args:
json_file: .txt file which stores the directory of the training images
cls: the class to train on, from 1 to 6
gpu: gpu id to use
synthetic: whether use synthetic data or not
epochs: number of epochs to train
batch_size: batch size
val_ratio: validation ratio during training
save_model: save model or not
iter_print: print training results per iter_print iterations
"""
train_data = NOCSDataset(json_file, cls, synthetic=synthetic, resize=64,
transform=transforms.Compose([transforms.ColorJitter(brightness=(0.6, 1.4),
contrast=(0.8, 1.2),
saturation=(0.8, 1.2),
hue=(-0.01, 0.01)),
AddGaussianNoise(10 / 255)]))
print('Size of trainset ', len(train_data))
indices = list(range(len(train_data)))
np.random.shuffle(indices)
num_train = len(indices)
split = int(np.floor(num_train * val_ratio))
train_idx, valid_idx = indices[split:], indices[:split]
# define samplers for obtaining training and validation batches
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetRandomSampler(valid_idx)
# prepare data loaders (combine dataset and sampler)
num_workers = 4
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size,
sampler=train_sampler, num_workers=num_workers)
val_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size,
sampler=valid_sampler, num_workers=num_workers)
device = torch.device(f"cuda:{gpu}" if torch.cuda.is_available() else "cpu")
print("device: ", f"cuda:{gpu}" if torch.cuda.is_available() else "cpu")
# architecture for correspondence block - 13 objects + backgound = 14 channels for ID masks
correspondence_block = UNet()
correspondence_block = correspondence_block.to(device)
# custom loss function and optimizer
criterion_x = nn.CrossEntropyLoss()
criterion_y = nn.CrossEntropyLoss()
criterion_z = nn.CrossEntropyLoss()
# specify optimizer
optimizer = optim.Adam(correspondence_block.parameters(), lr=3e-4, weight_decay=3e-5)
# training loop
val_loss_min = np.Inf
save_path = model_save_path(cls)
writer = SummaryWriter(save_path.parent / save_path.stem / datetime.now().strftime("%d%H%M"))
for epoch in range(epochs):
t0 = time.time()
train_loss = 0
val_loss = 0
print("------ Epoch ", epoch, " ---------")
correspondence_block.train()
print("training")
for iter, (rgb, xmask, ymask, zmask, adr_rgb) in enumerate(train_loader):
rgb = rgb.to(device)
xmask = xmask.to(device)
ymask = ymask.to(device)
zmask = zmask.to(device)
optimizer.zero_grad()
xmask_pred, ymask_pred, zmask_pred = correspondence_block(rgb)
loss_x = criterion_x(xmask_pred, xmask)
loss_y = criterion_y(ymask_pred, ymask)
loss_z = criterion_z(zmask_pred, zmask)
loss = loss_x + loss_y + loss_z
loss.backward()
optimizer.step()
train_loss += loss.item()
if iter % iter_print == 0:
print(
'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
format(epoch, iter * len(rgb), len(train_loader.dataset),
100. * iter / len(train_loader), loss.item()))
correspondence_block.eval()
print("validating")
for rgb, xmask, ymask, zmask, _ in val_loader:
rgb = rgb.to(device)
xmask = xmask.to(device)
ymask = ymask.to(device)
zmask = zmask.to(device)
xmask_pred, ymask_pred, zmask_pred = correspondence_block(rgb)
loss_x = criterion_x(xmask_pred, xmask)
loss_y = criterion_y(ymask_pred, ymask)
loss_z = criterion_z(zmask_pred, zmask)
loss = loss_x + loss_y + loss_z
val_loss += loss.item()
# calculate average losses
train_loss = train_loss / len(train_loader.sampler)
val_loss = val_loss / len(val_loader.sampler)
t_end = time.time()
print(f'{t_end - t0} seconds')
writer.add_scalar('train loss', train_loss, epoch)
writer.add_scalar('val loss', val_loss, epoch)
writer.add_scalar('epoch time', t_end - t0, epoch)
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, train_loss, val_loss))
# save model if validation loss has decreased
if val_loss <= val_loss_min:
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(
val_loss_min,
val_loss))
if save_model:
torch.save(correspondence_block.state_dict(), save_path)
val_loss_min = val_loss
writer.close()
import torch.nn.parallel
import os
import torchvision.transforms as transforms
from torch.autograd import Variable
import torchvision.datasets as datasets
import numpy as np
import csv
import matplotlib.image as mpimg
normalize = transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
std=[0.2023, 0.1994, 0.2010])
val_loader = torch.utils.data.DataLoader(datasets.CIFAR10(
root='./data',
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
normalize,
])),
batch_size=128,
shuffle=False,
num_workers=2,
pin_memory=True)
total_num = 5000
net_names = ['012052', '012072']
parameters = [(1, 20, 16.0)]
from resnet import ResNet18 as n00
class Ensemble(nn.Module):
def __init__(self, net1, net2, net3, net4, net5):
super(Ensemble, self).__init__()
# Ignore warnings
import warnings
warnings.filterwarnings("ignore")
plt.ion() # interactive mode
device = torch.device("cpu")
#device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#Parameters
#learning_rate = 1e-4
epochs = 10
data_transform_train = transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
data_transform_val = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
#Loading Dataset
miniImageNet_trainset = datasets.ImageFolder(root='/home/nvidia/miniset/train',
transform=data_transform_train)
miniImageNet_validationset = datasets.ImageFolder(
n_box = 5
grid_w = int(img_w / box_size[1])
grid_h = int(img_h / box_size[0])
save_path = save_dir + save_name + str(nn) + ".pt"
out_len = 5 + nclazz
fin_size = n_box * out_len
input_vec = [grid_w, grid_h, n_box, out_len]
anchors = np.array(anchors)
animal_dataset_valid = AnimalBoundBoxDataset(root_dir=files_location_valid,
inputvec=input_vec,
anchors=anchors,
maxann=max_annotations,
transform=transforms.Compose([
MakeMat(input_vec, anchors),
ToTensor()
]),
gray=grey_tf
)
animalloader_valid = DataLoader(animal_dataset_valid, batch_size=1, shuffle=False)
layerlist = get_weights(weightspath)
net = YoloNetOrig(layerlist, fin_size, channels_in)
net = net.to(device)
net.load_state_dict(torch.load(save_path))
net.eval()
tptp = 0
fpfp = 0
# pytorch_learning_19_validation
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
batch_size = 200
learning_rate = 0.01
epochs = 10
train_db = datasets.MNIST('../pytorch_learning_02_MNIST/mnist_data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
train_loader = torch.utils.data.DataLoader(
train_db,
batch_size=batch_size, shuffle=True)
test_db = datasets.MNIST('../pytorch_learning_02_MNIST/mnist_data', train=False, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
test_loader = torch.utils.data.DataLoader(test_db,
batch_size=batch_size, shuffle=True)
print('train:', len(train_db), 'test:', len(test_db))
train_db, val_db = torch.utils.data.random_split(train_db, [50000, 10000])
import torch.nn.functional as F
import torch.optim as opt
from torchvision import datasets,transforms
from visdom import Visdom
import numpy
#预设参数:训练批次，学习率，和迭代次数
batch_size = 200
learning_rate = 0.01
epochs = 10
viz = Visdom()
#使用Pytorch内置函数，设置训练集
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data',train=True,download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))
])), #数据集的保存目录，训练和下载标记，变化换为Tensor，标准化
batch_size=batch_size,shuffle=True) #训练批次，打乱数据集
#使用Pytorch内置函数，设置测试集
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data',train=False,download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))
])),
batch_size=batch_size,shuffle=True)
#定义一个封装好的类
class MLP(nn.Module):
action='store_true',
help='resume from checkpoint')
args = parser.parse_args()
use_cuda = torch.cuda.is_available()
torch.manual_seed(1)
if use_cuda:
torch.cuda.manual_seed(1)
best_acc = 0 # best test accuracy
start_epoch = 0 # start from epoch 0 or last checkpoint epoch
# Data
print('==> Preparing data..')
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)),
])
trainset = torchvision.datasets.CIFAR10(
root='/homes/crosarko/pytorch-cifar/data',
train=True,
download=True,
transform=transform_train)
shuffle(trainset.train_labels)
print(trainset.train_labels)
def main():
start = time.time()
# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
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=5,
metavar='N',
help='number of epochs to train (default: 5)')
parser.add_argument('--lr',
type=float,
default=0.01,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
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=True,
help='For Saving the current Model')
parser.add_argument('--file-name',
type=str,
default='test_' + str(int(start))[-3:],
metavar='filename',
help='Name of file to store model and losses')
parser.add_argument(
'--quant-type',
type=str,
default='none',
metavar='qtype',
help='Type of quantisation used on activation functions')
parser.add_argument('--bit-res',
type=int,
default=4,
metavar='bitres',
help='Bit resolution of activation funtion')
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 = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
train_loader = torch.utils.data.DataLoader(datasets.MNIST(
'../data',
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(datasets.MNIST(
'../data',
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
qt = args.quant_type
if qt == 'dumb':
model = DumbNet().to(device)
print("Building dumb {0} bit network".format(args.bit_res))
elif qt == 'lit':
model = LitNet().to(device)
print("Building LIT {0} bit network".format(args.bit_res))
else:
model = Net().to(device)
print("\nBuilding full resolution network")
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum)
losses_train = np.zeros((args.epochs))
losses_test = np.zeros((args.epochs))
start = time.time()
for epoch in range(1, args.epochs + 1):
epoch_train_loss = train(args, model, device, train_loader, optimizer,
epoch)
epoch_test_loss = test(args, model, device, test_loader)
losses_train[epoch - 1] = epoch_train_loss
losses_test[epoch - 1] = epoch_test_loss
current_time = time.time() - start
print('\nEpoch: {:d}'.format(epoch))
print('Training set loss: {:.6f}'.format(epoch_train_loss))
print('Test set loss: {:.6f}'.format(epoch_test_loss))
print('Time taken: {:.6f}s'.format(current_time))
if (args.save_model):
if not os.path.exists('models'):
os.mkdir('models')
torch.save(model.state_dict(), 'models/' + args.file_name + '.pt')
if not os.path.exists('data'):
os.mkdir('data')
losses = np.stack((losses_train, losses_test), axis=1)
np.savetxt('data/' + args.file_name + '.txt', losses, delimiter=', ')
fig = plt.figure()
ax = fig.gca()
ax.set_title('Loss per Epoch')
plt.plot(losses_train)
plt.plot(losses_test)
plt.ylabel('loss')
plt.xlabel('epoch')
blue_line = mpatches.Patch(color='blue', label='Training Loss')
orange_line = mpatches.Patch(color='orange', label='Testing Loss')
plt.legend(handles=[blue_line, orange_line])
plt.show()
from torch.optim import lr_scheduler
import numpy as np
from torch.utils.data import DataLoader
import os
import matplotlib.pyplot as plt
import time
import copy
import torch.optim as optim
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
data_transforms = {
'train':
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
data_dir = '../data_files/data/hymenoptera_data'
image_datasets = {
x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])
for x in ['train', 'val']
def main():
# Training settings
# Use the command line to modify the default settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=32, 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=10, 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('--step', type=int, default=1, metavar='N',
help='number of epochs between learning rate reductions (default: 1)')
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('--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('--traintest', action='store_true', default=False,
help='train on fractions of data and test')
parser.add_argument('--show_wrong', action='store_true', default=False,
help='show incorrectly labelled test images')
parser.add_argument('--show_features', action='store_true', default=False,
help='show first layer features')
parser.add_argument('--show_tsne', action='store_true', default=False,
help='show first layer features')
parser.add_argument('--evaluate', action='store_true', default=False,
help='evaluate your model on the official test set')
parser.add_argument('--load-model', type=str,
help='model file path')
parser.add_argument('--save-model', action='store_true', default=True,
help='For Saving the current Model')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
np.random.seed(args.seed)
random.seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
print("Device:", device)
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
# show features
if args.show_features:
assert os.path.exists(args.load_model)
model = Net().to(device)
model.load_state_dict(torch.load(args.load_model))
conv1 = model.conv1.weight.detach().cpu()
plt.figure()
for i, filt in enumerate(conv1):
plt.subplot(331 + i)
plt.axis('off')
plt.title(f'Filter {i+1}')
plt.imshow(filt[0])
if i == 8:
break
plt.show()
return
# Evaluate on the official test set
if args.evaluate or args.show_wrong:
assert os.path.exists(args.load_model)
# Set the test model
model = Net().to(device)
model.load_state_dict(torch.load(args.load_model))
test_dataset = datasets.MNIST('../data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=args.test_batch_size, shuffle=True, **kwargs)
test(model, device, test_loader, show_wrong=args.show_wrong, tsne=args.show_tsne)
return
if args.traintest:
test_dataset = datasets.MNIST('../data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,),
(0.3081,))
]))
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=args.test_batch_size, shuffle=True,
**kwargs)
# Pytorch has default MNIST dataloader which loads data at each iteration
data_transforms = {"train": transforms.Compose([
transforms.RandomRotation(degrees=10),
#transforms.RandomAffine(degrees=10, scale=(.9, .9)),# scale=(.1, .1), shear=.1),
transforms.ToTensor(),
#transforms.RandomErasing(p=0.8, scale=(.05, .05)),
#transforms.Normalize((0.1307,), (0.3081,))
]),
"val": transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
}
train_dataset = datasets.MNIST('../data', train=True, download=True, transform=data_transforms["train"])
val_dataset = datasets.MNIST('../data', train=False, download=True, transform=data_transforms["val"])
# You can assign indices for training/validation or use a random subset for
# training by using SubsetRandomSampler. Right now the train and validation
# sets are built from the same indices - this is bad! Change it so that
# the training and validation sets are disjoint and have the correct relative sizes.
class_data = [[] for _ in range(10)]
for i, elem in enumerate(tqdm(val_dataset)):
class_data[elem[1]].append(i)
split = .85
subset_indices_train = []
subset_indices_valid = []
for i in range(10):
np.random.shuffle(class_data[i])
subset_indices_train += class_data[i][:int(len(class_data[i])*split)]
subset_indices_valid += class_data[i][int(len(class_data[i])*split):]
if args.traintest:
train_fracs = [1., .5, .25, .125, .0625]
else:
train_fracs = [1.]
train_frac_losses = []
test_frac_losses = []
train_frac_accs = []
test_frac_accs = []
for train_frac in train_fracs:
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size,
sampler=SubsetRandomSampler(subset_indices_train[:int(len(subset_indices_train)*train_frac)])
)
val_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=args.test_batch_size,
sampler=SubsetRandomSampler(subset_indices_valid[:int(len(subset_indices_valid)*train_frac)])
)
#for imgs, label in train_loader:
# for img in imgs:
# plt.figure()
# plt.imshow(img[0])
# plt.show()
# Load your model [fcNet, ConvNet, Net]
model = Net().to(device)
# Try different optimzers here [Adam, SGD, RMSprop]
optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
# Set your learning rate scheduler
scheduler = StepLR(optimizer, step_size=args.step, gamma=args.gamma)
# Training loop
train_losses = []
test_losses = []
train_accs = []
test_accs = []
for epoch in range(1, args.epochs + 1):
train_loss, train_acc = train(args, model, device, train_loader, optimizer, epoch)
test_loss, test_acc = test(model, device, val_loader)
scheduler.step() # learning rate scheduler
train_losses.append(train_loss)
train_accs.append(train_acc)
test_losses.append(test_loss)
test_accs.append(test_acc)
# You may optionally save your model at each epoch here
if not args.traintest:
figs, axs = plt.subplots(2)
axs[0].set_title("Loss")
axs[0].set_ylabel("Loss")
axs[0].plot(test_losses)
axs[0].plot(train_losses)
axs[1].set_title("Accuracy")
axs[1].set_ylabel("Accuracy")
axs[1].plot(test_accs)
axs[1].set_xlabel("Epoch")
plt.show()
else:
test_loss, test_acc = test(model, device, test_loader)
test_frac_losses.append(test_loss)
train_frac_losses.append(train_loss)
test_frac_accs.append(test_acc)
train_frac_accs.append(train_acc)
if args.traintest:
plt.figure()
plt.subplot(2, 1, 1)
plt.title("Loss")
plt.plot(train_fracs, test_frac_losses)
plt.plot(train_fracs, train_frac_losses)
plt.legend(["Test", "Train"])
plt.ylabel("Loss (log)")
plt.yscale("log")
plt.xscale("log")
plt.subplot(2, 1, 2)
plt.title("Accuracy")
plt.plot(train_fracs, test_frac_accs)
plt.plot(train_fracs, train_frac_accs)
plt.legend(["Test", "Train"])
plt.xlabel("Fraction of Training Set (log)")
plt.ylabel("Accuracy (log)")
plt.yscale("log")
plt.xscale("log")
plt.show()
if args.save_model:
torch.save(model.state_dict(), "mnist_model.pt")
#crop face from img
faceCascade = cv2.CascadeClassifier(detectFace)
image = cv2.imread(imagePath)
faces = faceCascade.detectMultiScale(image,
scaleFactor=1.1,
minNeighbors=5,
minSize=(10, 10))
for (x, y, w, h) in faces:
cv2.imwrite('./image/crop/' + 'test_face.jpg', image[y:y + h, x:x + w])
cv2.waitKey(0)
#transfer img to tensor
dataTransforms = transforms.Compose([
transforms.Resize(inputSize),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
#load net
net = ShuffleNetV2(inputSize)
checkpoint = torch.load(fiiqaWeight)
net.load_state_dict(checkpoint['net'])
net.eval()
#load face and get expect num
face = Image.open(facePath)
imgblob = dataTransforms(face).unsqueeze(0)
#imgblob = Variable(imgblob)
torch.no_grad()
predict = F.softmax(net(imgblob), dim=1)
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"
)
if opt.dataset in ['imagenet', 'folder', 'lfw']:
# folder dataset
dataset = dset.ImageFolder(root=opt.dataroot,
transform=transforms.Compose([
transforms.Scale(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(db_path=opt.dataroot,
classes=['bedroom_train'],
transform=transforms.Compose([
transforms.Scale(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 == 'cifar10':
dataset = dset.CIFAR10(root=opt.dataroot,
def main():
# Init logger
if not os.path.isdir(args.save_path):
os.makedirs(args.save_path)
log = open(os.path.join(args.save_path, 'log_seed_{}.txt'.format(args.manualSeed)), 'w')
print_log('save path : {}'.format(args.save_path), log)
state = {k: v for k, v in args._get_kwargs()}
print_log(state, log)
print_log("Random Seed: {}".format(args.manualSeed), log)
print_log("python version : {}".format(sys.version.replace('\n', ' ')), log)
print_log("torch version : {}".format(torch.__version__), log)
print_log("cudnn version : {}".format(torch.backends.cudnn.version()), log)
# Init dataset
if not os.path.exists(args.data_path):
os.makedirs(args.data_path)
if args.dataset == 'cifar10':
mean = [x / 255 for x in [125.3, 123.0, 113.9]]
std = [x / 255 for x in [63.0, 62.1, 66.7]]
elif args.dataset == 'cifar100':
mean = [x / 255 for x in [129.3, 124.1, 112.4]]
std = [x / 255 for x in [68.2, 65.4, 70.4]]
else:
assert False, "Unknow dataset : {}".format(args.dataset)
train_transform = transforms.Compose(
[transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, padding=4), transforms.ToTensor(),
transforms.Normalize(mean, std)])
test_transform = transforms.Compose(
[transforms.ToTensor(), transforms.Normalize(mean, std)])
if args.dataset == 'cifar10':
train_data = dset.CIFAR10(args.data_path, train=True, transform=train_transform, download=True)
test_data = dset.CIFAR10(args.data_path, train=False, transform=test_transform, download=True)
num_classes = 10
elif args.dataset == 'cifar100':
train_data = dset.CIFAR100(args.data_path, train=True, transform=train_transform, download=True)
test_data = dset.CIFAR100(args.data_path, train=False, transform=test_transform, download=True)
num_classes = 100
elif args.dataset == 'svhn':
train_data = dset.SVHN(args.data_path, split='train', transform=train_transform, download=True)
test_data = dset.SVHN(args.data_path, split='test', transform=test_transform, download=True)
num_classes = 10
elif args.dataset == 'stl10':
train_data = dset.STL10(args.data_path, split='train', transform=train_transform, download=True)
test_data = dset.STL10(args.data_path, split='test', transform=test_transform, download=True)
num_classes = 10
elif args.dataset == 'imagenet':
assert False, 'Do not finish imagenet code'
else:
assert False, 'Do not support dataset : {}'.format(args.dataset)
train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
print_log("=> creating model '{}'".format(args.arch), log)
# Init model, criterion, and optimizer
net = models.__dict__[args.arch](num_classes)
print_log("=> network :\n {}".format(net), log)
net = torch.nn.DataParallel(net, device_ids=list(range(args.ngpu)))
# define loss function (criterion) and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), state['learning_rate'], momentum=state['momentum'],
weight_decay=state['decay'], nesterov=False)
#optimizer = AccSGD(net.parameters(), state['learning_rate'], kappa = 1000.0, xi = 10.0)
#optimizer.zero_grad()
#loss_fn(model(input), target).backward()
# optimizer.step()
if args.use_cuda:
net.cuda()
criterion.cuda()
recorder = RecorderMeter(args.epochs)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print_log("=> loading checkpoint '{}'".format(args.resume), log)
checkpoint = torch.load(args.resume)
recorder = checkpoint['recorder']
args.start_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print_log("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch']), log)
else:
raise ValueError("=> no checkpoint found at '{}'".format(args.resume))
else:
print_log("=> do not use any checkpoint for {} model".format(args.arch), log)
if args.evaluate:
validate(test_loader, net, criterion, log)
return
# Main loop
start_time = time.time()
epoch_time = AverageMeter()
train_cc=0
loss_e=0
for epoch in range(args.start_epoch, args.epochs):
current_learning_rate = adjust_learning_rate(optimizer, epoch, args.gammas, args.schedule,loss_e)
optimizer = torch.optim.SGD(net.parameters(), current_learning_rate, momentum=state['momentum'],
weight_decay=state['decay'], nesterov=False)
need_hour, need_mins, need_secs = convert_secs2time(epoch_time.avg * (args.epochs-epoch))
need_time = '[Need: {:02d}:{:02d}:{:02d}]'.format(need_hour, need_mins, need_secs)
print_log('\n==>>{:s} [Epoch={:03d}/{:03d}] {:s} [learning_rate={:6.4f}]'.format(time_string(), epoch, args.epochs, need_time, current_learning_rate) \
+ ' [Best : Accuracy={:.2f}, Error={:.2f}]'.format(recorder.max_accuracy(False), 100-recorder.max_accuracy(False)), log)
# train for one epoch
train_acc, train_los,loss_e = train(train_loader, net, criterion, optimizer, epoch, log,train_cc)
# evaluate on validation set
#val_acc, val_los = extract_features(test_loader, net, criterion, log)
val_acc, val_los = validate(test_loader, net, criterion, log)
is_best = recorder.update(epoch, train_los, train_acc, val_los, val_acc)
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': net.state_dict(),
'recorder': recorder,
'optimizer' : optimizer.state_dict(),
'args' : copy.deepcopy(args),
}, is_best, args.save_path, 'sgd8_40lcheck.pth.tar')
# measure elapsed time
epoch_time.update(time.time() - start_time)
start_time = time.time()
recorder.plot_curve( os.path.join(args.save_path, 'sgd8_40l.png') )
log.close()
# init model
device = torch.device("cuda")
model_name = "resnet{depth}".format(depth=config.model_depth)
model = torchvision.models.__dict__[model_name](pretrained=config.pretrained)
model.fc = torch.nn.Linear(model.fc.in_features, 1)
# set transforms
augs = [transforms.ToTensor()]
if config.aug:
augs.append(transforms.RandomHorizontalFlip(p=0.5))
augs.append(transforms.RandomVerticalFlip(p=0.5))
tfms = transforms.Compose(augs)
dataset_aug = datasets.ImageFolder("data/ready_to_train", transform=tfms)
dataset = datasets.ImageFolder("data/ready_to_train", transform=transforms.ToTensor())
train_len = int(dataset.__len__()*0.75)
test_len = dataset.__len__()-train_len
trainset, _ = torch.utils.data.random_split(dataset_aug, [train_len, test_len], generator=torch.Generator().manual_seed(42))
_ , testset = torch.utils.data.random_split(dataset, [train_len, test_len], generator=torch.Generator().manual_seed(42))
# loaders
train_loader = torch.utils.data.DataLoader(
trainset,
batch_size=config.batch_size,
shuffle=True
)
def main():
global best_acc
start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch
if not os.path.isdir(args.checkpoint):
mkdir_p(args.checkpoint)
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'valf')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
data_aug_scale = (0.08, 1.0) if args.modelsize == 'large' else (0.2, 1.0)
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(traindir, transforms.Compose([
transforms.RandomResizedCrop(224, scale = data_aug_scale),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.train_batch, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.test_batch, shuffle=True,
num_workers=args.workers, pin_memory=True)
# create model
if args.pretrained:
print("=> using pre-trained model '{}'".format(args.arch))
model = models.__dict__[args.arch](pretrained=True)
elif 'resnext' in args.arch:
model = models.__dict__[args.arch](
baseWidth=args.base_width,
cardinality=args.cardinality,
)
else:
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
flops, params = get_model_complexity_info(model, (224, 224), as_strings=False, print_per_layer_stat=False)
print('Flops: %.3f' % (flops / 1e9))
print('Params: %.2fM' % (params / 1e6))
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()
cudnn.benchmark = True
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
# Resume
title = 'ImageNet-' + args.arch
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(args.resume), 'Error: no checkpoint directory found!'
args.checkpoint = os.path.dirname(args.resume)
checkpoint = torch.load(args.resume)
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
# model may have more keys
t = model.state_dict()
c = checkpoint['state_dict']
flag = True
for k in t:
if k not in c:
print('not in loading dict! fill it', k, t[k])
c[k] = t[k]
flag = False
model.load_state_dict(c)
if flag:
print('optimizer load old state')
optimizer.load_state_dict(checkpoint['optimizer'])
else:
print('new optimizer !')
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True)
else:
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(['Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.', 'Valid Acc.'])
if args.evaluate:
print('\nEvaluation only')
test_loss, test_acc = test(val_loader, model, criterion, start_epoch, use_cuda)
print(' Test Loss: %.8f, Test Acc: %.2f' % (test_loss, test_acc))
return
# Train and val
for epoch in range(start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr']))
train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, use_cuda)
test_loss, test_acc = test(val_loader, model, criterion, epoch, use_cuda)
# append logger file
logger.append([state['lr'], train_loss, test_loss, train_acc, test_acc])
# save model
is_best = test_acc > best_acc
best_acc = max(test_acc, best_acc)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': test_acc,
'best_acc': best_acc,
'optimizer' : optimizer.state_dict(),
}, is_best, checkpoint=args.checkpoint)
logger.close()
print('Best acc:')
print(best_acc)
def __init__(self, args, valid=False, one_hot=True):
self.args = args
self.valid = valid
self.one_hot = one_hot
print('\nData Preparation')
# Data Uplaod
data_transform = transforms.Compose([
transforms.ToTensor(),
])
encoded_data_transform = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
])
# root_path = '/Users/changgang/Documents/DATA/Data For Research/CIFAR'
root_path = '/HDD/personal/zhengchanggang/CIFAR'
# root_path = '../data'
if (args.dataset == 'cifar-10'):
self.trainset = CIFAR10(root=root_path,
train=True,
valid=valid,
classes=np.arange(10),
transform=data_transform)
self.testset = CIFAR10(root=root_path,
train=False,
classes=np.arange(10),
transform=data_transform)
self.encoded_trainset = CIFAR10(root=root_path,
train=True,
valid=valid,
encoded=True,
classes=np.arange(10),
transform=encoded_data_transform)
self.encoded_testset = CIFAR10(root=root_path,
train=False,
encoded=True,
classes=np.arange(10),
transform=encoded_data_transform)
self.with_encoded_trainset = CIFAR10(
root=root_path,
train=True,
valid=valid,
encoded=True,
with_encoded=True,
classes=np.arange(10),
transform=encoded_data_transform)
self.with_encoded_testset = CIFAR10(
root=root_path,
train=False,
encoded=True,
with_encoded=True,
classes=np.arange(10),
transform=encoded_data_transform)
else:
assert args.dataset == 'cifar-100'
self.trainset = CIFAR100(root=root_path,
train=True,
valid=valid,
classes=np.arange(100),
transform=data_transform)
self.testset = CIFAR100(root=root_path,
train=False,
classes=np.arange(100),
transform=data_transform)
self.encoded_trainset = CIFAR100(root=root_path,
train=True,
valid=valid,
encoded=True,
classes=np.arange(100),
transform=encoded_data_transform)
self.encoded_testset = CIFAR100(root=root_path,
train=False,
encoded=True,
classes=np.arange(100),
transform=encoded_data_transform)
self.with_encoded_trainset = CIFAR100(
root=root_path,
train=True,
valid=valid,
encoded=True,
with_encoded=True,
classes=np.arange(100),
transform=encoded_data_transform)
self.with_encoded_testset = CIFAR100(
root=root_path,
train=False,
encoded=True,
with_encoded=True,
classes=np.arange(100),
transform=encoded_data_transform)
self.label_transformer = OneHotEncoder(
sparse=False, categories='auto').fit(
np.array(self.trainset.train_labels).reshape(-1, 1))
if self.one_hot: # DEFAULT True
self.trainset.train_labels = self.label_transformer.transform(
np.array(self.trainaset.train_labels).reshape(-1, 1))
self.testset.test_labels = self.label_transformer.transform(
np.array(self.testset.test_labels).reshape(-1, 1))
self.encoded_trainset.train_labels = self.label_transformer.transform(
np.array(self.encoded_trainset.train_labels).reshape(-1, 1))
self.encoded_testset.test_labels = self.label_transformer.transform(
np.array(self.encoded_testset.test_labels).reshape(-1, 1))
self.with_encoded_trainset.train_labels = self.label_transformer.transform(
np.array(self.with_encoded_trainset.train_labels).reshape(
-1, 1))
self.with_encoded_testset.test_labels = self.label_transformer.transform(
np.array(self.with_encoded_testset.test_labels).reshape(-1, 1))
self.with_encoded_trainset.encoded_train_labels = self.label_transformer.transform(
np.array(
self.with_encoded_trainset.encoded_train_labels).reshape(
-1, 1))
self.with_encoded_testset.encoded_test_labels = self.label_transformer.transform(
np.array(
self.with_encoded_testset.encoded_test_labels).reshape(
-1, 1))
if valid:
self.validset = Validset(copy.deepcopy(trainset))
self.encoded_validset = Validset(copy.deepcopy(
self.encoded_trainset),
encoded=True)
self.with_encoded_validset = Validset(copy.deepcopy(
self.with_encoded_trainset),
encoded=True,
with_encoded=True)
else:
self.validloader = None
self.encoded_validloader = None
self.with_encoded_validset = None
import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
validationset = torchvision.datasets.CIFAR10(root='./data', train=False,
transform=transform)
validationloader = torch.utils.data.DataLoader(validationset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
@Author: John @Email: [email protected] @Date: 2020-06-11 10:02:35 @LastEditor: John @LastEditTime: 2020-06-11 16:57:34 @Discription: @Environment: python 3.7.7 ''' import numpy as np import torch import torchvision.transforms as T from PIL import Image resize = T.Compose( [T.ToPILImage(), T.Resize(40, interpolation=Image.CUBIC), T.ToTensor()]) def get_cart_location(env, screen_width): world_width = env.x_threshold * 2 scale = screen_width / world_width return int(env.state[0] * scale + screen_width / 2.0) # MIDDLE OF CART def get_screen(env, device): # Returned screen requested by gym is 400x600x3, but is sometimes larger # such as 800x1200x3. Transpose it into torch order (CHW). screen = env.render(mode='rgb_array').transpose((2, 0, 1)) # Cart is in the lower half, so strip off the top and bottom of the screen _, screen_height, screen_width = screen.shape
