机器学习综合代码（课堂题）

机器学习综合代码（课堂题）

 

 

字典特征抽取

经过字典特征抽取之后的数据为：

 [[ 0.  1.  0. 36.]

 [ 1.  0.  0. 40.]

 [ 0.  0.  1. 20.]]

表头 ['city=上海', 'city=北京', 'city=深圳', 'temperature']

 

from sklearn.feature_extraction import DictVectorizer  #导包

transfer=DictVectorizer()#实例化一个转换器对象，名字是transfer

data = [{"city":'北京','temperature':36},{"city":'上海','temperature':40},{"city":'深圳','temperature':20}]# 准备数据

data_new=transfer.fit_transform(data)#调用对象的fit—transform方法进行转化

print("经过字典特征转化数据集：\n",data_new.toarray())#打印输出转换后的结果

 

import csv

with open('/home/aistudio/work/test.csv') as f:

   a = [{k: (v) for k, v in row.items()}#将csv转列表序列

     for row in csv.DictReader(f, skipinitialspace=True)]

print(a)#打印转化后的结果

from sklearn.feature_extraction import DictVectorizer #导包

transfer=DictVectorizer()#实例化一个转换器对象，名字是transfer

a_new=transfer.fit_transform(a)#调用对象的fit—transform方法进行转化

print("经过字典特征转化数据集：\n",a_new.toarray())#打印输出转换后的结果

文本特征抽取（基于频次）

from sklearn.feature_extraction.text import CountVectorizer

data = ["life is short,i like like python", "life is too long,i dislike python"]

    # 1、实例化一个转换器类

transfer = CountVectorizer()

    # 2、调用fit_transform

data = transfer.fit_transform(data)

print("文本特征抽取的结果：\n", data.toarray())

print("返回特征名字：\n", transfer.get_feature_names())

 
文本特征抽取的结果：
 [[0 1 1 2 0 1 1 0]
 [1 1 1 0 1 1 0 1]]
返回特征名字：
 ['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']

from sklearn.feature_extraction.text import CountVectorizer

import jieba

def cut_word(text):

    # 用结巴对中文字符串进行分词

    text = " ".join(list(jieba.cut(text)))

    return text

data=["昨日因前日的熬夜，深感身体的疲倦，于是下班之后早早的就洗漱完毕，躺在床上，酝酿着睡意。"]

    # 将原始数据转换成分好词的形式

text_list = []

for sent in data:

    text_list.append(cut_word(sent))

    print(text_list)

    # 1、实例化一个转换器类

transfer = CountVectorizer()

    # 2、调用fit_transform

data = transfer.fit_transform(text_list)

print("文本特征抽取的结果：\n", data.toarray())

print("返回特征名字：\n", transfer.get_feature_names())

 
 
文本特征抽取的结果：
 [[1 0 1 0 0 1 0 0 0 0 0 1 0 0 0 1 0 0 1 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 0 1
  0 0 1 0]
 [0 1 1 1 0 0 0 0 1 0 0 0 1 0 1 0 0 1 0 1 1 0 1 1 0 0 0 1 0 0 1 0 0 1 1 0
  1 0 0 1]
 [0 0 0 0 1 0 1 2 1 1 1 0 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0
  0 1 0 0]]
返回特征名字：
 ['下班', '不知', '之后', '习惯', '事情', '于是', '催促', '先生', '入睡', '准备', '刷刷', '前日', '午夜', '吐槽', '告诉', '完毕', '尴尬', '已经', '床上', '恋恋不舍', '我们', '早早', '时分', '时间', '昨日', '洗漱', '深感', '熬夜', '疲倦', '睡意', '睡眠', '知觉', '种种', '等到', '自己', '身体', '还是', '遇见', '酝酿', '长大']

文本特征抽取（TFIDF）+特征预处理

from sklearn.feature_extraction.text import TfidfVectorizer

import jieba

def cut_word(text):

    # 用结巴对中文字符串进行分词

    text = " ".join(list(jieba.cut(text)))

    return text  

    #对中文进行特征抽取

data = ["昨日因前日的熬夜，深感身体的疲倦，于是下班之后早早的就洗漱完毕，躺在床上，酝酿着睡意。",

 "不知是长大之后的我们睡眠时间变少，还是已经习惯了熬夜，总要等到午夜时分才恋恋不舍的告诉自己该去入睡。"

 ,"刷刷剧，和曹先生吐槽遇见的种种尴尬事情，不知觉间又是午夜时分，在曹先生的催促下准备入睡。"]

    # 将原始数据转换成分好词的形式

text_list = []

