机器学习——线性回归与决策树实验（附效果以及完整代码）（数据集、测试集开源）

已于 2022-04-26 22:21:55 修改
阅读量6.6k 收藏 56
点赞数 9
分类专栏： 学习笔记 文章标签： 机器学习 python
于 2022-04-11 00:00:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/freezing_00/article/details/124088650
版权

机器学习实验

实验名称：实验一、线性回归与决策树

一、实验目的

（1）掌握线性回归算法和决策树算法 ID3 的原理；
（2）学会线性回归算法和决策树算法 ID3 的实现和使用方法。

二、实验内容

本次实验为第一次实验，要求完成本次实验所有内容。具体实验内容如下：

1. 线性回归模型实验

（1）假设 line-ext.csv 是对变量 y 随变量 x 的变化情况的统计数据集。请根据教材的公式（3.7，3.8），使用 Python 语言编程计算线性回归模型的系数，建立一个线性回归模型。要求：
1）计算出回归系数，输出模型表达式，绘制散点图和回归直线，输出均方误差；
2）给出当自变量 x =0.8452 时，因变量 y 的预测值。

（2）对于上面的数据集 line-ext.csv，分别使用第三方模块 sklearn 模块中的类LinearRegression、第三方模块 statsmodels 中的函数ols()来计算线性回归模型的系数，建立线性回归模型，验证上面计算结果及预测结果。

2. 决策树算法实验

（1）隐形眼镜数据集 glass-lenses.txt 是著名的数据集。它包含了很多患者眼部状况的观察条件以及医生推荐的隐形眼镜类型。请使用Python 语言建立决策树模型 ID3，划分 25%的数据集作为测试数据集，并尝试进行后剪枝操作。要求 ：
1）使用 Graphviz 工具，将此决策树绘制出来；
2）输出混淆矩阵和准确率。

数据集的属性信息如下：
– 4 Attributes
\1. age of the patient: (1) young, (2) pre-presbyopic (for short, pre ), (3) presbyopic
\2. spectacle prescription: (1) myope, (2) hypermetrope (for short, hyper )
\3. astigmatic: (1) no, (2) yes
\4. tear production rate: (1) reduced, (2) normal
– 3 Classes
1 : the patient should be fitted with hard contact lenses,
2 : the patient should be fitted with soft contact lenses,
3 : the patient should not be fitted with contact lenses.

（2）对于数据集 glass-lenses.txt，使用 sklearn 模块中的类 DecisionTreeClassifier（其中，criterion=’entropy’）来建立决策树模型 ID3，重复 2（1）中的操作，验证上面计算结果。

三、实验代码和过程

①线性回归模型实验

（一）
1）计算出回归系数，输出模型表达式，绘制散点图和回归直线，输出均方误差；
1、读入数据集
# 从CSV文件中读取数据，并返回2个数组。分别是自变量x和因变量y。方便TF计算模型。
def zc_read_csv():
    zc_dataframe = pd.read_csv("line-ext.csv", sep=",")
    x = []
    y = []
    for zc_index in zc_dataframe.index:
        zc_row = zc_dataframe.loc[zc_index]
        x.append(zc_row["YearsExperience"])
        y.append(zc_row["Salary"])
    return (x,y)
x, y = zc_read_csv()
2、计算回归系数
averageX = 0
averageY = 0
for i in range (len(x)):
    averageX += x[i]
for i in range (len(y)):
    averageY += y[i]
#先计算平均数
averageX = averageX/(len(x))
averageY = averageY/(len(y))
#计算回归系数W
numerator = 0
denominator = 0
twice = 0
for i in range (len(x)):
    numerator+=(y[i]*(x[i]-averageX))
    twice += (x[i]*x[i])
    denominator +=x[i]
decominator = math.pow(denominator,2)/(len(x))
w = numerator/(twice-decominator)
b=0
for i in range (len(x)):
   b +=(y[i]-w*x[i])
b /= (len(x))
print("系数为",w)
print("偏置为",b)

