PyTorch是一个基于Python的深度学习框架，它提供了一种灵活、高效、易于学习的方式来实现深度学习模型。PyTorch最初由Facebook开发，被广泛应用于计算机视觉、自然语言处理、语音识别等领域。

安装

建议创建一个新的conda虚拟环境来安装pytorch，避免弯弯绕绕

这里我们选择创建python版本为3.9的conda虚拟环境

conda create -n universal python=3.9

也可以直接在Anaconda里面直接创建。

检查CPU版本

在命令提示符内输入；

nvidia-smi

会显示我们CPU的版本以及CPU算力。

根据CPU版本去官网选择对应的Torch版本

https://pytorch.org/get-started/previous-versions/

复制官网的下载链接下载到对应的虚拟环境即可（需先切换到对应提前创建的虚拟环境），我在这里是选择下载的11.1的版本

下载文件较大，中途不能断网，断了就得重下了。

可能会出现的问题。

numpy版本不兼容，版本不宜过高

中途出现报错的话，就卸载掉原有numpy，重新下载指定版本的numpy。

Torch简介

PyTorch会将数据封装成张量（Tensor）进行计算，所谓张量就是元素为相同类型的多维矩阵。

张量可以在 GPU 上加速运行。

类型：

PyTorch中有3种数据类型：浮点数、整数、布尔。其中，浮点数和整数又分为8位、16位、32位、64位，加起来共9种。

按维度看的话；

标量 是 0 阶张量，只有大小没有方向(温度,高度),如 a = torch.tensor(5)

向量 是 1 阶张量，具有大小和方向(加速度,力),如 b = torch.tensor([1, 2, 3])

2维矩阵 是 2 阶张量,线性变换(旋转矩阵,位移矩阵)，,如 c = torch.tensor([[1, 2], [3, 4]])

        更高维度的张量，如3维、4维等，通常用于表示图像、视频数据等复杂结构。

1.创建tensor

1.1 torch.tensor

该API是为创建指定数据的张量的

参数：

dtype：数据类型

device：用于计算的设备，分为CPU和‘cuda’（GPU）

（1）可以直接丢数据进去创建，还可以创建标量

（2）也可以用随机数指定维度先创建numpy数组，再创建torch张量

（3）也可以直接创建列表，再转成torch张量

import torch
import numpy as np
x = torch.tensor([1,2,3,4],device='cuda')
x1 = torch.tensor(5)
x3 = np.random.randn(4,4)
x3 = torch.tensor(x3)
x4 = [324,234,234,234],[34,234,234,32]
x4 = torch.tensor(x4)

1.2 torch.Tensor

这个API可以根据维度创建，也可以指定数据（总体跟tensor功能差不多）

import torch
#输出结果不用科学计数法
torch.set_printoptions(sci_mode=False)
#创建的张量为随机浮点数的数组
x = torch.Tensor(3,4,3)
x2 = torch.tensor([10])
print(x)
print(x2.shape)

1.3 创建线性张量

使用torch.arange 和 torch.linspace 和torch.logspace创建线性张量：

import torch
torch.set_printoptions(sci_mode=False)
def test():
    r = torch.arange(1,21,2)
    # print(r)
    #创建一个等差数列
    g = torch.linspace(1,30,14)
    # print(g)
    #创建一个等比数列
    b = torch.logspace(3,10,10,base=3)
    print(b)

2.随机张量

2.1 随机数种子

随机数生成器是一种算法，用于生成一个看似随机的数列，但如果使用相同的种子进行初始化，生成器将产生相同的数列。（随机数种子）

设置 manual_seed( )
获取 torch.initial_seed( )

import torch
def test_random():
    #设置随机数种子
    torch.manual_seed(666)
    #获取随机数种子
    print(torch.initial_seed())

在 PyTorch 中，种子影响所有与随机性相关的操作，包括张量的随机初始化、数据的随机打乱、模型的参数初始化等。通过设置随机数种子，可以做到模型训练和实验结果在不同的运行中进行复现。

生成一组随机张量： torch.rand( )

生成一组随机张量，呈正太分布        torch.randn( ) 

import torch
def test_seed():
    #设置种子
    torch.manual_seed(666)
    #生成随机张量
    print(torch.rand(2,3))
    # 生成随机张量：标准正态分布
    print(torch.randn(4,4))

3.创建01张量

