Pandas常用方法笔记汇总

数据分析常用方法和函数
【np】
np.array()
type()
data.dtype
data.shape
data.reshape(())

np.ones(shape, dtype=None, order=‘C’)
np.ones((10,30,450),dtype = “float”)

np.zeros(shape, dtype=float, order=‘C’)
np.zeros((10,30,450),dtype = “float”)

np.full(shape, fill_value, dtype=None, order=‘C’)
np.dull((12,),fill_value = 1024)

np.eye(N, M=None, k=0, dtype=float)
对角线为1其他的位置为0

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
np.arange([start, ]stop, [step, ]dtype=None)
np.random.randint(low, high=None, size=None, dtype=‘l’)

np.random.randn(d0, d1, …, dn) 标准正太分布

np.random.normal(loc=0.0, scale=1.0, size=None)

np.random.random(size=None) 生成0到1的随机数，左闭右开
np.random.random(size = 10)

np.random.randint(0,20,size =(2,3))生成0-20随机整数，两行三列的二维数组

4个属性
data.ndim 维度
data.shape 形状
data.size 长度
data.dtype 元素类型

普通
nd[2,2] = 250 根据索引修改数据
切片：用冒号，两个冒号跟的数据是 取值的步幅
数据反转：
nd1 = np.random.randint(0,100,size = 11)
nd1[::-1]

变形 reshape
级联:就是两个ndarray的数据合到一起 np.concatenate()
需要注意的点：
(1)级联的参数是列表：一定要加中括号或小括号
(2)维度必须相同
(3)形状相符
【重点】级联的方向默认是shape,这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向,
行上面进行级联的时候（axis = 0）, 列是必须相同的
列上面进行级联的时候（axis = 1）, h行是必须相同的
np.hstack()
np.vstack()
切分：
np.splite()
np.vsplit()
np.hsplit()
副本
data.copy()

聚合
np.prod()乘法
np.power()幂运算

data.argmin()最小值索引
data.argmax()最大值索引

矩阵
data.add()
data.substract()
data.multiply()
data.divide()
np.dot()矩阵乘积

排序
np.sort()
ndarray.sort()
部分排序
np.partition(nd, kth = 10) 就是把前kth个数字 排在前面

【pd01_数据结构】

导包三剑客
import numpy as np
import pandas as pd
from pandas import Series,DataFrame

由ndarray创建的是引用，而不是副本。对Series元素的改变也会改变原来的ndarray对象中的元素。（列表没有这种情况）
1.Series
创建
(1)列表创建
Series(value,index)
nd = np.array([0,2,4,6])
s = Series(nd, index = [“A”,“B”,“C”,“D”])
（2）字典创建
s = Series(data = {“a”:10, “pi”:3.14,“e”:2.713,“g”:0.618 }, index = [“a”,“pi”,“e”,“g”,“kk”])
索引
（1）显示
使用index中的元素作为索引值，直接用中括号
s[“e”]
使用.loc[]（推荐）
s.loc[“e”]
（2）隐式
使用整数作为索引值

使用.iloc[]（推荐）注意，使用iloc进行切片的时候，都是左闭右开的

注意：一个中括号和两个中括号返回的数据是不一样的（重要的）

属性
data.shape
data.size
data.index
data.values

查看样式
pd.read_csv()
head()
tail()

检测空值
pd.isnull()
pd.notnull()
或
data.isnull()
data.notnull()
返回元素是boolean 类型的值 如果为空的话， 返回True 如果不为空的话， 返回False #注意事项：对于DataFrame而言， 每一列数据其实都是一个Series, 并且都是有name属性的

series运算
（1）适用于numpy的数组运算也适用于Series
（2）Series之间的运算：在运算中自动补齐不同索引的数据；如果索引不对应，则补NAN

2.DataFrame
三类数据：
#结构化数据：例如数据库的数据表， 有行有列
#半结构化数据：比如 xml， json
#非结构化数据：图片， 音频，视频等 二进制流的形式进行读取存储的

DataFrame是一个【表格型】的数据结构，可以看做是【由Series组成的字典】（共用同一个索引）。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。

• 行索引：index
• 列索引：columns
• 值：values（numpy的二维数组）
  （1）创建dataframe
  最常用的方法是传递一个字典来创建
  DataFrame属性：values、columns、index、shape
  （2）索引
  a.列索引：
  可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。
  方式一：类似字典；
  方式二：通过属性的方式，取多个的时候采用两个中括号

b.行索引

• 使用.ix[]来进行行索引
• 使用.loc[]加index来进行行索引
• 使用.iloc[]加整数来进行行索引
  同样返回一个Series，index为原来的columns。
  c.对元素索引的方法
• 使用列索引
• 使用行索引(iloc[3,1]相当于两个参数;iloc[[3,3]] 里面的[3,3]看做一个参数)
• 使用values属性（二维numpy数组）
  注意: 直接用中括号时：
  索引表示的是列索引
  切片表示的是行切片

