人脸图像的几何归一化和灰度归一化

2017年10月13日 由 Creater 没有评论 »

在对人脸表情进行识别时,人脸的归一化处理是至关重要的一环,它涉及到下一步处理的好坏。
人脸的归一化包括几何归一化和灰度归一化,几何归一化分两步:人脸校正和人脸裁剪。而灰度归
一化主要是增加图像的对比度,进行光照补偿。
1.几何归一化
几何归一化的目的主要是将表情子图像变换为统一的尺寸,有利于表情特征的提取。具体步骤如下:
(1)标定特征点,这里用[x,y] = ginput(3)函数来标定两眼和鼻子三个特征点。主要是用鼠标动手标
定,获取三个特征点的坐标值。
(2)根据左右两眼的坐标值旋转图像,以保证人脸方向的一致性。设两眼之间的距离为d,其中点为O。
(3)根据面部特征点和几何模型确定矩形特征区域,以O为基准,左右各剪切d,垂直方向各取0.5d和
1.5d的矩形区域进行裁剪。
(4)对表情子区域图像进行尺度变换为统一的尺寸,更有利于表情特征的提取。把截取的图像统一规格
为90*100的图像,实现图像的几何归一化。
面部几何模型如下图:
20130709122421625
2.灰度归一化
灰度归一化 主要是增加图像的亮度,使图像的细节更加清楚,以减弱光线和光照强度的影响。
这里用的是image=255*imadjust(C/255,[0.3;1],[0;1]); 用此函数进行光照补偿。
具体代码如下:

C= imread('Image001.jpg');
figure(1),imshow(C);
C=double(C);
image=255*imadjust(C/255,[0.3;1],[0;1]);
figure(2),imshow(image/255);
title('Lighting compensation');%光照补偿

[x,y] = ginput(3);    %%1 left eye, 2 right eye, 3 top of nose
cos = (x(2)-x(1))/sqrt((x(2)-x(1))^2+(y(2)-y(1))^2);
sin = (y(2)-y(1))/sqrt((x(2)-x(1))^2+(y(2)-y(1))^2);
mid_x = round((x(1)+x(2))/2);
mid_y = round((y(2)+y(1))/2);
d = round(sqrt((x(2)-x(1))^2+(y(2)-y(1))^2));
rotation = atan(sin./cos)*180/pi;
img = imrotate(image,rotation,'bilinear','crop'); 
figure(3), imshow(img);%人脸校正

[h,w] = size(img);
leftpad = mid_x-d;
if leftpad<1
   leftpad = 1;
end
toppad =mid_y - round(0.5*d);
if toppad<1
   toppad = 1;
 end
 rightpad = mid_x + d;
 if rightpad>w
    rightpad = w;
 end
 bottompad = mid_y + round(1.5*d);
 if bottompad>h
    bottompad = h;
 end   
 I1 =[];
 I2 =[];
 I1(:,:) = img(toppad:bottompad,leftpad:rightpad);
 I2(:,:) = imresize(I1,[90 100]); 
 figure(4),imshow(I2,[]);%人脸裁剪

matlab图像类型转换以及uint8、double、im2double、im2uint8和mat2gray等说明

2017年10月13日 由 Creater 没有评论 »

1. matlab图像保存说明
matlab中读取图片后保存的数据是uint8类型(8位无符号整数,即1个字节),以此方式存储的图像称作8位图像,好处相比较默认matlab数据类型双精度浮点double(64位,8个字节),自然可以节省很大一部分存储空间。
详细来说imread把灰度图像存入一个8位矩阵,当为RGB图像时,就存入8位RGB矩阵中。例如,彩色图像像素大小是400*300( 高 * 宽 ),则保存的数据矩阵为400*300*3,其中每个颜色通道值是处于0~255之间。
但是虽然matlab中读入图像的数据类型是uint8,而在图像矩阵运算的时候,使用的数据类型却是double类型。一是为了保证精度,二是因为如果不转换,在对uint8进行加减时会产生溢出,可能提示的错误为:

Function ‘*’ is not defined for values of class ‘uint8’
1个字节无符号整型最大只能存储数据为255,对图片的操作所以很容易溢出。

