def load_image(path):
image=Image.open(path).convert('rgb)
transforms=transforms.Compose([transforms.resize(256),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225))])
image = in_transform(image)[:3,:,:].unsqueeze(0)
return image
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 image_transform(self, data_type, size):
if (data_type == 'train'):
transform = transforms.Compose(
[transforms.Resize(size),
transforms.ToTensor()])
else:
transform = transforms.Compose(
[transforms.resize(size),
transforms.ToTensor()])
return transform
def __init__(self, batch_size, image_size=None):
self.batch_size = batch_size
self.image_size = image_size
self.loader = None
self.transform = transforms.Compose([transforms.resize((self.image_size, self.image_size))
transforms.RandomResizedCrop(),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def __call__(self, sample):
image, landmarks, landmarks_2d = sample['image'], sample['landmarks'], sample['landmarks_2d']
h, w = image.shape[:2]
if isinstance(self.output_size, int):
if h > w:
new_h, new_w = self.output_size * h / w, self.output_size
else:
new_h, new_w = self.output_size, self.output_size * w / h
else:
new_h, new_w = self.output_size
new_h, new_w = int(new_h), int(new_w)
img = transforms.resize(image, (new_h, new_w))
landmarks_2d = landmarks_2d* [new_w/ w, new_h/ h]
landmarks = landmarks_2d.reshape[-1 ,1]
return {'image': img, 'landmarks': landmarks, 'landmarks_2d': landmarks_2d}
def __call__(self, sample):
image, label = sample['image'], sample['label']
h, w = image.shape[:2]
if isinstance(self.output_size, int):
if h > w:
new_h, new_w = self.output_size * h / w, self.output_size
else:
new_h, new_w = self.output_size, self.output_size * w / h
else:
new_h, new_w = self.output_size
new_h, new_w = int(new_h), int(new_w)
img = transforms.resize(image, (new_h, new_w))
# h and w are swapped for landmarks because for images,
# x and y axes are axis 1 and 0 respectively
landmarks = landmarks * [new_w / w, new_h / h]
return {'image': img, 'label': label}
def create_train_val_loader(
folder,
train_fraction=0.8,
is_structured=True,
aug_plus=DEFAULT_CONFIG['aug_plus'],
batch_size=DEFAULT_CONFIG['batch_size'],
num_workers=DEFAULT_CONFIG['workers']) -> torch.utils.data.DataLoader:
"""Loads a folder for training and validation
The folder can either be structured or unstructered :
- structured :
root
|
|--> cls1
| sample1
| sample2
|--> cls2
| sample1
| sample2
.
.
|--> clsN
| sample1
| sample2
- unstructured ;
root
| sample1
| sample2
| .
| .
| .
| sampleN
----------------------------------------------------
args:
- folder : (str) Folder containing the dataset.
- is_structured : (bool) whether the folder is structured or not
"""
# TODO : implement unstructured folder when needed
datadir = os.path.join(folder, 'train')
# Data transforms
# TODO : change the values to data-relevant mean and std
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if aug_plus:
# MoCo v2's aug: similar to SimCLR https://arxiv.org/abs/2002.05709
augmentation = [
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomApply(
[
transforms.ColorJitter(0.4, 0.4, 0.4,
0.1) # not strengthened
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomApply([moco.loader.GaussianBlur([.1, 2.])],
p=0.5),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize
]
else:
# MoCo v1's aug: the same as InstDisc https://arxiv.org/abs/1805.01978
augmentation = [
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomGrayscale(p=0.2),
transforms.ColorJitter(0.4, 0.4, 0.4, 0.4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
]
# Create the torch data loading pipeline
dataset = datasets.ImageFolder(datadir,
moco.loader.TwoCropsTransform(augmentation))
# Split the dataset into
train_data_len = int(len(dataset) * train_fraction)
val_data_len = len(dataset) - train_data_len
split = [train_data_len, val_data_len]
train_set, val_set = torch.utils.data.random_split(dataset, split)
# Change the transforms for the val set
val_set.transform = transforms.Compose(
[transforms.resize(256),
transforms.CenterCrop(224), normalize])
train_sampler = torch.utils.data.distributed.DistributedSampler(train_set)
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=batch_size,
shuffle=(train_sampler is None),
num_workers=num_workers,
pin_memory=True,
sampler=train_sampler,
drop_last=True)
val_loader = torch.utils.data.DataLoader(val_set,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=True)
return train_loader, val_loader
"""定义成功了嘛？"""
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 __call__(self, img):
return tvxfrm.resize(img, self.output_size)
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import torchvision.models as models
from torch.optim import lr_scheduler
# Device configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Hyper-parameters
num_epochs = 50
learning_rate = 0.001
# Image preprocessing modules
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
ds_trans = transforms.Compose([
transforms.resize(224),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
])
# Data loader
train_loader = load_dataset("./data/train")
test_loader = load_dataset("./data/test")
from PIL import Image
dataset_path = 'datasets/'
cifar10_train = datasets.CIFAR10(dataset_path, train=True, download=True)
cifar10 = datasets.CIFAR10(dataset_path, train=False, download=True)
alphabets = []
for i in string.ascii_letters:
alphabets.append(i)
def gen_random_name(image):
"""gen_random_name: This function takes the image as input and generates a random name for it"""
image_name = random.choice(alphabets) + random.choice(alphabets) + random.choice(alphabets) + random.choice(alphabets) + random.choice(alphabets) + random.choice(alphabets) + '.jpg'
with open(image_name, 'wb') as f:
f.write(image)
img = Image.open(os.path.join(os.cwd+"uploads/image_name"))
preprocess = transforms.Compose([
transforms.resize(25),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485,0.456,0.406],
std=[0.229,0.224,0.225]
)])
batch_t = torch.unsqueeze(img_t, 0)
img_t = preprocess(img)
img, label = cifar10[99]
plt.imshow(img)
plt.show()
class NNet(nn.Module):
