机器学习各种算法以及开发具体流程+API具体实例+案例的实现
<机器学习算法分类以及开发流程>
本可儿不才，最近学习机器学习和深度学习的算法之余总结了一点小经验，供大家参考。排版还有待提高厚~~
离散型（不可分）--连续型（预测类别，票房等等）
一、
（1）
【1、监督学习： 特征值 + 目标值。 2、 非监督学习： 特征值 1000个样本】
机器学习算法的分类：
1监督学习（预测）重点
//分类：k-近邻算法，贝叶斯分类，决策树与随机森林，逻辑回归，神经网络（目标是离散型）（样本属于哪一个类别）
//大多数算法应用非常广泛，一定要学好
回归：线性回归，岭回归 （目标值连续型，具体的值） 连续型
//标注：隐马尔可夫模型（不做要求）
2、无监督学习
聚类。k-means （只有特征值。什么都没有的）应用： 银行，图像，文本，贷款吗，票房， 预测价格，股票
预测具体的气温，年龄扽等 （回归） 预测天气是晴天还是阴天：（分类问题）
（2）
机器学习开发流程。 《数据》
1、公司本身就有的数据
2、合作过来的数据（和银行的合作数据，情感分析）
3、购买的数据（很少）
爬虫爬数据需要提前定好。但是不能随便想爬什么就爬什么
原始数据：
1、明确问题是做什么的，建立模型：根据数据类型划分应用种类
分类问题还是回归问题2、 表的合并pd取处理数据，前读取pd.red_csv
pd.merge合并数据的基本处理 ：合并表，缺失值
3、（主要）特征工程
对每个特征进行处理对特征进行处理，标准化，归一化。文本转化数字，fit_transform
4、找到合适的算法去进行预测分析（使用算法）
什么是模型？ 算法 + 数据 （抽象）
5、
模型的评估过程。，不能讲拿来就用。（不断提高模型的准确性 95%以上）
如果模型评估没有合格，则需要换其他比较好的算法（调整参数）
if （==false）
特征工程继续改变，影响因素，增加特征，删除
《前提。明确问题。分裂回归还是聚类》
模型评估 ➡️ 上线使用 （以API形式提供）
知识点回顾：
CountVectorizer Tf idf。//用这个
特征预处理：对于数值型的数据需要归一化标准化，主成分分析
归一化（目的）：避免某一个特征对最终结果造成影响
特征的降维：把特征值减少。1、特征选择 （删除低方差特征）
2、主成分分析（PCA：特征数量>=100）
有监督（有特征有目标值），无监督 （无目标，只有特征）
分类：离散
回归：连续
聚类：
课程第二天： （内容重要并且多）
1、sklearn数据集与估计器
2、分类算法-k-近邻算法
3、k-近邻算法实例
4、分类模型评估
5、分类算法-朴素贝叶斯算法 （分类算法：重点）
6、朴素贝叶斯算法实例
7、模型选择和调优 （重点）
8、决策树余随机森林
（一）
1、数据的获取pd
2、数据集的划分
3、数据及的接口介绍
4、分类和回归数据集（重点）
问题：1、如果拿到数据全部都用于训练一个模型？
数据 （拿一部分数据取训练） （拿一些未知的数据评估）
（训练集（多） - 测试集（少）） 比例： 70% ：30% / 80% :20% / 75%: 25%（使用最多）
2、划分训练集合测试集是什么意思？
把样本给划分一部分给测试集
训练集（建立模型） 测试集（评估模型，建议模型效果是否好不好）
3、划分的API ：sklearn。model_seletion.train_test_split 训练测试分来
（二）
sklearn 数据集api介绍
sklearn。datasets 。。加载获取流行数据集
datasets,load_*（） ..规模小的数据集
datasets,fetch_*(data_home=None) 。。 规模大的数据集
默认下载目录是 ~/scikit_learn_data/获取数据格式：
load* fecth* 都是字典数据
[n_sample * n_features]提前实例化好
print(xxx.data) 特征值 二维的numpy.ndarray
print(xxx.target) 目标值 标签数组 二维的numpy.ndarrayprint(xxx.DESCR) //特征的属性含义
也可以单独获取
feature_names:特征名
target_names:标签名
sklearn分类数据集（目标值是离散型的，具体的数值）
sklearn，datasets.load_iris() 加载鸢尾花数据集
sklearn.datasets.load_digits() 加载并返回数字数据集数据集的分割：
sklearn.model_seletion.train_test_split()
参数：x数据集的特征值, y训练集的特征值
test_size 测试集的大小 0.2 float
random_state
return特征值x的训练集和测试集，目标值y的训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(li.data , li.target, test_size=0.25)用于分类的大数据集：新闻数据集
(已经下载好了，世直接实例就好了fetch_20newsgroups)
slklearn,daatsets.fetch_20newsgroups(data_home=None,subset='train')
datasets.clear_data_home(data_home=None)sllearn回归数据集
sklearn.datasets.load_boston()
加载并获取波士顿房价数据集sklearn.datasets_load_diabetes() 获取并返回糖尿病数据集
进行数据的转换：transformfit_transform 输入数据直接转化为数值
fit（）：输入数据 transform（）转化数据
from sklearn.preprocessing import StandScaler
s = StandScaler()
s,fit_transform([[],[],[]])
直接进行数据转化
先用standardScaler（）实例化再用fit_transform([])进行标准化和转化
(三)估计器：算法的实现，实线算法的api
1、用于分类的估计器：
sklearn.neighbors k-近邻算法
sklearn.naive_bayes 贝叶斯
sklearn.linear_model.LogosticRegression 逻辑回归
sklearn.tree 决策树余随机森林
2、用于回归的估计器：
sklearn.linear_model.LinearRegression 线性回归
sklearn.linear_model.Ridge 岭回归
门槛：每隔算法api中的参数，传入算法的参数以及属性。了解哪些参数需要传
估计器的流程：
训练集 测试集
extamitor 估计器 ：流程与transform类似 （x_train， y_train）
1、调用fit(x_train, y_train) //可以用
2、输入预测数据(测试集) x_test， y_test
y_predict = predict(x_test) //预测目标值
3、预测准确率：score(x_text, y_test)
（1）分类算法-k近邻算法（knn） 1960年提出（简单）
需要标准化
1、 定义：一个样本中k个最相似（特征宽假中最邻近）的样本的大多数属于某一个类别，则该样本也属于这个类别
2、欧式距离：比如说a(a1,a2,a3)b(b1,b2,b3)
(a1-b1)^2+(a2-b2)^2+(a3-b3)^2 开根号
结合之前的例子，计算两个样本距离的特征有什么影响？需要对数据做些什么？
标准化： preprocession StandardScaler
API： sklearn.neighbors.KNeighborsClassifier(n_neighboes=5,algorithm='auto')
n_neighbors:查询默认使用的邻居数
algorithm：可选用余计算最近邻居的算法 BallTree kd_tree=KDTree传递参数
举例：k-近邻实例预测住房数据 （分类问题）
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
def knncls():
"""
k-近邻预测用户签到位置
:return: None
"""
# 读取数据
data = pd.read_csv("/Users/wusibin/Downloads/热身赛数据/01-12/chongzhi_beier-east-01-12.csv")
# print(data.head(10))
# print(data.head(20))
#处理数据
#缩小数据，查询数据筛选
data = data.query("x> 1.0 & x < 1.25, y>1.0 & y<1.25")
#处理时间的的数据
time_value = pd.to_datetime(data['time'], unit='s')
print(time_value)
#把日期格式转换成字典格式
time_value = pd.DatetimeIndex(time_value)
# 构造一些特征
data['date'] = time_value.day
data['hour'] = time_value.hour
data['weekday'] = time_value.weekday
#把时间戳特征删除
data.drop(['time'], axis=1)
print(data)
#把签到数量少于n的目标位置删除
place_count= data.groupby('place_id').count()
tf = place_count[place_count.row_id > 3].reset_index()
data = data[data['place_id'].isin(tf.place_id)]
#去除数据当中的特征值和目标值
y = data['place_id']
x = data.drop(['place_id'], axis=1)
#把数据分成训练集和测试集
x_train,x_test,y_train,y_test = train_test_split(x, y, test_size=0.25)
#特征工程（标准化）
# data['day'] =
std = StandardScaler()
#对测试集合训练集进行标准化
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)
#进行算法流程
knn = KNeighborsClassifier(n_neighbors=5)
#fit ,predict,acore
knn.fit(x_train, y_train)
#得出预测结果
y_predict= knn.predict(x_test)
print("预测目标签到位置为：",y_predict)
# 得出一个准确率
print("预测的准确率：",knn.score(x_test,y_test))
return None
if __name__ == "__main__":
knncls()
强调：以下的方法不一定对，需要看训练后的结果怎么样。
特征值：x,y 坐标，定位准确性，时间戳，日，时，周 目标值：入住位置的id
处理： 0
2、时间戳进行处理，看最后的效果。
效果不好就不处理。（年、月、日、周、时、分秒），当做新特征放入数据里
3、入住位置特别多（几千，几万个），导致预测准确率低。少于指定的亲到人数的位置删除
data.query(""),里面翻条件，大于多少小于多少，，索引去查询数据
pd.to_datetime() 把时间戳转换成时间年月日
数据的处理：
1、缩小数据集的范围
Dataframe.query()2、处理日期数据
pd.to_datetime
pd.Datetimeindex3、删除没用的日期数据
DataFrame.drop5、将签到位置少于n个用户的删除
data.groupby('place_id').count[] tf = place_count[place_count.row_id >3].reset_index()
data = data[data['place_id'].isin(tf.place_id)]
.reset_index()、把索引变成某一列
总结：
问题：
1、k值去多大？有什么影响？
k值去很小：容易受异常点的影响
k值取很大：容易受样本，k值 数量里面的类别的影响的波动
2、性能问题？
时间复杂度，样本越大，时间复杂度越高。所以需要手动调参。特别麻烦
参数需要调优，参数对结果造成影响。所以需要调优
总结：
1、优点：简单易于实现理解，无需参数，无需训练。估计（超参数）
算法实例化
2、缺点：k值取值，以及计算量。
基本上在实际案例中不用。准确率不高，容易影响计算性能。
分类算法------朴素贝叶斯
1、概率基础 2、朴素贝叶斯介绍
应用：垃圾邮件的分类（金融，软件，产品，互联网）找出类别那个可能性概率最高，
就将这个类别分为所占比例最高的一类的名称
1、概率基础：根据历史数据预测未来发生的可能性，扔硬币和预测天气
2、联合概率：包含多个条件，且所有条件同事成立 p(AB)
2、条件概率：事件A在事件B以及发生的条件下的概率 p(A|B)p(A|B）
自然语言处理不独立的情况
朴素贝叶斯----条件（特征）相互独立，否则效果不好
面试：朴素，条件独立的意思
文档分类：
反应主题中心的词：
P(科技|词1，词2，词3.。。) 文档：词1，词2，词3.。。。。
P(娱乐|词a，词b，词c。。。) 文档：词1 ，词2，词3 。。。
重点：
（面试）贝叶斯公式： p(C|W) = P(W|C)P(C) /P(W)
w为给定文档的特征值（），c为文档的类别（给定文档的词）
P(C)：每个文档类别的概率：（某文档数、总文档数）
P(W|C)：给定类别下特征（被预测文档中出现的词）的概率
但是也会出现概率为0
如何解决？
拉普拉斯平滑系数 P(F1|C) = Ni+a / N+am
a指定的系数1，m为训练集中统计文档的次数
朴素贝叶斯分类实现API
sklearn.naive_bayes.MultinomalNB（alpha = 1.0） 默认
alpha：拉普拉斯平滑系数，防止分类的时候类别的概率为0
朴素贝叶斯算法案例：
sklearn20类新闻分类
20个新闻数据集包含20个主题的18000个新闻组帖子
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassifier
import pandas as pd
def naviebays():
"""
朴素贝叶斯分类文本
:return: None
"""
news = fetch_20newsgroups(subset='all')
# 对数据进行分割
x_train,x_test,y_train,y_test = train_test_split(news.data,news.target,test_size=0.25)
# 对数据集进行特征抽取
tf = TfidfVectorizer()
# 训练集中对此的列表进行每篇文章的重要性统计['a','b','c','d']
x_train = tf.fit_transform(x_train)
print(tf.get_feature_names())
x_test = tf.transform(x_test)
#进行朴素贝叶斯算法的预测
mlt = MultinomialNB(alpha=1.0)
print(x_train.toarray())
#sparse的矩阵
mlt.fit(x_train, y_train)
# 以及在api实现了 关于predict的算法
y_predict = mlt.predict(x_test)
print("预测文章的类别为：", y_predict)
# 得出准确率
print("准确率为：",mlt.score(x_test,y_test))
print("每个类别的精确率和召回率：",classification_report(y_test,y_predict,news.target_names))
# classification_report(y_true=,y_pred=,target_names=)
#构造一些参数值进行搜索
param = {"n_neighbors":[3,5,10]}
# 进行网格搜索 knn无实例，数据需要在官网获取下载
gc = GridSearchCV(knn,param_grid=param,cv=10)
gc.fit(x_train,y_train)
# 预测准确率
print("在测试集上的准确率：",gc.score(x_test,y_test))
print("在交叉验证中最好的结果：", gc.best_score_)
print("选择最好的模型是：",gc.best_estimator_)
print("每隔超参数每次交叉验证的结果：",gc.cv_results_)
return None
if __name__ == "__main__":
naviebays()
流程：
1、先把数据加载下来fetch——20newsgroups（subsets=0.5）
并进行分割陈训练集测试集x_train，y_train，x_test,y_test
文本特征抽取
2、生成文章特征词
文本特征抽取
3、朴素贝叶斯estimator流程进行预估 不需要调参。
朴素贝叶斯算法受训练集的影响非常大，训练集误差大，结果看到不好
重要的词如果不具有代表性的话。
不需要调参。
总结：
优点：
1、分类效率高，准确。只要数据集是准确的
2、对于缺失数据集不太敏感，少了一个词一个概率影响不大
3、分类准确率高，无法调参
4、易于文本分类
缺点：
1、假设了文章中的词是具有独立性的，对文章讲不太靠谱
2、在训练集中进行统计词的工作，会对结果造成较大的干扰。
只要训练集准备的准确，里面的词具有代表性就效果好
朴素贝叶斯：文本分类
神经网络：效果更好
（一）
分类模型的评估：精确率（准确率）和召回率
其他分类标准：F1-score 反应了数据的稳定性
分类模型评估API： 度量，评估 分类，精确率，召回率
sklearn.metrics.classification_report（y_true,y_pred,target_names=Nome）
y_true:真实目标值
y_pred：估计器预测目标值
target——names：目标类别名称
return：每个类别进去率余召回率
实例：
print("每个类别的精确率和召回率：",classification_report(y_test,y_predict,news.target_names))
（二）
模型的选择余调优 k值，特征值
交叉验证 网格搜索
交叉验证，网格搜索搭配使用
1、交叉验证，为了让评估的模型更加准确可以信
所有数据分成n等分（与x_test，y_test，无关系）
训练集 训练集 训练集 | 验证集 得出一个模型准确率 模型1
训练集 训练集 验证集 | 训练集 得出一个模型准确率 模型2
训练集 验证集 训练集 | 训练集 得出一个模型准确率 模型3
。。。最后求出模型的品均值的结果为80%
2、网格搜索---调参数 （调到某一个位置达到的效果最好 ）
k-近邻：超参数K若超参数不止一个，a[2,3,5,8,10] b[20,70,80] 两两进行组合
超参数搜索--网格搜索API 交叉验证param = {"n_neighbors":[3,5,10]} 这里的参数可调，提前构造出来的参数值
sklearn.model_selection.GridSearchCV(estimator,param_gird=None,cv=None)
estimator:估计器对象
param_grid:估计器参数（dict）{"n_neighbors":[1,3,5]}
fit：输入训练数据
cv：指定几折交叉验证
score：准确率结果分析：
best_score:在交叉验证中验证的最好结果
best——estimator：最好的参数模型
cv_results_:每次交叉验证后的验证集准确率地结果和训练集的准确率的结果
（三） 分类算法----决策树（随机森林）
比朴素贝叶斯 和 k近邻准确率高很多，高纬度高特征，数据月复杂优势越明显
1、认识决策树
2、信息基础-银行贷款分析
3、决策树的生成
4、泰坦尼克号乘客生存分类
信息熵----信息和消除不确定性是相联系的（决策树的时间划分）
哪个减少的信息熵更多就选哪个（以此玩下进行二分，是则继续，否则不分）
例如：决策树的实际划分：有自己的房子（是/否）
是公务员吗？（否/是）
决策树的划分依据：
信息和消除不确定性是相互联系的
（1）信息增益
当得知一个特征的条件之后，减少的信息熵的大小
g(D,A)=H(D)-H(D|A)
g为信息增益
H(D) 初始信息熵的大小
信息熵的计算
条件熵的计算
g(D|年龄)=H(D|年龄）=
常见的决策树的使用方法
ID3信息增益最大的准则
C4.5 信息增益比 对大的准则
CART
回归树：平方误差最小
分类树：基尼系数 最小准则在sklearn中可以选择划分的默认原则
sklearn决策树API
class sklearn.tree.DecisionTreeClassifier(criterion='gini',max_depth=None,random_state=None)决策树分类器：
criterion：默认是'gini'系数，也可以选择信息增益的熵'entropy'
max_depth:书店深度大小
random_state:随机数种子method：
decision_path:返回洁厕书的路径
案例：泰坦尼克号的分类，预测是生是死。看看预测是否准确
集成学习方法--随机森林
泰坦尼克号乘客生死分类模型
import pandas as pd
from sklearn.feature_extraction import DictVectorizer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.ensemble import RandomForestClassifier
def decisionTree():
"""
决策树预测泰坦尼克号的生死
:return: None
"""
# 获取数据
titan = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub//Main/DataSets/titanic.txt")
# 处理数据，找出特征值和目标值
x = titan[['pclass','age','sex']]
y = titan['survived']
print(x)
#缺失值的处理,把空值进行填充，求平均值
x['age'].fillna(x['age'].mean(), inplace=True)
# 分割数据到训练集到测试集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 进行处理 特征工程 特征？》类别的处理---one_hot编码
dict = DictVectorizer(sparse=False)
x_train = dict.fit_transform(x_train.to_dict(orient="records"))
print(dict.get_feature_names())
x_test = dict.transform(x_test.to_dict(orient="records"))
# print(x_train)
# 重点，，，用决策树进行预测，并且修改深度5层，超参数，会影响结果
# max_depth深度可调，值越大决策树越少
dec = DecisionTreeClassifier(max_depth=8)
# 固定步骤，把训练集的目标值和特征值翻入进行
dec.fit(x_train,y_train)
# 预测准确率
# 训练后的成为测试集用dec.score方法预测准确率
print("预测的准确率：", dec.score(x_test, y_test))
#
# # 导出决策树的结构
# export_graphviz(dec, out_file="./tree.dot", feature_names=['年龄', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', '女性', '男性'])
#
# 随机森林进行预测，超参数调优
rf = RandomForestClassifier()
param = {"n_estimators": [120, 200, 300, 500, 800, 1200], "max_depth":[5,8,15,25,30]}
# 网格搜索余交叉验证
gc = GridSearchCV(rf, param_grid=param, cv=2)
gc.fit(x_train, y_train)
print("预测准确率:", gc.score(x_test, y_test))
print("查看选择的参数模型：", gc.best_params_)
return None
if __name__ == '__main__':
decisionTree() 流程：
1、pd读取数据
2、寻找有影响的特征，处理缺失值（填补，按照那一列的品均值进行填补）
3、进行特种工程，pd转化字典，特征抽取x_train.to_tict(orient="records")
4、决策树估计器流程
决策树的结构、本地保存
1、sklearn.tree.export_graphviz()该函数能够导出DOT格式
tree.export_graphviz(estimator,out_file='tree.dot',feature_names=[","])2、工具：（能够将dot文件替换为pdf、png）
按照graphviz
mac： brew install graphviz运行命令
$ dot -Tpng tree.dot -o tree.png
# 导出决策树的结构
export_graphviz(dec, out_file="/User/wusibin/Downloads/tree.dot", feature_names=['age年龄', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female女性', 'sex=male男性'])
总结：
优点：
1、简单的理解和解释，树木的可视化
需要很少的数据准备，其他技术通常需要数据归一化
缺点：
1、决策树学习者穿件不能很好的推广数据过于复杂的数
这被称为过拟合
DecisionTree
改进：
1、减枝cart算法（决策树api中以及实现，随机森林参数调优有关的介绍）
把最后分的结果砍掉一点，通过api中实现
2、随机森林 也可以解决过拟合的问题（决策树的原理）
ps：企业的重要决策，由于决策树很傻的分析能力，在决策过程应用较多（通过信息增益的大小来判断）
前三个因素占主要，就用决策树
没有进行归一化，数据参数需要修改
集成学习方法：
建立多个模型组合来解决单一的一个问题随机森林：
包含多个决策树进行分类（随机森林建立多个决策树的过程）
单个树建立过程：
1、随机在N个样本中选择一个样本，重复N次，样本有可能重复
2、随机在N个样本在选出m个特征。m取值随机又返回的抽样：bootstrap
重点：随机森林API（参数有很多）
ensemble 集成学习方法 n_estimators： int potional（default = 10）
random随机数class sklearn.ensemble.RandomForestClassifier(n_estimators=10,criterion='gini', max_depth=None,bootstrap=True,random_state=None)
nestimators: 森林里的树木量
max_depth：(默认=无) 数的最大深度 5，8，15，25，30
max_features='auto' 每隔决策树的最大特征数量
//特征数量太多会过拟合
if "auto ,then 'max_feature=sqrt(n_features)'"bootstrap： 博哦了按，optional（default = True）是否在构建树时使用返回抽样，随机有放回
随机森林的超参数：
n_estimator 决策树的数量
max_depth 每颗树的深度限制
总结：
优点：
1、没有缺点
2、具有极高的准确率
2、有效运行在大数据上
3、不需要降维
4、评估各个特征在分类问题上的重要性
5、使用最多最广泛
复习：
（三个分类算法）
1、数据集的划分训练集x_train ，y_train
测试集 x_test ，y_test
目的，调试好，使得预测结果准确
2、sk-learn的api：
estimator 估计器里面# 随机森林进行预测，超参数调优
rf = RandomForestClassifier()param = {"n_estimators": [120, 200, 300, 500, 800, 1200], "max_depth":[5,8,15,25,30]}
3、算法
k-近邻 //重要程度低
朴素贝叶斯
决策树-随机森林，网格搜索和交叉验证信息熵，信息增益，
多了就过拟合
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
（第三天）
回归
1、线性回归 之前是准确率，精确率，召回率
2、分类算法
3、非监督学习
岭回归
k-means ：数据集里面没有目标值怎么去处理 （聚类算法）
回忆回归问题的判定？
1、【之前的是分类问题：离散，属于哪个类别。每一个数值代表着一个类型】
2、目标值为连续性，无线划分，某个区间内取得任意数。
100.35 223.43
只要目标值为连续性都可以预测
应用：
房价()，销售额(影响因素：公司收入，研发的好坏，对特征进行预测)，等等
贷款额度的预测(得到贷款的一个数值，而不是是否能得到贷款)
举例： 期末成绩= ：0.7 X 考试成绩 + 0.3 X 平时成绩（上课出勤率）
线性回归，寻找一种预测的趋势：二维的直线关系
三维：特征，目标值，平面中
线性关系的定义：
y = kx + b
加b：伪类是对于单个特征的勤快更加通用
多个特征：k1 房子的面积 + k2 房子的位置 + b
线性关系模型：
1、一个通过属性（特征）的线性组合来进行预测的函数
f(x) = w1x3 +w2x3 + w3x3
w为权重 b为偏置项
线性回归：
（简单的线性组合）
1、特征值余目标值之间进行建模的回归分析
2、一元线性回归（一个特征，一个目标值）
多元：
（一）、属性和权重的一种组合来预测结果
矩阵：
大多数算法的计算基础
数组： 矩阵：0维 5
1维 【5，2，3，3，322】
2维 【2，34，56，345，【】】行和列的格式 必须是二维结构[[行]列]，满足特定运算需求3维 【【】【】【】】 列表套列表 矩阵的乘法（神经网络）
(m行,l列）*（l行，n列）=（m行，n列）
特征值
[[1，2，3，4] [[2],[2],[2],[2]]
[5,6,7,8]]一个特征 一个权重 目标值
（1行，4列） （ ） 一个样本一个值
(1,1)
(100,1)
数组的运算：加法 乘法
numpy： ndarray
从今往后的所有算法都是迭代的算法：
回归： 迭代的算法（一步一步取调参，一步一步取更新的算法）
神经网络
我们只需要用什么方法，和api就行。拿过来能用就可以了。不需要深入了解
专有名词：损失函数： （预测结果与真实结果的 - 第二个预测结果和真实结果的）的平方 从1开始依次递加
不断迭代，寻找最优化的w的值
方法
《统计学习方法》
算法 策略 优化 ----迭代过程线性回归 损失函数
方法：
1、正规方程：（不做要求）
求解： w = (x的转置x)的-1次方 x的转置y
缺点：当特征过于复杂，求解速度太慢
2、最下二乘法之梯度下降
学习率 * 方向
正规方程与梯度下降对比？
sklearn 线性回归方程，梯度下降APIsklearn.linear_model.LinearRegression
正规方程
普通最小二乘法线性回归coef_；回归系数
sklearn.linear_model.SGDRegressor
通过SGD最小化线性模型梯度下降
scikit-learn 优点：
1、建立模型简单，预测简单
缺点：
1、算法过程，有些参数都在API内部优化执行好了，不用自己去指定
TensorFlow框架：
封装有高有低，可以自己实现线性回归，学习率，这些参数可以自己手动指定
案例：
线性回归实例：
1、sklearn线性回归正规方程，梯度下降API
2、波士顿房价数据集分析流程
from sklearn.datasets import load_boston
from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge, LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
from sklearn.externals import joblib
def mylinear():
"""
线性回归两种预测房子价格
:return: None
"""
# 获取数据
lb = load_boston()
# 分割数据到训练集和测试集 data训练值 target 测试纸
x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target, test_size=0.25)
# 输出的是目标值的训练集和测试集，不是测试值的训练集和测试集
print(y_train,y_test)
# 进行标准化处理(?)目标值是否需要标准化处理？要，标准化处理的结果是所有数据都变得非常非常小权重也小。所以更原来的比起来就小监理损失求解
# inverse_transform 转化成之前的值
# 特征值和目标值都必须进行标准化处理，要处理两个，所以要实例化两个标准化的API
# 标准化测试值
std_x = StandardScaler()
x_train = std_x.fit_transform(x_train)
x_test = std_x.transform(x_test)
# 标准化目标值
std_y = StandardScaler()
# 19版本需要用reshape转化成数组或矩阵的形式 .reshape(-1),,,-1是默认值
y_train = std_y.fit_transform(y_train.reshape(-1, 1))
y_test = std_y.transform(y_test.reshape(1, -1))
# estimator预测
# 正规方程求解方式预测结果 训练数据
lr = LinearRegression()
lr.fit(x_train, y_train)
# 打印权重参数
print(lr.coef_)
# 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
y_lr_predict = std_y.inverse_transform(lr.predict(x_test))
print("测试集里面每个房子样本的预测价格：", y_lr_predict)
print("正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_lr_predict))
# 梯度下降进行房价预测 实例化
sgd = SGDRegressor()
sgd.fit(x_train, y_train)
# 打印权重参数
print(sgd.coef_)
# 保存训练好的模型
joblib.dump(lr, "./temp/test.pkl")
# 预测房价的价格
model = joblib.load("./temp/test.pkl")
y_predict = std_y.inverse_transform(model.predict_test)
print("保存的模型预测结果：", y_predict)
# 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))
print("梯度下降测试集里面每个房子样本的预测价格：", y_sgd_predict)
print("梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_sgd_predict))
# 岭回归进行实例".
rd = Ridge(alpha=1)
# 梯度下降进行房价预测 实例化
rd = SGDRegressor()
rd.fit(x_train, y_train)
# 打印权重参数
print(rd.coef_)
# 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
y_rd_predict = std_y.inverse_transform(rd.predict(x_test))
print("梯度下降测试集里面每个房子样本的预测价格：", y_rd_predict)
print("梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_rd_predict))
return None
if __name__ == "__main__":
mylinear()
分析：影响房子的价格因素：小区犯罪率，空气好坏等等，得出13个权重
目的：求出这13个权重
需要做标准化处理的算法：
k-近邻
线性回归
流程：
1、获取数据
2、数据分割
3、训练与测试集，数据标准化处理（重点）
为什么要标准化？
因为建立过程，权重和特征都会有影响。数据特征越大影响越大，所以需要做标准化处理# 进行标准化处理(?)目标值是否需要标准化处理？要，标准化处理的结果是所有数据都变得非常非常小
特征值和目标值都必须进行标准化处理，要处理两个，所以要实例化两个标准化的API
4、使用最简单的线性回归模型LinearReggression 和梯度下降估计SGDRegressor对房价进行预测
19版本要求标准化API转换器，estimator必须是二维的
# 19版本需要用reshape转化成数组或矩阵的形式 .reshape(-1),,,-1是默认值
y_train = std_y.fit_transform(y_train.reshape(-1, 1))
y_test = std_y.transform(y_test.reshape(1, -1))
(二)
回归性能评估：均方误差，与差值余真实值之间差值的平安和求一个平均值
API：mean_squared_error(y_true,y_pred)
y_true：真实值
y_pred：预测值
return：浮点数结果
------------------------------- ---------------对比--------------------------------------------------------
梯度下降 | 正规方程
需要选择学习率a | 不需要
需要多次迭代 | 一次运算出
当特征数量n大是也能很好的使用 | 需要计算很多东西东西东西
适用于各种类型的模型 | 只适用于线性模型，不适用逻辑回归模型等其他模型小规模数据LinearRegression 大规模数据：SGDRegressor
(三)
过拟合（模型过于复杂） 与 欠拟合（模型过于简单）
解决办法：
根据结果现象来判断：
比较：交叉验证训练集的结果，网格搜索
欠拟合：测试集，交叉验证，训练集的结果表现不写
过拟合：交叉验证99%，但在测试集就是89%，表现越来越差
欠拟合：增加数据过拟合：在训练的时候学不到什么东西，但是在测试集的时候还是。
1、特征选择（消除一些没用的删掉）
2、交叉训练（让所有数据都有结果训练）：实际无效果
3、正则化
特征选择：
1、嵌入式 重点
2、包裹时
3、过滤式 低方差特征
4、正则化
5、神经网络
6、决策树
线性回归：LinearRegression 容易出现过拟合 因为在训练的过程中伪类把训练集的数据表现更好。
对线性和非线性都可以去拟合
对于非线性去拟合最容易出现复杂模型
问题？训练数据训练的很好啊，误差也不大，为什么测试集上面有问题呢？ 对线性模型模型训练会变成复杂模型
（岭回归）通过回归解决过拟合：
线性回归LinearRegression 容易出现过拟合，为了把训练集数据表现根号L2正则化： 岭回归 带有正则化的西安新回归 解决过拟合
API： sklearn.linear_model.Ridge(alpha=1.0)
具有L2 正则化的闲心最小二乘法把二次项的系数趋近于0
Ridge：
alpha：正则化力度
coef_：回归系数
岭回归：正则化，把高次项系数不断趋近于0
总结：
岭回归LinearRession 与Ridge对比
岭回归与闲心回归的比较一定要在数据中才能体现出来
具有L2 正则化的闲心最小二乘法把二次项的系数趋近于0
岭回归得到的回归系数更符合实际。林外，能让估计参数的波动更稳定，变化小，又有实用价值
第二天总结： 思维导图存于桌面机器学习文件夹里面
（一）
模型的保存与加载
API： from sklearn.externals.import joblib
joblib 模块保存： joblib.dump(rf, 'test.pkl')
加载：estimator = joblib.load('test.okl')
ps:sklearn里面固定保存的文件格式
（二）逻辑回归
1、线性回归的输入------>分类问题 （逻辑回归）
2、sigmoid函数 （要求计入其样子）
值为 0-1 之间（具体的概率值）
3、
逻辑回归的损失： 信息熵越小预测越准确，100%确定，信息熵为0
梯度下降求解：损失函数的最低点
损失函数：均方误差（不存在局部最低点）只有一个最小值
对数似然损失：
方法：使用梯度下降关系
梯度下降求解：
1、多次随机初始化，多次比较最小值结果
2、求解过程当中，调整学习率
（尽量改善，但不能解决最终问题）
尽管没有全局最低点，但效果哦还是不错的
正规方程与梯度下降的对比？
逻辑回归API：
sklearn.linear_model.LogisticRegression(penalty='12',c=1.0)
Logistic 回归分类器
coef_:回归系数
逻辑回归案例：
良性、恶性乳腺癌肿瘤
数据描述：699个氧泵，一共11列数组，第一列用语言检索id，后9列分别是与肿瘤相关的医学特征
from sklearn.datasets import load_boston
from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge, LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, classification_report
from sklearn.externals import joblib
import pandas as pd
import numpy as np
def mylinear():
"""
线性回归两种预测房子价格
:return: None
"""
# 获取数据
lb = load_boston()
# 分割数据到训练集和测试集 data训练值 target 测试纸
x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target, test_size=0.25)
# 输出的是目标值的训练集和测试集，不是测试值的训练集和测试集
print(y_train,y_test)
# 进行标准化处理(?)目标值是否需要标准化处理？要，标准化处理的结果是所有数据都变得非常非常小权重也小。所以更原来的比起来就小监理损失求解
# inverse_transform 转化成之前的值
# 特征值和目标值都必须进行标准化处理，要处理两个，所以要实例化两个标准化的API
# 标准化测试值
std_x = StandardScaler()
x_train = std_x.fit_transform(x_train)
x_test = std_x.transform(x_test)
# 标准化目标值
std_y = StandardScaler()
# 19版本需要用reshape转化成数组或矩阵的形式 .reshape(-1),,,-1是默认值
y_train = std_y.fit_transform(y_train.reshape(-1, 1))
y_test = std_y.transform(y_test.reshape(1, -1))
# estimator预测
# 正规方程求解方式预测结果 训练数据
lr = LinearRegression()
lr.fit(x_train, y_train)
# 打印权重参数
print(lr.coef_)
# 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
y_lr_predict = std_y.inverse_transform(lr.predict(x_test))
print("测试集里面每个房子样本的预测价格：", y_lr_predict)
print("正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_lr_predict))
# 梯度下降进行房价预测 实例化
sgd = SGDRegressor()
sgd.fit(x_train, y_train)
# 打印权重参数
print(sgd.coef_)
# 保存训练好的模型
joblib.dump(lr, "./temp/test.pkl")
# 预测房价的价格
model = joblib.load("./temp/test.pkl")
y_predict = std_y.inverse_transform(model.predict_test)
print("保存的模型预测结果：", y_predict)
# 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))
print("梯度下降测试集里面每个房子样本的预测价格：", y_sgd_predict)
print("梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_sgd_predict))
# 岭回归进行实例".
rd = Ridge(alpha=1)
# 梯度下降进行房价预测 实例化
rd = SGDRegressor()
rd.fit(x_train, y_train)
# 打印权重参数
print(rd.coef_)
# 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
y_rd_predict = std_y.inverse_transform(rd.predict(x_test))
print("梯度下降测试集里面每个房子样本的预测价格：", y_rd_predict)
print("梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_rd_predict))
return None
def logistic():
"""
逻辑回归左细胞分类的预测
:return:
"""
# pd.merge( )
# 构造列明标签名字，
column = ['time_date','street','direction','car1','car2']
#以下的数据可能有误差
data = pd.read_csv("/Users/wusibin/Downloads/热身赛数据/01-12/chongzhi_beier-east-01-12.csv",names=column)
# data = pd.read_csv("https://archive.ics.uic.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data",names=column)
print(data)
# 缺失值进行处理 缺失值是？号，替换？号 替换成np.nan
data.replace(to_replace='?', value=np.nan)
# 删除空缺值
data = data.dropna()
# 进行数据的分割 评判 找特征值
x_train,x_test,y_train,y_test = train_test_split(data[column[1:10]],data[column[10]],test_size=0.25)
# 进行标准化处理
std = StandardScaler()
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)
# 逻辑回归预测
lg = LogisticRegression(C=1.0)
lg.fit(x_train, y_train)
y_preditc = lg.predict(x_test)
print(lg.coef_)
print("准确率：", lg.score(x_test,y_test))
print("召回率:", classification_report(y_test,y_preditc,labels =[2,4],target_names=["良性", "恶性"]))
return None
if __name__ == "__main__":
# mylinear()
logistic()流程：
1、网上获取数据（工具pandas）
2、数据缺失值的处理、标准化
3、LogisticRegression 估计器流程
pandas的使用：
pd.read_csv(",names=column_names")
类别的名字
column_names=['Sample code number','clump thichks','....','.......']
replace(to_place",value=):返回数据cv是代表交叉验证
总结逻辑回归：
只能解决二分类问题：
应用： 广告点击率预测，是否患病，金融诈骗，是否为虚假账号1、优点：适合需要得到一个分类概率的场景，建档，速度快
2、缺点：不好处理多分类问题
多分类问题：神经网络1、softmax方法-逻辑回归咋更多分类问题上的推广
生成模型和判别模型
逻辑回归 朴素贝叶斯
解决问题 二分类 文本分类
应用场景 癌症，二分类需要的概率 文本分类问题
参数 正则化力度 没有
得出的结果都有概率解释
判别模型：
判别模型的依据：
是否有先验概率：是否从历史依据中总结出来的概率信息
如果不需要总结就称之为判别模型
1、决策树，随机森林，神经网络，k-近邻 （先验概率）
2、隐马尔可夫模型
基本的分类和回归算法都已经完毕了
softmax方法逻辑回归在多分类问题上的推广---将在后面的神经网络算法中介绍
非监督学习算法：（聚类 k-means ）
1、没有目标值，只有特征值（不适用来预测）
2、把相近特征的数据归为一个类别（物以类聚，人以群分）
聚类：k把数据划分成多少个类别，
1、知道类别个数
2、不知道类别个数 超参数
k-means步骤：
举例：
1、k=3 在1000多个样本中取出三个样本，当做三个类别的中心点（ k1,k2,k3）
2、计算其余的点，分别到这三个中心点的举例（a,b,c）,每一个样本有三个距离，从中选出距离最近的一个点，作为自己的一个标记（形成了三个族群）//简单的聚类过程
3、分别计算这三个族群的平均值，把三个品均值与之前的三个旧中心点进行比较
绿1(x1,x2) 绿2(x2,x2) 平均值（x1平,x2平）
如果相同： 结束聚类
如果不相同：把这三个平均值单做新的中心点，重复第二步骤
k-means API 聚类
sklearn.cluster.KMeans(n_cluster=8,init='k-means++')k-means'聚类'
n_cluster:开始的聚类中心数量
init:初始化方法，默认为'k-means++'labels_:默认标记的类型，可以和真实值比较（不是值比较）
k-means对instacart Market用户聚类
1、降维之后的数据
2、k-means聚类
3、聚类结果显示
