2020 tensorflow (2)

2020-01-25 本文已影响0人 zidea

Tensorflow.jpg

softmax 多分类

相当于将 w 从向量扩展为矩阵，维度行数是特征数量而列数就是输出神经元的数量。

要做多分类我们可以在 2 分类基础上，扩展到多分类。我们先看一看
$\begin{cases} p(y=0|x,\theta) = h_{\theta} = \frac{1}{1 + e^{-\theta^Tx}}\\ p(y=1|x,\theta) = 1 - h_{\theta} = \frac{e^{-\theta^Tx}}{1 + e^{-\theta^Tx}} \end{cases}$

我们看二分类每一个神经元输出分别是 1 和 $e^{-\theta^Tx}$ 分子可以看成归一化，因为分子相同。

$softmax(a) = \frac{e^{a_j}}{\sum_j e^{a_j}}$

我们之前做二分类问题，然后加载数据筛选 0 和 1 分类，现在我们要做多分类所以去掉部分代码。

for filename in filenames:
    # 使用上面读取文件数据的函数来加载文件的数据
    data,labels = load_data(filename)
    """
    因为我们样本数和标签数是一样的，而且对应位置相同，所以可以通过 zip 函数
    将样本数和标签数进行合并
    """
    for item, label in zip(data,labels):
        if label in [0,1]:#因为是二分类问题我们需要两个类别就够了
            all_data.append(item)
            all_labels.append(label)

因为是多分类问题，所以我们无需筛选添加所有数据，修改后的代码如下

for filename in filenames:
    # 使用上面读取文件数据的函数来加载文件的数据
    data,labels = load_data(filename)
    # 修改——我们现在要做多分类所有去掉对数据按类别筛选
    all_data.append(data)
    all_labels.append(labels)

# y = wx + b
# 定义(权重)参数 w 3072 * 10
w = tf.get_variable('w',[x.get_shape()[-1],10],initializer=tf.random_normal_initializer(0,1))
# 通过 get_variable 来定义参数首先是 w 是参数名称，然后定义参数形状这里定义为 [3072x1] 因为我们有 3072 特征值，也就是每一个
# 像素值，最后是初始化变量，参数初始化对模型训练也是有一定程度影响，这里采用均值为 0 方差为 1 正态分布来初始化 w

# 定义偏置(10,)这里 b 是一维，通过 tensorflow 广播我们可以扩展，初始化为 0
b = tf.get_variable('b',[10],initializer=tf.constant_initializer(0.0))

# y = wx + b
# [None,3072] * [3072,10] = [None,10]
y_ = tf.matmul(x,w) + b

因为输出变成10维，所以线程 w 重向量变成矩阵变成 w 变成 3072 * 10 矩阵，同样 b 偏置也会增加维度。

# 1 + e^x
# [[0.01,0.02,...,0.9],[]]
p_y = tf.nn.softmax(y_)
# onehot 编码将一个数值变为长度为 10 的向量
# 3 = [0,0,1,0,0,0,0,0,0,0]
y_one_hot = tf.one_hot(y,10,dtype=tf.float32)
# 这里损失函数依旧用平方差来求
loss = tf.reduce_mean(tf.square(y_one_hot - p_y))

这里函数我们用 softmax 来代替原来 2 分类的 sigmoid ，其实 sigmoid 英文本意是 s 形状的函数。

$softmax = \frac{tf.exp(logits)}{tf.reduce_sum(tf.exp(logits),axis)}$

既然我们输出 p_y 变成输出 10 维向量也就是每一个元素代表是该样本分布属于不同类别的概率。所以我们也需要将 [6,9,...,3]变成 one_hot 编码方式来表示。

