精华内容
下载资源
问答
  • 图片数据的预处理 所谓,预处理就是训练图片提前进行一些处理,为什么要这么干呢?? 答案是 为了降低其他无关因素最后的识别结果的影响,比如说一幅图片在不同亮度或是对比度等指标下呈现的效果可能差别...

    IDE:pycharm
    Python: Python3.6
    OS: win10
    tf: 1.5.0

    图片数据的预处理

    所谓,预处理就是对训练图片提前进行一些处理,为什么要这么干呢??
    答案是 为了降低其他无关因素对最后的识别结果的影响,比如说一幅图片在不同亮度或是对比度等指标下呈现的效果可能差别特别大,但是这些对于我们来说,不要影响到最后的识别结果,所以这就是预处理最想解决的东西,其次通过预处理方式也可以让数据集更加多样化,随机化,可以让model更加健壮。
    #图像编码处理
    彩色图片为RGB三个通道,所以可以看成一个三维矩阵,矩阵中的每一个数表示了图像上不同位置,不同颜色的亮度。然而对于图片的存储,并非直接存储这个矩阵,而是对图片进行编码之后存储的

    编码解码处理代码

    1.首先展示一下我大欧文
    Kyrie_Irving.jpg
    这里写图片描述
    有详细的讲解注释

    import matplotlib.pyplot as plt  #导入这个包用来显示图片
    import tensorflow as tf
    
    #读取图像的原始图像  这里可能会出现decode‘utf-8’的error读用rb就搞定
    #读入的为二进制流,  ./yangmi.jpg 为当前程序文件夹的图片途径
    #tf.gfile.FastGFile为tf自带的读取数据的操作函数
    image_raw_data = tf.gfile.FastGFile('./Kyrie_Irving.jpg', 'rb',).read()
    with tf.Session() as sess:
        #对图片进行解码 二进制文件解码为uint8 
        img_data = tf.image.decode_jpeg(image_raw_data)
        #输出图片数据(三维矩阵) 每个数字都为0-255之间的数字
        print(img_data.eval())
        #利用matplotlib显示图片
        plt.imshow(img_data.eval())
        plt.show()
        #将图片转换为 float32类型  相当于归一化   矩阵中的数字为0-1之间的数字
        #这个操作是对图片的大小调整等操作提供便利
        img_data = tf.image.convert_image_dtype(img_data, dtype=tf.float32)
        #图片按jpeg格式编码
        encode_image = tf.image.encode_jpeg(img_data)
        #创建文件并写入
        with tf.gfile.GFile('./ouwen', 'wb') as f:
            f.write(encode_image.eval())
    
    

    对没有错你会发现运行之后出error
    这里写图片描述
    这个错误的出现在jpeg编码位置,意思是进行jpeg编码需要的类型矩阵是uint8类型,而这里我把这个类型转换为了float32,所以先不管这个先去掉归一化操作之后的话我再用这个来操作。

    import matplotlib.pyplot as plt
    import tensorflow as tf
    
    #读取图像的原始图像  这里可能会出现decode‘utf-8’的error   读用rb就搞定
    image_raw_data = tf.gfile.FastGFile('./Kyrie_Irving.jpg', 'rb',).read()
    with tf.Session() as sess:
        #对图片进行解码 二进制文件解码为uint8
        img_data = tf.image.decode_jpeg(image_raw_data)
        #输出图片数据(三维矩阵)
        print(img_data.eval())
        #利用matplotlib显示图片
        plt.imshow(img_data.eval())
        plt.show()
    
        #图片按jpeg格式编码
        encode_image = tf.image.encode_jpeg(img_data)
        #创建文件并写入
        with tf.gfile.GFile('./ouwen', 'wb') as f:
            f.write(encode_image.eval())
    
    

    输出:
    三维矩阵
    这里写图片描述
    plt显示的图片
    这里写图片描述
    写入编码之后的文件
    这里写图片描述
    打开的时候选择image
    这里写图片描述
    显示
    这里写图片描述

    小总结

    1.这里是对jpg图片格式的操作,tf中还有png的操作,这个在编写程序导包的时候很容易找到
    2.存储jpg图片的时候需要把图片转换成uint8类型
    #对图片预处理操作

    图片大小调整

    一般数据集都是不整齐的,如果自己准备数据集可能还是通过爬虫搞定的
    所以一般来讲图片的尺寸是大小不一的,但是神经网络的输入节点的个数是固定的,所以在图片预处理阶段应该需要对图片统一大小的操作

    import matplotlib.pyplot as plt
    import tensorflow as tf
    
    #读取图像的原始图像  这里可能会出现decode‘utf-8’的error   读用rb就搞定
    image_raw_data = tf.gfile.FastGFile('./Kyrie_Irving.jpg', 'rb',).read()
    with tf.Session() as sess:
        #对图片进行解码 二进制文件解码为uint8
        img_data = tf.image.decode_jpeg(image_raw_data)
        #利用matplotlib显示图片
        plt.imshow(img_data.eval())
        plt.show()
    
    ################ 主要程序
        #将图片转换为 float32类型  相当于归一化
        #这样方便对图像数据进行处理
        img_data = tf.image.convert_image_dtype(img_data, dtype=tf.float32)
    
        #重新大小 第二个参数和第二个参数都为调整后的图像的大小 method 是调整图像大小的方法
        resizd = tf.image.resize_images(img_data, [200, 200], method=0)
        plt.imshow(resizd.eval())
        plt.show()
    
        img_data = tf.image.convert_image_dtype(resizd, dtype=tf.uint8)
    ###########################
        #图片按jpeg格式编码
        encode_image = tf.image.encode_jpeg(img_data)
        #创建文件并写入
        with tf.gfile.GFile('./ouwen', 'wb') as f:
            f.write(encode_image.eval())
    
    

    结果
    这里写图片描述

    这里写图片描述

    大致程序在*********************两行这个之间
    但是其实最主要的就是两句话

        #这样方便对图像数据进行处理
        img_data = tf.image.convert_image_dtype(img_data, dtype=tf.float32)
    
        #重新大小 第二个参数和第二个参数都为调整后的图像的大小 method 是调整图像大小的方法
        resizd = tf.image.resize_images(img_data, [200, 200], method=0)
    

    如果这里不对图片进行重新编码并且存储的话也不需要再把三维矩阵的值转换为uint8了
    在以下的程序中我就省略这么完整的程序了,直接讲图片处理的函数
    比如这里的

      resizd = tf.image.resize_images(img_data, [200, 200], method=0)
    

    这里写图片描述
    method如上图所示,如果你学过数字图像处理,你应该不陌生,但这里不多讲了

    图像剪裁或是填充

    这里多说一句:其实这些函数都是英语单词的_的连接形式还是很好记的

        #参数: 输入图片数据, 改变尺寸
        crop = tf.image.resize_image_with_crop_or_pad(img_data, 100, 100)
        pad = tf.image.resize_image_with_crop_or_pad(img_data, 800, 800)
    

    crop:
    这里写图片描述
    pad:
    这里写图片描述
    可以看出来如果尺寸大于原图的话周围都自动被填充成黑色

    还可以通过比例进行调整图像的大小

    第二个参数为比例大小0-1之间的数字

     central = tf.image.central_crop(img_data, 0.5)
    

    结果为
    这里写图片描述

    图像翻转

        updown = tf.image.flip_up_down(img_data) #上下镜像
        leftright = tf.image.flip_left_right(img_data)#左右镜像
        transpose = tf.image.transpose_image(img_data)#对角镜像
    

    从代码函数的意思也很容易就理解
    updown:
    这里写图片描述
    leftright :
    这里写图片描述
    transpose :
    这里写图片描述

    小总结

    在很多图像识别问题中,图像的翻转一般不会影响识别的结果。于是在训练模型时采用随机翻转训练图像,这样训练出的模型可以更好的识别不同角度的实体。
    举一个很极端的例子,如果训练样本的目标都在左侧,最后训练出来的model可能就无法很好的识别目标在右侧的图片,所以随机的翻转照片可以性价比很高的在很大程度上缓解这个问题,这一方式也是很常见的。

        updown = tf.image.random_flip_up_down(img_data) #随机上下镜像
        leftright = tf.image.random_flip_left_right(img_data)#随机左右镜像
    

    图片色彩调整

    亮度调整

    birght1 = tf.image.adjust_brightness(img_data, 0.5)
    birght2 = tf.image.adjust_brightness(img_data, -0.5)
    

    对比度

        contrast1 = tf.image.adjust_contrast(img_data, -5)
        contrast2 = tf.image.adjust_contrast(img_data, 5)
    

    色相

      hue = tf.image.adjust_hue(img_data, 0.1)
    

    饱和度

        saturation1 = tf.image.adjust_saturation(img_data, 1)
        saturation2 = tf.image.adjust_saturation(img_data, -1)
    

    小总结

    和图像翻转一样,图像的亮度、对比度、饱和度和色相在很多图像识别应用中都不会影响识别结果。所以和上述的思想一样也是随机的来调整图像的这些属性,从而可以使得训练得到的模型尽可能小的受这些无关因素的影响,这也是预处理的目标之一

         #[-max, max]随机
        brightness= tf.image.random_brightness(img_data, max)
        #[lower, upper]随机
        contrast= tf.image.random_contrast(img_data, lower, upper)
        #[-max, max]随机 max最大为0.5
        hue = tf.image.random_hue(img_data, max)
        ##[lower, upper]随机
        saturation = tf.image.random_saturation(img_data, lower, upper)
    
    展开全文
  • 今天用jmeter对图片对比进行性能测试,post请求为json请求,图片为Base64编码后的图片数据。所以需要将一张本地图片生成base64编码,找到一个js小工具,记录在这儿便于以后复用。 效果: js代码如下: <!...

    今天用jmeter对图片对比进行性能测试,post请求为json请求,图片为Base64编码后的图片数据。所以需要将一张本地图片生成base64编码,找到一个js小工具,记录在这儿便于以后复用。

    效果:

    js代码如下:

        <!DOCTYPE> # 这是将代码复制到一个文件后命名为html格式文件后用浏览器打开即可使用小工具转换
    <input type="file" id="img"> <br/> <button id="start">开始转换</button> <div> 预览:<img id="imgShow" src="" alt=""> </div> <b>Base64数据:</b> <textarea rows=15 cols=60 id="conte"></textarea> <button id='cpData'>复制</button><span id="succ"></span> <div id="len">数据长度:</div> <script> var img = document.getElementById('img') , imgShow = document.getElementById('imgShow') , conte = document.getElementById('conte') , len = document.getElementById('len') , start = document.getElementById('start') , cpData = document.getElementById('cpData'); cpData.addEventListener('click', cpDataF); start.addEventListener('click', startt); /*转换函数*/ function startt() { var imgFile = new FileReader(); imgFile.readAsDataURL(img.files[0]); imgFile.onload = function () { var imgData = this.result; //base64数据 imgShow.setAttribute('src', imgData); conte.value = imgData; len.innerHTML += imgData.length; } } /*复制数据*/ function cpDataF() { conte.select(); // 选择对象 var cpd=document.execCommand("Copy"); // 执行浏览器复制命令 cpd ? document.getElementById('succ').innerHTML = '复制成功' : console.warn('复制失败'); window.setTimeout(function () { document.getElementById('succ').innerHTML = ''; }, 1000) } </script>

     

    转载于:https://www.cnblogs.com/ranxf/p/8946243.html

    展开全文
  • 有时候我们需要把图片编码成base64编码的文本,然后保存起来,这时候就需要把图片的二进制数据读到内存,然后按照base64的算法进行编码得到一大串文本,这样就方便存放或者在网络上传输,当然也可以在网页上显示。...
    有时候我们需要把图片编码成base64编码的文本,然后保存起来,这时候就需要把图片的二进制数据读到内存,然后按照base64的算法进行编码得到一大串文本,这样就方便存放或者在网络上传输,当然也可以在网页上显示。
    
    下面是一个完整的c  实现的base64编码解码程序代码
    
    base64.h
    
    #include "stdafx.h"
    #include 
    展开全文
  • 本文实例讲述了C#二进制数据进行base64编码的方法。分享给大家供大家参考。具体实现方法如下: using System; using System.IO; static class MyModClass { public static string Base64EncodeBytes(this byte[]...
  • PyTorch读取自己的本地图片数据集训练自编码

    万次阅读 热门讨论 2018-08-28 18:09:46
    下面我就以一些动漫头像为例,来说明怎样利用torch来进行训练和测试数据的预处理。下面是图片的格式: ...压缩到三个神经元的目的有两个,一个是可以对图片进行可视化,三个神经元代表三个坐标轴X...

    下面我就以一些动漫头像为例,来说明怎样利用torch来进行训练和测试数据的预处理。下面是图片的格式:

    动漫头像数据集

    上述图片一共有51223张,每个图片的大小为3*96*96。 下载地址为:百度云链接

    网络的基本结构是通过 卷积层*2,全连接层*n,解码层(全连接层*m)输入和输出的数据是一样的,最多是压缩到三个神经元。压缩到三个神经元的目的有两个,一个是可以对图片进行可视化,三个神经元代表三个坐标轴XYZ,另一个目的就是通过对三个神经元的随机赋值,再通过解码层生成一个张图片,相当于使用自编码器作为一个生成模型(效果可能很差)。

    下面是构造自编码网络和训练这个网络的代码:

    import torch
    import torch.nn as nn
    import numpy as np
    import matplotlib.pyplot as plt 
    import cv2 
    import os
    #定义自编码器的网络结构
    class AutoEncoder(nn.Module):
        def __init__(self):
            super(AutoEncoder, self).__init__()
    
            ###############################################################
            self.conv1=nn.Sequential(
                nn.Conv2d(
                    in_channels=3,
                    out_channels=16,
                    kernel_size=3,
                    stride=1,
                    padding=1,
                        ),#->(16,96,96)
                nn.ReLU(),#->(16,96,96)
                nn.MaxPool2d(kernel_size=2),#->(16,48,48)
                )                     
            
            #->(16,48,48)
            ###############################################################
            self.conv2=nn.Sequential(
                nn.Conv2d(#->(16,48,48)
                    in_channels=16,
                    out_channels=32,
                    kernel_size=3,
                    stride=1,
                    padding=1),#->(32,48,48)
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2),#->(32,24,24)            
               
                )
    
            ###############################################################
            self.linear=nn.Sequential(
                nn.Linear( 32*24*24, 256 ), 
                nn.Tanh(),  # 激活函数
                nn.Linear( 256, 64 ), 
                nn.Tanh(),
                nn.Linear( 64, 12),
                nn.Tanh(),
                nn.Linear( 12 ,3),
                nn.Tanh()
                )
          
            #)
            self.decoder=nn.Sequential(
                nn.Linear(3,12),
                nn.Tanh(),
                nn.Linear( 12, 64 ),
                nn.Tanh(),
                nn.Linear( 64, 128 ),
                nn.Tanh(),
                nn.Linear( 128, 96*96*3),
                nn.Sigmoid()
            )
        def forward(self, x):
            x=self.conv1(x)
            x=self.conv2(x)
            x=x.view(x.size(0),-1)
            encoded=self.linear(x)
            decoded=self.decoder(encoded)
            return encoded,decoded
    #训练并反向传播
    def trainOneBatch(batch:torch.FloatTensor,raw:torch.FloatTensor):
        encoded,decoded=auto(batch)
        loss=loss_function(decoded,raw)
    
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    #前向传播获得误差
    def testOneBatch(batch:torch.FloatTensor,raw:torch.FloatTensor):
        encoded,decoded=auto(batch)
        loss=loss_function(decoded,raw)
        return loss
    #超参数
    LR=0.001
    BATCH_SIZE=100
    EPOCHES=30
    #获取gpu是不是可用
    cuda_available=torch.cuda.is_available()
    #实例化网络
    auto=AutoEncoder() 
    
    if cuda_available :
        auto.cuda()
    
    #定义优化器和损失函数
    optimizer=torch.optim.Adam(auto.parameters(),lr=LR)
    loss_function=nn.MSELoss()
    
    
    #数据准备
    DIRECTORY= "E:\\DataSets\\facess\\faces"#这里是自己的图片的位置
    files=os.listdir(DIRECTORY)
    imgs=[]#构造一个存放图片的列表数据结构
    for file in files:
        file_path=DIRECTORY+"\\"+file
        img=cv2.imread(file_path)
        imgs.append(img)
    
    print("train")
    
    #遍历迭代期
    for i in range(EPOCHES):
        print(i)
        #打乱数据
        np.random.shuffle(imgs)
        count=0#count是为了凑齐成为一个batch_size的大小
        batch=[]
    
        for j in range(len(imgs)):
            img=imgs[j]
            count+=1
            batch.append(img)
    
            if count==BATCH_SIZE or j==len(imgs)-1:#这里就算最后
    
                #列表转成张量,再转换维度
                batch_train=torch.Tensor(batch).permute(0,3,2,1)/255#batch,3,96,96
                raw=batch_train.contiguous().view(batch_train.size(0),-1)#batch,3*96*96
                if cuda_available:
                    raw=raw.cuda()#数据变换到gpu上
                    batch_train=batch_train.cuda()
                trainOneBatch(batch_train,raw)#训练一个批次
                batch.clear()
                count=0
        batch.clear()
        #测试
        for j in range(100):
            batch.append(imgs[j])
            batch_train=torch.Tensor(batch).permute(0,3,2,1)/255
            raw=batch_train.contiguous().view(batch_train.size(0),-1)
            if cuda_available:
                raw=raw.cuda()
                batch_train=batch_train.cuda()
        #调用函数获得损失
        loss=testOneBatch(batch_train,raw)
        batch.clear()
        print(loss)
        #把训练的中间结果输出到本地文件
        torch.save(auto,"auto.pkl")
    

    下面是读取训练完成之后的网络,然后进行生成图像的代码:

    
    import torch
    import torch.nn as nn
    import numpy as np
    
    import cv2
    class AutoEncoder(nn.Module):
        def __init__(self):
            super(AutoEncoder, self).__init__()
            #self.encoder=nn.Sequential(     #->(3,96,96)
            ###############################################################
            self.conv1=nn.Sequential(
                nn.Conv2d(
                    in_channels=3,
                    out_channels=16,
                    kernel_size=3,
                    stride=1,
                    padding=1,
                        ),#->(16,96,96)
                nn.ReLU(),#->(16,96,96)
                nn.MaxPool2d(kernel_size=2),#->(16,48,48)
                )                     
            
            #->(16,48,48)
            ###############################################################
            self.conv2=nn.Sequential(
                nn.Conv2d(#->(16,48,48)
                    in_channels=16,
                    out_channels=32,
                    kernel_size=3,
                    stride=1,
                    padding=1),#->(32,48,48)
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2),#->(32,24,24)            
               
                )
    
            ###############################################################
            self.linear=nn.Sequential(
                nn.Linear( 32*24*24, 256 ), 
                nn.Tanh(),  # 激活函数
                nn.Linear( 256, 64 ), 
                nn.Tanh(),
                nn.Linear( 64, 12),
                nn.Tanh(),
                nn.Linear( 12 ,3),
                nn.Tanh()
                )
          
            #)
            self.decoder=nn.Sequential(
                nn.Linear(3,12),
                nn.Tanh(),
                nn.Linear( 12, 64 ),
                nn.Tanh(),
                nn.Linear( 64, 128 ),
                nn.Tanh(),
                nn.Linear( 128, 96*96*3),
                nn.Sigmoid()
            )
        def forward(self, x):
            x=self.conv1(x)
            x=self.conv2(x)
            x=x.view(x.size(0),-1)
            encoded=self.linear(x)
            decoded=self.decoder(encoded)
            return encoded,decoded
    
    auto:AutoEncoder=torch.load("auto.pkl")
    print(auto)
    auto=auto.cuda()
    for i in range(6):
        for j in range(6):
            for k in range(6):
                m=i/2.5-1
                n=i/2.5-1
                p=k/2.5-1
                print(m,n,p)
                x=torch.FloatTensor([m,n,p])
                decoded=auto.decoder(x.cuda())
                img=decoded.contiguous().view(3,96,96).permute(2,1,0).detach().cpu().numpy()*255
                cv2.imwrite("imgs/" + str(i)+str(j)+str(k) + ".jpg",cv2.cvtColor(img,cv2.COLOR_BGR2GRAY))
    
    cv2.waitKey(0)

    下面是给解码器三个数字,然后生成的图像

    我感觉生成的图像样式基本都一样,只是颜色不一样而已。我就怀疑这些生成的图片只是数据集中的图片的平均,然后就了一个程序,然后输出所有图片的平均值,得到的结果和使用自编码网络生成的图片基本一致,可能原因是网络太深,中间层的神经元数量太少。所以如果要用自编码作为生成器的话,可能还需要很多其他的策略。但是对于mnist数据来说的话,如果解码器生成的图片是所有数据集的平均的话,那么很显然得到的就不是一个数字了,实际程序发现,对于随机的输入一个数字,生成的确实也是数字的样子,并不是所有图片的平均,但是可能是某个类别的平均。

    自编码器相当于通过编码器数据集投影到低纬度的表示空间,一般来说会损失一些信息,然后通过解码器把低维的数据,映射到高维的数据。那么利用训练好的网络中的编码器就可以实现降维并可视化的功能,利用解码器就可以从低维空间中选取一些点然后生成最后的数据。数据量再多也是不可能占满低维空间的所有位置的,因为空间中的点的个数是无限的,所以这就给扩充数据集提供了可能性。

    以上均为自己理解,难免会有偏差,欢迎评论、指正!

    展开全文
  • JSON传递图片Base64编码的一点总结

    千次阅读 2018-07-25 16:43:00
    冷静想想之后,发现问题在于使用OpenCV读取图片编码的是Mat::data,图片的纯数据,并非包含完整图片格式头的数据。 需要进行如下操作: Mat faceMat = imread(signlogList[i].snapshot_url); ...
  • # 急需一个可以在网页js调用的可以读取电脑磁盘图片转base64编码数据字符串返回的ocx控件,最好是还包含有磁盘文件和文件夹进行相关读写删除等操作接口?
  • 之前利用tensorflow建立自编码器,再加了分类层,实现了MNIST数据集的分类,但是这是对于图片的处理,我更想要的是一些时序数据进行分析,因此,尝试用凯斯西储大学的轴承数据进行故障分类。这个轴承数据网上...
  • 一些label进行重写时往往会造成编码问题’Invalid byte 2 of 2-byte UTF-8 sequence’,所以在写label的同时也要进行相应的写码操作,如下: import os import xml.etree.ElementTree as ET # 批量修改VOC数据...
  • 之前的一些介绍:tensorflow自编码器+softmax凯斯西储大学轴承数据进行故障分类 前面研究了一下自编码器,并顺利利用自编码轴承数据进行了故障分类,但我们在实际应用时,应用更多的还是堆叠自编码器,而网上...
  • 图片转Base64编码 base64编码图片

    千次阅读 2017-09-23 21:36:37
    这两天给手机写了几个服务(接口形式),其他数据还好,图片实在没处理过,这里记录下使用base64编码遇到的坑。。。。 1、图片转base64编码: public static String getImageStr(String imgUrl) {//将图片文件...
  • 图片的base64编码就是可以将一副图片数据编码成一串字符串,使用该字符串代替图像地址。 这样做有什么意义呢?我们知道,我们所看到的网页上的每一个图片,都是需要消耗一个 http 请求下载而来的。 没错,不管如何,...
  • Base64图片编码优化

    2017-06-22 10:47:00
    通过对图片进行base64编码,将base64(或其他数据)内嵌在image标签的属性当中(或者CSS中或JavaScript中),可以实现将图片直接嵌入代码中的目的,如此一来,可以减少HTTP请求,这对于提升Web性能很有好处。...
  • 图片的base64编码

    2020-05-15 16:38:59
    前端对图片的处理一直以来是一个非常值得研究的点。这里简单的介绍其中的一种:图片的base64编码 什么是base64编码 Base64就是一种编码格式。Base64要求把每三个8Bit的字节转换为四个6Bit的字节(38 = 46 = 24),...
  • IDE:pycharm Python: Python3.6 OS: win10 ...《TensorFlow学习笔记》对图片数据的预处理一、-编码解码调整大小色彩亮度 画标注框 这里还是沿用上一个博文的图片 Kyrie_Irving.jpg ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,075
精华内容 430
关键字:

对图片编码数据