机器学习基本模型

1.

#********** Begin **********#

# 读取“银行贷款审批数据.xlsx”表，自变量为x1~x15，决策变量为y（1-同意贷款，0-不同意贷款）

# 其中x1~x6为数值变量，x7~x15为名义变量

# 请对x1~x6中存在的缺失值用均值策略填充，x7~x15用最频繁值策略填充

# 最后返回填充处理后的X（即x1~x15），以及决策变量Y(即y)

def return_values():

    import pandas as pd

    A=pd.read_excel('银行贷款审批数据.xlsx')

    A1=A.iloc[:,:6]

    A2=A.iloc[:,6:-1]

    from sklearn.impute import SimpleImputer

    import numpy as np

    imr = SimpleImputer(missing_values=np.nan,strategy='mean')

    imr.fit(A1)

    a1_1=imr.transform(A1)

    imr = SimpleImputer(missing_values=np.nan,strategy='most_frequent')

    imr.fit(A2)

    a2_1=imr.transform(A2)

    import numpy as np

    X=np.hstack((a1_1,a2_1))

    Y=A['y'].values

    return(X,Y)

   

#********** End **********#

2.

#在上一关的基础上，对自变量X中的数值变量（x1~x6）作均值-方差标准化处理

# 需要注意的是x7~x15名义变量不需要作标准化处理

# 返回结果X1，数据结构为数组形式

# X1中含有标准化后的x1~x6和未标准化的x7~x15

from sklearn.preprocessing import StandardScaler

def return_values():

    import numpy as np

    X=np.load('X.npy')

    scaler = StandardScaler()

    X1 = np.copy(X)

    X1[:, :6] = scaler.fit_transform(X[:, :6])

    return X1

3.

#********** Begin **********#

#在上一关基础，对经过缺失值填充、数值变量标准化后的数据集，取前600条记录作为训练数据，后90条记录作为测试数据

#构建支持向量机模型，返回计算结果模型准确率rv和预测准确率r

def return_values():

    import numpy as np

    from sklearn import svm

    X1=np.load('X1.npy') #经过缺失值填充、数值变量标准化后的数据集，numpy数组690*15

    Y=np.load('Y.npy')   #因变量，numpy数组，690个元素

    x1 = X1[:600,:]    

    y1 = Y[:600]

    x2 = X1[600:,:]    

    y2 = Y[600:]

    clf = svm.SVC(kernel='rbf')  

    clf.fit(x1, y1)

    rv=clf.score(x1, y1);

    R=clf.predict(x2)

    Z=R-y2

    r=len(Z[Z==0])/len(Z)

    #print("模型准确率: " + str(rv))

    #print("预测准确率：" + str(r))

    return(rv,r)

 

#********** End **********#

4.

#********** Begin **********#

#在上一关基础，对经过缺失值填充、数值变量标准化后的数据集，取前600条记录作为训练数据，后90条记录作为测试数据

#构逻辑回归模型，返回计算结果模型准确率rv和预测准确率r

def return_values():

    from sklearn.linear_model import LogisticRegression as LR

    import numpy as np

    import warnings

    # 忽略收敛警告

    warnings.filterwarnings("ignore")

    X1=np.load('X1.npy') #经过缺失值填充、数值变量标准化后的数据集，numpy数组690*15

    Y=np.load('Y.npy')   #因变量，numpy数组，690个元素

    x = X1[:600,:]    

    y = Y[:600]

    x1 = X1[600:,:]    

    y1 = Y[600:]

    lr = LR()  

    lr.fit(x,y)

    rv=lr.score(x,y)

    R=lr.predict(x1)

    Z=R-y1

    r=len(Z[Z==0])/len(Z)

    #print('模型准确率为：',r)

    #print('预测准确率为：',r)

    return(rv,r)

#********** End **********#

5.

#********** Begin **********#

#在上一关基础，对经过缺失值填充、数值变量标准化后的数据集，取前600条记录作为训练数据，后90条记录作为测试数据

#构建神经网络分类模型，返回计算结果模型准确率rv和预测准确率r

import warnings

from sklearn.exceptions import ConvergenceWarning

warnings.filterwarnings("ignore",category=ConvergenceWarning)

def return_values():

    import numpy as np

    X1=np.load('X1.npy') #经过缺失值填充、数值变量标准化后的数据集，numpy数组690*15

    Y=np.load('Y.npy')   #因变量，numpy数组，690个元素

    x=X1[:600,:]    

    y=Y[:600]

    x1=X1[600:,:]    

    y1=Y[600:]

    from sklearn.neural_network import MLPClassifier

    clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5,2),       random_state=0)

    clf.fit(x,y)

    rv=clf.score(x,y)

    R=clf.predict(x1)

    Z=R-y1

    r=len(Z[Z==0])/len(Z)

    return(rv,r)

   

#********** End **********#

6

