keras usage and other hight level apis

Encapsulation/keras_high_level.py

@@ -0,0 +1,97 @@
+# -*- coding:utf-8 -*-
+
+import keras
+from keras.datasets import mnist
+from tflearn.layers.core import fully_connected
+from keras.layers import Input, Dense, Conv2D, MaxPooling2D
+from keras.models import Model
+
+
+def self_defined_fc():
+    (trainX, trainY), (testX, testY) = mnist.load_data()
+    trainX = trainX.reshape(trainX.shape[0], 784)
+    testX = testX.reshape(testX.shape[0], 784)
+    # int to float
+    trainX = trainX.astype('float32')
+    testX = testX.astype('float32')
+    trainX /= 255.0
+    testX /= 255.0
+    # one-hot encode
+    trainY = keras.utils.to_categorical(trainY, 10)
+    testY = keras.utils.to_categorical(testY, 10)
+
+    # define input
+    inputs = Input(shape=(784,))
+    x = Dense(500, activation='relu')(inputs)
+    predictions = Dense(10, activation='softmax')(x)
+
+    # define model
+    model = Model(inputs=inputs, outputs=predictions)
+    model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(), metrics=['accuracy'])
+    model.fit(trainX, trainY, batch_size=128, epochs=20, validation_data=(testX, testY))
+
+    score = model.evaluate(testX, testY)
+    print('Test loss: ', score[0])
+    print('Test accuracy: ', score[1])
+
+
+def inception_implement():
+    input_img = Input(shape=(256, 256, 3))
+    # branch 1
+    tower_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img)
+    tower_1 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_1)
+    # branch 2
+    tower_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img)
+    tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_2)
+    # branch 3
+    tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(input_img)
+    tower_3 = Conv2D(64, (1, 1), padding='same', activation='relu')(tower_3)
+
+    output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis=1)
+
+
+#   input1(784)
+#       |
+#       x(1)       input2(10)
+#       |     \     |
+#   output1(10)    output2(10)
+def multi_io_structure():
+    (trainX, trainY), (testX, testY) = mnist.load_data()
+    trainX = trainX.reshape(trainX.shape[0], 784)
+    testX = testX.reshape(testX.shape[0], 784)
+    # int to float
+    trainX = trainX.astype('float32')
+    testX = testX.astype('float32')
+    trainX /= 255.0
+    testX /= 255.0
+    # one-hot encode
+    trainY = keras.utils.to_categorical(trainY, 10)
+    testY = keras.utils.to_categorical(testY, 10)
+
+    input1 = Input(shape=(784,), name="input1")
+    input2 = Input(shape=(10,), name="input2")
+
+    x = Dense(1, activation='relu')(input1)
+    output1 = Dense(10, activation='softmax', name="output1")(x)
+    y = keras.layers.concatenate([x, input2])
+    output2 = Dense(10, activation='softmax', name="output2")(y)
+
+    model = Model(inputs=[input1, input2], outputs=[output1, output2])
+
+    loss = {'output1': 'binary_crossentropy', 'output2': 'binary_crossentropy'}
+    model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(), loss_weights=[1, 0.1],
+                  metrics=['accuracy'])
+    # 用字典可避免输入顺序不一致, 当然也可以用list     [trainX, trainY], [trainY, trainY]
+    model.fit(
+        {'input1': trainX, 'input2': trainY},
+        {'output1': trainY, 'output2': trainY},
+        batch_size=128,
+        epochs=20,
+        validation_data=(
+            [testX, testY], [testY, testY]
+        )
+    )
+
+
+# self_defined_fc()
+multi_io_structure()

Encapsulation/keras_usage.py

