机器学习笔记

开发环境为python

pickle

python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
pickle.dump(obj, file, [,protocol])
注解：将对象obj保存到文件file中去。
protocol为序列化使用的协议版本，0：ASCII协议，所序列化的对象使用可打印的ASCII码表示；1：老式的二进制协议；2：2.3版本引入的新二进制协议，较以前的更高效。其中协议0和1兼容老版本的python。protocol默认值为0。
file：对象保存到的类文件对象。file必须有write()接口， file可以是一个以’w’方式打开的文件或者一个StringIO对象或者其他任何实现write()接口的对象。如果protocol>=1，文件对象需要是二进制模式打开的。

pickle.load(file)
注解：从file中读取一个字符串，并将它重构为原来的python对象。

reshape

numpy.reshape(a, newshape, order=’C’)[source]
不改变数据的情况下给矩阵重新排列
a : 输入矩阵
newshape : 整数或者整数tuple
新shape下不改变数据量大小，如果是整数，就重新组成一个一维向量，如果是tuple，维数可以用-1表示自动判断该数据量下另一维度的大小
order : {‘C’, ‘F’, ‘A’}, 可选参数，使用指定索引顺序读取元素‘C’意味着 按C语言的方式（行存储）,’F’表示按fortan语言的方式（列存储），‘A’ 表示按元素原来的方式.

>>> a = np.arange(6).reshape((3, 2))>>> aarray([[0, 1],       [2, 3],       [4, 5]])>> np.reshape(a, (2, 3)) # C-like index orderingarray([[0, 1, 2],       [3, 4, 5]])#按行读 0 1 2 3 4 5，按行存成2行3列>>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshapearray([[0, 1, 2],       [3, 4, 5]])>>> np.reshape(a, (2, 3), order='F') # Fortran-like index orderingarray([[0, 4, 3],       [2, 1, 5]])#按列读0 2 4 1 3 5 按列存 02 41 35>>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')array([[0, 4, 3],       [2, 1, 5]])

MATLAB

>> mat = [1:12]mat =     1     2     3     4     5     6     7     8     9    10    11    12>> reshape(mat,[3,4])ans =     1     4     7    10     2     5     8    11     3     6     9    12

PYTHON

mat = np.arange(1,13)matarray([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])r = np.reshape(mat,(3,4))array([[ 1,  2,  3,  4],       [ 5,  6,  7,  8],       [ 9, 10, 11, 12]])r.shape(3, 4)

PYTHON修正代码

r = np.reshape(mat, (3,4), order="F")rarray([[ 1,  4,  7, 10],       [ 2,  5,  8, 11],       [ 3,  6,  9, 12]])

解释

需要在python程序中指明使用Fortran order, 如

np.reshape(matrix, (n,n), order="F")

Numpy默认是C order(按行存储) Matlab是 Fortran order（按列存储）.
注意：通过reshape生成的新数组和原始数组公用一个内存，也就是说，假如更改一个数组的元素，另一个数组也将发生改变

numpy.transpose

numpy.transpose()是对矩阵按照所需的要求的转置

import numpy as np  a = np.array(range(30)).reshape(2, 3, 5)  print ("a = ")  print (a)  print "\n=====================\n"  print ("a.transpose() = ")  print (a.transpose(1, 0, 2))</span>  输出：[python] view plain copy<span style="font-family:KaiTi_GB2312;font-size:18px;">a =   [[[ 0  1  2  3  4]    [ 5  6  7  8  9]    [10 11 12 13 14]]   [[15 16 17 18 19]    [20 21 22 23 24]    [25 26 27 28 29]]]  

a.transpose() =   [[[ 0  1  2  3  4]    [15 16 17 18 19]]   [[ 5  6  7  8  9]    [20 21 22 23 24]]   [[10 11 12 13 14]    [25 26 27 28 29]]]

