Tensorflow 2.0 : CNN

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u014281392/article/details/89071383

import warnings
import numpy as np
import pandas as pd
import seaborn as sns
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import layers, models, optimizers, metrics
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, accuracy_score
warnings.filterwarnings('ignore')
%matplotlib inline

# kaggle mnist
def load_data(path):
    data = pd.read_csv(path)
    data_x = data.drop(['label'], axis=1).values
    data_y = data.label.values
    train_x, valid_x, train_y, valid_y = train_test_split(data_x, data_y, test_size=1000)
    train_x = tf.cast(train_x, tf.float32)/255.0
    valid_x = tf.cast(valid_x, tf.float32)/255.0
    train_y = tf.cast(train_y, tf.int64)
    valid_y = tf.cast(valid_y, tf.int64)
    #train_x, valid_x = train_x/np.float64(255), valid_x/np.float64(255)
    train_ds = tf.data.Dataset.from_tensor_slices((train_x, train_y))
    valid_ds = tf.data.Dataset.from_tensor_slices((valid_x, valid_y))
    # 采样
    train_ds = train_ds.take(10000).shuffle(10000).batch(500)
    valid_ds = valid_ds.batch(500)
    return train_ds , valid_ds

# softmax cross entropy
def loss_function(labels, pred_proba):
    loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=pred_proba)
    return tf.reduce_mean(loss)

def compute_accuracy(labels, pred_proba):
    predictions = tf.argmax(pred_proba, axis=1)
    return accuracy_score(labels, predictions)

def test(model, valid_ds):
    loss_ , accu_ = [], []
    for (images, labels) in valid_ds:
        pred_proba = model.predict_proba(images)
        loss_.append(loss_function(labels, pred_proba))
        accu_.append(compute_accuracy(labels, pred_proba))
    return np.mean(loss_), np.mean(accu_)

def train(model, epochs):
    compute_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
    optimizer = optimizers.Adam(learning_rate=0.01)
    trainloss_list = []    # every step loss
    trainaccuracy_list = []
    train_ds, valid_ds = load_data('../DataSet/mnist_csv/train.csv')
    for i in range(epochs):
        for step,(x, y) in enumerate(train_ds):
            with tf.GradientTape() as gdt:
                pred_proba = model(x, training=True)
                predictions = tf.argmax(pred_proba, axis=1)
                tloss_ = loss_function(y, pred_proba)
                taccu_ = accuracy_score(y, predictions)
                trainloss_list.append(tloss_)
                trainaccuracy_list.append(taccu_)
            # compute gradient
            grads = gdt.gradient(tloss_, model.trainable_variables)
            # update weights
            optimizer.apply_gradients(zip(grads, model.trainable_variables))
            if step%1000==0:
                print('Train loss is : %f, Train accuracy is : %f'%(tloss_, taccu_))
    return trainloss_list,trainaccuracy_list, model

model = tf.keras.Sequential([layers.Reshape(target_shape=(28, 28, 1), input_shape=(784,)),
                             layers.Conv2D(2, 3, padding='same', activation=tf.nn.relu),
                             layers.MaxPooling2D((2, 2), (2, 2), padding='same'),
                             layers.Conv2D(4, 5, padding='same', activation=tf.nn.relu),
                             layers.MaxPooling2D((2, 2), (2, 2), padding='same'),
                             layers.Flatten(),
                             layers.Dense(32, activation=tf.nn.relu),
                             layers.Dropout(rate=0.3),
                             layers.Dense(10, activation=tf.nn.softmax)])

%time tloss, taccu, cnn_model= train(model, 10)

Train loss is : 2.302569, Train accuracy is : 0.080000
Train loss is : 1.809378, Train accuracy is : 0.650000
Train loss is : 1.656174, Train accuracy is : 0.806000
Train loss is : 1.625595, Train accuracy is : 0.832000
Train loss is : 1.601092, Train accuracy is : 0.866000
Train loss is : 1.574611, Train accuracy is : 0.886000
Train loss is : 1.568741, Train accuracy is : 0.892000
Train loss is : 1.568823, Train accuracy is : 0.896000
Train loss is : 1.555033, Train accuracy is : 0.904000
Train loss is : 1.537751, Train accuracy is : 0.924000
CPU times: user 1min 27s, sys: 1.29 s, total: 1min 28s
Wall time: 47.3 s

plt.figure(figsize=(26, 6))
plt.subplot(1,2,1)
plt.plot(tloss)
plt.subplot(1,2,2)
plt.plot(taccu)

_, valid_ds = load_data('../DataSet/mnist_csv/train.csv')

vloss, vaccu = test(cnn_model, valid_ds)
print('valid loss is %f'%vloss)
print('valid accu is %f'%vaccu)

valid loss is 1.517739
valid accu is 0.944000