python使用matplotlib绘图 — barChart

matploitlib画图的各种各样的源码以及图样:

http://matplotlib.org/gallery.html

 

    matplotlib 是python最著名的绘图库,它提供了一整套和matlab相似的命令API,十分适合交互式地进行制图。而且也可以方便地将它作为绘图控件,嵌入GUI应用程序中。它的文档相当完备,并且 Gallery页面 中有上百幅缩略图,打开之后都有源程序。因此如果你需要绘制某种类型的图,只需要在这个页面中浏览/复制/粘贴一下,基本上都能搞定。  —–引用自:http://hyry.dip.jp/pydoc/matplotlib_intro.html

你可以从 http://www.lfd.uci.edu/~gohlke/pythonlibs/#matplotlib 下载安装matplotlib。

这篇我们用matplotlib从构造最简单的bar一步一步向复杂的bar前行。什么是最简单的bar,看如下语句你就知道她有多么简单了:

import matplotlib.pyplot as plt

plt.bar(left = 0,height = 1)
plt.show()

执行效果:
是的,三句话就可以了,是我见过最简单的绘图语句。首先我们import了matplotlib.pyplot ,然后直接调用其bar方法,最后用show显示图像。我解释一下bar中的两个参数:
  • left:柱形的左边缘的位置,如果我们指定1那么当前柱形的左边缘的x值就是1.0了
  • height:这是柱形的高度,也就是Y轴的值了
left,height除了可以使用单独的值(此时是一个柱形),也可以使用元组来替换(此时代表多个矩形)。例如,下面的例子:
import matplotlib.pyplot as plt

plt.bar(left = (0,1),height = (1,0.5))
plt.show()

可以看到 left = (0,1)的意思就是总共有两个矩形,第一个的左边缘为0,第二个的左边缘为1。height参数同理。
当然,可能你还觉得这两个矩形“太胖”了。此时我们可以通过指定bar的width参数来设置它们的宽度。
import matplotlib.pyplot as plt

plt.bar(left = (0,1),height = (1,0.5),width = 0.35)
plt.show()

此时又来需求了,我需要标明x,y轴的说明。比如x轴是性别,y轴是人数。实现也很简单,看代码:
import matplotlib.pyplot as plt

plt.xlabel(u’性别’)
plt.ylabel(u’人数’)
plt.bar(left = (0,1),height = (1,0.5),width = 0.35)
plt.show()

注意这里的中文一定要用u(3.0以上好像不用,我用的2.7),因为matplotlib只支持unicode。接下来,让我们在x轴上的每个bar进行说明。比如第一个是“男”,第二个是“女”。
import matplotlib.pyplot as plt

plt.xlabel(u’性别’)
plt.ylabel(u’人数’)

plt.xticks((0,1),(u’男’,u’女’))

plt.bar(left = (0,1),height = (1,0.5),width = 0.35)

plt.show()

plt.xticks的用法和我们前面说到的left,height的用法差不多。如果你有几个bar,那么就是几维的元组。第一个是文字的位置,第二个是具体的文字说明。不过这里有个问题,很显然我们指定的位置有些“偏移”,最理想的状态应该在每个矩形的中间。你可以更改(0,1)=>( (0+0.35)/2 ,(1+0.35)/2 )不过这样比较麻烦。我们可以通过直接指定bar方法里面的align=”center”就可以让文字居中了。
import matplotlib.pyplot as plt

plt.xlabel(u’性别’)
plt.ylabel(u’人数’)

plt.xticks((0,1),(u’男’,u’女’))

plt.bar(left = (0,1),height = (1,0.5),width = 0.35,align=”center”)

plt.show()

接下来,我们还可以给图标加入标题。
plt.title(u”性别比例分析”)
当然,还有图例也少不掉:
import matplotlib.pyplot as plt

plt.xlabel(u’性别’)
plt.ylabel(u’人数’)

plt.title(u”性别比例分析”)
plt.xticks((0,1),(u’男’,u’女’))
rect = plt.bar(left = (0,1),height = (1,0.5),width = 0.35,align=”center”)

plt.legend((rect,),(u”图例”,))

plt.show()

注意这里的legend方法,里面的参数必须是元组。即使你只有一个图例,不然显示不正确。
接下来,我们还可以在每个矩形的上面标注它具体点Y值。这里,我们需要用到一个通用的方法:
def autolabel(rects):
for rect in rects:
height = rect.get_height()
plt.text(rect.get_x()+rect.get_width()/2., 1.03*height, ‘%s’ % float(height))
其中plt.text的参数分别是:x坐标,y坐标,要显示的文字。所以,调用代码如下:
import matplotlib.pyplot as plt

def autolabel(rects):
for rect in rects:
height = rect.get_height()
plt.text(rect.get_x()+rect.get_width()/2., 1.03*height, ‘%s’ % float(height))

plt.xlabel(u’性别’)
plt.ylabel(u’人数’)

plt.title(u”性别比例分析”)
plt.xticks((0,1),(u’男’,u’女’))
rect = plt.bar(left = (0,1),height = (1,0.5),width = 0.35,align=”center”)

plt.legend((rect,),(u”图例”,))
autolabel(rect)

plt.show()

到这里这个图形已经基本完备了,不过可以看到你一个矩形紧靠这顶部,不是很好看。最好能够空出一段距离出来就好了。这个设置我没有找到具体的属性。不过,我还是通过一个小技巧来实现了。就是bar属性的yerr参数。一旦设置了这个参数,那么对应的矩形上面就会有一个竖着的线,我不知道他是干什么的。不过当我把这个值设置的很小的时候,上面的空白就自动空出来了。如图:
rect = plt.bar(left = (0,1),height = (1,0.5),width = 0.35,align=”center”,yerr=0.000001)

对于左右两边能否空出空白来暂时还没有找到(xerr参数不行)

MATLAB的符号计算

所谓符号计算是指在运算时,无须事先对变量赋值,而将所得到结果以标准的符号形式来表示。
例如,在符号变量运算过程中pi就用pi表示,而不是具体的近似数值3.14或3.14159。使用符号变量进行运算能最大限度减少运算过程中因舍入造成的误差。符号变量也便于进行运算过程的演示。

一、符号计算基础

(一) 定义符号变量
参与符号运算的对象可以是符号变量、符号表达式或符号矩阵。符号变量要先定义,后引用。可以用sym函数、syms函数将运算量定义为符号型数据。引用符号运算函数时,用户可以指定函数执行过程中的变量参数;若用户没有指定变量参数,则使用默认的变量作为函数的变量参数。

1、sym函数
sym函数的主要功能是创建符号变量,以便进行符号运算,也可以用于创建符号表达式或符号矩阵。用sym函数创建符号变量的一般格式为:

x = sym(‘x’)

其目的是将’x’创建为符号变量,以x作为输出变量名。每次调用该函数,可以定义一个符号变量。

1
2
3
4
5
6
7
8
9
a=sym(‘a’); %定义‘a’为符号运算量,输出变量名为a
b=sym(‘b’);
x=sym(‘x’);
y=sym(‘y”);  
[x,y]=solve(‘a*x-b*y=1’, ‘a*x+b*y=5’, ‘x’, ‘y’)
                                %以a,b为符号常数,x,y为符号变量
即可得到方程组的解:
x =3/a
y =2/b

(一) 定义符号变量

【例2】已知一复数表达式 z=x+i*y, 试求其共轭复数,并求该表达式与其共轭复数乘积的多项式。
为了使乘积表达式x^2+y^2非负,这里,把变量x和y定义为实数。
x=sym(‘x’,’real’);
y=sym(‘y’,’real’);

z=x+i*y; %定义复数表达式
conj(z); %求共轭复数
expand(z*conj(z)) %求表达式与其共轭复数乘积的
多项式
ans =
x^2+y^2
若要去掉’x’的属性,可以使用下面语句
x = sym(‘x’,’unreal’)
将’x’创建为纯格式的符号变量。

2、syms函数
syms函数的功能与sym函数类似。syms函数可以在一个语句中同时定义多个符号变量,其一般格式为:
syms arg1 arg2 …argN
用于将rg1, arg2,…,argN等符号创建为符号型数据。

(二)默认符号变量
在数学表达式中,一般习惯于使用排在字母表中前面的字母作为变量的系数,而用排在后面的字母表示变量。例如:
f=ax2+bx+c
表达式中的a,b,c通常被认为是常数,用作变量的系数;而将x看作自变量。

