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

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()

你可能感兴趣的:(基础编程,深度学习,tensorflow,深度学习,人工智能)