主要内容

• 如何用tensor对数据进行表示
• 如何将原始数据（raw data）处理成可用于深度学习的形式

Tabular Data

用CSV或者其他表格形式组织的表格数据是最易于处理的，不同于时间序列数据，其中的每个数据项都是独立的，不存在时序上的关系。面对多种数值型的和定类型的数据，我们需要做的是把他们全部转化为浮点数表示的形式。

winequality-whit.csv是一个用;进行分隔的csv文件，第一行为各种相关的数值。

利用numpy导入的方法如下：

1
2
3
4

wine_path = "./winequality-white.csv"
wine_numpy = np.loadtxt(wine_path, dtype = np.float32, delimiter = ';', skiprows = 1)

wineq = torch.from_numpy(wine_numpy)

其中delimiter每行中分隔元素的分隔符。

将score从输入中分离：

1
2
3

data = wineq[:, :-1]

target = wineq[:, -1]

将score作为一个定类型的数据，用one_hot向量来表示

1
2
3
4
5

# 将target作为一个整数组成的向量
target = target.long()

target_onehot = torch.zeros(target.shape[0], 10)
target_onehot.scatter_(1, target.unsqueeze(1), 1.0)

由于下划线，scatter_是原地修改的，其中三个参数的意义如下：

• 指示后面两个参数操作对应的维度
• 一列tensor用来指示分散元素的下标
• 一个包含有分散元素的tensor，或者一个单一的向量或标量

unsqueeze把本来是4898大小的一维tensor转换成了size为4898x1大小的二维tensor。

可以对输入做一个标准化的处理：

1
2
3
4

data_mean = torch.mean(data, dim=0)
data_var = torch.var(data, dim=0)

data_normalized = (data - data_mean) / torch.sqrt(data_var)

同时可以考虑使用le，lt，gt，ge方法简单的进行划分

1
2
3
4
5
6
7

# le的返回值是一个0,1的tensor，可以直接用于索引
bad_indexes = torch.le(target, 3)
bad_data = data[bad_indexes]

bad_data = data[torch.le(target, 3)]
min_data = data[torch.gt(target, 3) & torch.lt(target, 7)]
good_data = data[torch.ge(target, 7)]

Time series

采用的数据集为https://archive.ics.uci.edu/ml/datasets/bike+sharing+dataset

1
2
3
4
5
6
7

bikes_numpy = np.loadtxt("hour-fixed.csv",
                        dtype = np.float32,
                        delimiter = ',',
                        skiprows = 1,
                        converters = {1: lambda x: float(x[8:10])})
# converters 用于把日期的字符串中的天数给提取出来并转换成数字
bikes = torch.from_numpy(bikes_numpy)

在这种时间序列数据中，行是按照连续的时间点进行有序排列的，所以不能把每一行当做一个独立的数据项进行处理。

对每个小时有的数据如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

instant 	# index of record
day 		# day of month
season 		# season (1: spring, 2: summer, 3: fall, 4: winter)
yr 		# year (0: 2011, 1: 2012)
mnth 		# month (1 to 12)
hr 		# hour (0 to 23)
holiday	 	# holiday status
weekday 	# day of the week
workingday 	# working day status
weathersit 	# weather situation
		# (1: clear, 2:mist, 3: light rain/snow, 4: heavy rain/snow)
temp 		# temperature in C
atemp 		# perceived temperature in C
hum 		# humidity
windspeed 	# windspeed
casual 		# number of causal users
registered 	# number of registered users
cnt		# count of rental bikes

神经网络需要看到一个序列的输入，是$N$个大小为$C$的平行序列，$C$代表channel，就如同一维数据中的column，$N$表示时间轴上的长度。

数据集的大小为(17520, 17)的，下面把它改为三个维度（天数，小时，信息）：

1

daily_bikes = bikes.view(-1, 24, bikes.shape[1])

使用view方法不会改变tensor的存储，事实上只是改变了索引的办法，是没有什么开销的。这样实际上就得到了N个24连续小时，有7个channel组成的块。如果要得到所希望的$N\times C\times L$的数据，可以采用transpose：

1

daily_bikes = daily_bikes.transpose(1, 2)

天气情况实际上是一个定类型的数据，可以考虑把它改成onehot的形式

1
2
3
4
5
6
7
8
9
10

daily_weather_onehot = torch.zeors(daily_bikes.shape[0], 4 daily_bikes.shape[2])

