机器学习

目录

准备

特征工程:

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介绍:

 

机器学习_第1张图片

数据特征抽取:

特征抽取案例:

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

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


热编码:适合类别型数据处理方式机器学习_第2张图片

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='

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

机器学习_第3张图片朴素贝叶斯算法实例

机器学习_第4张图片

机器学习_第5张图片

机器学习_第6张图片

 

有0对结果的影响

机器学习_第7张图片

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


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反应模型稳健性

机器学习_第8张图片

机器学习_第9张图片

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

机器学习_第10张图片

例子

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

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

 

机器学习_第11张图片

如何将pd转为字典

机器学习_第12张图片

代码


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/ 或者直接使用这个网站

决策树优缺点 缺点

机器学习_第13张图片

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

方案二:随机森林

随机森林

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

机器学习_第14张图片

单棵树学习过程:

1.在样本里拿一个样本,学习一次,再随机抽一个学习一次,重复N次(和样本一样)

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

采用bootstrap抽样

机器学习_第15张图片

前一个案例分析

机器学习_第16张图片

随机森林的过程优势

 

机器学习_第17张图片

回归算法

回归算法-线性回归分析

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

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

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

我们先考虑简单的问题

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

 

  
 

线性关系模型

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

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

机器学习_第18张图片

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

机器学习_第19张图片

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

多个h(w)

三个样本

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

b(4个权重)=[2,2,2,2]

就可以得到一个值

机器学习_第20张图片

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
机器学习_第21张图片

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

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

机器学习_第22张图片

4个特征 拿到4个w

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

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

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

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

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

机器学习_第23张图片

api

机器学习_第24张图片

 

在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))  # 估梯度下降

机器学习_第25张图片

使用哪一个?

机器学习_第26张图片

机器学习_第27张图片

岭回归 带正则化

处理过拟合,欠拟合

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

机器学习_第28张图片

主要有两种情况:过拟合(特征过于复杂)欠拟合(特征不够)

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

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

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

过拟合(训练很好,测试不好):

1.特征选择

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

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

 

机器学习_第29张图片

 

 

   

from sklearn.linear_model import Ridge

 

 

分类算法-逻辑回归

一般样本少    的为正例

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

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

from sklearn.linear_model import LogisticRegression

 

逻辑回归实例

聚类算法-kmeans

k-means实例

 

模型的保存

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

 

 

 

 

 

 

 

 

你可能感兴趣的:(python基础语法)