机器学习实践指南

一.python基础

Nump库

1.nabarry数组基础

**6.数组运算**        加法：array([20,31,42,53])=array([20,30,40,50])+array([0,1,2,3])        乘法：array([2,0],[0,4])=array([[2,0],[4,0]])=array([[1,1],[0,1]])*array([[2,x],[4,y]])        乘方：array([0,1,2,3])的二次方=arrat([0,1,4,9])

    7.数组的拷贝        浅拷贝：通过数组变量的赋值完成，只拷贝引用，对拷贝值修改 原数据也将修改                >>>a=ones((2,3))                >>>a                array([[1.,1.,1.],                        [1.,1.,1.])                >>>b=a###b为浅拷贝                >>>b[1,2]=2                >>>a                array([[1.,1.,1.],                        [1.,1.,2.])        深拷贝：复制放在不同内存中                >>>a=ones((2,3))                >>>b = a.copy()                >>>b[1,2] = 2                >>>a                array=([[1.,1.,1.],                        [1.,1.,2.]])

2.矩阵

    1.矩阵的创建        ①        >>>A = matrix('1.0 2.0;3.0 4.0')        >>>A        [[1. 2.]         [3. 4.]]        ②        >>>B = matrix([[1.0,2.0],[3.0,4.0]])        >>>b        matrix([[1.,2.],                [3.,4.]])    type(A)    <class 'numpy.matrixlib.defmatrix>    2.矩阵运算        form numpy import *        >>>A.T   #转置        [[1. 3.]         [2. 4.]]        >>>x = matrix('5.0 7.0')         Y = X.Y        >>>Y        [[5.]         [7.]]        >>>print A*Y #矩阵的乘法        [[19.]         [43.]]        >>>print A.I #逆矩阵        [[-2. 1   ]         [1.5 -0.5]]        >>>solve(A.Y) #解线性方程组        matrix([[-3.],                [-4]])          

3.1.3 pylab matplotlib绘图

1.sin函数的绘制import numpy as npimport matplotlib.pyplot as pltx = np.arange(0,5,0.1);y = np.sin(x)plt.plot(x,y)plt.show()

2.cos函数的绘制import numpy as npimport matplotlib.pyplot as pltx = np.arange(0,5,0.1);y = np.cos(x)plt.plot(x,y)plt.show()

import numpy as npimport matplotlib.pyplot as pltx = np.arange(-8,8,1);y = np.cos(x)plt.plot(x,y)plt.show()

二.数学基础

---

微积分

**1.logistic函数逻辑斯谛（Logistic）方程,即常微分方程:  **

**2.双曲正切函数**

双曲函数类似于常见的（也叫圆函数的）三角函数。基本双曲函数是双曲正弦“sinh”，双曲余弦“cosh”，从它们导出双曲正切“tanh”等。也类似于三角函数的推导。反函数是反双曲正弦“arsinh”（也叫做“arcsinh”或“asinh”）依此类推。

import pylabimport numpy as npN = 500delta = 0.6X = -1 + 2. * np.arange(N) / (N - 1)pylab.plot(X, (1.4 + np.tanh(4. * X / delta)) / 4, 'k-', linewidth=5)pylab.show()

2.权值更新规则http://blog.csdn.net/happyer88/article/details/46772347

3.神经元梯度

---

线性代数

1.连续模型和离散模型

离散模型适合于计算机仿真。在人口离散模型中，用x 0 (t),x 1 (t),x 2 (t),…,x m (t)表示t时刻的年龄构成，其中x i (t)表示t年代年满i周岁但不到i+1周岁的人口数，写成向量形式如 下：

离散人口模型可写成

式中μ i (t)(i=0,1,…,m-1)称为按龄死亡率，m为人类能活到的最高年龄。 在这个模型中，通过矩阵的形式，将时间、出生、死亡和迁移4个因素及它们之间的定量关系进行完全描述。
2.自回归模型
一种处理时间序列的方法，用同一变量例如x的前期进行预测（即x 1 至x t-1 预测本期x t 的表现），并 假设它们为线性关系，模型中X的当期值等于若干个后期值的线性组合，加常数项，加随机误差。

其中：c是常数项；ε t 被假设为平均数等于0、标准差等于σ的随机误差值；σ被假设为对于任何的t都不变
3.SVM
非线性可分转化为在特征空间中的线性可分

式中大于0的α i 对应的x i 就是支持向量

---

3.概率论

1.古典概率

条件概率

概率公理

公理1：0≤P(A)≤1(A∈S) 公理2：P(S)=1 公理3：P(A∪B)=P(A)+P(B)，如果A∩B=0 

概率分布

二项分布、几何分布、伯努利分布、泊松分布、均匀分布、正态分布、指数分布

随机变量X的累积分布函数定义为： F(x)=P(X≤x)其中，x为任意实数 设X为连续型随机变量，其累积分布函数为F X (x)，若存在f X (x)，满足

则f X (x)是它的概率密度函数
2.马尔科夫链
随机变量X 1 ,X 2 ,X 3 ,…的一个数列，这些变量所有可能取值的集合为状态空间，X n 的值则是在时间n的状态。设X n+1 对于过去状态的条件概率分布 可定义如下：

 P(X n+1 =x|X 0 ,X 1 ,X 2 ,…，X n )=P(X n+1 =x|X n )

同理，可计算更多步的转移概率：

三.Python语言基础

1.Python基本数据类型

“字符串” [列表] 元组 set([‘1’,’2’,’3’]）字典 {‘键’：值,’键’:值}
Python是解释运行的动态语言，解释器的提示符为”>>>”
（1）数字型，可将Python作为一个计算器使用，在计算过程中可使用”+”（加）、”-“（减）、”*”（乘）、 “/”（除）、”（”、”）”以及”%”（取余）等操作符

>>> 2+2 4 >>> # 本行是注释 ... 2+8 10 >>> (50-5*6)/2 10 >>> 9%2 1

使用”=”进行赋值操作，赋值操作不会返回任何结果，也可以在同一行中连接赋值

>>> c=5.2-6.5j###复数 >>> c (5.2-6.5j) >>> c.real###实部 5.2 >>> c.imag###虚部 -6.5 >>>x = y = z = 0

复数运算使用(real+imagj)的形式，也可使用complex(real,imag)创建一个复数对象，其中real表示实部，imag表示虚 部。

 >>> 2+6J     (2+6j)     >>> 2-6J     (2-6j)    (-1+0j)    >>> 3+1j*3    (3+3j) >>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5

变量”_”表示刚计算的结果

>>> 3+2 5 >>> _*6 30

（2）字符串型 “” ”包围表示 print输出
*Unicode编码（国际组织制定的容纳世界所有文字和符号的字符编码方案，用0～0x10FFFF映射字符，最多可以 容纳1114112个字符），在前面加u表示后面是Unicode字符串。下面的代码演示了Unicode字符的定义与使用、字 符串的输出等操作。
*

>>> 'spam eggs' 'spam eggs' >>> '"Yes," he said.' '"Yes," he said.' >>> print u"你好"你好>>> print u"机器学习"机器学习

Python的字符串可视为列表（数组），使用“[索引]”的方式能对它进行切片操作（索引从0开始），使用”+”可对 字符串进行连接。

>>> word = 'Help' + 'A' >>> word 'HelpA' >>> '<' + word*5 + '>''<HelpAHelpAHelpAHelpAHelpA>' >>> word[-2:]    #最后2个字符 'pA' >>> word[:-2]    #除去最后2个字符以外的字符    'Hel'

Python的字符串可使用转义字符，方法是在特殊字符前加上”\”。主要的转义字符有：

\'　单引号 \"　双引号 \a　发出系统响铃声 \b　退格符 \n　换行符 \t　横向制表符 \v　纵向制表符 \r　回车符 \f　换页符 \\　\ \o　八进制数代表的字符\x　十六进制数代表的字符 \000　终止符，\000后的字符串全部忽略 

用3个引号标示字符串，其功能是将字符串内 容原样输出，如果字符串本身包括换行，则输出换行，如果包括特殊字符，则字符串无需使用转义字符。

>>> 'doesn\'t' "doesn't" >>> "\"Yes,\" he said." '"Yes," he said.' >>> print u"你好,Python\n机器学习" 你好,Python机器学习>>> print u"""你好,Python ... 机器学习""" 你好,Python机器学习>>> mystr=  u"你好,Python\n机器学习" >>> print mystr 你好,Python机器学习>>> print mystr[:5] 你好,Py >>> print mystr[3:5] Py >>> len(mystr)###len函数计算字符串长度 14

Python字符串的三引号表示方式意义重大，用它可以在CGI（CGI允许Web服务器执行外部程序，并将它们的输 出发送给Web浏览器）程序中轻松输出HTML代码。

#!/usr/bin/env python print "Content-Type: text/html" print print """<html> <body> <h2>Hello World!</h2></body> </html> """

3.列表 [ ]包围
+可以链接列表

>>> a = ['hello', 'world', 100, 1234] >>> a ['hello', 'world', 100, 1234] >>> a[:2] + ['-', 2*2]###连接列表 ['hello', 'world', '-', 4] >>> mylist=[1,23,45] >>> mylist [1, 23, 45] >>> mylist*2###重复填充列表 [1, 23, 45, 1, 23, 45] >>> mylist[:2]###列表切片 [1, 23] >>> x = [12, 13] >>> y = [11, x, 14] >>> len(y)###求列表长度 3 >>> y[1] [12, 13] >>> x[1][0] 12

3.range函数 产生符合某种要求的列表等序列

>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range函数还可以产生更复杂的序列，
range(起始值（可省略），元素数量呢，步长（可省略，默认1）)

>>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70]

是range函数与for语句组合

>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): ...     print i, a[i] ...0 Mary 1 had 2 a 3 little 4 lamb

