Numply与Sklearn框架学习

Numply与Sklearn框架学习

1 Numply

import numpy as np
a = np.array([[1,2,3],[4,5,6]])#生成矩阵
print (a)
np.array(object,dtype,order,ndmin)
#object为对象，dtype更改数据格式，order按照行C或者列F来排列，ndmin最小维度
#用dtype来定义对象类
dt=np.dtype([(‘name’,‘S20’),(‘age’,‘i1’),(‘marks’,‘f4’)])
x=np.array([(‘asw’,23,56.6),(‘wes’,21,45)],dtype=dt)
print(x)

“”“字符 对应类型
b 布尔型
i (有符号) 整型
u 无符号整型 integer
f 浮点型
c 复数浮点型
m timedelta（时间间隔）
M datetime（日期时间）
O (Python) 对象
S, a (byte-)字符串
U Unicode
V 原始数据 (void)”""

a=np.arange(1,25)
print(a)
print(a.ndim)
print(a.reshape(2,3,4))#调整维度，二维数组，三行四列

#调整数组大小
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print (a)
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print (b)

#查看元素大小
ndarray.itemsize #以字节的形式返回数组中每一个元素的大小， itemsize 属性值为 8
数组的 dtype 为 int8（一个字节）
x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
print(x.itemsize)

#数组的 dtype 现在为 float64（八个字节）
y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
print(y.itemsize)

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
x = np.empty([3,2], dtype = int)
print (x)

numpy.zeros
创建指定大小的数组，数组元素以 0 来填充：

默认为浮点数
x = np.zeros(5)
print(x)

设置类型为整数
y = np.zeros((5,), dtype=np.int)
print(y)

#自定义类型
z = np.zeros((2, 2), dtype=[(‘x’, ‘i4’), (‘y’, ‘i4’)])
print(z)

将别的类型数据转化为矩阵
numpy.asarray(a, dtype = None, order = None)
注意asarray与array的区别：asarray相当于一个浅拷贝，而array相当于一个深拷贝

使用 range 函数创建列表对象
list = range(5)
it = iter(list)
使用迭代器创建 ndarray
x = np.fromiter(it, dtype=float)
print(x)

s=slice(2,7,2)#进行切片操作，从2开始，到7结束，间隔为2

高级索引
以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print (y)

使用布尔索引
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print (‘我们的数组是：’)
print (x)
print (’\n’)
现在我们会打印出大于 5 的元素
print (‘大于 5 的元素是：’)
print (x[x > 5])

“”“花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，
如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行”""
x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]])#输出的是对应的行
x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])])

“”“NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
迭代器最基本的任务的可以完成对数组元素的访问”""
a = np.arange(6).reshape(2,3)
print (‘原始数组是：’)
print (a)
print (’\n’)
print (‘迭代输出元素：’)
for x in np.nditer(a):
print (x, end=", " )
print (’\n’)

for x in np.nditer(a, order=‘F’): Fortran
#order，即是列序优先；
for x in np.nditer(a.T, order=‘C’): C
#order，即是行序优先；
a = np.arange(0,60,5)
a = a.reshape(3,4)
print (‘原始数组是：’)
print (a)
print (’\n’)
print (‘原始数组的转置是：’)
b = a.T
print (b)
print (’\n’)
print (‘以 C 风格顺序排序：’)
c = b.copy(order=‘C’)
print ©
for x in np.nditer©:
print (x, end=", " )
print (’\n’)
print (‘以 F 风格顺序排序：’)
c = b.copy(order=‘F’)
print ©
for x in np.nditer©:
print (x, end=", " )

a=np.array()
a.T#表示对数组进行赚转置

“”“nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），
为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式”""
a = np.arange(0,60,5)
a = a.reshape(3,4)
print (‘原始数组是：’)
print (a)
print (’\n’)
for x in np.nditer(a, op_flags=[‘readwrite’]):
x[…]=2*x
print (‘修改后的数组是：’)
print (a)

“”"
如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。
假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小
“”"
a = np.arange(0,60,5)
a = a.reshape(3,4)
print (‘第一个数组为：’)
print (a)
print (’\n’)
print (‘第二个数组为：’)
b = np.array([1, 2, 3, 4], dtype = int)
print (b)
print (’\n’)
print (‘修改后的数组为：’)
for x,y in np.nditer([a,b]):
print ("%d:%d" % (x,y), end=", " )

numpy.broadcast_to 函数将数组广播到新形状
a = np.arange(4).reshape(1, 4)
print(‘原数组：’)
print(a)
print(’\n’)
print(‘调用 broadcast_to 函数之后：’)
print(np.broadcast_to(a, (4, 4)))

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组
a = np.array([[1, 2], [3, 4]])
print(‘第一个数组：’)
print(a)
print(’\n’)
b = np.array([[5, 6], [7, 8]])
print(‘第二个数组：’)
print(b)
print(’\n’)