在这里插入图片描述

3、输出模型表达式
s="模型表达式y="+repr(w)+"x+"+repr(b)
print(s)

在这里插入图片描述

4、绘制散点图和回归直线
# 获得画图对象。
fig = plt.figure()
fig.set_size_inches(20, 8)   # 整个绘图区域的宽度10和高度4
ax = fig.add_subplot(1, 2, 1)  # 整个绘图区分成一行两列，当前图是第一个。
# 画出原始数据的散点图。
ax.set_title("salary table")
ax.set_xlabel("YearsExperience")
ax.set_ylabel("Salary")
ax.scatter(x, y)
plt.plot([0,1],[3.0077432426975914,4.7030658848688107],c='green',ls='-')
plt.show()

在这里插入图片描述

5、输出均方误差
mse = 0
for i in range(len(x)):
    mse += ((x[i]*w+b)-y[i])*((x[i]*w+b)-y[i])
mse /= (len(x))
print("线性回归方程的均方误差：",mse)

在这里插入图片描述

2)给出当自变量 x =0.8452 时，因变量 y 的预测值。
predictY = 0.8542*w+b
print("预测值",predictY)

在这里插入图片描述

(二)
1）LinearRegression预测
from sklearn import linear_model
linearRegression = linear_model.LinearRegression()
arrayX = np.array(x)
arrayY = np.array(y)
xTest = (arrayX.reshape((len(arrayX)),-1))
yTest = (arrayY.reshape((len(arrayY)),-1))
linearRegression.fit(xTest,yTest)
print("系数：",linearRegression.coef_)
print("截距：",linearRegression.intercept_)

在这里插入图片描述

2)OLS拟合
import statsmodels.api as smf
ols = smf.OLS(y,x)
model = ols.fit()
print(model.summary())

在这里插入图片描述

②决策树实验

（一）
1）使用Python 语言建立决策树模型
1、载入转化数据函数
#载入转化数据
#young:0,pre:1,presbyopic:2
#myope:0,hyper:1
#yes:1,no:-1
#no lenses:0,soft:1,hard:2
dic={'young':0,'pre':1,'presbyopic':2,'myope':0,'hyper':1,'yes':1,'no':-1,'no lenses':0,'soft':1,'hard':2}
2、读入数据
import pandas as pd
#载入转化数据
#young:0,pre:1,presbyopic:2
#myope:0,hyper:1
#yes:1,no:-1
#reduced:1,nomal:-1
#no lenses:0,soft:1,hard:2
dic={'young':0, 'pre':1, 'presbyopic':2, 'myope':0, 'hyper':1, 'yes':1, 'no':-1, 'reduced':-1, 'normal':1, 'no lenses':0, 'soft':1, 'hard':2}
#转换函数
def convert(v):
    return dic[v]
def load_data(file):
    data = pd.read_csv(file,sep='\t', header=0, names=['age', 'spectacle', 'astigmatic', 'tear','class'],index_col=False)
    data = data.applymap(convert)
    return data
data = load_data('glass-lenses.txt')
print(data)

在这里插入图片描述

3、计算信息熵、条件信息熵、信息增益
import pandas as pd
import numpy as np
#载入转化数据
#young:0,pre:1,presbyopic:2
#myope:0,hyper:1
#yes:1,no:-1
#reduced:1,nomal:-1
#no lenses:0,soft:1,hard:2
dic={'young':0, 'pre':1, 'presbyopic':2, 'myope':0, 'hyper':1, 'yes':1, 'no':-1, 'reduced':-1, 'normal':1, 'no lenses':0, 'soft':1, 'hard':2}
#转换函数
def convert(v):
    return dic[v]
def load_data(file):
    data = pd.read_csv(file,sep='\t', header=0, names=['id','age', 'spect', 'astig', 'tear','class'],index_col='id')
    data = data.applymap(convert)
    return data
data = load_data('glass-lenses.txt')
# print(data)