daily_weather_onehot.scatter_(1,
                              daily_bikes[:,9,:].long().unsequeeze(1)-1,
                             1.0)
# -1是为了从1~4变为0~3
daily_bikes = torch.cat((daily_bikes, daily_weather_onehot), dim=1)

# 可以采用这种mask的方法删除掉原来的列
daily_bikes = daily_bikes[:, torch.arange(daily_bikes.shape[1])!=9, :]

Text

深度学习采用基于循环神经网络的方法，在许多的NLP任务上都达到了SOTA的水平，这一章主要讲怎么把文本数据进行组织。采用的数据是《Pride and Prejudice》。

1
2

with open('1342-0.txt', encoding = 'utf-8') as f:
  text = f.read()

onehot

一种最为简单的方法就是onehot方法，在这里先考虑字母级别的，可以考虑将所有字母都转换成小写，从而减少需要encoding的量，或者可以删掉标点，数字等于任务没有什么关系的内容。

1
2
3
4
5
6

# line是text里面的任意一行
letter_tensor = torch.zeros(len(line), 128)

for i, letter in enumerate(line.lower().strip()):
  letter_index = ord(letter) if ord(letter) < 128 else 0
  letter_tensor[i][letter_index] = 1

对于词语级别的，可以通过构建一个词语表来完成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def clean_words(input_str):
  punctuation = '.,;:"!?”“_-'
  word_list = input_str.lower().replace('\n',' ').split()
  word_list = [word.strip(punctuation) for word in word_list]
  return word_list

words_in_line = clean_words(line)

# 构造一个从词语到索引的映射
word_list = sorted(set(clean_words(text)))
word2index_dict = {word: i for (i, word) in enumerate(word_list)}

# 完成tensor的构建
word_tensor = torch.zeros(len(words_in_line), len(word2index_dict))
for i, word in enumerate(words_in_line):
  word_index = word2index_dict[word]
  word_tensor[i][word_index] = 1

embedding

Onehot是一种简单方法，但是存在很多缺点：

1. 当语料库很大的时候，单词表会变得异常庞大
2. 每次出现一个新单词，都要修改单词表，改变tensor的维度

embedding是一种把单词映射到高维的浮点数向量的方法，以便用于下游的深度学习任务。想法就是，相近的词语，在高维的空间中有更接近的距离。

Word2vec是一个确切的算法，我们可以通过一个利用上下文预测词语的任务，利用神经网络从onehot向量训练出embedding。

Images

通过排列在规律网格中的标量，可以表示黑白图片，如果每个格点利用多个标量来表示的话，可以描述彩色图片，或者例如深度之类的其他feature。

可以利用imageio来加载图片

1
2
3
4
5

improt imageio

img_arr = imageio.imread('bobby.jpg')
img_arr.shape
# Out: (720, 1280, 3)

在PyTorch里面，对于图片数据采用的布局是$C\times H\times W$的（通道，高度，宽度）。可以使用transpose进行转换。

1
2

img = torch.from_numpy(img_arr)
out = torch.transpose(img, 0, 2)

对于大量的图片导入，预先分配空间是一个更为有效的方法：

1
2
3
4
5
6
7
8
9
10

batch_size = 100
batch = torch.zeros(100, 3, 256, 256, dtype=torch.uint8)

import os

data_dir = "image-cats/"
filenames = [name for name in os.listdir(data_dir) if os.path.splitext(name) == '.png']
for i, filename in enumerate(filenames):
  img_arr = imageio.imread(filename)
  batch[i] = torch.transpose(torch.from_numpy(img_arr), 0, 2)

由于神经网络对0~1范围内的数值能够鞥有效的处理，所以一般会采用下面的处理方法：

1
2
3
4
5
6
7
8
9
10

# 直接处理
batch = batch.float()
batch /= 255.0

# 对每个channel标准化
n_channels = batch.shape[1]
for c in range(n_channels):
  mean = torch.mean(batch[:, c])
  std = torch.std(batch[:, c])
  batch[:, c] = (batch[:, c] - mean) / std

同时可以考虑对图片进行旋转，缩放，裁剪等操作，进行数据增强，或者通过修改来适应神经网络的输入尺寸。

Volumetric data

除去一般的2D图像，还可能处理类似CT图像这样的数据，是一系列堆叠起来的图片，每一张代表一个切面的信息。本质上来说，处理这种体积的数据和图片数据没有很大区叠，只不过会增加一个深度维度，带来的是一个$N\times C\times H \times W \times D$的五维tensor。

