Day 9 [holiday] TensorFlow read summary and analysis of 3 images

def picread(filelist):
    '''
    读取狗的图片并转换成张量
    '''
    #1.构造文件队列
    file_queue=tf.train.string_input_producer(filelist)
    
    #2.构造阅读器去读取图片内容(默认读取一张图片)
    value=reader.read(file_queue)
    print(value)
    #还是会报错的，对于读取的图片时间，一定要解码
    
    #3.对于读取的图片数据进行解码
    image=tf.image.decode_jpeg(value)
    print(image)
    
    #要多做一步，因为你的原图片大小不一样
    image_resize=tf.image.resize_images(image,[200,200])
    print(image_resize)
    
    #注意：一定要把样本的形状固定  [200,200,3]  3是彩色的 不然不知道读多少个
    image_resize.set_shape([200,200,3])
    
    #4.进行批次处理
    tf.train.batch([image_resize],batch_size=20,num_threads=1,capacity=20)
    #20大小一样就行了  或者比他大
    
    print(image_batch)
    
    return image_batch

if __name__=="__main__":
    #1.找到文件，放入列表
    file_name=os.listdir("./data/dog/")
    filelist=[os.path,join("./data/dog/",file) for file in file_name]
    
    #print(file_name)
    image_resize=picread(filelist)
    
    #开启会话运行结果
    with tf.Session as sess:
        #定义一个线程协调器
        coord=tf.train.Coordinator()
        
        #开启读取文件的线程
        threads=tf.train.start_queue_runners(sess,coord=coord)
        
        #打印读取的内容
        print(sess.run([image_resize]))
        
        #回收子线程
        coord.request_stop()
        coord.join(threads)
        
    

This site can look

# Knowledge supplement
1.TensorFlow in tf.app.flags.FLAGS usage introduction
https://blog.csdn.net/rosefun96/article/details/78923140
feel it very fragmented, sum up, then, tf.app.flags .DEFINE_xxx () is to add optional argument (optional) the command line, and the line parameters tf.app.flags.FLAGS removed from the corresponding command parameter. Fixed format, remember on the line

2.uint8, it represents the variable is an unsigned integer in the range 0 to 255.
uint8 means 2 ^ 8-1 = 0 to 255 types of data, are common in the general image processing.

def picread(filelist):
    #1.构造文件队列
    file_queue=tf.train.string_input_producer(filelist)
    #2.构造阅读器去读取图片内容，默认读取一张图片
    value=reader.read(file_queue)
    print(value)
    #还是会报错的，一定要解码
    
    #3.解码
    image=tf.image.decode_jpeg(value)
    print(image)
    
    #要多一步处理图片的大小，统一大小
    image_resize=tf.image.resize_images(image,[200,200])
    print(image_resize)
    image_resize.set_shape([200,200,3])
    
    #4.进行批处理
    tf.train.batch([image_resize],batch_szie=20,num_threads=1,capacity=20)
    
    print(image_batch)
    return image_batch


#定义cifar的数据等命令行参数
FLAGS=tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("cifar_dir","./data/cifar10/cifar-10-batches-bin","文件的目录")

class CifarRead(object):
    #完成读取二进制文件，写进tfrecords，读取tfrecords
    def_init_(self,filelist):
        #文件列表
        self.file_list=filelist
        #定义读取的图片的一些属性
        self.height=32
        self.width=32
        self.channel=3
        #二进制文件每张图片的字节
        self.label_bytes=1
        self.image_bytes=self.height*self.width*self.channel
        
    def read_and_decode(self):
        #1.构造文件队列
        file_queue=tf.train.string_input_producer(self.file_list)
        #2.二进制文件读取器，这个图片选取的是二进制的内容
        reader=tf.FixedLengthRecordReader(self.bytes)
        key,value=reader.read(file_queue)
        #3.解码内容，这个是二进制内容的解码了
        label_image=tf.decode_raw(value,tf.unit8)
        print(label_image)
        #这个时候的他的输出的特征值是后面的目标值
        
        
        #4.分割出图片和标签数据，特征值和目标值
        #这个时候数据类型是 unit8，但是计算必须是unit类型
        #[self.label.bytes]这个前面定义了是1
        label=tf.cast(tf.slice(label_image,[0],[self.label.bytes],tf.int32))
        
        #labelimage切的范围[0],[self.label_bytes]
        image=tf.slice(label_image,[self.label_bytes],[self.image_bytes])
        #告诉他第一个在哪里停止
        
        #5.可以对图片的特征数据进行改变
        image_reshape=tf.reshape(image,[self.height,self.width,self.channel])
        print(label,image_reshape)
        
        #6.批量处理数据
        image_batch,label_batch=tr.train.batch([image_reshape,label],batch_size=10,num_threads=1,capacity=10)
        
        print(image_batch,label_batch)
        
        return image_batch,label_batch