2. matlab图像类型转换
matlab读入图像的数据是uint8,而matlab中数值一般采用double型(64位)存储和运算。所以要先将图像转为double格式的才能运算,区别如下:

img = imread('./1.jpg'); % 读入是unit8型(0~255)数据
I1  = im2double(img);    % 把图像转换成double精度类型(0~1)
I2  = double(img)/255;   % uint8转换成double,作用同im2double

这里补充说明一下,im2double( )和double( )的区别。double( img)就是简单的数据类型转换,将无符号整型转换为双精度浮点型double,但是数据大小没有变化,原本数据是0~255之间,转化后还是0~255。例如原来是255,那么转换后为255.0,小数位0个数是由double数据长度决定,实际数据大小还是255,只不过这个255已经是double类型空间存储了,再增加不会发生溢出情况。而im2double(img)则不仅仅是将uint8转换到double类型,而且把数据大小从0~255映射到0~1区间。
另外需要补充说明下面这种情况:

img = imread('./1.jpg');
I1  = double(img);
I2  = im2double(I2); % I2数据依然是0~255,并不是0~1,即I1=I2

因为I1已经是double类型,imdouble不会对double类型数据0~255映射到区间0~1,所以上面im2double操作没有任何作用,I1和I2相等。
总结如下:函数im2double将输入转换成double类型。如果输入是uint8、unit16 或者是二值的logical类型,则函数im2double 将其值归一化到0~1之间,当然就是double类型的了。如果输入本身就是double类型,输出还是double类型,并不进行映射。
如果已经是double类型的数据需要映射,则进行下面操作即可:

I2 = I1/255;
3. matlab图像显示imshow类型问题
在matlab处理完数据好,我们希望显示或者imwrite写入图片时候,需要注意。如果直接对double之间的数据矩阵I运行imshow(I),我们会发现有时候显示的是一个白色的图像。
这是因为imshow()显示图像时对double型是认为在0~1范围内,即大于1时都是显示为白色,而imshow显示uint8型时是0~255范围。所以对double类型的图像显示的时候,要么归一化到0~1之间,要么将double类型的0~255数据转为uint8类型。解决方法如下:

imshow(I/255);    % 将图像矩阵转化到0-1之间
imshow(I,[]);     % 自动调整数据的范围以便于显示
inshow(uint8(I)); % 转成uint8

4. uint和double数据转换的深入说明
double和uint8、uint16之间数据转换有下面的函数:

im2double(); % 将图像数组转换成double精度类型
im2uint8();  % 将图像数组转换成unit8类型 
im2uint16(); % 将图像数组转换成unit16类型

当然,当图像数据是double类型的0~1之间,下面两者操作是等价的:

I1=im2uint8(I); 
I2=uint8(round(I*255)); 

但是matlab默认double类型图片数据是位于0~1之间的,而uint8是位于0~255。所以如果矩阵数据图像是double类型(0~1之间)可直接im2uint8,这样不仅完成数据类型转换,而且将0~1之间映射为了0~255之间的数据。
但是如果图像矩阵数据是double类型的0~255,直接im2uint8转换的话,matlab会将大于1的数据都转换为255,0~1之间的数据才会映射到0~255之间整型的数据。例如下面程序:

img64 = [1,2,3,4];
I8    = im2uint8(img64); % I8结果为[255 255 255 255]

5. mat2gray()和im2double()区别
这两个如果都是对uint8数据操作,区别就在于前者是归一化操作,归一化后也在0~1之间,自然结果也是double类型,后者是将数据从0~255映射到0~1。例如:

I  = uint8([1,1,2,3]);
I1 = mat2gray(I);  % 归一化,I1结果是double型[0,0,0.5,1]
I2 = im2double(I); % 映射化,I2结果是double型[0.0039,0.0039,0.0078,0.0118]

可以看出,虽然两者都是一种归一化,im2double只不过最大值永远是常数255,最小值永远是0,如下:

(I−0.0)/(255.0−0.0)
而mat2gray最大值和最小值都是当前矩阵中最大最小的值,如下:
(I−min(I))/(max(I)−min(I))
另外补充一个函数,mat2str()是将数型转换为字符串类型,一般在批量处理图片,给保存图片格式的名称中有作用,这样就不需要格式化sprintf操作了,非常方便。

