第一次作业:深度学习基础

一、理论学习和动手实践

1、数据操作部分

  1 import torch
  2 
  3 #张量表示一个数值组成的数组
  4 x=torch.arange(12)
  5 #访问张量的形状和张量中元素的总数 
  6 x.shape#torch.Size([12])
  7 x.numel()#12
  8 
  9 #改变形状
 10 X=x.reshape(3,4)#tensor([[ 0,  1,  2,  3],
 11        # [ 4,  5,  6,  7],
 12        # [ 8,  9, 10, 11]])
 13 X
 14 
 15 #创建全0全1
 16 torch.zeros((2,3,4))
 17 torch.ones((2,3,4))
 18 
 19 #通过列表赋值
 20 torch.tensor([[2,1,4,3],[1,2,3,4,],[4,3,2,1]])
 21 
 22 #算术运算
 23 x=torch.tensor([1.0,2])#1.0是创建浮点数
 24 y=torch.tensor([2,3])
 25 x+y,x-y,x*y,x/y,x**y#**y求幂运算
 26 # (tensor([3., 5.]),
 27 #  tensor([-1., -1.]),
 28 #  tensor([2., 6.]),
 29 #  tensor([0.5000, 0.6667]),
 30 #  tensor([1., 8.]))
 31 torch.exp(x)#tensor([2.7183, 7.3891])
 32 
 33 #标准运算
 34 X=torch.arange(12,dtype=torch.float32).reshape((3, 4))
 35 Y=torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
 36 torch.cat((X,Y),dim=0)#第0维进行合并,以行为组拼接
 37 # tensor([[ 0.,  1.,  2.,  3.],
 38 #         [ 4.,  5.,  6.,  7.],
 39 #         [ 8.,  9., 10., 11.],
 40 #         [ 2.,  1.,  4.,  3.],
 41 #         [ 1.,  2.,  3.,  4.],
 42 #         [ 4.,  3.,  2.,  1.]])
 43 
 44 torch.cat((X,Y),dim=1)#第1维进行合并,以列为组拼接
 45 # tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
 46 #         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
 47 #         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]])
 48 
 49 #使用逻辑运算符构建二元张量
 50 X==Y
 51 # tensor([[False,  True, False,  True],
 52 #         [False, False, False, False],
 53 #         [False, False, False, False]])
 54 
 55 
 56 #求和
 57 X.sum()#tensor(66.),此时X是还是浮点数类型
 58 
 59 #广播机制broadcasting mechanism
 60 a=torch.arange(3).reshape((3, 1))
 61 b=torch.arange(2).reshape((1, 2))
 62 a,b
 63 # (tensor([[0],
 64 #      [1],
 65 #      [2]]), 
 66 # tensor([[0, 1]]))
 67 a+b#此处的相加是自动将a从(3,1)复制到(3,2)与b的列数相匹配,b从(1,2)复制到(3,2)与a的行数相匹配
 68 # tensor([[0, 1],[1, 2],[2, 3]])=(tensor([[0,0],[1,1],[2,2]])+tensor([[0, 1],[0, 1],[0, 1]]))
 69 
 70 #访问元素
 71 X[-1]#访问最后一个元素,即X的最后一行
 72 X[1:3]#访问元素的第1行和第2行
 73 
 74 #写入单个元素
 75 X[1,2]=9#数组行列都是从0开始的
 76 
 77 #写入多个元素
 78 X[0:2,:]=12#为第0行和第1行的所有列的元素赋值12
 79 
 80 #为新结果分配内存
 81 before=id(Y)#id类似指针,获得Y在python里唯一的标识号
 82 Y=Y+X
 83 id(Y)==before#判断两个是否相等,False
 84 
 85 #原地操作=内存位置不变,内部元素操作不会分配新内存
 86 Z=torch.zeros_like(Y)#跟Y的shape一样,但元素为0
 87 print('id(Z):',id(Z))#id(Z): 139891246746112
 88 Z[:]=X+Y
 89 print('id(Z):',id(Z))#id(Z): 139891246743712
 90 
 91 #减少内存开销,不分配新内存
 92 before=id(X)
 93 X+=Y#也可以写成X[:]=X+Y
 94 id(X)==before#True
 95 
 96 #tensor转为numpy
 97 A=X.numpy()
 98 #numpy转为tensor
 99 B=torch.tensor(A)
