评价类算法

最新推荐文章于 2023-09-06 16:50:43 发布
最新推荐文章于 2023-09-06 16:50:43 发布
阅读量3.8k 收藏 49
点赞数 5
分类专栏： 数学建模 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45927003/article/details/119282687
版权

本人建模小白。。。详细模型思路可参考《清风数学建模交流》坚持学习，加油!!!

优劣解距离法(TOPSIS)

(处理多方案打分的问题)（优点：数据多与少都可以分析，在系统数据资料较少和条件不满足统计要求的情况下，更具有实用性。
缺点：要求样本数据集具有时间序列特性，只是对评判对象的优劣做出鉴别,并不反映绝对水平，具有“相对评价”的全部缺点）

算法步骤:

      第一步: 将原始矩阵正向化

      第二步: 正向化矩阵标准化

      第三步: 计算得分并归一化

实战案例(清风视频)

题目:评价下表中20条河流的水质情况。
注：含氧量越高越好（极大型指标），PH值越接近7越好（中间型指标），细菌总数越少越好（极小型指标），植物性营养物量介于10~20之间最佳，超过20或低于10均不好(区间型指标)

河流含氧量PH 值细菌总数植物性营养物量
A4.696.595111.94
B2.037.86196.46
C9.116.31468.91
D8.617.054626.43
E7.136.505023.57
F2.396.773824.62
G7.696.79386.01
H9.306.812731.57
I5.457.62518.46
J6.197.27177.51
K7.937.5396.52
L4.407.281725.30
M7.468.242314.42
N2.015.554726.31
O2.046.402317.91
P7.736.145215.72
Q6.357.582529.46
R8.298.413912.02
S3.547.27543.16
T7.446.26828.41

python计算结果图
在这里插入图片描述

第一步: 将原始矩阵正向化

最常见的四种指标：

指标名称指标特点例子
极大型（效益型）指标 越大（多）越好成绩、GDP增速、企业利润
极小型（成本型）指标越小（少）越好费用、坏品率、污染程度
中间型指标越接近某个值越好水质量评估时的PH值
区间型指标落在某个区间最好体温、水中植物性营养物量

所谓的将原始矩阵正向化，就是要将所有的指标类型统一转化为极大型指标。（转化的函数形式可以不唯一）

1>极小型指标转化为极大型指标
在这里插入图片描述

2>中间型指标转化为极大型指标
在这里插入图片描述
3>区间型指标转化为极大型指标
在这里插入图片描述


# 第一步: 将原始矩阵正向化
def dataDirection(data):
    # 极小型指标转化为极大型指标
    _max_ = data['细菌总数'].max()
    data['细菌总数'] = _max_ - data['细菌总数']

    # 中间型指标转化为极大型指标
    x_best = 7
    data['PH值'] = abs(data['PH值'] - x_best)
    M = data['PH值'].max()
    data['PH值'] = 1 - data['PH值'] / M

    # 区间型指标转化为极大型指标
    a, b = 10, 20
    max1 = data['植物性营养物量'].max()
    min1 = data['植物性营养物量'].min()
    M = max(a - min1, max1 - b)

    for i in range(len(data)):
        if data.iloc[i, 3] < a:
            data.iloc[i, 3] = 1 - (a - data.iloc[i, 3]) / M
        elif a <= data.iloc[i, 3] <= b:
            data.iloc[i, 3] = 1
        else:
            data.iloc[i, 3] = 1 - (data.iloc[i, 3] - b) / M

    return data

第二步: 正向化矩阵标准化
在这里插入图片描述


# 正向化矩阵标准化
def standardization(data):
    # 遍历每一列
    for i in range(data.shape[1]):
        # 求每一列元素的平方和并开根号
        a = np.sqrt(sum(data.iloc[:, i] ** 2))
        data.iloc[:, i] = data.iloc[:, i] / a
    return data

第三步: 计算得分并归一化
在这里插入图片描述


# 计算得分并归一化
def normalization(data):
    scores = []
    length_max = []
    length_min = []
    _max_ = data.max()
    _min_ = data.min()

    for i in range(data.shape[0]):
        tp1 = tp2 = 0
        for j in range(data.shape[1]):
            tp1 += ((_max_[j] - data.iloc[i, j]) ** 2)*w[j]
            tp2 += ((_min_[j] - data.iloc[i, j]) ** 2)*w[j]
        tp1 = np.sqrt(tp1)
        tp2 = np.sqrt(tp2)
        length_max.append(tp1)
        length_min.append(tp2)
        scores.append(length_min[i] / (length_max[i] + length_min[i]))

    return scores / sum(scores)