@@ -0,0 +1,101 @@
+# -*- coding:utf-8 -*-
+import keras
+from keras.datasets import mnist
+from keras.models import Sequential, load_model
+from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
+from keras import backend as K
+
+from keras.layers import Embedding, LSTM
+from keras.datasets import imdb
+from keras.preprocessing import sequence
+
+import os
+
+
+def mnist_test():
+    num_classes = 10
+    img_rows, img_cols = 28, 28
+
+    (trainX, trainY), (testX, testY) = mnist.load_data()
+
+    # 不同底层 tf/MXNet 对输入要求不同, 根据输入图像编码格式设置输入层格式
+    if K.image_data_format() == 'channels_first':
+        trainX = trainX.reshape(trainX.shape[0], 1, img_rows, img_cols)
+        testX = testX.reshape(testX.shape[0], 1, img_rows, img_cols)
+        input_shape = (1, img_rows, img_cols)
+    else:
+        trainX = trainX.reshape(trainX.shape[0], img_rows, img_cols, 1)
+        testX = testX.reshape(testX.shape[0], img_rows, img_cols, 1)
+        input_shape = (img_rows, img_cols, 1)
+
+    # int to float
+    trainX = trainX.astype('float32')
+    testX = testX.astype('float32')
+    trainX /= 255.0
+    testX /= 255.0
+
+    # one-hot encode
+    trainY = keras.utils.to_categorical(trainY, num_classes)
+    testY = keras.utils.to_categorical(testY, num_classes)
+
+    # create layers container
+    model = Sequential()
+    model.add(
+        Conv2D(32, kernel_size=(5, 5), activation='relu', input_shape=input_shape))
+    model.add(
+        MaxPooling2D(pool_size=(2, 2)))
+    model.add(
+        Conv2D(64, kernel_size=(5, 5), activation='relu'))
+    model.add(
+        MaxPooling2D(pool_size=(2, 2)))
+    model.add(Flatten())
+    model.add(Dense(500, activation='relu'))
+    model.add(Dense(10, activation='softmax'))
+
+    # define loss, optimizer and analyze method
+    model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(), metrics=['accuracy'])
+
+    model.fit(trainX, trainY, batch_size=128, epochs=20, validation_data=(testX, testY))
+
+    score = model.evaluate(testX, testY)
+    print('Test loss: ', score[0])
+    print('Test accuracy: ', score[1])
+
+
+# mnist_test()
+
+
+def emotion_recognition():
+    # maximum words to use
+    max_features = 20000
+    # truncate length
+    maxlen = 80
+    batch_size = 32
+    # 25000 train data, 25000 test data
+    (trainX, trainY), (testX, testY) = imdb.load_data(path="/home/youchen/PycharmProjects/TF/Encapsulation/imdb.npz", num_words=max_features)
+    print(len(trainX), ' train sequences')
+    print(len(testX), ' test sequences')
+
+    # trim to the same length
+    trainX = sequence.pad_sequences(trainX, maxlen=maxlen)
+    testX = sequence.pad_sequences(testX, maxlen=maxlen)
+    print('x_train_shape: ', trainX.shape)
+    print('x_test_shape: ', testX.shape)
+
+    if not os.path.exists('emotion_model.h5'):
+        model = Sequential()
+        model.add(Embedding(max_features, 128))
+        model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2))
+        model.add(Dense(1, activation='sigmoid'))
+    else:
+        model = load_model('emotion_model.h5')
+    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+    model.fit(trainX, trainY, batch_size=batch_size, epochs=1, validation_data=(testX, testY))
+    model.save('emotion_model.h5')
+
+    score = model.evaluate(testX, testY, batch_size=batch_size)
+    print('Test loss: ', score[0])
+    print('Test accuracy: ', score[1])
+
+
+emotion_recognition()

Encapsulation/slim_usage.py

@@ -0,0 +1,18 @@
+# -*- coding:utf-8 -*-
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+import numpy as np
+from tensorflow.examples.tutorials.mnist import input_data
+
+
+def lenet5(inputs):
+    inputs = tf.reshape(inputs, [-1, 28, 28, 1])
+
+    net = slim.conv2d(inputs, 32, [5, 5], padding='SAME', scope='layer1-conv')
+    net = slim.max_pool2d(net, 2, stride=2, scope='layer2-max-pool')
+    net = slim.conv2d(net, 64, [5, 5], padding='SAME', scope='layer3-conv')
+    net = slim.max_pool2d(net, 2, scope='layer4-max-pool')
+    net = slim.flatten(net, scope='flatten')
+    net = slim.fully_connected(net, 500, scope='layer5-fc')
+    net = slim.fully_connected(net, 10, scope='output')
+    return net

Encapsulation/tflearn_usage.py

@@ -0,0 +1,23 @@
+# -*- coding:utf-8 -*-
+
+import tflearn
+from tflearn.layers.core import input_data, fully_connected
+from tflearn.layers.conv import conv_2d, max_pool_2d
+from tflearn.layers.estimator import regression
+
+import tflearn.datasets.mnist as mnist
+
+trainX, trainY, testX, testY = mnist.load_data(data_dir='../MNIST_data', one_hot=True)
+trainX = trainX.reshape([-1, 28, 28, 1])
+testX = testX.reshape([-1, 28, 28, 1])
+net = input_data(shape=[None, 28, 28, 1], name='input')
+net = conv_2d(net, 6, 5, activation='relu')
+net = max_pool_2d(net, 2)
+net = conv_2d(net, 16, 5, activation='relu')
+net = max_pool_2d(net, 2)
+net = fully_connected(net, 500, activation='relu')
+net = fully_connected(net, 10, activation='relu')
+
+net = regression(net, optimizer='sgd', learning_rate=0.01, loss='categorical_crossentropy')
+model = tflearn.DNN(net, tensorboard_verbose=0)
+model.fit(trainX, trainY, n_epoch=20, validation_set=([testX, testY]), show_metric=True)