例如,数学表达式
f=xn
g=sin(at+b)
根据数学式中表示自变量的习惯,默认a,b,c为符号常数,x为符号变量。
若在MATLAB中表示上述表达式,首先用syms 函数定义a,b,n,t,x为符号对象。在进行导数运算时,由于没有指定符号变量,则系统采用数学习惯来确定表达式中的自变量,默认a,b,c为符号常数,x,t为符号变量。
即 :   对函数f求导为:df/dx
对函数g求导为:dg/dt

(四) 生成符号函数
将表达式中的自变量定义为符号变量后,赋值给符号函数名,即可生成符号函数。例如有一数学表达式:

其用符号表达式生成符号函数fxy的过程为:
syms a b c x y              %定义符号运算量
fxy=(a*x^2+b*y^2)/c^2      %生成符号函数
生成符号函数fxy后,即可用于微积分等符号计算。

1
2
3
4
5
6
7
8
9
【例4】定义一个符号函数 fxy=(a*x2+b*y2)/c2 ,分别求该函数对x、y的导数和对x的积分。
syms a b c x y            %定义符号变量
fxy=(a*x^2+b*y^2)/c^2;  %生成符号函数 
diff(fxy,x)             %符号函数fxy对x求导数
ans =2*a*x/c^2
diff(fxy, y)            %符号函数fxy对y求导数   
ans =2*b*y/c^2
int(fxy, x)             %符号函数fxy对x求积分
ans =1/c^2*(1/3*a*x^3+b*y^2*x)

(五)标准代数运算

很多标准的代数运算可以在符号表达式上执行,函数symadd、symsub、symmul和symdiv为加、减、乘、除两个表达式,sympow将一个表达式上升为另一个表达式的幂次。

f= ‘ 2*x^2+3*x-5 ‘   %  define the symbolic expression
>>f=
2*x^2+3*x-5
>> g= ‘ x^2-x+7 ‘
g=
x^2-x+7

>> symadd(f,g)  %  find an expression for f+g
ans= 3*x^2+2*x+2
>> symsub(f,g)  %  find an expression for f-g
ans= x^2+4*x-12
>> symmul(f,g)  %  find an expression for f*g
ans= (2*x^2+3*x-5)*(x^2-x+7)
>> symdiv(f,g)  %  find an expression for f/g
ans= (2*x^2+3*x-5)/(x^2-x+7)
>> sympow(f, ‘ 3*x ‘ )  %  the same as sym(A)^sym(B)
ans= (2*x^2+3*x-5)^3*x

matlab符号函数及其运算0基础入门

matlab有强大的符号运算的功能。在符号运算下可以对方程,方程组进行求导,求偏导,求积分等复杂运算,加减乘除等简单运算更加易如反掌。

还可以对定义的符号进行某一次赋值,并求出对应的函数值。简单演示记录如下:

1.符号函数的定义:

syms x y   %定义两个符号,x和y

2.使用x,y定义两个方程如下:

>> f1 = 2*x^2 + x^y + x*y + 1;
>> f2 = exp(x^y) + x*y + 100;

%这是两个何其复杂的方程啊

>> F = [f1;f2];
>> F

F =

x*y + x^y + 2*x^2 + 1
exp(x^y) + x*y + 100

3. 求偏微分
>> dFdx = diff(F,x)

dFdx =

4*x + y + x^(y – 1)*y
y + x^(y – 1)*y*exp(x^y)

>>

4. 符号赋值求具体值:
>> B = [diff(f1,x),diff(f1,y);diff(f2,x),diff(f2,y)]

B =

[    4*x + y + x^(y – 1)*y,          x + x^y*log(x)]
[ y + x^(y – 1)*y*exp(x^y), x + x^y*exp(x^y)*log(x)]

>> x0 = 1;y0 = 4;
>> B0 = subs(B,{x,y},{x0,y0})

B0 =

12.0000    1.0000
14.8731    1.0000

>>

上边都是用事实说话,言语不多,把代码执行一遍该懂的自然懂了。

5. 再说一个积分的例子吧

>>
>>
>> f3 = 3*x + 4*y + 100;
>> f3_x = int(f3,x)  %对f3函数对x求积分

f3_x =

(3*x + 4*y + 100)^2/6

>> %将f3_x对x求导数确实等于f3,即验证了int函数的求积分功能

 

Matlab之Mupad散点画线并填充斜线阴影

点对数组:( [ x1,y1]…. [xn,yn] ) 做线:

num := 50;
for i from 1 to num do
x(i) := (i*PI)/num;
end_for;
for i from 1 to num do
y(i) := sin(x(i));
z(i) := cos(x(i));
end_for;

// f1 := plot::Line2d([x(i),y(i)],[x(i+1),y(i+1)],Color=RGB::Blue) $ i=1..(num-1) ;
// f2 := plot::Line2d([x(j),z(j)],[x(j+1),z(j+1)],Color=RGB::Red) $ j=1..(num-1) ;
// plot(f1,f2);
f3 := plot::Polygon2d([[x(i),y(i)] $i = 1..(num-1)],Closed = FALSE);
// S1 = plot::Scene2d(f3,Filled = TRUE,FillStyle = Winding);
plot(f3,Filled = TRUE,FillStyle = Winding);

 

使用了plot::Polygon2d 也就是把这些点看做多边形上的部分顶点,然后做多边形。可以通过选项

Closed = TRUE 或者 Closed = FALSE来设置是否要把这个多边形弄成封闭的多边形。

在plot的时候 设置Filled = TRUE来填充,并使用FillStyle来设置填充方式。

上边的那段代码的运行图为:

这种方法的数组画线法明显比上篇文章里面的三种方法都要好,简便而且好看。

对于例如

这样起终点不在同一个水平线上的,如果直接采用上边的填充方法就会出现很恶心的情况,这是因为虽然起终点没有连接在一块,但仍然把他们连在一块来看做多边形的。你懂的,图如下:

那么,处理方法就是,添加两个额外的点,额外的点分别对应始终点的x轴映射点。 如下f4. 为了不让f4显示出来边只用来显示填充,把他的边颜色设置成白色。而边部分另外画,如f5

f4 := plot::Polygon2d([[x(1),0],[x(i),z(i)] $i=1..(num),[x(num),0]],Closed = FALSE,Color=RGB::White);
f5 := plot::Polygon2d([[x(i),z(i)] $i=1..(num)],Closed = FALSE,Color=RGB::Red);

f4, f5效果图:

这正是我们想要的结果!!!

那么把f3 和 f4,f5画在一块,为了区分阴影部分,就要对阴影填充方式进行设置,用Fillpattern参数:

f3,f4,f5的赋值再次写在这里:

f3 := plot::Polygon2d([[x(i),y(i)] $i = 1..(num-1)],Closed = FALSE,Color=RGB::Blue,FillPattern = FDiagonalLines); //设置成反斜线
f4 := plot::Polygon2d([[x(1),0],[x(i),z(i)] $i=1..(num),[x(num),0]],Closed = FALSE,Color=RGB::White);
f5 := plot::Polygon2d([[x(i),z(i)] $i=1..(num)],Closed = FALSE,Color=RGB::Red);
plot(f3,f4,f5,Filled = TRUE,FillStyle = Winding ,Layout = Horizontal);

效果图:

还阔以。 回宿舍了。明天再探讨如何只在两个线之间画线。

继续昨天的讨论,在两线之间画阴影。  大致思想就是,把需要画阴影的部分的两线之间的点连成一个多边形。不解释了,自己看代码和下面的截图:

f3 := plot::Polygon2d([[x(i),y(i)] $i = 1..(num-1)],Closed = FALSE,Color=RGB::Blue,FillPattern = FDiagonalLines); //设置成反斜线
//f4 := plot::Polygon2d([[x(1),0],[x(i),z(i)] $i=1..(num),[x(num),0]],Closed = FALSE,Color=RGB::White);
f5 := plot::Polygon2d([[x(i),z(i)] $i=1..(num)],Closed = FALSE,Color=RGB::Red);
//plot(f3,f4,f5);
f6 := plot::Polygon2d([[x(i),y(i)] $i=20..(30),[x(abs(j-30)),z(abs(j-30))] $j = 0..10],Closed = TRUE,Color = RGB::Green,Filled = TRUE);
plot(f3,f5,f6);

至此,想要画阴影线区域的目的都可以达到了。本课题结束。

matlab之mupad用散点画线方法

matlab的mupad中,使用两个数组进行画线的实现方法:

生成两个散点数组:

num := 50;
for i from 1 to num do
x(i) := (i*PI)/num;
end_for;
for i from 1 to num do
y(i) := sin(x(i));
z(i) := cos(x(i));
end_for;

然后实现 plot(x,y); hold on; plot(x,z);的功能:

plot(plot::Line2d([x(i),y(i)],[x(i+1),y(i+1)]) $ i=1..(num-1),plot::Line2d([x(j),z(j)],[x(j+1),z(j+1)]) $ j=1..(num-1),Color=RGB::Blue);

这样是对 x,y 的每两个相邻点之间都画线段,然后连接起来。x,z也是一样。

效果如图:

如果想要sin线 与 cos线 不同的颜色。则可以使用下述的方法:

f1 := plot::Line2d([x(i),y(i)],[x(i+1),y(i+1)],Color=RGB::Blue) $ i=1..(num-1) ;
f2 := plot::Line2d([x(j),z(j)],[x(j+1),z(j+1)],Color=RGB::Red) $ j=1..(num-1) ;

plot(f1,f2)

画出的图形为:

如果觉得使用 plot::Line2d来对数组画线太过复杂,想要使用直接对数组画线的函数。那么就用:

plot::Listplot 来对数组进行画线。

例子如下:

y2 := array(1..num);
for i from 1 to num do
y2[i] := sin(x(i));
end_for;
plot( plot::Listplot(y2,PointsVisible=FALSE) )

生成散点 y2 ,然后对y2进行画线。 并且设置不显示点。 效果如图:

是的被你发现了。有一个非常难看的框框,旁边还有莫名其妙的几行文字。所以,才有上边的前两种情况。

 

使用Matlab符号工具箱中MuPAD画带阴影的示意图

Wikipedia, MuPad 是一个计算机代数系统。最初由德国帕德博恩大学(University of Paderborn) 的MuPAD研究小组开发而成。之后,由该研究小组,SciFace Software公司和其他大学的合作伙伴共同开发。2008年9月SciFace被Matlab的东家Mathworks收购,因而,MuPad被整合 进Matlab中的符号工具箱。

以上是MuPad的历史,了解这个有两个用处:第一,Matlab2009以后才有这个功能;第二,MuPad中的语法和Matlab的语法是不一样的。

如何打开MuPad

打开Matlab–>单击左下角的Start–>Toolboxes–>Symbolic Math–>MuPAD

然后会出现一个新的窗口:

一个例子

这个例子是我最近写论文时要画得一个示意图。除了阴影部分,其他都可以用Matlab的常规画图命令画出来;而要画阴影部分,则必须用到MuPAD

成果图:

分析一下图片:一个长方形的框、四条线(两条实线、两条虚线)、两条实线中间的阴影部分。

在MuMAD中画图用plot。如果要画多个图,也只需要一个plot命令。比如,plot(sin(x), cos(x), tan(x), cot(x))因此,我们只需要把图片的每个部分定义好,最后再用plot命令即可。

从最简单的长方形开始。画长方形的代码为:plot::Rectangle(0.95..1.05,1..1.1,LineColor=RGB::Black)其中,0.95..1.05定义的是长方形横坐标的范围,1..1.1定义的纵坐标的范围,LineColor=RGB::Black 定义的是边的颜色。