100 type(A),type(B)#(numpy.ndarray, torch.Tensor)
101 
102 #大小为1的张量转换为python标量(标量指一维)
103 a=torch.tensor([3.5])
104 a,a.item(),float(a),int(a)#(tensor([3.5000]), 3.5, 3.5, 3)

2、数据预处理

 1 import os
 2 
 3 #创建一个人工数据集,存储在csv(逗号分隔值)文件
 4 os.makedirs(os.path.join('..', 'data'), exist_ok=True)
 5 data_file = os.path.join('..', 'data', 'house_tiny.csv')
 6 with open(data_file, 'w') as f:
 7     f.write('NumRooms,Alley,Price\n')#列名
 8     f.write('NA,Pave,127500\n')#每行表示一个数据样本
 9     f.write('2,NA,106000\n')
10     f.write('4,NA,178100\n')
11     f.write('NA,NA,140000\n')
12 
13 import pandas as pd#读取csv文件的库
14 data=pd.read_csv(data_file)
15 print(data)
16 #    NumRooms Alley   Price
17 # 0    NaN  Pave  127500
18 # 1    2.0   NaN  106000
19 # 2    4.0   NaN  178100
20 # 3    NaN   NaN  140000
21 
22 #插值
23 inputs,outputs=data.iloc[:,0:2],data.iloc[:,2]#inputs包含第0和1列所有行的元素;outputs包含第2列所有行的元素
24 inputs=inputs.fillna(inputs.mean())
25 print(inputs)
26 #       NumRooms Alley
27 # 0       3.0  Pave
28 # 1       2.0   NaN
29 # 2       4.0   NaN
30 # 3       3.0   NaN
31 
32 #视NaN是一个类别
33 inputs=pd.get_dummies(inputs,dummy_na=False)#get_dummies实现one-hot独热编码
34 print(inputs)
35 # NumRooms  Alley_Pave
36 # 3.0     1
37 # 2.0     0
38 # 4.0     0
39 # 3.0     0
40 
41 inputs=pd.get_dummies(inputs,dummy_na=True)#get_dummies实现one-hot独热编码
42 print(inputs)
43 # NumRooms  Alley_Pave
44 # 3.0     1
45 # 2.0     0
46 # 4.0     0
47 # 3.0     0
48 
49 #此时imputs和outputs的元素都是数值类型,不存在NaN,可以将数据转化为张量
50 import torch
51 X,y=torch.tensor(inputs.values),torch.tensor(outputs.values)
52 X,y
53 # (tensor([[3., 1.],
54 #          [2., 0.],
55 #          [4., 0.],
56 #          [3., 0.]], dtype=torch.float64),
57 #  tensor([127500, 106000, 178100, 140000]))

3、线性代数学习

(1)常用范数:F范数更加常用

  

 

   正对称:Aij=Aji

   反对称:Aij=-Aji

   正交矩阵:行相互正交、行有单位长度、UUT=1

   置换矩阵是正交矩阵

