keras简介(一)

主要模块

tf.kears是tensorflow 的高级API，用来快速开发验证。快速，方便、可扩展。
1、initializers : 初始化器，包含序列化 和 反序列化
2、layers
3、losses: 构建损失函数
4、optimizers: 优化器
5、regularizers : 正则化相关的内容
6、一个重要的类：
class Sequential : 线性层级的，序列模型
7、使用函数式API
可以构建更加灵活复杂的模型

构建模型

tf.keras.layers

用来配置每一层的结构。
tf.keras.layers. Dense ()  // 创建层
    参数： activation：  设置激活函数
          kernel_initializer 和 bias_initializer   ：  //核权重和偏差的初始化方案，默认："Glorot uniform"
          kernel_regularizer 和 bias_regularizer:  // 正则化方案，默认没有

序列模型

tf.keras.Sequential
model = tf.keras.Sequential()   //  定义序列模型，层级

复杂模型

keras 中可以使用函数式api 构建复杂的模型图：
1、层实例可以调用并返回，用于构建复杂的层级关系。
2、输入张量和输出张量用于定义 tf.keras.Model 实例。

数据的输入

1、使用 numpy 的 ndarray 数据

2、使用 tf.data

简单上手示例

Seauential

import numpy as np
import tensorflow as tf

#  创建模型实例 构建一个简单的全连接 网络  tf.Sequential
model = tf.keras.Sequential()
# 定义各层结构  tf.keras.layers
model.add( layers.Dense(64, activation='relu') )  %64units , 激活函数 "relu"
#  kernel_regularizer  正则化，默认没有正则化项
model.add( layers.Dense(64, activation='relu',) ,kernel_regularizer=tf.keras.regularizers.l1(0.01) ) 
% 可以指定  初始化 权重方案    kernel_initializer  默认 为"Glorot uniform"
model.add( layers.Dense(10, activation=doftmax",   kernel_initializer='orthogonal') )

%  配置模型训练的相关参数 tf.keras.Moedl
%  optimizer 指定参数优化函数
%  loss 指定 损失函数  
%  metrics  指定评价函数
model.compile( optimizer = tf.train.RMSPropOptimizer(0.01) , loss = tf.keras.losses.categotical_crossentrop,  metrics = [ tf.keras.metrics.categorical_accuracy ] ) 


% 输入数据、训练  
#使用numpy.ndarray
data = np.random.random( (1000, 64) )
labels = np.random.random( (1000,10) )

val_data = np.random.random( (100, 64) )
val_labels = np.random.random( (100,10) )
#  epoches ： 指定训练周期数，一个周期就是所有的数据完成一次迭代
model.fit( data, labels , epoches=10, batch_size=32 , validation_data=(val_data, val_labels) )

# 使用 tf.data.Dataset
# dataset = tf.data.Dataset.from_tensor_slices((data, labels))
# dataset = dataset.batch(32).repeat()
# val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))
# val_dataset = val_dataset.batch(32).repeat()
# model.fit(dataset, epochs=10, steps_per_epoch=30,
          validation_data=val_dataset,
          validation_steps=3)

# 模型的验证 和 预测
# 使用 numpy
model.evalute(val_data, val_labels, batch_size=32)
# 使用 tf.Dataset
model.evaluate(val_dataset, steps=30)

# 预测
result = model.predict(data, batch_size=32)
print(result.shape)

使用函数式API

# 使用 函数式api  定义网络模型
#  tf.keras.Sequential 模型是层的简单堆叠，无法表示任意模型
# 使用函数式API  可以构建复杂的模型
#          多输入、输出、共享层、非序列数据列等结构

import numpy as np
import tensorflow  as tf

# 定义模型结构
inputs = tf.keras.Input( shape=(64, ) )  # returen a placeholder rensor
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
y = tf.keras.layers.Dense(64, activation='relu')(x)

predictions = layes.Dense(10, activation = 'softmax')(x)

# 创建模型实例
model = tf.keras.Model( inputs=inputs, outputs = predictions)
# 配置训练参数
model.compile(optimizer = tf.train.RMSPropOptimizer(0.001), loss='categorical_crossentropy, metrics=['accuracy'])
# train
model.fit(data , labels , batch_size=32, epochs=5)

模型子类化

import numpy as np
import tensorflow af
from tensorflow.keras import layers

#  继承 tf.keras.Model 类
class MyModel(tf.keras.Model):
  def __init__(self, num_classes=10):
    super(MyModel, self).__init__(name='my_model')
    self.num_classes = num_classes
    # Define your layers here.
    self.dense_1 = layers.Dense(32, activation='relu')
    self.dense_2 = layers.Dense(num_classes, activation='sigmoid')
  #  前向传播
  def call(self, inputs):
    # Define your forward pass here,
    # using layers you previously defined (in `__init__`).
    x = self.dense_1(inputs)
    return self.dense_2(x)

  def compute_output_shape(self, input_shape):
    # You need to override this function if you want to use the subclassed model
    # as part of a functional-style model.
    # Otherwise, this method is optional.
    shape = tf.TensorShape(input_shape).as_list()
    shape[-1] = self.num_classes
    return tf.TensorShape(shape)

# 实例化
model = MyModel(num_classes=10)

# The compile step specifies the training configuration.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Trains for 5 epochs.
model.fit(data, labels, batch_size=32, epochs=5)

参考

tensorflow_guide_keras
keras函数式API
keras可使用的评估函数metrics
tensorflow 可使用的optimizer