transfer

# -*- coding: utf-8 -*-
"""
Created on Mon Nov 26 09:49:26 2018

@author: chsl-dxq
"""

import tensorflow as tf

#curl http://download.tensorflow.org/example_images/flower_photos.tgz
#tar xzf flower_photos.tgz

#wget https://storage.googleapis.com/download.tensorflow.org/models/\inception_dec_2015.zip
#unzip tensorflow/examples/label_image/data/inception_dec_2015.zip

import glob
import os.path
import random
import numpy as np
from tensorflow.python.platform import gfile

BOTTLENECT_TENSOR_SIZE=2048

BOTTLENECT_TENSOR_NAME='pool_3/_reshape:0'

JPEG_DATA_TENSOR_NAME='DecodeJpeg/contents:0'

MODEL_DIR='C:\\Users\\chsl-dxq\\.spyder-py3\\inception_v3'

MODEL_FILE='tensorflow_inception_graph.pb'

CACHE_DIR='C:\\Users\\chsl-dxq\\.spyder-py3\\inception_v3'

INPUT_DATA='C:\\Users\\chsl-dxq\\.spyder-py3\\flower_photos'

VALIDATION_PERCENTAGE=10

TEST_PERCENTAGE=10

LEARNING_RATE=0.01
STEPS=4000
BATCH=100

def create_image_lists(testing_percentage,validation_percentage):
    result={}
    sub_dirs=[x[0] for x in os.walk(INPUT_DATA)]
    is_root_dir=True
    for sub_dir in sub_dirs:
        if is_root_dir:
            is_root_dir=False
            continue
        extensions=['jpg','jpeg','JPG','JPEG']
        file_list=[]
        dir_name=os.path.basename(sub_dir)
        for extension in extensions:
            file_glob=os.path.join(INPUT_DATA,dir_name,'*.'+extension)
            file_list.extend(glob.glob(file_glob))
        if not file_list:
            continue
        
        label_name=dir_name.lower()
        traing_images=[]
        testing_images=[]
        validation_images=[]
        for file_name in file_list:
            base_name=os.path.basename(file_name)
            chance=np.random.randint(100)
            if chance<validation_percentage:
                validation_images.append(base_name)
            elif chance<(testing_percentage+validation_percentage):
                testing_images.append(base_name)
            else:
                traing_images.append(base_name)
                
        result[label_name]={
                'dir':dir_name,
                'training':traing_images,
                'testing':testing_images,
                'validation':validation_images}
        
    return result


def get_image_path(image_lists,image_dir,label_name,index,category):
    label_lists=image_lists[label_name]
    category_list=label_lists[category]
    mod_index=index%len(category_list)
    base_name=category_list[mod_index]
    sub_dir=label_lists['dir']
    full_path=os.path.join(image_dir,sub_dir,base_name)
    return full_path
                    

def get_bottleneck_path(image_lists,label_name,index,category):
    return get_image_path(image_lists,CACHE_DIR,label_name,index,category)+'.txt'


def run_bottleneck_on_image(sess,image_data,image_data_tensor,bottleneck_tensor):
    bottleneck_values=sess.run(bottleneck_tensor,{image_data_tensor:image_data})
    bottleneck_values=np.squeeze(bottleneck_values)
    return bottleneck_values
    
def get_or_create_bottleneck(sess,image_lists,label_name,index,
                             category,jpeg_data_tensor,bottleneck_tensor):
    label_lists=image_lists[label_name]
    sub_dir=label_lists['dir']
    sub_dir_path=os.path.join(CACHE_DIR,sub_dir)
    if not os.path.exists(sub_dir_path): os.makedirs(sub_dir_path)
    bottleneck_path=get_bottleneck_path(image_lists,label_name,index,category)
    
    if not os.path.exists(bottleneck_path):
        image_path=get_image_path(image_lists,INPUT_DATA,label_name,index,category)
        image_data=gfile.FastGFile(image_path,'rb').read()
        bottleneck_values=run_bottleneck_on_image(sess,image_data,jpeg_data_tensor,
                                                  bottleneck_tensor)
        bottleneck_string=','.join(str(x) for x in bottleneck_values)
        with open(bottleneck_path,'w') as bottleneck_file:
            bottleneck_file.write(bottleneck_string)
    else:
        with open(bottleneck_path,'r') as bottleneck_file:
            bottleneck_string=bottleneck_file.read()
        bottleneck_values=[float(x) for x in bottleneck_string.split(',')]
        
    return bottleneck_values

