hbase最新版本配置属性

import torch
from torch.nn import Conv2d,MaxPool2d,Sequential,Flatten,Linear
import torchvision
import torch.optim.optimizer
from torch.utils.data import DataLoader,dataset
from torch import nn
import torch.optim.optimizer


# 建模
model = nn.Linear(2,1)

#损失
loss = nn.MSELoss()
#优化
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.8)

#定义输入和标签
input = torch.tensor([[2.,7.],[1.,6.]])
y = torch.tensor([[1.],[3.]])

#输入模型数据
out= model(input)
print(out)
#计算损失
loss_fn = loss(y,out)
print(loss_fn.item())
#梯度清零
optimizer.zero_grad()
#反向传播
loss_fn.backward()
print(loss_fn.item())
#更新梯度
optimizer.step()

# 再次进行前向传播和反向传播
x = torch.tensor([[5., 6.], [7., 8.]])
y_true = torch.tensor([[11.], [15.]])
y_pred = model(x)
loss = loss_fn(y_pred, y_true)
optimizer.zero_grad()
loss.backward()
optimizer.step()



'''
optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr = 0.0001)



# SGD 就是随机梯度下降
opt_SGD         = torch.optim.SGD(net_SGD.parameters(), lr=LR)
# momentum 动量加速,在SGD函数里指定momentum的值即可
opt_Momentum    = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
# RMSprop 指定参数alpha
opt_RMSprop     = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
# Adam 参数betas=(0.9, 0.99)
opt_Adam        = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))


计算损失
w=w−l_r*dw
b=b-l_r*db

dw和db分别是权重和偏置的梯度，learning_rate是学习率，控制每次更新的步长
'''

def  hook():

    # 定义模型参数
    w = torch.tensor([1.0], requires_grad=True) #requires_grad=True 的作用是让 backward 可以追踪这个参数并且计算它的梯度。
    b = torch.tensor([0.0], requires_grad=True) ##requires_grad=True 的作用是让 backward 可以追踪这个参数并且计算它的梯度。

    # 定义输入和目标输出
    x = torch.tensor([2.0])
    y_true = torch.tensor([4.0])

    # 定义损失函数
    loss_fn = torch.nn.MSELoss()

    # 定义优化器
    optimizer = torch.optim.SGD([w, b], lr=0.1)

    # 迭代训练
    for i in range(100):
        # 前向传播
        y_pred = w * x + b
        loss = loss_fn(y_pred, y_true)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        # 提取梯度  我们使用loss.backward()计算损失函数对于模型参数的梯度，并将其保存在相应的张量的.grad属性中
        dw = w.grad
        db = b.grad
        print("dw".format(dw))
        print("db".format(db))
        # 更新模型参数
        optimizer.step()

    # 输出模型参数
    print("w = ", w)
    print("b = ", b)

记录一些api：

表3-1: 常见新建tensor的方法