机器学习模型需要对数据进行归一化

2017年10月11日 由 Creater 没有评论 »

1)归一化后加快了梯度下降求最优解的速度;2)归一化有可能提高精度

1 归一化为什么能提高梯度下降法求解最优解的速度?
如下图所示,蓝色的圈圈图代表的是两个特征的等高线。其中左图两个特征X1和X2的区间相差非常大,X1区间是[0,2000],X2区间是[1,5],其所形成的等高线非常尖。当使用梯度下降法寻求最优解时,很有可能走“之字型”路线(垂直等高线走),从而导致需要迭代很多次才能收敛;而右图对两个原始特征进行了归一化,其对应的等高线显得很圆,在梯度下降进行求解时能较快的收敛。因此如果机器学习模型使用梯度下降法求最优解时,归一化往往非常有必要,否则很难收敛甚至不能收敛。
192105553858119
2 归一化有可能提高精度
一些分类器需要计算样本之间的距离(如欧氏距离),例如KNN。如果一个特征值域范围非常大,那么距离计算就主要取决于这个特征,从而与实际情况相悖(比如这时实际情况是值域范围小的特征更重要)。
3 归一化的类型
1)线性归一化
76512b142c1b7e27e8a7e7eb1fc11225
这种归一化方法比较适用在数值比较集中的情况。这种方法有个缺陷,如果max和min不稳定,很容易使得归一化结果不稳定,使得后续使用效果也不稳定。实际使用中可以用经验常量值来替代max和min。

2)标准差标准化
  经过处理的数据符合标准正态分布,即均值为0,标准差为1,其转化函数为:
z-score-2
  其中μ为所有样本数据的均值,σ为所有样本数据的标准差。

3)非线性归一化
经常用在数据分化比较大的场景,有些数值很大,有些很小。通过一些数学函数,将原始值进行映射。该方法包括 log、指数,正切等。需要根据数据分布的情况,决定非线性函数的曲线,比如log(V, 2)还是log(V, 10)等。
源码示例(这里包含了三种方法:前两种是编程实现,最后一种直接调用MATLAB函数来实现):

oriImage = imread('XXXX.jpg');
grayImage = rgb2gray(oriImage);
figure;
imshow(grayImage);

originalMinValue = double(min(min(grayImage)));
originalMaxValue = double(max(max(grayImage)));
originalRange = originalMaxValue - originalMinValue;

% Get a double image in the range 0 to +255
desiredMin = 0;
desiredMax = 255;
desiredRange = desiredMax - desiredMin;
dblImageS255 = desiredRange * (double(grayImage) - originalMinValue) / originalRange + desiredMin;

figure;
imshow(uint8(dblImageS255));

% Get a double image in the range 0 to +1
desiredMin = 0;
desiredMax = 1;
desiredRange = desiredMax - desiredMin;
dblImageS1 = desiredRange * (double(grayImage) - originalMinValue) / originalRange + desiredMin;

figure;
imshow(dblImageS1);

% Another way to normalazation, which only calls MATLAB function
img3 = mat2gray(oriImage);
figure;
imshow(img3);

linux 通过命令行获取本机外网IP

2017年10月9日 由 Creater 没有评论 »
curl ifconfig.me
curl icanhazip.com
curl ident.me
curl whatismyip.akamai.com
curl tnx.nl/ip
curl myip.dnsomatic.com

MNIST数据库介绍及转换

2017年10月9日 由 Creater 没有评论 »

数据库的一个子集。

MNIST数据库官方网址为:http://yann.lecun.com/exdb/mnist/ ,直接下载,train-images-idx3-ubyte.gz、train-labels-idx1-ubyte.gz等。下载四个文件,解压缩。解压缩后发现这些文件并不是标准的图像格式。这些图像数据都保存在二进制文件中。每个样本图像的宽高为28*28。

以下为将其转换成普通的jpg图像格式的代码:
Matlab