transpose()中的参数的意义,因为数组a的shape为（2,3,5），是一个三维数组，那么这个元组对应的索引为：（0,1,2），通过b = a.transpose(1, 0, 2)，那么b.shape就变成(3， 2， 5)，这就是说transpose就是改变高维数组的形状，形状改变了，那么里面的元素自然也要重新排列

join os.path.join

Python中有join和os.path.join()两个函数，具体作用如下：
join：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
os.path.join()： 将多个路径组合后返回
一、函数说明
1.join（）函数
语法：‘sep’.join（seq）
参数说明：
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典等
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
2、os.path.join()函数
语法： os.path.join(path1[,path2[,……]])
返回值：将多个路径组合后返回
注：第一个绝对路径之前的参数将被忽略

numpy.concatenate()

numpy提供了numpy.concatenate((a1,a2,…), axis=0)函数。能够一次完成多个数组的拼接。其中a1,a2,…是数组类型的参数

>>> a=np.array([1,2,3])>>> b=np.array([11,22,33])>>> c=np.array([44,55,66])>>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写

array([ 1, 2, 3, 11, 22, 33, 44, 55, 66]) #对于一维数组拼接，axis的值不影响最后的结果

>>> a=np.array([[1,2,3],[4,5,6]])>>> b=np.array([[11,21,31],[7,8,9]])>>> np.concatenate((a,b),axis=0)array([[ 1,  2,  3],       [ 4,  5,  6],       [11, 21, 31],       [ 7,  8,  9]])>>> np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接array([[ 1,  2,  3, 11, 21, 31],       [ 4,  5,  6,  7,  8,  9]])

对numpy.append()和numpy.concatenate()两个函数的运行时间进行比较

>>> from time import clock as now>>> a=np.arange(9999)>>> b=np.arange(9999)>>> time1=now()>>> c=np.append(a,b)>>> time2=now()>>> print time2-time128.2316728446>>> a=np.arange(9999)>>> b=np.arange(9999)>>> time1=now()>>> c=np.concatenate((a,b),axis=0)>>> time2=now()>>> print time2-time120.3934997107

可知，concatenate()效率更高，适合大规模的数据拼接

strip

strip()函数

函数原型
声明：s为字符串，rm为要删除的字符序列
s.strip(rm) :删除s字符串中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm) :删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm) :删除s字符串中结尾处，位于 rm删除序列的字符

现在来分析s.strip(rm)这个函数。

现在假设s=‘abcd’
则 s.strip(‘bd’)————->’abc’ 而s.strip(‘ba’)和s.strip(‘ab’)的结果是一样的，都是’cd’ 而s.strip(‘bd’)得到的结果是’abc’,s.strip(‘bac’)———->’d’
注意是首尾字符的检查！因为’bd’只有一个尾部符合，所以删除’d’而’b’在中间。

enumerate

enumerate()是python的内置函数
enumerate在字典上是枚举、列举的意思
对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
enumerate多用于在for循环中得到计数
如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：

list1 = ["这", "是", "一个", "测试"]for i in range (len(list1)):    print i ,list1[i]

上述方法有些累赘，利用enumerate()会更加直接和优美：

list1 = ["这", "是", "一个", "测试"]for index, item in enumerate(list1):    print index, item>>>0 这1 是2 一个3 测试

enumerate还可以接收第二个参数，用于指定索引起始值，如：

list1 = ["这", "是", "一个", "测试"]for index, item in enumerate(list1, 1):    print index, item>>>1 这2 是3 一个4 测试

os.listdir

os.listdir(dirname)：列出dirname下的目录和文件

os.getcwd()：获得当前工作目录

os.curdir:返回当前目录（’.’)

os.chdir(dirname):改变工作目录到dirname

os.path.isdir(name):判断name是不是一个目录，name不是目录就返回false

os.path.isfile(name):判断name是不是一个文件，不存在name也返回false

os.path.exists(name):判断是否存在文件或目录name

os.path.getsize(name):获得文件大小，如果name是目录返回0

