<jupyter_start><jupyter_text>张量的创建-   张量（Tensors）类似于 Numpy 的 ndarrays，但张量可以在 GPU 上进行计算。所以从本质上来说，Pytorch 是一个处理张量的库。一个张量是一个数字、向量、矩阵或任何 n 维数组。-   下面分别展示了 0 维张量到 n 维张量：![tensor_example](https://gitee.com/Miraclezjy/utoolspic/raw/master/tensor-2022-1-2110:36:51.png)<jupyter_code>import torch
import numpy as np
torch.manual_seed(7)  # 固定随机数种子<jupyter_output><empty_output><jupyter_text>一、直接创建-   `torch.tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False)`-   功能：从 data 创建 tensor    -   data：数据，可以是 list, numpy    -   dtype：数据类型，默认与 data 的一致    -   device：所在设备，cuda / cpu    -   requires_grad：是否需要梯度    -   pin_memory：是否存于锁页内存<jupyter_code>torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])<jupyter_output><empty_output><jupyter_text>-   `torch.from_numpy(ndarray)`-   功能：从 numpy 创建 tensor-   注意：从 torch.from_numpy 创建的 tensor 与原 ndarray 共享内存，当修改其中一个数据，另一个也将会被改动。<jupyter_code>a = np.array([1, 2, 3])
t = torch.from_numpy(a)
print("a: ", a)
print("t: ", t)<jupyter_output>a:  [1 2 3]
t:  tensor([1, 2, 3], dtype=torch.int32)<jupyter_text>二、依据数值创建1.  `torch.zeros(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：依 size 创建全 0 张量    -   size：张量的形状，如 (3, 3)、(3, 224, 224)    -   out：输出的张量    -   layout：内存中布局形式，有 strided, sparse_coo 等    -   device：所在设备，gpu / cpu    -   requires_grad：是否需要梯度<jupyter_code>torch.zeros(2, 3)<jupyter_output><empty_output><jupyter_text>2. `torch.zeros_like(input, dtype=None, layout=None, device=None, requires_grad=False)`-   功能：依 input 形状创建全 0 张量    -   input：创建与 input 同形状的全 0 张量    -   dtype：数据类型    -   layout：内存中布局形式<jupyter_code>input = torch.empty(2, 3)
torch.zeros_like(input)<jupyter_output><empty_output><jupyter_text>3. `torch.ones(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`<jupyter_code>torch.ones(2, 3)<jupyter_output><empty_output><jupyter_text>4. `torch.ones_like(input, dtype=None, device=None, requires_grad=False)`-   功能：依 input 形状创建全 1 张量    -   size：张量的形状，如 (3, 3), (3, 224, 224)    -   dtype：数据类型    -   layout：内存中布局形式    -   device：所在设备，gpu / cpu    -   requires_grad：是否需要梯度<jupyter_code>input = torch.empty(2, 3)
torch.ones_like(input)<jupyter_output><empty_output><jupyter_text>5. `torch.full(*size, full_value, dtype=None, layout=torch.strided, device=None, requires_grad=False)`<jupyter_code>torch.full((2, 3), np.pi)<jupyter_output><empty_output><jupyter_text>6. `torch.full_like(input, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：依 input 形状创建指定数据的张量    -   size：张量的形状，如 (3, 3)    -   fill_value：张量的值 7. `torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：创建等差的 1 维向量    -   start：数列起始值    -   end：数列结束值    -   step：数列公差，默认为 1-   注意：数值区间为 `[start, end)`<jupyter_code>torch.arange(1, 2.5, 0.5)<jupyter_output><empty_output><jupyter_text>8. `torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：创建均分的 1 维张量<jupyter_code>torch.linspace(start=-10, end=10, steps=5)<jupyter_output><empty_output><jupyter_text>9. `torch.logspace(start, end, steps=100, base=10.0, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`<jupyter_code>torch.logspace(start=0.1, end=1.0, steps=5)<jupyter_output><empty_output><jupyter_text>10. `torch.eye(n, m=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：创建单位对焦矩阵（2 维张量）-   注意：默认为方阵    -   n：矩阵行数    -   m：矩阵列数<jupyter_code>torch.eye(3)<jupyter_output><empty_output><jupyter_text>三、依概率分布创建张量1. `torch.normal(mean, std, out=None)`-   功能：生成正态分布（高斯分布）    -   mean：均值    -   std：标准差-   四种模式：    -   mean 为标量，std 为标量    -   mean 为标量，std 为张量    -   mean 为张量，std 为标量    -   mean 为张量，std 为张量<jupyter_code># mean 为张量，std 为张量
torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))<jupyter_output><empty_output><jupyter_text>2. `torch.normal(mean, std, size, out=None)`-   功能：生成一定大小的正态分布（高斯分布）<jupyter_code>torch.normal(2, 3, size=(1, 4))<jupyter_output><empty_output><jupyter_text>3. `torch.randn(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：生成标准正态分布    -   size：张量的形状<jupyter_code>torch.randn(2, 3)<jupyter_output><empty_output><jupyter_text>4. `torch.rand(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：在区间 `[0, 1)` 上，生成均匀分布<jupyter_code>torch.rand(2, 3)<jupyter_output><empty_output><jupyter_text>5. `torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)`-   功能：在区间 `[low, high)` 生成整数均匀分布    -   size：张量的形状<jupyter_code>torch.randint(3, 10, (2, 2))<jupyter_output><empty_output><jupyter_text>6. `torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False)`-   功能：生成从 0 - 1 的随机排列    -   n：张量的长度<jupyter_code>torch.randperm(4)<jupyter_output><empty_output><jupyter_text>7. `torch.bernoulli(input, *, generator=None, out=None)`-   功能：以 input 为概率，生成伯努利分布（0-1 分布，两点分布）    -   input：概率值<jupyter_code>a = torch.empty(3, 3).uniform_(0, 1)
print("a: ", a)
torch.bernoulli(a)<jupyter_output>a:  tensor([[0.4703, 0.1049, 0.5137],
        [0.2674, 0.4990, 0.7447],
        [0.7213, 0.4414, 0.5550]])<jupyter_text>张量的操作 一、张量拼接与切分1. `torch.cat(tensor, dim=0, out=None)`-   功能：将张量按维度 dim 进行拼接    -   tensors：张量序列    -   dim：要拼接的维度<jupyter_code>x = torch.randn(2, 3)
torch.cat((x, x, x), 1)<jupyter_output><empty_output><jupyter_text>2. `torch.stack(tensors, dim=0, out=None)`-   功能：在新创建的维度 dim 上进行拼接    -   tensors：张量序列    -   dim：要拼接的维度3. `torch.chunk(input, chunks, dim=0)`-   功能：将张量按维度 dim 进行平均切分-   返回值：张量列表-   注意：若不能整除，最后一份张量小于其他张量    -   input：要切分的张量    -   chunks：要切分的份数    -   dim：要切分的维度4. `torch.split(tensor, split_size_or_sections, dim=0)`-   功能：将张量按维度 dim 进行切分-   返回值：张量列表    -   tensor：要切分的张量    -   split_size_or_sections：为 int 时，表示每一份的长度；为 list 时，按 list 元素切分    -   dim：要切分的维度<jupyter_code>a = torch.arange(10).reshape(5, -1)
print("a:\n", a)
torch.split(a, 2)<jupyter_output>a:
 tensor([[0, 1],
        [2, 3],
        [4, 5],
        [6, 7],
        [8, 9]])<jupyter_text>二、张量索引1. `torch.index_select(input, dim, index, out=None)`-   功能：在维度 dim 上，按 index 索引数据-   返回值：依 index 索引数据拼接的张量    -   input：要索引的张量    -   dim：要索引的维度    -   index：要索引数据的序号<jupyter_code>x = torch.randn(3, 4)
indices = torch.tensor([0, 2])
torch.index_select(x, 0, indices)<jupyter_output><empty_output><jupyter_text>2. `torch.masked_select(input, mask, out=None)`-   功能：按 mask 中的 True 进行索引-   返回值：一维张量    -   input：要索引的张量    -   mask：与 input 同形状的布尔类型张量<jupyter_code>x = torch.randn(3, 4)
mask = x.ge(0.5)
torch.masked_select(x, mask)<jupyter_output><empty_output><jupyter_text>三、张量变换1. `torch.reshape(input, shape)`-   功能：变换张量形状-   注意：当张量在内存中是连续时，新张量与 input 共享数据内存    -   input：要变换的张量    -   shape：新张量的形状<jupyter_code>a = torch.arange(4.)
torch.reshape(a, (2, 2))<jupyter_output><empty_output><jupyter_text>2. `torch.transpose(input, dim0, dim1)`-   功能：交换张量的两个维度    -   input：要交换的张量    -   dim0：要交换的维度    -   dim1：要交换的维度<jupyter_code>x = torch.randn(2, 3)
print("x:\n", x)
print("After transpose:")
torch.transpose(x, 0, 1)<jupyter_output>x:
 tensor([[ 0.0096, -0.5704, -0.1722],
        [ 0.4506,  0.4101,  0.8957]])
After transpose:<jupyter_text>3. `torch.t(input)`-   功能：二维张量转置，对矩阵而言，等价于 `torch.transpose(input, 0, 1)`<jupyter_code>x = torch.randn(())
print("x:\n", x)
torch.t(x)<jupyter_output>x:
 tensor(-0.2882)<jupyter_text>4. `torch.squeeze(input, dim=None, out=None)`-   功能：压缩长度为 1 的维度（轴）    -   dim：若为 None，移除所有长度为 1 的轴；若指定维度，当且仅当该轴长度为 1 时，可以被移除<jupyter_code>x = torch.zeros(2, 1, 2, 1, 2)
print("x:\n", x)
y = torch.squeeze(x)
y<jupyter_output>x:
 tensor([[[[[0., 0.]],

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



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

          [[0., 0.]]]]])<jupyter_text>5. `torch.unsqueeze(input, dim, out=None)`-   功能：依据 dim 扩展维度    -   dim：扩展的维度<jupyter_code>x = torch.tensor([1, 2, 3, 4])
torch.unsqueeze(x, 0)<jupyter_output><empty_output><jupyter_text>线性回归模型线性回归是分析一个变量与另外一（多）个变量之间关系的方法。因变量是 y，自变量是 x，关系线性：$y = \omega \times x + b$，任务是求解 $\omega, b$。我们的求解步骤是：1. 确定模型：$Model \rightarrow y = \omega \times x + b$2. 选择损失函数：这里用 $MSE: \frac{1}{m}\sum_{i=1}^m(y_i-\hat y_i)^2$3. 求解梯度并更新 $\omega, b$：$$\begin{array}{lcl}w &=& w - lr \times w.grad \\b &=& b - lr \times w.grad\end{array}$$下面我们开始写一个线性回归模型：<jupyter_code># 首先我们需要训练样本 X, Y，这里我们随机生成
x = torch.rand(20, 1) * 10
y = 2 * x + (5 + torch.randn(20, 1))

# 构建线性回归函数的参数
w = torch.randn((1), requires_grad=True)
b = torch.randn((1), requires_grad=True)  # 这两者都需要求梯度

# 设置学习率 lr 为 0.1
lr = 0.1

for iteration in range(100):
    # 前向传播
    wx = torch.mul(w, x)
    y_pred = torch.add(wx, b)

    # 计算 loss
    loss = (0.5 * (y - y_pred)**2).mean()

    # 反向传播
    loss.backward()

    # 更新参数
    b.data.sub_(lr * b.grad)  # 这种 _ 的加法操作时从自身减，相当于 -=s
    w.data.sub_(lr * w.grad)

    # 梯度清零
    w.grad.data.zero_()
    b.grad.data.zero_()

print(w.data, b.data)<jupyter_output>tensor([-1.3531e+27]) tensor([-2.1245e+26])
{'fraction_non_alphanumeric': 0.17583388557543628, 'fraction_numerical': 0.038988292467417716, 'mean_word_length': 4.627719080174021, 'pattern_counts': {'":': 0, '<': 110, '<?xml version=': 0, '>': 110, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '29', 'dir': 'jupyter-structured-clean-dedup', 'id': '553952', 'license': 'MIT', 'n_tokens_mistral': 4815, 'n_tokens_neox': 5034, 'n_words': 620, 'path': 'MachineLearning/pytorch_learning.ipynb', 'repo_name': 'AnotherOnezjy/Miracle', 'size': '9054'}