def dataloader(dataset, batch_size, cuda, conditional=-1, im_size=64):
if dataset == 'mnist':
data = datasets.MNIST(dataFolder + 'MNIST',
train=True,
download=True,
transform=transforms.Compose(
[AddUniformNoise(),
ToTensor()]))
test_data = datasets.MNIST(dataFolder + 'MNIST',
train=False,
download=True,
transform=transforms.Compose(
[AddUniformNoise(),
ToTensor()]))
if conditional >= 0 and conditional <= 9:
idx = data.targets == conditional
data.data = data.data[idx, :]
data.targets = data.targets[idx]
nTot = torch.sum(idx).item()
nTrain = int((5.0 / 6.0) * nTot)
nVal = nTot - nTrain
train_data, valid_data = torch.utils.data.random_split(
data, [nTrain, nVal])
idx = test_data.targets == conditional
test_data.data = test_data.data[idx, :]
test_data.targets = test_data.targets[idx]
else:
train_data, valid_data = torch.utils.data.random_split(
data, [50000, 10000])
else:
print('what network ?', dataset)
sys.exit(1)
#load data
kwargs = {'num_workers': 0, 'pin_memory': True} if cuda > -1 else {}
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=batch_size,
shuffle=True,
**kwargs)
valid_loader = torch.utils.data.DataLoader(valid_data,
batch_size=batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size,
shuffle=True,
**kwargs)
return train_loader, valid_loader, test_loader
def test_Yolov1Loss():
v1_loss = Yolov1Loss(weight_coord=1.,
weight_noobject=1.,
num_boxes=2,
num_classes=20,
grid_size=(7, 7))
print(v1_loss)
img_size, grid_size = (448, 448), (7, 7)
rs_ = Resize(size=img_size)
tt = ToTensor()
gco = ToGridCellOffset(img_size=img_size, grid_size=grid_size)
img_trans = Compose([rs_, tt])
box_trans = Compose([rs_, gco])
voc = VOCDataset(config,
phase='train',
img_transform=img_trans,
box_transform=box_trans)
img, boxes = voc[4]
# print(img.size(), type(boxes), boxes[0].size(), boxes[1].size())
img = img.unsqueeze(0)
grid = boxes[0].unsqueeze(0)
box = boxes[1].unsqueeze(0)
# print(img.size(), type(boxes), grid.size(), box.size())
net = Yolo(num_boxes=3, num_classes=20, grid_size=grid_size)
# net = net.cuda()
# img = img.cuda()
out = net(img)
# print(out.size())
# print(out.view(out.size(0), grid_size[0], grid_size[1], -1).size())
loss = v1_loss(out, (grid, box))
print(loss)
def test_transform():
rhf = RandomHorizontalFlip(p=0.5)
rc = RandomCrop(ratio=0.8)
cj = ColorJitter(brightness=0.4, saturation=0.4, hue=0.4)
rb = RandomBlur(p=0.5, r=(2, 3))
rs = RandomShift(p=0.5, ratio=0.1)
rs_ = Resize(size=(448, 448))
tt = ToTensor()
img_trans = Compose([rhf, rc, cj, rb, rs, rs_, tt])
box_trans = Compose([rhf, rc, rs, rs_, tt])
voc = VOCDataset(config,
phase='train',
img_transform=img_trans,
box_transform=box_trans)
img, boxes = voc[4]
print(img.size(), type(boxes), boxes, boxes.size())
img = img.permute(1, 2, 0)
img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
print(img.shape)
img_h, img_w = img.shape[:2]
for box in list(boxes):
class_idx, cx, cy, w, h = int(box[0]), float(box[1]), float(
box[2]), float(box[3]), float(box[4])
cx, cy, w, h = cx * img_w, cy * img_h, w * img_w, h * img_h
pt1, pt2 = (int(cx - w / 2), int(cy - h / 2)), (int(cx + w / 2),
int(cy + h / 2))
cv2.rectangle(img, pt1, pt2, (0, 255, 0), 2)
cv2.imshow('transform', img)
cv2.waitKey(0)
def test_ToGridCellOffset():
rs_ = Resize(size=(448, 448))
tt = ToTensor()
gco = ToGridCellOffset(img_size=(448, 448), grid_size=(7, 7))
img_trans = Compose([rs_, tt])
box_trans = Compose([rs_, gco])
voc = VOCDataset(config,
phase='train',
img_transform=img_trans,
box_transform=box_trans)
img, boxes = voc[4]
print(img.size(), type(boxes), len(boxes))
print(boxes[0].size(), boxes[1].size())
print(boxes[0])
print(boxes[1])
img = img.permute(1, 2, 0)
img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
for box in boxes[1]:
i, j, _, o_x, o_y, w, h = int(box[0]), int(box[1]), int(box[2]), float(
box[3]), float(box[4]), float(box[5]), float(box[6])
w, h = w * 448, h * 448
x, y = (i + o_x) * (448 / 7.) - w / 2, (j + o_y) * (448 / 7.) - h / 2
pt1 = (int(x), int(y))
pt2 = (int(x + w), int(y + h))
cv2.rectangle(img, pt1, pt2, (0, 255, 0), 2)
# Center point
cv2.line(img, (int(x + w / 2), int(y + h / 2)),
(int(x + w / 2), int(y + h / 2)), (255, 0, 0), 10)
# Draw grid
inter_ = 448 // 7
for i in range(7):
cv2.line(img, (0, inter_ * i), (448, inter_ * i), (0, 0, 255), 2)
for j in range(7):
cv2.line(img, (inter_ * j, 0), (inter_ * j, 448), (0, 0, 225), 2)
cv2.imshow('transform', img)
cv2.waitKey(0)
def test_ToTensor():
toTensor = ToTensor()
img_trans = Compose([toTensor])
box_trans = Compose([toTensor])
voc = VOCDataset(config,
phase='train',
img_transform=img_trans,
box_transform=box_trans)
img, boxes = voc[4]
print(img.size(), type(boxes), boxes, boxes.size())
img = img.permute(1, 2, 0)
img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
print(img.shape)
img_h, img_w = img.shape[:2]
for box in list(boxes):
class_idx, cx, cy, w, h = int(box[0]), float(box[1]), float(
box[2]), float(box[3]), float(box[4])
cx, cy, w, h = cx * img_w, cy * img_h, w * img_w, h * img_h
pt1, pt2 = (int(cx - w / 2), int(cy - h / 2)), (int(cx + w / 2),
int(cy + h / 2))
cv2.rectangle(img, pt1, pt2, (0, 255, 0), 2)
cv2.imshow('transform', img)
cv2.waitKey(0)
def load_data(dataset="MNIST", batch_size=100, cuda=-1):
if dataset == "MNIST":
data = datasets.MNIST('./MNIST',
train=True,
download=True,
transform=transforms.Compose(
[AddUniformNoise(),
ToTensor()]))
train_data, valid_data = torch.utils.data.random_split(
data, [50000, 10000])
test_data = datasets.MNIST('./MNIST',
train=False,
download=True,
transform=transforms.Compose(
[AddUniformNoise(),
ToTensor()]))
kwargs = {'num_workers': 0, 'pin_memory': True} if cuda > -1 else {}
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=batch_size,
shuffle=True,
drop_last=True,
**kwargs)
valid_loader = torch.utils.data.DataLoader(valid_data,
batch_size=batch_size,
shuffle=True,
drop_last=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size,
shuffle=True,
drop_last=True,
**kwargs)
elif len(dataset) == 6 and dataset[:5] == 'MNIST':
data = datasets.MNIST('./MNIST',
train=True,
download=True,
transform=transforms.Compose(
[AddUniformNoise(),
ToTensor()]))
label = int(dataset[5])
idx = data.train_labels == label
data.targets = data.train_labels[idx]
data.data = data.train_data[idx]
train_data, valid_data = torch.utils.data.random_split(
data, [5000, idx.sum() - 5000])
test_data = datasets.MNIST('./MNIST',
train=False,
download=True,
transform=transforms.Compose(
[AddUniformNoise(),
ToTensor()]))
idx = test_data.test_labels == label
test_data.targets = test_data.test_labels[idx]
test_data.data = test_data.test_data[idx]
kwargs = {'num_workers': 0, 'pin_memory': True} if cuda > -1 else {}
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=batch_size,
shuffle=True,
drop_last=True,
**kwargs)
valid_loader = torch.utils.data.DataLoader(valid_data,
batch_size=batch_size,
shuffle=True,
drop_last=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size,
shuffle=True,
drop_last=True,
**kwargs)
elif dataset == "CIFAR10":
im_dim = 3
im_size = 32 # if args.imagesize is None else args.imagesize
trans = lambda im_size: tforms.Compose(
[tforms.Resize(im_size),
tforms.ToTensor(), add_noise])
train_data = dset.CIFAR10(root="./data",
train=True,
transform=tforms.Compose([
tforms.Resize(im_size),
tforms.RandomHorizontalFlip(),
tforms.ToTensor(),
add_noise,
]),
download=True)
test_data = dset.CIFAR10(root="./data",
train=False,
transform=trans(im_size),
download=True)
kwargs = {'num_workers': 0, 'pin_memory': True} if cuda > -1 else {}
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=batch_size,
drop_last=True,
shuffle=True,
**kwargs)
# WARNING VALID = TEST
valid_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size,
drop_last=True,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size,
drop_last=True,
shuffle=True,
**kwargs)
return train_loader, valid_loader, test_loader
def dataloader(dataset, batch_size, cuda, conditionnal=False):
if dataset == 'CIFAR10':
data = datasets.CIFAR10('./CIFAR10', train=True, download=True,
transform=transforms.Compose([
AddUniformNoise(0.05),
Transpose(),
ToTensor()
]))
data_hflip = datasets.CIFAR10('./CIFAR10', train=True, download=True,
transform=transforms.Compose([
HorizontalFlip(),
AddUniformNoise(0.05),
Transpose(),
ToTensor()
]))
data = torch.utils.data.ConcatDataset([data, data_hflip])
train_data, valid_data = torch.utils.data.random_split(data, [90000, 10000])
test_data = datasets.CIFAR10('./CIFAR10', train=False, download=True,
transform=transforms.Compose([
AddUniformNoise(0.05),
Transpose(),
ToTensor()
]))
elif dataset == 'MNIST':
data = datasets.MNIST('./MNIST', train=True, download=True,
transform=transforms.Compose([
AddUniformNoise(),
ToTensor()
]))
train_data, valid_data = torch.utils.data.random_split(data, [50000, 10000])
test_data = datasets.MNIST('./MNIST', train=False, download=True,
transform=transforms.Compose([
AddUniformNoise(),
ToTensor()
]))
elif len(dataset) == 6 and dataset[:5] == 'MNIST':
data = datasets.MNIST('./MNIST', train=True, download=True,
transform=transforms.Compose([
AddUniformNoise(),
ToTensor()
]))
label = int(dataset[5])
idx = data.train_labels == label
data.train_labels = data.train_labels[idx]
data.train_data = data.train_data[idx]
train_data, valid_data = torch.utils.data.random_split(data, [5000, idx.sum() - 5000])
test_data = datasets.MNIST('./MNIST', train=False, download=True,
transform=transforms.Compose([
AddUniformNoise(),
ToTensor()
]))
idx = test_data.test_labels == label
test_data.test_labels = test_data.test_labels[idx]
test_data.test_data = test_data.test_data[idx]
elif dataset == 'MNIST32':
data = datasets.MNIST('./MNIST', train=True, download=True,
transform=transforms.Compose([
Resize(),
AddUniformNoise(),
ToTensor()
]))
train_data, valid_data = torch.utils.data.random_split(data, [50000, 10000])
test_data = datasets.MNIST('./MNIST', train=False, download=True,
transform=transforms.Compose([
Resize(),
AddUniformNoise(),
ToTensor()
]))
elif len(dataset) == 8 and dataset[:7] == 'MNIST32':
data = datasets.MNIST('./MNIST', train=True, download=True,
transform=transforms.Compose([
Resize(),
AddUniformNoise(),
ToTensor()
]))
label = int(dataset[7])
idx = data.train_labels == label
data.train_labels = data.train_labels[idx]
data.train_data = data.train_data[idx]
train_data, valid_data = torch.utils.data.random_split(data, [5000, idx.sum() - 5000])
test_data = datasets.MNIST('./MNIST', train=False, download=True,
transform=transforms.Compose([
Resize(),
AddUniformNoise(),
ToTensor()
]))
idx = test_data.test_labels == label
test_data.test_labels = test_data.test_labels[idx]
test_data.test_data = test_data.test_data[idx]
else:
print ('what network ?', args.net)
sys.exit(1)
#load data
kwargs = {'num_workers': 0, 'pin_memory': True} if cuda > -1 else {}
train_loader = torch.utils.data.DataLoader(
train_data,
batch_size=batch_size, shuffle=True, **kwargs)
valid_loader = torch.utils.data.DataLoader(
valid_data,
batch_size=batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size, shuffle=True, **kwargs)
return train_loader, valid_loader, test_loader
with open(args.config) as rptr:
config = EasyDict(yaml.load(rptr))
config = parser_config(config)
torch.manual_seed(config.SEED)
torch.cuda.manual_seed(config.SEED)
np.random.seed(config.SEED)
random.seed(config.SEED)
rhf = RandomHorizontalFlip(p=0.5)
rc_ = RandomCrop(ratio=0.75)
cj_ = ColorJitter(brightness=0.4, saturation=0.4, hue=0.4)
rb_ = RandomBlur(p=0.5, r=(2, 3))
rsf = RandomShift(p=0.5, ratio=0.15)
rs_ = Resize(size=(448, 448))
tt_ = ToTensor()
gco = ToGridCellOffset((448, 448), (7, 7))
img_trans = Compose([rhf, rc_, cj_, rb_, rsf, rs_, tt_])
box_trans = Compose([rhf, rc_, rsf, rs_, gco])
dataloader = MakeDataLoader(dataset=VOCDataset(config,
phase='train',
img_transform=img_trans,
box_transform=box_trans),
batch_size=config.TRAIN.BATCH_SIZE,
shuffle=True)
exe = Execute(config=config, dataloader=dataloader)
exe.train()
if __name__ == "__main__":
### Constants ###
BATCH_SIZE = 16
EPOCH_NBR = 40
RESCALE_SIZE = 68
RDM_CROP_SIZE = 64
LEARNING_RATE = 0.01
VALIDATION_SPLIT = 0.2
### Load the dataset ###
print("> DATASET LOADING")
data_transform = transforms.Compose(
[Rescale(RESCALE_SIZE),
RandomCrop(RDM_CROP_SIZE),
ToTensor()])
emotions = [
"neutral",
"happiness",
"surprise",
"sadness",
"anger",
"disgust",
"fear",
"contempt",
]
dataset = FaceEmotionsDataset(
csv_file="./csv/balanced.csv",
root_dir="./img/",