for sent in data:

   text_list.append(cut_word(sent))

print(text_list)

    # 1、实例化一个转换器类

transfer = TfidfVectorizer(stop_words=['于是', '还是', '因'])

    # 2、调用fit_transform

data = transfer.fit_transform(text_list)

print("文本特征抽取的结果：\n", data.toarray())

print("返回特征名字：\n", transfer.get_feature_names())

用以评估一个词对于一个文件集或者一个语料库的其中一份文件的重要程度

 

[[0.27569246 0.         0.20967122 0.         0.         0.

  0.         0.         0.         0.         0.27569246 0.

  0.         0.         0.27569246 0.         0.         0.27569246

  0.         0.         0.27569246 0.         0.         0.27569246

  0.27569246 0.27569246 0.20967122 0.27569246 0.27569246 0.

  0.         0.         0.         0.         0.27569246 0.

  0.27569246 0.        ]

 [0.         0.26829814 0.20404765 0.26829814 0.         0.

  0.         0.20404765 0.         0.         0.         0.20404765

  0.         0.26829814 0.         0.         0.26829814 0.

  0.26829814 0.26829814 0.         0.20404765 0.26829814 0.

  0.         0.         0.20404765 0.         0.         0.26829814

  0.         0.         0.26829814 0.26829814 0.         0.

  0.         0.26829814]

 [0.         0.         0.         0.         0.26050857 0.26050857

  0.52101713 0.19812348 0.26050857 0.26050857 0.         0.19812348

  0.26050857 0.         0.         0.26050857 0.         0.

  0.         0.         0.         0.19812348 0.         0.

  0.         0.         0.         0.         0.         0.

  0.26050857 0.26050857 0.         0.         0.         0.26050857

  0.         0.        ]]

import numpy as np

a1=np.array([[90,56,8,1],

[60,60,5,2],

[75,49,7,3],

[30,50,0,1]])

data=a1[0:3,0:3]#矩阵分割三行三列

from sklearn.preprocessing import MinMaxScaler#StandardScaler

transfer=MinMaxScaler(feature_range=(0,1))

#归一化

#调用对象fit_transform

data_new=transfer.fit_transform(data)

print("lies,weight,games\n",data_new)

lies,weight,games

 [[1.         0.63636364 1.        ]

 [0.         1.         0.        ]

 [0.5        0.         0.66666667]]

import numpy as np

a1=np.array([[90,56,8,1],

[60,60,5,2],

[75,49,7,3],

[30,50,0,1]])

data=a1[0:3,0:3]#矩阵分割三行三列

from sklearn.preprocessing import StandardScaler

#标准化

transfer=StandardScaler()

#diaoyongduixiang fit_transform

data_new=transfer.fit_transform(data)

print("lies,weight,games\n",data_new)

lies,weight,games

 [[ 1.22474487  0.21997067  1.06904497]

 [-1.22474487  1.09985336 -1.33630621]

 [ 0.         -1.31982404  0.26726124]]

特征降维  

1、 低方差特征过滤 2、相关系数计算 3、PCA

2、 #导包

3、 from sklearn.feature_selection import VarianceThreshold

4、 import pandas as pd

5、 #读取数据

6、 data = pd.read_csv("/home/aistudio/work/factor_returns.csv")

7、 data = data.iloc[:,1:6]#1-5行索引

8、 transfer = VarianceThreshold(threshold=10) 初始化#VarianceThreshfold，指定阀值方差

9、     # 1、实例化一个转换器类

10、     #调用对象的fit_transform方法进行转换

11、     data_new = transfer.fit_transform(data)

12、     data_new.shape

13、      print("形状：\n", data.shape)

(2318, 5)

初始化VarianceThreshfold，指定阀值方差

调用fit_transform

相关系数

import pandas as pd

from scipy.stats import pearsonr

#导包

data = pd.read_csv("/home/aistudio/work/factor_returns.csv")

factor = ['pb_ratio','market_cap','return_on_asset_net_profit'  ,'du_return_on_equity','earnings_per_share','revenue','total_expense','return']

 #数据表格第一行特征（除data日期）

for i in range(len(factor)):

    for j in range(i,len(factor)-1):

        #for循环两两特征成对相关性

        print(

            "指标%s与指标%s之间的相关性大小为%f" %(factor[i], factor[j+1], pearsonr(data[factor[i]], data[factor[j + 1]])[0]))

#指标%s与指标%s之间的相关性大小

指标pb_ratio与指标market_cap之间的相关性大小为-0.004389

指标pb_ratio与指标return_on_asset_net_profit之间的相关性大小为-0.068863

