pytorch-TensorFlow-线性回归

在之前的简单线性回归代码中，没有用到矩阵的形式。

所以当有多个变量的时候写起来也比较复杂，今天就用矩阵来表示这些变量，以达到简化的效果。

写一个简单的神经网络，来看看tf.Keras.Dense层和pytorch.nn.Linear层里面究竟是怎样实现的，它的过程是怎样的。

如果对神经网络，以及矩阵乘法不太了解的，请去百度百科了解一下，也是非常的简单。

下面先来写一下代码 ：

import tensorflow as tf
import numpy as np
x =    #假设x.shape（n，2）
y =    #假设y.shape(n,1)

w = tf.Variable(tf.random.randn([2,1],name='weight')   #w,b这里的参数与x，y的				     shape对应
b = tf.Variable(tf.random.randn([1],name='bias')

def linear_regression():
	return x*w + b
def square_loss(y_pred,y_true):
	return tf.reduce_mean(tf.pow(y_pred-y_true,2).sum())
optimizer = tf.optimizers.SGD(0.01)   #应用随机梯度下降算法，是梯度下降下降算法的一种改进。
def run_optimization():
	with tf.GradientTape() as g:      #获取 梯度信息
		pred = linear_regression()
		loss = square_loss(pred,y)
	gradients = g.gradients(loss,[w,b])  #得到loss对变量w，b的梯度
	optimizer.apply_gradients(zip(gradients,[w.b])  #通过梯度信息，更新变量w，b将loss最小化
for i in range(100):
	run_optimization()

下面是pytorch代码

import torch
import numpy as np
from torch.autograd import Variable
x =   #numpy.float32数据类型  
y =   #numpy.float32数据类型

x , y = torch.from_numpy(x), torch.from_numpy(y)  #将numpy数据转换成tensor

w = Variable(torch.randn(1),requires_grad=True)
b = Variable(torch.randn(1),requires_grad=True)
def linear_regression():
    return x*w.expand_as(x) + b.expand_as(x)

for i in range(100):
    if (w.grad is not None) and (b.grad is not None):  
        w.grad.data.zero_() #因为梯度会累加 ，  所以在更新之前要先将之前的梯度信息归零
        b.grad.data.zero_() 
    pred = linear_regression()
    loss = torch.mean((pred - y) ** 2) 
    
    loss.backward()#方向传播 ，得到 变量的梯度
    print(loss)
    w.data.add_(- 0.01 * w.grad.data)  #利用上一步计算中得到的w的梯度信息更新w中的data数值
    b.data.add_(- 0.01 * b.grad.data)  #利用上一步计算中得到的b的梯度信息更新b中的data数值

上面没有用到形成的神经网络，下面来调用api实现线性回归

import torch
import torch.nn as nn
import torch.optim
from torch.autograd import Variable

x =    
y =

class Net(nn.Model):
	def __init__(self):
		super(Net,self).__init__()  #自动寻找基类
		self.layers = nn.Linear(1,1)   #输入输出数据的维度
	def forwadr(self,x):
		x = self.layers(x)
		return x     #进行前向传播
net = Net()
optimizer = torch.optim.SGD(0.001)
error = torch.nn.MSELoss()
for i in range(1100):
	pred = net(x)
	loss = error(pred,y)
	optimizer.zero_grad()   #清除梯度信息
	loss.backward() 		#生成梯度信息
	optimizer.step()        #应用梯度信息
 

在用TensorFlow来实现一下，对比一下两框架的区别以便跟好的学习

import tensorflow as tf
from tensorflow.keras import Model , layers

x = 
y = 
class Net(Model):
	def __init__(self):
		super(Net,self).__init__()
		self.layers = layers.Dense(1,activation='relu')
	def forward(self,x):
		x = self.layers(x)
		return x
def square_loss(y_pred,y_true):
	return tf.reduce_mean(tf.pow(y_pred-y_true,2).sum())
optimizer = tf.optimizers.SGD(0.001)
net = Net()
def run_optimization():
	with tf.gradientTape() as g:
		pred = net(x)
		loss = square_loss(pred,y)
	trainable_cariables = net.trainable_variables
	gradients = g.gradient(loss,trainable_cariables)
	optimizer.apply_gradients(zip(gradients,trainable_cariables))

通过代码，我们已经对这两个框架的基本的使用有了一定的了解，也对利用神经网络完成线性回归任务用了一定的了解，那要实现逻辑回归呢??有没有想过？例如识别手写数字。

Thank for your reading ！！！ 、