Pytorch tutorial 之Datar Loading and Processing (1)

landmarks_frame = pd.read_csv('/faces/face_landmarks.csv')
landmarks_frame.info()

landmarks_frame = pd.read_csv('faces/face_landmarks.csv')n = 65
img_name = landmarks_frame.iloc[n, 0] #查看第65张照片名
landmarks = landmarks_frame.iloc[n, 1:].as_matrix() # 将后136列reshape为横纵坐标形式
landmarks = landmarks.astype('float').reshape(-1, 2) # 68行2列print('Image name: {}'.format(img_name))
print('Landmarks shape: {}'.format(landmarks.shape))
print('First 4 Landmarks: {}'.format(landmarks[:4])) # 查看前四个点

def show_landmarks(image, landmarks):
"""Show image with landmarks"""
plt.imshow(image)
plt.scatter(landmarks[:, 0], landmarks[:, 1], s=10, marker='.', c='r')
plt.pause(0.001) # pause a bit so that plots are updatedplt.figure()
show_landmarks(io.imread(os.path.join('faces/', img_name)), landmarks)
plt.show()

class FaceLandmarksDataset(Dataset):
"""Face Landmarks dataset.""" def __init__(self, csv_file, root_dir, transform=None):
"""
Args:
csv_file (string): Path to the csv file with annotations.
root_dir (string): Directory with all the images.
transform (callable, optional): Optional transform to be applied
on a sample.
"""
self.landmarks_frame = pd.read_csv(csv_file)
self.root_dir = root_dir
self.transform = transform def __len__(self):
return len(self.landmarks_frame) def __getitem__(self, idx): # idx即为图像索引
img_name = os.path.join(self.root_dir,
self.landmarks_frame.iloc[idx, 0])
image = io.imread(img_name)
landmarks = self.landmarks_frame.iloc[idx, 1:].as_matrix()
landmarks = landmarks.astype('float').reshape(-1, 2)
sample = {'image': image, 'landmarks': landmarks} # 为方便返回字典形式，其他形式也可以 if self.transform:
sample = self.transform(sample) # 可以实现裁剪缩放等数据转换（transform类是有__call__方法的）
# 所以就可以利用函数形式transform（sample）来进行变换
return sample

face_dataset = FaceLandmarksDataset(csv_file='faces/face_landmarks.csv', root_dir='faces/') # 实例化fig = plt.figure()for i in range(len(face_dataset)):
sample = face_dataset[i] # 因为有__getitem__ 方法，所以可以查看索引，返回字典，即第i个样本的image和landmarke

print(i, sample['image'].shape, sample['landmarks'].shape) ax = plt.subplot(1, 4, i + 1)
plt.tight_layout()
ax.set_title('Sample #{}'.format(i))
ax.axis('off')
show_landmarks(**sample) # 因为sample为字典，所以可以利用这种形式返回字典中所有键对应的值 if i == 3:
plt.show()
break

tsfm = Transform(params) # 实例化一个含有_call__方法的transform类
transformed_sample = tsfm(sample) # 此时tsfm为一个实例化后的对象，它可以作为一个函数来用，此时函数的输入便为sample！