指标pb_ratio与指标du_return_on_equity之间的相关性大小为-0.066009

指标pb_ratio与指标earnings_per_share之间的相关性大小为-0.046153

指标pb_ratio与指标revenue之间的相关性大小为-0.072082

指标pb_ratio与指标total_expense之间的相关性大小为-0.058689

指标pb_ratio与指标return之间的相关性大小为-0.025527

from sklearn.decomposition import PCA

#准备数据

data = [[2,8,4,5],[6,3,0,8],[5,4,9,1]]

transfer=PCA(n_components=0.95)

# 实例化PCA,指定降维到的维数小数：表示保留百分之多少的信息

     整数：减少到多少个特征

data_new=transfer.fit_transform(data)

print("主成分分析之后的结果为：",data_new)

# 调用fit_transform

主成分分析之后的结果为： [[ 1.28620952e-15  3.82970843e+00]

 [ 5.74456265e+00 -1.91485422e+00]

 [-5.74456265e+00 -1.91485422e+00]]

KNN

KNN 2、instarcart案例

import math

movie_data = {"cm": [3, 104, "爱情片"],

              "he": [2, 100,  "爱情片"],

              "bw": [1, 81, "爱情片"],

              "kl": [101, 10, "动作片"],

              "rs": [99, 5, "动作片"],

              "a2": [98, 2, "动作片"]}

# 测试样本，为求与数据集中所有数据的距离代码：

x = [18, 90]

KNN = []

for key, v in movie_data.items():

    d = math.sqrt((x[0] - v[0]) ** 2 + (x[1] - v[1]) ** 2 )

    KNN.append([key, round(d, 2)])# 求与数据集中所有数据的距离代码

#print(KNN)按照距离大小进行递增排序

KNN.sort(key=lambda dis: dis[1])

#选取距离最小的k个样本，这里取k=5；

KNN=KNN[:5]

print(KNN)

#确定前k个样本所在类别出现的频率，并输出出现频率最高的类别

labels = {"爱情片":0,"动作片":0}

for s in KNN:

    label = movie_data[s[0]]

    labels[label[2]] += 1

labels =sorted(labels.items(),key=lambda l: l[1],reverse=True)

print(labels,labels[0][0],sep='\n')

[['he', 18.87], ['bw', 19.24], ['cm', 20.52], ['kl', 115.28], ['rs', 117.41]]

[('爱情片', 3), ('动作片', 2)]

爱情片

 

import pandas as pd

from sklearn.decomposition import PCA

from sklearn.cluster import KMeans

from sklearn.metrics import silhouette_score

    # 1、获取数据

aisles = pd.read_csv("C:/Users/Admin/Desktop/instacart/aisles.csv")

order_products__prior = pd.read_csv("C:/Users/Admin/Desktop/instacart/order_products__prior.csv")

orders = pd.read_csv("C:/Users/Admin/Desktop/instacart/orders.csv")

products = pd.read_csv("C:/Users/Admin/Desktop/instacart/products.csv")

    # 2、合并表

table1 = pd.merge(order_products__prior, products, on=["product_id", "product_id"])

table2 = pd.merge(table1, orders, on=["order_id", "order_id"])

table = pd.merge(table2, aisles, on=["aisle_id", "aisle_id"])

table = pd.crosstab(table["user_id"], table["aisle"])

    # 3、交叉表处理，把user_id和aisle进行分组

    # 实例化一个转换器类PCA

table = table[:1000]

transfer = PCA(n_components=0.9)

data = transfer.fit_transform(table)

print(data)

# 4、主成分分析的方法进行降维

鸢尾花案例增加K值调优

 

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.neighbors import KNeighborsClassifier

from sklearn.model_selection import GridSearchCV

 

iris=load_iris()#获取属性数据

x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target)

#将原始数据集按照一定比例划分训练集和测试集对模型进行训练

transfer=StandardScaler()

x_train=transfer.fit_transform(x_train)

x_test=transfer.transform(x_test) #3 特征抽取：标准化

estimator=KNeighborsClassifier()
    #4 KNN算法预估器

#模型选择与调优API

param={"n_neighbors":[2,3,5,8,12,15,17]}#自定义数据

estimator=GridSearchCV(estimator,param_grid=param,cv=6)
    #加入网格搜索与交叉验证

estimator.fit(x_train,y_train)

#输出准确率

score=estimator.score(x_test,y_test)

#score

print("最佳的参数：",estimator.best_params_)

print("最佳的准确率：",estimator.best_score_)

