Tensorflow2.0 -搭建模型的多种方式_tensorflow搭建模型

Tensorflow1.0 搭建模型

一、搭建深度学习模型的区别（背过！！！）

Tensorflow1.x

Tensorflow1.x最重要的在于Graph的概念，个人认为搭建相对较为麻烦，但是tf1.x也较为灵活。

Tensorflow2.x

Tensorflow2.x兼容keras，非常好用。

对于Tensorflow1.0，

        step 01 ：准备输入数据

        step 02：定义输入PlaceHolder

        step 03：搭建模型

        step 04：定义损失函数及优化器

        step 05：初始化所有变量

        step 06：创建会话session

        step 07：传参计算session.run()

对于Tensorflow 2.0，

        step 01 ：准备输入数据

         step 02：定义输入PlaceHolder

        step 03：搭建模型

        step 04：定义损失函数及优化器

        step 05：初始化所有变量

        step 06：创建会话session

        step 07：传参计算model()

二、TensorFlow 2.0 相比于TensorFlow 1.0 的其他区别

1. TensorFlow 2.0 动态图机制默认开启，方便开发者调试。

        TensorFlow 1.0 默认是静态图，需要手动开启动态图。

2. tf.keras模块上的区别

•  Keras是对TensorFlow的更高一层封装，简化了TensorFlow的使用。

• TensorFlow 2.0中搭建网络，官方推荐使用Keras提供的方法。有两种搭建风格：Keras Function API (tf1中搭建模型的风格）和 Model Subclassing API（类似于Pytorch中搭建模型的风格）

• TensorFlow 2.0 删除了重复、废弃的API。而在TensorFlow 1.0，同一个功能可以找到多个API实现，会给开发者造成疑惑。

3.在TensorFlow 2.0 中使用 @tf.function 装饰器，构造高效的Python代码

TesorFlow2.0推荐使用tf.keras，tf.data 等高层库：

• 用Eager模式搭建原型
• 用tf.data处理数据
• 用tf.feature_column提取特征
• 用tf.keras搭建模型
• 用tf.saved_model打包模型

---

TF1.0 搭建模型

 
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import os
os.environ["CUDA_DEVICE_ORDER"] = "0,1"
 
 
mnist = input_data.read_data_sets("MNIST_data",one_hot=True)
 
def compute_accuracy(v_xs,v_ys):
    global prediction
    y_pre = sess.run(prediction,feed_dict ={xs:v_xs,keep_prob:1})
    correct_predicton = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_predicton,tf.float32))
    result = sess.run(accuracy,feed_dict = {xs:v_xs,ys:v_ys,keep_prob:1})
    return result
 
def weight_variable(shape):
    initial = tf.truncated_normal(shape=shape,stddev=0.1)
    return tf.Variable(initial)
 
def bias_variable(shape):
    initial = tf.constant(0.1,shape=shape)
    return tf.Variable(initial)
 
def conv2d(x,W):
    #stride [1,x_movement,y_movement,1]
    #Must have strides[0] = strides[3] = 1
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding="SAME")
 
def max_pool_2x2(x):
    # stride [1,x_movement,y_movement,1]
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")
 
def add_layer(inputs,in_size,out_size,activation_function=None):
    Weight = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size])+0.1)
    Wx_plus_b = tf.matmul(inputs,Weight)+biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs
 
#define placeholder for inputs to network
 
xs = tf.placeholder(tf.float32,[None,784])
ys = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32)
x_image = tf.reshape(xs,[-1,28,28,1])
 
## conv1 layer ##
W_conv1 = weight_variable([5,5, 1,32]) # patch 5x5, in size 1, out size 32
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # output size 28x28x32
h_pool1 = max_pool_2x2(h_conv1)                                         # output size 14x14x32
 
## conv2 layer ##
W_conv2 = weight_variable([5,5, 32, 64]) # patch 5x5, in size 32, out size 64
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) # output size 14x14x64
h_pool2 = max_pool_2x2(h_conv2)              # output size 7x7x64
 
 
# #func1 layer
# input = tf.reshape(h_pool2,[-1,7*7*64])
# fc1 = add_layer(input,7*7*64,1024,activation_function=tf.nn.relu)
# fc1_drop = tf.nn.dropout(fc1,keep_prob)
#
# #func2 layer
# fc2 = add_layer(fc1_drop,1024,10,activation_function=tf.nn.softmax)
# prediction = fc2
 
## func1 layer ##
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
# [n_samples, 7, 7, 64] ->> [n_samples, 7*7*64]
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
 
## func2 layer ##
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
 
#loss
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indices=[1]))
 
train_step = tf.train.AdamOptimizer(0.0001).minimize(cross_entropy)
 
config = tf.ConfigProto(log_device_placement=True)
config.gpu_options.allow_growth = True
 
sess = tf.Session(config=config)
 
sess.run(tf.initialize_all_variables())
 
for i in range(1000):
    batch_xs,batch_ys = mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys,keep_prob:0.5})
    if i%50 ==0:
        print(compute_accuracy(mnist.test.images,mnist.test.labels))