（3）运算
a.dataframe运算
同Series一样：
在运算中自动对齐不同索引的数据
如果索引不对应，则补NaN；两个DataFrame进行相加的时候，axis是不起作用的
b.Series与DataFrame之间的运算
使用Python操作符：以行为单位操作（参数必须是行），对所有行都有效。（类似于numpy中二维数组与一维数组的运算，但可能出现NaN）

使用pandas操作函数：

axis=0：以列为单位操作（参数必须是列），对所有列都有效。
axis=1：以行为单位操作（参数必须是行），对所有行都有效。

【pd_02处理缺失值】
有两种丢失数据：
None
np.nan(NaN)
1.numpy中的
（1）.None
None是Python自带的，其类型为python object。因此，None不能参与到任何计算中。
object类型的运算要比int类型的运算慢得多
计算不同数据类型求和时间
%timeit np.arange(1e5,dtype=xxx).sum()
（2）.np.nan（NaN）
np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。
但可以使用np.nan*()函数来计算nan，此时视nan为0

2.pandas中
（1） pandas中None与np.nan都视作np.nan
（2）pandas中None与np.nan的操作
isnull()：一般 isnull()和any() 连用
notnull()
dropna(): 过滤丢失数据
fillna(): 填充丢失数据
【pd_03层细化索引】
1.多层行索引

1. 隐式构造
   常见的方法是给DataFrame构造函数的index参数传递两个或更多的数组
   s = Series(data = [1,2,3,“a”], index = [[“a”,“a”,“b”,“b”],[“期中”,“期末”,“期中”,“期末”]])
2. 显示构造pd.MultiIndex
   a.使用数组
   b.使用tuple
   c.使用product（最简单推荐使用）

2.多层列索引

3. 多层索引对象的索引与切片操作
   1）Series的操作：对于Series来说，直接中括号[]与使用.loc()完全一样，因此，推荐使用中括号索引和切片。
   a.索引

b.切片

2）DataFrame的操作
行：使用行索引需要用ix()，loc()等函数，推荐使用loc()函数
列：可以直接使用列名称来进行列索引
注意：在对行索引的时候，若一级行索引还有多个，对二级行索引会遇到问题！也就是说，无法直接对二级索引进行索引，必须让二级索引变成一级索引后才能对其进行索引！

4.索引的堆（stack）
stack(level = 1)：把列索引变成行索引
unstack(level=0)：把里面的行索引变成列索引
小技巧：
使用stack()的时候，level等于哪一个，哪一个就消失，出现在行里；
使用unstack()的时候，level等于哪一个，哪一个就消失，出现在列里

5.聚合操作
注意：
（1）需要指定axis
（2）和unstack()相反，聚合的时候，axis等于哪一个，哪一个就保留

data.std()标准差

【pandas04_拼接】
两种拼接：
级联pd.concat, pd.append
合并pd.merge, pd.join
0.回顾np级联

1. 使用pd.concat()级联
   pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数：
   pd.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False,
   keys=None, levels=None, names=None, verify_integrity=False,
   copy=True)

1. 简单级联
   和np.concatenate一样，优先增加行数（默认axis=0）
   可以通过设置axis来改变级联方向,这个axis的使用和np.concatenate一样的， 当axis = 0 的时候增加的行数， 如果不想有空值的出现，列应该是相同的
   #当axis = 1的时候， 增加的是列数， 如果不想有空值的出现， 行索引应该是一样的
   2)不匹配级联
   不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致
   有3种连接方式：
   外连接;补NaN（默认模式）
   内连接：只连接匹配的项
   连接指定轴 join_axes
2. 使用append()函数添加
   由于在后面级联的使用非常普遍，因此有一个函数append专门用于在后面添加

2. 使用pd.merge()合并
   两个DataFrame一般要有两个相同的列名字， 才可以进行合并， 融合;
   merge与concat的区别在于，merge需要依据某一共同的行或列来进行合并
   使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。
   注意每一列元素的顺序不要求一致

1. 一对一合并
2. 多对一合并
3. 多对多合并
4. key的规范化:使用on=显式指定哪一列为key,当有多个key相同时使用
   使用left_on和right_on指定左右两边的列作为key，当左右两边的key都不相等时使用
5. 内合并与外合并
   内合并：只保留两者都有的key（默认模式）
   外合并 how=‘outer’：补NaN
   左合并、右合并：how=‘left’，how=‘right’，
6. 列冲突的解决
   当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名
   可以使用suffixes=自己指定后缀
   【案例分析：美国加州人口数据分析】
   【pandas05_数据处理】
   1、删除重复元素
   使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True
   使用drop_duplicates()函数删除重复的行

2. 映射
   映射的含义：创建一个映射关系列表，把values元素和一个特定的标签或者字符串绑定
   需要使用字典：

map = {
‘label1’:‘value1’,
‘label2’:‘value2’,
…
}

包含三种操作：

replace()函数：替换元素
最重要：map()函数：新建一列
rename()函数：替换索引

1. replace()函数：替换元素
   使用replace()函数，对values进行替换操作
2. map()函数：新建一列
   使用map()函数，由已有的列生成一个新列
   适合处理某一单独的列。
   注意：map()函数中可以使用lambda函数
   df[“C”] = df[“Go”].map(lambda x : x-3)
   df
3. rename()函数：替换索引