print("最佳的预估器：",estimator.best_estimator_)

print("cv的交叉检测结果：\n",estimator.cv_results_)

最佳的参数： {'n_neighbors': 2}

最佳的准确率： 0.9732142857142857

最佳的预估器： KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',

           metric_params=None, n_jobs=None, n_neighbors=2, p=2,

           weights='uniform')

cv的交叉检测结果：

 {'mean_fit_time': array([0.00037992, 0.00035445, 0.00036168, 0.00035866, 0.00036192,

       0.00036709, 0.00036271]), 'std_fit_time': array([3.61592123e-05, 1.35533268e-05, 2.65123890e-05, 1.60265450e-05,

       1.38775179e-05, 1.59744402e-05, 1.26681334e-05]), 'mean_score_time': array([0.01317004, 0.00109971, 0.00109784, 0.0011305 , 0.00113698,

       0.00115188, 0.00120171]), 'std_score_time': array([2.70044483e-02, 1.16196958e-05, 1.06032998e-05, 2.26400031e-05,

       2.60863836e-05, 1.16716927e-05, 1.21671339e-04]), 'param_n_neighbors': masked_array(data=[2, 3, 5, 8, 12, 15, 17],

             mask=[False, False, False, False, False, False, False],

       fill_value='?',

Facebook案例

import pandas as pd

from sklearn.model_selection import train_test_split,GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.neighbors import KNeighborsClassifier

# 1、获取数据集

facebook = pd.read_csv('train.csv')

facebook_data = facebook.query("x>2 & x<2.5 & y>1.0 & y<1.5")   #范围的数据，使用query

# 2.2 选择时间特征

time = pd.to_datetime(facebook_data["time"], unit="s")  #

time = pd.DatetimeIndex(time)

facebook_data["day"] = time.day  #加一列day

facebook_data["hour"] = time.hour  #加一列hour

facebook_data["weekday"] = time.weekday   #加一列weekday

# 2.3 去掉签到较少的地方

place_count = facebook_data.groupby("place_id").count()   #分组聚类，按数目聚类

place_count = place_count[place_count["row_id"]>3]      

facebook_data = facebook_data[facebook_data["place_id"].isin(place_count.index)]   #传递数据

#facebook_data.shape()

# 2.4 确定特征值和目标值

x = facebook_data[["x", "y", "accuracy", "day", "hour", "weekday"]]  #特征值

y = facebook_data["place_id"]     #目标值

# 2.5 分割数据集

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

transfer = StandardScaler()

# 3.2 调用fit_transform

x_train = transfer.fit_transform(x_train)   #特征训练集

x_test = transfer.fit_transform(x_test)     #特征测试集

# 机器学习--knn+cv

estimator = KNeighborsClassifier()

# 4.2 调用gridsearchCV

param_grid = {"n_neighbors": [1, 3, 5, 7, 9]}

estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5)

# 模型训练

estimator.fit(x_train, y_train)

# 模型评估

score = estimator.score(x_test, y_test)

print("最后预测的准确率为:\n", score)

y_predict = estimator.predict(x_test)

print("最后的预测值为:\n", y_predict)

print("预测值和真实值的对比情况:\n", y_predict == y_test)

print("在交叉验证中验证的最好结果:\n", estimator.best_score_)

print("最好的参数模型:\n", estimator.best_estimator_)

print("每次交叉验证后的验证集准确率结果和训练集准确率结果:\n",estimator.cv_results_)

 

朴素贝叶斯

# 案例: sklearn 20类新闻分类

from sklearn.datasets import fetch_20newsgroups   # 20类新闻数据

from sklearn.model_selection import train_test_split   # 数据分割API

from sklearn.feature_extraction.text import TfidfVectorizer  # 特征抽取API

from sklearn.naive_bayes import MultinomialNB  # 朴素贝叶斯API

# 1.获取所有数据

news = fetch_20newsgroups(subset='all')

# 2.进行数据分割

x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, test_size=0.25) #分割

# 3.对数据集进行特征抽取

tf = TfidfVectorizer()

# 以训练集当中的词的列表进行每篇文章重要性统计

x_train = tf.fit_transform(x_train)

x_test = tf.transform(x_test)

# 4.进行朴素贝叶斯算法

bys = MultinomialNB(alpha=0.1)

bys.fit(x_train, y_train)

# 5.进行预测

y_predict = bys.predict(x_test)

print("预测的文章类别为：", y_predict)

print("准确率为：", bys.score(x_test, y_test))

print(x_test)

预测的文章类别为： [17 12  6 ...  7 17  8]