# 数据集信息熵H(D)
def entropyOfData(D):
    nums = len(D)
    cate_data = D['class'].value_counts()
    cate_data = cate_data / nums # 类别及其概率
    # 计算数据集的熵
    return sum(- cate_data * np.log2(cate_data))

# 条件信息熵H(D|A)
def conditional_entropy(D, A):
    # 特征A的不同取值的概率
    nums = len(D) # 数据总数
    A_data = D[A].value_counts()# 特征A的取值及个数
    A_data = A_data / nums # 特征A的取值及其对应的概率
    # print(A_data)

    # 特征A=a的情况下，数据集的熵
    D_ik = D.groupby([A, 'class']).count().iloc[:, 0].reset_index() # Dik的大小
    D_i = D.groupby(A).count().iloc[:, 0] # Di的大小
    # print(D_ik)
    # print(D_i)

    # 给定特征A=a的情况下，数据集类别的概率
    D_ik['possibilities'] = D_ik.apply(lambda x: x[2]/D_i[x[0]], axis=1)
    # print(D_ik)
    # 给定特征A=a的情况下，数据集的熵
    entropy = D_ik.groupby(A)['possibilities'].apply(lambda x: sum(- x * np.log2(x)))
    # print(entropy)
    # 计算条件熵H(D|A)
    return sum(A_data * entropy)
# print(conditional_entropy(data, 'age'))
# 信息增益
def info_gain(D, A):
    return entropyOfData(D) - conditional_entropy(D, A)
# print(info_gain(data, 'age'))
4、选择最优特征属性
# 获得最优特征
def getOptiFeature(D):
    Max = -1
    Opti = ''
    for A in list(D)[:-1]:
        cur = info_gain(D, A)
        if Max < cur:
            Opti = A
            Max = cur
    return Opti, Max

# 选择最优特征
print(getOptiFeature(data))
5、划分数据集，构建决策树
def majorityCnt(classList):
    classCount = {}
    for vote in classList:  # 统计当前划分下每中情况的个数
        if vote not in classCount.keys():
            classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.items, key=operator.itemgetter(
        1), reversed=True)  # reversed=True表示由大到小排序
    # 对字典里的元素按照value值由大到小排序

    return sortedClassCount[0][0]

def createTree(dataSet, labels):
    classList = [example[-1]
                 for example in dataSet]  # 创建数组存放所有标签值,取dataSet里最后一列（结果）
    # 类别相同，停止划分
    # 判断classList里是否全是一类，count() 方法用于统计某个元素在列表中出现的次数
    if classList.count(classList[-1]) == len(classList):
        return classList[-1]  # 当全是一类时停止分割
    # 长度为1，返回出现次数最多的类别
    if len(classList[0]) == 1:  # 当没有更多特征时停止分割，即分到最后一个特征也没有把数据完全分开，就返回多数的那个结果
        return majorityCnt(classList)
    # 按照信息增益最高选取分类特征属性
    bestFeat = chooseBestFeatureToSplit(dataSet)  # 返回分类的特征序号,按照最大熵原则进行分类
    bestFeatLable = labels[bestFeat]  # 该特征的label, #存储分类特征的标签

    myTree = {bestFeatLable: {}}  # 构建树的字典
    del(labels[bestFeat])  # 从labels的list中删除该label

    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        # 子集合 ,将labels赋给sublabels，此时的labels已经删掉了用于分类的特征的标签
        subLables = labels[:]
        # 构建数据的子集合，并进行递归
        myTree[bestFeatLable][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLables)
    return myTree

def classify(inputTree, featLabels, testVec):
    firstStr = next(iter(inputTree))  # 根节点
    secondDict = inputTree[firstStr]
    featIndex = featLabels.index(firstStr)  # 根节点对应的属性
    classLabel = None
    for key in secondDict.keys():  # 对每个分支循环
        if testVec[featIndex] == key:  # 测试样本进入某个分支
            if type(secondDict[key]).__name__ == 'dict':  # 该分支不是叶子节点，递归
                classLabel = classify(secondDict[key], featLabels, testVec)
            else:  # 如果是叶子， 返回结果
                classLabel = secondDict[key]
    return classLabel
