目录

准备

特征工程：

scikit-learn介绍：

​

数据特征抽取：

热编码：适合类别型数据处理方式​

sklearn特征抽取API

字典特征抽取

 

文本特征抽取

TF_IDF(评估重要性):

数据特征预处理：

通过数学算法把数据转为算法要求的数据

归一化算法（原始分布情况不会改，数值减小了）

 

标准化 

缺失值处理：

数据降维：

数据类型：

算法分类 ：监督学习 和无监督学习

机器学习开发流程：

sklearn数据集与估计器

转换器估计器

 

分类算法-K近邻算法

K近邻算法实例

分类模型的评估

分类算法-朴素贝叶斯算法

朴素贝叶斯算法实例

模型的选择与调优

决策树与随机森林

 

 

---

准备

 

机器学习适合的数据：csv 

为什么？（mysql性能瓶颈） 2.格式不太符合机器学习要求数据类型

用到工具：numpy可以释放GIL锁  ，pandas读取工具

可用数据集：1.scikit-learn(提点：数据量小 2方便学习)   2 kaggle特点（数据量大，数据竞争平台，真实） 3.UCI(收录了360数据集 2.覆盖多个领域)

常用数据集数据的结构组成：特征值+目标值  样本的概念

数据中对特征的处理：scikit-learn  pandas

 

特征工程：

是什么：将原始数据转为更好的代表预测模型的潜在问题的特征的过程，从而提高了对未知数据的准确性

意义:直接影响预测结果

scikit-learn介绍：

 

数据特征抽取：

特征抽取案例：

结论 特征抽取时对文本等数据进行特征值化（方便让计算机去理解）

sparse矩阵 节约内存，方便读取处理

热编码：适合类别型数据处理方式

sklearn特征抽取API

from sklearn.feature_extraction import  DictVectorizer
from  sklearn.feature_extraction.text import CountVectorizer

字典特征抽取

from sklearn.feature_extraction import  DictVectorizer
di=DictVectorizer()
data=di.fit_transform(X=[{"头发":3,"升高":"180"},{"头发":7,"升高":"160"}]) 就拿到矩阵了
  (0, 1)	1.0
  (0, 2)	3.0
  (1, 0)	1.0
  (1, 2)	7.0

 

sklearn.feature_extraction  数据特征抽取API

DictVectorizer.fit_transform(X)  X>>>>> [{},{},{}] 返回>>>举证

DictVectorizer(sparse=True,) 默认返回矩阵 如果想要数组改为False

inverse_transform(X) X>数组或矩阵  转换之前数据格式
d.get_feature_names()#返回列表名称
d.transform() #按照原先的标转换

文本特征抽取

from  sklearn.feature_extraction.text import CountVectorizer
c=CountVectorizer()  #生成一个计文本特征抽取对象
data=c .fit_transform(["i like like laowang","i am find, thank"])  #解析文本返回元祖
    # (0, 10)	1
  # (0, 4)	1
  # (0, 2)	1
  # (0, 15)	2
  # (0, 16)	1
  # (1, 6)	1
# print(c.get_feature_names())  # 抽取的出文字名字列表 ['am', 'find', 'laowang', 'like', 'thank']
# print(cv.inverse_transform(x))  #返回转换之前数据格式  [array(['am'], dtype='<U7')]
# print(cv.get_feature_names) #得到抽取的名字列表

# print(data.toarray())  #转为数组 ，统计出现的次数，单个不统计 因为没有分类依据
# [[0 0 1 1 0]
#  [1 1 0 0 1]]




#对于中文来说如果要对一片文章的特征进行 需要用到空格隔开，但是太麻烦 此时可以用到jieba模块
然后再用空格拼接回去 拿到长的字符串

data=jieba.cut(con1)  自动抽取文档词汇 组成一个列表
data=“ ”.join(data)  
调用c.fit_taansform 文档抽取

TF_IDF(评估重要性):

