tcga.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 变量设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置数据集名称，对应 https://xenabrowser.net/datapages/ 中缩写\n",
    "dataset_name = ['LUAD', 'LUSC'] \n",
    "# 设置俩： ['LUAD', 'LUSC']\n",
    "# 单一个： ['LUAD'] \n",
    "method = 'normal' # diff是上面俩数据集的差异，normal是和正常样本的差异\n",
    "# method = 'diff'\n",
    "loglevel = ''\n",
    "# loglevel = 'debug'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据导入"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import os\n",
    "import gzip\n",
    "import shutil\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import defaultdict\n",
    "import seaborn as sns\n",
    "from sklearn import datasets\n",
    "import warnings\n",
    "import GEOparse\n",
    "from typing import Tuple, List\n",
    "from sklearn.metrics import  roc_curve, auc, precision_recall_curve, confusion_matrix, classification_report, accuracy_score, roc_auc_score, f1_score, precision_score, recall_score, confusion_matrix,fbeta_score\n",
    "from imblearn.over_sampling import SMOTE, SMOTEN\n",
    "sm = SMOTEN(random_state=42)\n",
    "from multiprocessing import Pool, cpu_count\n",
    "import ast\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import chi2\n",
    "from sklearn.feature_selection import f_classif\n",
    "from sklearn.feature_selection import mutual_info_classif\n",
    "from sklearn.linear_model import LinearRegression, RidgeClassifier, Lasso, LassoCV, LogisticRegression, LogisticRegressionCV, ElasticNet,ElasticNetCV,SGDClassifier,RidgeClassifierCV\n",
    "from sklearn.svm import SVC, LinearSVC, NuSVC\n",
    "from IPython.display import display, HTML\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def download_and_parse_data(dataset_name):\n",
    "    pkl_file_path = './datasets/' + 'TCGA-' + dataset_name + '.mirna_transposed.pkl'\n",
    "    if os.path.exists(pkl_file_path):\n",
    "        df_t = pd.read_pickle(pkl_file_path)\n",
    "    else:\n",
    "        url = \"https://gdc-hub.s3.us-east-1.amazonaws.com/download/TCGA-\" + dataset_name + \".mirna.tsv.gz\"\n",
    "        response = requests.get(url)\n",
    "        os.makedirs('./datasets', exist_ok=True)\n",
    "        gz_file_path = './datasets/' + 'TCGA-' + dataset_name + '.mirna.tsv.gz'\n",
    "        with open(gz_file_path, 'wb') as f_out:\n",
    "            f_out.write(response.content)\n",
    "        tsv_file_path = './datasets/' + 'TCGA-' + dataset_name + '.mirna.tsv'\n",
    "        with gzip.open(gz_file_path, 'rb') as f_in:\n",
    "            with open(tsv_file_path, 'wb') as f_out:\n",
    "                shutil.copyfileobj(f_in, f_out)\n",
    "        df = pd.read_csv(tsv_file_path, sep='\\t')\n",
    "        df_t = df.transpose()\n",
    "        df_t.columns = df_t.iloc[0]\n",
    "        df_t = df_t.drop(df_t.index[0])\n",
    "        df_t = np.power(2, df_t) - 1\n",
    "        df_t = df_t.round(4)\n",
    "        df_t['Status'] = df_t.index.map(lambda x: 1 if x.split('-')[3][:2] == '01' else 0)\n",
    "        df_t = df_t[['Status'] + [col for col in df_t.columns if col != 'Status']]\n",
    "        df_t.to_pickle(pkl_file_path)\n",
    "        os.remove(gz_file_path)\n",
    "        os.remove(tsv_file_path)\n",
    "    df_t = df_t.apply(pd.to_numeric)\n",
    "    return df_t\n",
    "\n",
    "def find_healthy_samples(df):\n",
    "    healthy_samples_df = df[df['Status'] == 0]\n",
    "    return healthy_samples_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "if method == \"diff\":\n",
    "    dataA = download_and_parse_data(dataset_name[0])\n",
    "    dataB = download_and_parse_data(dataset_name[1])\n",
    "\n",
    "    A_up = dataA[dataA['Status'] == 1]\n",
    "    B_up = dataB[dataB['Status'] == 1]\n",
    "\n",
    "    B_up['Status'] = 0\n",
    "    df_transposed = pd.concat([A_up, B_up], ignore_index=True)\n",
    "elif method == \"normal\":\n",
    "    df_transposed = pd.DataFrame()\n",
    "    for name in dataset_name:\n",
    "        df_transposed = df_transposed.append(download_and_parse_data(name))\n",
    "train_data = df_transposed.apply(pd.to_numeric)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 函数 准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义存储结果的DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_results = pd.DataFrame(columns=['method', 'model', 'n', 'acc', 'auc', 'f1', 'precision', 'recall', 'confusionmatrix','coef', 'coef_rounded', 'found_coef', 'multiple_times','intercept', 'miRNA_ID'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 可接受的权重的范围筛选器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_allowed_numbers(max_n=25,allowed_factors=[1,2,3,4,5]):\n",
    "    result = []\n",
    "    for x in allowed_factors:\n",
    "        for y in allowed_factors:\n",
    "            result.append(x*y)\n",
    "        result.append(x)\n",
    "    result = list(set(result))\n",
    "    return result\n",
    "\n",
    "def is_all_in_list(list,n=25,allowed_factors=[2,3,5]):\n",
    "    for i in list:\n",
    "        if i not in get_allowed_numbers(n,allowed_factors):\n",
    "            return False\n",
    "    return list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 画图"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分数分布图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_labels = ['得了', '没得']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_score_distribution(ax, y_score, final_Status):                                 # 这个函数负责处理分数分布图这一个小图\n",
    "    ax.scatter(range(len(y_score)), y_score, c=final_Status, cmap='bwr', alpha=0.5)     # 画散点图，x轴是样本序号，y轴是分数，颜色是感染情况，颜色映射是蓝白红，透明度是0.5\n",
    "                                                                                        # x是样本序号：分开画，免得都黏在一起了，透明度的设置是一样的原因。\n",
    "    ax.set_title('分数分布图')\n",
    "    ax.set_xlabel('样本序号')\n",
    "    ax.set_ylabel('分数')\n",
    "    plt.rcParams['font.sans-serif']=['SimHei']                                          # 中文乱码\n",
    "    plt.rcParams['axes.unicode_minus']=False                                            # 负号乱码\n",
    "    labels = plot_labels                                                                # 图例标签，这里是感染情况，以后如果换了的话得改。 #todo 将这个改为传入参数\n",
    "    ax.legend(labels, loc='upper right')                                                # 图例\n",
    "    ax.plot([0, len(y_score)], [0.5, 0.5], color='black', lw=1, linestyle='--')         # 以0.5为界，画一条虚线，表示分数大于0.5的是细菌感染，小于0.5的是病毒感染，这个以后也得改\n",
    "                                                                                        # 因为不同的模型（如linear regression 和 ridge regression）的判断标准不一样，所以这个界限也不一样。\n",
    "                                                                                        # 现在的做法是直接在y_score 上做手脚，还是……蛮不优雅的，但是先这样吧。\n",
    "                                                                                        # todo 将这个改为传入参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ROC曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_roc_curve(ax, y_score, final_Status):\n",
    "    from sklearn.metrics import auc\n",
    "    fpr, tpr, thresholds = roc_curve(final_Status, y_score)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    ax.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n",
    "    ax.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "    ax.set_xlabel('False Positive Rate 假阳性率')\n",
    "    ax.set_ylabel('True Positive Rate 真阳性率')\n",
    "    ax.set_title('ROC 曲线（受试者工作特征曲线）')\n",
    "    ax.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PR曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pr_curve(ax, y_score, final_Status):\n",
    "    precision, recall, thresholds = precision_recall_curve(final_Status, y_score)\n",
    "    ax.plot(recall, precision, color='darkorange', lw=2, label='PR curve')\n",
    "    ax.set_xlabel('Recall 召回率')\n",
    "    ax.set_ylabel('Precision 准确率')\n",
    "    ax.set_title('PR 曲线（准确率-召回率曲线）')\n",
    "    ax.set_xlim([0.0, 1.0])\n",
    "    ax.set_ylim([0.0, 1.05])\n",
    "    ax.legend(loc=\"lower left\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(ax, y_score, final_Status):\n",
    "    y_pred = np.where(y_score > 0.5, 1, 0)\n",
    "    cnf_matrix = confusion_matrix(final_Status, y_pred)\n",
    "    ax.imshow(cnf_matrix, interpolation='nearest',cmap=plt.cm.Blues) # type: ignore\n",
    "    ax.set_title('Confusion Matrix 混淆矩阵')\n",
    "    tick_marks = np.arange(2)\n",
    "    plt.xticks(tick_marks, plot_labels, rotation=45)\n",
    "    plt.yticks(tick_marks, plot_labels)\n",
    "    thresh = cnf_matrix.max() / 2.\n",
    "    for i in range(cnf_matrix.shape[0]):\n",
    "        for j in range(cnf_matrix.shape[1]):\n",
    "            plt.text(j, i, cnf_matrix[i, j],horizontalalignment=\"center\",color=\"white\" if cnf_matrix[i, j] > thresh else \"black\",fontsize=20)\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label 感染情况')\n",
    "    plt.xlabel('Predicted label 预测情况')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分数分布图、ROC曲线、PR曲线和混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_all(score, Status, title=\"分数分布图、ROC曲线、PR曲线和混淆矩阵\", feature=None, weight=None):\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(12, 12))                                                     # 规定画布大小为1200*1200px，分成2*2的4个小图\n",
    "    fig.suptitle(title, fontsize=16)                                                                    # 设置标题\n",
    "    plot_score_distribution(axs[0,0], score, Status)                                                    # 第一个小图（左上角）是分数分布图 这里的axs[0,0]是指第一行第一列的小图，注意计数是从0开始的。\n",
    "    plot_roc_curve(axs[0,1], score, Status)                                                             # 第二个小图（右上角）是ROC曲线\n",
    "    plot_pr_curve(axs[1,0], score, Status)                                                              # 第三个小图（左下角）是PR曲线\n",
    "    plot_confusion_matrix(axs[1,1], score, Status)                                                      # 第四个小图（右下角）是混淆矩阵\n",
    "    if feature or weight:                                                                               # 如果有feature或者weight的话，就在图的下方加上文字\n",
    "        try:\n",
    "            # add margin at bottom\n",
    "            fig.subplots_adjust(bottom=0.12)                                                            # 调整图的下边距，这样文字就不会挡住图了\n",
    "            # add feature and weight at the bottom\n",
    "            fig.text(0.5, 0.04, '使用feature:'+str(feature), ha='center', va='bottom', fontsize=12)     # 在图的下方加上文字，这里的0.5,0.04是指文字的位置，ha='center'是指文字居中，va='bottom'是指文字在底部，fontsize=12是指文字大小\n",
    "            fig.text(0.5, 0.02, '对应权重:'+str(weight), ha='center', va='bottom', fontsize=8)          # 同上\n",
    "        except:\n",
    "            pass                                                                                        # 如果出错了就算了\n",
    "    return fig, axs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 给定 基因 权重 和数据，计算分数并画图（可能需要修改）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 筛选"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "筛选哪些基因比较有差异"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_higher_columns(data, diff=2.0):\n",
    "    data_mean = data.groupby('Status').mean()\n",
    "    higher_columns = []\n",
    "    higher_times = []\n",
    "    for i in range(data_mean.shape[1]):\n",
    "        if  diff*data_mean.iloc[0,i] < data_mean.iloc[1,i]  or data_mean.iloc[0,i] > diff*data_mean.iloc[1,i]:\n",
    "            higher_columns.append(data_mean.columns[i])\n",
    "            # 0\n",
    "            if data_mean.iloc[0,i] == 0:\n",
    "                higher_times.append(1e10)\n",
    "            else:\n",
    "                higher_times.append(data_mean.iloc[1,i]/data_mean.iloc[0,i])\n",
    "    return higher_columns, higher_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "排序有差异的基因"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_higher_columns(data, higher_columns, higher_times):\n",
    "    # sort the columns and times together\n",
    "    data_higher_times, data_higher_columns = zip(*sorted(zip(higher_times, higher_columns), reverse=True))\n",
    "    # convert data_higher_columns to list\n",
    "    data_higher_columns = list(data_higher_columns)\n",
    "    # add Status column to the top of data_higher_columns\n",
    "    data_higher_columns.append('Status')\n",
    "    # get the new data\n",
    "    data_higher = data[data_higher_columns]\n",
    "    return data_higher, data_higher_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_best_acc(test_acc, n, gene_symbol, coef):\n",
    "    best_acc = max(test_acc)\n",
    "    best_i = 0\n",
    "    i = 0\n",
    "    print('最好的准确率为：', best_acc)\n",
    "    for acc in test_acc:\n",
    "        if acc == best_acc:\n",
    "            print('='*60)\n",
    "            print('对应的特征数为：', n[i],'方法为：', methods[i // len(models)].__name__,'特征为：', gene_symbol[i])\n",
    "            print('模型为：', models[i % len(models)],'特征权重为：', coef[i])\n",
    "            weights_avg = np.mean(coef[i])\n",
    "            new_coefs = []\n",
    "            for j in range(len(coef[i])):\n",
    "                # new_coefs.append(10*(coef[i][j]/weights_avg)) 保留2位小数\n",
    "                # new_coefs.append(round(10*(coef[i][j]/weights_avg), 2)) type numpy.ndarray doesn't define __round__ method\n",
    "                new_coefs.append(np.round(10*(coef[i][j]/weights_avg), 2))\n",
    "            print('比例大致为：', new_coefs)\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一次性完成基因筛选和模型训练\n",
    "通过调控C，使用LogisticRegression or LinearSVC 一次性完成基因筛选和模型训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def percent_to_color(percent: float) -> str:\n",
    "    assert 0 <= percent <= 1, \"Percent must be between 0 and 1\"\n",
    "    if percent >= 0.82:\n",
    "        hue = int(120 - (1 - percent) * 4000 / 3)\n",
    "    else:\n",
    "        hue = 0\n",
    "    saturation = 100  # 饱和度为100%\n",
    "    lightness = 50  # 亮度为50%\n",
    "    return f\"hsl({hue}, {saturation}%, {lightness}%)\"\n",
    "\n",
    "def colored_text(text: str, percent: float) -> str:\n",
    "    color = percent_to_color(percent)\n",
    "    return f'<span style=\"color: {color}\">{text}</span>'\n",
    "def evaluate_classifier(clf, method, model, X_train, y_train, X_test, y_test, params):\n",
    "    global final_results\n",
    "\n",
    "    acc_scores, auc_scores, f1_scores, precision_scores, recall_scores, n_features = [], [], [], [], [], []\n",
    "\n",
    "    for param in params:\n",
    "        clf.set_params(**param)\n",
    "        clf.fit(X_train, y_train)\n",
    "        nonzero_coef_indices = np.flatnonzero(clf.coef_)  # Indices where coef_ != 0\n",
    "        n = len(nonzero_coef_indices)\n",
    "        y_pred = clf.predict(X_test)\n",
    "        y_pred = np.array([1 if i > 0.5 else 0 for i in y_pred], dtype=int)\n",
    "        \n",
    "        if 3 <= n <= 20:\n",
    "            cm = confusion_matrix(y_test, y_pred)\n",
    "            auc = roc_auc_score(y_test, y_pred)\n",
    "            f1 = f1_score(y_test, y_pred)\n",
    "            f2 = fbeta_score(y_test, y_pred, beta=2)\n",
    "            f05 = fbeta_score(y_test, y_pred, beta=0.5)\n",
    "            precision = precision_score(y_test, y_pred)\n",
    "            recall = recall_score(y_test, y_pred)\n",
    "            \n",
    "            # acc = clf.score(X_test, y_test) if method is lasso or elasticnet, score is not accuracy\n",
    "            acc = accuracy_score(y_test, y_pred)\n",
    "\n",
    "            allowed_numbers = get_allowed_numbers()\n",
    "            coef = clf.coef_\n",
    "            # only use non-zero coef\n",
    "            coef = coef[coef != 0]\n",
    "            weights_avg = np.mean(np.abs(coef))\n",
    "            min_times = 0.5 / np.min(np.abs(coef))\n",
    "            max_times = 25.5 / np.max(np.abs(coef))\n",
    "            if min_times > max_times:\n",
    "                multipletimes = [max_times]\n",
    "            else:\n",
    "                multipletimes = np.linspace(min_times, max_times, num=500)\n",
    "            found_coef = False\n",
    "            coef_roundeds = []\n",
    "            deltas = []\n",
    "            for multipletime in multipletimes:\n",
    "                coef_rounded_t = []\n",
    "                differences = []\n",
    "                for coef_i in coef:\n",
    "                    # 符号问题，先存符号\n",
    "                    coef_i_sign = coef_i / np.abs(coef_i)\n",
    "                    coef_i = np.abs(coef_i)\n",
    "                    differences_i = []\n",
    "                    for allowed_number in allowed_numbers:\n",
    "                        difference = np.abs(coef_i * multipletime - allowed_number) / allowed_number\n",
    "                        differences_i.append(difference)\n",
    "                    best_allowed_number = allowed_numbers[np.argmin(differences_i)]\n",
    "                    coef_rounded_t.append(best_allowed_number * coef_i_sign)\n",
    "                    differences.append(np.min(differences_i))\n",
    "                delta = np.average(np.array(differences))\n",
    "                deltas.append(delta)\n",
    "                coef_roundeds.append(coef_rounded_t)\n",
    "\n",
    "            coef_rounded = coef_roundeds[np.argmin(deltas)]\n",
    "            delta = np.min(deltas)\n",
    "            mean_coef = np.mean(np.abs(coef_rounded))\n",
    "            times = mean_coef / weights_avg\n",
    "            if delta < 0.30: # 30%的平均误差\n",
    "                found_coef = True\n",
    "            if np.sum(coef_rounded) == 0:\n",
    "                balanced = True\n",
    "            else:\n",
    "                balanced = False\n",
    "\n",
    "            intercept = clf.intercept_\n",
    "\n",
    "            nonzero_coef_indices = np.flatnonzero(clf.coef_) # get the indices of non-zero coef\n",
    "            gene_id = list(X_train.columns[nonzero_coef_indices])\n",
    "\n",
    "            result = pd.DataFrame({\n",
    "                'method': [method],\n",
    "                'model': [model],\n",
    "                'n': [n],\n",
    "                'acc': [acc],\n",
    "                'auc': [auc],\n",
    "                'f1': [f1],\n",
    "                'f2': [f2],\n",
    "                'f05': [f05],\n",
    "                'precision': [precision],\n",
    "                'recall': [recall],\n",
    "                'confusionmatrix': [cm],\n",
    "                'coef': [coef.tolist()],\n",
    "                'coef_rounded': [coef_rounded],\n",
    "                'found_coef': [found_coef],\n",
    "                'delta': [delta],\n",
    "                'multiple_times': [times],\n",
    "                'intercept': [intercept.item()],\n",
    "                'balanced': [balanced],\n",
    "                'gene_id': [gene_id],\n",
    "            })\n",
    "\n",
    "            final_results = pd.concat([final_results, result], ignore_index=True) \n",
    "\n",
    "            # For plotting\n",
    "            n_features.append(n) \n",
    "            acc_scores.append(acc)\n",
    "            auc_scores.append(auc)\n",
    "            f1_scores.append(f1)\n",
    "            precision_scores.append(precision)\n",
    "            recall_scores.append(recall)\n",
    "\n",
    "            if loglevel == 'debug':\n",
    "                result_text = \"\"\n",
    "                result_text += f'method: {method}, '\n",
    "                result_text += f'model: {model}, '\n",
    "                result_text += f'n: {n}, '\n",
    "                result_text += 'acc: ' + colored_text(f'{acc:.3f}', acc) + ', '\n",
    "                result_text += 'auc: ' + colored_text(f'{auc:.3f}', auc) + ', '\n",
    "                result_text += 'f1: ' + colored_text(f'{f1:.3f}', f1) + ', '\n",
    "                result_text += 'precision: ' + colored_text(f'{precision:.3f}', precision) + ', '\n",
    "                result_text += 'recall: ' + colored_text(f'{recall:.3f}', recall) + '<br>'\n",
    "                coef_text = 'coef: '+ coef_rounded.__str__() + 'Gene: ' + gene_id.__str__()\n",
    "                result_text += coef_text\n",
    "                # 对 coef 和 gene_id 同样这样处理\n",
    "                # 最后，一次性打印所有的结果\n",
    "                display(HTML(result_text))\n",
    "        if n > 22:\n",
    "            break\n",
    "\n",
    "    # Plotting inside the function\n",
    "    plt.figure(figsize=(10,6))\n",
    "    plt.plot(n_features, auc_scores, label='AUC')\n",
    "    plt.scatter(n_features, auc_scores)\n",
    "    plt.plot(n_features, f1_scores, label='F1 score')\n",
    "    plt.scatter(n_features, f1_scores)\n",
    "    plt.plot(n_features, precision_scores, label='Precision', linestyle='dashed')\n",
    "    plt.plot(n_features, recall_scores, label='Recall', linestyle='dashed')\n",
    "    plt.title('Performance metrics by number of features (' + method + ')')\n",
    "    plt.xlabel('Number of features')\n",
    "    plt.ylabel('Performance metrics')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "高表达差异基因数目： 1009\n"
     ]
    }
   ],
   "source": [
    "higher_columns, higher_times = get_higher_columns(train_data, 2)\n",
    "print('高表达差异基因数目：', len(higher_columns))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "根据倍率不同进行排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_higher, data_higher_times = sort_higher_columns(train_data, higher_columns, higher_times)\n",
    "X_train, X_test, y_train, y_test = train_test_split(data_higher.drop(['Status'], axis=1), data_higher['Status'], test_size=0.2, random_state=42)\n",
    "# X_train, y_train = sm.fit_resample(data_higher, data_higher['Status'])\n",
    "# smote\n",
    "X_train, y_train = sm.fit_resample(X_train, y_train)\n",
    "# X_test, y_test= sm.fit_resample(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练不同的模型，使用不同的特征选择方法，选择出特征后，使用不同的方法来训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "final_results = pd.DataFrame(columns=['method', 'model', 'n', 'acc', 'auc', 'f1', 'precision', 'recall', 'f2','f05', 'confusionmatrix','coef', 'coef_rounded', 'found_coef', 'multiple_times','delta','intercept','balanced', 'gene_id'])\n",
    "max_run_num = 600\n",
    "C_values = np.logspace(-9, 0, num=max_run_num, base=10)\n",
    "alpha_values = np.logspace(15, -5, num=max_run_num, base=10)\n",
    "\n",
    "# LinearSVC\n",
    "lsvc = LinearSVC(penalty=\"l1\", dual=False)\n",
    "lsvc_params = [{'C': C} for C in C_values]\n",
    "evaluate_classifier(lsvc, 'LinearSVC', 'lsvc', X_train, y_train, X_test, y_test, lsvc_params)\n",
    "# Elastic-Net\n",
    "#    encv = ElasticNetCV(l1_ratio=1-np.logspace(-3, -0.1, num=10, base=10), n_alphas=200, max_iter=5000, n_jobs=10, selection='cyclic')\n",
    "#    encv.fit(X_train, y_train)\n",
    "#    print('-'*60)\n",
    "#    print('ElasticNetCV')\n",
    "#    print('best l1_ratio:', encv.l1_ratio_)\n",
    "#    print('selected features:', X_train.columns[encv.coef_ != 0].values)\n",
    "#    print('n features:', encv.n_features_in_)\n",
    "en = ElasticNet(alpha=0.1, l1_ratio=0.75, max_iter=5000, selection='cyclic')\n",
    "en_params = [{'alpha': alpha} for alpha in alpha_values]\n",
    "evaluate_classifier(en, 'ElasticNet', 'en', X_train, y_train, X_test, y_test, en_params)\n",
    "# LogisticRegression\n",
    "#       lrcv = LogisticRegressionCV(penalty='l1', solver='liblinear', max_iter=10000, n_jobs=-1)\n",
    "#       lrcv.fit(X_train, y_train)\n",
    "#       print('-'*60)\n",
    "#       print('LogisticRegressionCV')\n",
    "#       print('best C:', lrcv.C_)\n",
    "# print('selected features:', X_train.columns[lrcv.coef_ != 0].values)\n",
    "# print('n features:', lrcv.n_features_in_)\n",
    "lr = LogisticRegression(penalty='l1', solver='liblinear')\n",
    "lr_params = [{'C': C} for C in C_values]\n",
    "evaluate_classifier(lr, 'LogisticRegression', 'lr', X_train, y_train, X_test, y_test, lr_params)\n",
    "# Lasso\n",
    "#       lassocv = LassoCV(max_iter=5000, n_jobs=-1)\n",
    "#       lassocv.fit(X_train, y_train)\n",
    "#       print('-'*60)\n",
    "#       print('LassoCV')\n",
    "#       print('best alpha:', lassocv.alpha_)\n",
    "#       print('selected features:', X_train.columns[lassocv.coef_ != 0].values)\n",
    "#       print('n features:', lassocv.n_features_in_)\n",
    "lasso = Lasso(alpha=0.1, max_iter=5000)\n",
    "lasso_params = [{'alpha': alpha} for alpha in alpha_values]\n",
    "evaluate_classifier(lasso, 'lasso', 'lasso', X_train, y_train, X_test, y_test, lasso_params)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 重新排序\n",
    "sort_columns = ['found_coef','f1', 'auc',  'balanced','n', 'delta']\n",
    "sort_order = [False,False, False, False,True, True]\n",
    "\n",
    "# Sort the DataFrame\n",
    "results_sorted = final_results.sort_values(by=sort_columns, ascending=sort_order).reset_index(drop=True).copy()\n",
    "results_sorted_view = results_sorted.head(5).copy().drop(['coef','gene_id','intercept','multiple_times'], axis=1)\n",
    "# results_sorted_view\n",
    "\n",
    "# 复制 'final_results' 到 'final_results_unique' \n",
    "final_results_unique = results_sorted.copy()\n",
    "\n",
    "# 将 'coef_rounded' 和 'gene_id' 列转化为字符串\n",
    "final_results_unique['coef_rounded'] = final_results_unique['coef_rounded'].astype('str')\n",
    "final_results_unique['gene_id'] = final_results_unique['gene_id'].astype('str')\n",
    "\n",
    "# 删除重复行\n",
    "final_results_unique.drop_duplicates(subset=['coef_rounded', 'gene_id'], keep='first', inplace=True)\n",
    "final_results_unique['coef_rounded'] = final_results_unique['coef_rounded'].apply(ast.literal_eval)\n",
    "final_results_unique['gene_id'] = final_results_unique['gene_id'].apply(ast.literal_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>model</th>\n",
       "      <th>n</th>\n",
       "      <th>acc</th>\n",
       "      <th>auc</th>\n",
       "      <th>f1</th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f2</th>\n",
       "      <th>f05</th>\n",
       "      <th>confusionmatrix</th>\n",
       "      <th>coef_rounded</th>\n",
       "      <th>found_coef</th>\n",
       "      <th>delta</th>\n",
       "      <th>balanced</th>\n",
       "      <th>gene_id</th>\n",
       "      <th>reproduce</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>11</td>\n",
       "      <td>0.990826</td>\n",
       "      <td>0.971172</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>[[18, 1], [1, 198]]</td>\n",
       "      <td>[25.0, 5.0, 16.0, -1.0, -6.0, -5.0, -16.0, -9....</td>\n",
       "      <td>True</td>\n",
       "      <td>0.051344</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-21, hsa-mir-148a, hsa-le...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>11</td>\n",
       "      <td>0.990826</td>\n",
       "      <td>0.971172</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>[[18, 1], [1, 198]]</td>\n",
       "      <td>[2.0, 8.0, 4.0, 2.0, 6.0, -16.0, 20.0, -2.0, -...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.068394</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-192, hsa-mir-182, hsa-mir-203a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>12</td>\n",
       "      <td>0.990826</td>\n",
       "      <td>0.971172</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>[[18, 1], [1, 198]]</td>\n",
       "      <td>[25.0, 1.0, 5.0, 16.0, -1.0, -15.0, -6.0, -9.0...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.116090</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>54</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>13</td>\n",
       "      <td>0.990826</td>\n",
       "      <td>0.971172</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>[[18, 1], [1, 198]]</td>\n",
       "      <td>[8.0, 4.0, 5.0, 1.0, 4.0, -12.0, -2.0, 25.0, 3...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.058093</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-192, hsa-mir-182, hsa-mir-203a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>13</td>\n",
       "      <td>0.990826</td>\n",
       "      <td>0.971172</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>0.994975</td>\n",
       "      <td>[[18, 1], [1, 198]]</td>\n",
       "      <td>[1.0, 25.0, 2.0, 4.0, 15.0, -1.0, -20.0, -5.0,...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.062031</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-192, hsa-mir-182, hsa-mir-203a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>431</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.963303</td>\n",
       "      <td>0.956096</td>\n",
       "      <td>0.979592</td>\n",
       "      <td>0.994819</td>\n",
       "      <td>0.964824</td>\n",
       "      <td>0.970677</td>\n",
       "      <td>0.988671</td>\n",
       "      <td>[[18, 1], [7, 192]]</td>\n",
       "      <td>[20.0, 8.0, 25.0, 25.0, -1.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.079734</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>432</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.963303</td>\n",
       "      <td>0.956096</td>\n",
       "      <td>0.979592</td>\n",
       "      <td>0.994819</td>\n",
       "      <td>0.964824</td>\n",
       "      <td>0.970677</td>\n",
       "      <td>0.988671</td>\n",
       "      <td>[[18, 1], [7, 192]]</td>\n",
       "      <td>[16.0, 8.0, 25.0, 25.0, -1.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.177091</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>434</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>4</td>\n",
       "      <td>0.958716</td>\n",
       "      <td>0.953584</td>\n",
       "      <td>0.976982</td>\n",
       "      <td>0.994792</td>\n",
       "      <td>0.959799</td>\n",
       "      <td>0.966599</td>\n",
       "      <td>0.987590</td>\n",
       "      <td>[[18, 1], [8, 191]]</td>\n",
       "      <td>[9.0, 4.0, 15.0, 15.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.024128</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>437</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.944954</td>\n",
       "      <td>0.946046</td>\n",
       "      <td>0.969072</td>\n",
       "      <td>0.994709</td>\n",
       "      <td>0.944724</td>\n",
       "      <td>0.954315</td>\n",
       "      <td>0.984293</td>\n",
       "      <td>[[18, 1], [11, 188]]</td>\n",
       "      <td>[4.0, 4.0, 25.0, 25.0, -1.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.203767</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>438</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.944954</td>\n",
       "      <td>0.946046</td>\n",
       "      <td>0.969072</td>\n",
       "      <td>0.994709</td>\n",
       "      <td>0.944724</td>\n",
       "      <td>0.954315</td>\n",
       "      <td>0.984293</td>\n",
       "      <td>[[18, 1], [11, 188]]</td>\n",
       "      <td>[5.0, 4.0, 25.0, 25.0, -1.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.224450</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>89 rows × 17 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                 method  model   n       acc       auc        f1  precision  \\\n",
       "35   LogisticRegression     lr  11  0.990826  0.971172  0.994975   0.994975   \n",
       "42   LogisticRegression     lr  11  0.990826  0.971172  0.994975   0.994975   \n",
       "50   LogisticRegression     lr  12  0.990826  0.971172  0.994975   0.994975   \n",
       "54   LogisticRegression     lr  13  0.990826  0.971172  0.994975   0.994975   \n",
       "55   LogisticRegression     lr  13  0.990826  0.971172  0.994975   0.994975   \n",
       "..                  ...    ...  ..       ...       ...       ...        ...   \n",
       "431               lasso  lasso   5  0.963303  0.956096  0.979592   0.994819   \n",
       "432          ElasticNet     en   5  0.963303  0.956096  0.979592   0.994819   \n",
       "434               lasso  lasso   4  0.958716  0.953584  0.976982   0.994792   \n",
       "437          ElasticNet     en   5  0.944954  0.946046  0.969072   0.994709   \n",
       "438               lasso  lasso   5  0.944954  0.946046  0.969072   0.994709   \n",
       "\n",
       "       recall        f2       f05       confusionmatrix  \\\n",
       "35   0.994975  0.994975  0.994975   [[18, 1], [1, 198]]   \n",
       "42   0.994975  0.994975  0.994975   [[18, 1], [1, 198]]   \n",
       "50   0.994975  0.994975  0.994975   [[18, 1], [1, 198]]   \n",
       "54   0.994975  0.994975  0.994975   [[18, 1], [1, 198]]   \n",
       "55   0.994975  0.994975  0.994975   [[18, 1], [1, 198]]   \n",
       "..        ...       ...       ...                   ...   \n",
       "431  0.964824  0.970677  0.988671   [[18, 1], [7, 192]]   \n",
       "432  0.964824  0.970677  0.988671   [[18, 1], [7, 192]]   \n",
       "434  0.959799  0.966599  0.987590   [[18, 1], [8, 191]]   \n",
       "437  0.944724  0.954315  0.984293  [[18, 1], [11, 188]]   \n",
       "438  0.944724  0.954315  0.984293  [[18, 1], [11, 188]]   \n",
       "\n",
       "                                          coef_rounded found_coef     delta  \\\n",
       "35   [25.0, 5.0, 16.0, -1.0, -6.0, -5.0, -16.0, -9....       True  0.051344   \n",
       "42   [2.0, 8.0, 4.0, 2.0, 6.0, -16.0, 20.0, -2.0, -...       True  0.068394   \n",
       "50   [25.0, 1.0, 5.0, 16.0, -1.0, -15.0, -6.0, -9.0...       True  0.116090   \n",
       "54   [8.0, 4.0, 5.0, 1.0, 4.0, -12.0, -2.0, 25.0, 3...       True  0.058093   \n",
       "55   [1.0, 25.0, 2.0, 4.0, 15.0, -1.0, -20.0, -5.0,...       True  0.062031   \n",
       "..                                                 ...        ...       ...   \n",
       "431                      [20.0, 8.0, 25.0, 25.0, -1.0]       True  0.079734   \n",
       "432                      [16.0, 8.0, 25.0, 25.0, -1.0]       True  0.177091   \n",
       "434                             [9.0, 4.0, 15.0, 15.0]       True  0.024128   \n",
       "437                       [4.0, 4.0, 25.0, 25.0, -1.0]       True  0.203767   \n",
       "438                       [5.0, 4.0, 25.0, 25.0, -1.0]       True  0.224450   \n",
       "\n",
       "    balanced                                            gene_id  reproduce  \n",
       "35     False  [hsa-mir-182, hsa-mir-21, hsa-mir-148a, hsa-le...       True  \n",
       "42     False  [hsa-mir-192, hsa-mir-182, hsa-mir-203a, hsa-m...       True  \n",
       "50     False  [hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...       True  \n",
       "54     False  [hsa-mir-192, hsa-mir-182, hsa-mir-203a, hsa-m...       True  \n",
       "55     False  [hsa-mir-192, hsa-mir-182, hsa-mir-203a, hsa-m...       True  \n",
       "..       ...                                                ...        ...  \n",
       "431    False  [hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...       True  \n",
       "432    False  [hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...       True  \n",
       "434    False  [hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...       True  \n",
       "437    False  [hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...       True  \n",
       "438    False  [hsa-mir-182, hsa-mir-203a, hsa-mir-21, hsa-mi...       True  \n",
       "\n",
       "[89 rows x 17 columns]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reproduce\n",
    "results_sorted_found_coef = final_results_unique[results_sorted['found_coef'] == True].reset_index(drop=True).copy()\n",
    "reperduce = []\n",
    "for i in range(len(results_sorted_found_coef)):\n",
    "    gene_ids = results_sorted_found_coef['gene_id'][i]\n",
    "    # check if gene_ids are in X_test columns\n",
    "    if set(gene_ids).issubset(set(X_test.columns)):\n",
    "        X_test_selected = X_test[gene_ids].copy()\n",
    "    else:\n",
    "        # modify gene_ids to match X_test columns\n",
    "        gene_ids = [col for col in gene_ids if col in X_test.columns]\n",
    "        X_test_selected = X_test[gene_ids].copy()\n",
    "    y_test_selected = y_test\n",
    "    # calculate score\n",
    "    coef = results_sorted_found_coef['coef_rounded'][i]\n",
    "    times = results_sorted_found_coef['multiple_times'][i]\n",
    "    intercept = results_sorted_found_coef['intercept'][i]\n",
    "    model_name = results_sorted_found_coef['model'][i]\n",
    "\n",
    "    scores = []\n",
    "    predictions = []\n",
    "    \n",
    "    # determine model and calculate scores and predictions\n",
    "    if model_name == 'LinearRegression':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'RidgeClassifier' or model_name == 'RidgeClassifierCV':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'LogisticRegression' or model_name == 'LogisticRegressionCV':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            z = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            score = 1 / (1 + np.exp(-z))\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'Lasso' or model_name == 'LassoCV':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'LinearSVC' or model_name == 'NuSVC':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'ElasticNet':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'SGDClassifier':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    else:\n",
    "        # handle SVC\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "        \n",
    "    # calculate evaluation metrics\n",
    "    acc = accuracy_score(y_test_selected, predictions)\n",
    "    auc = roc_auc_score(y_test_selected, scores)\n",
    "    f1 = f1_score(y_test_selected, predictions)\n",
    "    precision = precision_score(y_test_selected, predictions)\n",
    "    recall = recall_score(y_test_selected, predictions)\n",
    "\n",
    "    # 能复现\n",
    "    if acc == results_sorted_found_coef['acc'][i] and f1 == results_sorted_found_coef['f1'][i]:\n",
    "        can_reproduce = True\n",
    "    else:\n",
    "        can_reproduce = False\n",
    "    # can_reproduce = True\n",
    "\n",
    "    # if not acc == results_sorted_found_coef['acc'][i]:\n",
    "    #     can_reproduce = False\n",
    "    #     # print results\n",
    "    #     print('Model:', model_name, 'n:', results_sorted_found_coef['n'][i],'acc:', acc, 'auc:', auc, 'f1:', f1, 'precision:', precision, 'recall:', recall)\n",
    "    #     print(acc)\n",
    "    #     print(results_sorted_found_coef['acc'][i])\n",
    "    \n",
    "    reperduce.append(can_reproduce)\n",
    "\n",
    "results_sorted_found_coef['reproduce'] = reperduce\n",
    "results_sorted_found_coef_view = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True][results_sorted_found_coef['n'] <= 15].copy().drop(['coef','intercept','multiple_times'], axis=1)\n",
    "results_sorted_found_coef_view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# for results_sorted_found_coef, draw the figure\n",
    "# Group the results by method and model\n",
    "# filter by n\n",
    "results_sorted_found_coef_n = results_sorted_found_coef[results_sorted_found_coef['n'] <= 25]\n",
    "groups = results_sorted_found_coef_n.groupby(['method'])\n",
    "methods = [method for method, _ in groups]\n",
    "# Create a figure with multiple subplots\n",
    "fig, axs = plt.subplots(1,len(methods), sharex=True, sharey=True, figsize=(20, 12))\n",
    "\n",
    "# Iterate over the subplots and plot the acc and roc values\n",
    "for i, method in enumerate(methods):\n",
    "    group = groups.get_group(method)\n",
    "    axs[i].scatter(group['n'], group['f1'], label='F1', color='blue')\n",
    "    axs[i].scatter(group['n'], group['auc'], label='auc', color='orange')\n",
    "    axs[i].set_xlabel('n')\n",
    "    axs[i].set_ylabel('score')\n",
    "    axs[i].set_ylim([0.95, 1.00]) # Set y-axis limits\n",
    "    axs[i].legend()\n",
    "    # Find the maximum acc and roc values for this method and model\n",
    "    max_acc_idx = group['f1'].idxmax()\n",
    "    max_auc_idx = group['auc'].idxmax()\n",
    "    max_acc = group.loc[max_acc_idx, 'f1']\n",
    "    max_auc = group.loc[max_auc_idx, 'auc']\n",
    "    max_n_acc = group.loc[max_acc_idx, 'n']\n",
    "    max_n_auc = group.loc[max_auc_idx, 'n']\n",
    "\n",
    "    # Add annotations with the maximum acc and roc values\n",
    "    axs[i].annotate(f'Max F1: {max_acc:.3f} (n={max_n_acc})',\n",
    "                        xy=(max_n_acc, max_acc),\n",
    "                        xytext=(max_n_acc, max_acc - 0.006),\n",
    "                        ha='center',\n",
    "                        arrowprops=dict(arrowstyle='->'))\n",
    "    axs[i].annotate(f'Max Roc: {max_auc:.3f} (n={max_n_auc})',\n",
    "                        xy=(max_n_auc, max_auc),\n",
    "                        xytext=(max_n_auc, max_auc + 0.006),\n",
    "                        ha='center',\n",
    "                        arrowprops=dict(arrowstyle='->'))\n",
    "\n",
    "    axs[i].set_title(f'{method} - selected genes')\n",
    "    # grid\n",
    "    axs[i].grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导出保存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calthreadhold( model_name, instances, times):\n",
    "    if model_name == 'LinearRegression':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'RidgeClassifier' or model_name == 'RidgeClassifierCV':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'LogisticRegression' or model_name == 'LogisticRegressionCV':\n",
    "            threshold = (0 - instances) * times\n",
    "    elif model_name == 'lasso' or model_name == 'LassoCV':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'LinearSVC' or model_name == 'NuSVC':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'ElasticNet':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'SGDClassifier':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    else:\n",
    "        threshold = (0.5 - instances) * times\n",
    "    return threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 计算f1值的60%分位数\n",
    "# quantile_60 = results_sorted_found_coef['f1'].quantile(0.6)\n",
    "# \n",
    "# # 过滤results_sorted_found_coef，只保留f1值在前60%的数据\n",
    "# filtered_results = results_sorted_found_coef[results_sorted_found_coef['f1'] >= quantile_60]\n",
    "# filtered_results\n",
    "filtered_results = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True].copy()\n",
    "filtered_results['threshold'] = filtered_results.apply(lambda x: calthreadhold(x['model'], x['intercept'], x['multiple_times']), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import excel \n",
    "import openpyxl\n",
    "# 时间\n",
    "import time\n",
    "xsl_file = str(dataset_name) + time.strftime(\"%Y%m%d%H%M%S\", time.localtime()) + '.xlsx'\n",
    "# 检查文件是否存在\n",
    "import os\n",
    "if os.path.exists(xsl_file):\n",
    "    os.remove(xsl_file)\n",
    "wb = openpyxl.Workbook()\n",
    "ws = wb.active\n",
    "try:\n",
    "    ws = wb['Results']\n",
    "except KeyError:\n",
    "    ws = wb.create_sheet('Results')\n",
    "# remove all rows\n",
    "ws.delete_rows(1, ws.max_row)\n",
    "# write column name\n",
    "for col in range(len(filtered_results.columns)):\n",
    "    ws.cell(row=1, column=col+1, value=filtered_results.columns[col])\n",
    "# write data\n",
    "for i in range(len(filtered_results)):\n",
    "    for col in range(len(filtered_results.columns)):\n",
    "        # not NaN\n",
    "        if filtered_results.iloc[i, col] == '':\n",
    "            ws.cell(row=i+2, column=col+1, value='N/A')\n",
    "        else:\n",
    "            try:\n",
    "                ws.cell(row=i+2, column=col+1, value=filtered_results.iloc[i, col])\n",
    "            except ValueError:\n",
    "                ws.cell(row=i+2, column=col+1, value=str(filtered_results.iloc[i, col]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建一个默认字典来存储每个列表的f1值的总和、计数、最大f1值和对应的其他值\n",
    "f1_dict = defaultdict(lambda: [0, 0, 0, float('inf'), 0, 0, 0, None])\n",
    "\n",
    "# 遍历filtered_results，更新f1_dict\n",
    "for _, row in filtered_results.iterrows():\n",
    "    key = tuple(row['gene_id'])\n",
    "    f1_dict[key][0] += row['f1']\n",
    "    f1_dict[key][1] += 1\n",
    "    if row['f1'] > f1_dict[key][2] or (row['f1'] == f1_dict[key][2] and row['intercept'] < f1_dict[key][3]):\n",
    "        f1_dict[key][2] = row['f1']\n",
    "        f1_dict[key][3] = row['intercept']\n",
    "        f1_dict[key][4] = row['coef_rounded']\n",
    "        f1_dict[key][5] = row['multiple_times']\n",
    "        f1_dict[key][6] = row['delta']\n",
    "        f1_dict[key][7] = row['model']\n",
    "\n",
    "# 创建一个空的DataFrame\n",
    "df = pd.DataFrame(columns=['List', 'Length', 'Count', 'Average F1 Score', 'Max F1 Score','Best Coef',  'Best Intercept', 'Best Multiple Times', 'Best Delta', 'Best Model'])\n",
    "\n",
    "# 将f1_dict的内容添加到DataFrame中\n",
    "for key, value in f1_dict.items():\n",
    "    df = df.append({'List': list(key), 'Length': len(key), 'Count': value[1], 'Average F1 Score': value[0] / value[1], 'Max F1 Score': value[2], 'Best Intercept': value[3], 'Best Coef': value[4], 'Best Multiple Times': value[5], 'Best Delta': value[6], 'Best Model': value[7]}, ignore_index=True)\n",
    "\n",
    "# 按照长度和出现次数进行排序\n",
    "df = df.sort_values(by=['Length', 'Count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    ws = wb['Sheet1']\n",
    "except KeyError:\n",
    "    ws = wb.create_sheet('Sheet1')\n",
    "# remove all rows\n",
    "ws.delete_rows(1, ws.max_row)\n",
    "# write column name\n",
    "for col in range(len(df.columns)):\n",
    "    ws.cell(row=1, column=col+1, value=df.columns[col])\n",
    "# write data\n",
    "for i in range(len(df)):\n",
    "    for col in range(len(df.columns)):\n",
    "        # not NaN\n",
    "        if df.iloc[i, col] == '':\n",
    "            ws.cell(row=i+2, column=col+1, value='N/A')\n",
    "        else:\n",
    "            try:\n",
    "                ws.cell(row=i+2, column=col+1, value=df.iloc[i, col])\n",
    "            except ValueError:\n",
    "                ws.cell(row=i+2, column=col+1, value=str(df.iloc[i, col]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_data = pd.DataFrame()\n",
    "# count\n",
    "miRNAs = filtered_results['gene_id'].tolist()\n",
    "# 统计出现次数 miRNAs_count as a dict\n",
    "miRNAs_count = {}\n",
    "for miRNA in miRNAs:\n",
    "    # miRNA is a list\n",
    "    # Add length of miRNA to miRNA\n",
    "    for miRNA_ in miRNA:\n",
    "        if miRNA_ in miRNAs_count:\n",
    "            miRNAs_count[miRNA_] += 1\n",
    "        else:\n",
    "            miRNAs_count[miRNA_] = 1\n",
    "\n",
    "miRNAs_count = sorted(miRNAs_count.items(), key=lambda x: x[1], reverse=True)\n",
    "miRNAs_count = pd.DataFrame(miRNAs_count, columns=['gene_id', 'count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    ws = wb['Count']\n",
    "except KeyError:\n",
    "    ws = wb.create_sheet('Count')\n",
    "# remove all rows\n",
    "ws.delete_rows(1, ws.max_row)\n",
    "# write column name\n",
    "df = miRNAs_count\n",
    "for col in range(len(df.columns)):\n",
    "    ws.cell(row=1, column=col+1, value=df.columns[col])\n",
    "# write data\n",
    "for i in range(len(df)):\n",
    "    for col in range(len(df.columns)):\n",
    "        # not NaN\n",
    "        if df.iloc[i, col] == '':\n",
    "            ws.cell(row=i+2, column=col+1, value='N/A')\n",
    "        else:\n",
    "            try:\n",
    "                ws.cell(row=i+2, column=col+1, value=df.iloc[i, col])\n",
    "            except ValueError:\n",
    "                ws.cell(row=i+2, column=col+1, value=str(df.iloc[i, col]))\n",
    "# save\n",
    "# delete default sheet\n",
    "wb.remove(wb['Sheet'])\n",
    "\n",
    "wb.save(xsl_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 绘图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature: ['hsa-mir-21', 'hsa-mir-148a', 'hsa-mir-143', 'hsa-mir-30a']\n",
      "weight: [8.0, 6.0, -5.0, -20.0]\n"
     ]
    }
   ],
   "source": [
    "# 选择的模型\n",
    "# 实际输入的模型\n",
    "select = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True][results_sorted_found_coef['n'] <= 6].copy().iloc[0]\n",
    "feature = select.gene_id\n",
    "print('feature:', feature)\n",
    "weight = select.coef_rounded\n",
    "print('weight:', weight)\n",
    "times = select.multiple_times\n",
    "intercept = select.intercept\n",
    "model = select.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "ID = feature.copy()\n",
    "ID.append(\"Status\")\n",
    "ID = np.array(ID).reshape(-1)\n",
    "ID.astype('str')\n",
    "testdata = pd.concat([X_test, y_test], axis=1)[ID]\n",
    "# testdata = train_data[ID]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 对平均值都乘以权重\n",
    "weight = weight + [1]\n",
    "testdata_weight = testdata * weight\n",
    "weight = weight[:-1]\n",
    "testdata_weight['score'] = testdata_weight.sum(axis=1) / times + intercept\n",
    "if model == 'lr':\n",
    "    testdata_weight['score'] = testdata_weight['score'].apply(lambda x: 1 / (1 + np.exp(-x)))\n",
    "testdata_weight['prediction'] = testdata_weight['score'].apply(lambda x: 1 if x > 0.5 else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_curve, auc, precision_recall_curve, confusion_matrix, ConfusionMatrixDisplay\n",
    "def plot_metrics(testdata_weight, feature, weight):\n",
    "    # 创建一个figure并添加4个子图（ax）\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(12, 12))\n",
    "\n",
    "    # 在第一个子图上绘制分数分布图\n",
    "    scatter = axs[0, 0].scatter(range(len(testdata_weight['score'])), testdata_weight['score'], c=testdata_weight['Status'], cmap='bwr', alpha=0.5)\n",
    "    axs[0, 0].plot([0, len(testdata_weight['score'])], [0.5, 0.5], color='black', lw=1, linestyle='--')\n",
    "    axs[0, 0].set_title('Score distribution')\n",
    "    legend1 = axs[0, 0].legend(['Threshold', 'Positive', 'Negative'], loc=\"upper right\")\n",
    "    axs[0, 0].add_artist(legend1)\n",
    "\n",
    "    # 在第二个子图上绘制ROC曲线\n",
    "    fpr, tpr, _ = roc_curve(testdata_weight['Status'], testdata_weight['score'])\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    axs[0, 1].plot(fpr, tpr, color='darkorange', label='ROC curve (area = %0.4f)' % roc_auc)\n",
    "    axs[0, 1].plot([0, 1], [0, 1], color='navy', linestyle='--')\n",
    "    axs[0, 1].set_xlim([0.0, 1.0])\n",
    "    axs[0, 1].set_ylim([0.0, 1.05])\n",
    "    axs[0, 1].set_xlabel('False Positive Rate')\n",
    "    axs[0, 1].set_ylabel('True Positive Rate')\n",
    "    axs[0, 1].set_title('Receiver operating characteristic')\n",
    "    axs[0, 1].legend(loc=\"lower right\")\n",
    "\n",
    "    # 在第三个子图上绘制PR曲线\n",
    "    precision, recall, _ = precision_recall_curve(testdata_weight['Status'], testdata_weight['score'])\n",
    "    axs[1, 0].step(recall, precision,color='darkorange', lw=2, where='post')\n",
    "    axs[1, 0].set_xlabel('Recall')\n",
    "    axs[1, 0].set_ylabel('Precision')\n",
    "    axs[1, 0].set_ylim([0.0, 1.05])\n",
    "    axs[1, 0].set_xlim([0.0, 1.0])\n",
    "    axs[1, 0].set_title('Precision-Recall curve')\n",
    "    axs[1, 0].legend(['PR curve'])\n",
    "\n",
    "    # 在第四个子图上绘制混淆矩阵\n",
    "    cm = confusion_matrix(testdata_weight['Status'], testdata_weight['prediction'])\n",
    "    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Negative', 'Positive'])\n",
    "    disp.plot(ax=axs[1, 1], cmap='Blues', colorbar=False)\n",
    "    axs[1, 1].set_title('Confusion Matrix')\n",
    "\n",
    "    # add margin at bottom\n",
    "    fig.text(0.5, 0.04, 'feature:'+str(feature), ha='center', va='bottom', fontsize=8)     # 在图的下方加上文字，这里的0.5,0.04是指文字的位置，ha='center'是指文字居中，va='bottom'是指文字在底部，fontsize=12是指文字大小\n",
    "    fig.text(0.5, 0.02, 'Weight:'+str(weight), ha='center', va='bottom', fontsize=12)          # 同上\n",
    "\n",
    "    fig.suptitle('Metrics and Feature Weights', fontsize=16)\n",
    "    plt.tight_layout()\n",
    "    # 得调整图的下边距，否则会显示不全\n",
    "    plt.subplots_adjust(bottom=0.1)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weight_int = np.array(weight, dtype=int)\n",
    "plot_metrics(testdata_weight, feature, weight_int)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "igem",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}