---

Tensorflow2.0  序列式、函数式、Model子类

a. Sequential API
b. Functional API
c. Subclassing API

a. sequential的方式用来实现一层接着一层的模型
b. functional的模型能完成大多数模型
c. subclassing的模型能完全自定义，但是比较复杂 所常归来说，用functional就好了

局限性

重要的是，在使用命令式API时，模型是由类方法的主体定义的。你的模型不再是透明的数据结构，而是一段不透明的字节码。当使用这种风格时，你是在用可用性和重用性来换取灵活性。

调试发生在执行过程中，而不是在定义模型时。

几乎没有对输入或层间兼容性的检查，所以当使用这种风格时，很多调试负担从框架转移到开发人员身上。

命令式模型可能更难于重用。例如，你不能使用一致的API访问中间层或激活。

相反，提取激活的方法是用新的调用(或前向)方法编写一个新类。最初写可能很有趣，也很简单，但如果没有标准，它可能会为以后埋坑。

命令式模型也更难于检查、复制或克隆。

模型本身(指定层、训练循环等的代码部分)是位于中间的小框。

三种方式使用的优先级

先考虑能不能用Keras Sequential APIs 方式建立需要的模型，如果不能，在考虑能不能使用Keras Functional APIs方式来建立你需要的模型，如果还是不能，最后再考虑Keras Model Subclassing APIs方式

1、序列模型是layer-by-layer的，它是最简单的定义模型的方法，但是有几个不足：
• 不能够共享某一层
• 不能有多个分支
• 不能有多个输入
这种结构的经典网络比如有：Lenet5，AlexNet，VGGNet

2、函数式API有更强的功能
• 定义更复杂的模型
• 支持多输入多输出
• 可以定义模型分支，比如inception block ， resnet block
• 方便layer共享
另外，对于任意的Sequential模型，都可以用函数式编程方式来实现。

• ResNet
• GoogleNet/Inception
• Xception
• SqueezeNet

3、Subclassing API

TensorFlow 2.0通过Keras Subclassing API支持这种开箱即用的方式。在keras中Model类做为基本的类，可以在些基础上，进行会任意个人设置，带来很强的自由。但同进带来的不足就是没用序列和函数定义模型使用起来简单。既然子类方法有些难，为什么还要用呢，因为这对一些研究人员很好，可以模型所以部分进行控制。

---

Tensorflow 2.0 中模型构建的三种方式（三种模型的定义方式）_RichardorMu的博客-CSDN博客_细论述使用tensorflow构造序列模型的方法,并举例说明;

[TensorFlow 2.0] Keras三种搭建模型的方式——序列式、函数式、Model子类_手撕机的博客-CSDN博客

---

序列式（keras.Sequential API）

# coding = utf-8
import numpy as np
import tensorflow as tf
from tensorflow import keras
 
# Prepare data X_train: ndarray,(60000, 28, 28) y_train: ndarray, (60000,)
(X_train, y_train), (X_valid, y_valid) = keras.datasets.fashion_mnist.load_data()
X_train = X_train / 255.0
X_valid = X_valid / 255.0
 
# Build model
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),  # input layer
    keras.layers.Dense(128, activation='relu'),  # hidden layer
    keras.layers.Dense(10, activation='softmax')  # output layer
])
 
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
 
# Train model
model.fit(X_train, y_train, epochs=10)
 
# Evaluate model
valid_loss, valid_acc = model.evaluate(X_valid, y_valid, verbose=1)
print(f"Valid loss:{valid_loss}")
print(f"Valid accuracy:{valid_acc}")
 
# Make one prediction
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
y_predicts = model.predict(X_valid)
print(y_predicts[0])
y_index = np.argmax(y_predicts[0])
print(y_index)
y_label = class_names[y_index]
print(y_label)

#sparse_categorical_crossentropy和categorical_crossentropy区别：
如果输出只用一位整数表示类别，则用sparse_categorical_crossentropy；
比如targets形如：[2, 0, 1, 5, 19]
如果输出是One-Hot编码了的，则用categorical_crossentropy。
比如targets形如：[[0, 1, 0], [1, 0, 0], [0, 0, 1]]
 

函数式（Functional API）keras.Model()

# Build model
inputs = keras.Input(shape=(28, 28))
x = keras.layers.Flatten()(inputs)
x = keras.layers.Dense(128, activation='relu')(x)
outputs = keras.layers.Dense(10, activation='softmax')(x)
 
model = keras.Model(inputs, outputs)

Model子类

继承Keras的Model类，并重写call方法即可。

# Build model
class MyModel(keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.input_layer = keras.layers.Flatten(input_shape=(28, 28))
        self.hidden_layer = keras.layers.Dense(128, activation='relu')
        self.output_layer = keras.layers.Dense(10, activation='softmax')
 
    def call(self, inputs):
        x = self.input_layer(inputs)
        x = self.hidden_layer(x)
        x = self.output_layer(x)
        return x
 
 
model = MyModel()