% Matlab_Read_t10k-images_idx3.m
% 用于读取MNIST数据集中t10k-images.idx3-ubyte文件并将其转换成bmp格式图片输出。
% 用法:运行程序,会弹出选择测试图片数据文件t10k-labels.idx1-ubyte路径的对话框和
% 选择保存测试图片路径的对话框,选择路径后程序自动运行完毕,期间进度条会显示处理进度。
% 图片以TestImage_00001.bmp~TestImage_10000.bmp的格式保存在指定路径,10000个文件占用空间39M。。
% 整个程序运行过程需几分钟时间。
% Written By DXY@HUST IPRAI
% 2009-2-22
clear all;
clc;
%读取训练图片数据文件
[FileName,PathName] = uigetfile('*.*','选择测试图片数据文件t10k-images.idx3-ubyte');
TrainFile = fullfile(PathName,FileName);
fid = fopen(TrainFile,'r'); %fopen()是最核心的函数,导入文件,‘r’代表读入
a = fread(fid,16,'uint8'); %这里需要说明的是,包的前十六位是说明信息,从上面提到的那个网页可以看到具体那一位代表什么意义。所以a变量提取出这些信息,并记录下来,方便后面的建立矩阵等动作。
MagicNum = ((a(1)*256+a(2))*256+a(3))*256+a(4);
ImageNum = ((a(5)*256+a(6))*256+a(7))*256+a(8);
ImageRow = ((a(9)*256+a(10))*256+a(11))*256+a(12);
ImageCol = ((a(13)*256+a(14))*256+a(15))*256+a(16);
%从上面提到的网页可以理解这四句
if ((MagicNum~=2051)||(ImageNum~=10000))
    error('不是 MNIST t10k-images.idx3-ubyte 文件!');
    fclose(fid);    
    return;    
end %排除选择错误的文件。
savedirectory = uigetdir('','选择测试图片路径:');
h_w = waitbar(0,'请稍候,处理中>>');
for i=1:ImageNum
    b = fread(fid,ImageRow*ImageCol,'uint8');   %fread()也是核心的函数之一,b记录下了一副图的数据串。注意这里还是个串,是看不出任何端倪的。
    c = reshape(b,[ImageRow ImageCol]); %亮点来了,reshape重新构成矩阵,终于把串转化过来了。众所周知图片就是矩阵,这里reshape出来的灰度矩阵就是该手写数字的矩阵了。
    d = c'; %转置一下,因为c的数字是横着的。。。
    e = 255-d; %根据灰度理论,0是黑色,255是白色,为了弄成白底黑字就加入了e
    e = uint8(e);
    savepath = fullfile(savedirectory,['TestImage_' num2str(i,'d') '.bmp']);
    imwrite(e,savepath,'bmp'); %最后用imwrite写出图片
    waitbar(i/ImageNum);
end
fclose(fid);
close(h_w);

CPP

#include "funset.hpp"
#include <iostream>
#include <fstream>
#include <vector>
#include <opencv2/opencv.hpp>

static int ReverseInt(int i)
{
	unsigned char ch1, ch2, ch3, ch4;
	ch1 = i & 255;
	ch2 = (i >> 8) & 255;
	ch3 = (i >> 16) & 255;
	ch4 = (i >> 24) & 255;
	return((int)ch1 << 24) + ((int)ch2 << 16) + ((int)ch3 << 8) + ch4;
}

static void read_Mnist(std::string filename, std::vector<cv::Mat> &vec)
{
	std::ifstream file(filename, std::ios::binary);
	if (file.is_open()) {
		int magic_number = 0;
		int number_of_images = 0;
		int n_rows = 0;
		int n_cols = 0;
		file.read((char*)&magic_number, sizeof(magic_number));
		magic_number = ReverseInt(magic_number);
		file.read((char*)&number_of_images, sizeof(number_of_images));
		number_of_images = ReverseInt(number_of_images);
		file.read((char*)&n_rows, sizeof(n_rows));
		n_rows = ReverseInt(n_rows);
		file.read((char*)&n_cols, sizeof(n_cols));
		n_cols = ReverseInt(n_cols);

		for (int i = 0; i < number_of_images; ++i) {
			cv::Mat tp = cv::Mat::zeros(n_rows, n_cols, CV_8UC1);
			for (int r = 0; r < n_rows; ++r) {
				for (int c = 0; c < n_cols; ++c) {
					unsigned char temp = 0;
					file.read((char*)&temp, sizeof(temp));
					tp.at<uchar>(r, c) = (int)temp;
				}
			}
			vec.push_back(tp);
		}
	}
}