准确率为： 0.8991935483870968

  (0, 147684) 0.054933031214536535

  (0, 143913) 0.029475847939334707

  (0, 143536) 0.16141132909771103

  (0, 143160) 0.027980854825006313

  (0, 142689) 0.09799784002741448

  (0, 142447) 0.03380717366663775

  (0, 142244) 0.045458530278201785

 

　　即假定给定目标值时属性之间相互条件独立。也就是说没有哪个属性变量对于决策结果来说占有着较大的比重，也没有哪个属性变量对于决策结果占有着较小的比重。

虽然这个简化方式在一定程度上降低了贝叶斯分类算法的分类效果，但是在实际的应用场景中，极大地简化了贝叶斯方法的复杂性。

决策树

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.tree import export_graphviz

#决策树

iris=load_iris()

x=iris.data

y=iris.data

x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target) #2 划分数据集

#3 特征抽取

estimator=DecisionTreeClassifier(criterion="entropy")

estimator.fit(x_train,y_train)

# 模型评估

score=estimator.score(x_test,y_test)

print("准确率：\n",score)

export_graphviz(estimator,out_file='iris_tree_test.dot',feature_names=iris.feature_names)

 

泰坦尼克号数据决策树+随机森林

1、泰坦尼克号数据+决策树 2、泰坦尼克号数据+随机森林（包含交叉验证和网格搜索）

import pandas as pd

import numpy as np

from sklearn.feature_extraction import DictVectorizer

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier, export_graphviz

# 1、获取数据

titan = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")

x = titan[["pclass", "age", "sex"]]

y = titan["survived"]

# 缺失值需要处理，将特征当中有类别的这些特征进行字典特征抽取

x['age'].fillna(x['age'].mean(), inplace=True)

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

# 对于x转换成字典数据x.to_dict(orient="records")

# [{"pclass": "1st", "age": 29.00, "sex": "female"}, {}]

transfer = DictVectorizer(sparse=False)

x_train = transfer.fit_transform(x_train.to_dict(orient="records"))

x_test = transfer.fit_transform(x_test.to_dict(orient="records"))

# 4.机器学习(决策树)

estimator = DecisionTreeClassifier(criterion="entropy")

estimator.fit(x_train, y_train)

# 5.模型评估

estimator.score(x_test, y_test)

estimator.predict(x_test)

# 决策树的可视化名字可以用get来取

export_graphviz(estimator, out_file='./tree.dot', feature_names=transfer.get_feature_names())

#生成dot，见文件

 

#模型训练

from sklearn.tree import DecisionTreeClassifier

from sklearn.ensemble import RandomForestClassifier #随机森林

#gini

#[50,100,200,300,400,700]

#max_depth:[3,5,7,10,20]

estimator=RandomForestClassifier(n_estimators=200,criterion="entropy")

estimator.fit(x_train,y_train)

 

线性回归

1、正规方程优化损失函数 2、梯度下降优化损失函数

from sklearn.datasets import load_boston

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

boston=load_boston()

x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target)

estimator=LinearRegression(fit_intercept=True)

estimator.fit(x_train,y_train)

    #预估器

    #得出模型

print("正规方程权重系数：\n",estimator.coef_)

print("正规方程偏置：\n",estimator.intercept_)

#模型评估-均方误差

y_predict=estimator.predict(x_test)

error=mean_squared_error(y_test,y_predict)

print("正规方程均方误差：\n：",error)

正规方程权重系数：

 [-9.09718273e-02  5.27381166e-02  4.69779299e-02  2.64579753e+00

 -1.61292024e+01  3.16356788e+00  1.92130509e-02 -1.39875540e+00

  3.53666692e-01 -1.42541411e-02 -9.72477984e-01  9.42910189e-03

 -6.64947650e-01]

正规方程偏置：

 39.92144158361965

正规方程均方误差：

： 24.185798121837564

from sklearn.linear_model import SGDClassifier

from sklearn.datasets import load_boston

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

 

boston=load_boston()

x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target)

a=SGDClassifier(fit_intercept=True)#预估器

a.fit(x_train,y_train.astype(int))

print("梯度下降权重系数：\n",a.coef_)

print("梯度下降偏置：\n",a.intercept_)

#模型评估-均方误差

y_predict=a.predict(x_test)

error=mean_squared_error(y_test,y_predict)

print("梯度下降均方误差：\n：",error)

鲍鱼预测年龄

import pandas as pd

# 将数据矩阵随机划分训练集和测试集

from sklearn.model_selection import train_test_split

# 线性回归模型

from sklearn.linear_model import LinearRegression