指标带有权重的情况
上面计算的得分默认各指标权重都是1，但实际情况下权重不一定都是1，此时便可利用层次分析法计算各个指标的权重，得到加权后的得分。

指标带有权重的计算方法

在这里插入图片描述
根据如下计算公式可知只需要在第三步函数中加上权重值即可（权值通过AHP计算得到）
在这里插入图片描述

完整代码
# coding=gbk
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd


# 第一步: 将原始矩阵正向化
def dataDirection(data):
    # 极小型指标转化为极大型指标
    _max_ = data['细菌总数'].max()
    data['细菌总数'] = _max_ - data['细菌总数']

    # 中间型指标转化为极大型指标
    x_best = 7
    data['PH值'] = abs(data['PH值'] - x_best)
    M = data['PH值'].max()
    data['PH值'] = 1 - data['PH值'] / M

    # 区间型指标转化为极大型指标
    a, b = 10, 20
    max1 = data['植物性营养物量'].max()
    min1 = data['植物性营养物量'].min()
    M = max(a - min1, max1 - b)

    for i in range(len(data)):
        if data.iloc[i, 3] < a:
            data.iloc[i, 3] = 1 - (a - data.iloc[i, 3]) / M
        elif a <= data.iloc[i, 3] <= b:
            data.iloc[i, 3] = 1
        else:
            data.iloc[i, 3] = 1 - (data.iloc[i, 3] - b) / M

    return data


# 正向化矩阵标准化
def standardization(data):
    # 遍历每一列
    for i in range(data.shape[1]):
        # 求每一列元素的平方和并开根号
        a = np.sqrt(sum(data.iloc[:, i] ** 2))
        for j in range(data.shape[0]):
            data.iloc[j, i] = data.iloc[j, i] / a
    return data


# 计算得分并归一化
def normalization(data):
    scores = []
    length_max = []
    length_min = []
    _max_ = data.max()
    _min_ = data.min()

    for i in range(data.shape[0]):
        tp1 = tp2 = 0
        for j in range(data.shape[1]):
            tp1 += (_max_[j] - data.iloc[i, j]) ** 2  # 此处可以根据其他如熵权法确定权重再*w[j]即可
            tp2 += (_min_[j] - data.iloc[i, j]) ** 2
        tp1 = np.sqrt(tp1)
        tp2 = np.sqrt(tp2)
        length_max.append(tp1)
        length_min.append(tp2)
        scores.append(length_min[i] / (length_max[i] + length_min[i]))

    return scores / sum(scores)


# 绘图
def drawPic(df):
    x = df.index
    y = df.得分
    plt.barh(x, y, height=0.5, align='center')
    plt.show()


if __name__ == '__main__':
    file_path = '../datas/data1.xlsx'

    # 从excel文件中读取数据
    data = pd.read_excel(file_path, index_col='河流', sheet_name='Sheet1')

    # 第一步: 将原始矩阵正向化
    data1 = dataDirection(data)
    # 第二步: 正向化矩阵标准化
    data1 = standardization(data1)
    # 第三步: 计算得分并归一化
    scores = np.array(normalization(data1))

    df_empty = pd.DataFrame(scores, columns=['得分'], index=data.index)
    df = pd.concat([data1, df_empty], axis=1)

    # 按得分降序排序
    df.sort_values(by=['得分'], ascending=False, inplace=True)
    df.to_excel('../datas/data2.xlsx', float_format='%.4f')

    # 绘制图像
    drawPic(df)

层次分析法(AHP)

详细原理

层次分析法主要就是构建出判断矩阵求解出权重,但感觉主观性有些强…代码用到的数据取自数学建模清风视频。本代码可根据自己设定的判断矩阵生成最终的权值数据,再用Excel进一步计算结果即可(目标层采用特征值法生成权重,可再添加另两个方法,最好三种方法都做一下)

核心要点

假设方案层数量有N个,准则层包含的指标有M个，则需要构建的判断矩阵的个数为(1 + M)

计算方法

原始数据

景色苏杭北戴河桂林
苏杭1 25
北戴河1/212
桂林 1/5 1/2 1

1>算术平均法求权重

第一步： 将判断矩阵按照列归一化;
在这里插入图片描述
第二步： 将归一化的列相加(按行求和);
在这里插入图片描述
第三步： 将相加后得到的向量中的每个元素除以 n 即可得到权重向量.
在这里插入图片描述
在这里插入图片描述
方法2：几何平均法求权重