os.path.abspath(name):获得绝对路径

os.path.normpath(path):规范path字符串形式

os.path.split(name):分割文件名与目录（事实上，如果你完全使用目录，它也会将最后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在）

os.path.splitext():分离文件名与扩展名

os.path.join(path,name):连接目录与文件名或目录

os.path.basename(path):返回文件名

os.path.dirname(path):返回文件路径

numpy.flatnonzero

numpy.flatnonzero(a)[source]
Return indices that are non-zero in the flattened version of a.
将array平铺展开拉长后输出非零值得索引
等价于 a.ravel().nonzero()[0].

输入输出都是ndarray
区别：nonzero返回输入array的非零值
ravel
返回一个 1-D 输入信号的array
抽取非零值

x = np.arange(-2, 3) xarray([-2, -1,  0,  1,  2])np.flatnonzero(x)array([0, 1, 3, 4]) 

>>> x.ravel()[np.flatnonzero(x)]array([-2, -1,  1,  2])

numpy.random.choice

numpy.random.choice(a, size=None, replace=True, p=None)
从给定的 1-D array中随机生成一个指定长度的样本
a : 1-D array或者整数
如果是一维向量，那么随机样本从这些向量元素中产生，如果是整数，则元素取自np.arange(n)
size : 整数或者整数的tuple ，参数可选（也可以不指定）
replace : 样本是否可重复
p : 1-D array-like, 可选参数（指定元素被选中的概率）未给定则表示参数选择概率服从均匀分布

>>> np.random.choice(5, 3)array([0, 3, 4])>>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])array([3, 3, 0])>>> np.random.choice(5, 3, replace=False)array([3,1,0])>>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])array([2, 3, 0])>>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']>>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'],

Numpy.zeros