元组 类似列表 但不能修改

>>> x = 10, 20, 'learn' >>> x[0] 10>>> x[0]=90 Traceback (most recent call last):  File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment 

Sets集合
无重复 无先后 不能索引
set函数直接将列表转化为集合（去重）

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana'] >>> fruit = set(basket)>>> fruit set(['orange', 'pear', 'apple', 'banana'])

in 检测成员与集合的关系

>>> 'orange' in fruit ###集合类是否有成员 'orange' True >>> 'crabgrass' in fruit###集合类是否有成员'crabgrass' False

集合支持union（联合或并）、intersection（交）、 difference（差）和sysmmetric difference（对称差）等操作，可通过”-“、”|”、”&”、”^”操作符计算集合的差集、并 集、交集和对称差集

>>> a = set('abracadabra') >>> b = set('alacazam') >>> a set(['a', 'r', 'b', 'c', 'd']) >>> a - b                              #差集 set(['r', 'd', 'b']) >>> a | b                              # 并集 set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l']) >>> a & b                              # 交集 set(['a', 'c']) >>> a ^ b                              # 对称差集 set(['r', 'd', 'b', 'm', 'z', 'l'])

字典 {‘键’：值,’键’:值}
字典由若干个键值 对组成，键值对是一种映射，一个键对应于一个值。
键值一一对应 字典以键对值进行管理
用del操作删除键值对，使 用keys()方法返回字典变量存储的所有键

