《吴恩达机器学习》5 Python/Numpy 教程（Octave/Matlab 教程）

前言

《吴恩达机器学习》是在2014年发布的（2011年录制），那个时候机器学习的编程语言用octave较多，但是现在几乎都是python的天下，几乎所有的机器学习框架都在python上有很好的实现方式，如TensorFlow，pytorch等。所谓磨刀不误砍柴工，学好python（不求精通）是很有必要的。另外值得提醒的有3点
1、以下的所有实现都是基于python3，若代码不通过请切换到python3。
2、安装python及最基本的使用请参考别的教程，这里只讨论与机器学习有关的python教程

一、python基本使用

我之前工作大部分使用的是cpp，cpp运行效率卓越但是同时开发效率也非常低。特别是现在开发接口的方式越来越拥抱调用restful接口的形式（可以查考阿里云，百度，科大讯飞的接口），而不是通过提供一种语言的SDK。我也用gunicorn+flask+gevent这种方式写过web接口，测试后发现性能非常好，一点也不比cpp用最底层的epoll这种形式差，现在我基本上能用python开发都不会用cpp。毕竟时间有限，特别是在学习新知识这款，不要纠结语言层的东西，能把算法应用上才是王道，而python非常友好，学习成本也低。

1、数据类型

python中有number（包含了整型，浮点型），字符串，这两种使用和别的高级语言没有太多区别，我主要想讨论的是python中比较特殊的数据结构——列表（list）、元组（tuple）和dict（字典）
列表（list）
序列是Python中最基本的数据结构，用中括号 [ ] 表示。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。以下是一个列表

list1 = ['Google', 'Apple', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

元组（tuple）
Python 的元组与列表类似，不同之处在于元组的元素不能修改。用小括号 ( ) 表示。

tup1 = ('Google', 'Apple', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = ("a", "b", "c", "d")

字典（dict）
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，用**花括号 { } ** 表示。

dict1 = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
dict2 = { 'abc': 123, 98.6: 37 }
print("dict1['Age'] = ", dict1['Age'])
print("dict2[98.6] = ", dict2[98.6])
# 以上代码输出
dict1['Age'] =  7
dict2[98.6] =  37

2、语法

python用四个空格区分代码结构，不像别的语言使用花括号。所以当你的代码逻辑嵌套太多就会非常乱，也有人调侃这个时候要带一把游标卡尺来量哪一行对应同个代码块，这个我猜是因为设计python的人鼓励你代码别写那么长，才这样设计的（逃~）
if语句

#!/usr/bin/python3
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")

while语句

#!/usr/bin/env python3
n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
print("1 到 %d 之和为: %d" % (n,sum))

for语句

#!/usr/bin/python3
sites = ["you", "deserve","better","!"]
for site in sites:
    print("循环数据 " + site) # print中+表示链接字符串
print("完成循环1")
for num in range(5):
	print("循环数 ", num)	# print中,可以连接后面的number
print("完成循环2")

3、切片（重要）

切片（Slice）也就是对list、tuple或者dict这种数据结构进行便捷的查询和修改方式，对于机器学习中经常操作训练数据的这种操作，切片是非常重要的，以下来看下传统的数据操作

# 传统中取前3个数据的如下
L = ['lisa', 'tom', 'jack', 'lucy', 'mike']
n = 3
for i in range(n):
	print(i)

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片操作符，能大大简化这种操作.对应上面的问题，取前3个元素，用一行代码就可以完成切片：

L = ['lisa', 'tom', 'jack', 'lucy', 'mike']
print(L[0:3])

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。如果第一个索引是0，还可以省略成L[:3]
以下是几种操作方式

L = ['lisa', 'tom', 'jack', 'lucy', 'mike']
print(L[0:3])	# 表示从索引0到索引3为止，及0, 1, 2
print(L[-2:])	# 表示从倒数第二个数到最后一个数
print(L[::2])	# 表示从所有的数中，每2个数取一个
print(L[:])		# 表示原封不动的同一个L

# 输出如下
>> ['lisa', 'tom', 'jack']
>> ['lucy', 'mike']
>> ['lisa', 'jack', 'mike']
>> ['lisa', 'tom', 'jack', 'lucy', 'mike']

4、函数及类

Python 定义函数使用 def 关键字，一般格式如下：

#!/usr/bin/python3
 
# 计算面积函数
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("machine learning")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

在Python中创建一个类和对象是很容易的，如下示

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('{}: {}'.format(self.name, self.score))
a = Student('jack', 98.5)
a.print_sore()
# 输出
>> jack: 98.5

二、numpy使用

前面是讲的都是python的数据结构和基本使用，而在机器学习下的运算都是使用numpy的（当然不同框架下也不是绝对的）。numpy使用起来也非常的方便，以下着重介绍下矩阵（多维数组）的运算

1、矩阵

numpy创建一个矩阵的方式非常方便，如下示

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])	# 创建一个2*3的矩阵
b = np.zeros((3,4))    					# 创建3*4全零二维数组
c = np.one((2,3,4))						# 创建2*3*4数值都是1的三维数组
d = np.zeros((5, 1))					# 创建5*1全零二维数组
e = np.identity(5)      				# 创建一个5*5的单位矩阵
# 输出如下
>>	[[1 2 3]
 	[4 5 6]]
>>	[[0. 0. 0. 0.]
 	[0. 0. 0. 0.]
 	[0. 0. 0. 0.]]
