pytorch基础入门

pytorch基础入门

在学习中，肯定很多人不了解为什么要用pytorch去处理数据，而不用熟悉的numpy，并且学过的也知道pytorch的运用跟numpy的运用十分类似！

首先介绍一下张量

张量（Tensor）是 PyTorch 中的一个重要概念。它是一个多维数组，可以看作是标量、向量、矩阵的高维拓展.在 PyTorch 中，torch.Tensor（PyTorch 中的张量）是操作数据的主要工具，基本和 Numpy 类似，只是 Tensor 可以在 GPU 上进行运算，可以进行自动求梯度等操作。这意味着你可以使用张量来存储和操作数据，例如图像、声音、文本等.

大家就会想，为什么能在GPU上运算就会更好呢？

GPU（图形处理单元）比CPU（中央处理单元）更适合进行大规模并行运算。这是因为GPU的设计目的是为了处理大量的计算任务，而CPU则是为了处理串行指令而优化的。在深度学习和神经网络中，许多计算都可以并行完成，因此使用GPU可以加速这些计算。

此外，GPU通常拥有比CPU更多的计算核心，这意味着它能够同时处理更多的任务。例如，在深度学习中，神经网络是高度并行的，可以将整个任务分解成一组较小的任务以并行计算。因此，使用GPU可以大大提高深度学习和神经网络计算的速度。

所以，开始我们的深度学习之旅吧！（沐神的深度学习）

注意虽然它被称为pytorch，但是代码中使用的是torch而不是pytorch

import torch

首先用arange创建一个行向量x。

x = torch.arange(12)
x

我就不一一写，一些简单的直接打出来一笔代过，有点技巧性的我再细写

x.shape:可知道size是多少

x.numel():张量总数

x.reshape(n,m):转变成n行m列的矩阵

torch.zeros():生成全为0的张量，维度可以按照自己想要的定 eg.torch.zeros((2, 3, 4))

torch.ones():生成全为1的张量

随机生成均值为0，标准差为1的标准高斯分布：在深度学习经常出现，因为高斯分布的熵是所有分布中最大的。可以这样理解，“熵最大”是为了使理想更接近实际，让特殊逼近一般，从而使模型更具一般性。在高斯分布的情况下，我们使用相应的模型得到的结果是稳健的。

torch.randn(3, 4)

维度拼接：torch.cat()

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

按照行和列拼接

将大小为1的张量转换为python的标量

a = torch.tensor([3,5])
a, a.item(), float(a), int(a)

接下来就是pd怎么转torch

访问路径写入，再读出

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

#处理缺失值
inputs, outputs = data.iloc[:,0:2], data.iloc[:,2]
inputs = inputs.fillna(inputs.mean())
input

视NAN为一个类别，其他自动分类

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

转换为张量

import torch
X, y = torch.tensor(inputs.values),torch.tensor(outputs.values)
X, y

运算符

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

还有其他什么 exp之类的 。。。。

有一个很重要 X.sum()：对张量中的所有元素进行求和，会产生一个单元素张量

X.sum()

广播机制

广播机制是一种在形状不同的张量上应用算术运算的方法。它允许较小的数组“广播至”较大的数组，使两者形状互相兼容。广播提供了一种向量化数组操作的机制，可以避免不必要的数据复制，通常导向高效的算法实现。

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

a + b

逻辑就是都广播成3*2的矩阵然后进行加法

索引和切片

X = torch.arange(12, dtype=torch.float32).reshape((3, 4))
X[-1], X[1:3]

赋值

X[1, 2] = 9
X

X[0:2, :] =12
X

节省内存

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

before = id(Y)
Y = Y + X
id(Y) == before

输出是False
这样的写法可能不可取，沐神的说法是

执行原地操作

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

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

X[:] = X + Y的意思就是：在原地修改数组X的方法。它使用了切片语法 [:]来选择数组X中的所有元素，然后将这些元素替换为X+Y 的结果。这样，数组X中的每个元素都会被更新为原来的值加上数组Y中对应位置的值。

before = id(X)
X+=Y
id(X) ==before