#**********Begin**********#

#在发电场中电力输出（PE）与AT（温度）、V（压力）、AP（湿度）、RH（压强）有关，

# 相关测试数据见“发电场数据.xlsx”文件，请完成以下任务：

# 1)求出PE与AT、V、AP、RH之间的线性回归关系式系数向量,用列表b表示，其元素依次为常数项、对应变量系数

# 2)求出回归方程的拟合优度（判定系数），用变量r表示

# 3)今有某次测试数据AT=28.4、V=50.6、AP=1011.9、RH=80.54，试利用构建的线性回归模型预测其PE值

def return_values():

    import pandas as pd

    import numpy as np  

    from sklearn.linear_model import LinearRegression as LR  

    data=pd.read_excel('发电场数据.xlsx')

    x=data.iloc[:,0:4].values

    y=data.iloc[:,4].values

   

    lr = LR()    #创建线性回归模型类  

    lr.fit(x, y) #拟合  

    #判定系数

    r=lr.score(x,y)

    #系数

    c_x=lr.coef_    

    #常系数    

    c_b=lr.intercept_  

    b=[c_b,c_x[0],c_x[1],c_x[2],c_x[3]]

    #对数据进行预测

    x1=np.array([28.4,50.6,1011.9,80.54]).reshape(1,4)  

    PE=lr.predict(x1)  

 

    return(b,r,PE)

#**********End**********#

7.

# -*- coding: utf-8 -*-

#基于上一关的数据集，构建神经网络回归模型，返回计算结果模型准确率r，

#并针对测试数据AT=28.4、V=50.6、AP=1011.9、RH=80.54，预测其PE值。

def return_values():

    from sklearn.neural_network import MLPRegressor

    import numpy as np

    import pandas as pd

    data=pd.read_excel('发电场数据.xlsx')

    x=data.iloc[:,0:4].values

    y=data.iloc[:,4].values

    clf = MLPRegressor(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=8, random_state=1)

    clf.fit(x, y)

    r=clf.score(x,y)

    x1=np.array([28.4,50.6,1011.9,80.54]).reshape(1,4)

    PE=clf.predict(x1)

 

    return(r,PE)

8.

# -*- coding: utf-8 -*-

#基于上一关的数据集，构建支持向量机回归模型（采用线性核函数），返回计算结果模型的拟合优度r，

#并针对测试数据AT=28.4、V=50.6、AP=1011.9、RH=80.54，预测其PE值。

def return_values():

    import numpy as np

    import pandas as pd

    from sklearn import svm

    data=pd.read_excel('发电场数据.xlsx')

    x=data.iloc[:,0:4].values

    y=data.iloc[:,4].values

    kernel = ['linear','poly','rbf','sigmoid']

    list1 = [] #保存针对训练数据获得的模型准确度

    list2 = [] #保存预测值

    for i in kernel:

        clf = svm.SVR(kernel=i)

        clf.fit(x, y)

        x1 = np.array([28.4,50.6,1011.9,80.54]).reshape(1,4)

        list1.append(clf.score(x,y))

        list2.append(clf.predict(x1))

    result = {'核函数':kernel,'模型准确度':list1,'预测值':list2}

    result = pd.DataFrame(result)

    r=result['模型准确度'].max()

    PE=result['预测值'].min()

 

    return(r,PE)

9.

#********** Begin **********#

#读取“农村居民人均可支配收入来源2016.xlsx”数据表，其中数据来源于2016年《中国统计年鉴》，

#首先，对指标数据进行均值方差标准化处理

#其次，其次对标准化处理后的指标数据作主成分分析，要求提前累计贡献率在95%以上

#再次，基于提取的主成分计算综合得分，综合得分=提取的各主成分与对应贡献率之和

#最后，基于综合得分获得各地区的排名，得分按从高到低排序，用一个序列Rs来表示，其中index为地区名称，值为综合得分

def return_values():

    import pandas as pd

    from sklearn.preprocessing import StandardScaler

    from sklearn.decomposition import PCA  

    Data=pd.read_excel('农村居民人均可支配收入来源2016.xlsx')

    X=Data.iloc[:,1:]

    R=X.corr()

    scaler = StandardScaler()

    scaler.fit(X)

    X=scaler.transform(X)

    pca=PCA(n_components=0.95)

    pca.fit(X)

    Y=pca.transform(X)

    tzxl=pca.components_              

    tz=pca.explained_variance_          

    gxl=pca.explained_variance_ratio_    #返回主成分方差百分比（贡献率）

    for i in range(0,4):

        Y[i]=sum(X[i,:]*tzxl[0,:])

    F=gxl[0]*Y[:,0]+gxl[1]*Y[:,1]+gxl[2]*Y[:,2]  #综合得分=各个主成分×贡献率之和

    dq=list(Data['地区'].values)         #提取地区

    Rs=pd.Series(F,index=dq)             #以地区作为index,综合得分为值,构建序列

    Rs=Rs.sort_values(ascending=False) #按综合得分降序进行排序

   

    return Rs

