lab2/实验作业二_机器学习单模态_模板.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8c9fda4c-4d10-44b0-86d9-0187ae18ed6a",
   "metadata": {},
   "source": [
    "### 使用opensmile提取音频特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3061bfb7-790b-40e4-84a5-21777e581d49",
   "metadata": {},
   "outputs": [],
   "source": [
    "import opensmile\n",
    "import pandas as pd\n",
    "import os\n",
    "import sklearn\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b3d66b3-1655-4c09-90fb-7c45cb291a4c",
   "metadata": {},
   "source": [
    "## 1、构造特征提取函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "037185c3-14fb-48b7-894e-8870d1786124",
   "metadata": {},
   "outputs": [],
   "source": [
    "## 提取特征函数\n",
    "## file_list:音频文件路径的列表  list类型\n",
    "## 返回值numpy.ndarray  形状:(len(file_list),88)\n",
    "def extract_audio_feature(file_list,save_path):\n",
    "    # 如果已存在保存的特征文件，则直接加载\n",
    "    if os.path.exists(save_path):\n",
    "        print(f\"已找到保存的特征文件 '{save_path}'，正在加载...\")\n",
    "        feature = np.load(save_path)\n",
    "        print(\"特征加载完毕！\")\n",
    "        return feature    \n",
    "    print(\"请耐心等待特征提取完！\")\n",
    "    smile = opensmile.Smile(\n",
    "    feature_set=opensmile.FeatureSet.eGeMAPSv02,\n",
    "    feature_level=opensmile.FeatureLevel.Functionals)#指定了特征集（eGeMAPSv02）和特征级别（Functionals）\n",
    "    feature = []\n",
    "    for n,file in enumerate(file_list):#enumerate函数用于遍历，返回一个迭代器（索引和值）\n",
    "        y = smile.process_file(file)#调用process_file函数处理音频文件\n",
    "        y = y.to_numpy().reshape(-1)#-1 表示自动计算这一维的大小\n",
    "        feature.append(y)\n",
    "        if (n+1)%100 == 0:\n",
    "            print(f\"当前进度{n+1}/{len(file_list)}\")\n",
    "    print(\"此次特征提取已结束\")\n",
    "    print(\"-------------------------------\")\n",
    "    feature = np.stack(feature,axis = 0)\n",
    "    # 将特征保存到指定的文件中\n",
    "    np.save(save_path, feature)\n",
    "    print(f\"特征已保存到文件 '{save_path}'\")\n",
    "    \n",
    "    return feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "313ead32",
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_features(features, scaler=None, method='minmax'):\n",
    "    \"\"\"\n",
    "    对已提取的特征进行归一化或标准化处理，并应用训练集的归一化参数。\n",
    "    \n",
    "    参数:\n",
    "    features: numpy.ndarray, 待归一化的特征数据，形状为 (n_samples, n_features)\n",
    "    scaler: 已拟合的归一化器（标准化或归一化器），如果没有提供，则会根据训练集拟合一个新的\n",
    "    method: str, 归一化方法，'standard'为标准化（Z-score），'minmax'为最小-最大归一化，默认 'standard'\n",
    "    \n",
    "    返回:\n",
    "    numpy.ndarray: 归一化后的特征数据\n",
    "    \"\"\"\n",
    "    if method == 'standard':  # 使用标准化 (Z-score)\n",
    "        if scaler is None:  # 如果没有提供 scaler，就拟合一个新的\n",
    "            scaler = StandardScaler()\n",
    "            features = scaler.fit_transform(features)\n",
    "        else:  # 如果提供了 scaler，就应用已经拟合好的归一化参数\n",
    "            features = scaler.transform(features)\n",
    "        print(\"标准化（Z-score）完成\")\n",
    "    \n",
    "    elif method == 'minmax':  # 使用最小-最大归一化\n",
    "        if scaler is None:\n",
    "            scaler = MinMaxScaler()\n",
    "            features = scaler.fit_transform(features)\n",
    "        else:\n",
    "            features = scaler.transform(features)\n",
    "        print(\"最小-最大归一化完成\")\n",
    "    \n",
    "    else:\n",
    "        raise ValueError(\"未知的归一化方法，请选择 'standard' 或 'minmax'。\")\n",
    "    \n",
    "    return features, scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "52c093c8-ffc1-4c3c-ac38-5cdb0f52ba18",
   "metadata": {},
   "outputs": [],
   "source": [
    "## 特征提取示例\n",
    "#file = \"./train/Ses01F_impro01_F000.wav\"\n",
    "#audio_feature = extract_audio_feature([file])\n",
    "#print(type(audio_feature),audio_feature.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b942c23-9f97-48a5-9c04-395639fd3a66",
   "metadata": {},
   "source": [
    "## 2、csv文件读入示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2996d3bc-d357-4668-a624-a76d3f4fe372",
   "metadata": {},
   "outputs": [],
   "source": [
    "## 读入csv文件示例\n",
    "## 由于我们的csv文件使用\"#\"分隔，需要定义sep参数为\"#\",否则会读取失败！！！\n",
    "train_csv = pd.read_csv(\"./CSVfile/train.csv\",sep=\"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "743c4b1c-beb9-4802-8ad4-eaff49fa7f39",
   "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>num</th>\n",
       "      <th>id</th>\n",
       "      <th>path</th>\n",
       "      <th>text</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Ses01F_impro01_F000</td>\n",
       "      <td>train/Ses01F_impro01_F000.wav</td>\n",
       "      <td>Excuse me.</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Ses01F_impro01_F001</td>\n",
       "      <td>train/Ses01F_impro01_F001.wav</td>\n",
       "      <td>Yeah.</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Ses01F_impro01_F002</td>\n",
       "      <td>train/Ses01F_impro01_F002.wav</td>\n",
       "      <td>Is there a problem?</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Ses01F_impro01_F005</td>\n",
       "      <td>train/Ses01F_impro01_F005.wav</td>\n",
       "      <td>Well what's the problem?  Let me change it.</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Ses01F_impro01_F012</td>\n",
       "      <td>train/Ses01F_impro01_F012.wav</td>\n",
       "      <td>That's out of control.</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   num                   id                           path  \\\n",
       "0    1  Ses01F_impro01_F000  train/Ses01F_impro01_F000.wav   \n",
       "1    2  Ses01F_impro01_F001  train/Ses01F_impro01_F001.wav   \n",
       "2    3  Ses01F_impro01_F002  train/Ses01F_impro01_F002.wav   \n",
       "3    4  Ses01F_impro01_F005  train/Ses01F_impro01_F005.wav   \n",
       "4    5  Ses01F_impro01_F012  train/Ses01F_impro01_F012.wav   \n",
       "\n",
       "                                          text  label  \n",
       "0                                   Excuse me.      2  \n",
       "1                                        Yeah.      2  \n",
       "2                          Is there a problem?      2  \n",
       "3  Well what's the problem?  Let me change it.      2  \n",
       "4                       That's out of control.      0  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## 快速查看前5条数据\n",
    "train_csv.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b5ab3872-3da8-4f5f-9331-b72a4ddbd472",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "label\n",
       "2    1066\n",
       "1     891\n",
       "3     696\n",
       "0     606\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## 统计该csv下lable列不同值的数量\n",
    "train_csv.value_counts(subset=\"label\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3d370b09-9821-4109-991c-493c0954b27f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Train dataset sample distribution')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## 画图显示类别数\n",
    "plt.bar([0,1,2,3],list(train_csv.value_counts(subset=\"label\")),tick_label = [\"0\",\"1\",\"2\",\"3\"])\n",
    "plt.xlabel(\"Label\")\n",
    "plt.ylabel(\"Num\")\n",
    "plt.title(\"Train dataset sample distribution\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e484248-1338-44b6-87d4-75220e0a6f3f",
   "metadata": {},
   "source": [
    "## 3、性能指标函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "26ee6440-0f98-4edd-874e-a21f56be1d7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6f5bf921-2d72-4144-bdc1-e4cde8fbd009",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_score_classification(preds, labels, average_f1='macro'):  # weighted, macro\n",
    "    accuracy = accuracy_score(labels, preds)\n",
    "    f1 = f1_score(labels, preds, average=average_f1, zero_division=0)\n",
    "    precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "    ua = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "    confuse_matrix = confusion_matrix(labels, preds)\n",
    "    return accuracy, ua, f1, precision, confuse_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56698ac9-01ae-4e00-8dc4-62e69d12fad8",
   "metadata": {},
   "source": [
    "### 4、构造机器学习模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36e664f2-00f8-444a-aecd-60e92b3462ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# #使用sklearn实现随机森林\n",
    "# from sklearn.ensemble import RandomForestClassifier\n",
    "# from sklearn.metrics import accuracy_score\n",
    "# ## 这里的myrf类仅为示例，可以自行修改以达到更好的性能\n",
    "# # class MyRF:\n",
    "# #     def __init__(self):\n",
    "# #         pass\n",
    "# #     def train(self):\n",
    "# #         pass\n",
    "# #     def evaluate(self):\n",
    "# #         pass\n",
    "# from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, n_estimators=100, max_depth=None, random_state=42):\n",
    "#         # 初始化随机森林分类器，指定一些参数\n",
    "#         self.model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=random_state)\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练模型\n",
    "#         print(\"开始训练模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         # 返回 5 个指标\n",
    "#         accuracy, ua, f1, precision, confuse_matrix = calculate_score_classification(preds, labels)\n",
    "#         return accuracy, ua, f1, precision, confuse_matrix\n",
    "\n",
    "\n",
    "\n",
    "# from sklearn.linear_model import LinearRegression\n",
    "# from sklearn.metrics import mean_squared_error, r2_score\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self):\n",
    "#         # 初始化线性回归模型\n",
    "#         self.model = LinearRegression()\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练模型\n",
    "#         print(\"开始训练线性回归模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"线性回归模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         # 返回 5 个指标\n",
    "#         accuracy, ua, f1, precision, confuse_matrix = calculate_score_classification(preds, labels)\n",
    "#         return accuracy, ua, f1, precision, confuse_matrix\n",
    "\n",
    "# from sklearn.svm import SVC\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, kernel='rbf', C=1.0, gamma='scale'):\n",
    "#         # 初始化支持向量机分类器\n",
    "#         self.model = SVC(kernel=kernel, C=C, gamma=gamma)\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练SVM分类器\n",
    "#         print(\"开始训练支持向量机模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"支持向量机模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         # 返回评估指标\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "\n",
    "# from sklearn.ensemble import RandomForestClassifier, VotingClassifier\n",
    "# from sklearn.svm import SVC\n",
    "# from sklearn.neighbors import KNeighborsClassifier\n",
    "# from sklearn.gaussian_process import GaussianProcessClassifier\n",
    "# from sklearn.tree import DecisionTreeClassifier\n",
    "# from sklearn.neural_network import MLPClassifier\n",
    "# from sklearn.ensemble import AdaBoostClassifier\n",
    "# from sklearn.naive_bayes import GaussianNB\n",
    "# from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# from sklearn.gaussian_process import GaussianProcessClassifier\n",
    "# from sklearn.gaussian_process.kernels import RBF\n",
    "\n",
    "# from sklearn.ensemble import VotingClassifier\n",
    "# from sklearn.neighbors import KNeighborsClassifier\n",
    "# from sklearn.svm import SVC\n",
    "# from sklearn.gaussian_process import GaussianProcessClassifier\n",
    "# from sklearn.gaussian_process.kernels import RBF\n",
    "# from sklearn.tree import DecisionTreeClassifier\n",
    "# from sklearn.neural_network import MLPClassifier\n",
    "# from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "# from sklearn.naive_bayes import GaussianNB\n",
    "# from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self):\n",
    "#         # 使用 RBF 核\n",
    "#         self.classifiers = [\n",
    "#             (\"Nearest Neighbors\", KNeighborsClassifier(3)),\n",
    "#             (\"Linear SVM\", SVC(kernel=\"linear\", C=0.025, probability=True)),  # 注意要设置 probability=True\n",
    "#             (\"RBF SVM\", SVC(gamma=2, C=1, probability=True)),  # 同样设置 probability=True\n",
    "#             (\"Gaussian Process\", GaussianProcessClassifier(kernel=RBF(1.0))),  # 使用 RBF 核\n",
    "#             (\"Decision Tree\", DecisionTreeClassifier(max_depth=5)),\n",
    "#             (\"Random Forest\", RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1)),\n",
    "#             (\"Neural Net\", MLPClassifier(alpha=1, max_iter=1000)),\n",
    "#             (\"AdaBoost\", AdaBoostClassifier()),\n",
    "#             (\"Naive Bayes\", GaussianNB()),\n",
    "#             (\"QDA\", QuadraticDiscriminantAnalysis())\n",
    "#         ]\n",
    "        \n",
    "#         # 使用软投票集成分类器（需要分类器支持 predict_proba）\n",
    "#         self.model = VotingClassifier(estimators=self.classifiers, voting='soft')\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练集成模型\n",
    "#         print(\"开始训练集成模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"集成模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估集成模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from sklearn.neighbors import KNeighborsClassifier\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, n_neighbors=4):\n",
    "#         # 初始化KNN分类器\n",
    "#         self.model = KNeighborsClassifier(n_neighbors=n_neighbors)\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练KNN分类器\n",
    "#         print(\"开始训练KNN模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"KNN模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         # 返回评估指标\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from sklearn.svm import SVC\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, kernel='rbf', C=1.0, gamma='scale'):\n",
    "#         \"\"\"\n",
    "#         初始化 RBF 核支持向量机模型\n",
    "#         :param kernel: 核函数类型，这里默认使用 RBF 核\n",
    "#         :param C: 正则化参数，默认值为 1.0\n",
    "#         :param gamma: RBF 核的 gamma 参数，默认值为 'scale'\n",
    "#         \"\"\"\n",
    "#         self.model = SVC(kernel=kernel, C=C, gamma=gamma)\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         \"\"\"\n",
    "#         训练 SVM 模型\n",
    "#         :param features: 训练特征\n",
    "#         :param labels: 训练标签\n",
    "#         \"\"\"\n",
    "#         print(\"开始训练 RBF 核支持向量机模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"RBF 核支持向量机模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         \"\"\"\n",
    "#         在验证集上评估 SVM 模型\n",
    "#         :param features: 验证集特征\n",
    "#         :param labels: 验证集标签\n",
    "#         :return: 准确率、召回率、F1 分数、精确率和混淆矩阵\n",
    "#         \"\"\"\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from sklearn.tree import DecisionTreeClassifier\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "# from sklearn.model_selection import train_test_split\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, criterion='gini', max_depth=None, random_state=42):\n",
    "#         \"\"\"\n",
    "#         初始化决策树分类器\n",
    "#         - criterion: 划分标准，可选 'gini' 或 'entropy'\n",
    "#         - max_depth: 决策树的最大深度\n",
    "#         \"\"\"\n",
    "#         self.model = DecisionTreeClassifier(criterion=criterion, max_depth=max_depth, random_state=random_state)\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练决策树分类器\n",
    "#         print(\"开始训练决策树模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"决策树模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from sklearn.ensemble import AdaBoostClassifier\n",
    "# from sklearn.tree import DecisionTreeClassifier\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "# from sklearn.model_selection import train_test_split\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, estimator=None, n_estimators=50, learning_rate=1.0, random_state=42):\n",
    "#         \"\"\"\n",
    "#         初始化AdaBoost分类器\n",
    "#         - estimator: 基础分类器，默认为决策树\n",
    "#         - n_estimators: 最大弱分类器数量\n",
    "#         - learning_rate: 学习率\n",
    "#         \"\"\"\n",
    "#         if estimator is None:\n",
    "#             estimator = DecisionTreeClassifier(max_depth=1)\n",
    "#         self.model = AdaBoostClassifier(\n",
    "#             estimator=estimator,\n",
    "#             n_estimators=n_estimators,\n",
    "#             learning_rate=learning_rate,\n",
    "#             random_state=random_state,\n",
    "#         )\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练AdaBoost分类器\n",
    "#         print(\"开始训练AdaBoost模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"AdaBoost模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from sklearn.naive_bayes import GaussianNB\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# class MyRF:\n",
    "#     def __init__(self):\n",
    "#         \"\"\"\n",
    "#         初始化朴素贝叶斯分类器\n",
    "#         \"\"\"\n",
    "#         self.model = GaussianNB()\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练朴素贝叶斯分类器\n",
    "#         print(\"开始训练朴素贝叶斯模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"朴素贝叶斯模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "# class MyRF:\n",
    "#     def __init__(self, reg_param=0.0, priors=None, tol=1e-4):\n",
    "#         \"\"\"\n",
    "#         初始化二次判别分析分类器\n",
    "#         \"\"\"\n",
    "#         self.model = QuadraticDiscriminantAnalysis(reg_param=reg_param, priors=priors, tol=tol)\n",
    "#         # 如果需要设置 solver 参数，可以在这里手动设置\n",
    "#         # self.model.solver = 'lsqr'  # 或者 'eig'\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练二次判别分析分类器\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"二次判别分析模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 评估模型\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy = accuracy_score(labels, preds)\n",
    "#         f1 = f1_score(labels, preds, average='macro', zero_division=0)\n",
    "#         precision = precision_score(labels, preds, average='macro', zero_division=0)\n",
    "#         recall = recall_score(labels, preds, average='macro', zero_division=0)\n",
    "#         confuse_matrix = confusion_matrix(labels, preds)\n",
    "#         return accuracy, recall, f1, precision, confuse_matrix\n",
    "# from autosklearn.classification import AutoSklearnClassifier\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self):\n",
    "#         self.model = AutoSklearnClassifier(time_left_for_this_task=60,  per_run_time_limit=10,         #每个模型的最大运行时间为30秒\n",
    "#                                            )\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练模型\n",
    "#         print(\"开始训练模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         # 返回 5 个指标\n",
    "#         accuracy, ua, f1, precision, confuse_matrix = calculate_score_classification(preds, labels)\n",
    "#         return accuracy, ua, f1, precision, confuse_matrix\n",
    "\n",
    "#     def predict(self, features):\n",
    "#         return self.model.predict(features)\n",
    "    \n",
    "#     def show_and_save_models(self, filename=\"model_info.txt\"):\n",
    "#         # 获取所有模型的详细信息\n",
    "#         models_info = self.model.show_models()\n",
    "    \n",
    "#         # 将信息打印到控制台\n",
    "#         print(\"Model information:\")\n",
    "#         for model_idx, model_details in models_info.items():\n",
    "#             print(f\"Model {model_idx}:\")\n",
    "#             for key, value in model_details.items():\n",
    "#                 print(f\"  {key}: {value}\")\n",
    "#             print(\"\\n\")\n",
    "    \n",
    "#         # 将信息保存到文件\n",
    "#         with open(filename, \"w\") as f:\n",
    "#             f.write(\"Model information:\\n\")\n",
    "#             for model_idx, model_details in models_info.items():\n",
    "#                 f.write(f\"Model {model_idx}:\\n\")\n",
    "#                 for key, value in model_details.items():\n",
    "#                     f.write(f\"  {key}: {value}\\n\")\n",
    "#                 f.write(\"\\n\")\n",
    "# from sklearn.svm import SVC\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# class MyRF:\n",
    "#     def __init__(self, kernel='rbf', C=1.0, gamma='scale'):\n",
    "#         self.model = SVC(kernel=kernel, C=C, gamma=gamma)\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         # 训练模型\n",
    "#         print(\"开始训练SVM模型...\")\n",
    "#         self.model.fit(features, labels)\n",
    "#         print(\"SVM模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy, recall, f1, precision, conf_matrix = calculate_score_classification(preds, labels)\n",
    "#         return accuracy, recall, f1, precision, conf_matrix\n",
    "# from sklearn.svm import SVC\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# from skopt import BayesSearchCV  # 导入贝叶斯优化类\n",
    "# from skopt.space import Real, Categorical, Integer\n",
    "# from skopt.utils import use_named_args\n",
    "\n",
    "# from skopt import BayesSearchCV\n",
    "# from skopt.space import Real, Categorical, Integer\n",
    "# from sklearn.svm import SVC\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, kernel='rbf', C=1.0, gamma='scale'):\n",
    "#         self.model = SVC(kernel=kernel, C=C, gamma=gamma)\n",
    "#         self.param_space = {\n",
    "#             'C': Real(0.01, 3, prior='uniform'),  # C的范围\n",
    "#             'gamma': Categorical(['scale']) ,\n",
    "#             'kernel': Categorical(['poly']),  # 核函数类型'rbf', 'linear', 'sigmoid'\n",
    "#             'degree': Integer(2, 8),  # 仅对poly核有效，表示多项式核的度数\n",
    "#             'coef0': Real(-1.0, 1.0),  # poly和sigmoid核的偏置项\n",
    "#             'class_weight': Categorical([None, 'balanced']),  # 处理类别不平衡\n",
    "#             'tol': Real(5e-5, 1e-1, prior='log-uniform'),  # 容忍度范围，采用对数均匀分布\n",
    "#         }\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         print(\"开始贝叶斯优化...\")\n",
    "\n",
    "#         # 使用贝叶斯优化来寻找最佳参数\n",
    "#         bayes_search = BayesSearchCV(self.model, self.param_space, n_iter=100, cv=5, scoring='f1_macro', verbose=1)\n",
    "#         bayes_search.fit(features, labels)\n",
    "        \n",
    "#         print(\"贝叶斯优化完成，最佳参数：\", bayes_search.best_params_)\n",
    "#         self.model = bayes_search.best_estimator_\n",
    "#         print(\"SVM模型训练完成！\")\n",
    "\n",
    "#     def evaluate(self, features, labels):\n",
    "#         # 在验证集上评估模型\n",
    "#         print(\"开始评估模型...\")\n",
    "#         preds = self.model.predict(features)\n",
    "#         accuracy, recall, f1, precision, conf_matrix = calculate_score_classification(preds, labels)\n",
    "#         return accuracy, recall, f1, precision, conf_matrix\n",
    "# from catboost import CatBoostClassifier\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "# from skopt import BayesSearchCV\n",
    "# from skopt.space import Real, Integer, Categorical\n",
    "\n",
    "# class MyRF:\n",
    "#     def __init__(self, random_state=42):\n",
    "#         # 设置模型的初始参数\n",
    "#         self.model = CatBoostClassifier(random_state=random_state, verbose=0)\n",
    "\n",
    "#         # 定义贝叶斯优化的超参数空间\n",
    "#         self.param_space = {\n",
    "#             'iterations': Integer(100, 1000),  # 迭代次数\n",
    "#             'depth': Integer(3, 10),           # 树的深度\n",
    "#             'learning_rate': Real(0.01, 0.3),  # 学习率\n",
    "#             'l2_leaf_reg': Real(1, 10),        # L2正则化\n",
    "#             'border_count': Integer(32, 255),  # 特征的划分数\n",
    "#             'thread_count': Categorical([1, 2, 4, 8, 16]),  # 线程数\n",
    "#         }\n",
    "\n",
    "#     def train(self, features, labels):\n",
    "#         print(\"开始贝叶斯优化...\")\n",
    "\n",
    "#         # 使用BayesSearchCV进行贝叶斯优化\n",
    "#         bayes_search = BayesSearchCV(self.model, self.param_space, n_iter=50, cv=3, scoring='f1_macro', verbose=1)\n",
    "#         bayes_search.fit(features, labels)\n",
    "\n",
    "#         print(\"贝叶斯优化完成，最佳参数：\", bayes_search.best_params_)\n",
    "\n",
    "#         # 使用找到的最佳参数训练模型\n",
    "#         self.model = bayes_search.best_estimator_\n",
    "#         print(\"CatBoost模型训练完成！\")\n",
    "\n",
    "    # def evaluate(self, features, labels):\n",
    "    #     print(\"开始评估模型...\")\n",
    "    #     preds = self.model.predict(features)\n",
    "    #     accuracy = accuracy_score(labels, preds)\n",
    "    #     f1 = f1_score(labels, preds, average='macro')\n",
    "    #     precision = precision_score(labels, preds, average='macro')\n",
    "    #     recall = recall_score(labels, preds, average='macro')\n",
    "    #     conf_matrix = confusion_matrix(labels, preds)\n",
    "    #     return accuracy, recall, f1, precision, conf_matrix\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix\n",
    "from skopt import BayesSearchCV\n",
    "from skopt.space import Real, Categorical, Integer\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "class MyRF:\n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        初始化逻辑回归分类器\n",
    "        \"\"\"\n",
    "        self.model = LogisticRegression(max_iter=10000)  # 增加迭代次数避免收敛问题\n",
    "\n",
    "        # 贝叶斯优化的超参数空间\n",
    "        self.param_space = {\n",
    "            'C': Real(1e-6, 1e-2, prior='log-uniform'),  # 正则化参数 C\n",
    "            'penalty': Categorical(['l2', 'l1']),  # 正则化类型：l2, l1\n",
    "            'solver': Categorical(['liblinear', 'saga']),  # 求解器选择：liblinear 或 saga\n",
    "        }\n",
    "\n",
    "    def train(self, features, labels):\n",
    "        \"\"\"\n",
    "        使用贝叶斯优化训练逻辑回归模型\n",
    "        \"\"\"\n",
    "        print(\"开始贝叶斯优化训练逻辑回归模型...\")\n",
    "\n",
    "        # 使用贝叶斯优化寻找最佳的超参数\n",
    "        bayes_search = BayesSearchCV(self.model, self.param_space, n_iter=50, cv=5, scoring='f1_macro', verbose=1)\n",
    "        bayes_search.fit(features, labels)\n",
    "        \n",
    "        print(\"贝叶斯优化完成，最佳参数：\", bayes_search.best_params_)\n",
    "        self.model = bayes_search.best_estimator_\n",
    "        print(\"逻辑回归模型训练完成！\")\n",
    "\n",
    "    def evaluate(self, features, labels):\n",
    "        \"\"\"\n",
    "        评估模型性能\n",
    "        \"\"\"\n",
    "        print(\"开始评估模型......\")\n",
    "        preds = self.model.predict(features)\n",
    "        \n",
    "        # 计算评估指标\n",
    "        accuracy = accuracy_score(labels, preds)\n",
    "        f1 = f1_score(labels, preds, average='macro')\n",
    "        precision = precision_score(labels, preds, average='macro')\n",
    "        recall = recall_score(labels, preds, average='macro')\n",
    "        conf_matrix = confusion_matrix(labels, preds)\n",
    "        \n",
    "        return accuracy, recall, f1, precision, conf_matrix\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9455c40-5fbb-4246-be20-f34e6110ac3a",
   "metadata": {},
   "source": [
    "## 5、读取csv文件，分离音频文件路径、标签"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8b93e714-a3c8-4185-9129-377a8001a14a",
   "metadata": {},
   "outputs": [],
   "source": [
    "## 读取train.csv、dev.csv\n",
    "train_csv = pd.read_csv(\"./CSVfile/train.csv\", sep = \"#\")\n",
    "dev_csv = pd.read_csv(\"./CSVfile/dev.csv\", sep = \"#\")\n",
    "## 分离文件路径和标签\n",
    "## 可先截取少量样本验证代码正确性，再使用所有样本\n",
    "# train_path = list(train_csv.path)[:100]\n",
    "# train_label = list(train_csv.label)[:100]\n",
    "# dev_path = list(dev_csv.path)[:50]\n",
    "# dev_label = list(dev_csv.label)[:50]\n",
    "\n",
    "train_path = list(train_csv.path)\n",
    "train_label = list(train_csv.label)\n",
    "dev_path = list(dev_csv.path)\n",
    "dev_label = list(dev_csv.label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21e94ff3-cfe9-46e4-bdc3-68d2c71e67a1",
   "metadata": {},
   "source": [
    "## 6、结果写入函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "080fa340-a9ca-48ff-abec-187b4a65dfe7",
   "metadata": {},
   "outputs": [],
   "source": [
    "## test_preds 长度为1241的list，对应测试集中1241个样本的标签\n",
    "##运行后会在当前目录生成result.csv文件，提交result.csv文件即可\n",
    "##如果没有生成，请检查test_preds的长度是否为1241！\n",
    "def write_result(test_preds):\n",
    "    if len(test_preds) != 1241:\n",
    "        print(\"错误！请检查test_preds长度是否为1241！！！\")\n",
    "        return -1\n",
    "    test_csv = pd.read_csv(\"./CSVfile/test.csv\",sep=\"#\")\n",
    "    test_csv[\"label\"] = test_preds\n",
    "    test_csv.to_csv(\"./result.csv\",sep = \"#\")\n",
    "    print(\"测试集预测结果已成功写入到文件中！\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70446b3a-cc68-422c-9d2c-afea8df57fb8",
   "metadata": {},
   "source": [
    "## 7、特征预处理函数、主函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b89011cb-de51-47da-9043-7b3371877d03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "已找到保存的特征文件 './feature/train_feature.npy'，正在加载...\n",
      "特征加载完毕！\n",
      "最小-最大归一化完成\n",
      "开始贝叶斯优化训练逻辑回归模型...\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/pp2/lib/python3.9/site-packages/skopt/optimizer/optimizer.py:517: UserWarning: The objective has been evaluated at point [0.01, 'l2', 'saga'] before, using random point [0.0059214427120961085, 'l2', 'liblinear']\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n",
      "贝叶斯优化完成，最佳参数： OrderedDict([('C', 0.01), ('penalty', 'l2'), ('solver', 'saga')])\n",
      "逻辑回归模型训练完成！\n",
      "开始评估模型......\n",
      "train:\n",
      "Acc:0.5041423749616447 \n",
      "Ua:0.4769779447654642 \n",
      "Macro_F1:0.4921229202995768 \n",
      "Pre:0.5733742639953581\n",
      "Confuse_matrix:\n",
      "[[190 233 174   9]\n",
      " [ 53 403 378  57]\n",
      " [  3 183 735 145]\n",
      " [  1  24 356 315]]\n",
      "已找到保存的特征文件 './feature/dev_feature.npy'，正在加载...\n",
      "特征加载完毕！\n",
      "最小-最大归一化完成\n",
      "开始评估模型......\n",
      "dev:\n",
      "Acc:0.44131910766246363 \n",
      "Ua:0.43620242754117367 \n",
      "Macro_F1:0.43044363771326505 \n",
      "Pre:0.5233281074011905\n",
      "Confuse_matrix:\n",
      "[[ 81 145  96   5]\n",
      " [ 28 172  99   4]\n",
      " [  0  76 155  27]\n",
      " [  0   4  92  47]]\n",
      "已找到保存的特征文件 './feature/test_feature.npy'，正在加载...\n",
      "特征加载完毕！\n",
      "最小-最大归一化完成\n",
      "1241\n",
      "测试集预测结果已成功写入到文件中！\n"
     ]
    }
   ],
   "source": [
    "## 特征处理函数，可以对提取的特征进行处理，以获得更好的特征表示\n",
    "def feature_process(feature):\n",
    "    return feature\n",
    "\n",
    "## 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    ## 实例化模型\n",
    "    rf = MyRF()\n",
    "    ## 提取训练样本特征\n",
    "    ## 文件数量很多时需要的时间较长，请耐心等待\n",
    "    train_save_path=\"./feature/train_feature.npy\"\n",
    "    train_feature = extract_audio_feature(train_path,train_save_path) ## np.array (n,88)\n",
    "    train_feature_normalized, scaler = normalize_features(train_feature, method='minmax')\n",
    "    train_feature = feature_process(train_feature_normalized)\n",
    "\n",
    "    ##训练模型\n",
    "    rf.train(train_feature_normalized,train_label)\n",
    "    ##评估在训练集上的拟合效果\n",
    "    acc,ua,f1,pre,confuse_matrix = rf.evaluate(train_feature_normalized,np.array(train_label))\n",
    "    print(f\"train:\\nAcc:{acc} \\nUa:{ua} \\nMacro_F1:{f1} \\nPre:{pre}\\nConfuse_matrix:\\n{confuse_matrix}\")\n",
    "    \n",
    "    ##计算在dev上的性能\n",
    "    dev_save_path=\"./feature/dev_feature.npy\"\n",
    "    dev_feature = extract_audio_feature(dev_path,dev_save_path)\n",
    "    dev_feature_normalized, _ = normalize_features(dev_feature, scaler=scaler, method='minmax')\n",
    "    dev_feature = feature_process(dev_feature_normalized)\n",
    "    acc,ua,f1,pre,confuse_matrix = rf.evaluate(dev_feature_normalized,np.array(dev_label))\n",
    "    print(f\"dev:\\nAcc:{acc} \\nUa:{ua} \\nMacro_F1:{f1} \\nPre:{pre}\\nConfuse_matrix:\\n{confuse_matrix}\")\n",
    "    \n",
    "    #rf.show_and_save_models(\"model_info.txt\")\n",
    "    ##读入test.csv\n",
    "    test_csv = pd.read_csv(\"./CSVfile/test.csv\",sep = \"#\")\n",
    "    test_path = list(test_csv.path)\n",
    "    test_save_path=\"./feature/test_feature.npy\"\n",
    "    test_feature = extract_audio_feature(test_path,test_save_path)\n",
    "    test_feature_normalized, _ = normalize_features(test_feature, scaler=scaler, method='minmax')\n",
    "    test_label = rf.model.predict(test_feature_normalized)\n",
    "    test_preds = test_label\n",
    "    print(len(test_feature))\n",
    "    \n",
    "    ## 通过模型获得测试集对应的标签列表test_preds，并写入到result.csv文件中\n",
    "    write_result(test_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2add4368-4312-4972-a6f7-fdea31f31d8e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pp2",
   "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.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}