zoukankan      html  css  js  c++  java
  • 第一次作业:深度学习基础

    一、理论学习和动手实践

    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
    ')#列名
     8     f.write('NA,Pave,127500
    ')#每行表示一个数据样本
     9     f.write('2,NA,106000
    ')
    10     f.write('4,NA,178100
    ')
    11     f.write('NA,NA,140000
    ')
    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、收获

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

  • 相关阅读:
    Python开发入门与实战3-Django动态页面
    Python开发入门与实战2-第一个Django项目
    Python开发入门与实战1-开发环境
    牛客网剑指offer第12题——数值的整数次方
    再叙快速排序
    牛客网剑指offer第29题——最小的k个数
    牛客网剑指offer第59题——按之字形顺序打印二叉树
    牛客网剑指offer第33题——第N个丑数
    各种特征距离的计算方法及应用
    牛客网剑指offer第24题——二叉树中和为某一值的路径
  • 原文地址:https://www.cnblogs.com/sun-or-moon/p/15231313.html
Copyright © 2011-2022 走看看