TensorFlow2.x简单入门，编写一个简单的一元线性回归

 1.调用Eager Execution

这是因为在TensorFlow 2.x中，Eager Execution是默认开启的，因此直接引入TensorFlow即可。

import tensorflow as tf

2.使用tensorflow2.x读入一个序列之后将其打印

data=tf.constant([1,2])
print(data)

得到结果 维度大小2，数据类型int32

tf.Tensor([1 2], shape=(2,), dtype=int32)

 tensor数据转化为Numpy数据

data=tf.constant([1,2])
print(data.numpy())
print(type(data))
print(type(data.numpy()))

[1 2]

3.数据读取

使用TensorFlow中自带的Dateset API可完成数据的迭代

3.1 生成数据

生成一维的numpy向量

import numpy as np
arr_list=np.arange(0,100)

3.2 使用Dataset读取API

dataset = tf.data.Dataset.from_tensor_slices(arr_list)
dataset_iterator = dataset.shuffle(shape[0]).batch(10)

这里首先使用Dataset.from_tensor_slices读取数据，之后使用shuffle函数打乱顺序，最终将数据以每个batch为10输出。

3. 2 创建计算模型

将输入的数据乘以10并输出

def model(xs):
    outputs = tf.multiply(xs,10)
    return outputs

3.3 数据的迭代输出

for it in dataset_iterator:
    logits = model(it)
    print(logits)

 下面是输出结果

tf.Tensor([780 830 210 190 860 980 620 580 630 180], shape=(10,), dtype=int32)
tf.Tensor([ 40 910 690 660 850 650 720 360 240  10], shape=(10,), dtype=int32)
tf.Tensor([840 600 110 570 590  80 470 270  70 990], shape=(10,), dtype=int32)
tf.Tensor([560 950 150 730   0 480 770 290 120 900], shape=(10,), dtype=int32)
tf.Tensor([760 350 810 440 140 450 530 710 170 220], shape=(10,), dtype=int32)
tf.Tensor([ 60  90 930 490  20 390 960 610 750 430], shape=(10,), dtype=int32)
tf.Tensor([410 970 260 700 330 340 510 550 870 880], shape=(10,), dtype=int32)
tf.Tensor([370 800 890 320 310 680  30 790 230 280], shape=(10,), dtype=int32)
tf.Tensor([380  50 940 250 300 640 540 500 740 460], shape=(10,), dtype=int32)
tf.Tensor([520 670 400 160 200 920 420 100 130 820], shape=(10,), dtype=int32)

4.使用tensorflow建立一个简单的线性回归

4.1模型与数据的生成

这里任意选用一个线性模型

input_xs = np.random.rand(1000)
input_ys = 5.0*input_xs+2.0

4.2 模型的定义

weight =tf.Variable(1.,name="weight")
bias =tf.Variable(1.,name="bias")
def model(xs):
    logits =tf.multiply(xs,weight)+bias
    return logits

4.3 Adam优化器的使用

opt=tf.optimizers.Adam(1e-1)

本例使用方差来你和数据与真实数据之间的误差

4.4 梯度跟新的计算

for xs,ys in zip(input_xs,input_ys):
    xs = np.reshape(xs,[1])
    ys = np.reshape(ys,[1])
    with tf.GradientTape() as tape:
        _loss = tf.reduce_mean(tf.pow((model(xs)-ys),2))/(2*1000)
    grads = tape.gradient(_loss,[weight,bias])
    opt.apply_gradients(zip(grads,[weight,bias]))
    print("Train loss is :",_loss.numpy())
print(weight)
print(bias)

4.4.1这里涉及到zip函数的使用

zip()方法用于返回各个可迭代参数共同组成的元组

list1 = [1,3,5,7,9]
str1 = "FishC"
for each in zip(list1,str1):
    print(each)
    print(type(each))

 得到如下结果：

(1, 'F')

(3, 'i')

(5, 's')

(7, 'h')

(9, 'C')

for x,y in zip(list1,str1):
    print(x)
    print(type(x))
    print(y)
    print(type(y))

1

F

3

i

5

s

7

h

9

C

 可见xs和ys完全被分离开了,然后通过np.reshape函数将每个xs和ys的值变为一维数组

4.4.2 然后我们涉及到tf.GradientTape函数的使用

参考资料：

深度学习笔记-tf.GradientTape用法详解_DeepBrainWH的博客-CSDN博客_tf.gradienttape

1.简单的梯度计算

x = tf.Variable(3.)
with tf.GradientTape() as tape:
    tape.watch(x)
    y=tf.pow(x,4)
    print(y)
    dy_dx=tape.gradient(y,x)
    print(dy_dx)
del tape

tf.Tensor(81.0, shape=(), dtype=float32)
tf.Tensor(108.0, shape=(), dtype=float32)

 将进行了求导得到

2.计算二阶梯度

x=tf.Variable(4.)
with tf.GradientTape() as tape1:
    tape1.watch(x)
    with tf.GradientTape() as tape2:
        tape2.watch(x)
        y=tf.pow(x,4)
        dy_dx = tape2.gradient(y,x)
        print(dy_dx)
    dy2_dx2=tape1.gradient(dy_dx,x)
    print(dy2_dx2)
del tape1,tape2

tf.Tensor(256.0, shape=(), dtype=float32)
tf.Tensor(192.0, shape=(), dtype=float32)

 

4.4.3 探寻tf.reduce_mean的使用

x = [[1,2,3],[4,5,6]]

y = tf.cast(x, tf.float32)

得到y的值

tf.reduce_mean(y)

即tf.reduce_mean可以算出数组的平均值

4.4.4 opt=tf.optimizers.Adam(1e-1)

参考文章：

tf.keras.optimizers.Adam函数_不负韶华ღ的博客-CSDN博客_tf.keras.optimizers.adam

4.4.5 opt.apply_gradients

通过梯度函数对参数进行跟新。