class Rescale(object): # 第一个类规范图像尺寸
"""Rescale the image in a sample to a given size. Args:
output_size (tuple or int): Desired output size. If tuple, output is
matched to output_size. If int, smaller of image edges is matched
to output_size keeping aspect ratio the same.
""" def __init__(self, output_size): # 此类需传入的参数为图像输出大小
assert isinstance(output_size, (int, tuple)) # 这个size可以为int例如256,也可以为tuple，例如（256,256）
self.output_size = output_size def __call__(self, sample):
image, landmarks = sample['image'], sample['landmarks'] h, w = image.shape[:2]
if isinstance(self.output_size, int): # 当输出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: # 当输出为tuple时，直接将此tuple作为图像输出尺寸
new_h, new_w = self.output_size new_h, new_w = int(new_h), int(new_w) img = transform.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, 'landmarks': landmarks} # 注意__getitem__返回的是字典，所以这里也要返回字典class RandomCrop(object): #第二个类随机裁剪
"""Crop randomly the image in a sample. Args:
output_size (tuple or int): Desired output size. If int, square crop
is made.
""" def __init__(self, output_size): # 此类需传入输出尺寸
assert isinstance(output_size, (int, tuple))
if isinstance(output_size, int): # 如果为int例如256则返回任意（256,256）大小的图
self.output_size = (output_size, output_size)
else:
assert len(output_size) == 2 # 如果为tuple例如（211,985），则返回（211,985）大小的图
self.output_size = output_size def __call__(self, sample):
image, landmarks = sample['image'], sample['landmarks'] h, w = image.shape[:2]
new_h, new_w = self.output_size top = np.random.randint(0, h - new_h)
left = np.random.randint(0, w - new_w) image = image[top: top + new_h,
left: left + new_w] landmarks = landmarks - [left, top] return {'image': image, 'landmarks': landmarks}class ToTensor(object): # 第三个类转numpy为tensor
"""Convert ndarrays in sample to Tensors.""" def __call__(self, sample): # 无需init方法，直接将此类作为函数
image, landmarks = sample['image'], sample['landmarks'] # swap color axis because
# numpy image: H x W x C
# torch image: C X H X W
image = image.transpose((2, 0, 1)) # 转换维度，按照torch格式来
return {'image': torch.from_numpy(image),
'landmarks': torch.from_numpy(landmarks)}

scale = Rescale(256) # 实例化第一个类，此时该对象可当做函数使用
crop = RandomCrop(128) # 实例化第二个类，此时该对象可当做函数使用
composed = transforms.Compose([Rescale(256), # 结合两个方法
RandomCrop(224)])# Apply each of the above transforms on sample.
fig = plt.figure()
sample = face_dataset[65]
for i, tsfrm in enumerate([scale, crop, composed]): # 试着分别使用这三个函数
transformed_sample = tsfrm(sample) # sample作为参数传入了函数里面，返回image、landmark字典 ax = plt.subplot(1, 3, i + 1)
plt.tight_layout()
ax.set_title(type(tsfrm).__name__)
show_landmarks(**transformed_sample) # 调用之前的函数进行显示plt.show()

transformed_dataset = FaceLandmarksDataset(csv_file='faces/face_landmarks.csv',
root_dir='faces/',
transform=transforms.Compose([
Rescale(256),
RandomCrop(224),
ToTensor()
])) # 实例化我们定制的dataset！for i in range(len(transformed_dataset)):
sample = transformed_dataset[i] # for循环， 每次采样索引为i的一张图片 print(i, sample['image'].size(), sample['landmarks'].size()) if i == 3: # 查看4张图就好
break

dataloader = DataLoader(transformed_dataset, batch_size=4, # batch为4张，打散，进程数为4
shuffle=True, num_workers=4) # Helper function to show a batch
def show_landmarks_batch(sample_batched): # 显示一个batch数据的函数，主要利用工具函数make_grid
"""Show image with landmarks for a batch of samples."""
images_batch, landmarks_batch = \
sample_batched['image'], sample_batched['landmarks']
batch_size = len(images_batch)
im_size = images_batch.size(2) grid = utils.make_grid(images_batch) # 其输入为FLoatTensor
plt.imshow(grid.numpy().transpose((1, 2, 0))) # 只有当画图的时候才转为numpy并转换维度 for i in range(batch_size):
plt.scatter(landmarks_batch[i, :, 0].numpy() + i * im_size,
landmarks_batch[i, :, 1].numpy(),
s=10, marker='.', c='r') plt.title('Batch from dataloader')

for i_batch, sample_batched in enumerate(dataloader):
print(i_batch, sample_batched['image'].size(),
sample_batched['landmarks'].size()) # observe 4th batch and stop.
if i_batch == 3: # 只打印第4个batch
plt.figure()
show_landmarks_batch(sample_batched)
plt.axis('off')
plt.ioff()
plt.show()
break

import torch
from torchvision import transforms, datasetsdata_transform = 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])
])
hymenoptera_dataset = datasets.ImageFolder(root='hymenoptera_data/train',
transform=data_transform)
dataset_loader = torch.utils.data.DataLoader(hymenoptera_dataset,
batch_size=4, shuffle=True,
num_workers=4)