3.1 创建全0张量

torch.zeros 和 torch.zeros_like

import torch
def test_zero():
    #创建一个全0张量
    x = torch.zeros(4,4)
    print(x)
    #创建一个全1张量
    x1 = torch.ones((4,5))
    #用zeros_ones方法转成一个全0张量
    x2 = torch.zeros_like(x1)
    print(x2)

3.2 创建全1张量

torch.ones 和 torch.

ones_like

import torch
def test_one():
    #创建一个全1张量
    x = torch.ones(4,4)
    print(x)
    #创建一个全0张量
    x1 = torch.zeros((4,5))
    #用zeros_ones方法转成一个全1张量
    x2 = torch.ones_like(x1)
    print(x2)

4. 创建指定值张量

torch.full 和 torch.full_like 创建全为指定值张量。

import torch
def test_full():
    #用full创建一个2维张量，全部用666填充
    x = torch.full((3,3),666)
    print(x)
    #用full_like方法将x内的666替换为999
    x1 = torch.full_like(x,999)
    print(x1)

5. 创建单位矩张量

也就是创建一个单位矩阵，不过是单位张量。

API：为torch.eye( ),括号内为整数

import torch
def test_eye():
   x = torch.eye(6)
   print(x)

Tensor常见属性

张量有device、dtype、shape等常见属性

1. 切换设备

第一种方法，定义一个三元表达式用于切换

 #把数据切换到GPU进行计算
    device = "cuda" if torch.cuda.is_available() else "cpu"

第二种方法，手动切换

data = data.cuda()
    print(data.device)

第三种，我认为最方便简单的

就是在创建张量时，把张量给定义到GPU上

 data = torch.tensor([1, 2, 3],device='cuda')

2. 类型转换

# 1. 使用type进行类型转换
    data = data.type(torch.float32)
    print(data.dtype)  # float32
    data = data.type(torch.float16)
    print(data.dtype)  # float16

    # 2. 使用类型方法
    data = data.float()
    print(data.dtype)  # float32
    data = data.half()
    print(data.dtype)  # float16
    data = data.double()
    print(data.dtype)  # float64
    data = data.long()
    print(data.dtype)  # int64

五、Tensor数据转换

张量转numpy

共享内存时（浅拷贝）

调用numpy()方法可以把Tensor转换为Numpy，此时内存是共享的。

def test():
    x = torch.tensor([1,2,3,4])
    x_numpy = x.numpy()
    x_numpy[0] = 20
    print(x_numpy)
    print(x)

更新下标[0]时，双方数据都有更改，说明此次转换是浅拷贝

不共享内存时（深拷贝）

使用copy( )方法

import torch
def test():
    x = torch.tensor([1,2,3,4])
    #使用copy（）方法
    x_numpy = x.numpy().copy()
    x_numpy[0] = 20
    print(type(x))
    print(type(x_numpy))
    print(x_numpy)
    print(x)

Numpy转张量

共享内存时（浅拷贝）

使用from_numpy（）方法，此时的内存是共享的

import torch
import numpy as np
def test006():
    # 1. numpy转张量
    data_numpy = np.array([[1, 2, 3], [4, 5, 6]])
    data_tensor = torch.from_numpy(data_numpy)
    print(type(data_tensor), type(data_numpy))

    # 2. 他们内存是共享的
    data_tensor[0, 0] = 100
    print(data_tensor, data_numpy)

不共享内存时（深拷贝）

直接用torch.tensor( )，是不共享内存的。

data_numpy = np.array([[1, 2, 3], [4, 5, 6]])
    data_tensor = torch.tensor(data_numpy)

六.Tensor与图像

6.1 图片转Tensor

调用这两个库；

from PIL import Image
from torchvision import transforms

图片转tosor的方法是

先读取图片

imgpath = r"./105429.jpg"
        # 1. 读取图片
        img = Image.open(imgpath)

然后实例化转换器（transfroms.ToTensor）。再将要转换得图片使用转换器转换

6.2 Tensor转图片

跟上面的方法差不多，只是转换器的参数是transfroms.ToPILImage（）

  img_tensor = torch.randn(3, 224, 224)
    # 2. 创建一个transforms
    transform = transforms.ToPILImage()
    # 3. 转换为图片
    img = transform(img_tensor)
    img.show()
    # 4. 保存图片
    img.save("./test.jpg")