[Test ] Steps: 5000 ,acc: 0.15000
[Train] Step: 5500, loss 0.12439, acc: 0.35000
[Train] Step: 6000, loss 0.15130, acc: 0.20000
[Train] Step: 6500, loss 0.08905, acc: 0.55000
[Train] Step: 7000, loss 0.13070, acc: 0.35000
[Train] Step: 7500, loss 0.14359, acc: 0.25000
[Train] Step: 8000, loss 0.16766, acc: 0.15000
[Train] Step: 8500, loss 0.14527, acc: 0.25000
[Train] Step: 9000, loss 0.13771, acc: 0.30000
[Train] Step: 9500, loss 0.09076, acc: 0.50000
[Train] Step: 10000, loss 0.15590, acc: 0.20000
[Test ] Steps: 10000 ,acc: 0.20000

从效果上来看结果还是不如任意，单层神经网络还有限的，随后我们会添加一些隐藏层来提高模型的能力

# 将单层神经网络换成多层神经网络
hidden_1 = tf.layers.dense(x,100,activation=tf.nn.relu)
hidden_2 = tf.layers.dense(hidden_1,100,activation=tf.nn.relu)
hidden_3 = tf.layers.dense(hidden_2,50,activation=tf.nn.relu)
# 在 tensorflow 提供更好用函数全连接层帮助我们实现上面的代码
y_ = tf.layers.dense(hidden_3,10)

loss = tf.losses.sparse_softmax_cross_entropy(labels=y,logits=y_)

首先我们创建全连接层来替换之前定义模型多个步骤

y_ = tf.layers.dense(hidden_3,10)

然后添加隐藏层，可以简单理解增加模型复杂度，从而提高模型拟合能力，防止欠拟合。我们隐藏层用激活函数为 relu。

hidden_1 = tf.layers.dense(x,100,activation=tf.nn.relu)
hidden_2 = tf.layers.dense(hidden_1,100,activation=tf.nn.relu)
hidden_3 = tf.layers.dense(hidden_2,50,activation=tf.nn.relu)

从效果上来看，的确有所提升。

[Train] Step: 5500, loss 1.21677, acc: 0.65000
[Train] Step: 6000, loss 1.47908, acc: 0.45000
[Train] Step: 6500, loss 1.08759, acc: 0.65000
[Train] Step: 7000, loss 1.05058, acc: 0.65000
[Train] Step: 7500, loss 1.83413, acc: 0.30000
[Train] Step: 8000, loss 1.30575, acc: 0.50000
[Train] Step: 8500, loss 1.71861, acc: 0.40000
[Train] Step: 9000, loss 1.06098, acc: 0.65000
[Train] Step: 9500, loss 1.52687, acc: 0.55000
[Train] Step: 10000, loss 1.59764, acc: 0.50000
[Test ] Steps: 10000 ,acc: 0.40000

完整代码

# coding=utf-8
import tensorflow as tf
import os
import cPickle
import numpy as np

import matplotlib.pyplot as plt

CIFAR_DIR= '../data'
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
print os.listdir(CIFAR_DIR)

def load_data(filename):
    """ 读取数据 """
    with open(filename,'rb') as f:
        data = cPickle.load(f)
        return data['data'],data['labels']

