def _get_cutout_train_transform(self):
transform = torchvision.transforms.Compose([
transforms.normalize(self.mean, self.std),
transforms.cutout(self.config['cutout_size'],
self.config['cutout_prob'],
self.config['cutout_inside']),
transforms.to_tensor(),
])
return transform
def __init__(self, root, transforms=None, train=True, test=False):
self.test = test
imgs = [os.path.join(rppt, img) for img in os.listdir(root)]
# test1:data/test1/8973.jpg
# train:data/train/cat.10004.jpg
if self.test:
# 如果为测试集
imgs = sorted(imgs,
key=lambda x: int(x.split('.')[-2].split('/')[-1]))
else:
# 如果为训练集
imgs = sorted(imgs, key=lambda x: int(x.split('.')[-2]))
imgs_num = len(imgs)
if self.test:
self.imgs = imgs
elif train:
# 训练集
self.imgs = imgs[:int(0.7 * imgs_num)]
else:
# 验证集
self.imgs = imgs[int(0.7 * imgs_num):]
if transforms is None:
normalize = T.normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if self.test or not train:
self.transforms = T.Compose([
T.resize(224),
T.CenterCrop(224),
T.ToTensor(), normalize
])
# 训练集
else:
self.transforms = T.Compose([
T.Resize(256),
T.RandomReSizedCrop(224),
T.RandomHorizontalFlip(),
T.ToTensor(), normalize
])
def __getitem__(self, index):
img_path = self.imgs[index]
if self.test:
label = int(self.imgs[index].split('.')[-2].split('/')[-1])
else:
label = 1 if 'dog' in img_path.split('/')[-1] else 0
data = Image.open(img_path)
data = self.transforms(data)
return data, label
def __len__(self):
return len(self.imgs)
def _get_cutout_train_transform(self):
transform = torchvision.transforms.Compose([
torchvision.transforms.RandomCrop(28, padding=4),
torchvision.transforms.RandomHorizontalFlip(),
transforms.normalize(self.mean, self.std),
transforms.cutout(self.config['cutout_size'],
self.config['cutout_prob'],
self.config['cutout_inside']),
transforms.to_tensor(),
])
return transform
def _get_random_erasing_train_transform(self):
transform = torchvision.transforms.Compose([
transforms.normalize(self.mean, self.std),
transforms.random_erasing(
self.config['random_erasing_prob'],
self.config['random_erasing_area_ratio_range'],
self.config['random_erasing_min_aspect_ratio'],
self.config['random_erasing_max_attempt']),
transforms.to_tensor(),
])
return transform
def _get_random_erasing_train_transform(self):
transform = torchvision.transforms.Compose([
torchvision.transforms.Resize((32,32)),
torchvision.transforms.ColorJitter(0.1,0.1,0.1),
# torchvision.transforms.RandomRotation(15),
# RandomAffine(degrees=15,scale=(0.8,1.2),shear=15),
torchvision.transforms.RandomCrop(32, padding=4),
torchvision.transforms.RandomHorizontalFlip(),
transforms.normalize(self.mean, self.std),
transforms.random_erasing(
self.config['random_erasing_prob'],
self.config['random_erasing_area_ratio_range'],
self.config['random_erasing_min_aspect_ratio'],
self.config['random_erasing_max_attempt']),
transforms.to_tensor(),
])
return transform
if __name__ == '__main__':
img_path = glob.glob("..\datasets\street_signs\mchar_train\mchar_train\*.png")
# 最好传入Dataset类的是已经处理好的label，否则容易报错
label_path = "..\datasets\street_signs\mchar_train.json"
label_path=json.load(open(label_path))
label_path=[label_path[x]['label'] for x in label_path]
print(len(img_path),len(label_path))
train_loader = torch.utils.data.DataLoader(
data_set(img_path, label_path,
transforms.Compose([
transforms.resize((64, 128)),
transforms.randomcrop((60, 120)),
transforms.colorjitter(0.3, 0.3, 0.2),
transforms.randomrotation(5),
transforms.totensor(),
transforms.normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])),
batch_size=40,
shuffle=True,
num_workers=10,
)
for inputs,labels in train_loader:
print(inputs)
print(labels)
break
def img_transform_test(crop_size):
normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
return transforms.Compose([transforms.normalize()])
class ToTensor(object): #Transforms from cv2 array data to tensor, always needed to do
def __init__(self):
self.output_size = ""#output_size
def __call__(self):
""
data_transform = transforms.Compose([
Resize(256),
Crop(128),
transforms.ToTensor(), # WHy need to convert tot tensor ?
transforms.normalize() # Why good idea to normalize data
])
# Data Loader
dataset = OttawaDataset(csv_file = "data/ottawa.csv",
root_dir = "data/Ottawa-Dataset/",
transform= data_transform)
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
from torchvision import transforms
import random
from torch.autograd import Variable
#<------------Trainingdatenvorbereiten----------------------->#
#Bilder vereinheitlichen
normalize = transforms.normalize(
#Durchschnitt Normalisierungsvektor um die Belichtung etc. zu vereinheitlichen
mean=[0.485, 0.456, 0.406],
#Normalverteilung, wie weit diese normal vom Durchschnitt abweichen
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
#Größe anpassen
transforms.Resize(780),
#Breite und Höhe gleiche Größe und zentriert
transforms.CenterCrop(780),
#als Tensor
transforms.ToTensor(),
def _get_test_transform(self):
transform = torchvision.transforms.Compose([
transforms.normalize(self.mean, self.std),
transforms.to_tensor(),
])
return transform
def _add_normalization(self):
self._train_transforms.append(
transforms.normalize(self.mean, self.std))
def activation(x):
"""
Sigmoid activation function
Arguments
---------
x: torch.Tensor
"""
return 1 / (1 + torch.exp(-x))
transform = transforms.Compose([
transforms.ToTensor(),
transforms.normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
trainset = datasets.MNIST('MNIST_data/',
download=True,
train=True,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=64,
shuffle=True)
# Get our data
images, labels = next(iter(trainloader))
# Flatten images
inputs = images.view(images.shape[0], -1)
w1 = torch.randn(784, 256)