第一步： 将A的元素按照行相乘得到一个新的列向量

第二步： 将新的向量的每个分量开n次方

第三步： 对该列向量进行归一化即可得到权重向量
在这里插入图片描述
方法3：特征值法求权重
直接将特征向量归一化即可求得特征向量。
求的结果为：最大特征值为 3.0055,
一致性比例 CR = 0.0053 对应的 特征向量:[-0.8902,-0.4132,-0.1918]
归一化后得到权重向量 : [0.5954,0.2764,0.1283]

最终得到如下图所示的权重矩阵：
在这里插入图片描述

完整代码
# coding=gbk
import numpy as np
import pandas as pd
import xlrd


class AHP:
    # 相关信息的传入和准备
    def __init__(self, arr):
        # 记录矩阵相关信息
        self.arr = arr
        # 记录矩阵大小
        self.n = arr.shape[0]
        # 初始化RI值，用于一致性检验
        self.RI_list = [0, 0, 0.52, 0.89, 1.12, 1.26, 1.36, 1.41, 1.46, 1.49, 1.52, 1.54, 1.56, 1.58, 1.59]
        # 矩阵的特征值和特征向量
        self.eig_val, self.eig_vector = np.linalg.eig(self.arr)
        # 矩阵的最大特征值
        self.max_eig_val = np.max(self.eig_val)
        # 矩阵最大特征值对应的特征向量
        self.max_eig_vector = self.eig_vector[:, np.argmax(self.eig_val)].real
        # 矩阵的一致性指标CI
        self.CI_val = (self.max_eig_val - self.n) / (self.n - 1)
        # 矩阵的一致性比例CR
        self.CR_val = self.CI_val / (self.RI_list[self.n - 1])

    # 一致性判断
    def test_consist(self):
        # 打印矩阵的一致性指标CI和一致性比例CR
        print("判断矩阵的CI值为：" + str(self.CI_val))
        print("判断矩阵的CR值为：" + str(self.CR_val))
        # 进行一致性检验判断
        if self.n == 2:  # 当只有两个子因素的情况
            print("仅包含两个子因素，不存在一致性问题")
        else:
            if self.CR_val < 0.1:  # CR值小于0.1，可以通过一致性检验
                print("判断矩阵的CR值为" + str(self.CR_val) + ",通过一致性检验")
                return True
            else:  # CR值大于0.1, 一致性检验不通过
                print("判断矩阵的CR值为" + str(self.CR_val) + "未通过一致性检验")
                return False

    # 算术平均法求权重
    def cal_weight_by_arithmetic_method(self):
        # 求矩阵的每列的和
        col_sum = np.sum(self.arr, axis=0)
        # 将判断矩阵按照列归一化
        array_normed = self.arr / col_sum
        # 计算权重向量
        array_weight = np.sum(array_normed, axis=1) / self.n
        # 返回权重向量的值
        return array_weight

    # 几何平均法求权重
    def cal_weight__by_geometric_method(self):
        # 求矩阵的每列的积
        col_product = np.product(self.arr, axis=0)
        # 将得到的积向量的每个分量进行开n次方
        array_power = np.power(col_product, 1 / self.n)
        # 将列向量归一化
        array_weight = array_power / np.sum(array_power)
        # 返回权重向量的值
        return array_weight[::-1]

    # 特征值法求权重
    def cal_weight__by_eigenvalue_method(self):
        # 将矩阵最大特征值对应的特征向量进行归一化处理就得到了权重
        array_weight = self.max_eig_vector / np.sum(self.max_eig_vector)
        # 返回权重向量的值
        return array_weight


