机器学习笔记DayOne

最新推荐文章于 2024-06-26 23:12:54 发布

YINGZHECHENG

最新推荐文章于 2024-06-26 23:12:54 发布

阅读量152

点赞数

文章标签：机器学习 python numpy

本文链接：https://blog.csdn.net/YINGZHECHENG/article/details/129678994

版权

DataWhale 学习笔记

date1- 安装

安装pytorch，前提，有anconda并且已经有jupyter和环境。

https://pytorch.org/get-started/locally/, 访问官网

然后自己选择，复制下面的命令到conda新建的环境终端里开始下载。

import torch

没有报错，说明torch安装成功。

date2 - 预备知识

数据操作

为了能够完成各种数据操作，我们需要某种方法来存储和操作数据。通常，我们需要做两件重要的事：（1）获取数据；（2）将数据读入计算机后对其进行处理。如果没有某种方法来存储数据，那么获取数据是没有意义的。

首先，我们介绍的n维数组，也称为张量（tensor）。使用过Python中NumPy计算包的读者会对本部分很熟悉。无论使用哪个深度学习框架，它的张量类（在MXNet中为ndarray，在PyTorch和TensorFlow中为Tensor）都与Numpy的ndarray类似。但深度学习框架又比Numpy的ndarray多一些重要功能：首先，GPU很好地支持加速计算，而NumPy仅支持CPU计算；其次，张量类支持自动微分。这些功能使得张量类更适合深度学习。如果没有特殊说明，本书中所说的张量均指的是张量类的实例。

# 创建一个张量
x = torch.arange(12)
x

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

# 访问张量的形状和元素总数
x.shape

torch.Size([12])

# 元素总数
x.numel()

要改变一个张量的形状而不改变元素量和值，调用reshape函数

x = x.reshape()
x

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

x.shape

torch.Size([3, 4])

使用全0、全1、其他常量或者从特定分布中随机采样的数字

# 全0
torch.zeros((2,3,4))

tensor([[[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]],

        [[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]]])

# 全1
torch.ones((2,3,4))

tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

# 随机
torch.randn(3,4)

tensor([[ 1.7191,  0.3106, -1.0100, -1.1257],
        [ 2.4160,  1.4670,  1.2344, -0.6265],
        [-0.5450,  1.8891, -0.0472, -0.7566]])

通过提供包含数值的 Python 列表（或嵌套列表）来为所需张量中的每个元素赋予确定值

torch.tensor([[2,0,0,2],[0,1,2,2],[1,2,0,3]])

tensor([[2, 0, 0, 2],
        [0, 1, 2, 2],
        [1, 2, 0, 3]])

运算符

常见的标准算术运算符（+、-、*、/ 和 ** ）都可以被升级为按元素运算

x = torch.tensor([1.0,2,3,4])
y = torch.tensor([2,2,2,2])
x+y,x-y,x*y,x**y,x/y

(tensor([3., 4., 5., 6.]),
 tensor([-1.,  0.,  1.,  2.]),
 tensor([2., 4., 6., 8.]),
 tensor([ 1.,  4.,  9., 16.]),
 tensor([0.5000, 1.0000, 1.5000, 2.0000]))

# 还有指数运算，返回以e为底，x中元素为幂的张量
torch.exp(x)

tensor([ 2.7183,  7.3891, 20.0855, 54.5981])

还可以把多个张量连起来，横着连竖着连。。。

x = torch.arange(12,dtype=torch.float32).reshape((3,4))
y = torch.tensor([[2.0,0,0,2],[0,1,2,2],[3,4,5,1]])
torch.cat((x,y),dim=0),torch.cat((x,y),dim=1)

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  0.,  0.,  2.],
         [ 0.,  1.,  2.,  2.],
         [ 3.,  4.,  5.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  0.,  0.,  2.],
         [ 4.,  5.,  6.,  7.,  0.,  1.,  2.,  2.],
         [ 8.,  9., 10., 11.,  3.,  4.,  5.,  1.]]))

通过逻辑运算符构建二元张量

x == y,x > y