#********** End **********#

10.

#********** Begin **********#

#读取“农村居民人均可支配收入来源2016.xlsx”数据表，数据来源于2016年《中国统计年鉴》，

# 首先，对指标数据作均值-方差标准化处理，注意首列为地区名称，不用标准化

# 其次，对标准化后的指标数据，作K-均值聚类分析（K=4），

# 最后，给出聚类分析结果，用一个序列Fs来表示，其中index为地区名称，值为所属类别的标签值（0、1、2、3）。

def return_values():

    #导入K-均值聚类模块KMeans。

    from sklearn.cluster import KMeans

    from sklearn.preprocessing import StandardScaler

    import pandas as pd

    import numpy as np

    Data=pd.read_excel('农村居民人均可支配收入来源2016.xlsx')

    X=Data.iloc[:,1:]

    #对X做均值-方差规范化处理

    scaler = StandardScaler()

    scaler.fit(X)

    X=scaler.transform(X)

    #利用KMeans创建K-均值聚类对象model。

    model = KMeans(n_clusters = 4, random_state=0, max_iter = 500)

    #调用model对象中的fit()方法进行拟合训练。

    model.fit(X)

    #获取model对象中的labels_属性，可以返回其聚类的标签。

    c=model.labels_#聚类结果

    jlzx = model.cluster_centers_#各个类的聚类中心

    Fs=pd.Series(c,index=Data['地区'])#地区

    return Fs

#********** End **********#

11.

#********** Begin **********#

##将以下超市的购买记录（已用一个"超市购买记录.txt"来存放，读取该文件即可）

##注意：文件内容存放与下列展示一致，即顿号分隔，“##”号不是文件内容，文件编码为utf-8）：

##  I1、西红柿、排骨、鸡蛋、毛巾、水果刀、苹果

##  I2、西红柿、茄子、水果刀、香蕉

##  I3、鸡蛋、袜子、毛巾、肥皂、苹果、水果刀

##  I4、西红柿、排骨、茄子、毛巾、水果刀

##  I5、西红柿、排骨、酸奶、苹果

##  I6、鸡蛋、茄子、酸奶、肥皂、苹果、香蕉

##  I7、排骨、鸡蛋、茄子、水果刀、苹果

##  I8、土豆、鸡蛋、袜子、香蕉、苹果、水果刀

##  I9、西红柿、排骨、鞋子、土豆、香蕉、苹果

## 将其转换为布尔数据集，其中数据集用数据框Data来表示，数据框中的字段名称即为商品名称，如果商品在某个购买记录中出现用1来表示，否则为0

def return_values():

    tiem=['西红柿','排骨','鸡蛋','茄子','袜子','酸奶','土豆','鞋子']#商品名称，也是数据框的字段名

    import pandas as pd

    import numpy as np

    data=pd.read_table('超市购买记录.txt',engine='python',sep='、',encoding = 'utf-8',header=None)

    data=data.iloc[:,1:]

    D=dict()

    for t in range(len(tiem)):

        z=np.zeros((len(data)))

        li=list()

        for k in range(len(data.iloc[0,:])):

            s=data.iloc[:,k]==tiem[t]

            li.extend(list(s[s.values==True].index))

        z[li]=1

        D.setdefault(tiem[t],z)

    Data=pd.DataFrame(D)  #布尔值数据表

    return Data

 

#********** End **********#

12.

#针对以下布尔数据集(已用一个“test12.xlsx”表格来存取，直接读取即可，字段名称为A、B、C，“#”号非表格数据):

#   A    B    C

#   1    1    0

#   0    1    1

#   1    0    0

#   1    1    1

#   1    1    1

#   1    0    0

#   1    1    1

#   0    1    1

#   1    0    0

#   1    1    1

#   1    1    0

#   1    1    1

#   1    1    0

##请编程计算规则“A->B”和“A,B->C”的支持度和置信度，分别用sp1和co1,sp2和co2来表示

def return_values():

    import pandas as pd

    # 读取数据

    data = pd.read_excel('test12.xlsx')

    # 计算指标

    total_records = len(data['A'])

    AB_records = len(data[(data['A'] == 1) & (data['B'] == 1)])

    ABC_records = len(data[(data['A'] == 1) & (data['B'] == 1) & (data['C'] == 1)])

    A_records = len(data[data['A'] == 1])

    AB_records = len(data[(data['A'] == 1) & (data['B'] == 1)])

    # 计算支持度和置信度

    sp1 = AB_records / total_records

    co1 = AB_records / A_records

    sp2 = ABC_records / total_records

    co2 = ABC_records / AB_records

   

    return (sp1,co1,sp2,co2)

 

    return (sp1,co1,sp2,co2)