6、绘制决策树
if __name__ == '__main__':
    with open('glass-lenses.txt', 'r') as fr_train:  # 加载文件
        lenses_train = [inst.strip().split('\t') for inst in fr_train.readlines()]  # 处理文件
    lenses_target_train = []  # 提取每组数据的类别，保存在列表里
    for each in lenses_train:
        lenses_target_train.append(each[-1])

    lensesLabels_train = ['age', 'prescript', 'astigmatic', 'tearRate']  # 特征标签
    lenses_list_train = []  # 保存lenses数据的临时列表
    lenses_dict_train = {}  # 保存lenses数据的字典，用于生成pandas
    for each_label in lensesLabels_train:  # 提取信息，生成字典
        for each in lenses_train:
            lenses_list_train.append(each[lensesLabels_train.index(each_label)])
        lenses_dict_train[each_label] = lenses_list_train
        lenses_list_train = []
    #print(lenses_dict)  # 打印字典信息
    lenses_pd_train = pd.DataFrame(lenses_dict_train)  # 生成pandas.DataFrame
    #print(lenses_pd_train)
    le_train = preprocessing.LabelEncoder()  # 创建LabelEncoder()对象，用于序列化
    for col in lenses_pd_train.columns:  # 为每一列序列化
        lenses_pd_train[col] = le_train.fit_transform(lenses_pd_train[col])
    #print(lenses_pd_train)
    clf = tree.DecisionTreeClassifier(criterion='entropy',max_depth=4)  # 创建DecisionTreeClassifier()类
    clf = clf.fit(lenses_pd_train.values.tolist(), lenses_target_train)  # 使用数据，构建决策树
    print(clf)
    dot_data = StringIO()
    tree.export_graphviz(clf, out_file=dot_data,  # 绘制决策树
                         feature_names=lenses_pd_train.keys(),
                         class_names=clf.classes_,
                         filled=True, rounded=True,
                         special_characters=True)
    graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
    graph.write_pdf("tree.pdf")

在这里插入图片描述

2)输出混淆矩阵和准确率。

在这里插入图片描述

决策树完整代码

import pandas as pd
import seaborn as sn
import numpy as np
from sklearn import preprocessing
from sklearn import tree
from io import StringIO
import pydotplus
import math
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix

#载入转化数据
#young:0,pre:1,presbyopic:2
#myope:0,hyper:1
#yes:1,no:-1
#reduced:1,nomal:-1
#no lenses:0,soft:1,hard:2
dic={'young':0, 'pre':1, 'presbyopic':2, 'myope':0, 'hyper':1, 'yes':1, 'no':-1, 'reduced':-1, 'normal':1, 'no lenses':0, 'soft':1, 'hard':2}
#转换函数
def convert(v):
    return dic[v]
def load_data(file):
    data = pd.read_csv(file,sep='\t', header=0, names=['age', 'spect', 'astig', 'tear','class'])
    data = data.applymap(convert)
    return data
#print(data)
def calculateEnt(dataSet):  # 计算香农熵
    numEntries = len(dataSet)
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]  # 取得最后一列数据，该属性取值情况有多少个
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
    # 计算熵
    Ent = 0.0
    for key in labelCounts:
        prob = float(labelCounts[key])/numEntries
        Ent -= prob*math.log(prob, 2)

    return Ent

def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:  # 取大列表中的每个小列表
        if featVec[axis] == value:
            reduceFeatVec = featVec[:axis]
            reduceFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reduceFeatVec)

    return retDataSet  # 返回不含划分特征的子集

