精华内容
下载资源
问答
  • base64编码图片数据存储服务器

    千次阅读 2017-03-06 19:50:45
    base64编码图片数据存储服务器 如果直接提交base64编码图片数据,过大的话后台会出现转发错误问题。 我在刚开始接触base64编码图片数据时,就是把base64编码图片数据传到后台来解码生成图片。导致生成的图片无法打开...

    base64编码图片数据存储服务器

    如果直接提交base64编码图片数据,过大的话后台会出现转发错误问题。

    我在刚开始接触base64编码图片数据时,就是把base64编码图片数据传到后台来解码生成图片。导致生成的图片无法打开,后来才发现其实传到后台的base64编码根本就不完整,导致解码出现问题,无法显示图片。所以,base64编码只能在前端处理。

    后来查阅资料,看见一个不错的解决方式就是将base64编码的图片数据转换为Blob(与File相似)并添加到form中提交。下面是代码:

    $(".avatar-save").on("click", function() {
    		var img_lg = document.getElementById('imageHead');
    		// 截图小的显示框内的内容
    		html2canvas(img_lg, {
    			allowTaint: true,
    			taintTest: false,
    			onrendered: function(canvas) {
    				canvas.id = "mycanvas";
    				//生成base64图片数据
    				var dataUrl = canvas.toDataURL("image/png");
    				var newImg = document.createElement("img");
    				newImg.src = dataUrl;
    				imagesAjax(dataUrl);//提交base64图片数据
    			}
    		});
    	})

    //dataUrl	base64图片数据
    function imagesAjax(dataUrl) {
    		//这里连带form里的其他参数也一起提交了,如果不需要提交其他参数可以直接FormData无参数的构造函数
        		var formData = new FormData();//var formData = new FormData(form);
       		//convertBase64UrlToBlob函数是将base64编码转换为Blob
       		//append函数的第一个参数是后台获取数据的参数名,和html标签的input的name属性功能相同
       		formData.append("ImgBase64",convertBase64UrlToBlob(dataUrl));  
       		console.log(formData);
        		//ajax 提交form
    		$.ajax({
    			url:'uploadImage.action',
    			type:'POST',
    			data:formData,
    			 dataType:"text",
          		 	processData : false,         // 告诉jQuery不要去处理发送的数据
           		 	contentType : false,        // 告诉jQuery不要去设置Content-Type请求头
    			success: function(data) {
    				 top.layer.alert("头像更新成功!");
    				 window.location.reload();//刷新当前页面 
    			},
    			error:function(){
                        top.layer.alert("头像更新失败,请检查网络后重试!")
                }
    		});
    	}


    /**
    	 * 将以base64的图片url数据转换为Blob
    	 * 	@param urlData
    	 *   用url方式表示的base64图片数据
    	 */
    	function convertBase64UrlToBlob(urlData){
    	    var bytes=window.atob(urlData.split(',')[1]);        //去掉url的头,并转换为byte
    	    //处理异常,将ascii码小于0的转换为大于0
    	    var ab = new ArrayBuffer(bytes.length);
    	    var ia = new Uint8Array(ab);
    	    for (var i = 0; i < bytes.length; i++) {
    	        ia[i] = bytes.charCodeAt(i);
    	    }
    	    return new Blob( [ab] , {type : 'image/png'});
    	}

    最后注意的是,因为提交到后台的是Blob类型的数据,没有文件名称,需要强制重新命名名称及类型。

    我这里采用的是springMVC注解的方式 接收请求。通过org.springframework.web.multipart.MultipartHttpServletRequest  就可以拿到文件。

    /**
    	 *添加/更新/替换图片
    	 * @param request
    	 * @return
    	 */
    	@ResponseBody
    	@RequestMapping(method = RequestMethod.POST,value="information/uploadImage")
    	public String uploadImage(HttpServletRequest request,HttpSession session){
    		String basePath = request.getSession().getServletContext().getRealPath("upload");
    		Manager manager= (Manager)session.getAttribute("manager");
    		JSONObject obj = new JSONObject();
    		//将文件交给文件处理工具类处理
    		List<Map<String, String>> fileName = UploadFileUtil.uploadBlodImage(request,"/image");
    		Accessory accessory = new Accessory();
    		for (Map<String, String> map : fileName) {
    			//取出用户名称
    			accessory.setAccessoryName(map.get("fileName"));
    			//取出路径别名
    			accessory.setUuidFileName(map.get("newFilePath"));
    			//取出上传文件大小
    			accessory.setValueSize(map.get("valueSize"));
    			//将资源附件进行存储并返回附件关联代码
    			managerService.addOrUpdateManagerToAccessory(accessory, manager.getId(), basePath);
    		}
    		return obj.toString();
    	}	
    }
    

    展开全文
  • YUV420P像素数据编码为JPEG图片

    千次阅读 热门讨论 2016-10-09 16:43:17
    本文的编码器实现了YUV420P的数据编码为JPEG图片。本着简单的原则,代码基本上精简到了极限。使用了2014年5月6号编译的最新的FFMPEG类库。 程序很简单,打开工程后直接运行即可将YUV数据编码为JPEG。本程序十分灵活...

    本文的编码器实现了YUV420P的数据编码为JPEG图片。本着简单的原则,代码基本上精简到了极限。使用了2014年5月6号编译的最新的FFMPEG类库。

    程序很简单,打开工程后直接运行即可将YUV数据编码为JPEG。本程序十分灵活,可以根据需要修改成编码各种图像格式的编码器,比如PNG,GIF等等。平台使用VC2010。

    1.  * 本程序实现了YUV420P像素数据编码为JPEG图片。是最简单的FFmpeg编码方面的教程。 
    2.  * 通过学习本例子可以了解FFmpeg的编码流程。 
    3.  */  
    4.   
    5. #include <stdio.h>  
    6.   
    7. #define __STDC_CONSTANT_MACROS  
    8.   
    9. #ifdef _WIN32  
    10. //Windows  
    11. extern "C"  
    12. {  
    13. #include "libavcodec/avcodec.h"  
    14. #include "libavformat/avformat.h"  
    15. };  
    16. #else  
    17. //Linux...  
    18. #ifdef __cplusplus  
    19. extern "C"  
    20. {  
    21. #endif  
    22. #include <libavcodec/avcodec.h>  
    23. #include <libavformat/avformat.h>  
    24. #ifdef __cplusplus  
    25. };  
    26. #endif  
    27. #endif  
    28.   
    29.   
    30. int main(int argc, char* argv[])  
    31. {  
    32.     AVFormatContext* pFormatCtx;  
    33.     AVOutputFormat* fmt;  
    34.     AVStream* video_st;  
    35.     AVCodecContext* pCodecCtx;  
    36.     AVCodec* pCodec;  
    37.   
    38.     uint8_t* picture_buf;  
    39.     AVFrame* picture;  
    40.     AVPacket pkt;  
    41.     int y_size;  
    42.     int got_picture=0;  
    43.     int size;  
    44.   
    45.     int ret=0;  
    46.   
    47.     FILE *in_file = NULL;                            //YUV source  
    48.     int in_w=480,in_h=272;                           //YUV's width and height  
    49.     const char* out_file = "cuc_view_encode.jpg";    //Output file  
    50.   
    51.     in_file = fopen("cuc_view_480x272.yuv""rb");  
    52.   
    53.     av_register_all();  
    54.   
    55.     //Method 1  
    56.     pFormatCtx = avformat_alloc_context();  
    57.     //Guess format  
    58.     fmt = av_guess_format("mjpeg", NULL, NULL);  
    59.     pFormatCtx->oformat = fmt;  
    60.     //Output URL  
    61.     if (avio_open(&pFormatCtx->pb,out_file, AVIO_FLAG_READ_WRITE) < 0){  
    62.         printf("Couldn't open output file.");  
    63.         return -1;  
    64.     }  
    65.   
    66.     //Method 2. More simple  
    67.     //avformat_alloc_output_context2(&pFormatCtx, NULL, NULL, out_file);  
    68.     //fmt = pFormatCtx->oformat;  
    69.   
    70.     video_st = avformat_new_stream(pFormatCtx, 0);  
    71.     if (video_st==NULL){  
    72.         return -1;  
    73.     }  
    74.     pCodecCtx = video_st->codec;  
    75.     pCodecCtx->codec_id = fmt->video_codec;  
    76.     pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;  
    77.     pCodecCtx->pix_fmt = AV_PIX_FMT_YUVJ420P;  
    78.   
    79.     pCodecCtx->width = in_w;    
    80.     pCodecCtx->height = in_h;  
    81.   
    82.     pCodecCtx->time_base.num = 1;    
    83.     pCodecCtx->time_base.den = 25;     
    84.     //Output some information  
    85.     av_dump_format(pFormatCtx, 0, out_file, 1);  
    86.   
    87.     pCodec = avcodec_find_encoder(pCodecCtx->codec_id);  
    88.     if (!pCodec){  
    89.         printf("Codec not found.");  
    90.         return -1;  
    91.     }  
    92.     if (avcodec_open2(pCodecCtx, pCodec,NULL) < 0){  
    93.         printf("Could not open codec.");  
    94.         return -1;  
    95.     }  
    96.     picture = av_frame_alloc();  
    97.     size = avpicture_get_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);  
    98.     picture_buf = (uint8_t *)av_malloc(size);  
    99.     if (!picture_buf)  
    100.     {  
    101.         return -1;  
    102.     }  
    103.     avpicture_fill((AVPicture *)picture, picture_buf, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);  
    104.   
    105.     //Write Header  
    106.     avformat_write_header(pFormatCtx,NULL);  
    107.   
    108.     y_size = pCodecCtx->width * pCodecCtx->height;  
    109.     av_new_packet(&pkt,y_size*3);  
    110.     //Read YUV  
    111.     if (fread(picture_buf, 1, y_size*3/2, in_file) <=0)  
    112.     {  
    113.         printf("Could not read input file.");  
    114.         return -1;  
    115.     }  
    116.     picture->data[0] = picture_buf;              // Y  
    117.     picture->data[1] = picture_buf+ y_size;      // U   
    118.     picture->data[2] = picture_buf+ y_size*5/4;  // V  
    119.   
    120.     //Encode  
    121.     ret = avcodec_encode_video2(pCodecCtx, &pkt,picture, &got_picture);  
    122.     if(ret < 0){  
    123.         printf("Encode Error.\n");  
    124.         return -1;  
    125.     }  
    126.     if (got_picture==1){  
    127.         pkt.stream_index = video_st->index;  
    128.         ret = av_write_frame(pFormatCtx, &pkt);  
    129.     }  
    130.   
    131.     av_free_packet(&pkt);  
    132.     //Write Trailer  
    133.     av_write_trailer(pFormatCtx);  
    134.   
    135.     printf("Encode Successful.\n");  
    136.   
    137.     if (video_st){  
    138.         avcodec_close(video_st->codec);  
    139.         av_free(picture);  
    140.         av_free(picture_buf);  
    141.     }  
    142.     avio_close(pFormatCtx->pb);  
    143.     avformat_free_context(pFormatCtx);  
    144.   
    145.     fclose(in_file);  
    146.   
    147.     return 0;  
    148. }  

    雷霄骅 (Lei Xiaohua)
    leixiaohua1020@126.com
    http://blog.csdn.net/leixiaohua1020


    版权声明:本文为博主原创文章,未经博主允许不得转载。

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

    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)
    
    展开全文
  • 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数据来说的话,如果解码器生成的图片是所有数据集的平均的话,那么很显然得到的就不是一个数字了,实际程序发现,对于随机的输入一个数字,生成的确实也是数字的样子,并不是所有图片的平均,但是可能是某个类别的平均。

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

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

    展开全文
  • XML传输图片数据-Base64编码

    千次阅读 2010-06-30 18:37:00
    解决方式其一就是先将图片数据以Base64编码,将数据转化成ASCII字符,这样实现将数据入在XML中传输。 (以下是转载)什么是Base64?  <br />按照RFC2045的定义,Base64被定义为:Base64内容传送编码被...
  • 利用base64对图片进行编码及解码

    千次阅读 2015-08-09 22:35:48
    1、对图片文件进行编码,转换为base64编码的格式,及一长串字符; 2、可将字符通过json进行传送; 3、目的方接收json数组,取出编码字符串,并进行解码,显示图片 该方法难点主要还是在于对图片的编解码处理,...
  • emoji图片编码

    千次下载 热门讨论 2012-05-17 15:11:49
    467个emoji的文件和编码数据 包括Unicode编码,UTF8编码,UTF16编码,SBUnicode编码
  • 图片转Base64编码 base64编码图片

    千次阅读 2017-09-23 21:36:37
    这两天给手机写了几个服务(接口形式),其他数据还好,图片实在没处理过,这里记录下使用base64编码遇到的坑。。。。 1、图片转base64编码: public static String getImageStr(String imgUrl) {//将图片文件...
  •  1、将图片base64编码数据和以及其他数据放到字典内,  2、然后转化为json串之后通过POST请求传给后台 。 问题描述: base64编码数据内包含有转义字符 ,后天接收到的数据转义字符不见了
  • /** ... * 图片的base64编码 */ function sumitImageFile(base64Codes){ var form=document.forms[0]; var formData = new FormData(form); //这里连带form里的其他参数也一起提交了,如果不需要
  • 一、对图片的压缩与解压缩,涉及以下内容:1.文件读写2.创建Huffman树3.生成Huffman编码4.压缩图片文件5 . 解压缩图片文件 二、将项目分成三个小任务,下一任务是在上一任务的基础上完成:1.任务一:统计权值...
  • /** * @param base64Codes * 图片的base64编码 */ function sumitImageFile(base64Codes){ var form=document.forms[0]; var formData = new FormData(form); //这里连带form里的其他参数也一起提交...
  • Base64对图片进行编码解码

    千次阅读 2018-08-06 10:11:59
    public static String GetImageStr(String imgFile) { InputStream in = null; byte[] data = null; // 读取图片字节数组 try { in = new FileInputStream(imgFile); ...
  • 首先讲一下什么是Base64编码
  • 数据预处理:独热编码(One-Hot Encoding)

    万次阅读 多人点赞 2017-03-10 11:32:04
    例如: ["male", "from US", "uses Internet Explorer"] 表示为[0, 1, 3] ["female", "from Asia", "uses Chrome"]表示为[1, 2, 1] 但是,即使转化为数字表示后,上述数据也不能直接用在我们的分类器中。这个的整数...
  • Redis数据类型及编码

    万次阅读 2020-04-28 18:12:48
    string类型是二进制安全的,意思是redis的string可以包含任何数据,比如图片或者序列化的对象 。string类型是redis最基本的数据类型,一个键最大能存储512MB的数据。String 数据结构是简单的 key-value 类型,value ...
  • VUE Base64编码图片展示与转换图片

    千次阅读 2020-06-23 14:25:24
    图片的 base64 编码就是可以将一副图片数据编码成一串字符串,使用该字符串代替图像地址,使用 base64 传输图片文件可以节省一个 http 请求,图片的 base64 编码可以算是前端优化的一环 VUE Base64编码图片展示 <...
  • 图片的base64编码就是可以将一副图片数据编码成一串字符串,使用该字符串代替图像地址。 这样做有什么意义呢?我们知道,我们所看到的网页上的每一个图片,都是需要消耗一个 http 请求下载而来的。 没错,不管如何,...
  • C# Base64图片编码和解码

    千次阅读 2019-03-12 09:28:37
    Base64是网络上最常见的用于传输8Bit字节码的编码方式之一,Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045~RFC2049,上面有MIME的详细规范。 Base64编码是从二进制到字符的过程,可...
  • 本篇主要是计算机常识中的信息编码方面的知识进行学习的总结的第二部分 上一篇传送门 数据校验 后面再补齐 字符编码 本质 计算机存储介质中实际存储的都是二进制,我们在使用计算机时看到了一切字符的本质也是二...
  • 编码论——PNG格式图片编码

    千次阅读 2017-11-04 14:51:22
    数据在传输时都是转换为01串的(二进制格式),那么怎么判断一个文件是否为PNG格式的图片呢? 举个例子 \x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x9a\x00\x00\x00\x8d 这个是从一张图片读出的前24个字节(\...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 285,710
精华内容 114,284
关键字:

对图片编码数据