同样可以采用imageio库进行加载：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import imageio

dir_path = 'volumetric-dicom/2-LUNG 3.0 B70f-04083'
vol_arr = imageio.volread(dir_path, 'DICOM')
vol_arr.shape

# OUT: (99, 512, 512)

vol = torch.from_numpy(vol_arr).float()
vol = torch.transpose(vol, 0, 2)
vol = torch.unsqueeze(vol, 0)
vol.shape

# OUT: (1, 512, 512, 99)

啥是深度学习

Input Representation -> Intermediate Representation -> Output Representation

神经网络学到的就是怎样把Input Representation转化成Output Representation。

Tensor

PyTorch中的tensor起始就是一个n维数组，可以和NumPy中的ndarray相类比，Tensor支持numpy的无缝衔接。

对比NumPy中的ndarray，tensor可以

• 在GPU上进行高效的运算
• 可以在多机器上进行运算
• 可以在运算图上进行追踪

Tensor基础

Python内置List的不足点

• 浮点数会使用超过32bit的大小来进行储存，数据量打的时候比较低效
• 不能从向量化的运算中得到优化，在内存中并不都是连续分布的
• 对于多维的情况只能写list的list，十分的低效
• python解释器和优化编译过后的代码相比比较低效，用C做底层会快很多

可以类似numpy中的索引方式。

可以利用torch.zeros(3,2)或者torch.ones(3,2)的函数进行初始化。

Tensor存储

存储形式类似C中数组的方式。

可以利用tensor.storage()方法获得连续的存储，无论本来是几维数组，都可以最终得到一个连续的数组，用正常方法进行索引。类似于得到C中多维数组的首地址。

通过改变storage中的值同样可以改变对应tensor的内容。

Size, storage offset, and strides

• Size：一个tuple，能告诉这个tensor的每一维有多少元素，tensor.size()或者tensor.shape

• Storage offset：相对于tensor中第一个元素的offset，tensor.storage_offset()

• Stride：每一维度上，所需要得到下一个元素的步长，tensor.stride()

注意：子tensor有着更少的维度，但是实际上有着和原来的tensor都在相同的地方存储，所以对子tensor的改变会改变原来的tensor（直接类比C语言中的多维数组）。可以采用tensor.clone()得到tensor的克隆，这样更改不会改变原来的tensor。

tensor.t()可以将tensor转置，但是他们的存储空间仍然是一样的，只是改变了size和stride。确切的说，只是把对应维度的size和stride进行了交换。

tensor.transpose()可以用来对多维数组的两个维度进行交换，接受两个参数，分别代表dim0和dim1。

contiguous表示tensor在存储中是否按照直接的形式进行存储。可以用tensor.is_contiguous()进行判断，并且可以用tensor.contiguous方法对存储重新排布，不改变size，改变storage和stride。

数值类型

在创建的时候可以用dtype进行指定，默认的是32-bit浮点数，torch.Tensor就是torch.FloatTensor的别名，下面是一些可能的值：

• torch.float32 or torch.float—32-bit floating-point

• torch.float64 or torch.double—64-bit, double-precision floating-point

• torch.float16 or torch.half—16-bit, half-precision floating-point

• torch.int8—Signed 8-bit integers

• torch.uint8—Unsigned 8-bit integers

• torch.int16 or torch.short—Signed 16-bit integers

• torch.int32 or torch.int—Signed 32-bit integers

• torch.int64 or torch.long—Signed 64-bit integers

可以通过tensor.dtype来获取类型，可以用对应的方法或者to()进行转换，type()进行同样的操作，但是to()还可以接受额外的参数。

1
2
3
4
5
6
7
8

double_points = torch.zeros(10,2).double()
short_points = torch.ones(10,2).short()

double_points = torch.zeros(10,2).to(torch.double)
short_points - torch.ones(10,2).to(dtype = torch.short)

points = torch.randn(10,2)
stort_points = points.type(torch.short)

tensor索引

正常的列表索引，不同维度上切片什么的随你玩

与NumPy的交互

利用tensor.numpy()把tensor转换为numpy中的array。利用tensor.from_numpy()把numpy中的array转换成tensor。

注意一点，如果tensor在CPU上分配的话，是共享存储的，但是如果在GPU上分配的话，会在CPU上重新创造一个array的副本。