from sklearn import model_selection

from sklearn import linear_model

# 评估模型准确率

from sklearn import metrics

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error

from sklearn.linear_model import SGDClassifier

target_url =  ("http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data")

## 数据集读取

abalone = pd.read_csv(target_url,header=None,prefix="V")

abalone.columns=['性别','长度','直径','高度','整体重量','肉重量','内脏重量','壳重','年龄']

print(abalone.head())

print(abalone.tail())

y = abalone["年龄"]

features_without_ones=['长度','直径','高度','整体重量','肉重量','内脏重量','壳重','年龄']

x= abalone[features_without_ones]

# 划分训练集和数据集

x_train,x_test,y_train,y_test = model_selection.train_test_split(x,y,test_size=0.2, random_state=111)

#特征工程：标准化

estimator=LinearRegression(fit_intercept=True)

estimator.fit(x_train,y_train)

print("正规方程权重系数：\n",estimator.coef_)

print("正规方程偏置：\n",estimator.intercept_)

#模型评估-均方误差

y_predict=estimator.predict(x_test)

error=mean_squared_error(y_test,y_predict)

print("正规方程均方误差：\n：",error)

a=SGDClassifier(fit_intercept=True)#预估器

a.fit(x_train,y_train.astype(int))

print("梯度下降权重系数：\n",a.coef_)

print("梯度下降偏置：\n",a.intercept_)

#模型评估-均方误差

y_predict=a.predict(x_test)

error=mean_squared_error(y_test,y_predict)

print("梯度下降均方误差：\n：",error)

#预测值

y_predict = estimator.predict(x_test)

print('预测值：\n',y_predict)

岭回归+逻辑回归

1、波士顿岭回归 2、癌症数据逻辑回归

from sklearn.datasets import load_boston

from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

# 加载数据波士顿数据集

boston = load_boston()

# 训练集，测试集拆分

X_train, X_test, y_train, y_test = train_test_split(

    boston.data, boston.target, test_size=0.25)

# 数据标准化处理

# 特征值标准化

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))

# 岭回归

ridge = Ridge()

ridge.fit(X_train, y_train)

print(ridge.coef_)

y_ridge_predict = std_y.inverse_transform(ridge.predict(X_test))

# 均方误差

ridge_mse = mean_squared_error(std_y.inverse_transform(y_test), y_ridge_predict)

print("岭回归均方误差：",ridge_mse)

[[-0.09382381  0.10584972 -0.00227478  0.07043118 -0.13744422  0.34302158

  -0.02474214 -0.29204187  0.21682143 -0.22316133 -0.20555426  0.0898064

  -0.36016803]]

岭回归均方误差： 47684.062130505896

癌症预测

import pandas as pd

import numpy as np

# 读取数据逻辑回归

path ='/home/aistudio/work/breast-cancer-wisconsin.data'

column_name = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',

               'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',

               'Normal Nucleoli', 'Mitoses', 'Class']

data = pd.read_csv(path,names=column_name)

data.head()

# 2.缺失值处理

data = data.replace(to_replace="?",value=np.nan)

# 缺失值处理（删除缺失样本）

data.dropna(inplace=True)

data.isnull().any()#不存在缺失值

# 3.划分数据集

# 4.特征工程：标准化

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import train_test_split

# 5.逻辑回归预估器

from sklearn.linear_model import LogisticRegression

# 筛选特征值和目标值

x = data.iloc[:,1:-1]

y = data["Class"]

x.head()

x_train,x_test,y_train,y_test = train_test_split(x,y)

transfer = StandardScaler()

x_train = transfer.fit_transform(x_train)

x_test = transfer.transform(x_test)

print(x_train)

estimator = LogisticRegression()

estimator.fit(x_train,y_train)

# 逻辑回归模型参数：回归系数和偏置

print(estimator.coef_)

print(estimator.intercept_)

# 6.模型评估

y_predict = estimator.predict(x_test)

# 方法一：直接比对真实值和预测值

print("y_predict:\n",y_predict)

print("直接比对真实值和预测值：\n",y_test==y_predict)

# 方法二：计算准确率

score = estimator.score(x_test,y_test)

print("准确率为：\n",score)

25      True

337     True

127     True

81      True

303     True

Name: Class, Length: 171, dtype: bool

准确率为：

 0.9649122807017544

              precision    recall  f1-score   support

 

          良性       1.00      0.95      0.97       117

          恶性       0.90      1.00      0.95        54

 

   micro avg       0.96      0.96      0.96       171

   macro avg       0.95      0.97      0.96       171