>>> tel = {'张三': 4098, '李四': 4139} >>> tel {'\xd5\xc5\xc8\xfd': 4098, '\xc0\xee\xcb\xc4': 4139} >>> tel['张三'] 4098 >>> del tel['张三']>>> tel['张三'] Traceback (most recent call last):  File "<stdin>", line 1, in <module> KeyError: '\xd5\xc5\xc8\xfd' >>> tel.keys() ['\xc0\xee\xcb\xc4'] >>> tel['王华']=1000 >>> tel.keys() ['\xcd\xf5\xbb\xaa', '\xc0\xee\xcb\xc4'] >>> print tel.keys()[0]王华

“\xcd”等为汉字在Python内部的编码。

python 类

class 类名:     #类成员变量      变量B=B初始值     #下面定义了类成员函数    def _init_(self, 参数1，参数2，...,参数n):        #类构造函数  ......      def _del_(self):         # 析构函数             ......      def 方法1(self,参数1，参数2，...,参数n):    #类的方法          ......     ......

复数类Complex，同时定义了类的实例变量x，最后输出该变量的实部和虚部。Complex类 很简单，在类构造函数中对实部成员和虚部成员进行赋值。

>>> class Complex: ...    r=0 ...    i=0...    def _init_(self, realpart, imagpart): ...       self.r = realpart ...       self.i = imagpart >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)

