精华内容
下载资源
问答
  • 基于当前repo优化后,A / B榜皆是Top1,代码整理中,后续会陆续放上来! 博客: 优化思路 岗位培训 m 提升mlm任务中的mask策略,提升灵活性,提高下游性能:挖掘新词,加入字典,整个word mask + dynamic mask 挖掘...
  • ijcai-2018 top1 solution 一.Graft Learning 首先科普一下什么是嫁接。 在生产实践过程中,嫁接对经济价值的提高,也有着非常多的实例:如普通的水杉,价值一元;而通过嫁接手段,培育成金叶水杉后,经济价值提高20...
  • 视频点击预测大赛-TOP1方案 CNS队员: 沉琢乔中国海洋大学大四 朱锐YOHO 算法工程师
  • 大规模资金流入流出预测Top1与Top2答辩pdf,天池大数据预测答辩ppt,时间序列预测,大学生服务外包
  • 本文来自阿里范围老师的分享。 1、淘宝体系架构的演进   2、淘宝商品架构   3、元数据在淘宝商品中...=>更多行业权威架构案例、领域标准及技术趋势请关注微信公众号 ‘软件真理与光’: ...作者:国家级软件工程
  • Top1ACC

    2021-04-16 17:20:29
    Top1ACCTop1ACCTop1ACC

    T o p 1 A C C Top1ACC Top1ACC

    准确率(accuracy): (TP + TN )/( TP + FP + TN + FN)

    Acc:所有预测正确的/所有

    #  for major_test
    import torch
    import major_config
    import torchvision.transforms as transforms
    from torch.utils.data import DataLoader
    from major_dataset import LoadDataset
    
    def evaluteTop1(model, loader):
        model.eval()
    
        correct = 0
        total = len(loader.dataset)
    
        for x, y in loader:
            #x, y = x.to(major_config.device), y.to(major_config.device)
            with torch.no_grad():
                logits = model(x)
                pred = logits.argmax(dim=1)
                correct += torch.eq(pred, y).sum().float().item()
            # correct += torch.eq(pred, y).sum().item()
        return correct / total
    
    
    def evaluteTop5(model, loader):
        model.eval()
        correct = 0
        total = len(loader.dataset)
        for x, y in loader:
            #x, y = x.to(major_config.device), y.to(major_config.device)
            with torch.no_grad():
                logits = model(x)
                maxk = max((1, 5))
                y_resize = y.view(-1, 1)
                _, pred = logits.topk(maxk, 1, True, True)
                correct += torch.eq(pred, y_resize).sum().float().item()
        return correct / total
    
    if __name__ == "__main__":
        # 1.加载测试数据
        # 1.1 预处理
        test_transform = transforms.Compose([
            transforms.Resize((32, 32)),
            transforms.ToTensor(),
            transforms.Normalize(major_config.norm_mean, major_config.norm_std),
        ])
        # 1.2 数据加载
        test_data = LoadDataset(data_dir=major_config.test_image, transform=test_transform)
        test_loader = DataLoader(dataset=test_data, batch_size=10, shuffle=True)  # shuffle训练时打乱样本
    
        # 2.加载模型
        net = major_config.model  # 对应修改模型 net = se_resnet50(num_classes=5,pretrained=True)
        path_model_state_dict = major_config.path_test_model
        net.load_state_dict(torch.load(path_model_state_dict))
    
        # 3.评测
        res_top1 = evaluteTop1(net,test_loader)
        print(res_top1)
        res_top5 = evaluteTop5(net,test_loader)
        print(res_top5)
    
    展开全文
  • ↑↑↑关注后"星标"Datawhale每日干货&每月组队学习,不错过Datawhale干货作者:望尼玛,浙江大学,Datawhale优秀选手知乎|https://www.z...

    ↑↑↑关注后"星标"Datawhale

    每日干货 & 每月组队学习,不错过

     Datawhale干货 

    作者:望尼玛,浙江大学,Datawhale优秀选手

    知乎|https://www.zhihu.com/people/lin-a-bi-78/posts

    1. 引言

    Hello,大家好。我是“摸鱼打比赛”队的wangli,首先介绍下自己吧,一枚半路出家的野生算法工程师。之所以起名字叫摸鱼打比赛,是因为当时5/6月份自己还处于业务交接没那么忙的一个状态中,然后想起自己也已经毕业两年,但对赛圈一直还是比较关注的,平日看到一些题目也会手痒,但奈何打工人下班之后惰性使然只想躺平,毕业之后始终没有好好打一场比赛,偶尔也会在深夜里问起自己:“廉颇老矣,尚能饭否”,就想着,这回我就利用下这段尚且不忙的日子好好打一场比赛吧。于是我就参加了这次的比赛,不仅侥幸获得了车贷这个小比赛的第一,然后还结识了一些好友,比如我尚在读研的队友陈兄,以及忙于秋招中的好友崔兄。真是收获满满~

    那么,接下来我就给大家介绍一下这场比赛中,我的一些具体的解题思路和感悟。

    2. 赛题背景

    赛题链接:https://challenge.xfyun.cn/topic/info?type=car-loan

    可以看到,这个赛题做的是车贷违约预测问题,基于,参赛选手们需要建立风险识别模型来预测可能违约的借款人。这道赛题,相比其他赛题,车贷违约预测这道题的难度是没那么大的,原因有二:

    • 赛题难度:非常传统的风控逾期预测,二分类问题,很多其他比赛的代码可能稍微改一下就能套上来用;

    • 竞争程度:赛题本身的奖金并不多,因此参赛的选手也不多。

    我个人是前期在打商品推荐赛(同“摸鱼打比赛”ID)的时候顺便打一下这个比赛,在最后几天有认真去挖了一些特征。(说到这个基于用户画像的商品推荐赛,就有点惭愧,前期感觉自己还是可以一战的,一度是在Top 3的,后面8月开始由于工作太忙,复赛开始之后就一直没有提交,说到底还是自己时间管理能力太菜了。就看看国庆期间能不能有时间再做一下吧)

    再说回这个比赛:

    • 数据量的话还是可以的,其中 训练集15w,测试集3w

    • 包含52个特征字段,各个字段主办方也是给了相应的解释

    • 评估指标:F1 Score

    所以,其实可以很快的写出一个baseline来,对于数据新手来说,是一个比较友好的比赛了。

    3. 解题思路

    这种偏数据挖掘的比赛的关键点在于如何基于对数据的理解抽象归纳出有用的特征,因此,我一开始做的时候,并没有想着说去套各种高大上的模型,而是通过对数据的分析去构造一些特征。如果不想往后看代码的话,我在这一章节会简单把我的整个方案讲一下:

    • 正负样本分布:可以看到这道题的正负样本比为 82:18 这样,在风控里面其实已经属于正负样本分布较为平衡的数据了,所以我在比赛中,并没有刻意的去往正负样本不平衡这块去做,有做了一些过采样的尝试,但效果反而不增反降。

    • 特征工程:

    首先我一开始就发现有很多ID类的特征,然后我就基于这些ID类特征做了一些target encoding特征,这些简单的特征 + 树模型就已经0.583了,能让我前期一直处在Top 10;

    而后,从业务角度构造了一些诸如:主账户和二级账户的年利率特征(因为往往银行的利率表现了其对用户的信用预测);从数据分布角度对一些金额类的特征做了些分箱操作;再从特征本身的有效性和冗余角度出发,剔除了一些毫无信息量的特征,比如贷款日期等。这时,我们可以做到0.587这样的水平;

    然后,在一次误打误撞的模型训练时,我误把客户ID放进模型中去训练了,结果我发现似乎还对模型性能有一定提升?那我这时候的想法是:这一定是由于欺诈有些集中性导致的,黑产可能在借贷银行(where)或借贷时间(when)上存在一定的集中性,而这种集中性一方面可以通过branch_id/supplier_id/manufacturer_id等反映出来,另一方面,本身客户的customer_id也是可以体现时间上的集中性,因此,我又基于这个点构造了近邻欺诈特征,这时候我们就能做到0.589了;

    模型选取

    前期,我一直是用的LightGBM,然后也没有很仔细的去调参(比如hyperopt/ optuna等工具,我都没有用),就很随意(平平无奇的手动调参小天才)

    后期,我开始尝试其他的XGBoost/CatBoost/TabNet等模型,但是发现CatBoost和TabNet效果都不是很好,就没有深入往下去钻了(主要白天还是要上班的,因此精力有限,说是摸鱼打比赛,但更准确的说是 熬夜打比赛)

    阈值选取:由于该题是用F1 Score作为评判标准的,因此,我们需要自己划一个阈值,然后决定哪些样本预测为正样本,哪些样本预测为负样本。在尝试了不同方案后,我们的方案基于oof的预测结果,选出一个在oof上表现最优的阈值,此时在榜上的效果是最佳的(千分位的提升)

    融合策略:最后选定了两个模型来融合,一个是LightGBM,一个是XGBoost(哈哈哈,就很土有没有),然后,直接按预测概率加权融合的话效果是比较一般的,而按照其ranking值分位点化之后再加权融合效果会更好。效果而言,单模LGB最优是0.5892,XGB是在0.5872这边,按照概率加权最优是0.59011,按照排序加权最优是0.59038

    其实主要思路和方案,就如同上述文字所描述的了。但看起来总是干巴巴的,如果你还对代码有兴趣的话,可以继续往下看。毕竟 Talk is Cheap, :)

    4. 具体实现 & 代码详解

    4.1 特征工程

    • target encoding/mean encoding,这里要注意的是,为了防止过拟合,需要分折来做

    # 用来TG编码的特征:
    TARGET_ENCODING_FETAS = [
                                'employment_type',
                                 'branch_id',
                                 'supplier_id',
                                 'manufacturer_id',
                                 'area_id',
                                 'employee_code_id',
                                 'asset_cost_bin'
                             ]
    
    # 具体实现:
    def gen_target_encoding_feats(train, test, encode_cols, target_col, n_fold=10):
        '''生成target encoding特征'''
        # for training set - cv
        tg_feats = np.zeros((train.shape[0], len(encode_cols)))
        kfold = StratifiedKFold(n_splits=n_fold, random_state=1024, shuffle=True)
        for _, (train_index, val_index) in enumerate(kfold.split(train[encode_cols], train[target_col])):
            df_train, df_val = train.iloc[train_index], train.iloc[val_index]
            for idx, col in enumerate(encode_cols):
                target_mean_dict = df_train.groupby(col)[target_col].mean()
                df_val[f'{col}_mean_target'] = df_val[col].map(target_mean_dict)
                tg_feats[val_index, idx] = df_val[f'{col}_mean_target'].values
    
        for idx, encode_col in enumerate(encode_cols):
            train[f'{encode_col}_mean_target'] = tg_feats[:, idx]
    
        # for testing set
        for col in encode_cols:
            target_mean_dict = train.groupby(col)[target_col].mean()
            test[f'{col}_mean_target'] = test[col].map(target_mean_dict)
    
        return train, test
    • 年利率特征/分箱等特征:

    def gen_new_feats(train, test):
        '''生成新特征:如年利率/分箱等特征'''
        # Step 1: 合并训练集和测试集
        data = pd.concat([train, test])
    
        # Step 2: 具体特征工程
        # 计算二级账户的年利率
        data['sub_Rate'] = (data['sub_account_monthly_payment'] * data['sub_account_tenure'] - data[
            'sub_account_sanction_loan']) / data['sub_account_sanction_loan']
    
        # 计算主账户的年利率
        data['main_Rate'] = (data['main_account_monthly_payment'] * data['main_account_tenure'] - data[
            'main_account_sanction_loan']) / data['main_account_sanction_loan']
    
        # 对部分特征进行分箱操作
        # 等宽分箱
        loan_to_asset_ratio_labels = [i for i in range(10)]
        data['loan_to_asset_ratio_bin'] = pd.cut(data["loan_to_asset_ratio"], 10, labels=loan_to_asset_ratio_labels)
        # 等频分箱
        data['asset_cost_bin'] = pd.qcut(data['asset_cost'], 10, labels=loan_to_asset_ratio_labels)
        # 自定义分箱
        amount_cols = [
                       'total_monthly_payment',
                       'main_account_sanction_loan',
                       'main_account_disbursed_loan',
                       'sub_account_sanction_loan',
                       'sub_account_disbursed_loan',
                       'main_account_monthly_payment',
                       'sub_account_monthly_payment',
                       'total_sanction_loan'
                    ]
        amount_labels = [i for i in range(10)]
        for col in amount_cols:
            total_monthly_payment_bin = [-1, 5000, 10000, 30000, 50000, 100000, 300000, 500000, 1000000, 3000000, data[col].max()]
            data[col + '_bin'] = pd.cut(data[col], total_monthly_payment_bin, labels=amount_labels).astype(int)
    
        # Step 3: 返回包含新特征的训练集 & 测试集
        return data[data['loan_default'].notnull()], data[data['loan_default'].isnull()]
    • 近邻欺诈特征(ID前后10个近邻的欺诈概率,其实可以更多不同尝试寻找最优的近邻数,但精力有限哈哈)

    def gen_neighbor_feats(train, test):
        '''产生近邻欺诈特征'''
        if not os.path.exists('../user_data/neighbor_default_probs.pkl'):
            # 该特征需要跑的时间较久,因此将其存成了pkl文件
            neighbor_default_probs = []
            for i in tqdm(range(train.customer_id.max())):
                if i >= 10 and i < 199706:
                    customer_id_neighbors = list(range(i - 10, i)) + list(range(i + 1, i + 10))
                elif i < 199706:
                    customer_id_neighbors = list(range(0, i)) + list(range(i + 1, i + 10))
                else:
                    customer_id_neighbors = list(range(i - 10, i)) + list(range(i + 1, 199706))
    
                customer_id_neighbors = [customer_id_neighbor for customer_id_neighbor in customer_id_neighbors if
                                         customer_id_neighbor in train.customer_id.values.tolist()]
                neighbor_default_prob = train.set_index('customer_id').loc[customer_id_neighbors].loan_default.mean()
                neighbor_default_probs.append(neighbor_default_prob)
    
            df_neighbor_default_prob = pd.DataFrame({'customer_id': range(0, train.customer_id.max()),
                                                     'neighbor_default_prob': neighbor_default_probs})
            save_pkl(df_neighbor_default_prob, '../user_data/neighbor_default_probs.pkl')
        else:
            df_neighbor_default_prob = load_pkl('../user_data/neighbor_default_probs.pkl')
        train = pd.merge(left=train, right=df_neighbor_default_prob, on='customer_id', how='left')
        test = pd.merge(left=test, right=df_neighbor_default_prob, on='customer_id', how='left')
    
        return train, test

    最终我只选取了47维特征:

    USED_FEATS = [
                     'customer_id',
                     'neighbor_default_prob',
                     'disbursed_amount',
                     'asset_cost',
                     'branch_id',
                     'supplier_id',
                     'manufacturer_id',
                     'area_id',
                     'employee_code_id',
                     'credit_score',
                     'loan_to_asset_ratio',
                     'year_of_birth',
                     'age',
                     'sub_Rate',
                     'main_Rate',
                     'loan_to_asset_ratio_bin',
                     'asset_cost_bin',
                     'employment_type_mean_target',
                     'branch_id_mean_target',
                     'supplier_id_mean_target',
                     'manufacturer_id_mean_target',
                     'area_id_mean_target',
                     'employee_code_id_mean_target',
                     'asset_cost_bin_mean_target',
                     'credit_history',
                     'average_age',
                     'total_disbursed_loan',
                     'main_account_disbursed_loan',
                     'total_sanction_loan',
                     'main_account_sanction_loan',
                     'active_to_inactive_act_ratio',
                     'total_outstanding_loan&##39;,
                     'main_account_outstanding_loan',
                     'Credit_level',
                     'outstanding_disburse_ratio',
                     'total_account_loan_no',
                     'main_account_tenure',
                     'main_account_loan_no',
                     'main_account_monthly_payment',
                     'total_monthly_payment',
                     'main_account_active_loan_no',
                     'main_account_inactive_loan_no',
                     'sub_account_inactive_loan_no',
                     'enquirie_no',
                     'main_account_overdue_no',
                     'total_overdue_no',
                     'last_six_month_defaulted_no'
                ]

    4.2 模型训练

    • LightGBM(十折效果更优)

    def train_lgb_kfold(X_train, y_train, X_test, n_fold=5):
        '''train lightgbm with k-fold split'''
        gbms = []
        kfold = StratifiedKFold(n_splits=n_fold, random_state=1024, shuffle=True)
        oof_preds = np.zeros((X_train.shape[0],))
        test_preds = np.zeros((X_test.shape[0],))
    
        for fold, (train_index, val_index) in enumerate(kfold.split(X_train, y_train)):
            logging.info(f'############ fold {fold} ###########')
            X_tr, X_val, y_tr, y_val = X_train.iloc[train_index], X_train.iloc[val_index], y_train[train_index], y_train[val_index]
            dtrain = lgb.Dataset(X_tr, y_tr)
            dvalid = lgb.Dataset(X_val, y_val, reference=dtrain)
    
            params = {
                'objective': 'binary',
                'metric': 'auc',
                'num_leaves': 64,
                'learning_rate': 0.02,
                'min_data_in_leaf': 150,
                'feature_fraction': 0.8,
                'bagging_fraction': 0.7,
                'n_jobs': -1,
                'seed': 1024
            }
    
            gbm = lgb.train(params,
                            dtrain,
                            num_boost_round=1000,
                            valid_sets=[dtrain, dvalid],
                            verbose_eval=50,
                            early_stopping_rounds=20)
    
            oof_preds[val_index] = gbm.predict(X_val, num_iteration=gbm.best_iteration)
            test_preds += gbm.predict(X_test, num_iteration=gbm.best_iteration) / kfold.n_splits
            gbms.append(gbm)
    
        return gbms, oof_preds, test_preds
    • XGBoost

    def train_xgb_kfold(X_train, y_train, X_test, n_fold=5):
        '''train xgboost with k-fold split'''
        gbms = []
        kfold = StratifiedKFold(n_splits=10, random_state=1024, shuffle=True)
        oof_preds = np.zeros((X_train.shape[0],))
        test_preds = np.zeros((X_test.shape[0],))
    
        for fold, (train_index, val_index) in enumerate(kfold.split(X_train, y_train)):
            logging.info(f'############ fold {fold} ###########')
            X_tr, X_val, y_tr, y_val = X_train.iloc[train_index], X_train.iloc[val_index], y_train[train_index], y_train[val_index]
            dtrain = xgb.DMatrix(X_tr, y_tr)
            dvalid = xgb.DMatrix(X_val, y_val)
            dtest = xgb.DMatrix(X_test)
    
            params={
                'booster':'gbtree',
                'objective': 'binary:logistic',
                'eval_metric': ['logloss', 'auc'],
                'max_depth': 8,
                'subsample':0.9,
                'min_child_weight': 10,
                'colsample_bytree':0.85,
                'lambda': 10,
                'eta': 0.02,
                'seed': 1024
            }
    
            watchlist = [(dtrain, 'train'), (dvalid, 'test')]
    
            gbm = xgb.train(params,
                            dtrain,
                            num_boost_round=1000,
                            evals=watchlist,
                            verbose_eval=50,
                            early_stopping_rounds=20)
    
            oof_preds[val_index] = gbm.predict(dvalid, iteration_range=(0, gbm.best_iteration))
            test_preds += gbm.predict(dtest, iteration_range=(0, gbm.best_iteration)) / kfold.n_splits
            gbms.append(gbm)
    
        return gbms, oof_preds, test_preds

    4.3 模型融合与阈值选取

    def gen_submit_file(df_test, test_preds, thres, save_path):
        df_test['test_preds_binary'] = np.where(test_preds > thres, 1, 0)
        df_test_submit = df_test[['customer_id', 'test_preds_binary']]
        df_test_submit.columns = ['customer_id', 'loan_default']
        print(f'saving result to: {save_path}')
        df_test_submit.to_csv(save_path, index=False)
        print('done!')
        return df_test_submit
    
    def gen_thres_new(df_train, oof_preds):
        df_train['oof_preds'] = oof_preds
        quantile_point = df_train['loan_default'].mean()
        thres = df_train['oof_preds'].quantile(1 - quantile_point)
    
        _thresh = []
        for thres_item in np.arange(thres - 0.2, thres + 0.2, 0.01):
            _thresh.append(
                [thres_item, f1_score(df_train['loan_default'], np.where(oof_preds > thres_item, 1, 0), average='macro')])
    
        _thresh = np.array(_thresh)
        best_id = _thresh[:, 1].argmax()
        best_thresh = _thresh[best_id][0]
    
        print("阈值: {}\n训练集的f1: {}".format(best_thresh, _thresh[best_id][1]))
        return best_thresh
    
    # 结果
    df_oof_res = pd.DataFrame({'customer_id': train['customer_id'],
                               'oof_preds_xgb': oof_preds_xgb,
                               'oof_preds_lgb': oof_preds_lgb,
                               'loan_default': train['loan_default']
                              })
    
    # 模型融合
    df_oof_res['xgb_rank'] = df_oof_res['oof_preds_xgb'].rank(pct=True)
    df_oof_res['lgb_rank'] = df_oof_res['oof_preds_lgb'].rank(pct=True)
    df_oof_res['preds'] = 0.31 * df_oof_res['xgb_rank'] + 0.69 * df_oof_res['lgb_rank']
    
    # 得到最优阈值
    thres = gen_thres_new(df_oof_res, df_oof_res['preds'])
    
    df_test_res = pd.DataFrame({'customer_id': test['customer_id'],
                                'test_preds_xgb': test_preds_xgb,
                                'test_preds_lgb': test_preds_lgb})
    
    df_test_res['xgb_rank'] = df_test_res['test_preds_xgb'].rank(pct=True)
    df_test_res['lgb_rank'] = df_test_res['test_preds_lgb'].rank(pct=True)
    df_test_res['preds'] = 0.31 * df_test_res['xgb_rank'] + 0.69 * df_test_res['lgb_rank']
    
    # 结果产出
    df_submit = gen_submit_file(df_test_res, df_test_res['preds'], thres,
                                save_path='../prediction_result/result.csv')

    完整代码

    Github地址:

    https://github.com/WangliLin/xunfei2021_car_loan_top1

    结果复现直接运行sh test.sh 即可。

    8404417ad04f33316c8fb5a681a6e206.png

    整理不易,三连

    展开全文
  • :dumpling:交子杯 - 2020 - AI赛道 - TOP1 summary 陆陆续续两个月的赛程结束了,从初赛A榜27到B榜第4,再到决赛A,B双榜第一,有过断断续续排名下降即将无缘现场决赛的失落,也有过现场决赛等待被超越的12小时,...
  • 分类网络中的top1和top5

    千次阅读 2020-05-21 07:42:26
    labels, topk=(1, 5)) top1.update(prec1, labels.size(0)) top5.update(prec5, labels.size(0)) print('Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(top1=top1, ...
    import torchvision
    import torch
    import torch.utils.data.dataloader as dataloader
    import torchvision.datasets as datasets
    import torchvision.transforms as transforms
    import torch.nn as nn
    import torch.optim as optim
    #  加载数据和处理数据
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
    
    train_data = torchvision.datasets.CIFAR10(root="./data", train=True, transform=transform, download=True)
    test_data = torchvision.datasets.CIFAR10(root="./data", train=False, transform=transform, download=True)
    
    train_loader = dataloader.DataLoader(dataset=train_data, shuffle=False, batch_size=4, num_workers=2)
    test_loader = dataloader.DataLoader(dataset=test_data, shuffle=True, batch_size=4, num_workers=2)
    
    
    #  定义网络
    class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__(),
            self.layer1 = nn.Sequential(
                nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3),
                nn.ReLU(),
                nn.MaxPool2d(2, 2)
            )
            self.layer2 = nn.Sequential(
                nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),
                nn.ReLU(),
                nn.MaxPool2d(2, 2)
            )
            self.layer3 = nn.Sequential(
                nn.Linear(5 * 5 * 16, 120),
                nn.Linear(120, 84),
                nn.Linear(84, 10)
            )
    
        def forward(self, x):
            x = self.layer1(x)
            x = self.layer2(x)
            x = x.view(-1, 5 * 5 * 16)
            x = self.layer3(x)
            return x
    
    
    #  实例化
    cnn = CNN()
    
    #  损失函数和优化
    loss_f = nn.CrossEntropyLoss()
    optim = optim.SGD(params=cnn.parameters(), lr=0.001, momentum=0.9)
    
    
    class AverageMeter(object):
        """Computes and stores the average and current value"""
        def __init__(self):
            self.reset()
    
        def reset(self):
            self.val = 0
            self.avg = 0
            self.sum = 0
            self.count = 0
    
        def update(self, val, n=1):
            self.val = val
            self.sum += val * n
            self.count += n
            self.avg = self.sum / self.count
    
    
    #  准确率
    def accuracy(output, target, topk=(1,)):
        maxk = max(topk) #topk=(1,)取top1准确率,topk=(1,5)取top1和top5准确率
        batch_size = target.size(0)
        _, pred = output.topk(maxk, 1, True, True) # topk参数中,maxk取得是top1准确率,dim=1是按行取值, largest=1是取最大值
        pred = pred.t()  # 转置
        correct = pred.eq(target.view(1, -1).expand_as(pred))  # 比较是否相等
    
        res = []
        for k in topk:
            correct_k = correct[:k].view(-1).float().sum(0)
            res.append(correct_k.mul_(100.0 / batch_size))
        return res
    
    
    #  train
    for i in range(2):
        losses = AverageMeter()
        top1 = AverageMeter()
        top5 = AverageMeter()
        for j, data in enumerate(train_loader, 0):
            inputs, labels = data
    
            optim.zero_grad()
    
            #  forward + backward + optimize
            outputs = cnn(inputs)
            loss = loss_f(outputs, labels)
            loss.backward()
            optim.step()
            # measure accuracy and record loss
            prec1 = accuracy(output=outputs, target=labels, topk=(1, 5))
            losses.update(loss.item(), labels.size(0))
            top1.update(prec1[0], labels.size(0))
            top5.update(prec1[1], labels.size(0))
            if j % 2000 == 1999:
                """
                top1.val是一个batch中的准确率, avg为准确率
                """
                print('Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                      'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
                      'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(loss=losses, top1=top1, top5=top5))
    
    #  测试
    top1 = AverageMeter()
    top5 = AverageMeter()
    for data in test_loader:
        inputs, labels = data
        outputs = cnn(inputs)
        prec1, prec5 = accuracy(outputs, labels, topk=(1, 5))
        top1.update(prec1, labels.size(0))
        top5.update(prec5, labels.size(0))
    
    print('Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
          'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(top1=top1, top5=top5))
    
    
    
    
    
    
    展开全文
  • Top1与Top5

    2020-04-25 14:40:43
    所谓TOP1 是指排名第一的类别与实际结果相符的准确率 所谓TOP5 是指排名前五的类别包含实际结果的准备率。 import numpy as np import tensorflow.keras.backend as K # 随机输出数字0~9的概率分布 output = K...

    分类任务中,会给出N个类别按照概率从高到低的类别排名。

      所谓TOP1 是指排名第一的类别与实际结果相符的准确率

      所谓TOP5 是指排名前五的类别包含实际结果的准备率。

    import numpy as np
    import tensorflow.keras.backend as K
    
    # 随机输出数字0~9的概率分布
    output = K.random_uniform_variable(shape=(1, 10), low=0, high=1)
    # 实际结果假设为数字1
    actual_pos = K.variable(np.array([1]), dtype='int32')
    print("数字0~9的预测概率分布为:", K.eval(output))
    print("实际结果为数字:", K.eval(actual_pos))
    print("实际结果是否in top 1: ", K.eval(K.in_top_k(output, actual_pos, 1)))
    print("实际结果是否in top 5: ", K.eval(K.in_top_k(output, actual_pos, 5)))

    运行结果

    数字0~9的预测概率分布为: [[0.301023   0.8182187  0.71007144 0.80164504 0.7268218  0.58599055 0.19250274 0.9076816  0.8101771  0.49439466]]
    实际结果为数字: [1]
    实际结果是否in top 1:  [False]
    实际结果是否in top 5:  [ True]
    展开全文
  • 《神经网络与深度学习》最新2018版中英PDF+源码 将机器学习模型部署为REST API FashionAI服装属性标签图像识别Top1-5方案分享 重要开源!CNN-RNN-CTC 实现手写汉字识别 yolo3 检测出图像中的不规则汉字 同样是机器...
  • 结论 直接上结论,既然是error所以,top-1 error rate和top-5 error rate越小说明模型越准确。 作用 出自于ImageNet,用于评判模型的性能,比如... top-1 error rate:只取概率最大的那1个类别,即top1,其他条件同上。
  • 残差网络 ResNet18 CIFAR-10 分类 计算top1-ACC,top3-ACC
  • top1st.github.io-源码

    2021-03-08 20:08:11
    /assets/images/top1st-sq.jpg 张希谦 网络和区块链开发人员 发现更多 /关于/ 错误的 财产 内容 og:url 财产 内容 og:title 张希谦| 网络和区块链开发人员 财产 内容 og:description 我是一名软件工程师,...
  • top1 top5错误率概念

    千次阅读 2020-05-24 10:43:45
    就是: top1-----就是你预测的label取最后概率向量里面最大的那一个作为预测结果,如过你的预测结果中概率最大的那个分类正确,则预测正确。否则预测错误 top5-----就是最后概率向量最大的前五名中,只要出现了正确...
  • top1和top5正确率的区别 top1:预测labels中,最后的概率向量中取最大的作为预测结果,如果最大的那个预测的分类结果正确就正确,若不正确则不正确。一般情况下默认是top1 top5:预测labels中,最后的概率向量中取...
  • import torch output = torch.tensor([[-5.4783, 0.2298], [-4.2573, -0.4794], [-0.1070, -5.1511], [-0.1785, -4.3339]]) 得到其top1值操作如下: maxk = max((1,)) # 取top1准确率,若取top1和top5准确率改为max...
  • 图片分类top1和top5

    2019-09-28 09:00:51
    Top-5错误率:预测一个图片,如果概率前五中包含正确答案,即认为正确。 Top-1错误率:预测一个图片,如果概率最大的是正确答案,才认为正确。 转载于:https://www.cnblogs.com/HL-blog/p/9620901.html...
  • top1与top5错误率

    千次阅读 2019-09-17 15:23:51
    top1错误率 top1就是你预测的label取最后概率向量里面最大的那一个作为预测结果,你的预测结果中概率最大的那个类必须是正确类别才算预测正确。而top5就是最后概率向量最大的前五名中出现了正确概率即为预测正确。 ...
  • ijcai-17-top1-single-mole-solution file 文件中包含答辩ppt和解决方案详细文档 比赛链接:
  • MatConvnet使用体验一:top1err出现大于1的情况自己构建网络进行训练时出现top1err大于1的情况 自己构建网络进行训练时出现top1err大于1的情况 原因是全连接层的输入不是1 X 1 X M X N的形式!这导致网络本身就是...
  • RepeT_Top1-源码

    2021-03-12 21:33:26
    RepeT_Top1
  • Pytorch实现Top1准确率和Top5准确率

    千次阅读 2019-09-23 09:20:24
    之前一直不清楚Top1和Top5是什么,其实搞清楚了很简单,就是两种衡量指标,其中,Top1就是普通的Accuracy,Top5比Top1衡量标准更“严格”, 具体来讲,比如一共需要分10类,每次分类器的输出结果都是10个相加为1的...
  • mysql实现topN top1

    千次阅读 2019-10-05 10:23:57
    有时会碰到一些需求,查询分组后的最大值,最小值所在的整行记录或者分组后的top n行的记录,像在hive中是有窗口函数的,可以通过它们来实现,但是MySQL没有这些函数,可通过下面的方法来实现 ...
  • 2 在每次迭代中计算混淆矩阵,然后求top1(即为准确率) !!!需要注意,我们平时说的top1就是准确率 def val(model, dataloader): ''' 计算模型在验证集上的准确率等信息,用以辅助训练 ''' opt = Default...
  • ↑↑↑关注后"星标"Datawhale每日干货&每月组队学习,不错过Datawhale干货作者:宋志龙、王威,啄云智能GOAT战队大家好,我们是来自浙江啄云智能科技有限公司...
  • 最终在dset1验证集(约含900张图,下同)上的Top1分类准确率约为0.52,在dset2验证集上的Top1准确率约为0.63。在K80显卡的单核上,该模型的训练速度约为205张图每秒,最终所得模型的checkpoint约为45MB。本报告将从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,313
精华内容 6,925
关键字:

top1