2.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 变量设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置数据集名称，对应 https://xenabrowser.net/datapages/ 中缩写\n",
    "dataset_name =  ['LUAD', 'LUSC']\n",
    "# 设置俩： ['LUAD', 'LUSC']\n",
    "# 更多更多也行\n",
    "# 单一个： ['LUAD'] \n",
    "# All possible Value:\n",
    "# ['ACC','CHOL','BLCA','BRCA','CESC','COAD','UCEC','ESCA','GBM','HNSC','KICH','KIRC','KIRP','DLBC','LIHC','LGG','LUAD','LUSC','SKCM','MESO','UVM','OV','PAAD','PCPG','PRAD','READ','SARC','STAD','TGCT','THYM','THCA','UCS']:\n",
    "method = 'normal' # diff是上面俩数据集的差异，normal是和正常样本的差异\n",
    "# method = 'diff'\n",
    "loglevel = ''\n",
    "# loglevel = 'debug'\n",
    "balance_input = 'true' # or true \n",
    "rate1 = 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据导入"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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",
    "from scipy.stats import pearsonr\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# balance_data\n",
    "def getStatus0data():\n",
    "    Status0data = pd.DataFrame()\n",
    "    Status1data = pd.DataFrame()\n",
    "    for datasets in ['LAML','ACC','CHOL','BLCA','BRCA','CESC','COAD','UCEC','ESCA','GBM','HNSC','KICH','KIRC','KIRP','DLBC','LIHC','LGG','LUAD','LUSC','SKCM','MESO','UVM','OV','PAAD','PCPG','PRAD','READ','SARC','STAD','TGCT','THYM','THCA','UCS']:\n",
    "        if datasets in dataset_name:\n",
    "            continue\n",
    "        try:\n",
    "            # use download_and_parse_data to download the data\n",
    "            dataframe = download_and_parse_data(datasets)\n",
    "            # 把Status为0的dataframe赋值给Status0data\n",
    "            Status0data = pd.concat([Status0data, dataframe[dataframe['Status'] == 0]])\n",
    "            Status1data = pd.concat([Status1data, dataframe[dataframe['Status'] == 1]])\n",
    "        except:\n",
    "            print('Error:', datasets)\n",
    "            continue\n",
    "\n",
    "    # 混入对应比例的1\n",
    "    # Status0data = pd.concat([Status0data, Status1data.sample(len(Status0data)*rate1/(1-rate1))])\n",
    "    # int is needed\n",
    "    Status0data = pd.concat([Status0data, Status1data.sample(n=int(len(Status0data)*rate1/(1-rate1)),random_state=42)])\n",
    "    # 把所有的label 都设为0\n",
    "    Status0data['Status'] = 0\n",
    "    # 保存0的dataframe为pkl文件\n",
    "    pkl_file_path = './datasets/Status0data.pkl'\n",
    "    Status0data.to_pickle(pkl_file_path)\n",
    "\n",
    "    return Status0data\n",
    "\n",
    "def balance_data(Currentdata):\n",
    "    # Get the count of Status=0 and Status=1\n",
    "    current1 = Currentdata[Currentdata['Status'] == 1]\n",
    "    current0 = Currentdata[Currentdata['Status'] == 0]\n",
    "    \n",
    "    if len(current0) > len(current1):\n",
    "        print('0 is more than 1')\n",
    "        # No need to balance, return the original DataFrame\n",
    "        return Currentdata\n",
    "    else:\n",
    "        print('1 is more than 0')\n",
    "        # If 1 is more, randomly sample from Status=0 data and concatenate\n",
    "        Status0data = getStatus0data()\n",
    "        balanced_data = pd.concat([current1, Status0data.sample(n=(len(current1) - len(current0)),random_state=42)])\n",
    "        print('Currentdata.shape:', balanced_data.shape)\n",
    "        return balanced_data\n",
    "\n",
    "def balance_data2(Currentdata):\n",
    "    # Get the count of Status=0 and Status=1\n",
    "    current1 = Currentdata[Currentdata['Status'] == 1]\n",
    "    current0 = Currentdata[Currentdata['Status'] == 0]\n",
    "    \n",
    "    if len(current0) > len(current1):\n",
    "        print('0 is more than 1')\n",
    "        # No need to balance, return the original DataFrame\n",
    "        return Currentdata\n",
    "    else:\n",
    "        print('1 is more than 0')\n",
    "        # If 1 is more, randomly remove some Status=1 data and concatenate\n",
    "        balanced_data = pd.concat([current0, current1.sample(n=len(current0),random_state=42)])\n",
    "        print('Currentdata.shape:', balanced_data.shape)\n",
    "        return balanced_data\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is more than 0\n",
      "Currentdata.shape: (1895, 1882)\n"
     ]
    }
   ],
   "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",
    "\n",
    "# if balance_input, we need to balance the data using different datasets.\n",
    "if balance_input == 'true':\n",
    "    df_transposed = balance_data(df_transposed)\n",
    "    \n",
    "train_data = df_transposed.apply(pd.to_numeric)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 函数 准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义存储结果的DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_allowed_numbers(max_n=25,allowed_factors=[1,2,3,4,5]):\n",
    "    # 100 以内的整数\n",
    "    result = range(1,100)\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": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_labels = ['得了', '没得']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": 10,
   "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": 11,
   "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": 12,
   "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": 13,
   "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": 14,
   "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": 15,
   "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": 16,
   "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": 17,
   "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 1 <= 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",
    "            coef = clf.coef_\n",
    "            # only use non-zero coef\n",
    "            coef = coef[coef != 0]\n",
    "            weights_avg = np.mean(np.abs(coef))\n",
    "            max_times = 100 / np.max(np.abs(coef))\n",
    "            multipletimes = [max_times]\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",
    "                    coef_rounded_t.append(coef_i * multipletime * coef_i_sign)\n",
    "                    differences.append(0)  # 不再使用 allowed_numbers\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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "高表达差异基因数目： 788\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": 19,
   "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)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation results saved to correlation_results.csv\n"
     ]
    },
    {
     "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>gene_id</th>\n",
       "      <th>Correlation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>hsa-mir-21</td>\n",
       "      <td>0.769929</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>hsa-mir-141</td>\n",
       "      <td>0.606017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>hsa-mir-182</td>\n",
       "      <td>0.567278</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>hsa-mir-183</td>\n",
       "      <td>0.558646</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>hsa-mir-96</td>\n",
       "      <td>0.544272</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1682</th>\n",
       "      <td>hsa-mir-5582</td>\n",
       "      <td>0.000422</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1683</th>\n",
       "      <td>hsa-mir-376b</td>\n",
       "      <td>0.000299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1684</th>\n",
       "      <td>hsa-mir-518a-2</td>\n",
       "      <td>-0.000211</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1685</th>\n",
       "      <td>hsa-mir-3918</td>\n",
       "      <td>0.000198</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1686</th>\n",
       "      <td>hsa-mir-4770</td>\n",
       "      <td>-0.000180</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1687 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             gene_id  Correlation\n",
       "0         hsa-mir-21     0.769929\n",
       "1        hsa-mir-141     0.606017\n",
       "2        hsa-mir-182     0.567278\n",
       "3        hsa-mir-183     0.558646\n",
       "4         hsa-mir-96     0.544272\n",
       "...              ...          ...\n",
       "1682    hsa-mir-5582     0.000422\n",
       "1683    hsa-mir-376b     0.000299\n",
       "1684  hsa-mir-518a-2    -0.000211\n",
       "1685    hsa-mir-3918     0.000198\n",
       "1686    hsa-mir-4770    -0.000180\n",
       "\n",
       "[1687 rows x 2 columns]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def calculate_correlation(train_data):\n",
    "    status = train_data.iloc[:, 0]\n",
    "    other_columns = train_data.iloc[:, 1:]\n",
    "    correlations = {}\n",
    "\n",
    "    for column in other_columns.columns:\n",
    "        data = other_columns[column]\n",
    "        corr, _ = pearsonr(status, data)\n",
    "        if not pd.isnull(corr):\n",
    "            correlations[column] = corr\n",
    "\n",
    "    sorted_correlations = sorted(correlations.items(), key=lambda x: abs(x[1]), reverse=True)[:] \n",
    "\n",
    "    correlation_df = pd.DataFrame(sorted_correlations, columns=['Column', 'Correlation'])\n",
    "    correlation_df = correlation_df.rename(columns={'Column': 'gene_id'})\n",
    "    correlation_df.to_csv('correlation_results.csv', index=False)\n",
    "    print(\"Correlation results saved to correlation_results.csv\")\n",
    "    return correlation_df\n",
    "data=calculate_correlation(train_data)\n",
    "\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x2000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = data.iloc[:20]\n",
    "data.set_index('gene_id', inplace=True)\n",
    "# 创建热力图\n",
    "plt.figure(figsize=(10, 20))\n",
    "sns.heatmap(data, annot=True, cmap='coolwarm', vmin=-1, vmax=1)\n",
    "plt.title('Correlation Matrix')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练不同的模型，使用不同的特征选择方法，选择出特征后，使用不同的方法来训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": 22,
   "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": 23,
   "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>19</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>6</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.994565</td>\n",
       "      <td>0.994536</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.989130</td>\n",
       "      <td>0.991285</td>\n",
       "      <td>0.997807</td>\n",
       "      <td>[[103, 0], [1, 91]]</td>\n",
       "      <td>[99.99999999999999, 59.074257572799226, 54.088...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>6</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.994565</td>\n",
       "      <td>0.994536</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.989130</td>\n",
       "      <td>0.991285</td>\n",
       "      <td>0.997807</td>\n",
       "      <td>[[103, 0], [1, 91]]</td>\n",
       "      <td>[100.0, 57.619339302976435, 55.35030103351411,...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>6</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.994565</td>\n",
       "      <td>0.994536</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.989130</td>\n",
       "      <td>0.991285</td>\n",
       "      <td>0.997807</td>\n",
       "      <td>[[103, 0], [1, 91]]</td>\n",
       "      <td>[100.0, 56.30475816456298, 56.49067542397592, ...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>6</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.994565</td>\n",
       "      <td>0.994536</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.989130</td>\n",
       "      <td>0.991285</td>\n",
       "      <td>0.997807</td>\n",
       "      <td>[[103, 0], [1, 91]]</td>\n",
       "      <td>[100.00000000000001, 55.114545393059686, 57.52...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>6</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.994565</td>\n",
       "      <td>0.994536</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.989130</td>\n",
       "      <td>0.991285</td>\n",
       "      <td>0.997807</td>\n",
       "      <td>[[103, 0], [1, 91]]</td>\n",
       "      <td>[100.0, 54.03486508310612, 58.4599900918236, -...</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...</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>511</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>3</td>\n",
       "      <td>0.953846</td>\n",
       "      <td>0.951087</td>\n",
       "      <td>0.948571</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.902174</td>\n",
       "      <td>0.920177</td>\n",
       "      <td>0.978774</td>\n",
       "      <td>[[103, 0], [9, 83]]</td>\n",
       "      <td>[28.40644839176302, 100.0, -0.03538345457509003]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b, hsa-mir-143]</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>528</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>2</td>\n",
       "      <td>0.938462</td>\n",
       "      <td>0.934783</td>\n",
       "      <td>0.930233</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.869565</td>\n",
       "      <td>0.892857</td>\n",
       "      <td>0.970874</td>\n",
       "      <td>[[103, 0], [12, 80]]</td>\n",
       "      <td>[17.031309199227845, 100.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b]</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>536</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>2</td>\n",
       "      <td>0.923077</td>\n",
       "      <td>0.918478</td>\n",
       "      <td>0.911243</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.836957</td>\n",
       "      <td>0.865169</td>\n",
       "      <td>0.962500</td>\n",
       "      <td>[[103, 0], [15, 77]]</td>\n",
       "      <td>[12.947275256731459, 100.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b]</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>544</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>1</td>\n",
       "      <td>0.912821</td>\n",
       "      <td>0.908189</td>\n",
       "      <td>0.899408</td>\n",
       "      <td>0.987013</td>\n",
       "      <td>0.826087</td>\n",
       "      <td>0.853933</td>\n",
       "      <td>0.950000</td>\n",
       "      <td>[[102, 1], [16, 76]]</td>\n",
       "      <td>[100.00000000000001]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-99b]</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>546</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>2</td>\n",
       "      <td>0.907692</td>\n",
       "      <td>0.902754</td>\n",
       "      <td>0.892857</td>\n",
       "      <td>0.986842</td>\n",
       "      <td>0.815217</td>\n",
       "      <td>0.844595</td>\n",
       "      <td>0.946970</td>\n",
       "      <td>[[102, 1], [17, 75]]</td>\n",
       "      <td>[0.8478635746286203, 100.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-200c, hsa-mir-99b]</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>237 rows × 17 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         method  model  n       acc       auc        f1  precision    recall  \\\n",
       "19   ElasticNet     en  6  0.994872  0.994565  0.994536   1.000000  0.989130   \n",
       "20   ElasticNet     en  6  0.994872  0.994565  0.994536   1.000000  0.989130   \n",
       "21   ElasticNet     en  6  0.994872  0.994565  0.994536   1.000000  0.989130   \n",
       "22   ElasticNet     en  6  0.994872  0.994565  0.994536   1.000000  0.989130   \n",
       "23   ElasticNet     en  6  0.994872  0.994565  0.994536   1.000000  0.989130   \n",
       "..          ...    ... ..       ...       ...       ...        ...       ...   \n",
       "511  ElasticNet     en  3  0.953846  0.951087  0.948571   1.000000  0.902174   \n",
       "528       lasso  lasso  2  0.938462  0.934783  0.930233   1.000000  0.869565   \n",
       "536  ElasticNet     en  2  0.923077  0.918478  0.911243   1.000000  0.836957   \n",
       "544  ElasticNet     en  1  0.912821  0.908189  0.899408   0.987013  0.826087   \n",
       "546       lasso  lasso  2  0.907692  0.902754  0.892857   0.986842  0.815217   \n",
       "\n",
       "           f2       f05       confusionmatrix  \\\n",
       "19   0.991285  0.997807   [[103, 0], [1, 91]]   \n",
       "20   0.991285  0.997807   [[103, 0], [1, 91]]   \n",
       "21   0.991285  0.997807   [[103, 0], [1, 91]]   \n",
       "22   0.991285  0.997807   [[103, 0], [1, 91]]   \n",
       "23   0.991285  0.997807   [[103, 0], [1, 91]]   \n",
       "..        ...       ...                   ...   \n",
       "511  0.920177  0.978774   [[103, 0], [9, 83]]   \n",
       "528  0.892857  0.970874  [[103, 0], [12, 80]]   \n",
       "536  0.865169  0.962500  [[103, 0], [15, 77]]   \n",
       "544  0.853933  0.950000  [[102, 1], [16, 76]]   \n",
       "546  0.844595  0.946970  [[102, 1], [17, 75]]   \n",
       "\n",
       "                                          coef_rounded found_coef  delta  \\\n",
       "19   [99.99999999999999, 59.074257572799226, 54.088...       True    0.0   \n",
       "20   [100.0, 57.619339302976435, 55.35030103351411,...       True    0.0   \n",
       "21   [100.0, 56.30475816456298, 56.49067542397592, ...       True    0.0   \n",
       "22   [100.00000000000001, 55.114545393059686, 57.52...       True    0.0   \n",
       "23   [100.0, 54.03486508310612, 58.4599900918236, -...       True    0.0   \n",
       "..                                                 ...        ...    ...   \n",
       "511   [28.40644839176302, 100.0, -0.03538345457509003]       True    0.0   \n",
       "528                        [17.031309199227845, 100.0]       True    0.0   \n",
       "536                        [12.947275256731459, 100.0]       True    0.0   \n",
       "544                               [100.00000000000001]       True    0.0   \n",
       "546                        [0.8478635746286203, 100.0]       True    0.0   \n",
       "\n",
       "    balanced                                            gene_id  reproduce  \n",
       "19     False  [hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...       True  \n",
       "20     False  [hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...       True  \n",
       "21     False  [hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...       True  \n",
       "22     False  [hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...       True  \n",
       "23     False  [hsa-mir-200c, hsa-mir-99b, hsa-let-7b, hsa-mi...       True  \n",
       "..       ...                                                ...        ...  \n",
       "511    False           [hsa-mir-200c, hsa-mir-99b, hsa-mir-143]       True  \n",
       "528    False                        [hsa-mir-200c, hsa-mir-99b]       True  \n",
       "536    False                        [hsa-mir-200c, hsa-mir-99b]       True  \n",
       "544    False                                      [hsa-mir-99b]       True  \n",
       "546    False                        [hsa-mir-200c, hsa-mir-99b]       True  \n",
       "\n",
       "[237 rows x 17 columns]"
      ]
     },
     "execution_count": 23,
     "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": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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",
    "xsl_file = 'results.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": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature = ['hsa-mir-200c', 'hsa-mir-99b', 'hsa-let-7b', 'hsa-mir-22', 'hsa-mir-21', 'hsa-mir-143']\n",
      "weight = [99.99999999999999, 59.074257572799226, 54.08818685424606, -7.034675308195321, -4.967634553261865, -4.814837162856728]\n",
      "times = 36948886.590665944\n",
      "intercept = 0.06665637201287894\n",
      "model = en\n"
     ]
    }
   ],
   "source": [
    "# 选择的模型\n",
    "# 实际输入的模型\n",
    "select = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True][results_sorted_found_coef['n'] <=20].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",
    "print('times =', times)\n",
    "intercept = select.intercept\n",
    "print('intercept =', intercept)\n",
    "model = select.model\n",
    "print('model =', model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": 34,
   "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": 35,
   "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='white', lw=1, linestyle='')\n",
    "    axs[0, 0].set_title('Score distribution')\n",
    "    c = {0: 'navy', 1: 'red'};ls = ['Negative', 'Positive']\n",
    "    ele = [plt.Line2D([0], [0], marker='o', color='none', markerfacecolor=c[i], markersize=7, label=label) for i, label in enumerate(ls)]\n",
    "    legend1 = axs[0, 0].legend(handles=ele, loc='upper right')\n",
    "    axs[0, 0].add_artist(legend1)\n",
    "    #legend1 = axs[0, 0].legend(['Positive', 'Negative','Threshold'], 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=12)     # 在图的下方加上文字，这里的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": 36,
   "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": "Python 3",
   "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
}