码迷,mamicode.com
首页 > 其他好文 > 详细

使用TensorFlow给花朵🌺分类

时间:2018-06-11 00:25:49      阅读:461      评论:0      收藏:0      [点我收藏+]

标签:slim   truncated   ESS   架构   restore   计算   dataset   还需要   大小   

技术分享图片

第一步:准备好需要的库

  • tensorflow-gpu  1.8.0
  • opencv-python     3.3.1
  • numpy
  • skimage
  • os
  • pillow

 第二步:准备数据集:

 链接:https://pan.baidu.com/s/1Kbz_UaRhAfhlweFY28R8Sw 密码:iym3

本次使用了花朵分类的数据集,总共有5类

技术分享图片

每类里面有不同形态的同一类花朵

技术分享图片

在下载完数据集之后,我们对数据集进行预处理:

from skimage import io, transform
import os
import numpy as np

# 将所有的图片resize成100*100
w = 100
h = 100
c = 3


# 读取图片
def read_img(path):
    imgs = []
    labels = []
    classs = os.listdir(path)

    for idx, folder in enumerate(classs):
        cate = os.path.join(path, folder)
        for im in os.listdir(cate):
            img_path =os.path.join(cate, im)
            # print(‘reading the images:%s‘ % (img_path))
            img = io.imread(img_path)
            img = transform.resize(img, (w, h))
            # with open(‘tests.txt‘, ‘a‘) as f:
            #     f.write(img_path+‘_‘+str(idx)+‘\n‘)
            imgs.append(img)
            labels.append(idx)
    return np.asarray(imgs, np.float32), np.asarray(labels, np.int32)



def suffer(data, label):
    # 打乱顺序
    num_example = data.shape[0]
    arr = np.arange(num_example)
    np.random.shuffle(arr)
    data = data[arr]
    label = label[arr]

    # 将所有数据分为训练集和验证集
    ratio = 0.8
    s = np.int(num_example * ratio)
    x_train = data[:s]
    y_train = label[:s]
    x_val = data[s:]
    y_val = label[s:]
    return x_train,y_train,x_val,y_val

def minibatches(inputs=None, targets=None, batch_size=None, shuffle=False):
    assert len(inputs) == len(targets)
    if shuffle:
        indices = np.arange(len(inputs))
        np.random.shuffle(indices)
    for start_idx in range(0, len(inputs) - batch_size + 1, batch_size):
        if shuffle:
            excerpt = indices[start_idx:start_idx + batch_size]
        else:
            excerpt = slice(start_idx, start_idx + batch_size)
        yield inputs[excerpt], targets[excerpt]

我们将图片统一设为100×100的大小,然后对每一个文件夹标号,作为标签。为了检验我们是否将标签与图片对齐,我预留了一个写文件路径+标签的一个文件。

写出来是这样的

技术分享图片

在做处理好标签和图片之后我们将其设定为 np.asarray(imgs, np.float32)的格式。

然后将这些图片随机打乱顺序。以8:2的比例划分训练集和验证集。

接着我们来生成minibatch:将数据切分成batch_size的大小送入网络。

在预处理完数据之后,我们开始进行网络的构建

import tensorflow as tf


def batch_norm(x, momentum=0.9, epsilon=1e-5, train=True, name=bn):
    return tf.layers.batch_normalization(x,
                      momentum=momentum,
                      epsilon=epsilon,
                      scale=True,
                      training=train,
                      name=name)