weighted avg       0.97      0.96      0.97       171

 

精确率+召回率+auc

1、精确率+召回率 2、AUC指标

import pandas as pd

import numpy as np

# 读取数据逻辑回归

path ='/home/aistudio/work/breast-cancer-wisconsin.data'

column_name = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',

               'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',

               'Normal Nucleoli', 'Mitoses', 'Class']

data = pd.read_csv(path,names=column_name)

data.head()

# 2.缺失值处理

data = data.replace(to_replace="?",value=np.nan)

# 缺失值处理（删除缺失样本）

data.dropna(inplace=True)

data.isnull().any()#不存在缺失值

# 3.划分数据集

# 4.特征工程：标准化

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import train_test_split

# 5.逻辑回归预估器

from sklearn.linear_model import LogisticRegression

# 筛选特征值和目标值

x = data.iloc[:,1:-1]

y = data["Class"]

x.head()

x_train,x_test,y_train,y_test = train_test_split(x,y)

transfer = StandardScaler()

x_train = transfer.fit_transform(x_train)

x_test = transfer.transform(x_test)

print(x_train)

estimator = LogisticRegression()

estimator.fit(x_train,y_train)

# 逻辑回归模型参数：回归系数和偏置

print(estimator.coef_)

print(estimator.intercept_)

# 6.模型评估

y_predict = estimator.predict(x_test)

# 计算准确率

score = estimator.score(x_test,y_test)

print("准确率为：\n",score)

#查看精确率、召回率、F1-score

from sklearn.metrics import classification_report

print(classification_report(y_test,estimator.predict(x_test),labels=[2,4],target_names=["良性","恶性"]))

#2代表良性，4代表恶性

#计算AUC指标

from sklearn.metrics import roc_auc_score

y_true=np.where(y_test>3,1,0)#将y_test中的2,4转换为0,1，因为计算AUC的API要求y_true是0（反例），1（正例）

#条件运算符

print("AUC的值:{}".format(roc_auc_score(y_true,estimator.predict(x_test))))#逻辑回归预测癌症分类的AUC指标

模型的保存和加载

from sklearn.linear_model import LogisticRegression

from sklearn.externals import joblib

estimator = LogisticRegression()

estimator.fit(x_train,y_train)#模型的保存和加载

joblib.dump(estimator,"/home/aistudio/work/mylogist.pkl")

K-means

流程分析：
        降维之后的数据
        1）预估器流程
        2）看结果
        3）模型评估

import pandas as pd

from sklearn.decomposition import PCA

from sklearn.cluster import KMeans

from sklearn.metrics import silhouette_score

# 读取四张表的数据

order_product = pd.read_csv("E:/QQ_Message/1179948633/FileRecv/instacart/instacart/order_products__prior.csv")

products = pd.read_csv("E:/QQ_Message/1179948633/FileRecv/instacart/instacart/products.csv")

orders = pd.read_csv("E:/QQ_Message/1179948633/FileRecv/instacart/instacart/orders.csv")

aisles = pd.read_csv("E:/QQ_Message/1179948633/FileRecv/instacart/instacart/aisles.csv")

# 合并四张表到一张表  （用户-物品类别）

table1 = pd.merge(order_product, products, on=["product_id", "product_id"])

table2 = pd.merge(table1, orders, on=["order_id", "order_id"])

table = pd.merge(table2, aisles, on=["aisle_id", "aisle_id"])

table = pd.crosstab(table["user_id"], table["aisle"])

# 交叉表（特殊的分组工具）

table=table[:1000]

transfer = PCA(n_components=0.9)

data = transfer.fit_transform(table)

estimator = KMeans(n_clusters=8, random_state=22)

estimator.fit_predict(data)

y_predict=estimator.predict(data)

y_predict[:300]
silhouette_score(data, y_predict)
  • 计算聚类中心并预测每个样本属于哪个类别,相当于先调用fit(x),然后再调用predict(x)

 

概况知识