if __name__ == "__main__":

    index = np.array(['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8']).T
    b1 = pd.read_excel('../../data/判断矩阵.xlsx', index_col=0)

    # 算术平均法求权重
    weight1 = AHP(b1).cal_weight_by_arithmetic_method()
    # 几何平均法求权重
    weight2 = AHP(b1).cal_weight__by_geometric_method()
    # 特征值法求权重
    weight3 = AHP(b1).cal_weight__by_eigenvalue_method()

    # 一致性判断
    print(AHP(b1).test_consist())

    temp = np.hstack((weight1, weight2))
    temp = np.hstack((temp, weight3)).reshape(3, 8).T

    # 打开文件(若读取xlsx出错降低库的版本就行...)
    work_book = xlrd.open_workbook('../../data/判断矩阵.xlsx')

    # 获取工作簿所有sheet表对象名称
    sheets_name = work_book.sheet_names()

    temp1 = []
    temp2 = []
    temp3 = []
    for i in range(1, 9):
        b = pd.read_excel('../../data/判断矩阵.xlsx', index_col=0, sheet_name=sheets_name[i]).values
        # 一致性判断
        print(i)
        print(AHP(b).test_consist())

        # 算术平均法求权重
        weight1 = AHP(b).cal_weight_by_arithmetic_method()
        temp1.append(weight1)
        # 几何平均法求权重
        weight2 = AHP(b).cal_weight__by_geometric_method()
        temp2.append(weight2)
        # 特征值法求权重
        weight3 = AHP(b).cal_weight__by_eigenvalue_method()
        temp3.append(weight3)

    temp = np.hstack((temp, temp3))
    temp = np.hstack((temp, temp2))
    temp = np.hstack((temp, temp1))

    df_empty = pd.DataFrame(temp,
                            columns=['算术平均法(1)', '几何平均法(2)', '特征值法(3)', '合资品牌(3)', '自主品牌(3)', '新势力品牌(3)', '合资品牌(2)',
                                     '自主品牌(2)', '新势力品牌(2)', '合资品牌(1)', '自主品牌(1)', '新势力品牌(1)'],
                            index=['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8'])
    df_empty.index.name = '各指标'
    df_empty.to_excel('../../ans0/data0.xlsx', encoding='utf-8', float_format='%.4f')

    df = pd.read_excel('../../ans0/data0.xlsx', index_col=0)

    scores = []
    sc = ['算术平均法(1)', '几何平均法(2)', '特征值法(3)']
    column_names = df.columns
    for i in range(3, 12):
        if 3 <= i <= 5:
            temp1 = sum(df[sc[2]] * df[column_names[i]])
        elif 6 <= i <= 8:
            temp1 = sum(df[sc[1]] * df[column_names[i]])
        else:
            temp1 = sum(df[sc[0]] * df[column_names[i]])
        scores.append(temp1)
    print(scores)

灰色关联分析法(GRA)      参考博客

（处理多方案打分的问题）（优点：原理简单，能同时进行多个对象评价，计算快捷，结果分辨率高、评价客观，具有较好的合理性和适用性，实用价值较高
缺点：只能国赛，只能反映各评价对象内部的相对接近度，并不能反映与理想的最优方案的相对接近程度（我的理解是只能判断已有方案那个最好，不能得出最优方案）

基本思想

     首先根据序列曲线几何图形的相似程度来判断其联系是否紧密。曲线越接近，相应的序列之间关联度越大，反之越小。灰色关联度分析对于一个系统发展变化态势提供了量化的度量，非常适合动态历程分析。其基本思想是通过确定参考数据列和若干个比较数据列的几何形状相似程度来判断其联系是否紧密，它反映了曲线间的关联程度。
    通常可以运用此方法来分析各个因素对于结果的影响程度，也可以运用此方法解决随时间变化的综合评价类问题，其核心是按照一定规则确立随时间变化的母序列，把各个评估对象随时间的变化作为子序列，求各个子序列与母序列的相关程度，依照相关性大小得出结论

算法步骤:

第一步：确定分析数列;

      确定反映系统行为特征的参考数列和影响系统行为的比较数列。反映系统行为特征的数据序列，称为参考数列。影响系统行为的因素组成的数据序列，称为比较数列。

第二步: 变量的无量纲化;

     预处理：先求出每个指标的均值，再用该指标中的每个元素都除以该均值。（约定俗成）

第三步：计算关联系数；
在这里插入图片描述

第四步：计算关联度；
在这里插入图片描述
在这里插入图片描述

第五步：关联度排序

实战案例

    下表为某地区国内生产总值的统计数据（以百万元计），问该地区从2000年到2005年之间哪一种产业对GDP总量影响最大

年份国内生产总值第一产业第二产业第三产业
20001988386839763
20012061408846808
20022335422960953
2003275048212581010
2004335651115771268
2005380656118931352

步骤1：确立母序列

     在此需要分别将三种产业与国内生产总值比较计算其关联程度，故母序列为国内生产总值。若是解决综合评价问题时则母序列可能需要自己生成，通常选定每个指标或时间段中所有子序列中的最佳值组成的新序列为母序列。