Serializing Tensor

tensor的保存与加载，即可以使用路径，也可以使用文件描述符

1
2
3
4
5
6
7
8
9
10
11

# Save
torch.save(points, '../data/p1ch3/ourpoints.t')

with open('../data/p1ch3/ourpoints.t','wb') as f:
    torch.save(points, f)

# Load
points = torch.load('../data/p1ch3/ourpoints.t')

with open('../data/p1ch3/ourpoints.t','rb') as f:
    torch.load(f)

如果要将tensor保存成一个更加可互用的形式，可以采用HDF5格式，一种用于表示多维数组的格式，他内部采用一个字典形式的键值对来进行保存。python通过h5py库支持HDF5格式，它可以接受和返回NumPy array。

1
2
3
4
5

import h5py

f = h5py.File('../data/plch3/ourpoints.hdf5','w')
dset = f.create_dataset('coords', data = points.numpy())
f.close()

在这里’coords’就是key，有趣的一点在于可以只从HDF5中加载一部分的内容，而不用加载全部！

1
2
3

f = h5py.File('../data/p1ch3/ourpoints','r')
dset = f['coords']
last_points = dset[1:]

在这种情况下只取出了后面几个点的坐标，返回了一个类似NumPy数组的对象。可以直接采用from_numpy()方法构造tensor。

这种情况下，数据会复制到tensor的storage。

1
2

last_points = torch.from_numpy(dset[1:])
f.close()

记得在加载完数据之后关闭文件！

将tensor移动到GPU

在GPU上可以对tensor进行高效的并行计算，tensor有一个device可以用来指定在CPU或者GPU上面，可以在创建时候指定，或者利用to方法创建一个GPU上的副本。

1
2
3
4

points_gpu = torch.tensor([[1.0, 4.0], [2.0, 1.0], [3.0, 4.0]],
                          device='cuda')

points_gpu = points.to(device='cuda')

注意！这个时候类型会从torch.FloatTensor变成torch.cuda.FloatTensor，其他的类型类似。

如果有多GPU的情况，可以用一个从零开始的int来指定特定的GPU，如下

1

points_gpu = points.to(device='cuda:0')

注意到一个问题，运算结束后，并不会把结果返回到CPU，只是返回一个handle，除非调用了to方法把它弄回了CPU。

可以使用cuda()方法和cpu()方法完成类似上面的事情

1
2
3

points_gpu = points.cuda() #默认是分配到下标为0的GPU
points_gpu = points.cuda(0)
points = points_gpu.cpu()

但是使用to方法可以传递多个参数！比如同时改变device和dtype。

Tensor API

注意有些api会在最后有一个下划线，表示他们是原地修改的，并不会返回一个新的tensor，例如zero_()会原地把矩阵清零。如果没有下划线会返回一个新的tensor，而原tensor保持不变。大致的API分类如下：

• Creation ops—Functions for constructing a tensor, such as ones and from_numpy

• Indexing, slicing, joining, and mutating ops—Functions for changing the shape,

stride, or content of a tensor, such as transpose

• Math ops—Functions for manipulating the content of the tensor through computations:

  • Pointwise ops—Functions for obtaining a new tensor by applying a function to each element independently, such as abs and cos
  • Reduction ops—Functions for computing aggregate values by iterating through tensors, such as mean, std, and norm
  • Comparison ops—Functions for evaluating numerical predicates over tensors, such as equal and max
  • Spectral ops—Functions for transforming in and operating in the frequency domain, such as stft and hamming_window
  • Other ops—Special functions operating on vectors, such as cross, or matrices, such as trace
  • BLAS and LAPACK ops—Functions that follow the BLAS (Basic Linear Algebra Subprograms) specification for scalar, vector-vector, matrix-vector, and matrix-matrix operations

• Random sampling ops—Functions for generating values by drawing randomly

  from probability distributions, such as randn and normal

• Serialization ops—Functions for saving and loading tensors, such as load and

save

• Parallelism ops—Functions for controlling the number of threads for parallel

CPU execution, such as set_num_threads

PyTorch拥有的工具

• 自动求导：torch.autograd
• 数据加载与处理：torch.util.data
  • Dataset
  • DataLoader
    生成子进程从Dataset加载数据
• 多GPU或者多机器训练：torch.nn.DataParallel, torch.distributed
• 优化器：torch.optim

Hello ?

Hello !