精华内容
下载资源
问答
  • 投票机制
    千次阅读
    2022-02-17 09:46:50

    快速回顾集成方法中的软投票和硬投票

    集成方法是将两个或多个单独的机器学习算法的结果结合在一起,并试图产生比任何单个算法都准确的结果。

    在软投票中,每个类别的概率被平均以产生结果。 例如,如果算法 1 以 40% 的概率预测对象是一块岩石,而算法 2 以 80% 的概率预测它是一个岩石,那么集成将预测该对象是一个具有 (80 + 40) / 2 = 60% 的岩石 可能性。

    在硬投票中,每个算法的预测都被认为是选择具有最高票数的类的集合。 例如,如果三个算法将特定葡萄酒的颜色预测为“白色”、“白色”和“红色”,则集成将预测“白色”。

    最简单的解释是:软投票是概率的集成,硬投票是结果标签的集成。

    生成测试数据

    下面我们开始代码的编写,首先导入一些库和一些简单的配置

    import pandas as pd
    import numpy as np
    import copy as cp
    
    from sklearn.datasets import make_classification
    from sklearn.model_selection import KFold, cross_val_score
    from typing import Tuple
    from statistics import mode
    from sklearn.ensemble import VotingClassifier
    from sklearn.metrics import accuracy_score
    
    from sklearn.linear_model import LogisticRegression
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.ensemble import ExtraTreesClassifier
    from xgboost import XGBClassifier
    from sklearn.neural_network import MLPClassifier
    from sklearn.svm import SVC
    from lightgbm import LGBMClassifier
    
    RANDOM_STATE : int = 42
    N_SAMPLES : int = 10000
    N_FEATURES : int = 25
    N_CLASSES : int = 3
    N_CLUSTERS_PER_CLASS : int = 2
        
    FEATURE_NAME_PREFIX : str = "Feature"
    TARGET_NAME : str = "Target"
        
    N_SPLITS : int = 5
        
    np.set_printoptions(suppress=True)
    

    还需要一些数据作为分类的输入。 make_classification_dataframe 函数将数据创建包含特征和目标的测试数据。

    这里我们设置类别数为 3。这样就可以实现多分类算法(超过2类都可以)的软投票和硬投票算法。并且我们的代码也可以适用于二元的分类。

    def make_classification_dataframe(n_samples : int = 10000, n_features : int = 25, n_classes : int = 2, n_clusters_per_class : int = 2, feature_name_prefix : str = "Feature", target_name : str = "Target", random_state : int = 42) -> pd.DataFrame:
        X, y = make_classification(n_samples=n_samples, n_features=n_features, n_classes=n_classes, n_informative = n_classes * n_clusters_per_class, random_state=random_state)
    
        feature_names = [feature_name_prefix + " " + str(v) for v in np.arange(1, n_features+1)]
        return pd.concat([pd.DataFrame(X, columns=feature_names), pd.DataFrame(y, columns=[target_name])], axis=1)
    
    df_data = make_classification_dataframe(n_samples=N_SAMPLES, n_features=N_FEATURES, n_classes=N_CLASSES, n_clusters_per_class=N_CLUSTERS_PER_CLASS, feature_name_prefix=FEATURE_NAME_PREFIX, target_name=TARGET_NAME, random_state=RANDOM_STATE)
    
    X = df_data.drop([TARGET_NAME], axis=1).to_numpy()
    y = df_data[TARGET_NAME].to_numpy()
    
    df_data.head()
    

    生成的数据如下:

    交叉验证

    使用交叉验证而不是 train_test_split,是因为可以提供更健壮的算法性能评估。

    cross_val_predict 辅助函数提供了执行此操作的代码:

    def cross_val_predict(model, kfold : KFold, X : np.array, y : np.array) -> Tuple[np.array, np.array, np.array]:
    
        model_ = cp.deepcopy(model)
        
        no_classes = len(np.unique(y))
        
        actual_classes = np.empty([0], dtype=int)
        predicted_classes = np.empty([0], dtype=int)
        predicted_proba = np.empty([0, no_classes]) 
    
        for train_ndx, test_ndx in kfold.split(X):
    
            train_X, train_y, test_X, test_y = X[train_ndx], y[train_ndx], X[test_ndx], y[test_ndx]
    
            actual_classes = np.append(actual_classes, test_y)
    
            model_.fit(train_X, train_y)
            predicted_classes = np.append(predicted_classes, model_.predict(test_X))
    
            try:
                predicted_proba = np.append(predicted_proba, model_.predict_proba(test_X), axis=0)
            except:
                predicted_proba = np.append(predicted_proba, np.zeros((len(test_X), no_classes), dtype=float), axis=0)
    
        return actual_classes, predicted_classes, predicted_proba
    

    在 predict_proba 中添加了 try 是因为并非所有算法都支持概率,并且没有一致的警告或错误可以显式捕获。

    在开始之前,快速看一下单个算法的 cross_val_predict …

    lr = LogisticRegression(random_state=RANDOM_STATE)
    kfold = KFold(n_splits=N_SPLITS, random_state=RANDOM_STATE, shuffle=True)
    
    %time actual, lr_predicted, lr_predicted_proba = cross_val_predict(lr, kfold, X, y)
    print(f"Accuracy of Logistic Regression: {accuracy_score(actual, lr_predicted)}")
    lr_predicted
    
    Wall time: 309 ms
    Accuracy of Logistic Regression: 0.6821
    array([0, 0, 1, ..., 0, 2, 1])
    

    函数cross_val_predict 已返回概率和预测类别,预测类别已显示在单元格输出中。

    第一组数据被预测为属于 0 , 0,1 等等。

    多个分类器进行预测

    下一件事是为几个分类器生成一组预测和概率,这里选择的算法是随机森林、XGboost等

    def cross_val_predict_all_classifiers(classifiers : dict) -> Tuple[np.array, np.array]:
        predictions = [None] * len(classifiers)
        predicted_probas = [None] * len(classifiers)
    
        for i, (name, classifier) in enumerate(classifiers.items()):
            %time actual, predictions[i], predicted_probas[i] = cross_val_predict(classifier, kfold, X, y)
            print(f"Accuracy of {name}: {accuracy_score(actual, predictions[i])}")
        
        return actual, predictions, predicted_probas
    
    classifiers = dict()
    classifiers["Random Forest"] = RandomForestClassifier(random_state=RANDOM_STATE)
    classifiers["XG Boost"] = XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=RANDOM_STATE)
    classifiers["Extra Random Trees"] = ExtraTreesClassifier(random_state=RANDOM_STATE)
    
    actual, predictions, predicted_probas = cross_val_predict_all_classifiers(classifiers)
    
    Wall time: 17.1 s
    Accuracy of Random Forest: 0.8742
    Wall time: 24.6 s
    Accuracy of XG Boost: 0.8838
    Wall time: 6.2 s
    Accuracy of Extra Random Trees: 0.8754
    

    predictions 变量是一个包含每个算法的一组预测类的列表:

    [array([2, 0, 0, ..., 0, 2, 1]),
     array([2, 0, 2, ..., 0, 2, 1], dtype=int64),
     array([2, 0, 0, ..., 0, 2, 1])]
    

    predict_probas 也是列表,但是其中包含每个预测目标的概率。 每个数组都是(10000, 3)的,其中:

    • 10,000 是样本数据集中的数据点数。 每个数组对于每组数据都有一行
    • 3 是非二元分类器中的类数(因为我们的目标是3个类)
    [array([[0.17, 0.02, 0.81],
            [0.58, 0.07, 0.35],
            [0.54, 0.1 , 0.36],
            ...,
            [0.46, 0.08, 0.46],
            [0.15, 0.  , 0.85],
            [0.01, 0.97, 0.02]]),
     array([[0.05611309, 0.00085733, 0.94302952],
            [0.95303732, 0.00187497, 0.04508775],
            [0.4653917 , 0.01353438, 0.52107394],
            ...,
            [0.75208634, 0.0398241 , 0.20808953],
            [0.02066649, 0.00156501, 0.97776848],
            [0.00079027, 0.99868006, 0.00052966]]),
     array([[0.33, 0.02, 0.65],
            [0.54, 0.14, 0.32],
            [0.51, 0.17, 0.32],
            ...,
            [0.52, 0.06, 0.42],
            [0.1 , 0.03, 0.87],
            [0.05, 0.93, 0.02]])]
    

    上面输出中的第一行详细解释如下

    对于第一种算法的第一组数据的预测(即DataFrame中的第一行有17%的概率属于0类,2%的概率属于1类,81%的概率属于2类(三类相加是100%)。

    软投票和硬投票

    现在进入本文的主题。 只需几行 Python 代码即可实现软投票和硬投票。

    def soft_voting(predicted_probas : list) -> np.array:
    
        sv_predicted_proba = np.mean(predicted_probas, axis=0)
        sv_predicted_proba[:,-1] = 1 - np.sum(sv_predicted_proba[:,:-1], axis=1)    
    
        return sv_predicted_proba, sv_predicted_proba.argmax(axis=1)
    
    def hard_voting(predictions : list) -> np.array:
        return [mode(v) for v in np.array(predictions).T]
    
    sv_predicted_proba, sv_predictions = soft_voting(predicted_probas)
    hv_predictions = hard_voting(predictions)
    
    for i, (name, classifier) in enumerate(classifiers.items()):
        print(f"Accuracy of {name}: {accuracy_score(actual, predictions[i])}")
        
    print(f"Accuracy of Soft Voting: {accuracy_score(actual, sv_predictions)}")
    print(f"Accuracy of Hard Voting: {accuracy_score(actual, hv_predictions)}")
    
    Accuracy of Random Forrest: 0.8742
    Accuracy of XG Boost: 0.8838
    Accuracy of Extra Random Trees: 0.8754
    Accuracy of Soft Voting: 0.8868
    Accuracy of Hard Voting: 0.881
    

    上面代码可以看到软投票比性能最佳的单个算法高出 0.3%(88.68% 对 88.38%),而硬投票却有所降低 (88.10% 对 88.38%),下面就对这两种机制做详细的解释

    投票算法代码实现

    软投票

    sv_predicted_proba = np.mean(predicted_probas, axis=0)
    sv_predicted_proba
    
    array([[0.18537103, 0.01361911, 0.80100984],
           [0.69101244, 0.07062499, 0.23836258],
           [0.50513057, 0.09451146, 0.40035798],
           ...,
           [0.57736211, 0.05994137, 0.36269651],
           [0.09022216, 0.01052167, 0.89925616],
           [0.02026342, 0.96622669, 0.01350989]])
    

    numpy mean 函数沿轴 0 (列)取平均值。 从理论上讲,这应该是软投票的全部内容,因为这已经创建了 3 组输出中的每组输出的平均值(均值)并且看起来是正确的。

    print(np.sum(sv_predicted_proba[0]))
    sv_predicted_proba[0]
    
    0.9999999826153119
    array([0.18537103, 0.01361911, 0.80100984])
    

    但是因为四舍五入的误差,行的值并不总是加起来为 1,因为每个数据点都属于概率和为 1 的三个类之一

    如果我们使用topk的方法获取分类标签,这种误差不会有任何的影响。但是有时候还需要进行其他处理,必须要保证概率为1,那么就需要做一些简单的处理:将最后一列中的值设置为 1- 其他列中值的总和

    sv_predicted_proba[:,-1] = 1 - np.sum(sv_predicted_proba[:,:-1], axis=1)
    
    1.0
    array([0.18537103, 0.01361911, 0.80100986])
    

    现在数据都没有问题了,每一行的概率加起来就是 1,就像它们应该的那样。

    下面就是使用numpy 的 argmax 函数获取概率最大的类别作为预测的结果(即对于每一行,软投票是否预测类别 0、1 或 2)。

    sv_predicted_proba.argmax(axis=1)
    
    array([2, 0, 0, ..., 0, 2, 1], dtype=int64)
    

    argmax 函数是沿axis参数中指定的轴选择数组中最大值的索引,因此它为第一行选择 2,为第二行选择 0,为第三行选择0等。

    硬投票

    hv_predicted = [mode(v) for v in np.array(predictions).T]
    

    其中np.array(predictions).T 语法只是转置数组,将(10000, 3)变为(3,10000 )

    print(np.array(predictions).shape)
    np.array(predictions).T
    
    (3, 10000)
    array([[2, 2, 2],
           [0, 0, 0],
           [0, 2, 0],
           ...,
           [0, 0, 0],
           [2, 2, 2],
           [1, 1, 1]], dtype=int64)
    

    然后列表推导获取每个元素(行)并将 statistics.mode 应用于它,从而选择从算法中获得最多票的分类…

    np.array(hv_predicted)
    
    array([2, 0, 0, ..., 0, 2, 1], dtype=int64)
    

    使用 Scikit-Learn

    从头编写代码可以让我们更好的链接算法的实现机制,但是不需要重复的制造轮子, scikit-learn的VotingClassifier 可以完成所有工作

    estimators = list(classifiers.items())
        
    vc_sv = VotingClassifier(estimators=estimators, voting="soft")
    vc_hv = VotingClassifier(estimators=estimators, voting="hard")
    
    %time actual, vc_sv_predicted, vc_sv_predicted_proba = cross_val_predict(vc_sv, kfold, X, y)
    %time actual, vc_hv_predicted, _ = cross_val_predict(vc_hv, kfold, X, y)
    
    print(f"Accuracy of SciKit-Learn Soft Voting: {accuracy_score(actual, vc_sv_predicted)}")
    print(f"Accuracy of SciKit-Learn Hard Voting: {accuracy_score(actual, vc_hv_predicted)}")
    
    Wall time: 1min 4s
    Wall time: 55.3 s
    Accuracy of SciKit-Learn Soft Voting: 0.8868
    Accuracy of SciKit-Learn Hard Voting: 0.881
    

    cikit-learn 实现产生的结果与我们手写的算法完全相同——软投票准确率为 88.68%,硬投票准确率为 88.1%。

    为什么硬投票的效果不好呢?

    想想这样一个情况,以二元分类为例:

    B的概率分别为0.01,0.51,0.6,0.1,0.7,则

    A的概率为0.99,0.49,0.4,0.9,0.3

    如果以硬投票计算:

    B 3票,A 2票,结果为B

    软投票的计算

    B:(0.01+0.51+0.6+0.1+0.7)/5=0.38

    A:(0.99+0.49+0.4+0.9+0.3)/5=0.61

    结果为A

    硬投票的结果最终由概率值相对较低的模型(0.51,0.6,0.7)决定,而软投票则由概率值较高的(0.99,0.9)模型决定,软投票会给使那些概率高模型获得更多的权重,所以表现要比硬投票好。

    集成学习到底能有多大的提升?

    我们看看集成学习究竟可以在准确度度量上实现多少改进呢?使用常见的6个算法看看我们可以从集成中挤出多少性能…

    lassifiers = dict()
    classifiers["Random Forrest"] = RandomForestClassifier(random_state=RANDOM_STATE)
    classifiers["XG Boost"] = XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=RANDOM_STATE)
    classifiers["Extra Random Trees"] = ExtraTreesClassifier(random_state=RANDOM_STATE)
    classifiers['Neural Network'] = MLPClassifier(max_iter = 1000, random_state=RANDOM_STATE)
    classifiers['Support Vector Machine'] = SVC(probability=True, random_state=RANDOM_STATE)
    classifiers['Light GMB'] = LGBMClassifier(random_state=RANDOM_STATE)
    
    estimators = list(classifiers.items())
    

    方法 1:使用手写代码

    %time
    actual, predictions, predicted_probas = cross_val_predict_all_classifiers(classifiers) # Get a collection of predictions and probabilities from the selected algorithms
    
    sv_predicted_proba, sv_predictions = soft_voting(predicted_probas) # Combine those collections into a single set of predictions
    hv_predictions = hard_voting(predictions)
    
    print(f"Accuracy of Soft Voting: {accuracy_score(actual, sv_predictions)}")
    print(f"Accuracy of Hard Voting: {accuracy_score(actual, hv_predictions)}")
    
    Wall time: 14.9 s
    Accuracy of Random Forest: 0.8742
    Wall time: 32.8 s
    Accuracy of XG Boost: 0.8838
    Wall time: 5.78 s
    Accuracy of Extra Random Trees: 0.8754
    Wall time: 3min 2s
    Accuracy of Neural Network: 0.8612
    Wall time: 36.2 s
    Accuracy of Support Vector Machine: 0.8674
    Wall time: 1.65 s
    Accuracy of Light GMB: 0.8828
    Accuracy of Soft Voting: 0.8914
    Accuracy of Hard Voting: 0.8851
    Wall time: 4min 34s
    

    方法2:使用 SciKit-Learn 和 cross_val_predict

    %%time
    vc_sv = VotingClassifier(estimators=estimators, voting="soft")
    vc_hv = VotingClassifier(estimators=estimators, voting="hard")
    
    %time actual, vc_sv_predicted, vc_sv_predicted_proba = cross_val_predict(vc_sv, kfold, X, y)
    %time actual, vc_hv_predicted, _ = cross_val_predict(vc_hv, kfold, X, y)
    
    print(f"Accuracy of SciKit-Learn Soft Voting: {accuracy_score(actual, vc_sv_predicted)}")
    print(f"Accuracy of SciKit-Learn Hard Voting: {accuracy_score(actual, vc_hv_predicted)}")
    
    Wall time: 4min 11s
    Wall time: 4min 41s
    Accuracy of SciKit-Learn Soft Voting: 0.8914
    Accuracy of SciKit-Learn Hard Voting: 0.8859
    Wall time: 8min 52s
    

    方法 3:使用 SciKit-Learn 和 cross_val_score

    %time print(f"Accuracy of SciKit-Learn Soft Voting using cross_val_score: {np.mean(cross_val_score(vc_sv, X, y, cv=kfold))}")
    
    Accuracy of SciKit-Learn Soft Voting using cross_val_score: 0.8914
    Wall time: 4min 46s
    

    3 种不同的方法对软投票准确性的评分达成一致,这再次说明了我们手写的实现是正确的。

    补充:Scikit-Learn 硬投票的限制

    from catboost import CatBoostClassifier
    from sklearn.model_selection import cross_val_score
    
    classifiers["Cat Boost"] = CatBoostClassifier(silent=True, random_state=RANDOM_STATE)
    estimators = list(classifiers.items())
    
    vc_hv = VotingClassifier(estimators=estimators, voting="hard")
    
    print(cross_val_score(vc_hv, X, y, cv=kfold))
    

    会得到一个错误:

    ValueError: could not broadcast input array from shape (2000,1) into shape (2000)
    

    这个问题很好解决,是因为输出是(2000,1)而输入的要求是(2000),所以我们可以使用np.squeeze将第二个维度删除即可。

    总结

    通过将将神经网络、支持向量机和lightGMB 加入到组合中,软投票的准确率从 88.68% 提高了 0.46% 至 89.14%,新的软投票准确率比最佳个体算法(XG Boost 为 88.38 提高了 0.76% )。添加准确度分数低于 XGBoost 的 Light GMB 将集成性能提高了 0.1%!也就是说集成不是最佳的模型也能够提升软投票的性能。如果是 Kaggle 比赛,那么 0.76% 可能是巨大的,可能会让你在排行榜上飞跃。

    作者:Graham Harrison

    cv=kfold))

    
    会得到一个错误:
    
    ```python
    ValueError: could not broadcast input array from shape (2000,1) into shape (2000)
    

    这个问题很好解决,是因为输出是(2000,1)而输入的要求是(2000),所以我们可以使用np.squeeze将第二个维度删除即可。

    总结

    通过将将神经网络、支持向量机和lightGMB 加入到组合中,软投票的准确率从 88.68% 提高了 0.46% 至 89.14%,新的软投票准确率比最佳个体算法(XG Boost 为 88.38 提高了 0.76% )。添加准确度分数低于 XGBoost 的 Light GMB 将集成性能提高了 0.1%!也就是说集成不是最佳的模型也能够提升软投票的性能。如果是 Kaggle 比赛,那么 0.76% 可能是巨大的,可能会让你在排行榜上飞跃。

    https://www.overfit.cn/post/a4a0f83dafad46f3b4135b5faf1ca85a

    作者:Graham Harrison

    更多相关内容
  • redis集群节点宕机 fail状态 redis的投票机制实测  redis集群是有很多个redis一起工作,那么就需要这个集群不是那么容易挂掉,所以呢,理论上就应该给集群中的每个节点至少一个备用的redis服务。这个备用的redis...
  • 基于随机森林和投票机制的大数据样例选择算法.pdf
  • EOS的DPOS, Stake与投票机制 DPOS EOS.IO软件架构中采用的共识算法。根据这种算法,全网持有代币的人可以通过投票系统来选择区块生产者,一旦当选任何人都可以参与区块的生产。 出块机制 超级节点轮流出块,每轮每个...
  • 云计算-基于投票机制的单应矩阵估计算法的研究与应用.pdf
  • 基于投票机制的融合聚类算法.pdf
  • 深度解析:DAO的7种常见投票机制

    千次阅读 2022-01-14 20:03:32
    在大多数的 DAO 当中,Token 承载了类似于股票对于股份公司的作用,...即便对于持币结构足够分散,有良好参与文化的 DAO 组织而言,如果缺乏良性的投票决策机制,也将导向“乌合之众”式的短视与愚蠢。 加密行业会给

    在大多数的 DAO 当中,Token 承载了类似于股票对于股份公司的作用,包括承载所有权,治理决策权,收益权等等。很长时间以来,DAO 的主要投票权体现形式,是最简单的一通证一票(1T1V)的形式。但这种安排弊端重重,持币比例较小的用户对参与治理采取「理性冷漠」态度,正如一句俗语:“说了不算,算了不说”;这进一步导致 DAO 当中投票权的中心化,转而服务于少数人利益;即便对于持币结构足够分散,有良好参与文化的 DAO 组织而言,如果缺乏良性的投票决策机制,也将导向“乌合之众”式的短视与愚蠢。

    加密行业会给予那些哪怕是做出微小创新的人以优厚的奖励。以 DAO 为载体,人们开始探索各种治理协调机制。由于区块链及Token的可编程性,DAO 诞生短短数年,已经为治理问题贡献了丰富的方案,而 DAO 组织较低的试错成本,也为不同治理机制提供了一个实验的舞台。

    DAO 是一种充满魅力的组织形态,它在实现公共物品的共有所有制、消除公益部门的腐败风险、达成非盈利的组织目标方面有无可比拟的优势。但这些优势,必须配合以良性的投票决策机制、公平的贡献衡量及奖励机制以及强韧的治理扩展性,才能得以实现。本文会介绍几种我们认为典型的、有趣的投票决策机制,这些投票机制尽管都不是解决一切问题的银弹,但其治理思想都有非凡的积极意义。

    • 流动民主(Vote delegation/Liquid democracy)

    每个决策都需要占用我们的思维带宽,这是我们现实中对公共议题选择「理性冷漠」的原因之一,但我们有更好的选择,那就是将决策委托给专家,这样比自己承担这些成本要低。另外在公共治理中,将权力委托到少数人手中可以有效的提高效率。但授权不是万能的,专家也不一定完全可靠,因此,在委托-代理关系中,监督是不可或缺的。

    权力需要集中,但更需要流动。流动民主和代议制整体相似,但比代议制整体的“流动”属性更强。拥有投票权的用户可以选择将自己的投票权委托给自己信任的,认为专业的人士,但他们随时可以撤回委托并亲自去行使投票权,或是转移委托给其他人。此外,委托是多级的,你委托出去的票,可能会被再次委托给其他人。

    流动民主机制最早在 Aragon 中被采用,通过这种方式,可以提高持币者的参与率,进而提高投票决策的合法性。尽管流动民主依旧存在贿选、串通等问题。但通过反应更加灵敏的、层次更多的委托机制,流动民主增加了每个人的选择权、也显著增加了委托人对被委托人的监督作用。

    • 二次方投票(Quadrac Voting)

    这是Vitalik Buterlin提出来的一种介于 1T1V 和 1P1V(一人一票)之间的投票机制,这种投票机制的关键作用在于允许单个投票主体为同一选项重复投票,以表达其意愿的强烈程度,与此同时,为了避免巨鲸垄断话语权,为同一选项进行重复投票的边际成本呈现递减趋势,这意味着第 n+1 次投票的成本要高于第 n 次投票。例如为同一选项投一票需要消耗 1 个 Token ,为其投 2 票则要消耗 4 个Token,为其投 3 票需要消耗 9 个Token,以此类推,为其投 10 票,则需要消耗 100 个Token。随着对一个选项重复投票的次数增加,投票的效用仅为已投 Token 数的平方根。

    二次方投票可以用于权利所有者对公共资源进行分配的投票,典型的应用案例是 Gitcoin。Gitcoin 是一个采用二次方投票机制来决定将来自以太坊基金会的资金用于资助哪些项目的一个Grant DAO。在 Gitcoin 出现之前,以太坊基金会赞助哪些项目是由一个中心化的委员会决定的。Gitcoin 提供了一个让社区用户表达意见的渠道。社区用户可以通过向自己支持的项目以“捐赠”的形式进行投票,一个项目获得的每一笔捐赠的平方根之和,最终决定了能获得的赞助额度。

    实际运行下来,Gitcoin 高效的为众多优质的以太坊项目提供了资金。二次方投票机制让那些受到更多人支持的项目脱颖而出,Gitcoin 的二次方投票机制省去了中心化委员会的评估过程,使得资金分配更有效率,同时创造了一种开放的社区参与文化。

    二次方投票的弱点在于必须依赖严格的身份证明机制才能保证其公正。如果允许伪造身份,其运行结果将与1T1V毫无差别。在身份识别上,Gitcoin 采用了绑定社交账号,连接 DID 服务等多元化的方式。用户每完成一项,即可获得一定数量的积分,积分达到 150 分之后可达成身份认证。

     

    Gitcoin 的身份验证界面

    • 全息共识(Holographic Consensus)

    全息共识是 DAOstack 为了增加治理扩展性而提供的一个解决方案。治理扩展性可以理解为某个治理机制对于 DAO 规模扩大的适应性。我们知道,随着 DAO 规模的扩大,协调的成本在急剧增加,让每个人都为每一个提案投票显然是不现实的,参与者的注意力不可避免的成为了最稀缺的资源。

    DAOstack 认为,为了让治理体系高效,必须要有管理集体注意力的机制,该机制要确保最重要的提案得到关注,得到参与投票的小群体倾向于按照大多数人的利益行事。“全息”一词本意是指在二维平面上记录三维物体全部信息的技术手段,而全息共识的目标则是让小群体准确表达大众意志。这点是通过注意力通证——GEN 实现的。

    GEN 是 DAOstack 生态系统中注意力货币化的标记。使用 GEN ,你不能投票,但你可以对任意一个提案进行押注,如果你押注的提案通过,你将获得更多的 GEN ,如果你押注的提案未被通过,你将损失 GEN 。这种押注的方式相当于建立了一个与投票机制并行的预测市场。

    全息共识的治理流程可以分为四个步骤:

    1. 发起提案:任何满足声誉门槛的用户均可发起提案;

    2. 提案增强:GEN 持有者选择他们认为通过概率大的提案进行押注,没有获得足够 GEN 押注的提案将被忽略,不会进入下一阶段;

    3. 投票决策:拥有投票权的群体对提案进行表决,若提案被通过,押注的用户可以获得GEN奖励,反之则损失 GEN ;

    4. 上链执行: 被通过的提案正式生效,并在链上执行。

    以上便是 DAOstack 提供的全息共识的治理投票框架,该框架具有很强的治理扩展性,为规模较大的DAO提供了可用的治理方案。

    对该框架的质疑主要集中在两点:其一,该框架是否真正筛选了最值得关注的提案,还是只是筛选出了具有传播效应的热门提案?其二,押注者的判断建立在某个提案是否会被通过,而非某个提案应当被通过,具有投票资格的押注者必然会参与投票,他们是否最终会扭曲投票结果?

    这些弊病有待在实际运行中予以检验和修正。无论如何,DAOstack 已提供了一个将预测市场和 DAO 治理相结合的有益实践。通过使用 DAOstack 的框架,DXdao、NecDAO 和 Prime DAO 已经在实践全息共识机制。

    • 信念投票(Conviction Voting)

    信念投票是 Aragon 提出的一种基于投票者信念的动态投票机制。当用户选择为某一提案投票时,其投票效用会随着时间推演而增加。这个增加过程不是匀速的,而是减速的,最终会达到一个最大值而不再增加。用户可以随时将已投出的票撤回或者转移到其他提案,但其在上一个提案上的投票效用不会立即消失,而是会逐渐减少,这个减少过程也不是匀速的,而是加速的。为了使表述更加形象,Aragon创造了“信念”的概念,用来指代投票效用。

    信念投票是一种新颖的决策过程,现已被 1HIVE 社区用于资金分配的社区决策。信念投票具有如下特点:

    1. 用户可以随时在多个正在进行中的提案中分配他的投票,且没有明确截止日期;

    2. 投票效用不止与所投票数有关,而且增加了时间函数,会随时间推移而逐渐增长;

    3. 用户可以随时撤回投票,其投票效用不会被立即移除,而是随时间推移逐渐减弱;

    4. 每个提案根据其所申请的资金额度,会有一个阈值,一旦提案所聚集的“信念”得到阈值,提案就会被通过,资金就会被拨付。

    念投票从根本上改变了投票的形式,社区用户将不被要求在一个时间限制下投票,也不会被要求为他们不了解的提案投票。用户可以充分表达自己的偏好,而不必总是“做决定”,他们可以为自己了解的,感兴趣的提案投票。信念投票不要求用户在同一个议题上达成多数共识,而是转而充分发挥用户意志的多样性,并让多条路径并行。

    当然信念投票并不能适用所有决策场景,从目前实践来看,信念投票对于预算决策而言非常适用。他有效的降低了投票的门槛,并让组织有效的收集社区的偏好,灵敏的反应群体意志。

    • 怒退机制(Rage Quitting)

    我们认为更好的翻译是“不爽就退”,该机制来源于 Moloch ,现在被广泛运用于包括 DAOhaus 在内的多个采用 Moloch 框架的 DAO 平台或 DAO 组织。

    理论上讲,靠多数投票来决定资金处置的组织是存在风险的,例如掌握70%投票权的所有者,投票通过一个提案,侵吞另外30%投票权所有者的资金。尽管这样极端的情况还未出现,但是在股份制公司,大股东利用决策权和信息优势,收割小股东利益的事情屡见不鲜。对于投资型DAO(Venture DAO)而言,防止具有决策权的小群体损害其他所有者的利益是十分有必要的,怒退机制便可以有效的实现这一点。

    对于 Moloch 框架的 DAO 而言,任意成员可以在任何时候退出 DAO 组织,销毁自己的 Share 或者 Loot(Share 是有投票权的股份,Loot 是没有投票权的股份),取回 DAO 当中对应份额的资金。而怒退特指在治理投票环节当中的退出行为。

    以 DAOhaus 为例,治理流程被分为以下步骤:

    1. 提交提案:任何人(不限于DAO组织成员)都可以提交提案;

    2. 赞助提案:提案必须获得足够的赞助才能进入投票阶段。赞助的含义是持有 Share 的人对此提案投票表达支持,此阶段可以过滤无意义或是不重要的提案;

    3. 排队:提案获得的赞助超过阈值之后,进入队列,等待投票。通过排队机制,确保提案有序的汇集到投票池中;

    4. 投票:在投票截止日期之前,提案必须获得足够多的赞成票才可以通过;

    5. 缓冲期:投票通过之后,在执行投票结果之前,有一个7天的缓冲期(Grace Period),在此期间,对投票结果不满意的股东可以怒退;

    6. 执行:提案被标记为完成,并在链上被执行。

    我们发现,在怒退机制下,任何成员都不能控制其他成员的资金,通过治理投票理论上无法伤害任意成员的利益。事实上,怒退机制不光可以保障成员的利益,而且可以提高组织在思想上的统一性,提高组织协调效率。

    • 加权投票与声誉投票(Weighted Voting & Reputation-based Voting)

    治理通证往往要承担双重职能,一方面要承担治理功能,另一方面又要承担价值流通职能。通证必须有足够的流通性才能捕获财务价值。但治理通证的财务价值,必然带来金融化的倾向。这意味着治理通证不仅可能出现在交易市场,而且可能出现在借贷市场,甚至可能产生衍生资产。

    攻击者可以从借贷市场借入,或是从可能存在的委托贿选市场中租用委托,即可短时间获得大量投票权,对DAO发起治理攻击。

    为了规避这样的问题,加权投票是个不错的方式,有些 DAO 组织让投票效用与持有时长(币龄)挂钩,持有时间越长,投票权越大,还有一些 DAO 组织,让投票效用与锁仓时长挂钩,例如Polkadot:用户可以选择不锁仓,但投票效用极小,选择较长的锁仓时长,可以提高投票效用。

     

     Kusama 平行链 Bifrost 的治理投票界面

    加权投票可以增加治理攻击的金融成本,让攻击不具备经济可信性。更加彻底的方案则是将财务价值通证和治理权力通证完全解耦,后者我们可以称之为「声誉」。

    声誉,是一种不可转让,不可流通的积分,通过持有或者锁仓通证可能获得声誉,但具有投票权的是声誉,而非通证。声誉还可以通过为组织做出贡献而获得。需要注意的是,声誉持有者对声誉并没有绝对的所有权,你已获得的声誉是可以通过代码规则或是治理投票销毁的。例如,当声誉持有者做出了损害组织利益的行为,其声誉有可能被扣除;再例如,为了避免早期获得的声誉持续产生影响力,破坏公平性,声誉可以随着时间推移而被陆续扣减,或因过期而失效。

    尽管声誉不能完全抵抗恶意贿选(例如你还是可以把你的私钥出售来间接转让声誉),但形成一个高效的声誉买卖市场、或是使其金融化无疑是极难的。

    从 DAOstack 开始,其他治理框架也陆续支持了声誉投票的方案。声誉投票赋予了 DAO 组织基于其社区生态分布、通证分布调整投票权重的能力,也避免了基于通证的投票带来的治理攻击问题,和公平性问题。通过自定义声誉值的计算规则和获得方式,DAO组织可以实践各自所理解和认可的”民主“。

    • 知识可提取投票 (Knowledge-extractable Voting (KEV))

    我们需要先了解一个被称为“Furtachy”的概念,因为它的“为信念押注”的思想对 DAO 治理投票机制产生了深远的影响。Futarchy 是由 Robin Hanson 于 2000 年提出的治理理论,这是一种将治理投票与预测市场相结合的模式。其核心思想是赋予投票行为下赌注的性质,从而奖励投了正确选项的人,惩罚投了错误选项的人。上文讲到的全息共识可以理解为是 Furtachy 的一种变体。

    本小节要介绍Furtachy的另外一种变体:知识可提取投票(该翻译为 Knowledge-extractable Voting 的直译,尚未形成行业共识),简称 KEV。

    KEV 的核心是让具有知识的专家拥有更多的投票权。KEV的思想源于对现实政治中民粹主义的反思。在英国脱欧的公投中,其实有不少对国际政治与贸易具有深刻认识的“有识之士”,他们普遍不支持脱欧,但他们没有更多的投票权,他们和大众一样,只有相同权重的一票。为了改善这种情况,KEV 机制引入了一种新型的知识通证,该通证和声誉的性质有些类似,不可交易,且可以通过既定的规则进行发放和罚没。但该通证不直接用于投票,而是通过影响投票权重来发挥作用。

    在 KEV 机制中,提案会被划分为不同的主题,不同的主题会对应不同的知识通证,拥有某类知识通证可以在该类主题的提案中拥有更大的投票权。假如 Alice 拥有很多税法主题的知识通证,Alice 在对税法方面的提案进行投票时,其投出的票会有更大的权重。

    如果 Alice 投出的票符合最终的投票结果,Alice 会被奖励更多的对应主题的知识通证,反之,如果 Alice 投出的票与最终投票结果不一致,则其知识通证会被扣减。KEV 机制鼓励对某个提案更有专业知识的人去投票,也鼓励对某个提案没有掌握足够信息和知识的人不要去投票。

    KEV机制的「知识影响权力」的想法无疑是具有正面意义的,但说到底判断专家的选择是否正确,还是得靠最终的投票结果本身,而非投票决策本身是否产生了正面的影响,这没有跳出Furtachy 的框架。

    KEV机制目前只有 dit protocol 正在采用,对于KEV的相关参数的合理设置也在探索中。

    小结

    什么是好的治理投票机制?对于私营公司,可能效率是第一位的,具有绝对权力的企业领袖、森严的科层制是其标配,但对于 DAO 组织,尽管也需要具有号召力的社区领袖和高效的执行力,但在这之前,我想「民主」应该首先被考虑。

    作为一个非西方文化背景下的研究团队,我们并没有把民主作为不假思索、天然正确的价值追求。DAO 组织之所以需要选择民主作为治理伦理,是符合现实利益的。我们先给 DAO 语境下的民主做个定义:由众多利益相关者广泛的、公平的参与决策。而广泛且公平的决策机制,可以帮助DAO组织实现以下两点目标:

    • 动员更多的智慧与资源

    一个群体,可以表现为“群体无意识”,也可以表现为“群体智慧”,这取决于有没有好的协调机制。机制良性、运作得当的 DAO 组织,可以让众多所有者选择创造价值,而非“搭便车”,从而有效发掘群体智慧与群体资源,为组织目标而服务。这一点对于传统的中心化组织,恐怕需要花更大代价才能做到。

    • 向“善”发展,长期存续

    私有制诞生以来,对人类文明的发展提供了巨大的动力,但随着生产力的发展,出现了很多提供公共物品的组织。无论是医院、学校这样的公共事业,还是像 Uber、Facebook 这样的互联网服务,都具有显著的公共物品性质。但是,当私有企业运营公共服务的时候,便会出现片面追求股东利益,损害其他更广泛的利益相关者的情况,例如私营医院过度收费,互联网公司大数据杀熟等。人类已经探索了很多种机制来解决这样的问题,例如工会参与治理、国有制、合作社、管家所有制(Steward Ownership)等等,但我们立足当前看,发现 DAO 才是完美的答案。DAO 几乎是运营公共物品最理想的组织形态,甚至 DAO 可能会创造更多的公共物品。或许有人会问,DAO的所有者们不会与其他利益相关者的利益矛盾吗,但我认为这个问题应该反过来思考:DAO如何将更广泛的利益相关者转化为所有者?

    DAO 的发展不光作为一种组织形态本身,可以克服内生异化,使得组织目标更好的达成,也产生了良好的外部性。其中之一便体现在对治理机制的创新与探索,创新与探索的力量源于新创的 DAO 组织,但更主要的会源于 Aragon、Moloch、DAOstack、SubDAO 这样的 DaaS 服务平台。

    DAO 的治理机制设计,已经超出了区块链的技术边界,而是回归到对人类组织形式本源的思考。我们更愿意相信,DAO 的根本目的,是通过技术降低组织协调的成本。例如二次方投票不光在 DAO 当中的得到应用——科罗拉多民主党也试验二次方投票来决定他们的纲领,这不仅是一个对投票机制的小小改进,而且是一种全新的社会治理技术的改革尝试,它将为公共议题的决策提供重要的参考;而全息共识中注意力货币化的思想、KEV 中的知识放大权力的哲学、信念投票的多元化内核,怒退机制和声誉投票的公平理念无不对我们的现实治理产生深刻的启发。

    展开全文
  • 提出基于卷积神经网络和投票机制的三维模型分类和检索算法。 3、优点 这种加权投票的分类思想既确保了三维物体各个视图间的相对独立性,又避免个别有歧义视图对物体类别判断的误导。 4、缺点 5、算法原理 ...

    作者:白静

    计算机辅助设计与图形学学报

    1、解决的问题

    由于三维模型投影得到的视图是由不同视点得到,具有相对独立性,这种像素级的融合运算并没有直接的物理或者几何意义,更有可能造成图像有益信息淹没和混淆。

    2、创新点

    提出基于卷积神经网络和投票机制的三维模型分类和检索算法。

    3、优点

    这种加权投票的分类思想既确保了三维物体各个视图间的相对独立性,又避免个别有歧义视图对物体类别判断的误导。

    4、缺点

    本文算法存在局部特征识别及细分类能力较弱的问题.,无法有效区分table和desk这些模型所属类别。

    5、算法原理

    首先,利用多视图表征3D模型;

    其次,利用卷积神经网络完成基于视图的处不识别;

    最后,通过决策层的加权投票完成3D模型的最终分类,以避免像素级的视图融合,突出多数有效视角,减小少数不佳视角干扰,仅为提高三维模型的分类能力。

    5.1、多视图表征

    本文采用Su-MVCNN所提出的12视图渲染方式构建给定网络模型M的多视图表征V(M)

    5.2、弱分类器:视图分类及表征

    考虑到3D模型库的规模及视图的复杂性,选用Jia提出的C阿飞飞Net作为面向单个二维视图分类及表征的深度学习模型。

    该网络共包含8层,其中前5层是卷积层,中间是2个全连接层,最后一层为网络输出层FC8和Softmax分类层。

    此训练分为2步:

    首先利用ImageNet图像资源作为输入,对CaffeNet进行预训练;

    然后采用3D模型渲染的二维视图作为输入对获得的网络模型进行微调,使最终获得的网络模型有效适应3D模型对应的二维视图。

    训练好后,给定3D模型M的单个视图vl,以FC8层的输出Dl作为该视图的特征描述,其中k为类的数目;以softMax层输出结果Pl作为分类结果,即视图属于各个类的概率。

    5.3、强分类器:基于投票的三维模型分类

    给定3D模型M多视图表征中每个视图属于各个类别的概率,以其为输入,构建强分类器,完成三维模型的分类。设依据视图属于每个类的概率分布情况,计算类i所获视图投票知为Tvote,k为类的数目,则模型M的分类结果为

    (1)概率投票法

    将3D模型各个视图属于某类的概率值Pil作为投票值,累加计算wi所获投票,设n为单个模型视图数目

    (2)0-1投票法

    依据Pil来看,3d模型最可能属于哪个类就给哪个类投出一票;若3D模型以相近似的概率属于多个类,则给这几个类都投出一票。

    其中,\Theta是阈值;Lk(Pl)表示视图vl属于各类概率Pl中的第k大元素

    (3)加权0-1投票法

    对于0-1投票法,有的视图可能投了多票具有不公平性。为此提出加权0-1投票法

    其中,视图vl的权重为其投票数目的倒数,来确保各个视图在投票中的相对平等地位。

    5.4、距离度量方法

    (1)A2A:视图集V(x)内每个视图到V(y)内所有视图的最短距离的平均值作为模型x到y之间的距离

    (2)MiniA2A:视图集V(x)内每个视图到V(y)内所有视图的最小距离作为模型x到y之间的距离

    (3)V2A:只考虑投票正确的视图间的距离,用视图集V(x)内投票正确的视图同视图集V(y)内投票正确的视图间距离的平均值作为模型x到y之间的距离

    (4)V2V:只考虑投票正确的视图间的距离,用视图集V(x)内投票正确的视图同视图集V(y)内投票正确的视图的最小距离作为模型x到y之间的距离

    6、实验设计

    6.1、分类实验

    (1)视图选取实验

    3V表示3视图,从结果整体来看,12V和80V取得了最好的分类效果。在非刚性数据集上,这两种方向相当,在刚性数据集上,模型数目较少的12V由于80V;在数目较多时80V优于12V

    (2)投票方式选取实验

    由表3可知,概率投票法不需要设置任何参数,最为鲁棒,分类性能与其他两种方法相当。

    无论选用哪种投票方式,参数如何选取,非刚性三维模型数据集都较为鲁棒。说明非刚性数据集的模型特征信息比较丰富。上表得出,ModelNet10 ,ModelNet40,SHREC10,SHREC11,SHREC15的\Theta取值依次为0.7,0.5,0,0,0

    (3) 基于视图的分类算法的对比试验

    本文算法分类准确率具有一定优势。在更加复杂的ModelNet40数据集上,准确率位居第一。

    (4)与其他分类算法的对比试验

    从表上看出本文算法有效性,同时也揭示了本文算法在刚性三维模型的分类中还存在一些缺陷。

    (5)各个类的根类结果分析

    在bed,char,monitor,toilet分类准确率均为1;dresser次之,0.91;在desk,night_stand和table上分类准确率为0.86,0.84,0.75.

    其中,table类和desk类在局部结构上有所区别,但是整体形状及其相似。可以看出本文算法在模型的细分类以及局部区域识别方面能力不足,因为无法有效区分这些模型所属类别。

    (6)非刚性三维模型分类实验对比

    6.2、检索实验

    设置视图数目n=12,选取modelnet和shrec完成测试。

    (1)4种距离度量算法对比。

    (2)刚性3D模型检索实验对比

    本文算法和其他4种典型算法的MAP和P-R曲线。

    各个类的检索结果。

    (3)非刚性三维模型检索实验对比

    本文算法和其他算法的P-R曲线

    下图是使用V2A检索算法,运行时间如表

    PS:

    刚性三维模型具有以下特点

    1、大多由规则的几何体组成,模型表面的几何信息也比较单一,大多是平面或规则的曲面;

    2、局部特征往往几种在特定的功能区域,而不是分散于模型的整个表面,因此不同视角下视图捕获的特征信息较为相似,区别力相对较弱。

     

    展开全文
  • 基于卷积神经网络和投票机制的三维模型分类与检索
  • sklearn中的投票机制学习笔记

    千次阅读 2019-01-13 21:09:30
    投票机制(voting)是集成学习里面针对分类问题的一种结合策略。基本思想是选择所有机器学习算法当中输出最多的那个类。机器学习分类算法的输出有两种类型:一种是直接输出类标签,另外一种是输出类概率,使用前者...

    投票机制(voting)是集成学习里面针对分类问题的一种结合策略。基本思想是选择所有机器学习算法当中输出最多的那个类。机器学习分类算法的输出有两种类型:一种是直接输出类标签,另外一种是输出类概率,使用前者进行投票叫做硬投票(Majority/Hard voting),使用后者进行分类叫做软投票(Soft voting)。 sklearn中的投票机制使用VotingClassifier来实现。本文以iris数据集为例做实验验证!

    1.硬投票是选择算法输出最多的标签,如果标签数量相等,那么按照升序的次序进行选择。实例代码如下:

    from sklearn import datasets
    from sklearn.model_selection import cross_val_score
    from sklearn.linear_model import LogisticRegression
    from sklearn.naive_bayes import GaussianNB
    from sklearn.ensemble import RandomForestClassifier
    import xgboost as xgb
    from sklearn.ensemble import VotingClassifier
    iris = datasets.load_iris()
    X, y = iris.data[:,1:3], iris.target
    clf1 = LogisticRegression(random_state=1)
    clf2 = RandomForestClassifier(random_state=1)
    clf3 = GaussianNB()
    clf4 = xgb.XGBClassifier(max_depth=5, learning_rate=0.1, n_estimators=160) 
    eclf = VotingClassifier(estimators=[('lr',clf1),('rf',clf2),('gnb',clf3),('xgb',clf4)], voting='hard')
    #使用投票法将三个模型结合在以前,estimotor采用 [(name1,clf1),(name2,clf2),...]这样的输入,和Pipeline的输入相同 voting='hard'表示硬投票
    for clf, clf_name in zip([clf1, clf2, clf3, clf4, eclf],['Logistic Regrsssion', 'Random Forest', 'naive Bayes', 'xgboost', 'Ensemble']):
        scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
        print('Accuracy: {:.2f} (+/- {:.2f}) [{}]'.format(scores.mean(), scores.std(), clf_name))
    
    
    Accuracy: 0.90 (+/- 0.05) [Logistic Regrsssion]
    Accuracy: 0.93 (+/- 0.05) [Random Forest]
    Accuracy: 0.91 (+/- 0.04) [naive Bayes]
    Accuracy: 0.95 (+/- 0.05) [xgboost]
    Accuracy: 0.95 (+/- 0.05) [Ensemble]
    

    2.软投票是使用各个算法输出的类概率来进行类的选择,输入权重的话,会得到每个类的类概率的加权平均值,值大的类会被选择。

    from itertools import product
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import datasets
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.svm import SVC
    from sklearn.ensemble import RandomForestClassifier
    import xgboost as xgb
    from sklearn.ensemble import VotingClassifier
    
    iris = datasets.load_iris()
    X = iris.data[:,[0,2]] #取两列,方便绘图
    y = iris.target
    #实例化分类器
    clf1 = DecisionTreeClassifier(max_depth=4)
    clf2 = KNeighborsClassifier(n_neighbors=7)
    clf3 = SVC(kernel='rbf', probability=True)
    clf4 = RandomForestClassifier(random_state=1)
    clf5 = xgb.XGBClassifier(max_depth=5, learning_rate=0.1, n_estimators=160) 
    
    eclf = VotingClassifier(estimators=[('dt',clf1),('knn',clf2),('svc',clf3),('rf',clf4),('xgb',clf5)], voting='soft', weights=[2,1,1,2,3])
    #weights控制每个算法的权重, voting=’soft' 使用了软权重
    #模型训练
    clf1.fit(X,y)
    clf2.fit(X,y)
    clf3.fit(X,y)
    clf4.fit(X,y)
    clf5.fit(X,y)
    eclf.fit(X,y)
    #网格范围限定
    x_min, x_max = X[:,0].min() -1, X[:,0].max() + 1
    y_min, y_max = X[:,1].min() -1, X[:,1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))  #创建网格
    #zhou=np.c_[xx.ravel(), yy.ravel()]
    #plt.imshow(xx)
    fig, axes = plt.subplots(3, 2, sharex='col', sharey='row', figsize=(10, 8)) #共享X轴和Y轴
    #for idx, clf, title in zip(product([0, 1],[0, 1]) #这里的顺序同plt.subplots(3, 2)的维度。
    for idx, clf, title in zip(product([0, 1,2],[0, 1]),
                               [clf1, clf2, clf3, clf4,clf5,eclf],
                               ['Decision Tree (depth=4)', 'KNN (k=7)',
                                'Kernel SVM','RandomForest','xgboost', 'Soft Voting']):
        Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) #起初我以为是预测的X的值,实际上是预测了上面创建的网格的值,以这些值来进行描绘区域
        Z = Z.reshape(xx.shape)
        axes[idx[0], idx[1]].contourf(xx, yy, Z, alpha=0.4) #绘制等高线
        axes[idx[0], idx[1]].scatter(X[:, 0],X[:, 1], c=y, s=20, edgecolor='k') #花上散点,颜色数=类别数
        axes[idx[0], idx[1]].set_title(title)
    plt.show()
    
    #for idx, clf, title in zip(product([0,1, 2],[0,1]),
    #                           [clf1, clf2, clf3, clf4,clf5,eclf],
    #                           ['Decision Tree (depth=4)', 'KNN (k=7)',
    #                            'Kernel SVM','RandomForest','xgboost', 'Soft Voting']):
    #    print(idx)
    #    print('================')    
    
    #对于感兴趣的语句可以单独提取出来研究,因为Python既很好的支持面向过程,又能很好的支持面向对象封装
    fig, axes = plt.subplots(3, 2, sharex='col', sharey='row', figsize=(10, 8)) #共享X轴和Y轴
    #for idx, clf, title in zip(product([0, 1],[0, 1]) #这里的顺序同plt.subplots(3, 2)的维度。
    for idx, clf, title in zip(product([0, 1,2],[0, 1]),
                               [clf1, clf2, clf3, clf4,clf5,eclf],
                               ['Decision Tree (depth=4)', 'KNN (k=7)',
                                'Kernel SVM','RandomForest','xgboost', 'Soft Voting']):
        Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) #起初我以为是预测的X的值,实际上是预测了上面创建的网格的值,以这些值来进行描绘区域
        Z = Z.reshape(xx.shape)
        axes[idx[0], idx[1]].contourf(xx, yy, Z, alpha=0.4) #绘制等高线
        #axes[idx[0], idx[1]].scatter(X[:, 0],X[:, 1], c=y, s=20, edgecolor='k')
        axes[idx[0], idx[1]].set_title(title)
    plt.show()
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 针对无线传感器网络节点易被捕获,导致网络中可能存在恶意节点等特点,提出了一种基于信誉-投票合作机制的恶意节点检测算法MNDRVM.该算法不同于以往的恶意节点检测方法,它利用基站广播控制信息给网内所有节点,...
  • 基于随机森林和投票机制的大数据样例选择算法
  • _基于投票机制和开源框架的大数据约简研究.caj
  • 法定人数投票要求有一定的投票者门槛(投票阈值),以使提案获得通过(例如:60%的法定人数,这意味着需要60%的投票权来投票)。一旦达到这个门槛,拥有更多的票数的决策就会获胜。没有达到法定人数门槛,提案就会...
  • 基于卷积神经网络和投票机制的三维模型分类与检索.pdf
  • 文章目录Voting即投票机制1)使用方式2)思想Hard VotingSoft VotingHard Voting 投票方式的弊端:硬投票代码软投票代码 机器学习的算法有很多,对于每一种机器学习算法,考虑问题的方式都略微有所不同,所以对于同...
  • 区块链投票机制

    千次阅读 2018-09-04 22:46:46
    那么如何在区块链上进行投票呢?设想一下,竞选委员为每个候选人或待选人创建一种数字“钱包”,经过授权的 选民每选一个席位就放一个代币或其他币。公民可以通过个人化身匿名投票,只要把“币”传送到所选候选人的...
  • 点击上方“AI算法修炼营”,选择“星标”公众号精选作品,第一时间送达本文收录于ECCV2020,从自下而上的角度出发,在目标检测任务中引入了投票机制,使得HoughNet能够集成近距离和...
  • 投票 如何训练多数规则分类器(硬投票): #训练多数规则分类器: from sklearn import datasets from sklearn.model_selection import cross_val_score from sklearn.linear_model import LogisticRegression ...
  • 也就是对于任何一个分类任务,训练n个弱分类器,也就是分类准确度只比随机猜好一点,那么当n足够大的时候,通过投票机制,也能提升很大的准确度:毕竟每个网络都分错同一个数据的可能性会降低。 接下来就是代码实现...
  • 投票法可以根据权重,或者直接平均,将模型的预测结果进行融合。 均值 pre = (pre1 + pre2 + pre3 +…+pren )/n 加权平均 pre = 0.1pre1 + 0.2pre2 +0.7pre3 1.简单均值投票法(hard voting) from
  • 2 pytorch综合多个弱分类器,投票机制,进行手写数字分类(boosting) 3 Stacking原理 4 Stacking分类应用 5 kaggle气胸病灶图像分割top4解决方案 1 基础原理 在所有集成学习方法中,最直观的是多数投票。因为其...
  • 浅谈投票制度

    2021-11-05 15:03:34
    浅谈投票制度前言投票制度的定义术语偏好概况决策方法合理投票制度应具有的性质选民中立性概念不满足此性质的决策方法举例候选人中立性概念不满足此性质的决策方法举例单调性概念不满足此性质的决策方法举例几乎具有...
  • 默认是采用投票数大于半数则胜出的逻辑。 选举流程简述 目前有5台服务器,每台服务器均没有数据,它们的编号分别是1,2,3,4,5,按编号依次启动,它们的选择举过程如下: 服务器1启动,给自己投票,然后发投票信息,...
  • 在二次投票 (QV) 下,代理人从票据交换所购买支持其首选替代方案的选票,支付购买选票数量的平方; 购买的所有选票的总和决定了结果。 我们在具有有界价值分布的规范独立私人价值环境中为这种机制提供了第一个严格...
  • 嵩嵩评选投票系统2017是一个以asp+access进行开发的asp投票系统源码。 系统主要功能特点: 1.支持3种不同的显示风格 2.可设置是否能按天重新投票 3.可设置精确的投票开始时间与结束时间 4.可设置投票总数量上限 5....
  • EOS系列 - DPOS, Stake与投票机制

    千次阅读 2019-12-24 19:55:59
    EOS的DPOS, Stake与投票机制 DPOS EOS.IO软件架构中采用的共识算法。根据这种算法,全网持有代币的人可以通过投票系统来选择区块生产者,一旦当选任何人都可以参与区块的生产。 出块机制 超级节点轮流出块,每轮每个...
  • 集成学习投票

    千次阅读 2021-04-14 19:26:30
    投票机制(voting)是集成学习里面针对分类问题的一种结合策略,基本思想是融合多个数据来降低误差。 对于回归模型:投票法最终的预测结果是多个其他回归模型预测结果的平均值。 对于分类模型:硬投票法的预测结果是多...
  • 但是为了客观的评价和产生结果,往往都会采用“少数服从多数”的投票机制。那么在机器学习中,也有类似的用法:针对同一个数据集,不同的模型由于本身的特性不同或是同一个模型由于超参数的设置不同等都会产生不同的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,889
精华内容 21,155
关键字:

投票机制