步骤2：无量纲化处理

    在此采用均值化法，即将各个序列每年的统计值与整条序列的均值作比值，可以得到如下结果：

年份国内生产总值第一产业第二产业第三产业
20000.7319590.8361010.6827610.743906
20010.7588370.8837550.6884580.787780
20020.8597200.9140790.7812290.929152
20031.0125181.0440431.0237350.984725
20041.2356411.1068591.2833311.236269
20051.4013251.2151621.5404861.318167

步骤3：计算每个子序列中各项参数与母序列对应参数的关联系数( i 表示子序列个数，这里就是三个产业;k 表示每个序列包含的样本数，这里就是年份数目(可以理解成指标数目))
在这里插入图片描述可得到如下结果：

年份S01（t）S02（t）S03（t）
20000.4751450.6586360.892228
20010.4298630.5732890.767955
20020.6355770.5461820.576630
20030.7520480.8984800.775266
20040.4223780.6656861.000000
20050.3355840.4035020.531718

步骤4：计算关联度

第一产业 0.508432
第二产业 0.624296
第三产业 0.757300

通过比较三个子序列与母序列的关联度可以得出结论：该地区在2000年到2005年期间的国内生产总值受到第三产业的影响最大。

完整代码
# coding=gbk
import pandas as pd

data = pd.read_excel('../datas/原始数据.xlsx', index_col='年份')

# 数据无量纲化
mean_col = data.mean()
for i in range(data.shape[1]):
    data.iloc[:, i] = data.iloc[:, i] / mean_col[i]

# 提取参考队列和比较队列
ck = data.iloc[:, 0]
cp = data.iloc[:, 1:4]
for i in range(cp.shape[1]):
    data.iloc[:, i + 1] = abs(ck[:] - cp.iloc[:, i])

cp = cp = data.iloc[:, 1:4]
# 求最值
min_ = cp.min(axis=0).min()
max_ = cp.max(axis=0).max()
p = 0.5
ksi = (min_ + p * max_) / (cp + p * max_)
r = ksi.mean()

# 5、关联度降序排序
ans = r.sort_values(ascending=False)
print(ksi)
print(r)
print(ans)

其他评价类算法