def simple_cnn(x):
    # 第一个卷积层(100——>50)
    conv1 = tf.layers.conv2d(
        inputs=x,
        filters=32,
        kernel_size=[3, 3],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    conv1 = batch_norm(conv1, name=pw_bn1)
    pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

    # 第二个卷积层(50->25)
    conv2 = tf.layers.conv2d(
        inputs=pool1,
        filters=64,
        kernel_size=[3, 3],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    conv2 = batch_norm(conv2, name=pw_bn2)
    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

    # 第三个卷积层(25->12)
    conv3 = tf.layers.conv2d(
        inputs=pool2,
        filters=128,
        kernel_size=[3, 3],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    conv3 = batch_norm(conv3, name=pw_bn3)

    pool3 = tf.layers.max_pooling2d(inputs=conv3, pool_size=[2, 2], strides=2)

    # 第四个卷积层(12->6)
    conv4 = tf.layers.conv2d(
        inputs=pool3,
        filters=128,
        kernel_size=[3, 3],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    conv4 = batch_norm(conv4, name=pw_bn4)

    pool4 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2)

    re1 = tf.reshape(pool4, [-1, 6 * 6 * 128])

    # 全连接层
    dense1 = tf.layers.dense(inputs=re1,
                             units=1024,
                             activation=tf.nn.relu,
                             kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                             kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
    dense2 = tf.layers.dense(inputs=dense1,
                             units=512,
                             activation=tf.nn.relu,
                             kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                             kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
    logits = tf.layers.dense(inputs=dense2,
                             units=5,
                             activation=None,
                             kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                             kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
    pred = tf.nn.softmax(logits, name=prob)
    return logits, pred

我们的网络由4个卷积层,两个全连接层,一个softmax层组成。在每一层的卷积后面加入了batch_normalization,relu和池化。

batch_normalization层很好用,加上它之后,有效的预防了梯度消逝和爆炸,还加速了收敛。

在搭建好网络之后,我们开始编写训练模块

import tensorflow as tf
import cnn
import dataset
# 将所有的图片resize成100*100
w = 100
h = 100
c = 3
path = flowers

x = tf.placeholder(tf.float32, shape=[None, w, h, c], name=x)
y_ = tf.placeholder(tf.int32, shape=[None, ], name=y_)

logits,pred = cnn.simple_cnn(x)
loss = tf.losses.sparse_softmax_cross_entropy(labels=y_, logits=logits)
train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
correct_prediction = tf.equal(tf.cast(tf.argmax(logits, 1), tf.int32), y_)
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


data, label = dataset.read_img(path)
x_train, y_train,x_val, y_val = dataset.suffer(data, label)

# 训练和测试数据,可将n_epoch设置更大一些
n_epoch = 11
batch_size = 16
def train():
    sess = tf.InteractiveSession()
    sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
    for epoch in range(n_epoch):
        train_loss, train_acc, n_batch = 0, 0, 0
        for x_train_a, y_train_a in dataset.minibatches(x_train, y_train, batch_size, shuffle=True):
            _, err, ac = sess.run([train_op, loss, acc], feed_dict={x: x_train_a, y_: y_train_a})
            train_loss += err
            train_acc += ac
            n_batch += 1

        print(Epoch %d - train loss: %f%(epoch, (train_loss / n_batch)))
        print(Epoch %d - train acc: %f%(epoch,train_acc / n_batch))

        # validation
        val_loss, val_acc, n_batch = 0, 0, 0
        for x_val_a, y_val_a in dataset.minibatches(x_val, y_val, batch_size, shuffle=False):
            err, ac = sess.run([loss, acc], feed_dict={x: x_val_a, y_: y_val_a})
            val_loss += err
            val_acc += ac
            n_batch += 1
        print(Epoch %d - Validation loss: %f %(epoch, val_loss / n_batch))
        print(Epoch %d - Validation Accuracy: %f%( epoch,(val_acc / n_batch)))
        if epoch % 5 == 0:
            saver.save(sess,  "./model/save_net.ckpt",epoch)
            print(Trained Model Saved.)



train()

训练时我们首先要定义X,Y作为索引

x = tf.placeholder(tf.float32, shape=[None, w, h, c], name=‘x‘)
y_ = tf.placeholder(tf.int32, shape=[None, ], name=‘y_‘)

然后对于刚才构建的网络进行损失的计算,精确度计算以及优化器的选择。
接着我们将session初始化
    sess = tf.InteractiveSession()
    sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()

 然后将定义的X,Y索引与你的真实数据,标签对齐。

使用

_, err, ac = sess.run([train_op, loss, acc], feed_dict={x: x_train_a, y_: y_train_a})

开始运行就可以了。
测试同理,不过测试的时候不需要优化器,所以只需要加入参数loss,acc就可以了。
我们每隔5次保存一次模型。

在训练结束后,我们对使用之前训练好的模型进行预测:

import numpy as np
import tensorflow as tf
from PIL import Image, ImageDraw, ImageFont
from cnn import simple_cnn
# 将所有的图片resize成100*100
w = 100
h = 100
c = 3
classes = [daisy,dandelion,roses,sunflowers,tulips]
image_test = Image.open(44079668_34dfee3da1_n.jpg)
resized_image = image_test.resize((w, h), Image.BICUBIC)
image_data = np.array(resized_image, dtype=float32)

imgs_holder = tf.placeholder(tf.float32, shape=[1, w, h, c])

logits,pred  = simple_cnn(imgs_holder)

saver = tf.train.Saver()
ckpt_dir = ./model/

with tf.Session() as sess:
    ckpt = tf.train.get_checkpoint_state(ckpt_dir)
    saver.restore(sess, ckpt.model_checkpoint_path)
    classes_ = sess.run(pred,feed_dict={ imgs_holder: np.reshape(image_data , [1, w, h, c])})

num = np.argmax(classes_)
print(class is :,classes[int(num)],  Probability is :,classes_[0][int(num)])

 

 在预测时,因为子还需要输入一张图片就可以了,所以我们只制作图片的索引

imgs_holder = tf.placeholder(tf.float32, shape=[1, w, h, c])

然后读取刚才保存的参数,只需要输入目录,即可自动读取最后训练的模型。
然后运行:
classes_ = sess.run(pred,feed_dict={ imgs_holder: np.reshape(image_data , [1, w, h, c])})

输出每个类的概率值。
我们将这个概率最大的值的标号读取出来,对应之前文件夹的标号。
classes = [‘daisy‘,‘dandelion‘,‘roses‘,‘sunflowers‘,‘tulips‘]
然后将这个标号对应的概率数标出来。
技术分享图片

 

本次使用了tf.layer进行了简单CNN的构建,并且使用了tensorflow传统的sess.run
的方法来运行图,没有使用之前提到的高级API。
在这种方法上进行了简单的尝试,接下来会尝试使用slim框架构建网络。
技术分享图片





 

 

使用TensorFlow给花朵🌺分类

标签:slim   truncated   ESS   架构   restore   计算   dataset   还需要   大小   

原文地址:https://www.cnblogs.com/ansang/p/9164805.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!