用法：zeros(shape, dtype=float, order=’C’)
返回：返回来一个给定形状和类型的用0填充的数组；
参数：shape:形状
dtype:数据类型，可选参数，默认numpy.float64
dtype类型：t ,位域,如t4代表4位
b,布尔值，true or false
i,整数,如i8(64位）
u,无符号整数，u8(64位）
f,浮点数，f8（64位）
c,浮点负数，
o,对象，
s,a，字符串，s24
u,unicode,u24
order:可选参数，c代表与c语言类似，行优先；F代表列优先

numpy.linalg.norm

顾名思义，linalg=linear+algebra，norm则表示范数，首先需要注意的是范数是对向量（或者矩阵）的度量，是一个标量（scalar）：
norm(x, ord=None, axis=None, keepdims=False)
x表示要度量的向量，ord表示范数的种类，
默认 二范数：
ord=2 二范数：
ord=1 一范数：ℓ1 |x1|+|x2|+…+|xn|
ord=np.inf 无穷范数： max(|x_i|)

numpy中的 dot, outer and *

import numpy as npa = [[1,2,3],[4,5,6]]a = np.array(a)b = [[1,2],[4,5],[3,6]]b= np.array(b)#一个（2，3）， 一个（3，2），是可以正常的矩阵相乘的c = np.dot(a, b)print c-->result: array([[18, 30],              [42, 69]])

说明dot是正常的矩阵相乘的方法

c = a * b-->result: error 不能相乘

注意：这里用的是array不是matrix, 如果定义为matrix则＊ 表示矩阵乘，是OK的。

c = np.outer(a,b)-->result:array([[ 1,  2,  4,  5,  3,  6],       [ 2,  4,  8, 10,  6, 12],       [ 3,  6, 12, 15,  9, 18],       [ 4,  8, 16, 20, 12, 24],       [ 5, 10, 20, 25, 15, 30],       [ 6, 12, 24, 30, 18, 36]])

说明outer是a的第一个元素跟b的每一个元素相乘作为第一行，第二个元素跟b的每一个元素相乘作为第二个元素…
一半outer()用的很少

下面试试＊的具体作用：

d = np.array([[1,2,1],[2,3,1]])c = a*dresult:array([[ 1,  4,  3],       [ 8, 15,  6]])

*来说只能是shape一样的才能相乘，与其他shape的矩阵相乘（＊）都会报错，
结果是对应元素相乘作为当前位置的结果，结果矩阵的形状保持不变

numpy.argsort

numpy.argsort(a, axis=-1, kind=’quicksort’, order=None)
返回排序后的索引
参数:
a : array_like 待排序
axis :整数，默认-1，按最后一个轴排序
kind : {‘quicksort’, ‘mergesort’, ‘heapsort’},可选参数，指定排序算法
order : str or list of str, 可选参数
返回值:
index_array : ndarray, int
索引的Array，依据这个array可以对其他同样size的array_like 进行相同排序

#One dimensional array:>>>>>> x = np.array([3, 1, 2])>>> np.argsort(x)array([1, 2, 0])#Two-dimensional array:>>>>>> x = np.array([[0, 3], [2, 2]])>>> xarray([[0, 3],       [2, 2]])>>>>>> np.argsort(x, axis=0)array([[0, 1],       [1, 0]])>>>>>> np.argsort(x, axis=1)array([[0, 1],       [0, 1]])#Sorting with keys:>>>>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])>>> xarray([(1, 0), (0, 1)],      dtype=[('x', '<i4'), ('y', '<i4')])>>>>>> np.argsort(x, order=('x','y'))array([1, 0])>>>>>> np.argsort(x, order=('y','x'))array([0, 1])

numpy.bincount

numpy.bincount(x, weights=None, minlength=None)
计算每个非负值发生频数
bins的数量为x中最大值的数量加1. 如果指定了参数 minlength那么输出array中至少有x中最大值+1个数，输出array的每个值都展示了x中这个索引值下值发生的数量，如果给出了weighted，那么如果a value n is found at position i, out[n] += weight[i] 而不是out[n] += 1.

x : array_like, 1 dimension, nonnegative ints
Input array.
weights : array_like, optional
Weights, array of the same shape as x.
minlength : int, optional
A minimum number of bins for the output array.

Returns:
out : ndarray of ints
The result of binning the input array. The length of out is equal to np.amax(x)+1.
简单的说，记录的x中值的频数，频数值存储在输出对应索引位置上，举个例子

>>> np.bincount(np.arange(5))#输入 0 1 2 3 4 array([1, 1, 1, 1, 1])#每个索引值下都是一个>>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))array([1, 3, 1, 1, 0, 0, 0, 1])#0出现一次 1出现三次 2 出现一次 3出现一次 4无 5 无 6 无 7一次>>>>>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])>>> np.bincount(x).size == np.amax(x)+1True>>>>>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights>>> x = np.array([0, 1, 1, 2, 2, 2])>>> np.bincount(x,  weights=w)array([ 0.3,  0.7,  1.1])#0 0.3 1：0.5+0.2 2：1+0.7-0.6

numpy.array_split and numpy.split

numpy.split(ary, indices_or_sections, axis=0)
把 array划分为多个sub-arrays.
ary : ndarray
indices_or_sections : int or 1-D array
If indices_or_sections 是一个整数 N, 划分array为N等份，如果不能均分则会报错.
If indices_or_sections是一个 有序整数组成的1-D array , 则会按此划分，比如 [2, 3] axis=0,划分为ary[:2]ary[2:3]ary[3:]三部分
如果索引超出维数，则会返回空sub-array.
axis : int, 默认为0

numpy.array_split(ary, indices_or_sections, axis=0)

#功能与split一样，唯一的区别是 array_split allows indices_or_sections to be an integer that does not equally divide the axis.>>> x = np.arange(8.0)>>> np.array_split(x, 3)[array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]

感谢：https://docs.scipy.org/doc/numpy-dev/reference/generated/numpy.reshape.html#numpy.reshape