pytorch 计算tensor内存大小 pytorch tensor tensor

一、补充知识：

1. Tensor和tensor的区别：

在PyTorch中，Tensor和tensor都能用于生成新的张量：

>>>import numpy as np
>>> a=torch.Tensor([1,2])
>>> a
tensor([1., 2.])
>>> a=torch.tensor([1,2])
>>> a
tensor([1, 2])

2. 计算图

https://zhuanlan.zhihu.com/p/69294347

3. 《动手学深度学习》

https://tangshusen.me/Dive-into-DL-PyTorch/#/chapter02_prerequisite/2.2_tensor

二、代码部分

1. 前馈过程

2. 线性模型的计算图(一)

2.1 代码实现

import numpy as np
import matplotlib.pyplot as plt
import torch

# 定义数据集
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w = torch.Tensor([1.0])  # 初始权值
w.requires_grad = True   # 计算梯度，True是需要计算，False是不计算的


def forward(x):     # 定义线性模型 y^ = x * w
    return x * w    # w 是 Tensor ， 所以会自动将x 转换为Tensor


def loss(x, y):     # 定义损失函数，构建计算图
    y_pred = forward(x)
    return (y_pred - y) ** 2     # loss = (y^ - y)**2

epoch_list = []
loss_list = []
print('Predict (befortraining)', 4, forward(4))

for epoch in range(100):    # 训练过程
    for x, y in zip(x_data, y_data):
        l = loss(x, y)      # 前馈过程
        l.backward()        # 反馈过程，.backward自动对w求导，
        print('\tgrad:', x, y, w.grad.item())  # item是将梯度grad里的数值拿出来变成一个标量
        w.data = w.data - 0.01 * w.grad.data   # 注意这里的grad是一个tensor，所以要取他的data，0.01是学习率
        w.grad.data.zero_()                    # 释放之前计算的梯度，清零
    print('Epoch:', epoch, 'loss=', l.item())
    epoch_list.append(epoch)    # 生成epoch列表，便于后面画图
    loss_list.append(l.item())  # 生成loss列表，便于后面画图
print('Predict(after training)', 4, forward(4).item())

# 打印损失图
plt.plot(epoch_list,loss_list)
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()

3. 线性模型的计算图(二)

3.1 代码实现

import numpy as np
import matplotlib.pyplot as plt
import torch

# 定义数据集
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w = torch.Tensor([1.0])    # 初始权值, #
w.requires_grad = True     # requires_grad = True计算梯度，True是需要计算，False是不计算的
b = torch.Tensor([2.0])
b.requires_grad=True

def forward(x):         # 定义线性模型 y^ = x * w
    return x * w +b     # w 是 Tensor ， 所以会自动将x 转换为Tensor


def loss(x, y):         # 定义损失函数，构建计算图
    y_pred = forward(x)
    return (y_pred - y) ** 2  # loss = (y^ - y)**2


epoch_list = []
loss_list = []
print('Predict (befortraining)', 4, forward(4))

for epoch in range(500):  # 训练过程,epoch设为500时效果明显
    for x, y in zip(x_data, y_data):
        l = loss(x, y)  # 前馈过程
        l.backward()  # 反馈过程，.backward自动对w求导，
        print('\tgrad:', x, y, w.grad.item(), b.grad.item())  # item是将梯度grad里的数值拿出来变成一个标量
        w.data = w.data - 0.01 * w.grad.data  # 对w做更新，注意这里的grad是一个tensor，所以要取他的data，0.01是学习率
        b.data = b.data - 0.01 * b.grad.data
        w.grad.data.zero_()  # 释放之前计算的梯度，清零
        b.grad.data.zero_()
    print('Epoch:', epoch, 'loss=', l.item())
    epoch_list.append(epoch)  # 生成epoch列表，便于后面画图
    loss_list.append(l.item())  # 生成loss列表，便于后面画图
print('Predict(after training)', 4, forward(4).item())

# 打印损失图
plt.plot(epoch_list, loss_list)
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()

4. 课后作业

4.1 代码实现

import matplotlib.pyplot as plt
import torch

# 定义数据集
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w1 = torch.Tensor([1.0])  # 初始权值
w1.requires_grad = True  # requires_grad = True计算梯度，True是需要计算，False是不计算的
w2 = torch.Tensor([1.0])  # 初始权值
w2.requires_grad = True
b = torch.Tensor([2.0])
b.requires_grad = True


def forward(x):  # 定义线性模型 y^ = x * w
    return w1 * x**2 + w2 * x + b


def loss(x, y):  # 定义损失函数，构建计算图
    y_pred = forward(x)
    return (y_pred - y) ** 2  # loss = (y^ - y)**2


epoch_list = []
loss_list = []
print('Predict (befortraining)', 4, forward(4))

for epoch in range(100):  # 训练过程
    for x, y in zip(x_data, y_data):
        l = loss(x, y)  # 前馈过程
        l.backward()  # 反馈过程，.backward自动对w求导，
        print('\tgrad:', x, y, w1.grad.item(), w2.grad.item(),b.grad.item())  # item是将梯度grad里的数值拿出来变成一个标量
        w1.data = w1.data - 0.01 * w1.grad.data  # 对w做更新，注意这里的grad是一个tensor，所以要取他的data，0.01是学习率
        w2.data = w2.data - 0.01 * w1.grad.data
        b.data = b.data - 0.01 * b.grad.data
        w1.grad.data.zero_()  # 释放之前计算的梯度，清零
        w2.grad.data.zero_()
        b.grad.data.zero_()
    print('Epoch:', epoch, 'loss=', l.item())
    epoch_list.append(epoch)  # 生成epoch列表，便于后面画图
    loss_list.append(l.item())  # 生成loss列表，便于后面画图
print('Predict(after training)', 4, forward(4).item())

# 打印损失图
plt.plot(epoch_list, loss_list)
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()