我的第一个tensorFlow程序

tensorFlow数据类型

import tensorflow as tf
#常量
tf.constant(calue,dtype)
#变量（张量）
tf.Variable(value,dtype)
#变量的numpy
w = tf.Variable(value,dtype)
w.numpy()
#向量（输出numpy的方法同上）
tf.Variable([2.3,1.3], dtype=tf.float32) 
#矩阵（张量）输出numpy的方法同上
wM = tf.Variable(tf.ones((3,2)), dtype=tf.float32)  
#创建一个3*4的矩阵
x = tf.Variable([[1,2,3,4],[1,3,2,2],[2,1,3,2]], dtype=tf.float32) 

#标量运算
wx = tf.multiply(w,x)  # 乘法  
wxb  = tf.add(wx,b)  # 加法  
wxbc = tf.subtract(wxb,c)  # 减法  
wxbcd = tf.divide(wxbc,d)  # 除法  

#向量运算是向量的对应位相乘，向量维度必须一致
#以下都是一维向量
wx = tf.multiply(w,x)  # 乘法  
wxb  = tf.add(wx,b)  # 加法  
wxbc = tf.subtract(wxb,c)  # 减法  
wxbcd = tf.divide(wxbc,d)  # 除法  

#矩阵运算（按照矩阵运算法则）
w = tf.Variable([[2],[1],[2],[3]], dtype=tf.float32)  
x = tf.Variable([[1,2,3,4],[1,3,2,2],[2,1,3,2]], dtype=tf.float32)  
b = tf.Variable([[1],[1],[2]], dtype=tf.float32)  
wx = tf.matmul(x,w)  # 乘法  
wxb  = tf.add(wx,b)  # 加法  

简单的自定义训练模型

'''最简单的自定义模型'''
import tensorflow as tf
#线性目标函数
class Model(object):
    def __init__(self):
        # 初始化变量  
        self.W = tf.Variable(5.0)  
        self.b = tf.Variable(0.0)  

    def __call__(self, x):  
        # x 只有一维数据情况  
        return self.W * x + self.b  
# 测试  
model = Model()  
print(model([2,5]))  
#out:tf.Tensor([10. 25.], shape=(2,), dtype=float32)

#损失函数
def loss(predicted_y, true_y):  
    return tf.reduce_mean(tf.square(predicted_y - true_y))

#优化函数
def train(model, inputs, outputs, learning_rate):  
    # 记录loss计算过程  
    with tf.GradientTape() as t:  
        loss_value = loss(model(inputs), outputs)  
        # 对W，b求导  
        dW, db = t.gradient(loss_value, [model.W, model.b])  
        # 减去梯度×学习率  
        model.W.assign_sub(dW*learning_rate)  
        model.b.assign_sub(db*learning_rate)

一个基础demo

'''基础demo'''
import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
import tensorflow as tf 
from tensorflow.keras import models,layers
import matplotlib.pyplot as plt

#导入数据
dftrain_raw = pd.read_csv('/home/kesci/input/data3483/data/titanic/train.csv')
dftest_raw = pd.read_csv('/home/kesci/input/data3483/data/titanic/test.csv')
print(dftrain_raw.head(10))

#绘制图象
%matplotlib inline
%config InlineBackend.figure_format = 'png'
ax = dftrain_raw['Survived'].value_counts().plot(kind = 'bar',
     figsize = (12,8),fontsize=15,rot = 0)
ax.set_ylabel('Counts',fontsize = 15)
ax.set_xlabel('Survived',fontsize = 15)
plt.show()

%matplotlib inline
%config InlineBackend.figure_format = 'png'
ax = dftrain_raw['Age'].plot(kind = 'hist',bins = 20,color= 'purple',
                    figsize = (12,8),fontsize=15)

ax.set_ylabel('Frequency',fontsize = 15)
ax.set_xlabel('Age',fontsize = 15)
plt.show()

%matplotlib inline
%config InlineBackend.figure_format = 'png'
ax = dftrain_raw.query('Survived == 0')['Age'].plot(kind = 'density',
                      figsize = (12,8),fontsize=15)
dftrain_raw.query('Survived == 1')['Age'].plot(kind = 'density',
                      figsize = (12,8),fontsize=15)
ax.legend(['Survived==0','Survived==1'],fontsize = 12)
ax.set_ylabel('Density',fontsize = 15)
ax.set_xlabel('Age',fontsize = 15)
plt.show()