特征工程{抽取{字典、文本{词频、TF-IDF中文文本特征抽象—分词}

预处理{归一化（填空题-公式）、标准化

降维{低方差特征过滤（设置方差阈值）、相关系数取值范围-1到1、pca主成分（小数与整数）小数：表示保留百分之多少的信息

     整数：减少到多少个特征

算法{有监督学习：分类KNN、朴素贝叶斯、决策树（信息增益决定先后顺序）、随机森林、逻辑回归（signmoid）

                回归：线性回归(损失函数：最小二乘、岭回归 

        无监督学习：k-means

 

特征工程：1、导包2、实例化转化器3、fit transfer（）4、打印

算法：1、导包2、实例化预估器对象3、fit （）模型生成4、模型评估{分类评估：对比、score}回归{均方误差}k-means{轮廓系数

从数据中自动分析获得模型，并利用模型对未知数据进行预测

 

有监督学习：分类、回归：输入数据有特征有标签（目标值），即有标准答案。

无监督学习：聚类，输入数据有特征无标签（目标值），没有标准答案。

开发流程{获取数据：数据处理：特征工程：机器学习算法训练—模型：模型评估：应用：

 

线性回归的几个关键点：

• 建模快速简单，特别适用于要建模的关系不是非常复杂且数据量不大的情况。

• 有直观的理解和解释。

• 线性回归对异常值非常敏感。

logistic回归有哪些优缺点？
优点：
（1）训练速度较快，分类的时候，计算量仅仅只和特征的数目相关；
（2）简单易理解，模型的可解释性非常好，从特征的权重可以看到不同的特征对最后结果的影响；
（3）适合二分类问题，不需要缩放输入特征；
（4）内存资源占用小，因为只需要存储各个维度的特征值；

缺点：
（1）不能用Logistic回归去解决非线性问题，因为Logistic的决策面试线性的；
（2）对多重共线性数据较为敏感；
（3）很难处理数据不平衡的问题；
（4）准确率并不是很高，因为形式非常的简单(非常类似线性模型)，很难去拟合数据的真实分布；
（5）逻辑回归本身无法筛选特征，有时会用gbdt来筛选特征，然后再上逻辑回归

 

特征值-4个：花瓣长度、花瓣宽度、花萼长度、花萼宽度

目标值-3个：山鸢尾花(Iris Setosa)，变色鸢尾花(Iris Versicolor)，维吉尼亚鸢尾花(Iris Virginica)，实际实例数：150

sklearn.datasets.load_数据集名() 获取数据集
sklearn.datasets.fetch_数据集名() 获取大规模数据集

机器学习的一般数据集会划分为两个部分：

训练数据：用于训练，构建模型

测试数据：在模型评估阶段使用，用于评估模型是否有效

划分比例

训练集（70%-80%）（数据量大训练的结构可能要好一点）

测试集占20%-30%

数据集划分API

 sklearn.model_selection.train_test_split(*array,*operations)

训练集数据特征值x_train，测试集数据特征值x_test，训练集数据目标值y_train，测试集数据目标值

y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=22)


  1. # -*-  coding: utf-8 -*-
  2. from sklearn import datasets #导入方法类
  3.  
  4. iris = datasets.load_iris() #加载 iris 数据集
  5. iris_feature = iris.data #特征数据
  6. iris_target = iris.target #分类数据

 

One-hot编码

from sklearn.preprocessing import LabelBinarizer

encoder = LabelBinarizer()

one_hot = encoder.fit_transform(a)

稀疏矩阵（Sparse）

返回sparse矩阵（toarray方法将稀疏矩阵转换成二维数组）

预估器（estimator）- sklearn机器学习算法的实现

  1、用于分类的估计器：

         sklearn_neighbors      KNN算法

         sklearn_bayes      贝叶斯算法

         sklearn_linear_model.LogisticRegerssion       逻辑回归

         sklearn.tree     决策树与随机森林

 2、用于回归的估计器

  sklearn_linear_model.LinearRegerssion    线性回归

  sklearn_linear_model.Ridge    岭回归

3、用于无监督学习的估计器类

         sklearn_cluster.Kmeans  聚类

 

预估器(estimator)
            1 实例化一个estimator
            2 estimator.fit(x_train, y_train) 计算
                —— 调用完毕，模型生成
            3 模型评估：
                1）直接比对真实值和预测值
                    y_predict = estimator.predict(x_test)
                    y_test == y_predict
                2）计算准确率
                    accuracy = estimator.score(x_test, y_test)

KNN的定义：

如果一个样本在特征空间中的K个最相似（即特征空间中最邻近）的样本中大多数属于某一个类别，则该样本也属于这个类别。 K=1时：容易受异常值的影响。

结果：
                k 值取得过小，容易受到异常点的影响
                k 值取得过大，样本不均衡的影响


 K-近邻总结：


            优点：简单，易于理解，易于实现
            缺点：
                1）必须指定K值，K值选择不当则分类精度不能保证
                2）懒惰算法，对测试样本分类时的计算量大，内存开销大
            使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试

网格搜索：遍历参数组合，找到最优的参数

 

 

posted @ 2021-03-10 16:36  大鹅小子  阅读(143)  评论(0)    收藏  举报