pytorch和tensorflow的爱恨情仇之一元线性回归例子（keras插足啦）

直接看代码：

一、tensorflow

#tensorflow
import tensorflow as tf
import random
import numpy as np

x_data = np.random.randn(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3
weights = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
biases = tf.Variable(tf.zeros([1]))

y = weights * x_data + biases
losses = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(losses)

init = tf.initialize_all_variables()
with tf.Session() as sess:
    sess.run(init)
    for step in range(10):
        sess.run(train)
        print(step, sess.run(weights), sess.run(biases))

2、pytorch

#pytorch
import torch
import numpy as np

x_data = np.random.randn(100).astype(np.float32)
y_data = x_data * 0.3 + 0.1
x_data = torch.from_numpy(x_data)
y_data = torch.from_numpy(y_data)

weights = torch.rand(1,requires_grad=True)
biases = torch.zeros(1,requires_grad=True)
print("初始参数weights:{}, biases:{}".format(weights.data, biases.data))
parameters = [weights, biases]

criterion = torch.nn()
optimizer = torch.optim.SGD(parameters, 0.5)
for i in range(10):
    y = weights * x_data + biases
    losses = criterion(y_data, y)
    print(losses.data, weights.data, biases.data)
    optimizer.zero_grad()
    losses.backward()
    optimizer.step()

三、keras

#keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
import numpy as np

x_data = np.random.randn(100).astype(np.float32)
y_data = x_data * 0.3 + 0.1

model = Sequential()

model.add(Dense(input_dim=1, units=1))

model.compile(loss="mse", optimizer=SGD(lr=0.5))
for i in range(10):
    losses = model.train_on_batch(x_data, y_data)
    w, b = model.get_weights()
    print(losses, w, b)

接下来我们再细说他们各自的一些异同：

不同点：

• pytorch要求输入的是tensor，而tensorflow和keras可以是numpy；
• tensorflow1.x是静态图，我们可以先定义好相关的操作，然后在session中执行即可；pytorch使用的是动态图，我们要在循环的过程中计算相关的损失；keras封装的更高级，只需要像model.compile()中传入损失函数以及优化方法，我们不用显示计算；
• tensorflow要求在定义好计算图之后，在Session()执行图上的计算操作；
• tensorflow初始化参数的时候是定义一个tf.initialize_all_variables()，然后在session中首先执行初始化操作：sess.run(init)；pytorch是将相关的参数封装成一个列表，然后传入给优化器；至于keras(我知道的是使用Sequential()来构建模型，不知道有没有自定义的参数实现，不使用类）；
• tensorflow使用optimizer.minimize(losses)来最小化损失，pytorch使用loss.backward()，optimizer.step()，实质都是使用反像传播算法不断优化参数使得损失最小化；keras直接使用model.train_on_batch()即可；

相同点：

• 总体思路是一致的：输入数据---》定义参数--》计算损失--》定义优化器--》循环迭代，最小化损失。

总结：这只是一个简单的对比，但是这么一套流程，就可以套用到各种神经网络中了，只是数据的处理、网络结构的搭建等不同。