def chooseBestFeatureToSplit(dataSet):
    numFeature = len(dataSet[0]) - 1
    baseEntropy = calculateEnt(dataSet)
    bestInforGain = 0
    bestFeature = -1

    for i in range(numFeature):
        featList = [number[i] for number in dataSet]  # 得到某个特征下所有值（某列）
        uniquelVals = set(featList)  # set无重复的属性特征值，得到所有无重复的属性取值

        # 计算每个属性i的概论熵
        newEntropy = 0
        for value in uniquelVals:
            subDataSet = splitDataSet(
                dataSet, i, value)  # 得到i属性下取i属性为value时的集合
            prob = len(subDataSet)/float(len(dataSet))  # 每个属性取值为value时所占比重
            newEntropy += prob*calculateEnt(subDataSet)
        inforGain = baseEntropy - newEntropy  # 当前属性i的信息增益

        if inforGain > bestInforGain:
            bestInforGain = inforGain
            bestFeature = i

    return bestFeature  # 返回最大信息增益属性下标

def majorityCnt(classList):
    classCount = {}
    for vote in classList:  # 统计当前划分下每中情况的个数
        if vote not in classCount.keys():
            classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.items, key=operator.itemgetter(
        1), reversed=True)  # reversed=True表示由大到小排序
    # 对字典里的元素按照value值由大到小排序

    return sortedClassCount[0][0]

def createTree(dataSet, labels):
    classList = [example[-1]
                 for example in dataSet]  # 创建数组存放所有标签值,取dataSet里最后一列（结果）
    # 类别相同，停止划分
    # 判断classList里是否全是一类，count() 方法用于统计某个元素在列表中出现的次数
    if classList.count(classList[-1]) == len(classList):
        return classList[-1]  # 当全是一类时停止分割
    # 长度为1，返回出现次数最多的类别
    if len(classList[0]) == 1:  # 当没有更多特征时停止分割，即分到最后一个特征也没有把数据完全分开，就返回多数的那个结果
        return majorityCnt(classList)
    # 按照信息增益最高选取分类特征属性
    bestFeat = chooseBestFeatureToSplit(dataSet)  # 返回分类的特征序号,按照最大熵原则进行分类
    bestFeatLable = labels[bestFeat]  # 该特征的label, #存储分类特征的标签

    myTree = {bestFeatLable: {}}  # 构建树的字典
    del(labels[bestFeat])  # 从labels的list中删除该label

    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        # 子集合 ,将labels赋给sublabels，此时的labels已经删掉了用于分类的特征的标签
        subLables = labels[:]
        # 构建数据的子集合，并进行递归
        myTree[bestFeatLable][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLables)
    return myTree

def classify(inputTree, featLabels, testVec):
    firstStr = next(iter(inputTree))  # 根节点
    secondDict = inputTree[firstStr]
    print(secondDict)
    featIndex = featLabels.index(firstStr)  # 根节点对应的属性
    classLabel = None
    for key in secondDict.keys():  # 对每个分支循环
        if testVec[featIndex] == key:  # 测试样本进入某个分支
            if type(secondDict[key]).__name__ == 'dict':  # 该分支不是叶子节点，递归
                classLabel = classify(secondDict[key], featLabels, testVec)
            else:  # 如果是叶子， 返回结果
                classLabel = secondDict[key]
    return classLabel