之后,我们说一下虚线的画法。代码为:plot::Function2d(0.98/x,x=0.95 .. 0.98,Line>

最后就是阴影区域。代码为:plot::Hatch(f1,f2,x=0.95 .. 1.01,Fill>

全部代码如下:

p1:=piecewise([x=0.99,1]):
f1:=plot::Function2d(p1,x=0.95 .. 1.01,LineColor=RGB::Black):
f2:=plot::Function2d(1.01/x,x=0.95 .. 1.01,LineColor=RGB::Black):
f3:=plot::Function2d(0.98/x,x=0.95 .. 0.98,LineColor=RGB::Black,LineStyle=Dashed):
f4:=plot::Function2d(1.02/x,x=0.95 .. 1.02,LineColor=RGB::Black,LineStyle=Dashed):
g:=plot(f1,f2,f3,f4,plot::Hatch(f1,f2,x=0.95 .. 1.01,FillColor=RGB::Black),
plot::Rectangle(0.95..1.05,1..1.1,LineColor=RGB::Black)):

说明:

  • 在输入命令时,如果需要换行,按Ctrl+Enter;直接按Enter的话,就输出结果。
  • Matlab中,通过”=”赋值;MuPAD中,通过”:=”赋值。
  • 如果一次要运行多个命令,需用”:”把命令分隔开。

导出图像

右键图片–>Export Graphics…–>Next–>选择Export current image of animation only–>Next–>选择图片格式和文件保存路径–>Export

图片可保存为png, gif, bmp, tiff, jped, wmf, eps, svg, pdf, jvx, jvd. 如果要用于Latex的话,就存成eps格式的矢量图。

matlab中patch函数的用法

patch

创建补片图形对象

句法:

patch(X,Y,C)

patch(X,Y,Z,C)

patch(FV)

patch(…’PropertyName’,propertyvalue…)

patch(‘PropertyName’,propertyvalue,…)

handle = patch(…)

描述:

   patch是个底层的图形函数,用来创建补片图形对象。一个补片对象是由其顶点坐标确定的一个或多个多边形。用户可以指定补片对象的颜色和灯光。

patch(X,Y,C)

   添加已填充的二维补片到当前坐标轴。X和Y中的元素指定了多边形的定点。如果X和Y是矩阵,MATLAB将每一列生成一个多边形。C决定了补片的颜色,它可以是单个的ColorSpec,每个表面一个颜色,或每个定点一个颜色。如果C是1*3的向量,它将被看成是RGB三元组,直接指定颜色。

patch(X,Y,Z,C)

   创建三维坐标下的补片。

patch(FV)

   使用结构体FV来创建补片。FV包含如下的结构域:vertices、faces以及facevertexdata(可选)。这些结构域对应补片对象的Vertices、Faces和FaceVerticxCData属性。

patch(‘PropertyName’,propertyvalue,…)

   利用指定的属性/值参数对来指定补片对象的所有属性。除非用户显式的指定FaceColor和EdgeColor的值,否则,MATLAB会使用缺省的属性值。该调用格式允许用户使用Faces和Vertices属性值来定义补片。

handle=patch(…)

   返回创建的补片对象的句柄。

注意:

   不像fill或area这样的高层创建函数,patch并不检查图形窗口的设置以及坐标轴的NextPlot属性,它仅仅将补片对象添加到当前坐标轴。

   如果坐标数据不能定义封闭的多边形,patch函数自动使多边形封闭。数据能定理凹面或交叉的多边形。然而,如果单个补片面的边缘相互交叉,得到的面可能不会完全填充。在这种情况下,最好将面分解为更小的多边形。

详细说明patch的属性:

   你可以注明这些属性为:属性名字和属性值成对形式、结构矩阵和细胞矩阵。

   其中有两个属性是用来说明颜色的:

   CData:用在说明X、Y、Z坐标时(XData、YData、ZData)

   FaceVertexCData:用在说明顶点或联接矩阵(Vertices和Faces)

   CData和FaceVertexCData属性接受这样的颜色数据:索引值、真彩色(RGB)值。(CData、FaceVertexCData)

  

   索引颜色数据可以表示整个色图的直接索引值或线性映射到整个色图的刻度值(caxis)。CDataMapping 决定了matlab如何翻译索引颜色数据。
matlab中patch函数的用法鈥斺攅mily

颜色数据说明:

patch的颜色说明如下:

   所有面用同一个颜色;

   一个面一个颜色,即平面着色;

   一个顶点一个颜色,即插值着色;

  

   下面的表格说明了matlab如何解释由CData、FaceVertexCData定义的颜色数据。

   [X,Y,Z]                    CData  

                    索引值            真彩色                  

     m*n             标量              1*1*3        所有面用同一个颜色,边缘用同一个颜色

     m*n            1*n(n>=4)        1*n*3        一个面一个颜色,边缘用一个颜色
     m*n              m*n             m*(n-3)     一个顶点一个颜色,面可以是平滑的一个颜色的或插值的,边缘也可以是平滑的或插值的。

    顶点         面             FaceVertexCData

                            索引值          真彩色

    m*n          k*3         标量            1*3

    m*n          k*3          k*1            k*3               同上

    m*n          k*3          m*1            m*3

举例:

   该例中使用两种不同的方法来创建一个补片对象:

   指定x、y和z坐标以及颜色数据(XData、YData和ZData以及CData属性)

   指定顶点,连接矩阵以及颜色矩阵(Vertices、Faces、FaceVertexCData以及FaceColor属性)

   1、指定x、y和z坐标

   x=[0 0;0 1;1 1];

   y=[1 1;2 2;2 1];

   z=[1 1;1 1;1 1];

   tcolor(1,1,1:3)=[1 1 1];

   tcolor(1,2,1:3)=[.7 .7 .7];

   patch(x,y,z,tcolor)

matlab中patch函数的用法鈥斺攅mily
   注意每个面和其他面之间共用两个顶点。

   2、指定定点和表面

   Vertices属性包含定义补片的每一个定点的坐标,Faces属性确定如何连接这些顶点来组成不判的每一个表面。在本例中,两个顶点位于同一个位置,因此需要指定六个顶点。每一样包含定点的x、y和z坐标。
   vert=[0 1 1;0 2 1;1 2 1;1 1 1];

   有两个表面,按照指定的顺序连接定点而成:

   fac=[1 2 3;1 3 4];

   指定表面的颜色,指定包含两个RGB颜色的2*3的矩阵;

   tcolor=[1 1 1;.7 .7 .7];

   用户必须设置FaceColor属性为flat,通过指定Faces、Vertices、FaceVertexCData以及FaceColor属性来创建

   补片对象:

   patch(’Faces’,fac,’Vertices’,vert,’FaceVertexCData’,tcolor,’FaceColor’,’flat’)

   结果如上图所示。

matlab中patch函数的用法鈥斺攅mily

。。。。。。

  

 

图像处理函数详解——imdilate

功能:对图像实现膨胀操作。

用法:IM2 = imdilate(IM,SE)
IM2 = imdilate(IM,NHOOD)
IM2 = imdilate(IM,SE,PACKOPT)
IM2 = imdilate(…,PADOPT)
IM2 = imdilate(IM,SE) 膨胀灰度,二值,压缩二值图像IM,返回IM2。参数SE为由strel函数返回的结构元素或者结构元素对象组。
IM2 = imdilate(IM,NHOOD)膨胀图像IM,这里NHOOD是定义结构元素邻域0和1的矩阵。
IM2 = imdilate(IM,SE,PACKOPT)定义IM是否是一个压缩的二值图像。
IM2 = imdilate(…,PADOPT)指出输出图像的大小。

例子:
I = imread(‘cameraman.tif’);
se = strel(‘ball’,5,5);
I2 = imdilate(I,se);
imshow(I), title(‘Original’)

figure, imshow(I2), title(‘Dilated’)

如何处理海量数据

在实际的工作环境下,许多人会遇到海量数据这个复杂而艰巨的问题,它的主要难点有以下几个方面:

一、数据量过大,数据中什么情况都可能存在。

如果说有10条数据,那么大不了每条去逐一检查,人为处理,如果有上百条数据,也可以考虑,如果数据上到千万级别,甚至过亿,那不是手工能解决的了,必须通过工具或者程序进行处理,尤其海量的数据中,什么情况都可能存在,例如,数据中某处格式出了问题,尤其在程序处理时,前面还能正常处理,突然到了某个地方问题出现了,程序终止了。

二、软硬件要求高,系统资源占用率高。

对海量的数据进行处理,除了好的方法,最重要的就是合理使用工具,合理分配系统资源。一般情况,如果处理的数据过TB级,小型机是要考虑的,普通的机子如果有好的方法可以考虑,不过也必须加大CPU和内存,就象面对着千军万马,光有勇气没有一兵一卒是很难取胜的。

三、要求很高的处理方法和技巧。

这也是本文的写作目的所在,好的处理方法是一位工程师长期工作经验的积累,也是个人的经验的总结。没有通用的处理方法,但有通用的原理和规则。

下面我们来详细介绍一下处理海量数据的经验和技巧:

一、选用优秀的数据库工具

现在的数据库工具厂家比较多,对海量数据的处理对所使用的数据库工具要求比较高,一般使用Oracle或者DB2,微软公司最近发布的SQL Server 2005性能也不错。另外在BI领域:数据库,数据仓库,多维数据库,数据挖掘等相关工具也要进行选择,象好的ETL工具和好的OLAP工具都十分必要,例如Informatic,Eassbase等。笔者在实际数据分析项目中,对每天6000万条的日志数据进行处理,使用SQL Server 2000需要花费6小时,而使用SQL Server 2005则只需要花费3小时。

二、编写优良的程序代码

处理数据离不开优秀的程序代码,尤其在进行复杂数据处理时,必须使用程序。好的程序代码对数据的处理至关重要,这不仅仅是数据处理准确度的问题,更是数据处理效率的问题。良好的程序代码应该包含好的算法,包含好的处理流程,包含好的效率,包含好的异常处理机制等。

三、对海量数据进行分区操作

对海量数据进行分区操作十分必要,例如针对按年份存取的数据,我们可以按年进行分区,不同的数据库有不同的分区方式,不过处理机制大体相同。例如SQL Server的数据库分区是将不同的数据存于不同的文件组下,而不同的文件组存于不同的磁盘分区下,这样将数据分散开,减小磁盘I/O,减小了系统负荷,而且还可以将日志,索引等放于不同的分区下。

四、建立广泛的索引

对海量的数据处理,对大表建立索引是必行的,建立索引要考虑到具体情况,例如针对大表的分组、排序等字段,都要建立相应索引,一般还可以建立复合索引,对经常插入的表则建立索引时要小心,笔者在处理数据时,曾经在一个ETL流程中,当插入表时,首先删除索引,然后插入完毕,建立索引,并实施聚合操作,聚合完成后,再次插入前还是删除索引,所以索引要用到好的时机,索引的填充因子和聚集、非聚集索引都要考虑。

五、建立缓存机制

当数据量增加时,一般的处理工具都要考虑到缓存问题。缓存大小设置的好差也关系到数据处理的成败,例如,笔者在处理2亿条数据聚合操作时,缓存设置为100000条/Buffer,这对于这个级别的数据量是可行的。

六、加大虚拟内存

如果系统资源有限,内存提示不足,则可以靠增加虚拟内存来解决。笔者在实际项目中曾经遇到针对18亿条的数据进行处理,内存为1GB,1个P42.4G的CPU,对这么大的数据量进行聚合操作是有问题的,提示内存不足,那么采用了加大虚拟内存的方法来解决,在6块磁盘分区上分别建立了6个4096M的磁盘分区,用于虚拟内存,这样虚拟的内存则增加为 4096*6 + 1024 =25600 M,解决了数据处理中的内存不足问题。

七、分批处理

海量数据处理难因为数据量大,那么解决海量数据处理难的问题其中一个技巧是减少数据量。可以对海量数据分批处理,然后处理后的数据再进行合并操作,这样逐个击破,有利于小数据量的处理,不至于面对大数据量带来的问题,不过这种方法也要因时因势进行,如果不允许拆分数据,还需要另想办法。不过一般的数据按天、按月、按年等存储的,都可以采用先分后合的方法,对数据进行分开处理。

八、使用临时表和中间表

数据量增加时,处理中要考虑提前汇总。这样做的目的是化整为零,大表变小表,分块处理完成后,再利用一定的规则进行合并,处理过程中的临时表的使用和中间结果的保存都非常重要,如果对于超海量的数据,大表处理不了,只能拆分为多个小表。如果处理过程中需要多步汇总操作,可按汇总步骤一步步来,不要一条语句完成,一口气吃掉一个胖子。

九、优化查询SQL语句

在对海量数据进行查询处理过程中,查询的SQL语句的性能对查询效率的影响是非常大的,编写高效优良的SQL脚本和存储过程是数据库工作人员的职责,也是检验数据库工作人员水平的一个标准,在对SQL语句的编写过程中,例如减少关联,少用或不用游标,设计好高效的数据库表结构等都十分必要。笔者在工作中试着对1亿行的数据使用游标,运行3个小时没有出结果,这是一定要改用程序处理了。

十、使用文本格式进行处理

对一般的数据处理可以使用数据库,如果对复杂的数据处理,必须借助程序,那么在程序操作数据库和程序操作文本之间选择,是一定要选择程序操作文本的,原因为:程序操作文本速度快;对文本进行处理不容易出错;文本的存储不受限制等。例如一般的海量的网络日志都是文本格式或者csv格式(文本格式),对它进行处理牵扯到数据清洗,是要利用程序进行处理的,而不建议导入数据库再做清洗。

十一、定制强大的清洗规则和出错处理机制

海量数据中存在着不一致性,极有可能出现某处的瑕疵。例如,同样的数据中的时间字段,有的可能为非标准的时间,出现的原因可能为应用程序的错误,系统的错误等,这是在进行数据处理时,必须制定强大的数据清洗规则和出错处理机制。

十二、建立视图或者物化视图

视图中的数据来源于基表,对海量数据的处理,可以将数据按一定的规则分散到各个基表中,查询或处理过程中可以基于视图进行,这样分散了磁盘I/O,正如10根绳子吊着一根柱子和一根吊着一根柱子的区别。

十三、避免使用32位机子(极端情况)

目前的计算机很多都是32位的,那么编写的程序对内存的需要便受限制,而很多的海量数据处理是必须大量消耗内存的,这便要求更好性能的机子,其中对位数的限制也十分重要。

十四、考虑操作系统问题

海量数据处理过程中,除了对数据库,处理程序等要求比较高以外,对操作系统的要求也放到了重要的位置,一般是必须使用服务器的,而且对系统的安全性和稳定性等要求也比较高。尤其对操作系统自身的缓存机制,临时空间的处理等问题都需要综合考虑。

十五、使用数据仓库和多维数据库存储

数据量加大是一定要考虑OLAP的,传统的报表可能5、6个小时出来结果,而基于Cube的查询可能只需要几分钟,因此处理海量数据的利器是OLAP多维分析,即建立数据仓库,建立多维数据集,基于多维数据集进行报表展现和数据挖掘等。

十六、使用采样数据,进行数据挖掘

基于海量数据的数据挖掘正在逐步兴起,面对着超海量的数据,一般的挖掘软件或算法往往采用数据抽样的方式进行处理,这样的误差不会很高,大大提高了处理效率和处理的成功率。一般采样时要注意数据的完整性和,防止过大的偏差。笔者曾经对1亿2千万行的表数据进行采样,抽取出400万行,经测试软件测试处理的误差为千分之五,客户可以接受。

还有一些方法,需要在不同的情况和场合下运用,例如使用代理键等操作,这样的好处是加快了聚合时间,因为对数值型的聚合比对字符型的聚合快得多。类似的情况需要针对不同的需求进行处理。

海量数据是发展趋势,对数据分析和挖掘也越来越重要,从海量数据中提取有用信息重要而紧迫,这便要求处理要准确,精度要高,而且处理时间要短,得到有价值信息要快,所以,对海量数据的研究很有前途,也很值得进行广泛深入的研究。

海量数据处理专题(一)——开篇

  大数据量的问题是很多面试笔试中经常出现的问题,比如baidu google 腾讯 这样的一些涉及到海量数据的公司经常会问到。

  下面的方法是我对海量数据的处理方法进行了一个一般性的总结,当然这些方法可能并不能完全覆盖所有的问题,但是这样的一些方法也基本可以处理绝大多数遇到的问题。下面的一些问题基本直接来源于公司的面试笔试题目,方法不一定最优,如果你有更好的处理方法,欢迎与我讨论。

  本贴从解决这类问题的方法入手,开辟一系列专题来解决海量数据问题。拟包含 以下几个方面。

  1. Bloom Filter
  2. Hash
  3. Bit-Map
  4. 堆(Heap)
  5. 双层桶划分
  6. 数据库索引
  7. 倒排索引(Inverted Index)
  8. 外排序
  9. Trie树
  10. MapReduce

  在这些解决方案之上,再借助一定的例子来剖析海量数据处理问题的解决方案。

海量数据处理专题(二)——Bloom Filter

【什么是Bloom Filter】
Bloom Filter是一种空间效率很高的随机数据结构,它利用位数组很简洁地表示一个集合,并能判断一个元素是否属于这个集合。Bloom Filter的这种高效是有一定代价的:在判断一个元素是否属于某个集合时,有可能会把不属于这个集合的元素误认为属于这个集合(false positive)。因此,Bloom Filter不适合那些“零错误”的应用场合。而在能容忍低错误率的应用场合下,Bloom Filter通过极少的错误换取了存储空间的极大节省。 这里有一篇关于Bloom Filter的详细介绍,不太懂的博友可以看看。
【适用范围】
可以用来实现数据字典,进行数据的判重,或者集合求交集
【基本原理及要点】
对于原理来说很简单,位数组+k个独立hash函数。将hash函数对应的值的位数组置1,查找时如果发现所有hash函数对应位都是1说明存在,很明显这 个过程并不保证查找的结果是100%正确的。同时也不支持删除一个已经插入的关键字,因为该关键字对应的位会牵动到其他的关键字。所以一个简单的改进就是 counting Bloom filter,用一个counter数组代替位数组,就可以支持删除了。

还有一个比较重要的问题,如 何根据输入元素个数n,确定位数组m的大小及hash函数个数。当hash函数个数k=(ln2)*(m/n)时错误率最小。在错误率不大于E的情况 下,m至少要等于n*lg(1/E)才能表示任意n个元素的集合。但m还应该更大些,因为还要保证bit数组里至少一半为0,则m应 该>=nlg(1/E)*lge 大概就是nlg(1/E)1.44倍(lg表示以2为底的对数)。

举个例子我们假设错误率为0.01,则此时m应大概是n的13倍。这样k大概是8个。

注意这里m与n的单位不同,m是bit为单位,而n则是以元素个数为单位(准确的说是不同元素的个数)。通常单个元素的长度都是有很多bit的。所以使用bloom filter内存上通常都是节省的。

【扩展】
Bloom filter将集合中的元素映射到位数组中,用k(k为哈希函数个数)个映射位是否全1表示元素在不在这个集合中。Counting bloom filter(CBF)将位数组中的每一位扩展为一个counter,从而支持了元素的删除操作。Spectral Bloom Filter(SBF)将其与集合元素的出现次数关联。SBF采用counter中的最小值来近似表示元素的出现频率。

【问题实例】
给你A,B两个文件,各存放50亿条URL,每条URL占用64字节,内存限制是4G,让你找出A,B文件共同的URL。如果是三个乃至n个文件呢?

根据这个问题我们来计算下内存的占用,4G=2^32大概是40亿*8大概是340亿bit,n=50亿,如果按出错率0.01算需要的大概是650亿个bit。 现在可用的是340亿,相差并不多,这样可能会使出错率上升些。另外如果这些urlip是一一对应的,就可以转换成ip,则大大简单了。

海量数据处理专题(三)——Hash

【什么是Hash】
Hash,一般翻译做“散列”,也有直接音译为“哈希”的,就是把任意长度的输入(又叫做预映射, pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
HASH主要用于信息安全领域中加密算法,它把一些不同长度的信息转化成杂乱的128位的编码,这些编码值叫做HASH值. 也可以说,hash就是找到一种数据内容和数据存放地址之间的映射关系。
数组的特点是:寻址容易,插入和删除困难;而链表的特点是:寻址困难,插入和删除容易。那么我们能不能综合两者的特性,做出一种寻址容易,插入删除也容易的数据结构?答案是肯定的,这就是我们要提起的哈希表,哈希表有多种不同的实现方法,我接下来解释的是最常用的一种方法——拉链法,我们可以理解为“链表的数组”,如图:

左边很明显是个数组,数组的每个成员包括一个指针,指向一个链表的头,当然这个链表可能为空,也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去,也是根据这些特征,找到正确的链表,再从链表中找出这个元素。
元素特征转变为数组下标的方法就是散列法。散列法当然不止一种,下面列出三种比较常用的。
1,除法散列法
最直观的一种,上图使用的就是这种散列法,公式:
index = value % 16
学过汇编的都知道,求模数其实是通过一个除法运算得到的,所以叫“除法散列法”。
2,平方散列法
求index是非常频繁的操作,而乘法的运算要比除法来得省时(对现在的CPU来说,估计我们感觉不出来),所以我们考虑把除法换成乘法和一个位移操作。公式:
index = (value * value) >> 28
如果数值分配比较均匀的话这种方法能得到不错的结果,但我上面画的那个图的各个元素的值算出来的index都是0——非常失败。也许你还有个问题,value如果很大,value * value不会溢出吗?答案是会的,但我们这个乘法不关心溢出,因为我们根本不是为了获取相乘结果,而是为了获取index。
3,斐波那契(Fibonacci)散列法
平方散列法的缺点是显而易见的,所以我们能不能找出一个理想的乘数,而不是拿value本身当作乘数呢?答案是肯定的。
1,对于16位整数而言,这个乘数是40503
2,对于32位整数而言,这个乘数是2654435769
3,对于64位整数而言,这个乘数是11400714819323198485
这几个“理想乘数”是如何得出来的呢?这跟一个法则有关,叫黄金分割法则,而描述黄金分割法则的最经典表达式无疑就是著名的斐波那契数列,如果你还有兴趣,就到网上查找一下“斐波那契数列”等关键字,我数学水平有限,不知道怎么描述清楚为什么,另外斐波那契数列的值居然和太阳系八大行星的轨道半径的比例出奇吻合,很神奇,对么?
对我们常见的32位整数而言,公式:
i ndex = (value * 2654435769) >> 28
如果用这种斐波那契散列法的话,那我上面的图就变成这样了:

很明显,用斐波那契散列法调整之后要比原来的取摸散列法好很多。
【适用范围】
快速查找,删除的基本数据结构,通常需要总数据量可以放入内存。
【基本原理及要点】
hash函数选择,针对字符串,整数,排列,具体相应的hash方法。
碰撞处理,一种是open hashing,也称为拉链法;另一种就是closed hashing,也称开地址法,opened addressing。
【扩展】
d-left hashing中的d是多个的意思,我们先简化这个问题,看一看2-left hashing。2-left hashing指的是将一个哈希表分成长度相等的两半,分别叫做T1和T2,给T1和T2分别配备一个哈希函数,h1和h2。在存储一个新的key时,同 时用两个哈希函数进行计算,得出两个地址h1[key]和h2[key]。这时需要检查T1中的h1[key]位置和T2中的h2[key]位置,哪一个 位置已经存储的(有碰撞的)key比较多,然后将新key存储在负载少的位置。如果两边一样多,比如两个位置都为空或者都存储了一个key,就把新key 存储在左边的T1子表中,2-left也由此而来。在查找一个key时,必须进行两次hash,同时查找两个位置。
【问题实例】
1).海量日志数据,提取出某日访问百度次数最多的那个IP。
IP的数目还是有限的,最多2^32个,所以可以考虑使用hash将ip直接存入内存,然后进行统计。

海量数据处理专题(四)——Bit-map

【什么是Bit-map】
所谓的Bit-map就是用一个bit位来标记某个元素对应的Value, 而Key即是该元素。由于采用了Bit为单位来存储数据,因此在存储空间方面,可以大大节省。
如果说了这么多还没明白什么是Bit-map,那么我们来看一个具体的例子,假设我们要对0-7内的5个元素(4,7,2,5,3)排序(这里假设这些元素没有重复)。那么我们就可以采用Bit-map的方法来达到排序的目的。要表示8个数,我们就只需要8个Bit(1Bytes),首先我们开辟1Byte的空间,将这些空间的所有Bit位都置为0(如下图:)

然后遍历这5个元素,首先第一个元素是4,那么就把4对应的位置为1(可以这样操作 p+(i/8)|(0x01<<(i%8)) 当然了这里的操作涉及到Big-ending和Little-ending的情况,这里默认为Big-ending),因为是从零开始的,所以要把第五位置为一(如下图):

然后再处理第二个元素7,将第八位置为1,,接着再处理第三个元素,一直到最后处理完所有的元素,将相应的位置为1,这时候的内存的Bit位的状态如下:

然后我们现在遍历一遍Bit区域,将该位是一的位的编号输出(2,3,4,5,7),这样就达到了排序的目的。下面的代码给出了一个BitMap的用法:排序。

C代码 

复制代码
 1     //定义每个Byte中有8个Bit位  
 2     #include <memory.h>  
 3     #define BYTESIZE 8  
 4     void SetBit(char *p, int posi)  
 5     {  
 6         for(int i=0; i < (posi/BYTESIZE); i++)  
 7         {  
 8             p++;  
 9         }  
10        
11         *p = *p|(0x01<<(posi%BYTESIZE));//将该Bit位赋值1  
12         return;  
13     }  
14        
15     void BitMapSortDemo()  
16     {  
17         //为了简单起见,我们不考虑负数  
18         int num[] = {3,5,2,10,6,12,8,14,9};  
19        
20         //BufferLen这个值是根据待排序的数据中最大值确定的  
21 //待排序中的最大值是14,因此只需要2个Bytes(16个Bit)  
22 //就可以了。  
23         const int BufferLen = 2;  
24         char *pBuffer = new char[BufferLen];  
25        
26         //要将所有的Bit位置为0,否则结果不可预知。  
27         memset(pBuffer,0,BufferLen);  
28         for(int i=0;i<9;i++)  
29         {  
30             //首先将相应Bit位上置为1  
31             SetBit(pBuffer,num[i]);  
32         }  
33        
34         //输出排序结果  
35         for(int i=0;i<BufferLen;i++)//每次处理一个字节(Byte)  
36         {  
37             for(int j=0;j<BYTESIZE;j++)//处理该字节中的每个Bit位  
38             {  
39                 //判断该位上是否是1,进行输出,这里的判断比较笨。  
40 //首先得到该第j位的掩码(0x01<<j),将内存区中的  
41 //位和此掩码作与操作。最后判断掩码是否和处理后的  
42 //结果相同  
43                 if((*pBuffer&(0x01<<j)) == (0x01<<j))  
44                 {  
45                     printf("%d ",i*BYTESIZE + j);  
46                 }  
47             }  
48             pBuffer++;  
49         }  
50     }  
51        
52     int _tmain(int argc, _TCHAR* argv[])  
53     {  
54         BitMapSortDemo();  
55         return 0;  
56     }
复制代码

【适用范围】

可进行数据的快速查找,判重,删除,一般来说数据范围是int的10倍以下

【基本原理及要点】

使用bit数组来表示某些元素是否存在,比如8位电话号码

【扩展】

Bloom filter可以看做是对bit-map的扩展

【问题实例】

1)已知某个文件内包含一些电话号码,每个号码为8位数字,统计不同号码的个数。

8位最多99 999 999,大概需要99m个bit,大概10几m字节的内存即可。 (可以理解为从0-99 999 999的数字,每个数字对应一个Bit位,所以只需要99M个Bit==1.2MBytes,这样,就用了小小的1.2M左右的内存表示了所有的8位数的电话)

2)2.5亿个整数中找出不重复的整数的个数,内存空间不足以容纳这2.5亿个整数。