>>	[[[1. 1. 1. 1.]
  	[1. 1. 1. 1.]
  	[1. 1. 1. 1.]]

 	[[1. 1. 1. 1.]
  	[1. 1. 1. 1.]
  	[1. 1. 1. 1.]]]
>> 	[[0.]
 	[0.]
 	[0.]
 	[0.]
 	[0.]]
>>	[[1. 0. 0. 0. 0.]
 	[0. 1. 0. 0. 0.]
 	[0. 0. 1. 0. 0.]
 	[0. 0. 0. 1. 0.]
 	[0. 0. 0. 0. 1.]]

2、矩阵运算

矩阵的加减法运算可以直接用 + - 运算符计算，要求矩阵的维度一致，否则会报错

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.ones(a.shape)
c = a + b
d = a - b
# 输出
>> a =	[[1 2 3]
 		[4 5 6]]
>> b = 	[[1. 1. 1.]
 		[1. 1. 1.]]
>> c = 	[[2. 3. 4.]
 		[5. 6. 7.]]
>> d =	[[0. 1. 2.]
 		[3. 4. 5.]]

矩阵的乘法

import numpy as np
A = np.array([[1, 1], [2, 2]])
B = np.array([[2, 0], [3, 4]])
C = np.array([[1, 1, 1], [2, 2, 2]])
D = A * B    		# 元素点乘
E = np.dot(B, C)   	# 矩阵乘法
>>	D = [[2 0]
		 [6 8]]
>>	E = [[ 2  2  2]
 		[11 11 11]]

矩阵的转置和逆矩阵，对于方阵A，如果为非奇异方阵，则存在逆矩阵inv(A)。对于奇异矩阵或者非方阵，并不存在逆矩阵，但可以使用pinv(A)求其伪逆

import numpy as np
a = np.array([[3, 3], [2, 2]])
b = np.linalg.pinv(a)
c = np.linalg.inv(a)
d = a.T
>> b = [[0.11538462 0.07692308]
 		[0.11538462 0.07692308]]
>> c = [[ 6.00479950e+15 -9.00719925e+15]
		[-6.00479950e+15  9.00719925e+15]]
>> d = [[3 2]
	 	[3 2]]

三、基于numpy的梯度下降法实现

上面讲了python和numpy的一些使用，那么我们来实现一个梯度下降法吧，如下示

import numpy as np
import matplotlib.pyplot as plt

# 从20-30 取199个点，并把x_data转为列向量
x_data_re = np.linspace(0, 30, 200)[:, np.newaxis]
x_data = (x_data_re - x_data_re.min()) / x_data_re.max() - x_data_re.min()
# 取概率分布的均值0，标准差为1的正太分布干扰变量
noise = np.random.normal(0, 0.1, x_data.shape)
# 设图像的斜率是2, 截距是6的图像
w = 2; b = 6
y_data =x_data*w + b + noise

# 下面开始用梯度下降法来得到我们的预期值 W 和 B
# 目标方程
def h(x_data, w, b):
    return w*x_data + b
# 代价函数
def J(x_data, y_data, w, b):
    return np.mean((h(x_data, w, b) - y_data)**2)/2
# 代价函数偏导数w
def dwJ(x_data, y_data, w, b):
    return np.mean((h(x_data, w, b) - y_data)*x_data)
# 代价函数偏导数b
def dbJ(x_data, y_data, w, b):
    return np.mean(h(x_data, w, b) - y_data)
print('初始损失率是 {}'.format(J(x_data, y_data, w, b)))

# 下面开始进行迭代，lr表示学习率，n_itera表示循环次数，epailon表示当损失函数变化很小时退出的阈值
def gradient_descent(x_data, y_data, w, b, lr=1e-3, n_itera = 1e4, epailon = 1e-8):
    w_history = list()
    b_history = list()
    W = w
    B = b
    w_history.append(W)
    b_history.append(B)
    itera = 0
    while itera < n_itera:
        # 保存上次的值
        print('此时的w = {},b = {}, 循环次数 = {}, 损失值 = {}'.format(W, B, itera, J(x_data, y_data, W, B)))
        lastW = W
        lastB = B
        # 计算梯度
        gradient_w = dwJ(x_data, y_data, W, B)
        gradient_b = dbJ(x_data, y_data, W, B)
        # 梯度下降迭代
        W = W - lr*gradient_w
        B = B - lr*gradient_b
        # 保存梯度下降的值
        w_history.append(W)
        b_history.append(B)
        if abs(J(x_data, y_data, W, B) - J(x_data, y_data, lastW, lastB)) <= epailon:
            print('此时的w = {},b = {}, 循环次数 = {}, 损失值 = {}'.format(W, B, itera, J(x_data, y_data, W, B)))
            break
        itera = itera+1
    return w_history, b_history

# 开始计算，给定初始值W,B
W = 0
B = 0
W_history, B_history = gradient_descent(x_data, y_data, W, B, lr=0.1)

# 画出训练集的点和我们希望的图像
plt.plot(x_data, y_data, 'bo')
plt.plot(x_data, x_data*W_history[-1] + B_history[-1], 'r-', lw=3)
plt.show()

下面就是训练的过程及拟合的图像

总结

由于《吴恩达机器学习》系列视频 Octave/Matlab 教程 中的octave已经不适合当前的形势了，故转为python/numpy教程，以便后续学习和查阅。