(2)线性代数实现

  1 import torch
  2 
  3 #生成标量
  4 x=torch.tensor([3.0])
  5 y=torch.tensor([2.0])
  6 
  7 #访问张量长度
  8 x=torch.arange(4)
  9 len(x)#4
 10 x.shape#torch.Size([4])
 11 
 12 #创建矩阵
 13 A=torch.arange(20).reshape(5, 4)
 14 A
 15 # tensor([[ 0,  1,  2,  3],
 16 #         [ 4,  5,  6,  7],
 17 #         [ 8,  9, 10, 11],
 18 #         [12, 13, 14, 15],
 19 #         [16, 17, 18, 19]])
 20 #将矩阵转置
 21 A.T
 22 # tensor([[ 0,  4,  8, 12, 16],
 23 #         [ 1,  5,  9, 13, 17],
 24 #         [ 2,  6, 10, 14, 18],
 25 #         [ 3,  7, 11, 15, 19]])
 26 
 27 #对称矩阵的转置等于其本身
 28 B=torch.tensor([[1,2,3],[2,0,4],[3,4,5]])
 29 B==B.T
 30 # tensor([[True, True, True],
 31 #         [True, True, True],
 32 #         [True, True, True]])
 33 
 34 #张量的加减乘除操作
 35 A=torch.arange(20,dtype=torch.float32).reshape(5,4)
 36 B=A.clone()#克隆分配新内存
 37 A+B
 38 # tensor([[ 0.,  2.,  4.,  6.],
 39 #         [ 8., 10., 12., 14.],
 40 #         [16., 18., 20., 22.],
 41 #         [24., 26., 28., 30.],
 42 #         [32., 34., 36., 38.]])
 43 A*B
 44 # tensor([[  0.,   1.,   4.,   9.],
 45 #         [ 16.,  25.,  36.,  49.],
 46 #         [ 64.,  81., 100., 121.],
 47 #         [144., 169., 196., 225.],
 48 #         [256., 289., 324., 361.]])
 49 
 50 #标量与张量做加减乘除操作
 51 a=2
 52 X=torch.arange(24).reshape(2,3,4)
 53 a+X,(a*X).shape
 54 # (tensor([[[ 2,  3,  4,  5],
 55 #           [ 6,  7,  8,  9],
 56 #           [10, 11, 12, 13]],
 57  
 58 #          [[14, 15, 16, 17],
 59 #           [18, 19, 20, 21],
 60 #           [22, 23, 24, 25]]]), torch.Size([2, 3, 4]))
 61 
 62 #计算元素的和
 63 x=torch.arange(4,dtype=torch.float32)
 64 x.sum()#tensor(6.)
 65 
 66 #按照维度求和,会使该维度消失
 67 A=torch.arange(20*2).reshape(2,5,4)
 68 A.shape
 69 # (torch.Size([2, 5, 4])
 70 A.sum(dim=1)
 71 # tensor([[ 40,  45,  50,  55],
 72 #         [140, 145, 150, 155]])
 73 A.sum()#tensor(780)
 74 #A.mean()#A.sum()/A.numel()
 75 #A.mean(axis=0)#A.sum(axis=0)/A.shape[0]
 76 
 77 sum_A=A.sum(axis=1,keepdims=True)#按维度为1求和,保持维度不变
 78 
 79 #某个轴计算元素的累加求和
 80 A.cumsum(axis=0)
 81 
 82 #点积是相同位置的元素乘积的和
 83 y=torch.ones(4,dtype=torch.float32)
 84 x,y,torch.dot(x,y)
 85 #(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))
 86 torch.sum(x*y)#通过元素乘法计算
 87 #tensor(6.))
 88 
 89 #矩阵与向量相乘
 90 #torch.mv(A,x)
 91 
 92 #矩阵与矩阵相乘
 93 #torch.mm(A,B)
 94 
 95 #L2范数:平方之和再开方
 96 u=torch.tensor([3.0,-4.0])
 97 torch.norm(u)#tensor(5.)
 98 
 99 #L1范数:绝对值之和
100 torch.abs(u).sum()#tensor(7.)
101 
102 #F范数:所有矩阵元素的平方和的平方根
103 torch.norm(torch.ones((4, 9)))#tensor(7.)

 4、(1)当y是个标量,x是个向量:标量对列向量求导,结果是行向量

  

 

 

 

   (2)当y是向量,x是标量

  

 

 

   (3)当x和y都是向量

 

 

5、自动求导

 

 

   

 

   

 

 

二、第一课总结

1、问题:

(1)对读取的数据进行one-hot编码时,得出的结果与视频结果不一致  

  

  

 

2、收获

  对数据的预处理和操作之前已经接触过,所以学起来没有难度。数学是乌龟的强项,看得我头晕眼花,还在消化中,周日感冒头疼,先写一课吧,明天慢慢整理。

 

posted @ 2021-09-05 21:48  古幽月兮  阅读(108)  评论(1编辑  收藏  举报