def qforward():
qnet = torch.load('./data_quan/cifar10_qun4_best.pt')
stats = load_stats('./data_quan/stats_table4.json')
#print(qnet)
#print(stats)
batch_size = 128
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.24703, 0.24349, 0.26159))])
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,shuffle=False, num_workers=4)
#classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# load model
model = copy.deepcopy(qnet)
num_bits = 4
val_record = {'min':{}, 'max':{}}
scale_factors_record = {}
final_accuracys = {}
corrects = 0
total = len(testloader.dataset)
model = model.cuda()
model.eval()
with torch.no_grad():
for n_scale in range(1, 16):
corrects = 0
print("with n_scale : {}".format(n_scale))
with tqdm(total=total, ascii=True) as tbar:
for images, labels in testloader:
images, labels = images.cuda(), labels.cuda()
outputs, weights_record, bias_record, scale_factors_record = bit_conv_forward(images,
model,
num_bits,
n_scale,
val_record,
scale_factors_record,
stats)
model.conv1.weight.data = weights_record[0]
model.conv2.weight.data = weights_record[1]
model.conv3.weight.data = weights_record[2]
model.conv4.weight.data = weights_record[3]
model.conv5.weight.data = weights_record[4]
model.conv6.weight.data = weights_record[5]
model.conv7.weight.data = weights_record[6]
model.conv8.weight.data = weights_record[7]
model.conv9.weight.data = weights_record[8]
model.conv10.weight.data = weights_record[9]
model.conv11.weight.data = weights_record[10]
model.conv12.weight.data = weights_record[11]
model.classifier.weight.data = weights_record[12]
model.conv1.bias.data = bias_record[0]
model.conv2.bias.data = bias_record[1]
model.conv3.bias.data = bias_record[2]
model.conv4.bias.data = bias_record[3]
model.conv5.bias.data = bias_record[4]
model.conv6.bias.data = bias_record[5]
model.conv7.bias.data = bias_record[6]
model.conv8.bias.data = bias_record[7]
model.conv9.bias.data = bias_record[8]
model.conv10.bias.data = bias_record[9]
model.conv11.bias.data = bias_record[10]
model.conv12.bias.data = bias_record[11]
model.classifier.bias.data = bias_record[12]
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).sum()
corrects += c
tbar.update(labels.size(0))
acc = (100.*corrects/total)
print("test accuracy: {}/{} = {}%\n".format(corrects, total, acc))
final_accuracys[str(n_scale)] = acc
return final_accuracys, scale_factors_record
def create_dataloader(loader_type, args):
"""
Create a data loader according to the parameters
"""
kwargs = {
'num_workers': args.num_loader_workers,
'pin_memory': True
} if args.cuda else {}
if args.dataset_type == DatasetType.NYU:
if loader_type == LoaderMode.VAL:
print("===> Creating validation data loader...")
needed_cam_ids = np.append(args.output_cam_ids_test,
args.needed_cam_ids_test)
needed_cam_ids_synth = []
num_samples_val = min(
int(round(args.max_val_train_ratio *
args.num_labeled_samples)), args.max_num_samples_val)
ids_val = np.arange(args.id_start_val, args.id_end_val + 1)
ids_val = args.rng.permutation(ids_val)
ids_val = ids_val[:num_samples_val]
loader = torch.utils.data.DataLoader(
NyuHandPoseMultiViewDataset(
args.nyu_data_basepath,
train=False,
cropSize=args.in_crop_size,
doJitterCom=args.do_jitter_com_test,
sigmaCom=args.sigma_com,
doAddWhiteNoise=args.do_add_white_noise_test,
sigmaNoise=args.sigma_noise,
transform=transforms.ToTensor(),
useCache=args.use_pickled_cache,
cacheDir=args.nyu_data_basepath_pickled,
annoType=args.anno_type,
neededCamIdsReal=needed_cam_ids,
neededCamIdsSynth=needed_cam_ids_synth,
randomSeed=args.seed,
cropSize3D=args.crop_size_3d_tuple,
args_data=args),
batch_size=args.batch_size,
sampler=smpl.SubsetRandomSampler(ids_val),
**kwargs)
print("Using {} samples for validation".format(len(ids_val)))
elif loader_type == LoaderMode.TEST:
print("===> Creating test data loader...")
needed_cam_ids_synth = []
loader = torch.utils.data.DataLoader(NyuHandPoseMultiViewDataset(
args.nyu_data_basepath,
train=False,
cropSize=args.in_crop_size,
doJitterCom=args.do_jitter_com_test,
sigmaCom=args.sigma_com,
doAddWhiteNoise=args.do_add_white_noise_test,
sigmaNoise=args.sigma_noise,
transform=transforms.ToTensor(),
useCache=args.use_pickled_cache,
cacheDir=args.nyu_data_basepath_pickled,
annoType=args.anno_type,
neededCamIdsReal=args.needed_cam_ids_test,
neededCamIdsSynth=needed_cam_ids_synth,
randomSeed=args.seed,
cropSize3D=args.crop_size_3d_tuple,
args_data=args),
batch_size=args.batch_size,
**kwargs)
print("Using {} samples for test".format(len(loader.sampler)))
else:
raise UserWarning("LoaderMode implemented.")
else:
raise UserWarning("DatasetType not implemented.")
return loader
def create_loader_preview(loader_type,
args_data,
do_use_gpu,
num_loader_workers,
min_samp_prob_label,
batch_size,
cam_ids_real,
cam_ids_synth,
seed,
id_range=[],
ids_train_permuted=[]):
# Sanity check
if not loader_type == LoaderMode.TRAIN:
print("Required loader-type {} not implemented.".format(loader_type))
raise UserWarning(
"requested loader generation currently only implemented for TRAINING data loaders"
)
kwargs = {
'num_workers': num_loader_workers,
'pin_memory': True
} if do_use_gpu else {}
if args_data.dataset_type == DatasetType.NYU:
if len(id_range) == 0:
id_range = [args_data.id_start_train, args_data.id_end_train + 1]
# Set up sample IDs to sample from
ids_train = np.arange(*id_range)
if len(ids_train_permuted) == 0:
ids_train_permuted = args_data.rng.permutation(ids_train)
ids_train_labeled = ids_train_permuted[:args_data.num_labeled_samples]
ids_train_unlabeled = ids_train_permuted[args_data.
num_labeled_samples:]
# Ensure a minimum sampling probability for labeled samples
ratio_labeled = len(ids_train_labeled) / float(len(ids_train))
prob_labeled = max(min_samp_prob_label, ratio_labeled)
prob_unlabeled = 1.0 - prob_labeled
# Set up distribution/weights to sample from (considering un-/labeled samples)
scale_weights = float(
len(ids_train)) # value to which weights will sum up
sample_weight_labeled = prob_labeled * scale_weights / float(
len(ids_train_labeled))
sample_weight_unlabeled = prob_unlabeled * scale_weights \
/ float(len(ids_train_unlabeled)) \
if len(ids_train_unlabeled) > 0 else 0.0
sampling_weights = np.zeros((args_data.num_all_samples_train))
sampling_weights[ids_train_labeled] = sample_weight_labeled
sampling_weights[ids_train_unlabeled] = sample_weight_unlabeled
num_samples_used_for_train = np.count_nonzero(sampling_weights)
loader = torch.utils.data.DataLoader(
NyuHandPoseMultiViewDataset(
args_data.nyu_data_basepath,
train=True,
cropSize=args_data.in_crop_size,
doJitterCom=args_data.do_jitter_com,
sigmaCom=args_data.sigma_com,
doAddWhiteNoise=args_data.do_add_white_noise,
sigmaNoise=args_data.sigma_noise,
unlabeledSampleIds=ids_train_unlabeled,
transform=transforms.ToTensor(),
useCache=args_data.use_pickled_cache,
cacheDir=args_data.nyu_data_basepath_pickled,
annoType=args_data.anno_type,
neededCamIdsReal=cam_ids_real,
neededCamIdsSynth=cam_ids_synth,
randomSeed=seed,
cropSize3D=args_data.crop_size_3d_tuple,
args_data=args_data),
batch_size=batch_size,
sampler=smpl.WeightedRandomSampler(
sampling_weights,
num_samples=num_samples_used_for_train,
replacement=True),
**kwargs)
print(
"Using {} samples for training".format(num_samples_used_for_train))
if sample_weight_labeled > 0.:
print(" {} labeled".format(len(ids_train_labeled)))
if sample_weight_unlabeled > 0.:
print(" {} unlabeled".format(len(ids_train_unlabeled)))
return loader
if img_path['articleType'] not in self.label_map:
self.label_map[img_path['articleType']] = i
i += 1
if img_path['articleType'] not in self.class_distribution:
self.class_distribution[img_path['articleType']] = 1
else:
self.class_distribution[img_path['articleType']] += 1
print("Found {} images in {} for provided csv file.".format(len(self.data), data_dir))
print("Total classes: {}".format(len(self.label_map)))
# print(self.label_map)
# for testing purpose
if __name__ == "__main__":
data_loader = FashionDataset("D:\\Projects\\Datasets\\fashion-product-images", "top20classes_set.csv", transform=transforms.Compose([transforms.Resize((224,224)), transforms.ToTensor()]))
i = 0
print(len(data_loader))
dataset_loader = torch.utils.data.DataLoader(dataset=data_loader, batch_size=16, shuffle=True)
print(len(dataset_loader))
# print(list(range(len(data_loader))))
print(data_loader[0][1])
for img, label in data_loader:
d = transforms.ToPILImage()(img)
i += 1
if i == 10:
print("Label: ", label)
# d.show()
# print(img.size())
# break
if __name__ == '__main__':
if args.channels == 3:
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
elif args.channels == 1:
normalize = transforms.Normalize(mean=[0.5], std=[0.5])
# create model
avg_pool_size = (args.avg_pooling_height, args.avg_pooling_width)
if args.simple_resnet:
model = resnet18(num_classes=args.num_classes,
channels=args.channels,
avg_pooling_size=avg_pool_size)
else:
model = densenet121(num_classes=args.num_classes,
channels=args.channels,
avg_pooling_size=avg_pool_size)
train_transforms = transforms.Compose([transforms.ToTensor(), normalize])
val_transforms = transforms.Compose([transforms.ToTensor(), normalize])
# start main loop
main(args,
model,
pil_loader,
pil_loader,
normalize,
validate_model=validate_model,
train_transforms=train_transforms,
val_transforms=val_transforms)
def main():
# specify device and choose gpu if it's available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Using device:', device)
lookup = dict()
reverselookup = dict()
count = 0
for j in os.listdir('./data/leapGestRecog/00/'):
if not j.startswith('.'): # If running this code locally, this is to
# ensure you aren't reading in hidden folders
lookup[j] = count
reverselookup[count] = j
count = count + 1
print(lookup)
classes = (lookup.keys())
x_data = []
label_data = []
imagecount = 0 # total Image count
for i in range(0, 10): # Loop over the ten top-level folders
for j in os.listdir('./data/leapGestRecog/0' + str(i) + '/'):
if not j.startswith('.'): # Again avoid hidden folders
count = 0 # To tally images of a given gesture
# loop over the images
# read in and convert to greyscale
for k in os.listdir('./data/leapGestRecog/0' + str(i) + '/' + j + '/'):
img = Image.open('./data/leapGestRecog/0' +
str(i) + '/' + j + '/' + k).convert('L')
img = img.resize((320, 120))
arr = np.array(img)
x_data.append(arr)
count = count + 1
y_values = np.full((count, 1), lookup[j])
label_data.append(y_values)
imagecount = imagecount + count
x_data = np.array(x_data, dtype='float32')
label_data = np.array(label_data)
label_data = label_data.reshape(imagecount, 1) # Reshape to be the correct size
# check the shape of train data
print("Total Data shape",x_data.shape)
print("Total labels shape",label_data)
# divide the data into train, validation and test
x_train, x_valid_test, y_train, y_valid_test = train_test_split(x_data, label_data, test_size=0.3)
x_validate, x_test, y_validate, y_test = train_test_split(x_valid_test, y_valid_test, test_size=0.5)
# check the shape of train data
print("Train Data shape=",x_train.shape)
print("Train Labels shape=",y_train.shape)
# check the shape of validation data
print("Validation data shape=",x_validate.shape)
print("Validation labels shape=",y_validate.shape)
# check the shape of test data
print("Test data shape=",x_test.shape)
print("Test data label=",y_test.shape)
batch_size_list = [64]
results = {}
resultsDF = []
f1DF = []
for BATCH_SIZE in batch_size_list:
# specify the transformation
transform = transforms.Compose(
[transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))])
# perform the pre-processing on train data
data_train = DatasetProcessing(x_train, y_train, transform)
# load the train data
train_loader = torch.utils.data.DataLoader(data_train, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)
# specify the transformation
transform = transforms.Compose(
[transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))])
data_validate = DatasetProcessing(x_validate, y_validate, transform)
validate_loader = torch.utils.data.DataLoader(data_validate, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)
# specify the transformation
transform = transforms.Compose(
[transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))])
data_test = DatasetProcessing(x_test, y_test, transform)
test_loader = torch.utils.data.DataLoader(data_test, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)
# specify the number of epochs and learning rate
learning_rate_list = [0.001]
optimizer_functions_list = ['Adam']
for LEARNING_RATE in learning_rate_list:
for OPTIMIZER in optimizer_functions_list:
# create instance of model
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
if OPTIMIZER == 'SGD':
optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE)
elif OPTIMIZER == 'ASGD':
optimizer = torch.optim.ASGD(model.parameters(), lr=LEARNING_RATE)
elif OPTIMIZER == 'Adam':
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
elif OPTIMIZER == 'Adagrad':
optimizer = torch.optim.Adagrad(model.parameters(), lr=LEARNING_RATE)
elif OPTIMIZER == 'Adadelta':
optimizer = torch.optim.Adadelta(model.parameters(), lr=LEARNING_RATE)
elif OPTIMIZER == 'RMSProp':
optimizer = torch.optim.RMSprop(model.parameters(), lr=LEARNING_RATE)
number_epochs_list = [2]
for NUM_EPOCHS in number_epochs_list:
training_loss = []
validation_loss = []
mean_training_loss = []
mean_validation_loss = []
for epoch in range(1, NUM_EPOCHS + 1):
start = timeit.default_timer()
train_loss = train(model, device, train_loader, optimizer, criterion, epoch)
stop = timeit.default_timer()
val_loss = validate(model, device, validate_loader, criterion, epoch)
training_loss = training_loss + train_loss
validation_loss = validation_loss + val_loss
mean_training_loss = mean_training_loss + [np.mean(train_loss)]
mean_validation_loss = mean_validation_loss + [np.mean(val_loss)]
accuracy, testing_loss, cm, cm1 = test(model, device, test_loader, criterion, epoch)
fig1 = plt.figure(figsize=(12, 8))
plt.plot(training_loss)
plt.plot(validation_loss)
plt.xlabel("batch samples", fontsize=20)
plt.ylabel("loss", fontsize=20)
plt.legend(['training loss', 'validation loss'], loc='upper right', fontsize=20)
plt.title("batch-wise training and validation loss for batch size=" + str(BATCH_SIZE)
+ ", lr=" + str(LEARNING_RATE) +
", optimizer=" + str(OPTIMIZER) + ", num_epochs=" + str(NUM_EPOCHS), fontsize=15)
# plt.show()
fig1.savefig("batchwise_training_validation_loss_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) +
"_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png")
fig2 = plt.figure(figsize=(12, 8))
plt.plot(mean_training_loss)
plt.plot(mean_validation_loss)
plt.xlabel("epochs", fontsize=20)
plt.ylabel("mean loss", fontsize=20)
plt.legend(['mean training loss', 'mean validation loss'], loc='upper right', fontsize=20)
# plt.show()
plt.title("epoch-wise mean training and validation loss for batch size=" + str(BATCH_SIZE) +
", lr=" + str(LEARNING_RATE) +
", optimizer=" + str(OPTIMIZER) + ", num_epochs=" + str(NUM_EPOCHS), fontsize=15)
fig2.savefig(
"epochwise_mean_training_validation_loss_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) +
"_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png")
fig3 = plt.figure(figsize=(12, 8))
plt.plot(training_loss)
plt.xlabel("batch samples", fontsize=20)
plt.ylabel("loss", fontsize=20)
plt.legend(['testing loss'], loc='upper right', fontsize=20)
plt.title("testing loss for batch size=" + str(BATCH_SIZE)
+ ", lr=" + str(LEARNING_RATE) +
", optimizer=" + str(OPTIMIZER) + ", num_epochs=" + str(NUM_EPOCHS), fontsize=15)
# plt.show()
fig3.savefig("testing_loss_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) +
"_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png")
fig4, ax = plot_confusion_matrix(conf_mat=cm)
#plt.show()
print(type(cm1.F1))
print("f1",cm1.F1)
fig4.savefig("confusion_matrix_" + str(BATCH_SIZE) + "_" + str(LEARNING_RATE) +
"_" + str(OPTIMIZER) + "_" + str(NUM_EPOCHS) + ".png")
results[(BATCH_SIZE, LEARNING_RATE, OPTIMIZER, NUM_EPOCHS)] = (
round(stop - start, 2), round(accuracy, 2))
print(results)
pdf = matplotlib.backends.backend_pdf.PdfPages("output.pdf")
for fig in range(1, plt.gcf().number + 1): ## will open an empty extra figure
pdf.savefig(fig)
pdf.close()
df = pd.DataFrame(list(results.items()))
df_parameters = pd.DataFrame(df.iloc[:, 0].tolist(),
columns=['batch_size', 'learning_rate', 'optimizer_method', 'num_epochs'])
df_obs = pd.DataFrame(df.iloc[:, 1].tolist(), columns=['time', 'accuracy'])
df_final = pd.concat([df_parameters, df_obs], axis=1)
df_final.to_csv("df_final.csv")
df_f1 = pd.DataFrame(list(cm1.F1.items()),columns=['labels', 'f1_score'])
resultsDF.append(df_final)
f1DF.append(df_f1)
df_results = pd.concat(resultsDF)
df_results = df_results.drop_duplicates(keep='first', inplace=False)
df_results.to_csv("results.csv")
df_f1_results = pd.concat(f1DF)
df_f1_results.to_csv("f1_score_results.csv")
torch.manual_seed(42)
USE_CUDA = torch.cuda.is_available()
DEVICE = torch.device("cuda" if USE_CUDA else "cpu")
EPOCHS = 40
BATCH_SIZE = 64
# ## 데이터셋 불러오기
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=BATCH_SIZE,
shuffle=True)
test_loader = torch.utils.data.DataLoader(datasets.MNIST(
'./.data',
train=False,
transform=transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])),
batch_size=BATCH_SIZE,
shuffle=True)
# ## 뉴럴넷으로 Fashion MNIST 학습하기
def __init__(self, config, args_data):
self.root_dir = config.root_dir
self.batch_size = config.batch_size
self.load_epoch = config.load_epoch
self.epoch_max = config.epoch_max
self.phase = config.phase
self.gpu_id = config.gpu_id
self.used_device = torch.device("cuda:{}".format(self.gpu_id))
self.dataset = config.dataset
self.test_id = config.test_id
self.model_save = config.model_save
self.G_type = config.G_type
self.view = config.view
self.input_size = config.input_size
self.joint_num = config.joint_num
self.G_lr = config.G_lr
self.G_step_size = config.G_step_size
self.G_opt_type = config.G_opt_type
self.scheduler_type = config.scheduler_type
# warm-up
self.lr_lambda = lambda epoch: (0.33**max(
0, 2 - epoch // 2)) if epoch < 4 else np.exp(-0.04 * epoch)
self.data_rt = self.root_dir + "/" + self.dataset
if self.model_save == '':
self.model_save = self.G_type + '_' + 'G' + str(
self.G_opt_type) + str(
self.G_lr) + "_" + self.scheduler_type + 'batch' + str(
self.batch_size)
self.model_dir = './model/' + self.dataset + '/' + self.model_save
self.cur_epochs = self.load_epoch
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
if not os.path.exists(self.model_dir + '/img'):
os.mkdir(self.model_dir + '/img')
# use GPU
self.cuda = torch.cuda.is_available()
gpu_num = 1
torch.cuda.set_device(self.gpu_id)
cudnn.benchmark = True
# set network
if 'basic' in self.G_type:
self.G = resnet18(pretrained=False, num_classes=3 * self.joint_num)
elif 'resnet_mur' in self.G_type:
self.G = resnet50(num_classes=self.joint_num * 3)
self.G.apply(weights_init_resnet)
if gpu_num > 1:
self.G = nn.DataParallel(self.G).cuda()
else:
self.G = self.G.cuda()
# load data
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%Y/%m/%d %H:%M:%S',
filename=os.path.join(self.model_dir, 'train.log'),
level=logging.INFO)
logging.info('======================================================')
# init loader
if self.phase == 'train':
if self.dataset == 'nyu':
self.trainData = NyuHandPoseDataset(
args_data.nyu_data_basepath,
train=True,
cropSize=args_data.in_crop_size,
doJitterCom=args_data.do_jitter_com,
sigmaCom=args_data.sigma_com,
doAddWhiteNoise=args_data.do_add_white_noise,
sigmaNoise=args_data.sigma_noise,
unlabeledSampleIds=None,
transform=transforms.ToTensor(),
useCache=args_data.use_pickled_cache,
cacheDir=args_data.nyu_data_basepath_pickled,
annoType=args_data.anno_type,
camIdsReal=[1],
camIdsSynth=[],
cropSize3D=args_data.crop_size_3d_tuple,
args_data=args_data)
self.testData = NyuHandPoseDataset(
args_data.nyu_data_basepath,
train=False,
cropSize=args_data.in_crop_size,
doJitterCom=args_data.do_jitter_com,
sigmaCom=args_data.sigma_com,
doAddWhiteNoise=args_data.do_add_white_noise,
sigmaNoise=args_data.sigma_noise,
unlabeledSampleIds=None,
transform=transforms.ToTensor(),
useCache=args_data.use_pickled_cache,
cacheDir=args_data.nyu_data_basepath_pickled,
annoType=args_data.anno_type,
camIdsReal=[1],
camIdsSynth=[],
cropSize3D=args_data.crop_size_3d_tuple,
args_data=args_data)
self.trainLoader = DataLoader(self.trainData,
batch_size=self.batch_size,
shuffle=True,
num_workers=8)
self.testLoader = DataLoader(self.testData,
batch_size=self.batch_size,
shuffle=False,
num_workers=8)
else:
if self.dataset == 'nyu':
self.testData = NyuHandPoseDataset(
args_data.nyu_data_basepath,
train=False,
cropSize=args_data.in_crop_size,
doJitterCom=args_data.do_jitter_com,
sigmaCom=args_data.sigma_com,
doAddWhiteNoise=args_data.do_add_white_noise,
sigmaNoise=args_data.sigma_noise,
unlabeledSampleIds=None,
transform=transforms.ToTensor(),
useCache=args_data.use_pickled_cache,
cacheDir=args_data.nyu_data_basepath_pickled,
annoType=args_data.anno_type,
camIdsReal=[1],
camIdsSynth=[],
cropSize3D=args_data.crop_size_3d_tuple,
args_data=args_data)
self.testLoader = DataLoader(self.testData,
batch_size=self.batch_size,
shuffle=False,
num_workers=8)
if self.G_opt_type == 'sgd':
self.G_opt = optim.SGD(self.G.parameters(),
lr=self.G_lr,
momentum=0.9,
weight_decay=1e-4)
elif self.G_opt_type == 'adam':
self.G_opt = optim.Adam(self.G.parameters(), lr=self.G_lr)
elif self.G_opt_type == 'rmsprop':
self.G_opt = optim.RMSprop(self.G.parameters(), lr=self.G_lr)
if self.scheduler_type == 'step':
self.G_scheduler = lr_scheduler.StepLR(self.G_opt,
step_size=self.G_step_size,
gamma=0.1)
elif self.scheduler_type == 'SGDR':
self.G_scheduler = optim.lr_scheduler.CosineAnnealingLR(
self.G_opt, int(float(len(self.trainData)) / self.batch_size))
elif self.scheduler_type == 'warm-up':
self.G_scheduler = optim.lr_scheduler.LambdaLR(
self.G_opt, lr_lambda=self.lr_lambda)
# load model
if self.load_epoch != 0:
self.G.load_state_dict(
torch.load(os.path.join(self.model_dir + '/latest_G' +
str(self.load_epoch) + '.pth'),
map_location=lambda storage, loc: storage))
self.loss_list_name = []
self.loss_list = []
self.error_list = []
#%%
import torchvision
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import MnistCNN
# %%
#download MNIST DATA
train_set = MNIST('./', train=True, transform=transforms.Compose([transforms.ToTensor()]),download=True)
test_set = MNIST('./', train=False, transform=transforms.Compose([transforms.ToTensor()]),download=True)
# %%
#display a sample
plt.imshow(train_set[0][0].squeeze(), cmap='gray')
# %%
#load data with batch size 100
train_loader = DataLoader(train_set, batch_size=100)
test_loader = DataLoader(test_set, batch_size=100)
# %%
#setting of MNISTCNN
model = MnistCNN.MnistCNN()
error = nn.CrossEntropyLoss()
learning_rate = 0.001
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
iterations_list = []
def reset(self):
self.val = 0
self.avg = 0
self.numerator = 0
self.denominator = 0
def update(self, val, n=1):
self.val = val
self.numerator += val
self.denominator += n
self.avg = float(self.numerator) / float(self.denominator)
if __name__ == '__main__':
# Mean and std used to normalize cifar10.
transform_train = transforms.Compose([transforms.ToTensor()])
train_dir = './data/'
trainset = datasets.ImageFolder(train_dir, transform=transform_train)
#trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform_train)
mean, std = get_mean_and_std(trainset)
print(mean) # output: (0.4914, 0.4822, 0.4465)
print(std) # output: (0.2023, 0.1994, 0.2010)
#city_function: #tensor([0.0047, 0.0054, 0.0062])
#tensor([0.0018, 0.0016, 0.0014])
# Mean and std used to normalize cifar100.
transform_train = transforms.Compose([transforms.ToTensor()])
trainset = torchvision.datasets.CIFAR100(root='./data',
train=True,
download=False,
transform=transform_train)
discriminator = Discriminator()
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# Configure data loader
os.makedirs("../../data/mnist", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
datasets.MNIST(
"../../data/mnist",
train=True,
download=True,
transform=transforms.Compose(
[transforms.Resize(opt.img_size), transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])]
),
),
batch_size=opt.batch_size,
shuffle=True,
)
# Optimizers
optimizer_G = torch.optim.Adam(
generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(
discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
def train(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 0, 'pin_memory': False}
transform = transforms.Compose([
transforms.Resize((
args.image_size, args.image_size)),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))])
train_dataset = dataset.CustomImageDataset(
args.dataset,
transform=transform,
img_size=args.image_size)
train_loader = DataLoader(train_dataset, batch_size=args.batch_size, **kwargs)
transformer = TransformerNet(args.pad_type)
transformer = transformer.train()
optimizer = torch.optim.Adam(transformer.parameters(), args.lr)
mse_loss = torch.nn.MSELoss()
#print(transformer)
vgg = Vgg16()
vgg.load_state_dict(torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight")))
vgg.eval()
transformer = transformer.cuda()
vgg = vgg.cuda()
style = utils.tensor_load_resize(args.style_image, args.style_size)
style = style.unsqueeze(0)
print("=> Style image size: " + str(style.size()))
#(1, H, W, C)
style = utils.preprocess_batch(style).cuda()
utils.tensor_save_bgrimage(style[0].detach(), os.path.join(args.save_model_dir, 'train_style.jpg'), True)
style = utils.subtract_imagenet_mean_batch(style)
features_style = vgg(style)
gram_style = [utils.gram_matrix(y).detach() for y in features_style]
for e in range(args.epochs):
train_loader.dataset.reset()
agg_content_loss = 0.
agg_style_loss = 0.
iters = 0
for batch_id, (x, _) in enumerate(train_loader):
if x.size(0) != args.batch_size:
print("=> Skip incomplete batch")
continue
iters += 1
optimizer.zero_grad()
x = utils.preprocess_batch(x).cuda()
y = transformer(x)
if (batch_id + 1) % 1000 == 0:
idx = (batch_id + 1) // 1000
utils.tensor_save_bgrimage(y.data[0],
os.path.join(args.save_model_dir, "out_%d.png" % idx),
True)
utils.tensor_save_bgrimage(x.data[0],
os.path.join(args.save_model_dir, "in_%d.png" % idx),
True)
xc = x.detach()
y = utils.subtract_imagenet_mean_batch(y)
xc = utils.subtract_imagenet_mean_batch(xc)
features_y = vgg(y)
features_xc = vgg(center_crop(xc, y.size(2), y.size(3)))
#content target
f_xc_c = features_xc[2].detach()
# content
f_c = features_y[2]
content_loss = args.content_weight * mse_loss(f_c, f_xc_c)
style_loss = 0.
for m in range(len(features_y)):
gram_s = gram_style[m]
gram_y = utils.gram_matrix(features_y[m])
batch_style_loss = 0
for n in range(gram_y.shape[0]):
batch_style_loss += args.style_weight * mse_loss(gram_y[n], gram_s[0])
style_loss += batch_style_loss / gram_y.shape[0]
total_loss = content_loss + style_loss
total_loss.backward()
optimizer.step()
agg_content_loss += content_loss.data
agg_style_loss += style_loss.data
mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format(
time.ctime(), e + 1, batch_id + 1, len(train_loader),
agg_content_loss / iters,
agg_style_loss / iters,
(agg_content_loss + agg_style_loss) / iters
)
print(mesg)
agg_content_loss = agg_style_loss = 0.0
iters = 0
# save model
save_model_filename = "epoch_" + str(e) + "_" + 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():
global args, best_prec1
args = parser.parse_args()
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))
if args.arch.startswith('mobilenetv1'):
model = MobileNetV1()
elif args.arch.startswith('mobilenetv2'):
model = MobileNetV2()
else:
model = models.__dict__[args.arch]()
print(model)
if not args.distributed:
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()
else:
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
if os.path.isfile(args.evaluate):
print("=> loading model '{}'".format(args.evaluate))
model.load_state_dict(torch.load(args.evaluate))
else:
print("=> no model found at '{}'".format(args.evaluate))
# 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
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):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer' : optimizer.state_dict(),
}, is_best)
def __init__(self, root_dir, set, tencrops=False, SemRGB=False):
"""
Initialize the dataset. Read scene categories, get number of classes, create filename and ground-truth labels
lists, create ImAug and PyTorch transformations
:param root_dir: Root directory to the dataset
:param set: Dataset set: Training or Validation
"""
# Extract main path and set (Train or Val).
self.image_dir = root_dir
self.set = set
# Set boolean variable of ten crops for validation
self.TenCrop = tencrops
self.SemRGB = SemRGB
if SemRGB:
self.RGB = "_RGB"
else:
self.RGB = ""
# Decode dataset scene categories
self.classes = list()
class_file_name = os.path.join(root_dir, "categories_places365.txt")
with open(class_file_name) as class_file:
for line in class_file:
line = line.split()[0]
split_indices = [i for i, letter in enumerate(line) if letter == '/']
# Check if there a class with a subclass inside (outdoor, indoor)
if len(split_indices) > 2:
line = line[:split_indices[2]] + '-' + line[split_indices[2]+1:]
self.classes.append(line[split_indices[1] + 1:])
# Get number of classes
self.nclasses = self.classes.__len__()
# Create list for filenames and scene ground-truth labels
self.filenames = list()
self.labels = list()
self.labelsindex = list()
self.auxiliarnames = list()
filenames_file = os.path.join(root_dir, (set + ".txt"))
# Fill filenames list and ground-truth labels list
with open(filenames_file) as class_file:
for line in class_file:
# if random.random() > 0.6 or (self.set is "val"):
split_indices = [i for i, letter in enumerate(line) if letter == '/']
# Obtain name and label
name = line[split_indices[1] + 1:-1]
label = line[split_indices[0] + 1: split_indices[1]]
self.filenames.append(name)
self.labels.append(label)
self.labelsindex.append(self.classes.index(label))
str2 = "\n"
indx2 = line.find(str2)
self.auxiliarnames.append(line[0:indx2])
# Control Statements for data loading
assert len(self.filenames) == len(self.labels)
# ----------------------------- #
# ImAug Transformations #
# ----------------------------- #
# Transformations for train set
self.seq = iaa.Sequential([
# Small gaussian blur with random sigma between 0 and 0.5.
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0, 0.5))),
# Strengthen or weaken the contrast in each image.
iaa.ContrastNormalization((0.75, 1.5)),
# Add gaussian noise.
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
# Make some images brighter and some darker.
iaa.Multiply((0.8, 1.2), per_channel=0.2),
], random_order=True) # apply augmenters in random order
self.seq_sem = iaa.Sequential([
iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels
], random_order=True)
# ----------------------------- #
# Pytorch Transformations #
# ----------------------------- #
self.mean = [0.485, 0.456, 0.406]
self.STD = [0.229, 0.224, 0.225]
self.outputSize = 224
# Train Set Transformation
self.train_transforms_img = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(self.mean, self.STD)
])
self.train_transforms_scores = transforms.ToTensor()
if not SemRGB:
self.train_transforms_sem = transforms.Lambda(
lambda sem: torch.unsqueeze(torch.from_numpy(np.asarray(sem) + 1).long(), 0))
else:
self.train_transforms_sem = transforms.Lambda(
lambda sem: torch.from_numpy(np.asarray(sem) + 1).long().permute(2, 0, 1))
# Transformations for validation set
if not self.TenCrop:
self.val_transforms_img = transforms.Compose([
transforms.CenterCrop(self.outputSize),
transforms.ToTensor(),
transforms.Normalize(self.mean, self.STD)
])
if not SemRGB:
self.val_transforms_sem = transforms.Compose([
transforms.CenterCrop(self.outputSize),
transforms.Lambda(lambda sem: torch.unsqueeze(torch.from_numpy(np.asarray(sem) + 1).long(), 0))
])
self.val_transforms_scores = transforms.Compose([
transforms.CenterCrop(self.outputSize),
transforms.ToTensor(),
])
else:
self.val_transforms_sem = transforms.Compose([
transforms.CenterCrop(self.outputSize),
transforms.Lambda(lambda sem: torch.from_numpy(np.asarray(sem) + 1).long().permute(2, 0, 1))
])
self.val_transforms_scores = transforms.Compose([
transforms.CenterCrop(self.outputSize),
transforms.ToTensor(),
])
else:
self.val_transforms_img = transforms.Compose([
transforms.TenCrop(self.outputSize),
transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])),
transforms.Lambda(
lambda crops: torch.stack([transforms.Normalize(self.mean, self.STD)(crop) for crop in crops])),
])
if not SemRGB:
self.val_transforms_sem = transforms.Compose([
transforms.TenCrop(self.outputSize),
transforms.Lambda(lambda crops: torch.stack(
[torch.unsqueeze(torch.from_numpy(np.asarray(crop) + 1).long(), 0) for crop in crops]))
])
self.val_transforms_scores = transforms.Compose([
transforms.TenCrop(self.outputSize),
transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])),
])
else:
self.val_transforms_sem = transforms.Compose([
transforms.TenCrop(self.outputSize),
transforms.Lambda(lambda crops: torch.stack(
[torch.from_numpy(np.asarray(crop) + 1).long().permute(2, 0, 1) for crop in crops])),
])
self.val_transforms_scores = transforms.Compose([
transforms.TenCrop(self.outputSize),
transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])),
])
import torch
import os
import cv2
from torchvision import transforms
class IconsDataset(torch.utils.data.Dataset):
def __init__(self, root_dir, transform=None, imread_mode=cv2.IMREAD_COLOR):
self.root_dir = root_dir
self.transform = transform
self.filenames = os.listdir(root_dir)
self.mode = imread_mode
def __len__(self):
return len(self.filenames)
def __getitem__(self, idx):
filename = os.path.join(self.root_dir, self.filenames[idx])
image = cv2.imread(filename, self.mode)
if self.transform:
image = self.transform(image)
return image
basic_img_transform = transforms.Compose([transforms.ToTensor()])
def demo(data, save, depth=100, growth_rate=12, efficient=True, valid_size=5000,
n_epochs=300, batch_size=64, seed=None):
"""
A demo to show off training of efficient DenseNets.
Trains and evaluates a DenseNet-BC on CIFAR-10.
Args:
data (str) - path to directory where data should be loaded from/downloaded
(default $DATA_DIR)
save (str) - path to save the model to (default /tmp)
depth (int) - depth of the network (number of convolution layers) (default 40)
growth_rate (int) - number of features added per DenseNet layer (default 12)
efficient (bool) - use the memory efficient implementation? (default True)
valid_size (int) - size of validation set
n_epochs (int) - number of epochs for training (default 300)
batch_size (int) - size of minibatch (default 256)
seed (int) - manually set the random seed (default None)
"""
# Get densenet configuration
if (depth - 4) % 3:
raise Exception('Invalid depth')
block_config = [(depth - 4) // 6 for _ in range(3)]
# Data transforms
mean = [0.5071, 0.4867, 0.4408]
stdv = [0.2675, 0.2565, 0.2761]
train_transforms = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
test_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
# Datasets
train_set = datasets.CIFAR10(data, train=True, transform=train_transforms, download=True)
test_set = datasets.CIFAR10(data, train=False, transform=test_transforms, download=False)
# Models
model = DenseNet(
growth_rate=growth_rate,
block_config=block_config,
num_classes=10,
small_inputs=True,
efficient=efficient,
)
print(model)
# Make save directory
if not os.path.exists(save):
os.makedirs(save)
if not os.path.isdir(save):
raise Exception('%s is not a dir' % save)
# Train the model
train(model=model, train_set=train_set, test_set=test_set, save=save,
valid_size=valid_size, n_epochs=n_epochs, batch_size=batch_size, seed=seed)
print('Done!')
tcg = torch.nn.DataParallel(tcg,
device_ids=[0, 1, 2, 3, 4, 5, 6,
7]).cuda()
log_format = '%(message)s'
logging.basicConfig(stream=sys.stdout,
level=logging.INFO,
format=log_format)
fh = logging.FileHandler(os.path.join(log_dir, 'log.txt'))
fh.setFormatter(logging.Formatter(log_format))
logging.getLogger().addHandler(fh)
train_transforms = transforms.Compose([
transforms.Resize((256, 256)), # smaller edge to 128
transforms.RandomCrop(224),
#transforms.RandomHorizontalFlip(0.5),
transforms.ToTensor()
])
color_jitter = transforms.ColorJitter(brightness=0.8,
contrast=0.8,
saturation=0.8,
hue=0.2)
color_jitter = transforms.RandomApply([color_jitter], p=0.8)
#train_dataset = UCF101VCOPDataset_color('data/ucf101', args.cl, args.it, args.tl, True, train_transforms,color_jitter_=color_jitter)
train_dataset = K400VCOPDataset_train('data/K400', args.cl, args.it,
args.tl, True, train_transforms)
val_dataset = K400VCOPDataset_val('data/K400', args.cl, args.it,
args.tl, True, train_transforms)
# split val for 800 videos
#train_dataset, val_dataset = random_split(train_dataset,(len(train_dataset)-800, 800))
logging.info('TRAIN video number: {}, VAL video number: {}.'.format(
len(train_dataset), len(val_dataset)))
def main():
cut_list = [1, 2, 3]
for i in range(len(cut_list)):
if i < 2:
continue
for j in range(cut_list[i] * cut_list[i]):
if j < 7:
continue
args.best_test_precision = 0
args.best_epoch = 0
checkpoint_save_dir = '/home/njuciairs/rainkeeper/Projects/PycharmProjects/Multi-granularity-integrations3/checkpoint0/' + str(
cut_list[i] * cut_list[i]) + '_' + str(j)
if not os.path.exists(checkpoint_save_dir):
os.makedirs(checkpoint_save_dir)
terminal_log_file = os.path.join(checkpoint_save_dir,
'terminal_log.txt')
terminal_file = open(terminal_log_file, 'a')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
trainset = ImageDataset(image_dir=os.path.join(
args.dataset_path, 'train_image',
str(cut_list[i] * cut_list[i]) + '_' + str(j)),
transform=transforms.Compose([
transforms.ToTensor(),
normalize,
]),
train=True)
train_loader = torch.utils.data.DataLoader(
trainset,
shuffle=True,
batch_size=args.batch_size,
num_workers=args.workers)
valset = ImageDataset(image_dir=os.path.join(
args.dataset_path, 'test_image',
str(cut_list[i] * cut_list[i]) + '_' + str(j)),
transform=transforms.Compose([
transforms.ToTensor(),
normalize,
]),
train=False)
val_loader = torch.utils.data.DataLoader(
valset,
shuffle=False,
batch_size=args.batch_size,
num_workers=args.workers)
args.device = torch.device(
args.gpu_id if torch.cuda.is_available() else "cpu")
torch.cuda.manual_seed(args.seed)
model = vggnet(load_weights=True)
model.to(args.device)
criterion = nn.CrossEntropyLoss().to(args.device)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.pre:
if os.path.isfile(args.pre):
print("=> loading checkpoint '{}'".format(args.pre))
checkpoint = torch.load(args.pre)
args.start_epoch = checkpoint['epoch']
args.best_test_precision = checkpoint[
'best_test_precision']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.pre, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.pre))
for epoch in range(args.start_epoch,
args.start_epoch + args.epochs):
train_precision = train(train_loader, model, criterion,
optimizer, epoch, terminal_file)
test_correct, test_total = validate(val_loader, model,
criterion, terminal_file)
test_precision = float(test_correct) / test_total
is_best = test_precision > args.best_test_precision
if is_best:
args.best_test_precision = test_precision
args.best_epoch = epoch
print(
'Epoch:%d, test correct:%d, test total:%d, test precsion:%.6f, current_best_test_acc:%.6f, current_best_acc_epoch:%d'
% (epoch, test_correct, test_total, test_precision,
args.best_test_precision, args.best_epoch))
print(
'Epoch:%d, test correct:%d, test total:%d, test precsion:%.6f, current_best_test_acc:%.6f, current_best_acc_epoch:%d'
% (epoch, test_correct, test_total, test_precision,
args.best_test_precision, args.best_epoch),
file=terminal_file)
if is_best:
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.pre,
'state_dict': model.state_dict(),
'best_test_precision': args.best_test_precision,
'optimizer': optimizer.state_dict()
}, checkpoint_save_dir, epoch)
if train_precision > 0.98:
print('best_test_precision:%.6f' %
args.best_test_precision)
print('best_test_precision:%.6f' %
args.best_test_precision,
file=terminal_file)
break
from torchsummary import summary
# device configuration
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# hyper parameters
EPOCHS = 20
batch_size = 64
learning_rate = 0.001
classes = 10
# Image preprocessing modules
transform = transforms.Compose([
transforms.Pad(4),
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32),
transforms.ToTensor(),
])
# cifar10 32*32*3
train_dataset = torchvision.datasets.CIFAR10(root='./cifar10_data',
train=True,
transform=transform,
download=True)
test_dataset = torchvision.datasets.CIFAR10(root='./cifar10_data',
train=False,
transform=transforms.ToTensor())
trainloader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
testloader = torch.utils.data.DataLoader(dataset=test_dataset,
def load_image(path, gpu=False):
img = Image.open(path)
img_tensor: torch.Tensor = transforms.ToTensor()(img)
if gpu:
img_tensor = img_tensor.cuda()
return img_tensor.reshape(1, *img_tensor.shape)