(tensor([[False, False, False, False],
         [False, False, False, False],
         [False, False, False, False]]),
 tensor([[False,  True,  True,  True],
         [ True,  True,  True,  True],
         [ True,  True,  True,  True]]))

x.sum()

tensor(66.)

广播机制

在上面的部分中，我们看到了如何在相同形状的两个张量上执行按元素操作。在某些情况下，即使形状不同，我们仍然可以通过调用广播机制（broadcasting mechanism）来执行按元素操作。这种机制的工作方式如下：

通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
对生成的数组执行按元素操作。

在大多数情况下，我们将沿着数组中长度为1的轴进行广播，如下例子：

a = torch.arange(3).reshape((3,1))
b = torch.arange(2).reshape((1,2))
a,b

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

a+b

tensor([[0, 1],
        [1, 2],
        [2, 3]])

索引和切片

元素访问

x,x[-2],x[1:3],x[1,3]

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]),
 tensor([4., 5., 6., 7.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]),
 tensor(7.))

还可以写入修改元素

x[1,3] = 666
x[1,3]

tensor(666.)

# 批量赋值
x[0:2,1:3] = 0
x

tensor([[ 0.,  0.,  0.,  3.],
        [ 4.,  0.,  0.,  7.],
        [ 8.,  9., 10., 11.]])

节省内存

运行一些操作可能会导致为新结果分配内存。例如，如果我们用Y = X + Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量。

在下面的例子中，我们用Python的id()函数演示了这一点，它给我们提供了内存中引用对象的确切地址。运行Y = Y + X后，我们会发现id(Y)指向另一个位置。这是因为Python首先计算Y + X，为结果分配新的内存，然后使Y指向内存中的这个新位置

before = id(y)
y = y + x
id(y) == before

False

这可能是不可取的，原因有两个：

首先，我们不想总是不必要地分配内存。在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新；
如果我们不原地更新，其他引用仍然会指向旧的内存位置，这样我们的某些代码可能会无意中引用旧的参数

执行原地操作,torch.zeros_like(),复制张量大小和形状，但所有元素为0

z = torch.zeros_like(y)
print(id(z))
z[:] = x + y
print(id(z))

1994428989584
1994428989584

如果在后续计算中没有重复使用 X，我们也可以使用 X[:] = X + Y 或 X += Y 来减少操作的内存开销

转化为Python其它对象

将深度学习框架定义的张量转换为NumPy张量（ndarray）很容易，反之也同样容易。 torch张量和numpy数组将共享它们的底层内存，就地操作更改一个张量也会同时更改另一个张量

A = x.numpy()
B = torch.tensor(A)
A,type(A),B,type(B)

(array([[ 0.,  0.,  0.,  3.],
        [ 4.,  0.,  0.,  7.],
        [ 8.,  9., 10., 11.]], dtype=float32),
 numpy.ndarray,
 tensor([[ 0.,  0.,  0.,  3.],
         [ 4.,  0.,  0.,  7.],
         [ 8.,  9., 10., 11.]]),
 torch.Tensor)

还可以将大小为1的张量转化为python标量

c = torch.tensor([3.5])
c,c.item(),int(c)

(tensor([3.5000]), 3.5, 3)

小节

深度学习存储和操作数据的主要接口是张量（n维数组）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他Python对象。

练习

运行本节中的代码。将本节中的条件语句X == Y更改为X < Y或X > Y，然后看看你可以得到什么样的张量。
用其他形状（例如三维张量）替换广播机制中按元素操作的两个张量。结果是否与预期相同？

x = torch.arange(6,dtype = torch.float32).reshape(2,3)
y = torch.tensor([[2,1,3],[5,2,6]])
x,y

(tensor([[0., 1., 2.],
         [3., 4., 5.]]),
 tensor([[2, 1, 3],
         [5, 2, 6]]))

x == y,x > y

(tensor([[False,  True, False],
         [False, False, False]]),
 tensor([[False, False, False],
         [False,  True, False]]))

X = torch.arange(12,dtype = torch.float32).reshape(2,3,2)
Y = torch.arange(6).reshape(2,3,1)
X,Y

