tensorflow学习--手写tf网络

数据集：

1.data_loader.py

import cv2
import os
import numpy as np
import random

# f1=open('dataset/train_data.txt','w+')
# path='dataset/'
# for file in os.listdir(path):
#     if file.endswith('png'):
#         line=path+file+'  1'+'\n'
#         f1.write(line)
#         print(line)



def one_hot(data, num_classes):
  return np.squeeze(np.eye(num_classes)[data.reshape(-1)])


def get_data_list(path):
    f1=open(path,'r')
    lines=f1.readlines()

    img_list=[]
    label_list=[]
    for line in lines:
        label=int(line.strip().split("  ")[1])
        label=one_hot(np.array(label),10)
        label_list.append(label)

        file_name=line.strip().split("  ")[0]
        img=cv2.imread(file_name, 0)
        img=np.reshape(img,[28,28,1])
        # print(img.shape)
        img_list.append(img)
        
    return img_list, label_list


def get_data(img_list, label_list, batch_size):
    lens=len(label_list)
    random_nums=random.sample(range(lens),lens)
    nums=random_nums[0:batch_size]
    # print(nums)

    data=[]
    label=[]
    for index in nums:
        data.append(img_list[index])
        label.append(label_list[index])
        
    return np.array(data), np.array(label)



# batch_size=1
# path="dataset/mnist/train/train_data.txt"

# img_list, label_list=get_data_list(path)
# print(len(img_list), len(label_list))

# data, label=get_data(img_list, label_list, batch_size)
# print(type(data[0]),label)

2.create_model.py

import tensorflow as tf
import os
import numpy as np
import cv2
import argparse


def model(inputs):
	w1=tf.Variable(tf.random_normal([3, 3, 1, 32], stddev=0.01))
	w2=tf.Variable(tf.random_normal([3, 3, 32, 64], stddev=0.01))
	w3=tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.01))
	w4=tf.Variable(tf.random_normal([2048, 625], stddev=0.01))
	w5=tf.Variable(tf.random_normal([625, 10], stddev=0.01))

	l1_conv=tf.nn.conv2d(inputs, w1, strides=[1, 1, 1, 1], padding='SAME')
	l1_relu=tf.nn.relu(l1_conv)
	l1_pool=tf.nn.max_pool(l1_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
	l1_drop = tf.nn.dropout(l1_pool, 0.5)

	l2_conv=tf.nn.conv2d(l1_drop, w2, strides=[1, 1, 1, 1], padding='SAME')
	l2_relu=tf.nn.relu(l2_conv)
	l2_pool=tf.nn.max_pool(l2_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
	l2_drop = tf.nn.dropout(l2_pool, 0.5)

	l3_conv=tf.nn.conv2d(l2_drop, w3, strides=[1, 1, 1, 1], padding='SAME')
	l3_relu=tf.nn.relu(l3_conv)
	l3_pool=tf.nn.max_pool(l3_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
	l3_out = tf.reshape(l3_pool, [-1, 2048])
	l3_drop = tf.nn.dropout(l3_out, 0.5)

	l4 = tf.nn.relu(tf.matmul(l3_drop, w4))
	l4 = tf.nn.dropout(l4, 0.5)

	out = tf.matmul(l4, w5)
	return out


def model2(inputs):
	w1=tf.Variable(tf.random_normal([5, 5, 1, 6], stddev=0.01))
	b1 = tf.Variable(tf.truncated_normal([6]))

	w2=tf.Variable(tf.random_normal([5, 5, 6, 16], stddev=0.01))
	b2 = tf.Variable(tf.truncated_normal([16]))

	w3=tf.Variable(tf.random_normal([5, 5, 16, 120], stddev=0.01))
	b3 = tf.Variable(tf.truncated_normal([120]))

	w4 = tf.Variable(tf.truncated_normal([7 * 7 * 120, 80]))
	b4 = tf.Variable(tf.truncated_normal([80]))

	w5 = tf.Variable(tf.truncated_normal([80, 10]))
	b5 = tf.Variable(tf.truncated_normal([10]))

	l1_conv=tf.nn.conv2d(inputs, w1, strides=[1, 1, 1, 1], padding='SAME')
	l1_sigmoid=tf.nn.sigmoid(l1_conv+b1)
	l1_pool=tf.nn.max_pool(l1_sigmoid, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

	l2_conv=tf.nn.conv2d(l1_pool, w2, strides=[1, 1, 1, 1], padding='SAME')
	l2_sigmoid=tf.nn.sigmoid(l2_conv+b2)
	l2_pool=tf.nn.max_pool(l2_sigmoid, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

	l3_conv=tf.nn.conv2d(l2_pool, w3, strides=[1, 1, 1, 1], padding='SAME')
	l3_sigmoid=tf.nn.sigmoid(l3_conv+b3)

	l3_out = tf.reshape(l3_sigmoid, [-1, 7*7*120])

	l4 = tf.nn.sigmoid(tf.matmul(l3_out, w4)+b4)

	out = tf.nn.softmax(tf.matmul(l4, w5) + b5)
	return out

3.train.py

import argparse
import cv2
import tensorflow as tf
from create_model import model,model2
import numpy as np
from data_loader import get_data, get_data_list
from sklearn.metrics import accuracy_score

def get_parms():
    parser = argparse.ArgumentParser(description='')

    parser.add_argument('--train_data', type=str, default="dataset/train_data.txt")
    parser.add_argument('--test_data', type=str, default='data/test/')

    parser.add_argument('--checkpoint_dir', type=str, default='./model/')
    parser.add_argument('--epoch', type=int, default=10)
    parser.add_argument('--batch_size', type=int, default=8)
    parser.add_argument('--save_epoch', type=int, default=5)
    
    args=parser.parse_args()

    return args

def train(args):
    # 预定义计算图
    input_size=[None,28,28,1]
    inputs=tf.placeholder(tf.float32, input_size)
    label=tf.placeholder(tf.float32, [None,10])
    print(inputs.shape, label.shape)

    # 网络模型
    out=model2(inputs)
    pred=tf.argmax(out,axis=1)

    # 损失函数+优化器
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=out, labels=label))
    optimizer = tf.train.GradientDescentOptimizer(0.001).minimize(loss)


    # 开始训练
    saver=tf.train.Saver()
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        img_list, label_list=get_data_list(args.train_data)
        for i in range(args.epoch):
            loss_list=[]
            acc_list=[]
            for j in range(int(len(label_list)/args.batch_size)):
                data, true_label=get_data(img_list, label_list, args.batch_size)
                
                result, train_loss,_=sess.run([pred,loss,optimizer], feed_dict={inputs:data, label:true_label})
                loss_list.append(train_loss)
                # print(i,j, result, np.argmax(true_label,axis=1), train_loss)
                
                acc = accuracy_score(result, np.argmax(true_label,axis=1))
                acc_list.append(acc)
            print('acc:',np.mean(acc_list), 'loss:',np.mean(loss_list))
                

            if i % args.save_epoch==0:
                saver.save(sess, "model/model")
    

if __name__ == '__main__':
    args = get_parms()
    train(args)