#预处理数据
def preprocessing(dfdata):

    dfresult= pd.DataFrame()

    #Pclass
    dfPclass = pd.get_dummies(dfdata['Pclass'])
    dfPclass.columns = ['Pclass_' +str(x) for x in dfPclass.columns ]
    dfresult = pd.concat([dfresult,dfPclass],axis = 1)

    #Sex
    dfSex = pd.get_dummies(dfdata['Sex'])
    dfresult = pd.concat([dfresult,dfSex],axis = 1)

    #Age
    dfresult['Age'] = dfdata['Age'].fillna(0)
    dfresult['Age_null'] = pd.isna(dfdata['Age']).astype('int32')

    #SibSp,Parch,Fare
    dfresult['SibSp'] = dfdata['SibSp']
    dfresult['Parch'] = dfdata['Parch']
    dfresult['Fare'] = dfdata['Fare']

    #Carbin
    dfresult['Cabin_null'] =  pd.isna(dfdata['Cabin']).astype('int32')

    #Embarked
    dfEmbarked = pd.get_dummies(dfdata['Embarked'],dummy_na=True)
    dfEmbarked.columns = ['Embarked_' + str(x) for x in dfEmbarked.columns]
    dfresult = pd.concat([dfresult,dfEmbarked],axis = 1)

    return(dfresult)

x_train = preprocessing(dftrain_raw)
y_train = dftrain_raw['Survived'].values

x_test = preprocessing(dftest_raw)
y_test = dftest_raw['Survived'].values

print("x_train.shape =", x_train.shape )
print("x_test.shape =", x_test.shape )


#定义模型
tf.keras.backend.clear_session()

model = models.Sequential()
model.add(layers.Dense(20,activation = 'relu',input_shape=(15,)))
model.add(layers.Dense(10,activation = 'relu' ))
model.add(layers.Dense(1,activation = 'sigmoid' ))

model.summary()

#训练模型
# 二分类问题选择二元交叉熵损失函数
model.compile(optimizer='adam',
            loss='binary_crossentropy',
            metrics=['AUC'])

history = model.fit(x_train,y_train,
                    batch_size= 64,
                    epochs= 30,
                    validation_split=0.2 #分割一部分训练数据用于验证
                   )
#显示训练过程
def plot_metric(history, metric):
    train_metrics = history.history[metric]
    val_metrics = history.history['val_'+metric]
    epochs = range(1, len(train_metrics) + 1)
    plt.plot(epochs, train_metrics, 'bo--')
    plt.plot(epochs, val_metrics, 'ro-')
    plt.title('Training and validation '+ metric)
    plt.xlabel("Epochs")
    plt.ylabel(metric)
    plt.legend(["train_"+metric, 'val_'+metric])
    plt.show()
plot_metric(history,"loss")

#保存代码（keras）
# 保存模型结构及权重

model.save('/home/kesci/input/data3483/data/keras_model_weight.h5')  

del model  #删除现有模型

# 加载模型
model = models.load_model('/home/kesci/input/data3483/data/keras_model_weight.h5')
model.evaluate(x_test,y_test)

# 保存模型结构
json_str = model.to_json()

# 恢复模型结构
model_json = models.model_from_json(json_str)

#保存模型权重
model.save_weights('/home/kesci/input/data3483/data/keras_model_weight.h5')

# 恢复模型结构
model_json = models.model_from_json(json_str)
model_json.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['AUC']
    )

# 加载权重
model_json.load_weights('/home/kesci/input/data3483/data/keras_model_weight.h5')
model_json.evaluate(x_test,y_test)

#tf原生方式保存
# 保存权重，该方式仅仅保存权重张量
model.save_weights('/home/kesci/input/data3483/data/tf_model_weights.ckpt',save_format = "tf")

# 保存模型结构与模型参数到文件,该方式保存的模型具有跨平台性便于部署

model.save('/home/kesci/input/data3483/data/tf_model_savedmodel', save_format="tf")
print('export saved model.')

model_loaded = tf.keras.models.load_model('/home/kesci/input/data3483/data/tf_model_savedmodel')
model_loaded.evaluate(x_test,y_test)

以上部分内容应用自ModelWhale https://www.heywhale.com/mw/project/5ea52b3f105d91002d5091da

数据文件csv位于https://github.com/lyhue1991/eat_tensorflow2_in_30_days/tree/master/data/titanic

下面简单讲解一下部分关键部分

1、Keras

Keras是由纯python编写的基于theano/tensorflow的深度学习框架。

Keras是一个高层神经网络API，支持快速实验，能够把你的idea迅速转换为结果，如果有如下需求，可以优先选择Keras：

a）简易和快速的原型设计（keras具有高度模块化，极简，和可扩充特性）