if __name__ == '__main__':
    with open('glass-lenses.txt', 'r') as fr_train:  # 加载文件
        lenses_train = [inst.strip().split('\t') for inst in fr_train.readlines()]  # 处理文件
    lenses_target_train = []  # 提取每组数据的类别，保存在列表里
    for each in lenses_train:
        lenses_target_train.append(each[-1])
    lensesLabels_train = ['age','prescript','astigmatic','tearRate','class'] # 特征标签
    lenses_list_train = []  # 保存lenses数据的临时列表
    lenses_dict_train = {}  # 保存lenses数据的字典，用于生成pandas
    for each_label in lensesLabels_train:  # 提取信息，生成字典
        for each in lenses_train:
            lenses_list_train.append(each[lensesLabels_train.index(each_label)])
        lenses_dict_train[each_label] = lenses_list_train
        lenses_list_train = []
    #print(lenses_dict)  # 打印字典信息
    lenses_pd_train = pd.DataFrame(lenses_dict_train)  # 生成pandas.DataFrame
    #print(lenses_pd_train)
    le_train = preprocessing.LabelEncoder()  # 创建LabelEncoder()对象，用于序列化
    for col in lenses_pd_train.columns:  # 为每一列序列化
        lenses_pd_train[col] = le_train.fit_transform(lenses_pd_train[col])
    #print(lenses_pd_train)
    clf = tree.DecisionTreeClassifier(criterion='entropy',max_depth=4)  # 创建DecisionTreeClassifier()类
    clf = clf.fit(lenses_pd_train.values.tolist(), lenses_target_train)  # 使用数据，构建决策树
    print(clf)
    dot_data = StringIO()
    tree.export_graphviz(clf, out_file=dot_data,  # 绘制决策树
                         feature_names=lenses_pd_train.keys(),
                         class_names=clf.classes_,
                         filled=True, rounded=True,
                         special_characters=True)
    graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
    graph.write_pdf("tree.pdf")
#     fr = open('glass-lenses.txt')
#     trainData=[inst.strip().split('\t') for inst in fr.readlines()]
#     lensesLabels=['age','prescript','astigmatic','tearRate','class']
#     lensesTree=createTree(trainData,lensesLabels)

#     fr = open('Test.txt')
#     testData = [lenses.strip().split('\t') for lenses in fr.readlines()]
#     print(testData)
#     testResults = classify(lensesTree,lensesLabels,testData)
#     print(testResults)
    with open('Test.txt', 'r') as fr_test:  # 加载文件
        lenses_test = [inst.strip().split('\t') for inst in fr_test.readlines()]  # 处理文件
    lenses_target_test = []  # 提取每组数据的类别，保存在列表里
    for each in lenses_test:
        lenses_target_test.append(each[-1])
    lensesLabels_test = ['age', 'prescript', 'astigmatic', 'tearRate','class']  # 特征标签
    lenses_list_test = []  # 保存lenses数据的临时列表
    lenses_dict_test = {}  # 保存lenses数据的字典，用于生成pandas
    for each_label in lensesLabels_test:  # 提取信息，生成字典
        for each in lenses_test:
            lenses_list_test.append(each[lensesLabels_test.index(each_label)])
        lenses_dict_test[each_label] = lenses_list_test
        lenses_list_test = []
    #print(lenses_dict)  # 打印字典信息
    lenses_pd_test = pd.DataFrame(lenses_dict_test)  # 生成pandas.DataFrame
    #print(lenses_pd_test)
    le_test = preprocessing.LabelEncoder()  # 创建LabelEncoder()对象，用于序列化
    for col in lenses_pd_test.columns:  # 为每一列序列化
        lenses_pd_test[col] = le_test.fit_transform(lenses_pd_test[col])

    # print(clf.predict(lenses_pd_test))
    sn.set()
    f,ax=plt.subplots()
    y_true = ['no lenses','soft','soft','no lenses','no lenses','hard']
    y_pred = clf.predict(lenses_pd_test)
    C2=confusion_matrix(y_true,y_pred,labels=['no lenses','soft','hard'])
    # print(C2)
    sn.heatmap(C2,annot=True,ax=ax)
    ax.set_title('confusion_matrix')
    ax.set_xlabel('predict')
    ax.set_ylabel('true')
    plt.show()

数据集

测试集开源
数据集开源
数据集、测试集已经上传

freezing?
关注
  • 9
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 24
    评论