def get_random_cached_bottlenecks(sess,n_classes,image_lists,how_many,category,
                                  jpeg_data_tensor,bottleneck_tensor):
    bottlenecks=[]
    ground_truths=[]
    for _ in range(how_many):
        label_index=random.randrange(n_classes)
        label_name=list(image_lists.keys())[label_index]
        image_index=random.randrange(65536)
        bottleneck=get_or_create_bottleneck(
                sess,image_lists,label_name,image_index,category,jpeg_data_tensor,
                bottleneck_tensor)
        ground_truth=np.zeros(n_classes,dtype=np.float32)
        ground_truth[label_index]=1.0
        bottlenecks.append(bottleneck)
        ground_truths.append(ground_truth)
        
    return bottlenecks,ground_truths

def get_test_bottlenecks(sess,image_lists,n_classes,jpeg_data_tensor,bottleneck_tensor):
    bottlenecks=[]
    ground_truths=[]
    label_name_list=list(image_lists.keys())
    for label_index,label_name in enumerate(label_name_list):
        category='testing'
        for index,unused_base_name in enumerate(image_lists[label_name][category]):
            bottleneck=get_or_create_bottleneck(sess,image_lists,label_name,index,
                                                category,jpeg_data_tensor,bottleneck_tensor)
            ground_truth=np.zeros(n_classes,dtype=np.float32)
            ground_truth[label_index]=1.0
            bottlenecks.append(bottleneck)
            ground_truths.append(ground_truth)
            
    return bottlenecks,ground_truths

def main():
    image_lists=create_image_lists(TEST_PERCENTAGE,VALIDATION_PERCENTAGE)
    n_classes=len(image_lists.keys())
    with gfile.FastGFile(os.path.join(MODEL_DIR,MODEL_FILE),'rb') as f:
        graph_def=tf.GraphDef()
        graph_def.ParseFromString(f.read())
        
    bottleneck_tensor,jpeg_data_tensor=tf.import_graph_def(
            graph_def,return_elements=[BOTTLENECT_TENSOR_NAME,JPEG_DATA_TENSOR_NAME])
    
    bottleneck_input=tf.placeholder(tf.float32,[None,BOTTLENECT_TENSOR_SIZE],
                                    name='BottleneckInputPlaceholder')
    ground_truth_input=tf.placeholder(tf.float32,[None,n_classes],name='GroundTruthInput')
    
    with tf.name_scope('final_training_ops'):
        weights=tf.Variable(tf.truncated_normal([BOTTLENECT_TENSOR_SIZE,n_classes],
                                                stddev=0.001))
        biases=tf.Variable(tf.zeros([n_classes]))
        logits=tf.matmul(bottleneck_input,weights)+biases
        final_tensor=tf.nn.softmax(logits)
        
    cross_entropy=tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=ground_truth_input)
    cross_entropy_mean=tf.reduce_mean(cross_entropy)
    train_step=tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(cross_entropy_mean)
    
    #计算正确率
    with tf.name_scope('evaluation'):
        correct_prediction=tf.equal(tf.argmax(final_tensor,1),tf.argmax(ground_truth_input,1))
        evaluation_step=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
        
    with tf.Session() as sess:
        init=tf.initialize_all_variables()
        sess.run(init)
        
        for i in range(STEPS):
            print(i)
            train_bottlenecks,train_ground_truth=get_random_cached_bottlenecks(
                    sess,n_classes,image_lists,BATCH,'training',jpeg_data_tensor,
                    bottleneck_tensor)
            
            sess.run(train_step,feed_dict={bottleneck_input:train_bottlenecks,
                                           ground_truth_input:train_ground_truth})
            
            if i%100==0 or i+1==STEPS:
                validation_bottlenecks,validation_ground_truth=get_random_cached_bottlenecks(
                        sess,n_classes,image_lists,BATCH,'validation',jpeg_data_tensor,
                        bottleneck_tensor)
                validation_accuracy=sess.run(
                        evaluation_step,feed_dict={
                                bottleneck_input:validation_bottlenecks,
                                ground_truth_input:validation_ground_truth})
                print('step %d: validation accuracy on random samples %d examples=%.1f%%' %
                      (i,BATCH,validation_accuracy*100))
                
        test_bottlenecks,test_ground_truth=get_test_bottlenecks(
                sess,image_lists,n_classes,jpeg_data_tensor,bottleneck_tensor)
        
        test_accuracy=sess.run(evaluation_step,feed_dict={
                bottleneck_input:test_bottlenecks,
                ground_truth_input:test_ground_truth})
            
        print('Final test accuracy=%.1f%%' % (test_accuracy*100))
        