3. 异常值检测和过滤
   使用describe()函数查看每一列的描述性统计量
   使用std()函数可以求得DataFrame对象每一列的标准差
   根据每一列的标准差，对DataFrame元素进行过滤。
   借助any()函数, 测试是否有True，有一个或以上返回True，反之返回False
   对每一列应用筛选条件,去除标准差太大的数据
4. 排序
   使用.take()函数排序
   可以借助np.random.permutation()函数随机排序
   随机抽样：当DataFrame规模足够大时，直接使用np.random.randint()函数，就配合take()函数实现随机抽样
5. 数据聚合【重点】
   数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。

数据分类处理：

分组：先把数据分为几组
用函数处理：为不同组的数据应用不同的函数以转换数据
合并：把不同组得到的结果合并起来
数据分类处理的核心： groupby()函数

6.高级数据聚合
（1）
可以使用pd.merge()函数将聚合操作的计算结果添加到df的每一行
（2）使用groupby分组后调用加和等函数进行运算，让后最后可以调用add_prefix()，来修改列名
（3）
可以使用pd.merge()函数将聚合操作的计算结果添加到df的每一行
使用groupby分组后调用加和等函数进行运算，让后最后可以调用add_prefix()，来修改列名

【pandas06_绘图函数】
1.简单图
简单的Series图表示例,plot()
简单的DataFrame图表示例,plot()
2.柱状图
Series柱状图示例,kind = ‘bar’/‘barh’
3.直方图
方图是特殊形状的柱状图
#表示数据分布的情况
#又叫密度图
#s.plot(kind = “hist”)
#normed归一化处理
s.hist(grid = False, bins = 20, normed = True)
直方图hist，函数中必须添加属性normed = True

【scipy】
scipy.fftpack模块用来计算快速傅里叶变换
速度比传统傅里叶变换更快，是对之前算法的改进
图片是二维数据，注意使用fftpack的二维转变方法
import scipy as sp
from scipy import fftpack
#专门处理傅里叶变换包