b）支持CNN和RNN，或二者的结合

c）无缝CPU和GPU切换

 

 几种典型的层：

        Dense(500,input_shape=(784,))，Dense是网络层，输出只指定了一个维度（500），因为另一个维度N通过输入的数据决定，Dense输入的是一维数据的集合，也就是由一维的数据向量构成的二维矩阵。如果输入不是一维的的话需要变换输入的shape才能输入。

        Activation('tanh')，激活层， 括号里的是激活函数

        Dropout(0.5)，随机断开一部分网络，防止过度拟合（按%）

Keras 官网 https://keras.io/ ，上面有API文档

Keras 创建模型的方法：

        顺序创建：sequential主要是最简单的模型创建方法是使用Sequential创建顺序模型，顾名思义，数据的传播是从前往后一条线传播的。用add方法往模型中加网络层或者初始化时从可迭代对象中创建也是可以的，层次顺序按照add的先后。然后compile, fit一个网络就搞定了。但是创建过程中只能一条路走到黑，改变不方便。官网文档：https://keras.io/guides/sequential_model/

        顺序创建无法使用的场合：

        模型具有多输入、多输出；任意一层具有多输入或者多输出；需要共用某些层；需要非线性模型拓扑结构。

        函数API创建：FunctionalAPI主要是这种方法定义的模型中间层自己自由发挥（需要使用Keras提供的层来堆叠构造），只需要把输入和输出交代给模型即可完成模型定义，这是由于模型是基于图的，有了输入输出就能追溯整个模型架构。官网文档：https://keras.io/guides/functional_api/

        例程：创建一个如下的 网络模型

'''
(input: 784-dimensional vectors)
       ↧
[Dense (64 units, relu activation)]
       ↧
[Dense (64 units, relu activation)]
       ↧
[Dense (10 units, softmax activation)]
       ↧
(output: logits of a probability distribution over 10 classes)
'''
inputs = keras.Input(shape=(784,))
#假如需要处理图片等多维数据：
img_inputs = keras.Input(shape=(32, 32, 3))
#input 包含shape 和dtype两个参数

dense = layers.Dense(64, activation="relu")
#将上一层的结果带入下一层
#第一层网络层
x = dense(inputs)
#将上一层的结果带入下一层
#第二层网络层
x = layers.Dense(64, activation="relu")(x)
#输出层
#softmax是指数函数的激活函数，将输入全部转化为正数
outputs = layers.Dense(10)(x)
#形成模型
model = keras.Model(inputs=inputs, outputs=outputs, name="mnist_model")
#查看模型的基本信息
model.summary()
#模型画图
keras.utils.plot_model(model, "my_first_model.png")
#画出包含shape的图
keras.utils.plot_model(model, "my_first_model_with_shape_info.png", show_shapes=True)

#简单的训练模型
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255

model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=keras.optimizers.RMSprop(),
    metrics=["accuracy"],
)
#fit函数是训练的部分
history = model.fit(x_train, y_train, batch_size=64, epochs=2, validation_split=0.2)

test_scores = model.evaluate(x_test, y_test, verbose=2)
print("Test loss:", test_scores[0])
print("Test accuracy:", test_scores[1])

最后附上保存方式

Keras：

# 保存模型结构及权重

model.save('/home/kesci/input/data3483/data/keras_model_weight.h5')  

del model  #删除现有模型

# identical to the previous one
model = models.load_model('/home/kesci/input/data3483/data/keras_model_weight.h5')
model.evaluate(x_test,y_test)

# 保存模型结构
json_str = model.to_json()

# 恢复模型结构
model_json = models.model_from_json(json_str)

#保存模型权重
model.save_weights('/home/kesci/input/data3483/data/keras_model_weight.h5')

# 恢复模型结构
model_json = models.model_from_json(json_str)
model_json.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['AUC']
    )

# 加载权重
model_json.load_weights('/home/kesci/input/data3483/data/keras_model_weight.h5')
model_json.evaluate(x_test,y_test)

TensorFlow：

# 保存权重，该方式仅仅保存权重张量
model.save_weights('/home/kesci/input/data3483/data/tf_model_weights.ckpt',save_format = "tf")

# 保存模型结构与模型参数到文件,该方式保存的模型具有跨平台性便于部署

model.save('/home/kesci/input/data3483/data/tf_model_savedmodel', save_format="tf")
print('export saved model.')

#利用Keras
# 模型导出
model.save('catdog.h5')

model_loaded = tf.keras.models.load_model('/home/kesci/input/data3483/data/tf_model_savedmodel')
model_loaded.evaluate(x_test,y_test)