IDB_drilling_monitoring_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mA_-eAkuEnLC"
   },
   "source": [
    "# IDB_drilling_monitoring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G6Dqfh0oC9d7"
   },
   "source": [
    "## Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "8KJudV78mY5m",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-16 16:16:21.293633: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thu Nov 16 16:16:23 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 525.105.17   Driver Version: 525.105.17   CUDA Version: 12.0     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ...  On   | 00000000:98:00.0 Off |                  Off |\n",
      "| 30%   29C    P8    18W / 450W |      2MiB / 24564MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|  No running processes found                                                 |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error\n",
    "\n",
    "np.random.seed(42)\n",
    "\n",
    "!nvidia-smi\n",
    "HOST_path = \"/root/autodl-tmp\"\n",
    "\n",
    "SAVE_path = os.path.join(HOST_path, \"IDB_drilling_monitoring/regression\")\n",
    "\n",
    "if not os.path.exists(SAVE_path):\n",
    "    os.makedirs(SAVE_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N4rlRDFk7mas"
   },
   "source": [
    "## Load signal data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Ax7US8NWaZT8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (166, 8) 165 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (163, 8) 162 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (171, 8) 170 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (184, 8) 183 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (207, 8) 206 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (201, 8) 200 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (209, 8) 208 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (218, 8) 217 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (260, 8) 259 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (214, 8) 213 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (226, 8) 225 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (279, 8) 278 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (79, 8) 78 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (81, 8) 80 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (90, 8) 89 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (95, 8) 94 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (114, 8) 113 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (87, 8) 86 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (119, 8) 118 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (115, 8) 114 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (95, 8) 94 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (94, 8) 93 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (126, 8) 125 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (99, 8) 98 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (274, 8) 273 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (218, 8) 217 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (241, 8) 240 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (226, 8) 225 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (232, 8) 231 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (230, 8) 229 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (227, 8) 226 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (243, 8) 242 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (249, 8) 248 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (259, 8) 258 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (290, 8) 289 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (260, 8) 259 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (111, 8) 110 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (152, 8) 151 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (179, 8) 178 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (182, 8) 181 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (191, 8) 190 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (171, 8) 170 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (169, 8) 168 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (215, 8) 214 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (233, 8) 232 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (172, 8) 171 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (245, 8) 244 s\n",
      "WARNING *** OLE2 inconsistency: SSCS size is 0 but SSAT size is non-zero\n",
      "<class 'numpy.ndarray'> (292, 8) 291 s\n"
     ]
    }
   ],
   "source": [
    "def load_table(table_path, time_start, time_end):\n",
    "  SIGNAL_pd = pd.read_excel(table_path)\n",
    "  # display(SIGNAL_pd)\n",
    "  SIGNAL_arr = SIGNAL_pd.values[time_start-2+10 : time_end-2-10+1, 1:-1]\n",
    "  print(type(SIGNAL_arr), SIGNAL_arr.shape, len(SIGNAL_arr)-1, \"s\")\n",
    "  # print(SIGNAL_arr)\n",
    "  return SIGNAL_arr\n",
    "\n",
    "Y01A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 140, 325)\n",
    "Y01B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 609, 791)\n",
    "Y01C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 1115, 1305)\n",
    "Y01D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 1530, 1733)\n",
    "\n",
    "Y02A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 3795, 4021)\n",
    "Y02B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 4241, 4461)\n",
    "Y02C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 4649, 4877)\n",
    "Y02D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 5100, 5337)\n",
    "\n",
    "Y03A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 5780, 6059)\n",
    "Y03B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 6267, 6500)\n",
    "Y03C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 6760, 7005)\n",
    "Y03D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-1.xls\"), 7223, 7521)\n",
    "\n",
    "Y04A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 123, 221)\n",
    "Y04B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 463, 563)\n",
    "Y04C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 773, 882)\n",
    "Y04D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 1103, 1217)\n",
    "\n",
    "Y05A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 1545, 1678)\n",
    "Y05B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 1931, 2037)\n",
    "Y05C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 2265, 2403)\n",
    "Y05D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 2613, 2747)\n",
    "\n",
    "Y06A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 3051, 3165)\n",
    "Y06B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 3377, 3490)\n",
    "Y06C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 3685, 3830)\n",
    "Y06D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-2.xls\"), 4169, 4287)\n",
    "\n",
    "Y07A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 146, 439)\n",
    "Y07B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 692, 929)\n",
    "Y07C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 1129, 1389)\n",
    "Y07D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 1592, 1837)\n",
    "\n",
    "Y08A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 2316, 2567)\n",
    "Y08B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 2809, 3058)\n",
    "Y08C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 3431, 3677)\n",
    "Y08D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 3895, 4157)\n",
    "\n",
    "Y09A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 4437, 4705)\n",
    "Y09B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 4951, 5229)\n",
    "Y09C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 5869, 6178)\n",
    "Y09D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 6396, 6675)\n",
    "\n",
    "Y10A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 8285, 8415)\n",
    "Y10B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 8629, 8800)\n",
    "Y10C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 9087, 9285)\n",
    "Y10D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 9710, 9911)\n",
    "\n",
    "Y11A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 10370, 10580)\n",
    "Y11B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 10785, 10975)\n",
    "Y11C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 11144, 11332)\n",
    "Y11D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 11733, 11967)\n",
    "\n",
    "Y12A = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 12445, 12697)\n",
    "Y12B = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 12955, 13146)\n",
    "Y12C = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 13325, 13589)\n",
    "Y12D = load_table(os.path.join(HOST_path, \"IDB_drilling_monitoring/table/9.17-3+4.xls\"), 13768, 14079)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y01A (166, 8) 165 s\n",
      "Y01B (163, 8) 162 s\n",
      "Y01C (171, 8) 170 s\n",
      "Y01D (184, 8) 183 s\n",
      "Y02A (207, 8) 206 s\n",
      "Y02B (201, 8) 200 s\n",
      "Y02C (209, 8) 208 s\n",
      "Y02D (218, 8) 217 s\n",
      "Y03A (260, 8) 259 s\n",
      "Y03B (214, 8) 213 s\n",
      "Y03C (226, 8) 225 s\n",
      "Y03D (279, 8) 278 s\n",
      "Y04A (79, 8) 78 s\n",
      "Y04B (81, 8) 80 s\n",
      "Y04C (90, 8) 89 s\n",
      "Y04D (95, 8) 94 s\n",
      "Y05A (114, 8) 113 s\n",
      "Y05B (87, 8) 86 s\n",
      "Y05C (119, 8) 118 s\n",
      "Y05D (115, 8) 114 s\n",
      "Y06A (95, 8) 94 s\n",
      "Y06B (94, 8) 93 s\n",
      "Y06C (126, 8) 125 s\n",
      "Y06D (99, 8) 98 s\n",
      "Y07A (274, 8) 273 s\n",
      "Y07B (218, 8) 217 s\n",
      "Y07C (241, 8) 240 s\n",
      "Y07D (226, 8) 225 s\n",
      "Y08A (232, 8) 231 s\n",
      "Y08B (230, 8) 229 s\n",
      "Y08C (227, 8) 226 s\n",
      "Y08D (243, 8) 242 s\n",
      "Y09A (249, 8) 248 s\n",
      "Y09B (259, 8) 258 s\n",
      "Y09C (290, 8) 289 s\n",
      "Y09D (260, 8) 259 s\n",
      "Y10A (111, 8) 110 s\n",
      "Y10B (152, 8) 151 s\n",
      "Y10C (179, 8) 178 s\n",
      "Y10D (182, 8) 181 s\n",
      "Y11A (191, 8) 190 s\n",
      "Y11B (171, 8) 170 s\n",
      "Y11C (169, 8) 168 s\n",
      "Y11D (215, 8) 214 s\n",
      "Y12A (233, 8) 232 s\n",
      "Y12B (172, 8) 171 s\n",
      "Y12C (245, 8) 244 s\n",
      "Y12D (292, 8) 291 s\n"
     ]
    }
   ],
   "source": [
    "table_list = [\"Y01A\", \"Y01B\", \"Y01C\", \"Y01D\",\n",
    "         \"Y02A\", \"Y02B\", \"Y02C\", \"Y02D\",\n",
    "         \"Y03A\", \"Y03B\", \"Y03C\", \"Y03D\",\n",
    "         \"Y04A\", \"Y04B\", \"Y04C\", \"Y04D\",\n",
    "         \"Y05A\", \"Y05B\", \"Y05C\", \"Y05D\",\n",
    "         \"Y06A\", \"Y06B\", \"Y06C\", \"Y06D\",\n",
    "         \"Y07A\", \"Y07B\", \"Y07C\", \"Y07D\",\n",
    "         \"Y08A\", \"Y08B\", \"Y08C\", \"Y08D\",\n",
    "         \"Y09A\", \"Y09B\", \"Y09C\", \"Y09D\",\n",
    "         \"Y10A\", \"Y10B\", \"Y10C\", \"Y10D\",\n",
    "         \"Y11A\", \"Y11B\", \"Y11C\", \"Y11D\",\n",
    "         \"Y12A\", \"Y12B\", \"Y12C\", \"Y12D\"]\n",
    "\n",
    "def check_table():\n",
    "    for table in table_list:\n",
    "        print(table, eval(table).shape, len(eval(table))-1,\"s\")\n",
    "check_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "INDEX_dict = [\"HEIGHT\", \"RPM\", \"TORQUE\", \"PUMPR\", \"PUMPP\", \"ROP\", \"WOB\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> (8953, 8)\n",
      "[['10:24:25' '-354.00' '233.00' ... '919.00' '29.00' '813.00']\n",
      " ['10:24:26' '-352.00' '295.00' ... '919.00' '26.00' '800.00']\n",
      " ['10:24:27' '-351.00' '306.00' ... '1312.00' '28.00' '800.00']\n",
      " ...\n",
      " ['22:06:22' '-245.00' '302.00' ... '611.00' '19.00' '915.00']\n",
      " ['22:06:23' '-245.00' '302.00' ... '609.00' '19.00' '915.00']\n",
      " ['22:06:24' '-245.00' '302.00' ... '608.00' '19.00' '915.00']]\n",
      "<class 'numpy.ndarray'> (8953, 2)\n",
      "[['90.48' '29.00']\n",
      " ['92.63' '26.00']\n",
      " ['92.95' '28.00']\n",
      " ...\n",
      " ['54.76' '19.00']\n",
      " ['53.67' '19.00']\n",
      " ['54.25' '19.00']]\n",
      "<class 'numpy.ndarray'> (8953, 4)\n",
      "[['233.00' '71.00' '919.00' '813.00']\n",
      " ['295.00' '71.00' '919.00' '800.00']\n",
      " ['306.00' '71.00' '1312.00' '800.00']\n",
      " ...\n",
      " ['302.00' '50.00' '611.00' '915.00']\n",
      " ['302.00' '50.00' '609.00' '915.00']\n",
      " ['302.00' '50.00' '608.00' '915.00']]\n"
     ]
    }
   ],
   "source": [
    "X = np.concatenate((Y01A, Y01B, Y01C, Y01D,\n",
    "                    Y02A, Y02B, Y02C, Y02D,\n",
    "                    Y03A, Y03B, Y03C, Y03D,\n",
    "                    Y04A, Y04B, Y04C, Y04D,\n",
    "                    Y05A, Y05B, Y05C, Y05D,\n",
    "                    Y06A, Y06B, Y06C, Y06D,\n",
    "                    Y07A, Y07B, Y07C, Y07D,\n",
    "                    Y08A, Y08B, Y08C, Y08D,\n",
    "                    Y09A, Y09B, Y09C, Y09D,\n",
    "                    Y10A, Y10B, Y10C, Y10D,\n",
    "                    Y11A, Y11B, Y11C, Y11D,\n",
    "                    Y12A, Y12B, Y12C, Y12D), axis=0)\n",
    "print(type(X), X.shape)\n",
    "print(X)\n",
    "\n",
    "Y = X[:,[3,6]]\n",
    "print(type(Y), Y.shape)\n",
    "print(Y)\n",
    "\n",
    "X = X[:,[2,4,5,7]]\n",
    "print(type(X), X.shape)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> (7162, 4)\n",
      "<class 'numpy.ndarray'> (1791, 4)\n",
      "<class 'numpy.ndarray'> (7162, 2)\n",
      "<class 'numpy.ndarray'> (1791, 2)\n"
     ]
    }
   ],
   "source": [
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)\n",
    "print(type(X_train), X_train.shape)\n",
    "print(type(X_test), X_test.shape)\n",
    "print(type(Y_train), Y_train.shape)\n",
    "print(type(Y_test), Y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 一元线性回归\n",
    "from sklearn.linear_model import LinearRegression\n",
    "model = LinearRegression()\n",
    "\n",
    "# 岭回归\n",
    "from sklearn.linear_model import Ridge\n",
    "# model = Ridge(alpha=0.01) \n",
    "\n",
    "# 弹性网络回归\n",
    "from sklearn.linear_model import ElasticNet\n",
    "# model = ElasticNet(random_state=0)\n",
    "\n",
    "# 最小回归角回归\n",
    "from sklearn.linear_model import Lars\n",
    "# model = Lars(n_nonzero_coefs=1)\n",
    "\n",
    "# 偏最小二乘法回归\n",
    "from sklearn.cross_decomposition import PLSRegression\n",
    "# model = PLSRegression(n_components=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_test_pred = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE = 8.009529709795945\n",
      "MSE = 135.63120205935306\n",
      "RMSE= 11.646080974274266\n",
      "R^2 = 0.34638852625631933\n"
     ]
    }
   ],
   "source": [
    "print(\"MAE =\", mean_absolute_error(Y_test, Y_test_pred))         # 残差绝对值\n",
    "print(\"MSE =\", mean_squared_error(Y_test, Y_test_pred))          # 通过平方放大了残差\n",
    "print(\"RMSE=\", np.sqrt(mean_squared_error(Y_test, Y_test_pred))) # 通过开方，还原被放大残差\n",
    "print(\"R^2 =\", r2_score(Y_test, Y_test_pred))                    # R2是相对比例值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1791, 2) (1791, 2)\n"
     ]
    }
   ],
   "source": [
    "print(Y_test.shape, Y_test_pred.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_compare(i):\n",
    "    plt.figure(figsize=(5,5))\n",
    "    plt.scatter(Y_test[:,i], Y_test_pred[:,i], s=20, edgecolor=\"black\",c=\"darkorange\", label=\"data\")\n",
    "    xlim = plt.xlim()\n",
    "    ylim = plt.ylim()\n",
    "    MIN = min(xlim[0], ylim[0])\n",
    "    MAX = max(xlim[1], ylim[1])\n",
    "    plt.xlim(MIN, MAX)\n",
    "    plt.ylim(MIN, MAX)\n",
    "    plt.savefig(os.path.join(SAVE_path, \"true_pred_\"+str(i)+\".png\"), dpi=300, bbox_inches='tight', transparent=True)\n",
    "\n",
    "for i in range(Y_test.shape[1]):\n",
    "    plot_compare(i)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}