if __name="__main__":
    #1.找到文件，放入列表
    file_name=os.listdir(FLAGS.cifar_dir)
    #下面是只要bin结尾的数据
    file_list=[os.path,join(FLAGS.cifar_dir,file) for file in file_name if file[-3:]="bin"]
    #print(file_name)
    cf=CifarRead(filelist)
    
    #别忘了调用这个
    image_batch,label_batch=cf.read_and_decode()
    
    #开启会话运行结果
    with tf.Session as sess:
        #定义一个线程协调器
        coord=tf.train.Coordinator()
        #开启读文件的线程
        threads=tf.train.start_queue_runners(sess,coord=coord)
        #打印读取的内容
        print(sess.run([image_batch,label_batch]))
        
        #回收子线程
        coord.request_stop()
        coord.join(threads)
    
    
    
    

For example, the pictures on the two-dimensional code to identify your computer and the results on an identified class dictionary format

#批量处理数据

def write_to_tfrecords(self,image_batch,label_batch):
       '''
    将图片的特征值和目标值存进tfrecords
    :param image_batch:10张照片的特征值
    :param label_batch:10张照片的目标值
    :return:None
    
    '''
    #1.构造一个TFRecord存储器
    writer=tf.python_io.TFRecordWriter(FLAGS.cifar_tfrecords)
    
    #2.循环将所有样本都写入文件，每张图片样本都要构造example协议
    for i in range(10):
        #取出第i个图片数据的特征值和目标值
        #image=image_batch[i] 这个获取的是一个类型，我们如果想要获得值
        #再转换成字符串
        image=image_batch[i].eval().tostring()
        label=int(label_batch[i].eval()[0])
        
        #构造一个样本的example
        example=tf.train.Example(features=tf.train.Features(feature={
            "image":tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),
            "label":tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),
        }))
        
        #写入单独的样本
        writer.write(example.SerializeToString)
        
        #关闭
        writer.close()
        return None
    
#因为是二进制，所以要解析，int就不用了
def read_from_tfrecords(self):
    #1.构造文件队列
    tf.train.string_input_producer([])
    
    #2.构造文件阅读器，读取文件的内容
    reader=tf.TFRecordReader()
    key,value=reader.read(file_queue)
    
    #3.解析 example
    features=tf.parse_single_example(value,features={
        #"image":tf.FixedLenFeature(shape,dtype)
        #shape 我们一般指定为空  只有float32，int64，string
        "image":tf.FixedLenFeature([],tf.string),
        "label":tf.FixedLenFeature([],tf.int64),
        
    })
    #print(features["image"],features["label"])
    
    #4.解码内容，如果读取的内容格式是string需要解码，如果是int64，float32不需要    
    image=tf.decode_raw(features["image"],tf.unit8)
    #固定图片形状，方便批处理
    image_reshape=tf.reshape(image,[self.height,self.width,self.channel])
    label=tf.cast(features["label"],tf.int32)
    print(image_reshape,label)
    
    
    #进行批处理
    image_batch,label_batch=tf.train.batch([image_reshape,label],batch_size=10,num_threads=1,capacity=10)
    
    return(image_batch,label_batch)

#加上这个解析，后面的二进制读取和存储都不用了,有的前面加了#都是因为上一步
# 由于有一个eval 所以它一定要写进session 
if __name__=="__main__":
    #1.找到文件，放入列表  路径+名字  ---->列表当中
    file_name=os.listdir(FLAGS.cifar_dir)
    
    filelist=[os.path,join(FLAGS.cifar _dir,file) for file in file_name if file[-3:]="bin"]
    #上面是只要bin结尾的数据
    #print(file_name)
    cf=CifarRead(filelist)
    
    #别忘了调用这个
    #image_batch,label_batch=cf.read_and_decode()
    
    image_batch,label_batch=cf.read_from_tfrecords()
    
    #开启会话运行结果
    with tf.Session() as sess:
        #定义一个线程协调器
        coord=tf.train.Coordinator()
        
        #开启读文件的线程
        threads=tf.train.start_queue_runners(sess,coord=coord)
        
        #存进tfrecords文件
        #print("开始存储")
        
        #cf.write_to_tfrecords(image_batch,label_batch)
        
        #print("结束存储")
        
        #打印读取的内容
        print(sess.run([image_batch,label_batch]))
        
        #回收子线程
        coord.request_stop()
        coord.join(threads)