将bit-map扩展一下,用2bit表示一个数即可,0表示未出现,1表示出现一次,2表示出现2次及以上,在遍历这些数的时候,如果对应位置的值是0,则将其置为1;如果是1,将其置为2;如果是2,则保持不变。或者我们不用2bit来进行表示,我们用两个bit-map即可模拟实现这个2bit-map,都是一样的道理。

海量数据处理专题(五)——堆

【什么是堆】
概念:堆是一种特殊的二叉树,具备以下两种性质
1)每个节点的值都大于(或者都小于,称为最小堆)其子节点的值
2)树是完全平衡的,并且最后一层的树叶都在最左边
这样就定义了一个最大堆。如下图用一个数组来表示堆:

 

那么下面介绍二叉堆:二叉堆是一种完全二叉树,其任意子树的左右节点(如果有的话)的键值一定比根节点大,上图其实就是一个二叉堆。

你一定发觉了,最小的一个元素就是数组第一个元素,那么二叉堆这种有序队列如何入队呢?看图:

 

假设要在这个二叉堆里入队一个单元,键值为2,那只需在数组末尾加入这个元素,然后尽可能把这个元素往上挪,直到挪不动,经过了这种复杂度为Ο(logn)的操作,二叉堆还是二叉堆。

那如何出队呢?也不难,看图:


出队一定是出数组的第一个元素,这么来第一个元素以前的位置就成了空位,我们需要把这个空位挪至叶子节点,然后把数组最后一个元素插入这个空位,把这个“空位”尽量往上挪。这种操作的复杂度也是Ο(logn)。

【适用范围】
海量数据前n大,并且n比较小,堆可以放入内存

【基本原理及要点】
最大堆求前n小,最小堆求前n大。方法,比如求前n小,我们比较当前元素与最大堆里的最大元素,如果它小于最大元素,则应该替换那个最大元 素。这样最后得到的n个元素就是最小的n个。适合大数据量,求前n小,n的大小比较小的情况,这样可以扫描一遍即可得到所有的前n元素,效率很高。

【扩展】
双堆,一个最大堆与一个最小堆结合,可以用来维护中位数。

【问题实例】
1)100w个数中找最大的前100个数。
用一个100个元素大小的最小堆即可。

 

海量数据处理专题(六)

【什么是双层桶】  
事实上,与其说双层桶划分是一种数据结构,不如说它是一种算法设计思想。面对一堆大量的数据我们无法处理的时候,我们可以将其分成一个个小的单元,然后根据一定的策略来处理这些小单元,从而达到目的。

【适用范围】 
第k大,中位数,不重复或重复的数字

【基本原理及要点】 
因为元素范围很大,不能利用直接寻址表,所以通过多次划分,逐步确定范围,然后最后在一个可以接受的范围内进行。可以通过多次缩小,双层只是一个例子,分治才是其根本(只是“只分不治”)。

【扩展】 
当有时候需要用一个小范围的数据来构造一个大数据,也是可以利用这种思想,相比之下不同的,只是其中的逆过程。