python异常处理

在Python中，异常是对象，可对它进行操作。所有异常都 是基类Exception的成员，从基类Exception继承，在exceptions模块中定义

try :          #下面为可能发生异常的语句块          ...... except 异常类型:          #下面为处理异常的语句块         ......

下面的代码将检查输入是否为有效数字。程序通过将输入转换成整型来测试是否为数字，如果不是数字，int函 数将触发异常ValueError

>>> while True: ...     try:...         x = int(raw_input("Please enter a number: ")) ...         break ...     except ValueError: ...         print "Oops!  That was no valid number.  Try again..." 

，Python还能主动触发异常，处理方式为：先通过raise语句抛出异常，然后用except 捕捉异常
演示raise主动抛出NameError异常后被捕捉，输出”An exception flew by!”后，继续抛出异 常，以便给更外层的异常处理函数继续处理。

>>> try: ...     raise NameError('HiThere') ... except NameError:...     print 'An exception flew by!' ...     raise ... An exception flew by! Traceback (most recent call last):  File "<stdin>", line 2, in ? NameError: HiThere

open cv 图像处理基础

分辨率是度量图像内数据量多少的一个参数，通常表示成每英寸像素数和每英寸点数。分辨率越高，图像包含的数据越多，就越能表现更丰富的细节，图形文件就
越大。从图4-7能较直观地看出这个效果，随着分辨率的增加，字母R越来越清晰

像素800*600的图片，每一行有800个像素点 共600行 用一个800列600行的数组来表示该图像
OpenCV图像矩阵中每个像素点的值由蓝色值、绿色值、红色值3个部分组成
假设A图像的高度（行数）为H，宽度（列数）为W，则H*W*3表示
.
读取img_a图像150行20列处的像素值

img_a[150,20,:]

*第1行是150行20列处像素的蓝色值，第2行是150行20列处像素的绿色值，第3行是150行20列处像素的红色值。
*
.

blue=img_a[150,20,0]green=img_a[150,20,1]red=img_a[150,20,2]

(1)显示图像

• imread(文件名)读取图像文件，生成图像矩阵
• imshow方法显示图像
• waitKey()方法等待按键
• destroyAllWindows()销毁窗口
-

import cv2fn="coco.jpg"img = cv2.imread(fn)cv2.imshow('preview', img) #preview预先看cv2.waitKey()cv2.destroyAllWindows()

（2）随机生成像素

首先产生空图像矩阵，然后确定矩阵的2000个随机位置，最后将随机位置处的像素值设置为随机数数组

import numpy as npimport cv2#行数sz1 = 200#列数sz2 = 300#产生空图像矩阵,大小为sz1*sz2(行数*列数)，本程序为200*300img =np.zeros((sz1, sz2,3), np.uint8)#unit8:无符号整形#np.zeros:返回来一个给定形状和类型的用0填充的数组；pos1=np.random.randint(200,size=(2000, 1))###行位置随机数组pos2=np.random.randint(300,size=(2000, 1))###列位置随机数组#在随机位置处设置像素点值for i in range(2000):     img[pos1[i],pos2[i],[0]]=np.random.randint(0,255)#蓝     #pos1-> 在1位置处     img[pos1[i],pos2[i],[1]]=np.random.randint(0,255)#黄     img[pos1[i],pos2[i],[2]]=np.random.randint(0,255)#红#显示图像cv2.imshow('preview', img) #preview 窗口的名字#等待按键cv2.waitKey()#销毁窗口cv2.destroyAllWindows()