main()
                
    
    
    
    


        







tfrecord
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 28 18:50:42 2018

@author: chsl-dxq
"""

#TFRecod

import numpy as np
import tensorflow as tf
from tensorflow.contrib import slim
from tensorflow.examples.tutorials.mnist import input_data

def make_example(image, label):
    return tf.train.Example(features=tf.train.Features(feature={
        'image' : tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),
        'label' : tf.train.Feature(bytes_list=tf.train.BytesList(value=[label]))
    }))

def write_tfrecord(images, labels, filename):
    writer = tf.python_io.TFRecordWriter(filename)
    for image, label in zip(images, labels):
        labels = labels.astype(np.float32)
        ex = make_example(image.tobytes(), label.tobytes())
        writer.write(ex.SerializeToString())
    writer.close()

def main():
    fashion_mnist = input_data.read_data_sets('fashion', one_hot=True)
    train_images  = fashion_mnist.train.images
    train_labels  = fashion_mnist.train.labels
    test_images   = fashion_mnist.test.images
    test_labels   = fashion_mnist.test.labels
    write_tfrecord(train_images, train_labels, 'fashion_mnist_train.tfrecord')
    write_tfrecord(test_images, test_labels, 'fashion_mnist_test.tfrecord')



def read_tfrecord(filename):
    filename_queue = tf.train.string_input_producer([filename])
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)

    features = tf.parse_single_example(
        serialized_example,
        features={
            'image': tf.FixedLenFeature([], tf.string),
            'label': tf.FixedLenFeature([], tf.string)
        })

    image = tf.decode_raw(features['image'], tf.float32)
    label = tf.decode_raw(features['label'], tf.float64)

    image = tf.reshape(image, [28, 28, 1])
    label = tf.reshape(label, [10])

    image, label = tf.train.batch([image, label],
            batch_size=16,
            capacity=500)

    return image, label


def model(image, label):
    net = slim.conv2d(image, 48, [5,5], scope='conv1')
    net = slim.max_pool2d(net, [2,2], scope='pool1')
    net = slim.conv2d(net, 96, [5,5], scope='conv2')
    net = slim.max_pool2d(net, [2,2], scope='pool2')
    net = slim.flatten(net, scope='flatten')
    net = slim.fully_connected(net, 512, scope='fully_connected1')
    logits = slim.fully_connected(net, 10,
            activation_fn=None, scope='fully_connected2')

    prob = slim.softmax(logits)
    loss = slim.losses.softmax_cross_entropy(logits, label)

    train_op = slim.optimize_loss(loss, slim.get_global_step(),
            learning_rate=0.001,
            optimizer='Adam')

    return train_op

def main():
    train_images, train_labels =read_tfrecord('data/fashion_mnist_train.tfrecord')
    train_op = model(train_images, train_labels)

    step = 0
    with tf.Session() as sess:
        init_op = tf.group(
            tf.local_variables_initializer(),
            tf.global_variables_initializer())
        sess.run(init_op)
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        while step < 3000:
            sess.run([train_op])

            if step % 100 == 0:
                print('step: {}'.format(step))

            step += 1

        coord.request_stop()
        coord.join(threads)

if __name__ == '__main__':
    main()