static void read_Mnist_Label(std::string filename, std::vector<int> &vec)
{
	std::ifstream file(filename, std::ios::binary);
	if (file.is_open()) {
		int magic_number = 0;
		int number_of_images = 0;
		int n_rows = 0;
		int n_cols = 0;
		file.read((char*)&magic_number, sizeof(magic_number));
		magic_number = ReverseInt(magic_number);
		file.read((char*)&number_of_images, sizeof(number_of_images));
		number_of_images = ReverseInt(number_of_images);

		for (int i = 0; i < number_of_images; ++i) {
			unsigned char temp = 0;
			file.read((char*)&temp, sizeof(temp));
			vec[i] = (int)temp;
		}
	}
}

static std::string GetImageName(int number, int arr[])
{
	std::string str1, str2;

	for (int i = 0; i < 10; i++) {
		if (number == i) {
			arr[i]++;
			str1 = std::to_string(arr[i]);

			if (arr[i] < 10) {
				str1 = "0000" + str1;
			} else if (arr[i] < 100) {
				str1 = "000" + str1;
			} else if (arr[i] < 1000) {
				str1 = "00" + str1;
			} else if (arr[i] < 10000) {
				str1 = "0" + str1;
			}

			break;
		}
	}

	str2 = std::to_string(number) + "_" + str1;

	return str2;
}

int MNISTtoImage()
{
	// reference: http://eric-yuan.me/cpp-read-mnist/
	// test images and test labels
	// read MNIST image into OpenCV Mat vector
	std::string filename_test_images = "E:/GitCode/NN_Test/data/database/MNIST/t10k-images.idx3-ubyte";
	int number_of_test_images = 10000;
	std::vector<cv::Mat> vec_test_images;

	read_Mnist(filename_test_images, vec_test_images);

	// read MNIST label into int vector
	std::string filename_test_labels = "E:/GitCode/NN_Test/data/database/MNIST/t10k-labels.idx1-ubyte";
	std::vector<int> vec_test_labels(number_of_test_images);

	read_Mnist_Label(filename_test_labels, vec_test_labels);

	if (vec_test_images.size() != vec_test_labels.size()) {
		std::cout << "parse MNIST test file error" << std::endl;
		return -1;
	}

	// save test images
	int count_digits[10];
	std::fill(&count_digits[0], &count_digits[0] + 10, 0);

	std::string save_test_images_path = "E:/GitCode/NN_Test/data/tmp/MNIST/test_images/";

	for (int i = 0; i < vec_test_images.size(); i++) {
		int number = vec_test_labels[i];
		std::string image_name = GetImageName(number, count_digits);
		image_name = save_test_images_path + image_name + ".jpg";

		cv::imwrite(image_name, vec_test_images[i]);
	}

	// train images and train labels
	// read MNIST image into OpenCV Mat vector
	std::string filename_train_images = "E:/GitCode/NN_Test/data/database/MNIST/train-images.idx3-ubyte";
	int number_of_train_images = 60000;
	std::vector<cv::Mat> vec_train_images;

	read_Mnist(filename_train_images, vec_train_images);

	// read MNIST label into int vector
	std::string filename_train_labels = "E:/GitCode/NN_Test/data/database/MNIST/train-labels.idx1-ubyte";
	std::vector<int> vec_train_labels(number_of_train_images);

	read_Mnist_Label(filename_train_labels, vec_train_labels);

	if (vec_train_images.size() != vec_train_labels.size()) {
		std::cout << "parse MNIST train file error" << std::endl;
		return -1;
	}

	// save train images
	std::fill(&count_digits[0], &count_digits[0] + 10, 0);

	std::string save_train_images_path = "E:/GitCode/NN_Test/data/tmp/MNIST/train_images/";

	for (int i = 0; i < vec_train_images.size(); i++) {
		int number = vec_train_labels[i];
		std::string image_name = GetImageName(number, count_digits);
		image_name = save_train_images_path + image_name + ".jpg";

		cv::imwrite(image_name, vec_train_images[i]);
	}

	// save big imags
	std::string images_path = "E:/GitCode/NN_Test/data/tmp/MNIST/train_images/";
	int width = 28 * 20;
	int height = 28 * 10;
	cv::Mat dst(height, width, CV_8UC1);

	for (int i = 0; i < 10; i++) {
		for (int j = 1; j <= 20; j++) {
			int x = (j-1) * 28;
			int y = i * 28;
			cv::Mat part = dst(cv::Rect(x, y, 28, 28));

			std::string str = std::to_string(j);
			if (j < 10)
				str = "0000" + str;
			else
				str = "000" + str;

			str = std::to_string(i) + "_" + str + ".jpg";
			std::string input_image = images_path + str;

			cv::Mat src = cv::imread(input_image, 0);
			if (src.empty()) {
				fprintf(stderr, "read image error: %s\n", input_image.c_str());
				return -1;
			}

			src.copyTo(part);
		}
	}

	std::string output_image = images_path + "result.png";
	cv::imwrite(output_image, dst);

	return 0;
}