random.randint　　random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= bprint random.randint(12,20)  #生成的随机数n: 12 <= n <= 20  print random.randint(20,20)  #结果永远是20  #print random.randint(20, 10)   #该语句是错误的。下限必须小于上限

（3）获取图像大小
程序通过图像矩阵的shape属性获取图像大小，shape返回tuple元组，元组的第1个元素为高度，第2个元素为宽度，第3个元素为3（像素值由三
原色组成）

import numpy as npimport cv2fn="2.jpg"if __name__ == '__main__':     #http://blog.konghy.cn/2017/04/24/python-entry-program/     #相当于是 Python 模拟的程序入口     # 如果模块是被直接运行的，则代码块被运行，     # #如果模块是被导入的，则代码块不被运行。     print ('loading %s ...' % fn)     img = cv2.imread(fn)     #获取图像矩阵大小     sp=img.shape     print (sp)     #高度，即行数     sz1=sp[0]     #宽度，即列数     sz2=sp[1]     print ('width:%d\nheight:%d'%(sz2,sz1))

调节图像亮度。调节的原理是，将像素值变小，则将亮度调小，全部色彩变暗；

import cv2import numpy as npfn="2.jpg"if __name__ == '__main__':     print ('loading %s ...' % fn)     print (u'正在处理中',)     img = cv2.imread(fn)     w=img.shape[1]#计算行数     h=img.shape[0]#计算列数     ii=0     #将全部色彩变暗     for xi in range (0,w):          for xj in range (0,h):     #将像素值整体减少，设为原像素值的20%               img[xj,xi,0]= int(img[xj,xi,0]*0.2)               img[xj,xi,1]= int(img[xj,xi,1]*0.2)               img[xj,xi,2]= int(img[xj,xi,2]*0.2)     #显示进度条          if xi%10==0 :print ('.',)     cv2.namedWindow('img')     cv2.imshow('img', img)     cv2.waitKey()     cv2.destroyAllWindows()

4-5调色

for xi in xrange(0,w):for xj in xrange (0,h):img[xj,xi,0]= int(img[xj,xi,0]*0.7)###蓝色值为原来的70%img[xj,xi,1]= int(img[xj,xi,1]*0.7)###绿色值为原来的70%

import cv2import numpy as npfn="2.jpg"if __name__ == '__main__':     print ('loading %s ...' % fn)     print (u'正在处理中'),     img = cv2.imread(fn)     w=img.shape[1]     h=img.shape[0]     ii=0     for xi in range(0,w):          for xj in range (0,h):               img[xj,xi,0]= int(img[xj,xi,0]*0.7)###蓝色值为原来的70%               img[xj,xi,1]= int(img[xj,xi,1]*0.7)###绿色值为原来的70%#显示进度条if xi%10==0 :print ('.'),#显示图像cv2.namedWindow('img')cv2.imshow('img', img)cv2.waitKey()cv2.destroyAllWindows()

（6）负片与水印效果
生成负片的原理是，将像素的三色值设为（255-原值）

#生成负片b, g, r = cv2.split(img)b=255-bg=255-gr=255-r

水印效果的原理是，调用putText函数，以图像矩阵为第1个参数，输出内容为第2个参数，在图像上直接输出水印文字

cv2.putText(img,"machine learning", (20,20),cv2.FONT_HERSHEY_PLAIN, 2.0, (0, 0, 0), thickness = 2)cv2.putText(img,"Support Vector Machines(SVMs)is an algorithmof machine learning.", (20,100),cv2.FONT_HERSHEY_PLAIN, 1.0, (0, 0, 0), thickness = 2)

（7）图像平铺
图像平铺的原理是，首先计算平铺后的图像大小，生成同样大小的空白图像，然后在空白图像中逐个像素复制图像，直接将空白图像像素值设置为
平铺后该位置对应的像素值，复制的顺序是逐行复制，横向平铺5个图像，纵向平铺2个图像，最后显示图像效果。