【问题实例】 
1).2.5亿个整数中找出不重复的整数的个数,内存空间不足以容纳这2.5亿个整数。

有 点像鸽巢原理,整数个数为2^32,也就是,我们可以将这2^32个数,划分为2^8个区域(比如用单个文件代表一个区域),然后将数据分离到不同的区 域,然后不同的区域在利用bitmap就可以直接解决了。也就是说只要有足够的磁盘空间,就可以很方便的解决。 当然这个题也可以用我们前面讲过的BitMap方法解决,正所谓条条大道通罗马~~~

2).5亿个int找它们的中位数。

这个例子比上面那个更明显。首先我们将int划分为2^16个区域,然后读取数据统计落到各个区域里的数的个数,之后我们根据统计结果就可以判断中位数落到那个区域,同时知道这个区域中的第几大数刚好是中位数。然后第二次扫描我们只统计落在这个区域中的那些数就可以了。

实 际上,如果不是int是int64,我们可以经过3次这样的划分即可降低到可以接受的程度。即可以先将int64分成2^24个区域,然后确定区域的第几 大数,在将该区域分成2^20个子区域,然后确定是子区域的第几大数,然后子区域里的数的个数只有2^20,就可以直接利用direct addr table进行统计了。

3).现在有一个0-30000的随机数生成器。请根据这个随机数生成器,设计一个抽奖范围是0-350000彩票中奖号码列表,其中要包含20000个中奖号码。

这个题刚好和上面两个思想相反,一个0到3万的随机数生成器要生成一个0到35万的随机数。那么我们完全可以将0-35万的区间分成35/3=12个区 间,然后每个区间的长度都小于等于3万,这样我们就可以用题目给的随机数生成器来生成了,然后再加上该区间的基数。那么要每个区间生成多少个随机数呢?计 算公式就是:区间长度*随机数密度,在本题目中就是30000*(20000/350000)。最后要注意一点,该题目是有隐含条件的:彩票,这意味着你 生成的随机数里面不能有重复,这也是我为什么用双层桶划分思想的另外一个原因。

海量数据处理专题(七)——数据库索引及优化

索引是对数据库表中一列或多列的值进行排序的一种结构,使用索引可快速访问数据库表中的特定信息。

数据库索引

什么是索引

数据库索引好比是一本书前面的目录,能加快数据库的查询速度。
例如这样一个查询:select * from table1 where id=44。如果没有索引,必须遍历整个表,直到ID等于44的这一行被找到为止;有了索引之后(必须是在ID这一列上建立的索引),直接在索引里面找44(也就是在ID这一列找),就可以得知这一行的位置,也就是找到了这一行。可见,索引是用来定位的。
索引分为聚簇索引和非聚簇索引两种,聚簇索引 是按照数据存放的物理位置为顺序的,而非聚簇索引就不一样了;聚簇索引能提高多行检索的速度,而非聚簇索引对于单行的检索很快。

概述

建立索引的目的是加快对表中记录的查找或排序。
为表设置索引要付出代价的:一是增加了数据库的存储空间,二是在插入和修改数据时要花费较多的时间(因为索引也要随之变动)。

 

B树索引-Sql Server索引方式

为什么要创建索引

创建索引可以大大提高系统的性能。
第一,通过创建唯一性索引,可以保证数据库表中每一行数据的唯一性。
第二,可以大大加快数据的检索速度,这也是创建索引的最主要的原因。
第三,可以加速表和表之间的连接,特别是在实现数据的参考完整性方面特别有意义。
第四,在使用分组和排序子句进行数据检索时,同样可以显著减少查询中分组和排序的时间。
第五,通过使用索引,可以在查询的过程中,使用优化隐藏器,提高系统的性能。
也许会有人要问:增加索引有如此多的优点,为什么不对表中的每一个列创建一个索引呢?因为,增加索引也有许多不利的方面。
第一,创建索引和维护索引要耗费时间,这种时间随着数据量的增加而增加。
第二,索引需要占物理空间,除了数据表占数据空间之外,每一个索引还要占一定的物理空间,如果要建立聚簇索引,那么需要的空间就会更大。
第三,当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,这样就降低了数据的维护速度。

在哪建索引

索引是建立在数据库表中的某些列的上面。在创建索引的时候,应该考虑在哪些列上可以创建索引,在哪些列上不能创建索引。一般来说,应该在这些列上创建索引:
在经常需要搜索的列上,可以加快搜索的速度;
在作为主键的列上,强制该列的唯一性和组织表中数据的排列结构;
在经常用在连接的列上,这些列主要是一些外键,可以加快连接的速度;在经常需要根据范围进行搜索的列上创建索引,因为索引已经排序,其指定的范围是连续的;
在经常需要排序的列上创建索引,因为索引已经排序,这样查询可以利用索引的排序,加快排序查询时间;
在经常使用在WHERE子句中的列上面创建索引,加快条件的判断速度。
同样,对于有些列不应该创建索引。一般来说,不应该创建索引的的这些列具有下列特点:
第一,对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为,既然这些列很少使用到,因此有索引或者无索引,并不能提高查询速度。相反,由于增加了索引,反而降低了系统的维护速度和增大了空间需求。
第二,对于那些只有很少数据值的列也不应该增加索引。这是因为,由于这些列的取值很少,例如人事表的性别列,在查询的结果中,结果集的数据行占了表中数据行的很大比例,即需要在表中搜索的数据行的比例很大。增加索引,并不能明显加快检索速度。
第三,对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为,这些列的数据量要么相当大,要么取值很少,不利于使用索引。
第四,当修改性能远远大于检索性能时,不应该创建索引。这是因为,修改性能和检索性能是互相矛盾的。当增加索引时,会提高检索性能,但是会降低修改性能。当减少索引时,会提高修改性能,降低检索性能。因此,当修改操作远远多于检索操作时,不应该创建索引。

数据库优化

此外,除了数据库索引之外,在LAMP结果如此流行的今天,数据库(尤其是MySQL)性能优化也是海量数据处理的一个热点。下面就结合自己的经验,聊一聊MySQL数据库优化的几个方面。
首先,在数据库设计的时候,要能够充分的利用索引带来的性能提升,至于如何建立索引,建立什么样的索引,在哪些字段上建立索引,上面已经讲的很清楚了,这里不在赘述。另外就是设计数据库的原则就是尽可能少的进行数据库写操作(插入,更新,删除等),查询越简单越好。如下:

数据库设计

其次,配置缓存是必不可少的,配置缓存可以有效的降低数据库查询读取次数,从而缓解数据库服务器压力,达到优化的目的,一定程度上来讲,这算是一个“围魏救赵”的办法。可配置的缓存包括索引缓存(key_buffer),排序缓存(sort_buffer),查询缓存(query_buffer),表描述符缓存(table_cache),如下图:

配置缓存

  第三,切表,切表也是一种比较流行的数据库优化法。分表包括两种方式:横向分表和纵向分表,其中,横向分表比较有使用意义,故名思议,横向切表就是指把记录分到不同的表中,而每条记录仍旧是完整的(纵向切表后每条记录是不完整的),例如原始表中有100条记录,我要切成2个表,那么最简单也是最常用的方法就是ID取摸切表法,本例中,就把ID为1,3,5,7。。。的记录存在一个表中,ID为2,4,6,8,。。。的记录存在另一张表中。虽然横向切表可以减少查询强度,但是它也破坏了原始表的完整性,如果该表的统计操作比较多,那么就不适合横向切表。横向切表有个非常典型的用法,就是用户数据:每个用户的用户数据一般都比较庞大,但是每个用户数据之间的关系不大,因此这里很适合横向切表。最后,要记住一句话就是:分表会造成查询的负担,因此在数据库设计之初,要想好是否真的适合切表的优化:

分表

第四,日志分析,在数据库运行了较长一段时间以后,会积累大量的LOG日志,其实这里面的蕴涵的有用的信息量还是很大的。通过分析日志,可以找到系统性能的瓶颈,从而进一步寻找优化方案。

性能分析

以上讲的都是单机MySQL的性能优化的一些经验,但是随着信息大爆炸,单机的数据库服务器已经不能满足我们的需求,于是,多多节点,分布式数据库网络出现了,其一般的结构如下:

分布式数据库结构

这种分布式集群的技术关键就是“同步复制”。。。

 

 

海量数据处理专题(八)——倒排索引(搜索引擎之基石)

引言:

在信息大爆炸的今天,有了搜索引擎的帮助,使得我们能够快速,便捷的找到所求。提到搜索引擎,就不得不说VSM模型,说到VSM,就不得不聊倒排索引。可以毫不夸张的讲,倒排索引是搜索引擎的基石。