(tensor([[[ 0.,  1.],
          [ 2.,  3.],
          [ 4.,  5.]],
 
         [[ 6.,  7.],
          [ 8.,  9.],
          [10., 11.]]]),
 tensor([[[0],
          [1],
          [2]],
 
         [[3],
          [4],
          [5]]]))

X + Y

tensor([[[ 0.,  1.],
         [ 3.,  4.],
         [ 6.,  7.]],

        [[ 9., 10.],
         [12., 13.],
         [15., 16.]]])

通过做题发现一个问题，使用广播机制是有前提的，比如一个（1，3）和（2，2）就报错了

至于为何报错我们可以回到1.2.3中，（1，2）和（3，1），可以发现同一维度广播时必须是整数倍关系。当然其实按理来书也是可以的，取两数的最小公倍数，（1，3），（2，2）都变成（2，6)，但人家就是这么设计肯定是有原因的，所以我们知道就行。

数据预处理

为了能用深度学习来解决现实世界的问题，我们经常从预处理原始数据开始，而不是从那些准备好的张量格式数据开始。在Python中常用的数据分析工具中，我们通常使用pandas软件包。像庞大的Python生态系统中的许多其他扩展包一样，pandas可以与张量兼容。本节我们将简要介绍使用pandas预处理原始数据，并将原始数据转换为张量格式的步骤。后面的章节将介绍更多的数据预处理技术

读取数据集

创建一个人工数据集，并存储在csv文件

import os
os.makedirs(os.path.join('.','data'),exist_ok=True)
data_file = os.path.join('.','data','house_tiny.csv')
with open(data_file,'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 列名
    f.write('NA,Pave,127500\n')  # 每行表示一个数据样本
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

import pandas as pd
data = pd.read_csv(data_file)
data

	NumRooms	Alley	Price
0	NaN	Pave	127500
1	2.0	NaN	106000
2	4.0	NaN	178100
3	NaN	NaN	140000

处理缺失值

注意，“NaN”项代表缺失值。为了处理缺失的数据，典型的方法包括插值法和删除法，其中插值法用一个替代值弥补缺失值，而删除法则直接忽略缺失值。在这里，我们将考虑插值法。

通过位置索引iloc，我们将data分成inputs和outputs，其中前者为data的前两列，而后者为data的最后一列。对于inputs中缺少的数值，我们用同一列的均值替换“NaN”项。

补充一点知识，pd.fillna()是填充空缺值，只接受标量或者ArrayLike(类数组，可以看作一个有索引的列表)，pd.mean()是求平均值，pd.mean()返回一个series。

inputs,outputs = data.iloc[:,0:2],data.iloc[:,2]
inputs = inputs.fillna(inputs.mean(numeric_only=True))
inputs.fillna()
inputs

	NumRooms	Alley
0	3.0	Pave
1	2.0	NaN
2	4.0	NaN
3	3.0	NaN

补充一下pd.get_dummies()，官方文档不易理解，只说这里用到的dummy_na。

get_dummies()是用于特征处理的，也叫one-hot-encodin处理，可能还是不好理解，再简单的说一个二维表里有一列是gender，性别有male和famale，那么这一列是有两个特征，然后把gender这一列换成gender_male和gender_famale分别体现gender的两个特征，那么符合male的为1，否则为0，famale同理。get_dummies()就是这么个作用。

然后dummy_na这个参数默认为False，为True就是说我把nan也看作一个特征，特别关注一下。

inputs = pd.get_dummies(inputs,dummy_na=True)
inputs

	NumRooms	Alley_Pave	Alley_nan
0	3.0	1	0
1	2.0	0	1
2	4.0	0	1
3	3.0	0	1

现在inputs和outputs中所有条目都是数值类型，他们可以转化为张量类型了

x,y = torch.tensor(inputs.values),torch.tensor(outputs.values)
x,y

(tensor([[3., 1., 0.],
         [2., 0., 1.],
         [4., 0., 1.],
         [3., 0., 1.]], dtype=torch.float64),
 tensor([127500, 106000, 178100, 140000]))