class CifarData:
    # filename 表示输入文件，need_shuffle 表示对于训练数据集
    # 是否需要洗牌，将数据打乱来得到更多更具有泛化能力的数据
    def __init__(self,filenames,need_shuffle):
        # 定义数据集和标签集
        all_data = []
        all_labels = []
        # 读入数据
        for filename in filenames:
            # 使用上面读取文件数据的函数来加载文件的数据
            data,labels = load_data(filename)
            # 修改——我们现在要做多分类所有去掉对数据按类别筛选
            all_data.append(data)
            all_labels.append(labels)
        self._data = np.vstack(all_data)
        self._data = self._data/127.5 - 1
        self._labels = np.hstack(all_labels)
        self._num_examples = self._data.shape[0]
        self._need_shuffle = need_shuffle
        # 定义遍历数据起始位置，表示遍历到数据集某个位置
        self._indicator = 0

        if self._need_shuffle:
            self._shuffle_data()
    def _shuffle_data(self):
        # 对于从 0 到 _num_examples 从小到大数据进行混排，也就是打乱顺序得到序号
        p = np.random.permutation(self._num_examples)
        self._data = self._data[p]
        self._labels = self._labels[p]
    # 每一次返回 batch_size 样本，也就是从数据集取出 batch_size 个样本
    def next_batch(self,batch_size):
        """ return batch_size examples as a batch. """
        end_indicator = self._indicator + batch_size
        if end_indicator > self._num_examples:
            # 如果当前没有住够数据时候如果可以洗牌
            if self._need_shuffle:
                self._shuffle_data()
                self._indicator = 0
                end_indicator = batch_size
            else:
                raise Exception("have no more examples")
        if end_indicator > self._num_examples:
            raise Exception("batch size is larager than all examples")
        batch_data = self._data[self._indicator:end_indicator]
        batch_labels = self._labels[self._indicator:end_indicator]
        self._indicator = end_indicator
        return batch_data, batch_labels

train_filenames = [os.path.join(CIFAR_DIR,'data_batch_%d' % i) for i in range(1,6)]
test_data_filenames = [os.path.join(CIFAR_DIR,'test_batch')]
train_data = CifarData(train_filenames,True)
test_data = CifarData(test_data_filenames,False)

x = tf.placeholder(tf.float32,[None,3072])
y = tf.placeholder(tf.int64,[None])


"""
w = tf.get_variable('w',[x.get_shape()[-1],10],initializer=tf.random_normal_initializer(0,1))
b = tf.get_variable('b',[10],initializer=tf.constant_initializer(0.0))
y_ = tf.matmul(x,w) + b
"""
# 将单层神经网络换成多层神经网络
hidden_1 = tf.layers.dense(x,100,activation=tf.nn.relu)
hidden_2 = tf.layers.dense(hidden_1,100,activation=tf.nn.relu)
hidden_3 = tf.layers.dense(hidden_2,50,activation=tf.nn.relu)
# 在 tensorflow 提供更好用函数全连接层帮助我们实现上面的代码
y_ = tf.layers.dense(hidden_3,10)

loss = tf.losses.sparse_softmax_cross_entropy(labels=y,logits=y_)

# predict = p_y_1 > 0.5
# 因为 y_ 是二维矩阵[None,10] 我们需要其 2 维度上计算最大值所以 1
predict = tf.argmax(y_,1)

correct_prediction = tf.equal(predict,y)

accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float64))
with tf.name_scope('train_op'):
    train_op =tf.train.AdamOptimizer(1e-3).minimize(loss)
# 先初始化变量
init = tf.global_variables_initializer()

batch_size = 20
train_steps = 10000
test_steps = 100
with tf.Session() as sess:
    sess.run(init)
    for i in range(train_steps):
        batch_data,batch_labels = train_data.next_batch(batch_size)
        loss_val, acc_val, _ = sess.run([loss, accuracy, train_op],feed_dict={x: batch_data, y: batch_labels})
        if (i+1) % 500 == 0:
            print '[Train] Step: %d, loss %4.5f, acc: %4.5f' % (i+1, loss_val,acc_val)
        if (i+1) % 5000 == 0:
            test_data = CifarData(test_data_filenames,False)
            for j in range(test_steps):
                test_batch_data,test_batch_labels = test_data.next_batch(batch_size)
                all_test_acc_val = []
                test_acc_val = sess.run([accuracy],{x: test_batch_data,y:test_batch_labels})
                all_test_acc_val.append(test_acc_val)
            test_acc = np.mean(all_test_acc_val)
            print '[Test ] Steps: %d ,acc: %4.5f' % (i+1,test_acc)

最后希望大家关注我们微信公众号

wechat.jpeg

2020 tensorflow (2)

softmax 多分类

猜你喜欢

热点阅读