VSM检索模型

VSM全称是Vector Space Model(向量空间模型),是IR(Information Retrieval信息检索)模型中的一种,由于其简单,直观,高效,所以被广泛的应用到搜索引擎的架构中。98年的Google就是凭借这样的一个模型,开始了它的疯狂扩张之路。废话不多说,让我们来看看到底VSM是一个什么东东。

在开始之前,我默认大家对线性代数里面的向量(Vector)有一定了解的。向量是既有大小又有方向的量,通常用有向线段表示,向量有:加、减、倍数、内积、距离、模、夹角的运算。

文档(Document):一个完整的信息单元,对应的搜索引擎系统里,就是指一个个的网页。

标引项(Term):文档的基本构成单位,例如在英文中可以看做是一个单词,在中文中可以看作一个词语。

查询(Query):一个用户的输入,一般由多个Term构成。

那么用一句话概况搜索引擎所做的事情就是:对于用户输入的Query,找到最相似的Document返回给用户。而这正是IR模型所解决的问题:

信息检索模型是指如何对查询和文档进行表示,然后对它们进行相似度计算的框架和方法。

举个简单的例子:

现在有两篇文章(Document)分别是 “春风来了,春天的脚步近了” 和 “春风不度玉门关”。然后输入的Query是“春风”,从直观上感觉,前者和输入的查询更相关一些,因为它包含有2个春,但这只是我们的直观感觉,如何量化呢,要知道计算机是门严谨的学科^_^。这个时候,我们前面讲的Term和VSM模型就派上用场了。

首先我们要确定向量的维数,这时候就需要一个字典库,字典库的大小,即是向量的维数。在该例中,字典为{春风,来了,春天, 的,脚步,近了,不度,玉门关} ,文档向量,查询向量如下图:

VSM模型示例

PS:为了简单起见,这里分词的粒度很大。

将Query和Document都量化为向量以后,那么就可以计算用户的查询和哪个文档相似性更大了。简单的计算结果是D1和D2同Query的内积都是1,囧。当然了,如果分词粒度再细一些,查询的结果就是另外一个样子了,因此分词的粒度也是会对查询结果(主要是召回率和准确率)造成影响的。

上述的例子是用一个很简单的例子来说明VSM模型的,计算文档相似度的时候也是采用最原始的内积的方法,并且只考虑了词频(TF)影响因子,而没有考虑反词频(IDF),而现在比较常用的是cos夹角法,影响因子也非常多,据传Google的影响因子有100+之多。
大名鼎鼎的Lucene项目就是采用VSM模型构建的,VSM的核心公式如下(由cos夹角法演变,此处省去推导过程)

VSM模型公式

从上面的例子不难看出,如果向量的维度(对汉语来将,这个值一般在30w-45w)变大,而且文档数量(通常都是海量的)变多,那么计算一次相关性,开销是非常大的,如何解决这个问题呢?不要忘记了我们这节的主题就是 倒排索引,主角终于粉墨登场了!!!

倒排索引

倒排索引非常类似我们前面提到的Hash结构。以下内容来自维基百科:

倒排索引(英语:Inverted index),也常被称为反向索引置入档案反向档案,是一种索引方法,被用来存储在全文搜索下某个单词在一个文档或者一组文档中的存储位置的映射。它是文档检索系统中最常用的数据结构。

有两种不同的反向索引形式:

  • 一条记录的水平反向索引(或者反向档案索引)包含每个引用单词的文档的列表。
  • 一个单词的水平反向索引(或者完全反向索引)又包含每个单词在一个文档中的位置。

后者的形式提供了更多的兼容性(比如短语搜索),但是需要更多的时间和空间来创建。

由上面的定义可以知道,一个倒排索引包含一个字典的索引和所有词的列表。其中字典索引中包含了所有的Term(通俗理解为文档中的词),索引后面跟的列表则保存该词的信息(出现的文档号,甚至包含在每个文档中的位置信息)。下面我们还采用上面的方法举一个简单的例子来说明倒排索引。

例如现在我们要对三篇文档建立索引(实际应用中,文档的数量是海量的):

文档1(D1):中国移动互联网发展迅速

文档2(D2):移动互联网未来的潜力巨大

文档3(D3):中华民族是个勤劳的民族

那么文档中的词典集合为:{中国,移动,互联网,发展,迅速,未来,的,潜力,巨大,中华,民族,是,个,勤劳}

建好的索引如下图:

倒排索引

在上面的索引中,存储了两个信息,文档号和出现的次数。建立好索引以后,我们就可以开始查询了。例如现在有一个Query是”中国移动”。首先分词得到Term集合{中国,移动},查倒排索引,分别计算query和d1,d2,d3的距离。有没有发现,倒排表建立好以后,就不需要在检索整个文档库,而是直接从字典集合中找到“中国”和“移动”,然后遍历后面的列表直接计算。

对倒排索引结构我们已经有了初步的了解,但在实际应用中还有些需要解决的问题(主要是由海量数据引起的)。笔者列举一些问题,并给出相应的解决方案,抛砖以引玉,希望大家可以展开讨论:

1.左侧的索引表如何建立?怎么做才能最高效?

可能有人不假思索回答:左侧的索引当然要采取hash结构啊,这样可以快速的定位到字典项。但是这样问题又来了,hash函数如何选取呢?而且hash是有碰撞的,但是倒排表似乎又是不允许碰撞的存在的。事实上,虽然倒排表和hash异常的相思,但是两者还是有很大区别的,其实在这里我们可以采用前面提到的Bitmap的思想,每个Term(单词)对应一个位置(当然了,这里不是一个比特位),而且是一一对应的。如何能够做到呢,一般在文字处理中,有很多的编码,汉字中的GBK编码基本上就可以包含所有用到的汉字,每个汉字的GBK编码是确定的,因此一个Term的”ID”也就确定了,从而可以做到快速定位。注:得到一个汉字的GBK号是非常快的过程,可以理解为O(1)的时间复杂度。

2.如何快速的添加删除更新索引?

有经验的码农都知道,一般在系统的“做加法”的代价比“做减法”的代价要低很多,在搜索引擎中中也不例外。因此,在倒排表中,遇到要删除一个文档,其实不是真正的删除,而是将其标记删除。这样一个减法操作的代价就比较小了。

3.那么多的海量文档,如果存储呢?有么有什么备份策略呢?

当然了,一台机器是存储不下的,分布式存储是采取的。一般的备份保存3份就足够了。

好了,倒排索引终于完工了,不足的地方请指正。谢谢

 

 

 

————————————————————————————————————————————-

感谢ヅ`fzly提供

 

Matlab 把数字产生001、00n这样的字符串 | num2str用法 |sprintf用法 |int2str用法

Matlab 把数字产生001、00n这样的字符串 | num2str用法 |sprintf用法 |int2str用法

Matlab把数字转变成str,可以用num2str, sprintf, int2str等

如果想要在转变的时候控制精度,可以在num2str的第二个参数设置format. sprintf 的第一个参数设置format
sprintf:


sprintf

Format data into string
Syntax

str = sprintf(format, A, ...)
[str, errmsg] = sprintf(format, A, ...)
Description

str = sprintf(format, A, ...) applies the format to all elements of array A and any additional array arguments in column order, and returns the results to string str.

[str, errmsg] = sprintf(format, A, ...) returns an error message string when the operation is unsuccessful. Otherwise, errmsg is empty.

num2str:

num2str

Convert number to string
Syntax

str = num2str(A)
str = num2str(A, precision)
str = num2str(A, format)
Description

The num2str function converts numbers to their string representations. This function is useful for labeling and titling plots with numeric values.

str = num2str(A) converts array A into a string representation str. Converted floating-point values have a maximum of four digits of precision, and an exponent if required. For integer values, num2str returns the exact string representation of the value.

str = num2str(A, precision) converts the array A into a string representation str with the maximum number of digits specified by precision.

str = num2str(A, format) converts array A using the supplied format, as described on the fprintf function reference page. By default, num2str displays floating point values using the '%11.4g' format (four significant digits in exponential or fixed-point notation, whichever is shorter).
Remarks

Unlike fprintf, the num2str function trims any leading spaces from a string, even when used with the space character flag. For example, num2str(42.67, '% 10.2f') returns a 1-by-5 character array '42.67'.

num2str(1.33333,’%.3d’) 把整数部分格式化成3位精度 1.33e000
num2str(1.333333,’%.3f’) 把小数部分格式化成3位精度 1.333
num2str(1,’%.3d’) 如果是一个整数没有小数部分,对整数部分格式化为3位精度就变为:001