""" 适合分类 :文本
解决不知道根据什么词汇作为主要词汇   用来评估一个词对文档的重要程度
如果在别的文章中也出现较多 可能说明这个词汇不重要  逆文档频率越低  统计总数/别的文章出现该词次数
TF  词的频率
IDF  逆文档频率
重要性=TF*IDF（出现的词汇的频率*逆文档频率）

from  sklearn.feature_extraction.text import  TfidfVectorizer
    c1, c2, c3 = cutword()
    c1 = "".join(c1)
    c2 = "".join(c2)
    c3 = "".join(c3)
    tfv=TfidfVectorizer()
    data=tfv.fit_transform([c1,c2,c3])
    print(len(tfv.get_feature_names()))
    print(tfv.get_feature_names())
    print(data.toarray())  #试点 出现的频率较高  0.60534851  如果增加别的文章出现的“试点”频率，这个值就会下降 
    #[[0.         0.         0.4305185  0.         0.4305185  0.
  #0.         0.         0.         0.4305185  0.         0.
  # 0.         0.         0.50854232 0.4305185  0.         0.        ]

================================================================================================

数据特征预处理：

接口：sklearn.preprocessing

通过数学算法把数据转为算法要求的数据

归一化算法（原始分布情况不会改，数值减小了）

主要是为了数据处理方便提出来的，把数据映射到0～1范围之内处理，更加便捷快速读取

比如查看魅力占分，取决于三个值，三个值同等重要。总不能按照原来数据进行计算。

缺点：如果数据不准确，例如最大值计算错误，会收到到异常的影响，此时需要标准化，这种只适合场景精确度小的场景。

标准差=（具体的特征值-这一列最小的值)/最大值-最小值


归一值 =标准差* （区间差  默认1 -0）+区间最大的值
原理 ：
X'=(x-min)/max-min  得到 X''=X’*（mx-mi）+mi
max为一列里的最大值，min为最小值，x''最终结果。
mx 区间最大值   mi区间最小

 

def  guiui():
    from sklearn.preprocessing import MinMaxScaler
    mm=MinMaxScaler()
    data2=mm.fit_transform([[5,4,2],[3,6,0],[7,1,1]])  #X为 二维数组 的列表  注：feature_range=(2,3)  默认0-1会影响最终结果
    print(data2)

 

标准化 

可以把数据转为均值为0，方差为1范围内

对于归一来说，出现异常点，结果会变

标准化，具有一定数据量，少量异常点影响较小

公式：
标准值：X‘=（x-均值）/标准差
标准差=根号(方差)
方差=（(x1-均值）^2+(x2-均值）^2）/n 样本个数  

from sklearn.preprocessing import StandardScaler
    import  numpy as np
    sds=StandardScaler()
    data=sds.fit_transform([[1,2,3],[4,5,6],[7,8,9]])
    print(sds.mean_) #原始数据的平均值
    print(sds.std_)  #原始数据的方差

 

缺失值处理：

思路：1.删除 达到一定要求比例 建议删除  2.插补 换成平均值 中数

可以用 numpy.replace 把一些错误数据变为nan

文件中有缺省，通过np.array转为fioa'转为数组即可

而在sklearn只需要通过接口，就可以把数据添上了

def queshizhi_chuli():
    """缺失值处理"""
    import  numpy as np
    from sklearn.preprocessing import  Imputer
    imp=Imputer(missing_values="NaN",strategy="mean",axis=0)
    data=imp.fit_transform([[1,2],[3,np.nan],[np.nan,6]])
    print(data)
    return None

 

数据降维：

这里指的是减少数据的特征的数量，但是不会减小数据的实际意义。数据降低了但是表达的意思不能少。

方式：特征选择  主成分分析

特征选择

选择部分特征作为训练特征，特征在选择后可以选择是否改变原值，但是维数一定减少

冗余：部分特征相关度高，容易消耗性能（不讲）

噪声：部分预测对与预测结果有影响 ，比如亚洲人统计皮肤颜色 ，但是亚洲人颜色又差不多

主要方法 过滤式Filter（过滤方差较小的）  Embedded(嵌入式) 正则化，决策树   Wrapper(包裹式)

过滤式，有一列数据可能方差小 没必要统计，那么我们就过滤掉

#设立过滤式方差阈值 多余的会被过滤
from sklearn.feature_selection import VarianceThreshold
    vt=VarianceThreshold(threshold=1.6)  #设置阀值,只保留方差在阀值以上的那一列
    data=vt.fit_transform ([[0,2,3,4],[4,5,2,1],[2,2,1,3]])
    print(data)

主成分分析：

高维度数据容易产生的问题:因为特征之间通常相关的，这些多余相关的数据可以不要

PCA:: 分析 简化数据集的技术 让数据压缩，在尽可能减少数据损害的情况下 减少数据维度为目的。

def zhuchengfeng_fengxi():
    '''主成分分析'
    PCA 是啥 分析 简化数据集的技术
    让数据压缩，为减少数据为目的，损失少量数据
    作用：可以削减回归分析或者聚类分析的数量
    '''
    from sklearn.decomposition import   PCA
    pca=PCA(n_components=0.99)  #n_components 小数的话为 保留百分之多少 整数的话 为减少几个维度
    data=pca.fit_transform(X=[[1,4,7,10],[2,5,8,11],[3,6,9,12]])
    print(data)  # 123  456 789  规律很显然 所以按照规律不要了
    return None

数据类型：

离散型数：所有数据都是int，不能再提高他们的精确度：如15000人，区间不可分

连续性数据：长度时间质量，区间可分

 

算法分类 ：监督学习 和无监督学习

有特征值+目标值------》有监督    有监督又分为

分类 ：有分类的，最基本二分类，眼睛，头发

回归 ：有连续的数据，如气温

只有特征值》》》无监督

===============================================================================================

机器学习开发流程：

算法是核心

准备数据：公司本身有的数据，合作过来的数据，购买的数据

1.明确老板想干啥  根据目标值划分重类  

2.数据预处理：pd 缺省 合并

3.特征进行处理 保留啊，归一化啊 文本啊

4.合适的算法进行预测，分类问题找分类算法，回归用回归

5.模型的评估   算法+数据

6.模型评估  最后上线使用 API 的形式提供

sklearn数据集与估计器

数据集划分 ：训练集 测试集 （全都为训练集，最后拿什么测，拿训练集测的话 不就百分百了？ 所以 75%作为训练，25%作为测试）

训练集集用来建立模型，测试集用来评估模型

API:

from sklearn.model_selection import train_test_split #进行数据分类

from sklearn.model_selection import  train_test_split  #进行数据分类
from sklearn.datasets import load_iris
li = load_iris()
x_train,x_test,y_train,y_test=train_test_split(li.data,li.target,test_size=0.25)
# 第一个参数为特征值训练的和测试的，第二个参数为目标值 训练的和测试的，test_size 测试值占比大小，比如 0.25
print(x_train)  #训练特征值
print("*"*120)
print(x_test)  #测试特征值
print("*" * 120)
print(y_train)  #训练目标值
print("*" * 120)
print(y_test)    #测试目标值

sklearn数据集接口

from sklearn.datasets import load_iris  #拿到小规模数据集 以load_ 开头，
数据已经在databases0了

from sklearn.datasets import fetch_20newsgroups  #拿到大规模数据集 
以fetch__ 开头
Fetch_20newsgroups(data_home=None)  #data_home数据集下载位置

sklearn回归数据集

    from sklearn.datasets import  load_iris
    li=load_iris()
    print(li.data) #[样本*特征值]    每一行为样本  列为特征值构成的二维数组   #这里有150 4列
    print(li.target) #目标值
    print(li.DESCR) #描述信息
    print(li.feature_names)  #特证值标题。注： 新闻数据，手写数据，回归数据集 没有此方法
    print(li.target_names)  #目标值标题

sklearn分类数据集

    from sklearn.datasets import  fetch_20newsgroups #没有的话会自动下在 可以指定目录
    new=fetch_20newsgroups(data_home="C:",subset="all") #train训练的 test测试的  all两个都
    print(new.data)
    print(new.target)  # 目标值
    print(new.DESCR)

    from sklearn.datasets import clear_data_home  # 清空目录下的数据
    clear_data_home(data_home=None)

 

转换器估计器

转换器：

我们之前其实实例化的是一个转换器，通过转换器的fit_transforms
自动计算得到矩阵 词频不能使用该方法


fit_transforms  输入数据直接转换


fit 输入数据计算 但是不转换


transform（）转换
注意 如果你fit了，如果再拿新的数据进行转换 肯定是和本意有区别的

 

估计器：是一类实现了算法的API

分类的估计器：sklearn.neighbors K近邻算法    
naive_bayes朴素贝叶斯  linear_model.logisticrege 逻辑回归，tree 决策数随机森岭

估计器：线性回归 岭回归

1.通过实例化转换器传入 训练的特征值，目标值 计算（fit）

然后通过估计器里的方法传入(测试特征值) 拿到目标值  （predic）

测试准确率

2 输入测试集的数据

 

分类算法-K近邻算法

与它最相似的数据作比较 最后推测出它的结果  通过算法实现

如果近邻数过小，那么极其容易受异常点影响，如果近邻数过大，结果不准确。

K近邻算法实例

from sklearn.model_selection import train_test_split
from sklearn.neighbors import  KNeighborsClassifier
time_value=pd.to_datetime(df["time"],unit="s")# 时间戳精确到秒
time_value=pd.DatetimeIndex(time_value)#把日期格式转换为字典格式

# 把日期格式提取出日时分
df["day"]=time_value.day
df["hour"]=time_value.hour
df["minute"]=time_value.minute
df.drop(["time"],axis=1)
#特征工程  进行一些数据清晰
place_count=df.groupby("place_id").count()  #根据事件 进行计数  得到DF
tf=place_count[place_count.row_id>3].reset_index()  #只保留row>3的行 再将索引加回去
df=df.drop(["row_id"], axis=1)
print(df)
data=df[df["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)
knn=KNeighborsClassifier(n_neighbors=5)
y_predict=knn.fit(x_train,y_train)  #把训练的加入
print("预测位置",y_predict)
print("准确率",knn.score(x_test,y_test))

 

分类算法-朴素贝叶斯算法

朴素贝叶斯原理
我可以根据每种类别的比重 进行分类（比如成人比例较大 我就是成人）

概率
一件事件发生的可能性
需要由数据说话 100天有3天晴天那么明天下雨的概率是 3% 不是说明天要么晴天要么雨天 概率就是50%

联合概率：

是XX并且xx的概率
P(A,B）=P(A)*P(B) A在数据中出现的概率*B在数据中出现的概率

条件概率：

就是事件A在 事件B 已经发生条件下的发生概率
在女神喜欢的条件下，职业是XX体重是XX的概率
记作P(产品，超重|喜欢)=P（产品|喜欢）*p(超重)

此条件成立必须是A1,A2相互不影响的结果

朴素贝叶斯 使用场景

特征独立（朴素）

一般用在文档分类比如
给一个文档求科技的类别
p(科技|文档) 》》把文档换成词

贝叶斯公式p(c/w)=[p(w/c)*pc]/p(w

朴素贝叶斯算法实例

 

有0对结果的影响

朴素贝叶斯算法受训练集影响特比大

from sklearn.model_selection import  train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.datasets import   fetch_20newsgroups
from sklearn.naive_bayes import MultinomialNB
all_new_Set=fetch_20newsgroups(subset="all")  #拿出所有的新闻数据集包裹特征值，目标值
x_tain,x_text,y_train,y_text=train_test_split(all_new_Set.data,all_new_Set.target,test_size=0.25) #
#对数据进行分割提取出 训练的特征值，训练的目标值，测试的特征，测试的目标

tf=TfidfVectorizer()#Tf_idf重要值评估
x_tain=tf.fit_transform(x_tain) #进行重要值评估并且转换
x_text=tf.transform(x_text)#对测试的特征也进行转换


mlt=MultinomialNB(alpha=1)#进行贝叶斯算法预测,拉普拉斯平滑设成1
mlt.fit(x_tain,y_train)  #建立模型计算 揉捻出预测的算法
#
y_caice=mlt.predict(x_text) #给测试集特征值，去推理最终结果



print("预测的目标值",y_caice)  #推测最终的目标值 
#
zhunquelv=mlt.score(x_text,y_text) # 得出分数
print("最终得分",zhunquelv)  #最终得分 0.8546264855687606

分类模型的评估

一般常用的是预测结果正确的百分比     

但是我们想看模型正列的准确率(想看能猜出癌症患者的个数占真实癌症患者的比例)

准确率 ：猜中的百分比

召回率：猜测的正列在实际中正列的比例

比如猜中15个是癌症患者/20个真实癌症患者 

精确率：真实的癌症患者/猜中的个数  （场景较少）

其他分类标准f1-score反应模型稳健性

from sklearn.metrics import classification_report
print(classification_report(y_text, y_caice,target_names=all_new_Set.target_names ))#真实目标，估计器预测目标，目标类别，返回精确率和召回率

交叉验证于网络搜索

原理：

交叉验证
把训练集右分一些出来作为验证集
所以数据分为N等分 1/4分  4折交叉验证
但是是交叉来验证
比如
验证 数据 数据 数据
数据 验证 数据 数据
。。。
。。。
所以最后预测结果可能不一样
最后求出平均结果

网络搜索：调参数

网格搜索:调参数
K-近零算法 超参数K 需要手动指定（又称网格搜索）

每组超参数都需要手动指定，手动复杂，所以需要对模型预设超参数组合
每组超参数都采用交叉验证来评估
最后选出最优的组合

有两个超参数怎么解决？-两两组合

API

from sklearn.model_selection import GridSearchCV

#构造参数进行搜索
param={"n_neighboors"=[1,3,10]}

#进行网络搜索
gc=GridSearchCV(knn,param_grid=param,cv=2)#指定几折交叉验证

gc.fit(x_train,y_train)

#计算准确率
gc.score(x_test,y_test) #测试集上得到准确率
gc.best_score_ 在交叉验证中求出最好的结果
gc.best_estimator_ 得到最好的模型
gc.cv_results  每个超参数每次交叉验证的结果
比如3,5,10  3，5，10  交叉两次的结果 ，3，3会得到一个平均值放在
mearn_test_score里面

 

模型的选择与调优

 

 

决策树与随机森林

原理

K近邻可以用网格搜索，但是参数少的情况下适用，那么参数特别多呢？
第三种分类算法 决策树 升级版本 随机森林
决策树原理 ：从上到下分析执行，就像if then一样   并且把最重要的先判断，可以减少不确定性

一个事件需要猜测5次 他的信息熵为5
公式前提预习：5bit=log32
5bit怎么来的 1/32log1/32   +1/32log1/32+1/32log1/32+.....取反 =-5

开放数据信息
信息熵：当32支球队夺冠概率相等，信息熵为5bit，
直到的情况下 信息熵就会比5bit小

信息熵越大，不确定越大
【信息】和【消除不确定性】是相关联的


哪个减少的信息熵的信息最多，把他当作第一个条件放在第一个
怎么划分决策树？把什么放在最前面？ 通过信息增益
怎么计算信息增益 g(d,a)=H(D)-H(D|A)  
H（d|A） 结果的信息商
翻译：a带来信息递增=初始信息熵大小-A带来的信息商大小  ？？？
比如 g(D,年龄)=初始值大小-H(D'|年龄)=总结果的信息熵-【青年比*年轻人的信息熵+...+老年比例*老年人信息熵】

怎么求A带来的信息熵？
筛选出青年看结果【能贷款成功】
H(青年)=-（2/5log(2/5)）

为什么我们在sklearn的标准选择gini 而不是信息递增entropy

因为gini划分更详细

API

例子

建立泰坦尼克号死亡率模型

API 截图
tanti事故分析
文件样本：截图
字段：“row.names”、“pclass”、“幸存”、“名称”、“年龄”、“开始”,“home.dest”、“空间”、“票”、“船”,“性”
文本url：http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt

 

如何将pd转为字典

代码

from sklearn.feature_extraction import DictVectorizer
from sklearn.model_selection import train_test_split
from sklearn.tree import  DecisionTreeClassifier
from sklearn.tree import export_graphviz
import  pandas as pd
import  numpy as np


pf=pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")
pf_x=pf[["pclass","age","sex"]] #提取特征值
pf_y=pf[["survived"]]#提取目标值
pf_x["age"].fillna(pf_x["age"].mean(),inplace=True) ]#缺失值处理


#数据划分
train_x,test_x,train_y,test_y=train_test_split(pf_x,pf_y,test_size=0.25)

dv=DictVectorizer(sparse=False)#矩阵关了

train_x=dv.fit_transform(train_x.to_dict(orient="records")) #特征值转换
test_x=dv.transform(test_x.to_dict(orient="records")) #特征值转换

fz_name=dv.get_feature_names()  
dtc=DecisionTreeClassifier()  
dtc.fit(train_x,train_y) #trre数进行计算
print("准确率",dtc.score(test_x,test_y)) #得分
export_graphviz(dtc,out_file="tree.dot",feature_names=fz_name) #转出dot
 

安装工具把dot转为pdf，png的工具 不能在虚拟环境安装 
然后我们把dat-Tpng tree.dot -o tree,png 
决策数如果更改深度的话 可能会影响到结果 (估计器里的max_depth)

https://convertio.co/zh/dot-png/ 或者直接使用这个网站

决策树优缺点 缺点

解决：
减枝 把分配较小的数据坎掉 ，防止有自己的枝叶
方案一：DecisionTreeClassifier（min_samples_split=2,min_samples__leaf=1 ）

方案二：随机森林

随机森林

什么是随机森林:一种继承学习方法利用多棵树对样本进行训练并预测的一种分类器，多个决策树  最后投票

单棵树学习过程：

1.在样本里拿一个样本，学习一次，再随机抽一个学习一次，重复N次（和样本一样）

2.随机再M个样本选出m个学习m<<M

采用bootstrap抽样

前一个案例分析

随机森林的过程优势

 

回归算法

回归算法-线性回归分析

回归：目标值连续 数据如225.35  

回归算法能做什么：只要你目标值是连续型的我都能预测 房价 销售额的预测
贷款额度的预测 （和能否贷款不一样，这个是能贷款多少）
也能把一个回归问题变为分类问题

比如一张图，我们预测房子的价格
曲线不好的话 就不好预测：后面分析

我们先考虑简单的问题

如直线，可能会有偏差
我们把图中的关系称之为 线性关系 ：二维：直线关系
两个因素影响房子因素 就不是二维问题而是三维

 

  
 

线性关系模型：

一个通过属性的线性组合来进行预测的函数

线性关系定义y=kx+b b:偏置 
为了使单个特征的情况更加通用

多个特征：
比如x1~xd都是我们的特征，那么我们只需要
权中*特征值 然后全部相加 最后+b 就是我们的线性函数
fx=w1*x1+w2*x2+...+b

自变量也可以特征值，因变量是目标值

多个h(w)

三个样本

a(三组特征)=[[1,2,3,4],[2,4,6,8],[3,6,9,12]]

b（4个权重）=[2,2,2,2]

就可以得到一个值

a(三组特征)=[[1,2,3,4],[2,4,6,8],[3,6,9,12]]

b（4个权重）=[2,2,2,2]
假设权重知道的情况
np.dot(a,b) 就可以拿到三个样本目标值

线性回归策略优化案例

我们用举证算出来的结果就是预测的结果
现在我们知道规律了，权重于预测的特征值想乘，得出预测结果
矩阵就是为了乘法运算上面
 

 

机器学习会误差，不能达到100%准确    

回归和神经网络有优化的空间（俗称迭代的算法）

回归算法知道自己有误差，也不断减少误差  （损失函数：见截图） 这个损失越小越好
比如权重也在不断该变

《统计学习方法》提了概念
算法           策略  （损失函数）        优化
线性回归        误差平方，最小二分法    见截图
  

如何求权重，使得损失最小，怎么找w

最小二分乘法之正规方程（不过不做要求）

转置*本身 的逆 再乘以X转置*目标

4个特征 拿到4个w

后面有数进来了 用这个w做运算

最小二分乘法之梯度下降（理解过程）
刚开始随机一个线性函数w
第二次学习的时候看是否有误差，在原有的基础上迭代优化，最终找到误差最小的w

我们以单变量的w0，w1为例子
w1,w2 

原始的值见去后面的结果得到新的w1 下次在w1的基础再迭代一次
下降的大小 称之为学习率

理解：
线性问题 》》有什么策略 误差平方和 和最小二乘法   优化 梯度下降

api

 

在sklearn 0.18版本中 二维一位都可以使用，但是0.19 转换器中的estimator必须是二维的

y_train.reshape(-1,1)

案例分析：

from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor,LinearRegression
from sklearn.model_selection import  train_test_split

def xx():
    l_b=load_boston()
    x_train,x_test,y_train,y_test=train_test_split(l_b.data,l_b.target,test_size=0.25)

    #因为有 k的关系 所以目标值也要归一化，归一化的转换必须不一样，所以用的是两个转换器
    std_x=StandardScaler()
    x_train=std_x.fit_transform(x_train)
    x_test=std_x.transform(x_test)

    std_y=StandardScaler()
    y_train = std_y.fit_transform(y_train.reshape(-1,1))
    y_test = std_y.transform(y_test.reshape(-1,1))

    lr=LinearRegression()
    lr.fit(x_train,y_train)
    # print(lr.coef_)
    yc_reg=lr.predict(x_test)#预测的数值
    yc_reg=std_y.inverse_transform(yc_reg) #转换会未归一化的数据
    print("测试机集预测的房子价格", yc_reg)

 

回归性能评估

from sklearn.metrics import mean_squared_error

print("您的估梯度模型评估得分:", mean_squared_error(std_y.inverse_transform(y_test), tzz_test))  # 估梯度下降

使用哪一个?

岭回归 带正则化

处理过拟合，欠拟合

出现的现象：为什么训练集挺好的，在测试集上就有问题呢

主要有两种情况：过拟合（特征过于复杂）欠拟合（特征不够）

欠拟合学到了2个特征，通过这两个特征 能匹配大多数结果 ，结果不准确

过拟合(训练不好，测试不好) 拿到了不必要的特征，大部分天鹅是白色，结果有黑天鹅 黑天鹅不算天鹅，结果不准确

欠拟合解决思路：增加特征

过拟合（训练很好，测试不好）：

1.特征选择

2.交叉验证，发现训练集交叉验证结果变得不行，测试机也不行，这种方法能检验出是否过拟合，无法解决

3.正则化，把一些过于复杂的曲线让他的权重趋近于0，正则化力度越来越大，权重越来越小

 

 

 

   

from sklearn.linear_model import Ridge

 

 

分类算法-逻辑回归

一般样本少    的为正例

适合二分类 这个分类的概率 另外一个分类的概率 【不好处理多分类】   

会出现和线性回归一样的问题：过拟合

from sklearn.linear_model import LogisticRegression

 

逻辑回归实例

聚类算法-kmeans

k-means实例

 

模型的保存

from sklearn.externals import joblib
joblib.dump("估计器","文件名")
估计器=joblib.load("文件名")