import cv2import numpy as npfn="1.png"if __name__ == '__main__':     print ('loading %s ...' % fn)     print ('正在处理中'),     img = cv2.imread(fn)     w=img.shape[1]     h=img.shape[0]     #    横向平铺5个图像     sz1=w*5     #纵向平铺2个图像     sz0=h*2     #创建空白图像，然后将图片排列     myimg1=np.zeros((sz0,sz1,3), np.uint8)     #逐个像素复制     img_x=0     img_y=0     for now_y in range(0,sz0):     #增加行数          for now_x in range(0,sz1):          #复制对应位置的图像像素点               myimg1[now_y,now_x,0]=img[img_y,img_x,0]               myimg1[now_y,now_x,1]=img[img_y,img_x,1]               myimg1[now_y,now_x,2]=img[img_y,img_x,2]               #增加列数               img_x+=1               if img_x>=w:                    img_x=0          img_y+=1          if img_y>=h:               img_y=0          print ('.'),     cv2.namedWindow('img1')     cv2.imshow('img1', myimg1)     cv2.waitKey()     cv2.destroyAllWindows()

（8）旋转并平铺图像
与刚才的例子相似，但多了一步旋转操作。旋转的原理是将图像矩阵转换为它的转置矩阵，旋转算法是将新图像矩阵[h,w]处的像素设为原图
像矩阵[w,h]处的值（这里的值是一维矩阵），相当于矩阵转置的算法

for now_y in xrange(0,sz0):    for now_x in xrange(0,sz1):        myimg1[now_x,now_y,:]=img[img_y,img_x,:]

import cv2import numpy as npfn="1.png"if __name__ == '__main__':     print ('loading %s ...' % fn)     print ('working'),     img = cv2.imread(fn)     w=img.shape[1]     h=img.shape[0]     #w为宽度，h为高度     sz1=w*2     sz0=h*3     #创建空白图像，然后将图片排列     myimg1=np.zeros((sz1,sz0,3), np.uint8)     #翻转并生成图像     #逐个复制像素     img_x=0     img_y=0     for now_y in range(0,sz0):          for now_x in range(0,sz1):               #旋转图像               myimg1[now_x,now_y,:]=img[img_y,img_x,:]               img_x+=1               #新的一次平铺               if img_x>=w:                    img_x=0          img_y+=1          #新的一次平铺          if img_y>=h:               img_y=0          print ('.'),     cv2.namedWindow('img1')     cv2.imshow('img1', myimg1)     cv2.waitKey()     cv2.destroyAllWindows()

4.1.5　图像融合与图像镜像

1.图像融合
将两个图像的像素值取50%后相加。为
简化计算，直接选取其中一个源图像作为新图像，设新图像矩阵为myimg2

#每个像素为2个像素的平均值for y in xrange(0,sz0):for x in xrange(0,sz1):myimg2[y,x,:]=myimg1[y,x,:]*0.5+myimg2[y,x,:]*0.5

import cv2import numpy as npfn1="2.jpg"fn2="1.jpg"if __name__ == '__main__':     print ('working'),     myimg1 = cv2.imread(fn1)     myimg2 = cv2.imread(fn2)     #取得图像大小     w=myimg1.shape[1]     h=myimg1.shape[0]     sz1=w     sz0=h     #每个像素为2个像素的平均值之和，进行图像融合     for y in range(0,sz0):          for x in range(0,sz1):               myimg2[y,x,:]=myimg1[y,x,:]*0.5+myimg2[y,x,:]*0.5               print ('.'),     cv2.namedWindow('img2')     cv2.imshow('img2', myimg2)     cv2.waitKey()     cv2.destroyAllWindows()

2.图像镜像
*首先获取图像的宽度，将宽度的50%取整后作为图像的纵向中线；然后以中线为轴，将图像左边反向复
制到图像右边，使图像最右边一列的像素点等于图像最左边一列的像素点。比如，图像大小为200×300（高200，宽300），第180
行170列（索引为[180,170,:]）的像素点值为第180行第130列的像素点值（300-170=130）*

#纵向生成镜像mirror_w=w/2for j in xrange(0,h):for i in xrange(0,mirror_w):img[j,i,:]=img[j,w-i-1,:]