熵权法参考博客
主成分分析法参考博客
因子分析权数法参考博客
客观赋权法的python实现参考博客
星航夜空的帆舟
关注
  • 5
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
8.评价分类算法
weixin_37954184的博客
08-11 767
混淆矩阵 Confusion Matrix： 例如预测10000个人是否患病。其中0代表不患病，1代表患病。 下图表示有9978个人没有患病，算法也预测他们没有患病；                有12个人没有患病，但算法预测他们患病；                有2个人患病，但算法预测他们没有患病；                有8个人患病，算法也预测他们患病； 精准...
MATLAB基础（六）评价类算法
热门推荐
少年程序郎
08-24 1万+
•常见的综合评定方法分为两类： •（1）综合评定法：直接评分法(专家打分综合法)、总分法、加权综合评定法、AHP+模糊综合评判、模糊神经网络评价法、待定系数法及分类法. •现代综合评价方法：层次分析法(Analytic Hierarchy Process,AHP)、数据包络分析法(Data Envelopment Analysis,DEA)、人工神经网络评价法(Artificial Neura...
【数学建模】评价类算法
m0_64548999的博客
07-18 2915
评价类算法集成
2 评价类算法：TOPSIS法笔记（附Python代码）
张某文_Lambda的博客
07-22 4857
介绍评价类算法：TOPSIS方法的一些内容，并附完整可实现的Python代码。
分类算法评价
Thinking_boy1992的博客
04-26 1639
一、引言 分类算法有很多，不同分类算法又有很多不同的变种。不同的分类算法有不同的特征，在不同的数据集上表现的效果也不同，我们需要根据特定的任务进行算法的选择，如何选择分类，如何评价一个分类算法的好坏，前面关于决策树的介绍，我们主要用的正确率（accuracy）来评价分类算法。 正确率确实是一个很好很直观的评价指标，但是有时候正确率高并不能代表一个算法就好。比如对某个地区某天地震的
数学建模评价类算法工具箱-不用写代码直接运行
08-02
这个是针对数学建模的评价类算法工具箱，工具箱有多种评价方法，包括层次分析法、TOPSIS法，熵权法、变异系数法、CRITIC法、主成分分析法、随机TOPSIS法、随机层次分析法-TOPSIS法、层次-熵权法、层次-变异系数法等...
评价，分析类算法.zip_分析_数学建模_评价算法_评价类算法
07-13
通过学习这部分资料可应对大多数分析评价类数学建模竞赛问题
评价，分析类算法.rar_建模能力评价_数学建模_数学建模算法_数学规划_评价类算法
07-13
可实现分析评价类数学建模问题，通过合理规划学习可有效提高自己matlab编程能力
如何评价算法的好坏？
数据森麟
11-23 3586
作者：林骥 来源：林骥序言评价一个算法的好坏，我认为关键是看能不能解决问题。如果算法能很好地解决实际的问题，那么我认为就是好算法。比如预测的算法，关键是看预测的准确率，即预测值与实际值之间的接近程度，而不是看算法本身的评分高低。1. 样本为了简化算法模型，我舍弃掉了前几年相对较小的数据，只保留了最近 5 年的数据。在数据量本身就比较少的情况下，我仍然遵循简单原则，这无形中就加大了...
1 评价类算法：层次分析法笔记（附Python代码）
张某文_Lambda的博客
07-20 2922
介绍评价类算法：层次分析法一些内容，并附完整可实现的Python代码。
【数学建模竞赛】评价类赛题常用算法解析
最新发布
caojunjia的博客
09-06 1698
层次分析法（Analytic Hierarchy Process，简称AHP）是一种，由美国运筹学家Saaty于20世纪70年代初期提出。该方法将与决策有关的元素分解成目标、准则、方案等多个层次，并在此基础上进行定性和定量分析。层次分析法是一种系统、简便、灵活有效的决策方法。其原理是将分析一个现象或问题之前，首先将现象或问题根据它们的性质分解为有关因素，并根据它们之间的关系分类而形成一个多层次的结构模型。
评估算法
青云志的博客
09-29 2630
@[TOC](准确率(Accuracy), 精确率(Precision), 召回率(Recall)) 例子 假如某个班级有男生80人,女生20人,共计100人.目标是找出所有女生. 现在某人挑选出50个人,其中20人是女生,另外还错误的把30个男生也当作女生挑选出来了.：（这男的之前估计是机械专业的） 作为评估者的你需要来评估(evaluation)下他的工作 定义 按照前面例子,我们需要从一个班...
评价类问题——topsis算法
qq_48345413的博客
07-14 599
topsis算法 文章目录topsis算法前言一、理论二、算法步骤 前言 Topsis法，全称为Technique for Order Preference by Similarity to an Ideal Solution中文常翻译为优劣解距离法，该方法能够根据现有的数据，对个体进行评价排序。根据有限个评价对象与理想化目标的接近程度进行排序的方法，是在现有的对象中进行相对优劣的评价 一、理论 最优的解，它的各个属性值都达到各备选方案中的最好的值； 而负理想解是一设想的最劣的解，它的各个属性值都达到各
计算机算法（一）评价算法
weixin_43772972的博客
03-02 296
How to balance an algorithm? correct fast small space simple general
算法和算法评价
Gefangen的博客
10-13 666
目录 1.1　算法的基本概念 1.2　算法效率的度量 1．时间复杂度 2.　空间复杂度 1.1　算法的基本概念 　　算法（Algorithm）是针对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作。算法具有五个重要特性： １）有穷性　一个算法（对任何合法的输入值）必须总是在执行有穷步之后结束，且每一步都可在有穷时间内完成。 ２）确定性　算法...
（2）评价算法-TOPSIS算法
xdg15294969271的博客
09-07 3975
文章目录1、TOPSIS算法2、TOPSIS算法流程2.1、极大型转化2.1.1 极大型2.1.2 中间型2.1.3 极小型2.1.4 区间型2.2 计算每项指标的权重2.3 正向矩阵标准化2.4 计算得分3、实例4、参考资料 1、TOPSIS算法 TOPSIS方法是基于数据对样本进行排序的一种方法，其基本思想是根据样本数据构造一个理想化的目标。主要找到每一列（指标）的最大值让它们构成一个向量Z+Z^+Z+和每一列（指标）的最小值构成一个向量Z−Z^-Z−。只要找到这两个向量，后面的事情就好办了。 2、TO
算法评价方式整理（理论+代码）--代码后续更新
宋建国的博客
05-11 484
1.绝对误差与相对误差 2.平均绝对误差 3.均方误差 4.均方根误差 5.平均绝对百分误差 6.Kappa统计 7.识别准确度 8.识别精确度 9，召回率 10.ROC曲线 11.混淆矩阵 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

星航夜空的帆舟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值