ml4vortex_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV,RandomizedSearchCV\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "from scipy.stats import uniform, randint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "############原始数据运用机器学习方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Ū2', 'H1', 'H2', 'T1', 'T2', 't-', 'Fmin', 'height(m)', 'label'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "vortex_v=pd.read_excel('C:\\\\Users\\\\Desktop\\\\identification1-1toZH.xlsx',sheet_name='Sheet1')\n",
    "vortex_v=vortex_v.dropna()\n",
    "# vortex_u=vortex_v['Ū']\n",
    "# vortex_t=vortex_v['t']\n",
    "print(vortex_v.columns)\n",
    "# target=pd.read_excel('C:\\\\Users\\\\Desktop\\\\identification1-1toZH.xlsx',sheet_name='Sheet2')\n",
    "# print(target)\n",
    "# vortex_v_norm.plot.scatter(x='Ū',y='t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-validation scores: [0.54166667 0.70833333 0.45833333 0.54166667 0.58333333 0.79166667\n",
      " 0.60869565 0.7826087  0.56521739 0.60869565]\n",
      "Average Accuracy: 0.6190217391304348\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "from sklearn.model_selection import cross_val_score, KFold\n",
    "warnings.filterwarnings('ignore')\n",
    "# 划分训练集和测试集\n",
    "vortex = vortex_v[['Ū2','H1','H2','T1','T2','Fmin']]\n",
    "target = vortex_v[['label']]\n",
    "# print(vortex.to_numpy)\n",
    "# print(target.to_numpy)\n",
    "# print(vortex)\n",
    "# print(target)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(vortex, target, test_size=0.2, random_state=42)\n",
    "\n",
    "# # 定义超参数的搜索范围\n",
    "# param_dist = {'C': uniform(loc=0, scale=10),\n",
    "#               'kernel': ['linear','sigmoid', 'rbf'],\n",
    "#               'gamma': uniform(loc=0, scale=10),\n",
    "#               'max_iter': [1000000] }\n",
    "\n",
    "# 创建SVM分类器\n",
    "svm = SVC()\n",
    "\n",
    "# # 使用随机搜索进行超参数调整\n",
    "# random_search = RandomizedSearchCV(svm, param_distributions=param_dist, n_iter=10, cv=3)\n",
    "# random_search.fit(X_train, y_train)\n",
    "\n",
    "# # 输出最佳超参数组合\n",
    "# print(\"最佳超参数组合:\", random_search.best_params_)\n",
    "\n",
    "# # 在测试集上评估模型\n",
    "# best_model = random_search.best_estimator_\n",
    "# test_predictions = best_model.predict(X_test)\n",
    "# test_accuracy = accuracy_score(y_test, test_predictions)\n",
    "# print(\"测试集准确率:\", test_accuracy)\n",
    "\n",
    "# 创建 k 折交叉验证对象\n",
    "kfold = KFold(n_splits=10)\n",
    "\n",
    "# 执行交叉验证\n",
    "scores = cross_val_score(svm,vortex, target, cv=kfold)\n",
    "\n",
    "# 输出交叉验证结果\n",
    "print(\"Cross-validation scores:\", scores)\n",
    "print(\"Average Accuracy:\", scores.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#可视化SVM结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###########逻辑斯蒂函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-validation scores: [0.78947368 0.78947368 0.68421053 0.68421053 0.68421053 0.89473684\n",
      " 0.89473684 1.         0.83333333 0.88888889]\n",
      "Average Accuracy: 0.814327485380117\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from scipy.stats import uniform\n",
    "from sklearn.model_selection import cross_val_score\n",
    "# 创建逻辑斯蒂回归模型\n",
    "model = LogisticRegression()\n",
    "\n",
    "# 定义要调整的超参数分布\n",
    "param_dist = {'C': uniform(loc=0, scale=4), 'penalty': ['l1', 'l2']}\n",
    "\n",
    "# # 执行随机搜索\n",
    "# random_search = RandomizedSearchCV(model, param_distributions=param_dist, n_iter=10, cv=5)\n",
    "# random_search.fit(X_train, y_train)\n",
    "\n",
    "# # 输出最佳参数组合\n",
    "# print(\"Best Parameters:\", random_search.best_params_)\n",
    "\n",
    "# # 输出最佳模型的性能\n",
    "# print(\"Best Score:\", random_search.best_score_)\n",
    "# 执行交叉验证\n",
    "scores = cross_val_score(model, X_train, y_train, cv=10)\n",
    "\n",
    "# 输出每折交叉验证的准确率\n",
    "print(\"Cross-validation scores:\", scores)\n",
    "\n",
    "# 输出平均准确率\n",
    "print(\"Average Accuracy:\", scores.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [10/100], Loss: 0.6425\n",
      "Epoch [20/100], Loss: 0.6008\n",
      "Epoch [30/100], Loss: 0.5584\n",
      "Epoch [40/100], Loss: 0.5149\n",
      "Epoch [50/100], Loss: 0.4524\n",
      "Epoch [60/100], Loss: 0.4084\n",
      "Epoch [70/100], Loss: 0.3776\n",
      "Epoch [80/100], Loss: 0.3576\n",
      "Epoch [90/100], Loss: 0.3421\n",
      "Epoch [100/100], Loss: 0.3269\n",
      "accuracy_score= tensor([0.7292])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "vortex_np = np.array(vortex)\n",
    "target_np = np.array(target)\n",
    "vortex_tensor = torch.from_numpy(vortex_np).to(torch.float32)\n",
    "target_tensor = torch.from_numpy(target_np).to(torch.float32)\n",
    "\n",
    "# print(vortex_tensor.shape)\n",
    "# print(target_tensor.shape)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(vortex_tensor, target_tensor, test_size=0.2, random_state=42)\n",
    "\n",
    "# print(X_train.dtype)\n",
    "# print(X_test.dtype)\n",
    "\n",
    "# print(X_test)\n",
    "# print(y_test)\n",
    "\n",
    "# 定义神经网络模型\n",
    "class SimpleNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SimpleNet, self).__init__()\n",
    "        self.hidden1 = nn.Linear(6,8)\n",
    "        self.bn = nn.BatchNorm1d(8)\n",
    "\n",
    "        self.hidden2 = nn.Linear(8,8)\n",
    "        \n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        self.out = nn.Linear(8,1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.hidden1(x)\n",
    "        out = self.bn(out)\n",
    "        out = self.sigmoid(out)\n",
    "        # print('------------------')\n",
    "        # print(out)\n",
    "        out = self.hidden2(out)\n",
    "        out = self.bn(out)\n",
    "        out = self.sigmoid(out)\n",
    "        # print('-------------')\n",
    "        # print(out)\n",
    "        out = self.out(out)\n",
    "        out = self.sigmoid(out)\n",
    "        # print('-------------end')\n",
    "        # print(out)\n",
    "        \n",
    "        return out\n",
    "\n",
    "# 创建模型实例\n",
    "model = SimpleNet()\n",
    "\n",
    "# 定义损失函数和优化器\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.02)\n",
    "\n",
    "# 训练模型\n",
    "num_epochs = 100\n",
    "for epoch in range(num_epochs):\n",
    "    # 前向传播\n",
    "    outputs = model(X_train)\n",
    "    loss = criterion(outputs, y_train)\n",
    "\n",
    "    # 反向传播和优化\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    # 打印训练信息\n",
    "    if (epoch+1) % 10 == 0:\n",
    "        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n",
    "\n",
    "\n",
    "\n",
    "# 使用训练好的模型进行预测\n",
    "with torch.no_grad():\n",
    "    predictions = model(X_test)\n",
    "    rounded_predictions = torch.round(predictions)\n",
    "\n",
    "# 打印预测结果\n",
    "sum_1=0\n",
    "for i in range(len(X_test)):\n",
    "    # print(X_test[i].numpy(), rounded_predictions[i].item())\n",
    "    sum_1+=(int(rounded_predictions[i].item())==y_test[i])\n",
    "    # print(predictions[i].item())\n",
    "print('accuracy_score=',sum_1/len(X_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##########点二列相关性分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PointbiserialrResult(correlation=array([0.12358837382501103], dtype=object), pvalue=0.05798727523752299)\n",
      "PointbiserialrResult(correlation=array([-0.46153227875060715], dtype=object), pvalue=7.488220033915613e-14)\n",
      "PointbiserialrResult(correlation=array([-0.2487833336229099], dtype=object), pvalue=0.00011223585019262065)\n",
      "PointbiserialrResult(correlation=array([0.22936407308445622], dtype=object), pvalue=0.00038184448364243236)\n",
      "PointbiserialrResult(correlation=array([0.342133405807397], dtype=object), pvalue=6.981864859642022e-08)\n",
      "PointbiserialrResult(correlation=array([-0.06952520968846497], dtype=object), pvalue=0.2874722222398788)\n"
     ]
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "# stats.pointbiserialr(vortex['Fmin'],target)\n",
    "print(stats.pointbiserialr(vortex['Ū2'],target))\n",
    "print(stats.pointbiserialr(vortex['H1'],target))\n",
    "print(stats.pointbiserialr(vortex['H2'],target))\n",
    "print(stats.pointbiserialr(vortex['T1'],target))\n",
    "print(stats.pointbiserialr(vortex['T2'],target))\n",
    "print(stats.pointbiserialr(vortex['Fmin'],target))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0      0.323542\n",
      "1      0.170575\n",
      "2      0.367358\n",
      "3      0.228615\n",
      "4      0.309062\n",
      "         ...   \n",
      "244    0.322943\n",
      "245    0.257386\n",
      "246    0.364673\n",
      "247    0.081005\n",
      "248    0.069273\n",
      "Name: Fmin, Length: 236, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(vortex['Fmin'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "test1",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}