关于不同算法模型对比验证

  在学习算法模型的过程中,(这里的算法模型均指机器学习中的算法模型),总会被各式各样的算法模型所迷惑,明明是干同一件事情,干嘛要出那么多幺蛾子? 背后复杂的数学理论这里就不多阐述了, 有很多相关资料非常专业,这里只陈述一下个人在学习中的感悟, 肯定存在一些主观臆断,欢迎大神拍砖指点.

   这里主要针对分类问题,以机器学习中算法模型来进行分类在现实生活中应用场景相对比较多, 因此观点也针对这系列问题.这里引出逻辑回归, 支持向量机, 决策树, 多层感知器. 它们在监督学习上比较有代表性, 

    1.逻辑回归: 经典的线性分割, 是最简单的神经网络;

    2.支持向量机: 在集成学习,和深度学习火起来之前,是公认最好的模型, 通过核函数进行非线性的分割;

    3.决策树: 基于信息论的规则模型, 可解释性较强;

    4.多层感知器: 也叫经典神经网络, 是深度学习的基础.

   这里提出一个假设: 现实存在的某一项数据, 也可以叫作特征, 其是来自某分布的一个随机变量, 该变量来自总体.这里分布的假设就相当于赋予该随机变量一定的约束, 它的值不能无规律的选取. 其实也就是相当于在入模之前, 让特征本身有一定规律了.

   机器学习分类算法模型本身的目标就是针对很多特征, 在假设空间上寻找一个最优的划分. 而特征本身来自于不同的分布.那么对于线性模型来说,特征的参差不齐很容易在假设空间中造成线性不可分了.而对于非线性模型来说,它能对任何数据训练数据进行有效划分, 也就是对于非线性模型而言, 能学习拟合出任何数据模型.

    下面构造一组稠密矩阵和稀疏矩阵来进行分别以上述几种模型来进行实验:

代码如下:

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

x_data_1 = np.random.uniform(0, 1, (10000, 100))
x_data_2 = np.zeros((10000, 100))
i = 0
while True:
    x = np.random.randint(0, 10000)
    y = np.random.randint(0, 100)
    x_data_2[x, y] = 1
    i += 1
    if i > 5000:
        break
y_data = np.random.randint(0, 2, 10000)

# create training data
x_train_1, x_test_1, y_train_1, y_test_1 = train_test_split(x_data_1, y_data, test_size=0.3)
x_train_2, x_test_2, y_train_2, y_test_2 = train_test_split(x_data_2, y_data, test_size=0.3)

# ================linear model===============================================================
# fit lr model one
lr_1 = LogisticRegression(C=1000)
lr_1.fit(x_train_1, y_train_1)
y_pred_train_1 = lr_1.predict(x_train_1)
y_pred_test_1 = lr_1.predict(x_test_1)
print("lr train_1: ", accuracy_score(y_train_1, y_pred_train_1))
print("lr test_1:", accuracy_score(y_test_1, y_pred_test_1))
print("-"*20)
# fit lr model two
lr_2 = LogisticRegression(C=1000)
lr_2.fit(x_train_2, y_train_2)
y_pred_train_2 = lr_2.predict(x_train_2)
y_pred_test_2 = lr_2.predict(x_test_2)
print("lr train_2: ", accuracy_score(y_train_2, y_pred_train_2))
print("lr test_2: ", accuracy_score(y_test_2, y_pred_test_2))
print("="*20)
# ===============Nonlinear model==============================================================
svm_1 = SVC(C=1000)
svm_1.fit(x_train_1, y_train_1)
y_pred_train_1 = svm_1.predict(x_train_1)
y_pred_test_1 = svm_1.predict(x_test_1)
print("svm train_1: ", accuracy_score(y_train_1, y_pred_train_1))
print("svm test_1:", accuracy_score(y_test_1, y_pred_test_1))
print("-"*20)
# fit lr model two
svm_2 = SVC(C=1000)
svm_2.fit(x_train_2, y_train_2)
y_pred_train_2 = svm_2.predict(x_train_2)
y_pred_test_2 = svm_2.predict(x_test_2)
print("svm train_2: ", accuracy_score(y_train_2, y_pred_train_2))
print("svm test_2: ", accuracy_score(y_test_2, y_pred_test_2))
print("="*20)
# ===================================================================================
dtree_1 = DecisionTreeClassifier()
dtree_1.fit(x_train_1, y_train_1)
y_pred_train_1 = dtree_1.predict(x_train_1)
y_pred_test_1 = dtree_1.predict(x_test_1)
print("dtree train_1: ", accuracy_score(y_train_1, y_pred_train_1))
print("dtree test_1:", accuracy_score(y_test_1, y_pred_test_1))
print("-"*20)
# fit lr model two
dtree_2 = DecisionTreeClassifier()
dtree_2.fit(x_train_2, y_train_2)
y_pred_train_2 = dtree_2.predict(x_train_2)
y_pred_test_2 = dtree_2.predict(x_test_2)
print("dtree train_2: ", accuracy_score(y_train_2, y_pred_train_2))
print("dtree test_2: ", accuracy_score(y_test_2, y_pred_test_2))
print("="*20)
# ========================nn============================================================
net_1 = MLPClassifier(hidden_layer_sizes=(100, 100, 100, ))
net_1.fit(x_train_1, y_train_1)
y_pred_train_1 = net_1.predict(x_train_1)
y_pred_test_1 = net_1.predict(x_test_1)
print("net train_1: ", accuracy_score(y_train_1, y_pred_train_1))
print("net test_1:", accuracy_score(y_test_1, y_pred_test_1))
print("-"*20)
# fit lr model two
net_2 = MLPClassifier(hidden_layer_sizes=(100, 100, 100, ))
net_2.fit(x_train_2, y_train_2)
y_pred_train_2 = net_2.predict(x_train_2)
y_pred_test_2 = net_2.predict(x_test_2)
print("net train_2: ", accuracy_score(y_train_2, y_pred_train_2))
print("net test_2: ", accuracy_score(y_test_2, y_pred_test_2))
print("="*20)

   这里随机构造的数据,稠密数据自于均匀分布, 稀疏数据为随机构造的高稀疏矩阵, 模型测试结果如下:

lr train_1:  0.5458571428571428
lr test_1: 0.5043333333333333
--------------------
lr train_2:  0.5367142857142857
lr test_2:  0.4886666666666667
====================
svm train_1:  0.9864285714285714
svm test_1: 0.494
--------------------
svm train_2:  0.5432857142857143
svm test_2:  0.487
====================
dtree train_1:  1.0
dtree test_1: 0.5036666666666667
--------------------
dtree train_2:  0.5747142857142857
dtree test_2:  0.49266666666666664
====================
net train_1:  1.0
net test_1: 0.49433333333333335
--------------------
net train_2:  0.5747142857142857
net test_2:  0.49
====================

   标号1代表稠密矩阵, 标号2代表稀疏矩阵. 对于稠密数据而言, 线性模型的表现就是投掷硬币的问题,而非线性模型都表现出了超强的准确性, 这不难理解, 因为非线性模型有很强的学习能力, 能学习从数据中学习拟合出任何函数来.而对于高稀疏数据而言,大家的表现都是扔银币了,也不难理解,数据都不足,如何做判断? 

   这里可以类比人的认知,在领域范围内, 可以认知所有事物, 但是一旦与原有认知相悖的情况就难以做出准确的判断了. 但是人比较是高级生物, 可以不断的对大脑中的认知进行update.