#两个数组的维度相同
print(‘沿轴 0 连接两个数组：’)
print(np.concatenate((a, b)))
print(’\n’)
print(‘沿轴 1 连接两个数组：’)
print(np.concatenate((a, b), axis=1))

numpy.split 函数沿特定的轴将数组分割为子数组
a = np.arange(9)
print(‘第一个数组：’)
print(a)
print(’\n’)
print(‘将数组分为三个大小相等的子数组：’)
b = np.split(a, 3)
print(b)
print(’\n’)
print(‘将数组在一维数组中表明的位置分割：’)
b = np.split(a, [4, 7])

“”"
resize 返回指定形状的新数组
append 将值添加到数组末尾
insert 沿指定轴将值插入到指定下标之前
delete 删掉某个轴的子数组，并返回删除后的新数组
unique 查找数组内的唯一元素
“”"

numpy.append 函数在数组的末尾添加值
a = np.array([[1, 2, 3], [4, 5, 6]])
print(‘第一个数组：’)
print(a)
print(’\n’)
print(‘向数组添加元素：’)
print(np.append(a, [7, 8, 9]))
print(’\n’)
print(‘沿轴 0 添加元素：’)
print(np.append(a, [[7, 8, 9]], axis=0))
print(’\n’)
print(‘沿轴 1 添加元素：’)
print(np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1))

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值
numpy.insert(arr, obj, values, axis)
“”"
arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开
“”"
numpy.delete 函数返回从输入数组中删除指定子数组的新数组

#NumPy数学函数
a = np.array([0,30,45,60,90])
print (‘不同角度的正弦值：’)
print (np.sin(anp.pi/180))
print (’\n’)
print (‘数组中角度的余弦值：’)
print (np.cos(anp.pi/180))
print (’\n’)
print (‘数组中角度的正切值：’)
print (np.tan(a*np.pi/180))

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）
np.ptp(a,axis=1)
百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数，若axis没有指出，则表示全部的
numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值

如果 returned 参数设为 true，则返回权重的和
print (‘权重的和：’)
print (np.average([1,2,3, 4],weights = [4,3,2,1], returned = True))

np.std()标准差
np.var()方差

排序、筛选
numpy.sort(a, axis, kind, order)
a: 要排序的数组
axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis = 0
按列排序，axis = 1
按行排序
kind: 默认为
‘quicksort’（快速排序）
order: 如果数组包含字段，则是要排序的字段

numpy.argsort() 函数返回的是数组值从小到大的索引值
x = np.array([3, 1, 2])
print (‘我们的数组是：’)
print (x)
print (’\n’)
print (‘对 x 调用 argsort() 函数：’)
y = np.argsort(x)
print (y)
print (’\n’)
print (‘以排序后的顺序重构原数组：’)
print (x[y])
print (’\n’)
print (‘使用循环重构原数组：’)
for i in y:
print (x[i], end=" ")

2 Sklearn

传统数据的分析流程一般为：获取数据 -> 数据预处理 -> 训练建模 -> 模型评估 -> 预测，分类。以下用sklearn简单展示
sklearn中含有大量的数据库，我们用iris

from sklearn import datasets
iris=datasets.load_iris()
x=iris.data
y=iris.label

获取数据后进行数据的预处理

from sklearn import preprocessing
#数据的规范化
data = [[0, 0], [0, 0], [1, 1], [1, 1]]
# 1. 基于mean和std的标准化
scaler = preprocessing.StandardScaler().fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)
# 2. 将每个特征值归一化到一个固定范围
scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)
#feature_range: 定义归一化范围，注用（）括起来

#数据的正则化
X = [[ 1., -1.,  2.],[ 2.,  0.,  0.],[ 0.,  1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')

#另外有一个one-hot编码，增加线性模型的非线性能力
data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]
encoder = preprocessing.OneHotEncoder().fit(data)
enc.transform(data).toarray()

之后对数据进行划分，得到测试集与训练集

# 作用：将数据集划分为 训练集和测试集
# 格式：train_test_split(*arrays, **options)
from sklearn.mode_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
"""
参数
---
arrays：样本数组，包含特征向量和标签

test_size：
　　float-获得多大比重的测试样本 （默认：0.25）
　　int - 获得多少个测试样本

train_size: 同test_size

random_state:
　　int - 随机种子（种子固定，实验可复现）
　　
shuffle - 是否在分割之前对数据进行洗牌（默认True）

返回
---
分割后的列表，长度=2*len(arrays), 
　　(train-test split)
"""

在之后就可以导入模型进行预测分析，用检验集合对模型拟合效果进行检验