LDA算法入门

2017年9月29日 由 Creater 没有评论 »
参考
Introduction to LDA
Linear Discriminant Analysis – A Brief Tutorial
http://www.aiaccess.net/English/Glossaries/GlosMod/e_gm_fisher_discriminant.htm
线性判别分析(Linear Discriminant Analysis, LDA)算法分析

一. LDA算法概述:

线性判别式分析(Linear Discriminant Analysis, LDA),也叫做Fisher线性判别(Fisher Linear Discriminant ,FLD),是模式识别的经典算法,它是在1996年由Belhumeur引入模式识别和人工智能领域的。性鉴别分析的基本思想是将高维的模式样本投影到最佳鉴别矢量空间,以达到抽取分类信息和压缩特征空间维数的效果,投影后保证模式样本在新的子空间有最大的类间距离和最小的类内距离,即模式在该空间中有最佳的可分离性。因此,它是一种有效的特征抽取方法。使用这种方法能够使投影后模式样本的类间散布矩阵最大,并且同时类内散布矩阵最小。就是说,它能够保证投影后模式样本在新的空间中有最小的类内距离和最大的类间距离,即模式在该空间中有最佳的可分离性。

下载详细介绍文件文档  以及 文档和代码

» 阅读更多: LDA算法入门

[收集]协方差矩阵的详细说明

2017年9月29日 由 Creater 没有评论 »

协方差矩阵的详细说明

1、协方差矩阵中的每一个元素是表示的随机向量X的不同分量之间的协方差,而不是不同样本之间的协方差,如元素Cij就是反映的随机变量Xi, Xj的协方差。

2、协方差是反映的变量之间的二阶统计特性,如果随机向量的不同分量之间的相关性很小,则所得的协方差矩阵几乎是一个对角矩阵。对于一些特殊的应用场合,为了使随机向量的长度较小,可以采用主成分分析的方法,使变换之后的变量的协方差矩阵完全是一个对角矩阵,之后就可以舍弃一些能量较小的分量了(对角线上的元素反映的是方差,也就是交流能量)。特别是在模式识别领域,当模式向量的维数过高时会影响识别系统的泛化性能,经常需要做这样的处理。

3、必须注意的是,这里所得到的式(5)和式(6)给出的只是随机向量协方差矩阵真实值的一个估计(即由所测的样本的值来表示的,随着样本取值的不同会发生变化),故而所得的协方差矩阵是依赖于采样样本的,并且样本的数目越多,样本在总体中的覆盖面越广,则所得的协方差矩阵越可靠。

4、如同协方差和相关系数的关系一样,我们有时为了能够更直观地知道随机向量的不同分量之间的相关性究竟有多大,还会引入相关系数矩阵。

ngrok 后台运行方法

2017年9月29日 由 Creater 没有评论 »

ngrok 用 & 不能后台运行
这就要使用screen这个命令
首先安装screen

apt-get install screen

之后运行

screen -S 任意名字(例如:keepngork)

然后运行ngrok启动命令

./ngrok -config=ngrok.cfg -hostname wx.vrlib.org 80

最后按快捷键

ctrl+A+D

既可以保持ngrok后台运行