机器学习实践指南

一.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])

source ./py3venv/bin/activate
    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 np
import matplotlib.pyplot as plt

x = np.arange(0,5,0.1);
y = np.sin(x)
plt.plot(x,y)
plt.show()

2.cos函数的绘制
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0,5,0.1);
y = np.cos(x)
plt.plot(x,y)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = 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 pylab
import numpy as np

N = 500
delta = 0.6
X = -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 cv2
fn="coco.jpg"


img = cv2.imread(fn)
cv2.imshow('preview', img) #preview预先看
cv2.waitKey()
cv2.destroyAllWindows()

（2）随机生成像素

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

import numpy as np
import cv2

#行数
sz1 = 200
#列数
sz2 = 300

#产生空图像矩阵,大小为sz1*sz2(行数*列数)，本程序为200*300
img =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 <= b

print 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 np
import cv2
fn="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 cv2
import numpy as np
fn="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 cv2
import numpy as np
fn="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-b
g=255-g
r=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 algorithm
of machine learning.", (20,100),cv2.FONT_HERSHEY_PLAIN, 1.0, (0, 0, 0), thickness = 2)

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

import cv2
import numpy as np
fn="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 cv2
import numpy as np
fn="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 cv2
import numpy as np
fn1="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/2
for 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/2
for j in xrange(0,h):
for i in xrange(0,mirror_w):
img[j,i,:]=img[j,w-i-1,:]

import cv2
import numpy as np
fn="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 cv2
import numpy as np

fn ="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] = 255
elif img.ndim == 3:
#非灰度图像,图像加噪
img[xj,xi,0]= 25
img[xj,xi,1]= 20
img[xj,xi,2]= 20

import cv2
import numpy as np

fn = "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()