1.数值积分，求解圆周率
求解圆周率 integrate 对函数(1 - x²⁾0.5进行积分

2.Scipy文件输入/输出
随机生成数组，使用scipy中的io.savemat()保存
文件格式是.mat，标准的二进制文件
from scipy import io
使用io.loadmat()读取数据
读写图片使用scipy中misc.imread()/imsave()
3.图片处理
from scipy import ndimage
使用scipy.misc.face(gray=True)获取图片，使用ndimage移动坐标、旋转图片、切割图片、缩放图片
shift移动坐标
rotate旋转图片
zoom缩放图片

【plt】

1.基础知识
导包
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

plt.imread()
plt.imshow()

使用CV2进行人脸更换
pip install opencv-python

import cv2

data = cv2.CascadeClassifier()
#加载
data.load()
#使用人脸识别的类
data= cascade.detectMultiScale()
（1）只含单一曲线
x = np.linspace(-5,5,1000)
y = x**2
plt.plot(x,y)

（2）包含多个曲线的图
a.可以使用多个plot函数（推荐），在一个图中绘制多个曲线
x = np.linspace(-5,5,1000)
y = x**2
plt.plot(x,y)
plt.plot(x, x*3)
#show() 函数显示之前的一个图形，然后show后面又显示一个图形
plt.show()
plt.plot(x, np.power(x, 3))

b.也可以在一个plot函数中传入多对X,Y值，在一个图中绘制多个曲线
line1, line2, line3 = plt.plot(x, y, x, x*3, x, np.power(x,3))
line1.set_linewidth(10)

(3)网格线
使用plt.grid(True)方法为图添加网格线，设置grid参数（参数与plot函数相同），使用plt面向对象的方法，创建多个子图显示不同网格线

面向对象的一种写法，创建多个子视图来进行绘图

#这个必须要会
figure = plt.figure(figsize=(12,5))
#z在绘图区域对象中添加子视图
axes1 = figure.add_subplot(1,3,1)
#开始向轴面（axes1）中绘制图形
x = np.linspace(-10,10,1000)
y = np.cos(x)

axes1.plot(x, y)
plt.grid()
#第二个子视图
axes2 = figure.add_subplot(1,3,2)
axes2.plot(x, y, color = “r”, linestyle = “-.”)
axes2.grid(color = “green”, linestyle = “–”)
#画第三个子视图
axes3 = figure.add_subplot(133)
axes3.plot(x, y, color = “purple”, linestyle = “:”)
axes3.grid(color = “pink”,linestyle = “-”)

（4）坐标轴界限
a.axis方法
如果axis方法没有任何参数，则返回当前坐标轴的上下限axis(xmin =,ymax = )

b.xlim方法和ylim方法
除了plt.axis方法，还可以通过xlim，ylim方法设置坐标轴范围
(5)坐标轴标签
xlabel方法和ylabel方法
plt.ylabel(‘y = x^2 + 5’,rotation = 60)旋转
（6）标题:title方法
plt.plot(x, y)
text = plt.title(“this is a half circle”, fontsize = 20)
text.set_color(“green”)
text.set_fontstyle(“oblique”)
#设置透明度 0-1
text.set_alpha(0.2)
text.set_bbox(dict(facecolor = “purple”, alpha = 0.4))
text.set_backgroundcolor(color = “blue”)
text.set_rotation(60)

(7)图例
legend方法
两种传参方法：
方式一：
plt.plot(x, y, x, np.sin(x), x, np.cos(x))
plt.legend([“half circle”, “sin(x)”,“cos(x)”])

a.方式二：lable 参数
#第二种写法
plt.plot(x,y,label = “half circle”)
plt.plot(x, np.sin(x), label = “sin(x)”)
plt.plot(x, np.cos(x), label = “cos(x)”)
#不调用是不显示的
plt.legend()
#最常用的是使用第二种写法
【推荐使用】在plot函数中增加label参数
在legend方法中传入字符串列表

b.loc参数
plt.plot(x,y,label = “half circle”)
plt.plot(x, np.sin(x), label = “sin(x)”)
plt.plot(x, np.cos(x), label = “cos(x)”)
#不调用是不显示的
plt.legend(loc = “upper left”)

c.ncol参数
plt.plot(x,y,label = “half circle”)
plt.plot(x, np.sin(x), label = “sin(x)”)
plt.plot(x, np.cos(x), label = “cos(x)”)
#不调用是不显示的
plt.legend(loc = “upper left”, ncol = 5)

2.设置风格和样式
plot语句中支持除X,Y以外的参数，以字符串形式存在，来控制颜色、线型、点型等要素，语法形式为：
plt.plot(X, Y, ‘format’, …)
(1)点和线的样式
a.颜色
参数color或c
b.颜色值的方式
别名
color=‘r’
合法的HTML颜色名
color = ‘red’
HTML十六进制字符串
color = ‘#eeefff’
归一化到[0, 1]的RGB元组
color = (0.3, 0.3, 0.4)

c.透明度
alpha参数
d.背景色
设置背景色，通过plt.subplot()方法传入facecolor参数，来设置坐标轴的背景色

e.线型
参数linestyle或ls
f.线宽
linewidth或lw参数

g.不同宽度的破折线
dashes参数
设置破折号序列各段的宽度

h.点型
marker参数
i.多参数连用
颜色、点型、线型

(2)面向对象方法
set_xticks、set_yticks、set_xticklabels、set_yticklabels方法

3.2D图形
(1)直方图
【直方图的参数只有一个x！！！不像条形图需要传入x,y】
hist()的参数

• bins
  可以是一个bin数量的整数值，也可以是表示bin的一个序列。默认值为10
• normed
  如果值为True，直方图的值将进行归一化处理，形成概率密度，默认值为False
• color
  指定直方图的颜色。可以是单一颜色值或颜色的序列。如果指定了多个数据集合，颜色序列将会设置为相同的顺序。如果未指定，将会使用一个默认的线条颜色
• orientation
  通过设置orientation为horizontal创建水平直方图。默认值为vertical

（2）条形图
【条形图有两个参数x,y！】

bar()、barh()
（3）饼图（扇形图）
饼图也只有一个参数x！】\

pie()
饼图适合展示各部分占总体的比例，条形图适合比较各部分的大小
x = [3,3,3]
plt.pie(x, labels = [“dog”,“pig”,“dragon”])
plt.axis(“equal”)

a.饼图属性设置
饼图阴影、分裂等属性设置

#labels参数设置每一块的标签；labeldistance参数设置标签距离圆心的距离（比例值）

#autopct参数设置比例值的显示格式(%1.1f%%)；pctdistance参数设置比例值文字距离圆心的距离

#explode参数设置每一块顶点距圆形的长度（比例值）；colors参数设置每一块的颜色；

#shadow参数为布尔值，设置是否绘制阴影
startangle设置旋转角度

(4）散点图
散点图需要两个参数x,y，但此时x不是表示x轴的刻度，而是每个点的横坐标！
scatter()
x
4。图形内的文字注释
（1）文字
text()
figtext()
（2）注释
annotate()
xy参数设置箭头指示的位置，xytext参数设置注释文字的位置
arrowprops参数以字典的形式设置箭头的样式
width参数设置箭头长方形部分的宽度，headlength参数设置箭头尖端的长度，
headwidth参数设置箭头尖端底部的宽度，
facecolor设置箭头颜色
shrink参数设置箭头顶点、尾部与指示点、注释文字的距离（比例值）

5.3D图
from mpl_toolkits.mplot3d.axes3d import Axes3D

导引
train_test_split()是sklearn包的model_selection模块中提供的随机划分训练集和测试集的函数；使用train_test_split函数可以将原始数据集按照一定比例划分训练集和测试集对模型进行训练

x，y是原始的数据集。
X_train,y_train 是原始数据集划分出来作为训练模型的，
fit模型的时候用。

X_test,y_test 这部分的数据不参与模型的训练，而是用于评价训练出来的模型好坏，score评分的时候用。

test_size=0.2 测试集的划分比例。如果为浮点型，则在0.0-1.0之间，代表测试集的比例；如果为整数型，则为测试集样本的绝对数量；如果没有，则为训练集的补充。

random_state：是随机数的种子。固定随机种子时，同样的代码，得到的训练集数据相同。不固定随机种子时，同样的代码，得到的训练集数据不同。
1.
分类：例如机器识别癌症，分为良性和恶性；网站设置年龄分级
回归：对未来趋势的预测。例如车祸预测系统
2.训练样本集（样本数据集合）
#1.样本数据集合，又叫训练样本集，比如判断一个人是男是女，首先要见过男或者女，

类似于参照物，这个之前见过的样本就相当于是训练样本集，找训练样本集是第一步

2.标签（并且是训练样本集中每一个数据都对应着唯一的标签）
3.输入没有标签的新数据：测试数据

新数据的每个特征与样本集中数据对应的 特征进行比较

K-近邻（K Nearest Neighbour）
【knn】
1.原理
K-近邻算法采用测量不同特征值之间的距离方法进行分类。存在一个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据 与所属分类的对应关系。输人没有标签的新数据后，将新数据的每个特征与样本集中数据对应的 特征进行比较，然后算法提取样本集中特征最相似数据（最近邻）的分类标签。一般来说，我们 只选择样本数据集中前K个最相似的数据，这就是K-近邻算法中K的出处,通常K是不大于20的整数。 最后 ，选择K个最相似数据中出现次数最多的分类，作为新数据的分类。
（2）几何原理
欧氏距离(欧几里得距离）是最常见的距离度量，衡量的是多维空间中各个点之间的绝对距离。

(3)优缺点
优点：精度高、对异常值不敏感、无数据输入假定。
缺点：时间复杂度高、空间复杂度高。
适用数据范围：数值型和标称型。

2.在scikit-learn库中使用k-近邻算法
导包
分类问题：from sklearn.neighbors import KNeighborsClassifier

回归问题：from sklearn.neighbors import KNeighborsRegressor
注：sklearn:google夏令营的产品

举例：
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
#训练样本集
#提高准确率，多加点属性 头发的长短，心率，体温， 血压，血糖，荷尔蒙
X_train = np.array([[175,60,43],
[160,48,36],
[226,120,49],
[155,43,35],
[180,78,44]])
labels = [“男”,“女”,“男”,“女”,“男”]
knn = KNeighborsClassifier()
#训练数据
knn.fit(X_train, labels)
#测试数据
x_test = np.array([[171,65,40]])
#开始进行预测
knn.predict(x_test)
（1）用于分类
导包，机器学习的算法KNN、数据蓝蝴蝶
#鸢尾花， 系统给咱们提供了一部分训练样本(数据集datasets)
import sklearn.datasets as datasets
#数据随机打乱并拆分
from sklearn.model_selection import train_test_split

iris_data = datasets.load_iris()
iris_data
#从字典里面拿出来数据
data = iris_data.data
data.shape
target = iris_data.target
#这里标签叫目标值
target.shape
X_train,X_test,y_train,y_test = train_test_split(data, target, test_size = 0.1)
#拆分包， 会把datab 按照比例0.1 拆分成 X_train ,X_test data 150个数据
#X_train （训练样本集） 135个 X_test （测试数据）15个
#会把target 按照比例0.1 拆分成 y_train 135, y_test 15
X_train.shape
X_test.shape
y_train.shape
#目标值 fit(X_train, y_train)
#真实的值
y_test

#声明算法，开始进行训练
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)

#进行预测
y_= knn.predict(X_test)
y_
#看一下得分：score函数 传参必须传 测试数据和真实的目标值
#测试数据的得分
knn.score(X_test, y_test)

#模型的得分
knn.score(X_train,y_train)

（2）用于回归
回归用于对趋势的预测

导包

生成样本数据

生成测试数据的结果

#【普通线性回归】
关键词;最小二乘法，线性

1.普通线性回归
线性回归就是在求方程
#线性方程
y = kx + b
分类的目标变量是标称型数据，而回归将会对连续型的数据做出预测。

应当怎样从一大堆数据里求出回归方程呢？

假定输人数据存放在矩阵X中，而回归系数存放在向量W中。那么对于给定的数据X1, 预测结果将会通过

Y=X*W

给出。现在的问题是，手里有一些X和对应的Y,怎样才能找到W呢？

一个常用的方法就是找出使误差最小的W。这里的误差是指预测Y值和真实Y值之间的差值，使用该误差的简单累加将使得正差值和负差值相互抵消，所以我 们采用平方误差。
2.实例
导包
import numpy as np
#线性回归的包
from sklearn.linear_model import LinearRegression
#获取糖尿病数据
import sklearn.datasets as datasets
diabetes = datasets.load_diabetes()
diabetes

训练
预测
评分

#【岭回归Ridge】
1.原理
缩减系数来“理解”数据，缩减方法可以去掉不重要的参数，因此能更好地理解数据。此外，与简单的线性回归相比，缩减法能取得更好的预测效果。岭回归是加了二阶正则项(lambda*I)的最小二乘，主要适用于过拟合严重或各变量之间存在多重共线性的时候，岭回归是有bias的，这里的bias是为了让variance更小。

数据的特征比样本点还多如何处理？
如果数据的特征比样本点还多应该怎么办？是否还可以使用线性回归和之前的方法来做预测？

答案是否定的，即不能再使用前面介绍的方法。这是因为输入数据的矩阵X不是满秩矩阵。非满秩矩阵在求逆时会出现问题。为了解决这个问题，统计学家引入了岭回归（ridge regression)的概念

2.过拟合和欠拟合
#过拟合：其实就是所建的机器学习模型或者是深度学习模型在训练样本中表现得过于优越，导致在验证数据集以及测试数据集中表现不佳。
#欠拟合：就是训练样本集过少，或者是属性过少，或者是属性不重要都有可能导致欠拟合的
3.多重共线性
就是属性之间存在线性关系，或者有制约关系

4.归纳总结
（1）岭回归可以解决特征数量比样本量多的问题

（2）岭回归作为一种缩减算法可以判断哪些特征重要或者不重要，有点类似于降维的效果

（3）缩减算法可以看作是对一个模型增加偏差的同时减少方差

5.岭回归用于处理下面两类问题：

（1）数据点少于变量个数

（2）变量间存在共线性（最小二乘回归得到的系数不稳定，方差很大）
6.缩减系数
#缩减系数
验证alpha和系数的关系
#针对于训练样本集来说，这个alpha到底怎么取合适？？ 答案：看缩减系数

7.实例
岭回归一般用在样本值不够的时候
from sklearn.linear_model import Ridge

#样本集小于特征值的
X_train = [[1,1,1,1],[1,2,3,4]]
y_train =[3,1]

使用普通线性回归

linear = LinearRegression()
linear.fit(X_train,y_train)
#查看模型的系数
linear.coef_

使用岭回归

#查看岭回归的系数 alpha 就是lambda
ridge = Ridge(alpha=0.1)
ridge.fit(X_train,y_train)
ridge.coef_

#创建一个假象的训练样本集
X_train = 1/(np.arange(1,11,1)+ np.arange(0,10,1).reshape((-1,1)))
X_train
#10行10列的数据， 基本上可以看成是 数据样本比特征少的一种情况了
y_train = [1,2,3,4,5,6,7,8,9,0]
#创建一个alpha集合，用来验证不同的alpha对预测系数的结果的影响
alphas = np.logspace(-10,-2,100)
alphas

#创建机器学习的模型
ridge = Ridge()
#一个alpha的值会对应 一个整体系数的列表出来[1,2,3,]
coefs_ = []
for alpha in alphas:
ridge.set_params(alpha = alpha)
ridge.fit(X_train,y_train)
#获取模型的系数
coefs_.append(ridge.coef_)
coefs_

#绘制图形：查看alpha和系数的关系

plt.figure(figsize=(10,10))
axes = plt.subplot(111)
axes.plot(alphas, coefs_)
#s设置x轴单元格
axes.set_xscale(“log”)

#【lass回归】

1.原理：
拉格朗日乘数法】

对于参数w增加一个限定条件，能到达和岭回归一样的效果：

在lambda足够小的时候，一些系数会因此被迫缩减到0
比现行回归和岭回归具有更强的缩减系数的能力 w = 0

案例：使用多种方法对boston数据集进行回归，画出回归图像，并比较多种回归方法的效果

from sklearn.datasets import load_boston
boston = load_boston()
x = boston.data
y = boston.target

from sklearn.linear_model import Ridge, LinearRegression,Lasso
import sklearn.datasets as datasets
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
%matplotlib inline

boston = datasets.load_boston()
boston

data = boston.data
target = boston.target
feature_names = boston.feature_names
samples = DataFrame(data = data, columns= feature_names)
samples.shape

X_train = samples[:450]
y_train = target[:450]
X_test = samples[450:]
y_true = target[450:]

linear = LinearRegression()
ridge = Ridge(alpha = 0)
lasso = Lasso(alpha=13)

linear.fit(X_train,y_train)
ridge.fit(X_train,y_train)
lasso.fit(X_train,y_train)

y_1 = linear.predict(X_test)
y_2 = ridge.predict(X_test)
y_3 = lasso.predict(X_test)

from sklearn.metrics import r2_score

#线性回归
r2_score(y_true, y_1)

#岭回归
r2_score(y_true, y_2)

#alpha = 0 的时候， 此时的岭回归就是线性回归

#lasso回归的
r2_score(y_true, y_3)

#查看一个指标对结果的影响
samples.head()

train = samples[“RM”]
X_train = train.values.reshape(-1,1)
y_train = target

linear.fit(X_train,y_train)
ridge.fit(X_train,y_train)
lasso.fit(X_train,y_train)

xmin, xmax = X_train.min(), X_train.max()
X_test = np.linspace(xmin, xmax, 100).reshape((-1,1))

#预测
y_1 = linear.predict(X_test)
y_2 = ridge.predict(X_test)
y_3 = lasso.predict(X_test)

#绘图
plt.plot(X_test, y_1, color = “red”,label = ‘liner’)
plt.plot(X_test, y_2, color = “green”, label = “ridge”)
plt.plot(X_test, y_3, color = “blue”, label = “lasso”)
plt.scatter(X_train, y_train)
plt.legend()
#linear和领回归的重合了， alpha = 0

【logistics】
虽然名字叫回归，但是其实分类， 而且这个分类很强大（以后工作是必须要用的（分类问题））
【关键词】Logistics函数，最大似然估计，梯度下降法
一.原理
利用Logistics回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。这里的“回归” 一词源于最佳拟合，表示要找到最佳拟合参数集。训练分类器时的做法就是寻找最佳拟合参数，使用的是最优化算法。接下来介绍这个二值型输出分类器的数学原理
1.实现步骤
Logistic Regression和Linear Regression的原理是相似的，可以简单的描述为这样的过程：

（1）找一个合适的预测函数，一般表示为h函数，该函数就是我们需要找的分类函数，它用来预测输入数据的判断结果。这个过程是非常关键的，需要对数据有一定的了解或分析，知道或者猜测预测函数的“大概”形式，比如是线性函数还是非线性函数。

（2）构造一个Cost函数（损失函数），该函数表示预测的输出（h）与训练数据类别（y）之间的偏差，可以是二者之间的差（h-y）或者是其他的形式。综合考虑所有训练数据的“损失”，将Cost求和或者求平均，记为J(θ)函数，表示所有训练数据预测值与实际类别的偏差。

（3）显然，J(θ)函数的值越小表示预测函数越准确（即h函数越准确），所以这一步需要做的是找到J(θ)函数的最小值。找函数的最小值有不同的方法，Logistic Regression实现时有梯度下降法（Gradient Descent）。

二.构造函数
1 构造预测函数
logistic Regression虽然名字里带“回归”，但是它实际上是一种分类方法，用于两分类问题（即输出只有两种）。首先需要先找到一个预测函数（h），显然，该函数的输出必须是两类值（分别代表两个类别），所以利用了Logistic函数（或称为Sigmoid函数），函数形式为
2构造损失函数
Cost函数和J(θ)函数是基于最大似然估计推导得到的。
最大似然估计就是要求得使l(θ)取最大值时的θ，其实这里可以使用梯度上升法求解，求得的θ就是要求的最佳参数
3梯度下降法求J(θ)的最小值
求J(θ)的最小值可以使用梯度下降法，根据梯度下降法可得θ的更新过程:

三、实战
sklearn.linear_model.LogisticRegression(penalty=‘l2’, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver=‘liblinear’, max_iter=100, multi_class=‘ovr’, verbose=0, warm_start=False, n_jobs=1)

solver参数的选择：

“liblinear”：小数量级的数据集
“lbfgs”, “sag” or “newton-cg”：大数量级的数据集以及多分类问题
“sag”：极大的数据集

1.手写数字数据集的分类
使用KNN与Logistic回归两种方法

from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
import sklearn.datasets as datasets
import matplotlib.pyplot as plt
%matplotlib inline

#导入数据load_digits()
digits = datasets.load_digits()
digits
data = digits.data
data.shape

images = digits.images
images.shape

plt.imshow(images[0], cmap = “gray”)
data[0].shape

plt.imshow(data[0].reshape(8,8), cmap = “gray”)

target = digits.target

from sklearn.model_selection import train_test_split
X_train, X_test,y_train,y_test = train_test_split(data, target, test_size = 0.02)

#创建模型，训练和预测
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

logic = LogisticRegression()
logic.fit(X_train,y_train)
logic.score(X_test,y_test)

2.使用make_blobs产生数据集进行分类
导包使用datasets.make_blobs创建一系列点

#make_blobs是专门画三簇点的
data, target = datasets.make_blobs(n_samples=150)
data.shape
target
plt.scatter(data[:,0],data[:,1], c = target)

#创建机器学习模型，训练数据
logic = LogisticRegression()
logic.fit(data, target)

import numpy as np

#预测数据
xmin, xmax = data[:,0].min(), data[:,0].max()
ymin, ymax = data[:,1].min(), data[:,1].max()
x = np.linspace(xmin, xmax, 500)
y = np.linspace(ymin, ymax, 300)
xx, yy = np.meshgrid(x,y)
x_test = np.c_[xx.ravel(), yy.ravel()]
x_test.shape

#预测坐标点数据，并进行reshape()

#对数据进行预测
y_= logic.predict(x_test)

#绘制图形
xx.shape
y_.shape

plt.figure(figsize=(12,9))
#plt.scatter(xx, x_test[:,1], c = y_)
#对坐标点进行着色
plt.pcolormesh(xx, yy,y_.reshape(xx.shape))
plt.scatter(data[:,0], data[:,1], c = target, cmap = “rainbow”)

【Bayes】
【关键词】
朴素：独立性假设
贝叶斯公式
一、基本概念
1.原理
朴素贝叶斯算法是一个典型的统计学习方法，主要理论基础就是一个贝叶斯公式，贝叶斯公式的基本定义如下：

这个公式虽然看上去简单，但它却能总结历史，预知未来：

公式的右边是总结历史
公式的左边是预知未来

如果把Y看成类别，X看成特征，P(Yk|X)就是在已知特征X的情况下求Yk类别的概率，而对P(Yk|X)的计算又全部转化到类别Yk的特征分布上来。

举个例子，大学的时候，某男生经常去图书室晚自习，发现他喜欢的那个女生也常去那个自习室，心中窃喜，于是每天买点好吃点在那个自习室蹲点等她来，可是人家女生不一定每天都来，眼看天气渐渐炎热，图书馆又不开空调，如果那个女生没有去自修室，该男生也就不去，每次男生鼓足勇气说：“嘿，你明天还来不？”,“啊，不知道，看情况”。

然后该男生每天就把她去自习室与否以及一些其他情况做一下记录，用Y表示该女生是否去自习室，即Y={去，不去}，X是跟去自修室有关联的一系列条件，比如当天上了哪门主课，蹲点统计了一段时间后，该男生打算今天不再蹲点，而是先预测一下她会不会去，现在已经知道了今天上了常微分方法这么主课，于是计算P(Y=去|常微分方程)与P(Y=不去|常微分方程)，看哪个概率大，如果P(Y=去|常微分方程) >P(Y=不去|常微分方程)，那这个男生不管多热都屁颠屁颠去自习室了，否则不就去自习室受罪了。P(Y=去|常微分方程)的计算可以转为计算以前她去的情况下，那天主课是常微分的概率P(常微分方程|Y=去)，注意公式右边的分母对每个类别（去/不去）都是一样的，所以计算的时候忽略掉分母，这样虽然得到的概率值已经不再是0~1之间，但是通过比较大小还是能选择类别。

后来他发现还有一些其他条件可以挖，比如当天星期几、当天的天气，以及上一次与她在自修室的气氛，统计了一段时间后，该男子一计算，发现不好算了，因为总结历史的公式：

这里n=3，x(1)表示主课，x(2)表示天气，x(3)表示星期几，x(4)表示气氛，Y仍然是{去，不去}，现在主课有8门，天气有晴、雨、阴三种、气氛有A+,A,B+,B，C五种，那么总共需要估计的参数有8×3×7×5×2=1680个，每天只能收集到一条数据，那么等凑齐1680条数据，大学都毕业了，男生大呼不妙，于是做了一个独立性假设，假设这些影响她去自习室的原因是独立互不相关的，于是：
有了这个独立假设后，需要估计的参数就变为，(8+3+7+5)×2 = 46个了，而且每天收集的一条数据，可以提供4个参数，这样该男生就预测越来越准了。

朴素的概念：独立性假设，假设各个特征之间是独立不相关的。

举例
贝叶斯：
#A B 容器
#A 7red 3 white
#B 1red 9white

p(A) = 1/2

#A容器中红球的概率
p(red|A) = 7/10

#抓一个球，该球是红球的概率
p(red) = 8/20

#抓了一个球，红球， 这个红球来自于A
p(A|red) = p(A)*p(red|A)/p(red)
#分子：===选择了A容器，并且A容器中红球的概率 整体相乘，
#分母是所有红球事件的概率
p(A|B) = P(A)*P（B|A）/P(B)

#贝叶斯是算概率的 属于哪一类 是不是应该有一个概率
#0.6 0 0.2 1 0.2 2
和逻辑斯蒂回归特别类似

2.优缺点
优点：

朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率；
对小规模的数据表现很好；
能处理多分类任务，适合增量式训练；
对缺失数据不太敏感，算法也比较简单，常用于文本分类

缺点：
只能用于分类问题
需要计算先验概率；
分类决策存在错误率；
对输入数据的表达形式很敏感

3.分类器
朴素贝叶斯的朴素体现在其对各个条件的独立性假设上，加上独立假设后，大大减少了参数假设空间。

二、三种朴素贝叶斯模型
1.高斯分布
高斯分布就是正态分布,一般用于分类问题
from sklearn.naive_bayes import GaussianNB
#使用自带的鸢尾花数据
import sklearn.datasets as datasets
iris = datasets.load_iris()
data = iris.data
target = iris.target

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(data, target, test_size = 0.2)

g_NB = GaussianNB()
g_NB.fit(X_train,y_train)
g_NB.score(X_test,y_test)

from sklearn.linear_model import LogisticRegression
LogisticRegression().fit(X_train,y_train).score(X_test,y_test)

2.多项式分布
适用于文本数据（特征表示的是次数，例如某个词语的出现次数）
from sklearn.naive_bayes import MultinomialNB
m_NB = MultinomialNB()
m_NB.fit(X_train,y_train)
m_NB.score(X_test,y_test)

3.伯努利分布
适用于伯努利分布，也适用于文本数据（此时特征表示的是是否出现，例如某个词语的出现为1，不出现为0）

绝大多数情况下表现不如多项式分布，但有的时候伯努利分布表现得要比多项式分布要好，尤其是对于小数量级的文本数据

from sklearn.naive_bayes import BernoulliNB
b_NB = BernoulliNB()
b_NB.fit(X_train,y_train)
b_NB.score(X_test, y_test)
三、文本分类实战(待完善）
对短信进行二分类，数据为SMSSpamCollection

导包
导入sklearn.feature_extraction.text.TfidfVectorizer用于转换字符串
读取短信数据
#特征词项的提取
from sklearn.feature_extraction.text import TfidfVectorizer
#向量化