专栏目录
使用Sklearn中线性回归（LinearRegression）模型与决策树回归（DecisionTreeRegressor）模型解决身高预测问题
m0_59611146的博客
03-19 1683
综上比较，可知一般线性回归模型拟合较好，预测数据准确率高于决策树回归。统一数据，不同模型，预测效果不同，可尝试多种模型进行训练预测。线性回归假设特征与输出之间存在线性关系，并通过最小化残差平方和来拟合最优的参数。线性回归容易理解和实现，但要求特征与输出之间的关系是线性的。决策树回归基于树的叶节点上的均值或中位数来预测输出。决策树回归易于解释和理解，但容易过拟合。
机器学习 | 实验一：线性回归
知识库搭建ing
03-05 2869
机器学习 |实验一：线性回归，以指导书为基础。
机器学习实验（支持向量机SVM）
最新发布
m0_73160249的博客
06-11 757
支持向量机（Support Vector Machine, SVM）是一种广泛应用的监督学习算法，主要用于数据分类问题。它基于统计学习理论和结构风险最小化原则，通过找到一个决策超平面来最大化不同类别之间的间隔，以此来实现数据分类。
机器学习-线性回归实验
贰十二的博客
08-15 7151
机器学习线性回归用scikit-learn和pandas学习线性回归1. 获取数据，定义问题2. 整理数据3. 准备数据4. 训练数据5. 模型评价尝试用不同的线性模型进行训练交叉验证6. 画图观察结果7. python程序完整源代码 用scikit-learn和pandas学习线性回归 1. 获取数据，定义问题 我们用UCI大学公开的机器学习数据来跑线性回归。 数据的下载地址在这里：http://archive.ics.uci.edu/mi/machine-learning-databases/00294
决策树--分类树、回归树
Cupid_kl的博客
07-17 602
决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法的核心是要解决两个问题：1）如何从数据表中找出最佳节点和最佳分枝？2）如何让决策树停止生长，防止过拟合？例如数据集：目标是，将动物们分为哺乳类和非哺乳类。
【机器学习】Linear Regression Experiment 线性回归实验 + Python代码实现
热门推荐
知不足而奋进，望远山而前行
10-18 2万+
把数据变成(０，１)或者（1,1）之间的小数。主要是为了数据处理方便提出来的，把数据映射到0～1范围之内处理，更加便捷快速。归一化是一种简化计算的方式，即将有量纲的表达式，经过变换，化为无量纲的表达式，成为纯量。在机器学习中，我们可能要处理不同种类的资料，例如，音讯和图片上的像素值，这些资料可能是高维度的，资料标准化后会使每个特征中的数值平均变为0(将每个特征的值都减掉原始资料中该特征的平均)、标准差变为1，这个方法被广泛的使用在许多机器学习算法中(例如：支持向量机、逻辑回归和类神经网络)。
实验二：线性回归
Y2807593076的博客
10-08 3441
④梯度下降法的收敛速度取决于学习率的选择和损失函数的形状。观察预测结果的均方误差，我们可以得知使用梯度下降法求得的MSE还是在误差允许范围内的，所以我们使用梯度下降法所得到的三元线性回归方程的拟合度还是比较高的。观察预测结果的均方误差，我们可以得知使用矩阵求解法求得的MSE还是在误差允许范围内的，所以我们使用矩阵求解法所得到的三元线性回归方程的拟合度还是比较高的。3. 梯度下降法适用于各种规模的数据集和复杂的模型，只需要在每次迭代中计算样本的梯度，占用的内存较少，迭代过程可以减少异常值对参数更新的影响。
机器学习数据集，房价预测数据集，含使用百度飞桨重写的房价预测模型
03-11
1. 模型选择：常见的模型有线性回归、决策树、随机森林、梯度提升机（XGBoost）、支持向量机（SVM）以及深度学习模型如LSTM、GRU等。 2. 模型训练：使用训练集对模型进行训练，调整模型参数以最小化预测误差。 3. ...
r语言与机器学习，数据集
07-29
《机器学习与R语言》中包含的数据集可能涵盖了各种领域，例如：金融、医疗、社会学等，涉及分类、回归、聚类等多种问题。通过分析这些数据，读者可以学习如何清洗数据、处理缺失值、转换特征，以及如何选择合适的...
Python机器学习编程与实战，源代码，实验数据
06-07
Scikit-learn是Python中最常用的机器学习库，它包含了大量的监督和无监督学习算法，如线性回归、逻辑回归、决策树、随机森林、支持向量机、K近邻、聚类等。此外，Scikit-learn还提供了特征选择、模型选择、交叉验证...
机器学习xgboost svm 大肠杆菌启动子启动强度的预测完整代码数据可直接运行
06-14
首先，XGBoost是一种基于梯度提升决策树的高效开源库，它优化了计算效率并提供了强大的并行化处理能力。在这个项目中，XGBoost可能被用来构建一个预测模型，通过学习大量的特征，如DNA序列信息、序列结构等，来预测...
机器学习、深度学习、自然语言处理等人工智能基础知识总结以及源代码.zip
02-27
机器学习、深度学习、自然语言处理等人工智能基础知识总结以及源代码.zip 说明 机器学习、深度学习、自然语言处理基础知识总结。 目前主要参考李航老师的《统计学习方法》一书，也有一些内容例如XGBoost、聚类、...
机器学习实验六：聚类
magic171的博客
12-06 983
以上就是今天要讲的内容，机器学习实验六：聚类。
回归决策树的介绍
Despicable_Me的博客
05-27 3311
回归决策树（Regression Decision Tree）是一种决策树算法，用于解决回归问题。与传统的分类决策树不同，回归决策树的目标是预测连续数值型的输出，而不是离散的类别标签。数据集准备：首先，需要准备训练数据集，包括输入特征和对应的输出值。每个样本都有一组特征值和一个连续数值型的输出。特征选择：选择最佳的特征来划分数据集。常用的划分准则包括平方误差（Mean Squared Error, MSE）和平均绝对误差（Mean Absolute Error, MAE）等。
【学习机器学习】实验——线性模型实现
weixin_44151650的博客
05-22 3799
决策树前言一、实验目的二、实验内容1、导入数据2、划分训练集与测试集3、多元线性回归3.1 多元线性回归系数矩阵3.2 多元线性回归可视化3.3 测试集检验4、线性判别分析4.1 编写线性判别分析4.2 线性判别分析可视化4.3 测试集检验三、实验总结PS：对数几率回归 前言 上周五机器学习的实验课内容，由于图像处理占用了大量时间（即便现在还在研究），所以腾不出时间写博客了。而且机器学习部分的实验内容多数要求调用matlab自带函数，因此也没有什么可讲的变成部分。下面的部分，我直接使用了实验报告的内容。 一
Linear Regression 吴恩达机器学习实验一（线性回归）
m0_53547520的博客
10-07 1022
吴恩达机器学习实验；线性回归；
【机器学习】线性回归方程的模型构建实验设计
Q20011102的博客
11-15 641
机器学习，代码实现线性回归模型实验设计，利用读取csv文件
机器学习实验
あずにゃん梓喵的博客
08-16 1603
一、项目背景 【项目简介】 Azure Machine Learning（简称“AML”）是微软在其公有云Azure上推出的基于Web使用的一项机器学习服务，机器学习属人工智能的一个分支，它技术借助算法让电脑对大量流动数据集进行识别。这种方式能够通过历史数据来预测未来事件和行为，其实现方式明显优于传统的商业智能形式。微软的目标是简化使用机器学习的过程，以便于开发人员、业务分析师和数据科学家进行...
【机器学习】决策树实验报告
小汤圆的博客
08-14 1万+
前面我们已经知道了年龄和兴趣指数的取值范围，这里我们通过随机生成age和interest的方法进行了三组实验，每组实验测试10个数据，得到了如图6的结果。为了观察建立的决策树模型随测试集大小变化其分类准确率的变化情况，先初始选取了0.001大小的测试集，以0.05的步长依次增大测试集的大小，每次循环训练一个决策树模型；接着选取80%的数据作为训练集训练决策树模型，并将训练好的决策树模型可视化后得到如图3的决策树：树的高度为9，此时分类准确率为。首先读取数据，查看数据的基本信息，发现没有空缺值。......
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

freezing?

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值