2.图像镜像
*先获取图像的宽度，将宽度的50%取整后作为图像的纵向中线；然后以中线为轴，将图像左边反向复
制到图像右边，使图像最右边一列的像素点等于图像最左边一列的像素点。比如，图像大小为200×300（高200，宽300），第180
行170列（索引为[180,170,:]）的像素点值为第180行第130列的像素点值（300-170=130）*

mirror_w=w/2for j in xrange(0,h):for i in xrange(0,mirror_w):img[j,i,:]=img[j,w-i-1,:]

import cv2import numpy as npfn="2.jpg"if __name__ == '__main__':     print('loading %s ...' % fn)     print('正在处理中'),     img = cv2.imread(fn)     w=img.shape[1]     h=img.shape[0]     ii=0     #纵向生成镜像     mirror_w=int(w/2)     for j in range(0,h):          for i in range (0, mirror_w):               img[j,i,:]=img[j,w-i-1,:]               print ('.')     cv2.namedWindow('img')     cv2.imshow('img', img)     cv2.waitKey()     cv2.destroyAllWindows()

4.1.6　图像灰度化与图像加噪

图像灰度化的原理是，彩色图像中的每个像素的颜色由R、G、B三个分量决定，而每个分量的取值范围为0～255。而灰度图像是R、G、B三个分量
相同的一种特殊的彩色图像，其算法有以下两种：
（1）求出每个像素点的R、G、B三个分量的平均值，然后将这个平均值赋予给这个像素的三个分量。
（2）根据RGB和YUV颜色空间的变化关系，建立亮度Y与R、G、B三个颜色分量的对应关系：Y=0.3R+0.59G+0.11B，以这个亮度值表达图像的灰
度值。
OpenCV有相关的函数cvtColor，用它可直接完成灰度化操作。设img为源图像矩阵，myimg1为灰度化后的目标图像矩阵，编写代码如下：

import cv2import numpy as npfn ="1.jpg"if __name__=='__main__':     print ('loading %s...'%fn)     img = cv2.imread(fn)     sp = img.shape     print (sp)     #获取图像大小     #height     sz1=sp[0]     #width     sz2 = sp[1]     #显示图像大小     print ('width:%d\nheight:%d'%(sz2,sz1))     #创建窗口显示图像     cv2.namedWindow('img')     cv2.imshow('1',img)     #复制图像     myimg2 = img.copy();     cv2.namedWindow('myimg2')     cv2.imshow('myimg2',myimg2)     #复制 转化为灰度图像     mying1 = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)     cv2.namedWindow('mying1')     cv2.imshow('mying1',mying1)     cv2.waitKey()     cv2.destroyAllWindows()

2.图像加噪
给图像人为加噪的原理是，将图像若干个像素点的值设为噪声点的值。比如，为图像加上很多像素值为[25,20,20]的像素点

for k in range(0,coutn):xi = int(np.random.uniform(0,img.shape[1]))xj = int(np.random.uniform(0,img.shape[0]))if img.ndim == 2:#灰度图像img[xj,xi] = 255elif img.ndim == 3:#非灰度图像,图像加噪img[xj,xi,0]= 25img[xj,xi,1]= 20img[xj,xi,2]= 20

import cv2import numpy as npfn = "2.jpg"if __name__ == '__main__':     # 加载图像     print('loading ...')     img = cv2.imread(fn)     # 噪点数量     coutn = 10000     for k in range(0, coutn):          print(k)          # 获取图像噪点的随机位置          xi = int(np.random.uniform(0, img.shape[1]))          xj = int(np.random.uniform(0, img.shape[0]))          # 图像加噪          if img.ndim == 2:  # 判断是否为二维数组               img[xj, xi] = 255          elif img.ndim == 3:  # 判断是否为三位数组               img[xj, xi, 0] = 25               img[xj, xi, 1] = 20               img[xj, xi, 2] = 20          cv2.namedWindow('img')          cv2.imshow('img', img)     cv2.waitKey()     cv2.destroyAllWindows()