diff --git a/POET_Training.ipynb b/POET_Training.ipynb index ccba69b..1558adf 100644 --- a/POET_Training.ipynb +++ b/POET_Training.ipynb @@ -27,30 +27,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-01-15 16:24:49.275664: I tensorflow/core/util/port.cc:153] 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", - "2025-01-15 16:24:49.404820: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running Keras in version 3.6.0\n" - ] - } - ], + "outputs": [], "source": [ "import keras\n", - "print(\"Running Keras in version {}\".format(keras.__version__))\n", - "\n", "import h5py\n", "import numpy as np\n", "import pandas as pd\n", @@ -62,7 +43,8 @@ "from imblearn.under_sampling import RandomUnderSampler\n", "from imblearn.over_sampling import RandomOverSampler\n", "from collections import Counter\n", - "import os" + "import os\n", + "from preprocessing import *" ] }, { @@ -74,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -109,17 +91,17 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
Model: \"sequential_5\"\n", + "Model: \"sequential\"\n", "\n" ], "text/plain": [ - "\u001b[1mModel: \"sequential_5\"\u001b[0m\n" + "\u001b[1mModel: \"sequential\"\u001b[0m\n" ] }, "metadata": {}, @@ -131,11 +113,11 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", "┃ Layer (type) ┃ Output Shape ┃ Param # ┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", - "│ dense_17 (Dense) │ (None, 128) │ 1,664 │\n", + "│ dense (Dense) │ (None, 128) │ 1,664 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_18 (Dense) │ (None, 128) │ 16,512 │\n", + "│ dense_1 (Dense) │ (None, 128) │ 16,512 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_19 (Dense) │ (None, 12) │ 1,548 │\n", + "│ dense_2 (Dense) │ (None, 12) │ 1,548 │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n", "\n" ], @@ -143,11 +125,11 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", - "│ dense_17 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,664\u001b[0m │\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,664\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_18 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m16,512\u001b[0m │\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m16,512\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_19 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m) │ \u001b[38;5;34m1,548\u001b[0m │\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m) │ \u001b[38;5;34m1,548\u001b[0m │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" ] }, @@ -210,17 +192,17 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "Model: \"sequential_6\"\n", + "Model: \"sequential_1\"\n", "\n" ], "text/plain": [ - "\u001b[1mModel: \"sequential_6\"\u001b[0m\n" + "\u001b[1mModel: \"sequential_1\"\u001b[0m\n" ] }, "metadata": {}, @@ -232,13 +214,13 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", "┃ Layer (type) ┃ Output Shape ┃ Param # ┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", - "│ dense_20 (Dense) │ (None, 512) │ 6,656 │\n", + "│ dense_3 (Dense) │ (None, 512) │ 6,656 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_21 (Dense) │ (None, 1024) │ 525,312 │\n", + "│ dense_4 (Dense) │ (None, 1024) │ 525,312 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_22 (Dense) │ (None, 512) │ 524,800 │\n", + "│ dense_5 (Dense) │ (None, 512) │ 524,800 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_23 (Dense) │ (None, 12) │ 6,156 │\n", + "│ dense_6 (Dense) │ (None, 12) │ 6,156 │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n", "\n" ], @@ -246,13 +228,13 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", - "│ dense_20 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m6,656\u001b[0m │\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m6,656\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_21 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m525,312\u001b[0m │\n", + "│ dense_4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m525,312\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_22 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m524,800\u001b[0m │\n", + "│ dense_5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m524,800\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", - "│ dense_23 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m) │ \u001b[38;5;34m6,156\u001b[0m │\n", + "│ dense_6 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m) │ \u001b[38;5;34m6,156\u001b[0m │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" ] }, @@ -321,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -340,12 +322,12 @@ " elif val < 0:\n", " return 10 ** val\n", " else:\n", - " return 0\n" + " return 0" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -391,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 99, "metadata": {}, "outputs": [], "source": [ @@ -407,6 +389,269 @@ "data_file.close()" ] }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "" + ], + "text/plain": [ + " H O Charge H_0_ O_0_ \\\n", + "0 111.012434 55.508192 -7.779554e-09 2.697041e-26 2.210590e-15 \n", + "1 111.012434 55.508427 -4.736083e-09 1.446346e-26 2.473481e-15 \n", + "2 111.012434 55.508691 -1.311169e-09 3.889826e-28 2.769320e-15 \n", + "3 111.012434 55.508698 -1.220023e-09 1.442658e-29 2.777193e-15 \n", + "4 111.012434 55.508699 -1.216643e-09 5.350528e-31 2.777485e-15 \n", + "... ... ... ... ... ... \n", + "2502495 111.012434 55.507488 3.573728e-09 5.424062e-145 1.375204e-10 \n", + "2502496 111.012434 55.507501 3.494007e-09 2.011675e-146 1.377139e-10 \n", + "2502497 111.012434 55.507512 3.429764e-09 7.460897e-148 1.377819e-10 \n", + "2502498 111.012434 55.507520 3.381745e-09 2.767237e-149 1.371144e-10 \n", + "2502499 111.012434 55.507525 3.348864e-09 5.321610e-151 1.376026e-10 \n", + "\n", + " Ba Cl S_2_ S_6_ Sr \\\n", + "0 2.041069e-02 4.082138e-02 0.000000e+00 0.000494 0.000494 \n", + "1 1.094567e-02 2.189133e-02 0.000000e+00 0.000553 0.000553 \n", + "2 2.943745e-04 5.887491e-04 0.000000e+00 0.000619 0.000619 \n", + "3 1.091776e-05 2.183551e-05 0.000000e+00 0.000620 0.000620 \n", + "4 4.049176e-07 8.098352e-07 0.000000e+00 0.000620 0.000620 \n", + "... ... ... ... ... ... \n", + "2502495 9.953520e-07 2.266555e-03 5.509534e-149 0.000318 0.001450 \n", + "2502496 9.817216e-07 2.217997e-03 2.043375e-150 0.000321 0.001429 \n", + "2502497 9.706451e-07 2.179066e-03 7.578467e-152 0.000324 0.001412 \n", + "2502498 9.621074e-07 2.149820e-03 2.810844e-153 0.000326 0.001400 \n", + "2502499 9.564401e-07 2.129912e-03 5.405468e-155 0.000327 0.001391 \n", + "\n", + " Barite Celestite \n", + "0 0.001 1.000000 \n", + "1 0.001 1.000000 \n", + "2 0.001 1.000000 \n", + "3 0.001 1.000000 \n", + "4 0.001 1.000000 \n", + "... ... ... \n", + "2502495 0.001 1.000014 \n", + "2502496 0.001 1.000010 \n", + "2502497 0.001 1.000006 \n", + "2502498 0.001 1.000004 \n", + "2502499 0.001 1.000001 \n", + "\n", + "[2502500 rows x 12 columns]" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_design" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -416,14 +661,14 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/signer/bin/miniconda3/envs/training/lib/python3.11/site-packages/sklearn/base.py:1473: ConvergenceWarning: Number of distinct clusters (1) found smaller than n_clusters (2). Possibly due to duplicate points in X.\n", + "/Users/hannessigner/miniconda3/envs/ai/lib/python3.11/site-packages/sklearn/base.py:1473: ConvergenceWarning: Number of distinct clusters (1) found smaller than n_clusters (2). Possibly due to duplicate points in X.\n", " return fit_method(estimator, *args, **kwargs)\n" ] } @@ -435,8 +680,8 @@ "class_label_result = np.array([])\n", "\n", "\n", - "i = 1000\n", - "for i in range(0,1001):\n", + "i = len(df_design) / 2500\n", + "for i in range(0,252):\n", " field_design = np.array(df_design['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50)\n", " field_result = np.array(df_results['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50)\n", " \n", @@ -454,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -467,15 +712,15 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Amount class 0: 0.9879380619380619\n", - "Amount class 1: 0.012061938061938062\n" + "Amount class 0: 0.9520126984126984\n", + "Amount class 1: 0.047987301587301585\n" ] } ], @@ -487,22 +732,22 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "\n", + " \n", + "
\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " H \n", + "O \n", + "Charge \n", + "H_0_ \n", + "O_0_ \n", + "Ba \n", + "Cl \n", + "S_2_ \n", + "S_6_ \n", + "Sr \n", + "Barite \n", + "Celestite \n", + "\n", + " \n", + "0 \n", + "111.012434 \n", + "55.508192 \n", + "-7.779554e-09 \n", + "2.697041e-26 \n", + "2.210590e-15 \n", + "2.041069e-02 \n", + "4.082138e-02 \n", + "0.000000e+00 \n", + "0.000494 \n", + "0.000494 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "1 \n", + "111.012434 \n", + "55.508427 \n", + "-4.736083e-09 \n", + "1.446346e-26 \n", + "2.473481e-15 \n", + "1.094567e-02 \n", + "2.189133e-02 \n", + "0.000000e+00 \n", + "0.000553 \n", + "0.000553 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "2 \n", + "111.012434 \n", + "55.508691 \n", + "-1.311169e-09 \n", + "3.889826e-28 \n", + "2.769320e-15 \n", + "2.943745e-04 \n", + "5.887491e-04 \n", + "0.000000e+00 \n", + "0.000619 \n", + "0.000619 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "3 \n", + "111.012434 \n", + "55.508698 \n", + "-1.220023e-09 \n", + "1.442658e-29 \n", + "2.777193e-15 \n", + "1.091776e-05 \n", + "2.183551e-05 \n", + "0.000000e+00 \n", + "0.000620 \n", + "0.000620 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "4 \n", + "111.012434 \n", + "55.508699 \n", + "-1.216643e-09 \n", + "5.350528e-31 \n", + "2.777485e-15 \n", + "4.049176e-07 \n", + "8.098352e-07 \n", + "0.000000e+00 \n", + "0.000620 \n", + "0.000620 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "\n", + " \n", + "2502495 \n", + "111.012434 \n", + "55.507488 \n", + "3.573728e-09 \n", + "5.424062e-145 \n", + "1.375204e-10 \n", + "9.953520e-07 \n", + "2.266555e-03 \n", + "5.509534e-149 \n", + "0.000318 \n", + "0.001450 \n", + "0.001 \n", + "1.000014 \n", + "\n", + " \n", + "2502496 \n", + "111.012434 \n", + "55.507501 \n", + "3.494007e-09 \n", + "2.011675e-146 \n", + "1.377139e-10 \n", + "9.817216e-07 \n", + "2.217997e-03 \n", + "2.043375e-150 \n", + "0.000321 \n", + "0.001429 \n", + "0.001 \n", + "1.000010 \n", + "\n", + " \n", + "2502497 \n", + "111.012434 \n", + "55.507512 \n", + "3.429764e-09 \n", + "7.460897e-148 \n", + "1.377819e-10 \n", + "9.706451e-07 \n", + "2.179066e-03 \n", + "7.578467e-152 \n", + "0.000324 \n", + "0.001412 \n", + "0.001 \n", + "1.000006 \n", + "\n", + " \n", + "2502498 \n", + "111.012434 \n", + "55.507520 \n", + "3.381745e-09 \n", + "2.767237e-149 \n", + "1.371144e-10 \n", + "9.621074e-07 \n", + "2.149820e-03 \n", + "2.810844e-153 \n", + "0.000326 \n", + "0.001400 \n", + "0.001 \n", + "1.000004 \n", + "\n", + " \n", + " \n", + "2502499 \n", + "111.012434 \n", + "55.507525 \n", + "3.348864e-09 \n", + "5.321610e-151 \n", + "1.376026e-10 \n", + "9.564401e-07 \n", + "2.129912e-03 \n", + "5.405468e-155 \n", + "0.000327 \n", + "0.001391 \n", + "0.001 \n", + "1.000001 \n", + "2502500 rows × 12 columns
\n", + "" + " " ] }, - "execution_count": 12, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ " " ] @@ -512,12 +757,72 @@ } ], "source": [ - "i=800\n", + "i=251\n", "\n", "plt.imshow(np.array(df_results['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50), interpolation='bicubic', origin='lower')\n", "plt.contour(np.array(df_results['Class'][(i*2500):(i*2500+2500)]).reshape(50,50), levels=[0.1], colors='red', origin='lower')" ] }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "df_design['Class threshold'] = df_design['Barite'] > 0.49\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9991298042059463" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_design['Class'][df_design[\"Class threshold\"] == True].sum() / df_design['Class threshold'][df_design[\"Class threshold\"] == True].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "i = 251\n", + "plt.imshow(np.array(df_design['Class threshold'][(i*2500):(i*2500+2500)]).reshape(50,50), interpolation='bicubic', origin='lower')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -527,7 +832,7 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -543,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -589,18 +894,34 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Amount class 0 before: 0.9878911088911089\n", - "Amount class 1 before: 0.012108891108891108\n", - "Using Oversampling\n", - "Amount class 0 after: 0.5\n", - "Amount class 1 after: 0.5\n" + "Amount class 0 before: 0.9563730158730158\n", + "Amount class 1 before: 0.043626984126984125\n" + ] + }, + { + "ename": "IndexError", + "evalue": "Boolean index has wrong length: 11 instead of 10", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[32], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m X_train, y_train \u001b[38;5;241m=\u001b[39m \u001b[43mbalancer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mover\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[31], line 14\u001b[0m, in \u001b[0;36mbalancer\u001b[0;34m(design, target, strategy, sample_fraction)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 13\u001b[0m classes \u001b[38;5;241m=\u001b[39m design[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mClass\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m---> 14\u001b[0m df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mconcat([design\u001b[38;5;241m.\u001b[39mloc[:,design\u001b[38;5;241m.\u001b[39mcolumns \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mClass\u001b[39m\u001b[38;5;124m\"\u001b[39m], \u001b[43mtarget\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdesign\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m!=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mClass\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m, classes], axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m strategy \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msmote\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUsing SMOTE strategy\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexing.py:1184\u001b[0m, in \u001b[0;36m_LocationIndexer.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 1182\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_is_scalar_access(key):\n\u001b[1;32m 1183\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_get_value(\u001b[38;5;241m*\u001b[39mkey, takeable\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_takeable)\n\u001b[0;32m-> 1184\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_tuple\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1185\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# we by definition only have the 0th axis\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxis \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexing.py:1377\u001b[0m, in \u001b[0;36m_LocIndexer._getitem_tuple\u001b[0;34m(self, tup)\u001b[0m\n\u001b[1;32m 1374\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_multi_take_opportunity(tup):\n\u001b[1;32m 1375\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_multi_take(tup)\n\u001b[0;32m-> 1377\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_tuple_same_dim\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtup\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexing.py:1020\u001b[0m, in \u001b[0;36m_LocationIndexer._getitem_tuple_same_dim\u001b[0;34m(self, tup)\u001b[0m\n\u001b[1;32m 1017\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m com\u001b[38;5;241m.\u001b[39mis_null_slice(key):\n\u001b[1;32m 1018\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[0;32m-> 1020\u001b[0m retval \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mretval\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mi\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1021\u001b[0m \u001b[38;5;66;03m# We should never have retval.ndim < self.ndim, as that should\u001b[39;00m\n\u001b[1;32m 1022\u001b[0m \u001b[38;5;66;03m# be handled by the _getitem_lowerdim call above.\u001b[39;00m\n\u001b[1;32m 1023\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m retval\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mndim\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexing.py:1413\u001b[0m, in \u001b[0;36m_LocIndexer._getitem_axis\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1411\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_slice_axis(key, axis\u001b[38;5;241m=\u001b[39maxis)\n\u001b[1;32m 1412\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m com\u001b[38;5;241m.\u001b[39mis_bool_indexer(key):\n\u001b[0;32m-> 1413\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getbool_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1414\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_list_like_indexer(key):\n\u001b[1;32m 1415\u001b[0m \u001b[38;5;66;03m# an iterable multi-selection\u001b[39;00m\n\u001b[1;32m 1416\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(key, \u001b[38;5;28mtuple\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(labels, MultiIndex)):\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexing.py:1209\u001b[0m, in \u001b[0;36m_LocationIndexer._getbool_axis\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1205\u001b[0m \u001b[38;5;129m@final\u001b[39m\n\u001b[1;32m 1206\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_getbool_axis\u001b[39m(\u001b[38;5;28mself\u001b[39m, key, axis: AxisInt):\n\u001b[1;32m 1207\u001b[0m \u001b[38;5;66;03m# caller is responsible for ensuring non-None axis\u001b[39;00m\n\u001b[1;32m 1208\u001b[0m labels \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_get_axis(axis)\n\u001b[0;32m-> 1209\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[43mcheck_bool_indexer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1210\u001b[0m inds \u001b[38;5;241m=\u001b[39m key\u001b[38;5;241m.\u001b[39mnonzero()[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 1211\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_take_with_is_copy(inds, axis\u001b[38;5;241m=\u001b[39maxis)\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexing.py:2681\u001b[0m, in \u001b[0;36mcheck_bool_indexer\u001b[0;34m(index, key)\u001b[0m\n\u001b[1;32m 2677\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_array_like(result):\n\u001b[1;32m 2678\u001b[0m \u001b[38;5;66;03m# GH 33924\u001b[39;00m\n\u001b[1;32m 2679\u001b[0m \u001b[38;5;66;03m# key may contain nan elements, check_array_indexer needs bool array\u001b[39;00m\n\u001b[1;32m 2680\u001b[0m result \u001b[38;5;241m=\u001b[39m pd_array(result, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mbool\u001b[39m)\n\u001b[0;32m-> 2681\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcheck_array_indexer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresult\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/pandas/core/indexers/utils.py:539\u001b[0m, in \u001b[0;36mcheck_array_indexer\u001b[0;34m(array, indexer)\u001b[0m\n\u001b[1;32m 537\u001b[0m \u001b[38;5;66;03m# GH26658\u001b[39;00m\n\u001b[1;32m 538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(indexer) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(array):\n\u001b[0;32m--> 539\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 540\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBoolean index has wrong length: \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 541\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(indexer)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m instead of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(array)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 542\u001b[0m )\n\u001b[1;32m 543\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_integer_dtype(dtype):\n\u001b[1;32m 544\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "\u001b[0;31mIndexError\u001b[0m: Boolean index has wrong length: 11 instead of 10" ] } ], @@ -617,7 +938,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 88, "metadata": {}, "outputs": [], "source": [ @@ -651,25 +972,9 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 101, "metadata": {}, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[88], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m df_design_log, df_results_log \u001b[38;5;241m=\u001b[39m log_scale(df_design, df_results, func_dict_in)\n\u001b[1;32m 2\u001b[0m data_min_log, data_max_log \u001b[38;5;241m=\u001b[39m get_min_max(df_design_log, df_results_log)\n", - "Cell \u001b[0;32mIn[87], line 8\u001b[0m, in \u001b[0;36mlog_scale\u001b[0;34m(df_design, df_result, func_dict)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m df_design\u001b[38;5;241m.\u001b[39mkeys():\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mClass\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m----> 8\u001b[0m df_design[key] \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvectorize(func_dict[key])(df_design[key])\n\u001b[1;32m 9\u001b[0m df_result[key] \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvectorize(func_dict[key])(df_result[key])\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m df_design, df_result\n", - "File \u001b[0;32m~/bin/miniconda3/envs/training/lib/python3.11/site-packages/numpy/lib/function_base.py:2372\u001b[0m, in \u001b[0;36mvectorize.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2369\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_stage_2(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 2370\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n\u001b[0;32m-> 2372\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_as_normal(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", - "File \u001b[0;32m~/bin/miniconda3/envs/training/lib/python3.11/site-packages/numpy/lib/function_base.py:2365\u001b[0m, in \u001b[0;36mvectorize._call_as_normal\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2362\u001b[0m vargs \u001b[38;5;241m=\u001b[39m [args[_i] \u001b[38;5;28;01mfor\u001b[39;00m _i \u001b[38;5;129;01min\u001b[39;00m inds]\n\u001b[1;32m 2363\u001b[0m vargs\u001b[38;5;241m.\u001b[39mextend([kwargs[_n] \u001b[38;5;28;01mfor\u001b[39;00m _n \u001b[38;5;129;01min\u001b[39;00m names])\n\u001b[0;32m-> 2365\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_vectorize_call(func\u001b[38;5;241m=\u001b[39mfunc, args\u001b[38;5;241m=\u001b[39mvargs)\n", - "File \u001b[0;32m~/bin/miniconda3/envs/training/lib/python3.11/site-packages/numpy/lib/function_base.py:2455\u001b[0m, in \u001b[0;36mvectorize._vectorize_call\u001b[0;34m(self, func, args)\u001b[0m\n\u001b[1;32m 2452\u001b[0m \u001b[38;5;66;03m# Convert args to object arrays first\u001b[39;00m\n\u001b[1;32m 2453\u001b[0m inputs \u001b[38;5;241m=\u001b[39m [asanyarray(a, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mobject\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args]\n\u001b[0;32m-> 2455\u001b[0m outputs \u001b[38;5;241m=\u001b[39m ufunc(\u001b[38;5;241m*\u001b[39minputs)\n\u001b[1;32m 2457\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ufunc\u001b[38;5;241m.\u001b[39mnout \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 2458\u001b[0m res \u001b[38;5;241m=\u001b[39m asanyarray(outputs, dtype\u001b[38;5;241m=\u001b[39motypes[\u001b[38;5;241m0\u001b[39m])\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "df_design_log, df_results_log = log_scale(df_design, df_results, func_dict_in)\n", "data_min_log, data_max_log = get_min_max(df_design_log, df_results_log)" @@ -677,7 +982,533 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "" + ], + "text/plain": [ + " H O Charge H_0_ O_0_ \\\n", + "0 111.012434 55.508192 -7.779554e-09 2.697041e-26 2.210590e-15 \n", + "1 111.012434 55.508427 -4.736083e-09 1.446346e-26 2.473481e-15 \n", + "2 111.012434 55.508691 -1.311169e-09 3.889826e-28 2.769320e-15 \n", + "3 111.012434 55.508698 -1.220023e-09 1.442658e-29 2.777193e-15 \n", + "4 111.012434 55.508699 -1.216643e-09 5.350528e-31 2.777485e-15 \n", + "... ... ... ... ... ... \n", + "2502495 111.012434 55.507488 3.573728e-09 5.424062e-145 1.375204e-10 \n", + "2502496 111.012434 55.507501 3.494007e-09 2.011675e-146 1.377139e-10 \n", + "2502497 111.012434 55.507512 3.429764e-09 7.460897e-148 1.377819e-10 \n", + "2502498 111.012434 55.507520 3.381745e-09 2.767237e-149 1.371144e-10 \n", + "2502499 111.012434 55.507525 3.348864e-09 5.321610e-151 1.376026e-10 \n", + "\n", + " Ba Cl S_2_ S_6_ Sr \\\n", + "0 2.041069e-02 4.082138e-02 0.000000e+00 0.000494 0.000494 \n", + "1 1.094567e-02 2.189133e-02 0.000000e+00 0.000553 0.000553 \n", + "2 2.943745e-04 5.887491e-04 0.000000e+00 0.000619 0.000619 \n", + "3 1.091776e-05 2.183551e-05 0.000000e+00 0.000620 0.000620 \n", + "4 4.049176e-07 8.098352e-07 0.000000e+00 0.000620 0.000620 \n", + "... ... ... ... ... ... \n", + "2502495 9.953520e-07 2.266555e-03 5.509534e-149 0.000318 0.001450 \n", + "2502496 9.817216e-07 2.217997e-03 2.043375e-150 0.000321 0.001429 \n", + "2502497 9.706451e-07 2.179066e-03 7.578467e-152 0.000324 0.001412 \n", + "2502498 9.621074e-07 2.149820e-03 2.810844e-153 0.000326 0.001400 \n", + "2502499 9.564401e-07 2.129912e-03 5.405468e-155 0.000327 0.001391 \n", + "\n", + " Barite Celestite \n", + "0 0.001 1.000000 \n", + "1 0.001 1.000000 \n", + "2 0.001 1.000000 \n", + "3 0.001 1.000000 \n", + "4 0.001 1.000000 \n", + "... ... ... \n", + "2502495 0.001 1.000014 \n", + "2502496 0.001 1.000010 \n", + "2502497 0.001 1.000006 \n", + "2502498 0.001 1.000004 \n", + "2502499 0.001 1.000001 \n", + "\n", + "[2502500 rows x 12 columns]" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_design" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + "
\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " H \n", + "O \n", + "Charge \n", + "H_0_ \n", + "O_0_ \n", + "Ba \n", + "Cl \n", + "S_2_ \n", + "S_6_ \n", + "Sr \n", + "Barite \n", + "Celestite \n", + "\n", + " \n", + "0 \n", + "111.012434 \n", + "55.508192 \n", + "-7.779554e-09 \n", + "2.697041e-26 \n", + "2.210590e-15 \n", + "2.041069e-02 \n", + "4.082138e-02 \n", + "0.000000e+00 \n", + "0.000494 \n", + "0.000494 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "1 \n", + "111.012434 \n", + "55.508427 \n", + "-4.736083e-09 \n", + "1.446346e-26 \n", + "2.473481e-15 \n", + "1.094567e-02 \n", + "2.189133e-02 \n", + "0.000000e+00 \n", + "0.000553 \n", + "0.000553 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "2 \n", + "111.012434 \n", + "55.508691 \n", + "-1.311169e-09 \n", + "3.889826e-28 \n", + "2.769320e-15 \n", + "2.943745e-04 \n", + "5.887491e-04 \n", + "0.000000e+00 \n", + "0.000619 \n", + "0.000619 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "3 \n", + "111.012434 \n", + "55.508698 \n", + "-1.220023e-09 \n", + "1.442658e-29 \n", + "2.777193e-15 \n", + "1.091776e-05 \n", + "2.183551e-05 \n", + "0.000000e+00 \n", + "0.000620 \n", + "0.000620 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "4 \n", + "111.012434 \n", + "55.508699 \n", + "-1.216643e-09 \n", + "5.350528e-31 \n", + "2.777485e-15 \n", + "4.049176e-07 \n", + "8.098352e-07 \n", + "0.000000e+00 \n", + "0.000620 \n", + "0.000620 \n", + "0.001 \n", + "1.000000 \n", + "\n", + " \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "\n", + " \n", + "2502495 \n", + "111.012434 \n", + "55.507488 \n", + "3.573728e-09 \n", + "5.424062e-145 \n", + "1.375204e-10 \n", + "9.953520e-07 \n", + "2.266555e-03 \n", + "5.509534e-149 \n", + "0.000318 \n", + "0.001450 \n", + "0.001 \n", + "1.000014 \n", + "\n", + " \n", + "2502496 \n", + "111.012434 \n", + "55.507501 \n", + "3.494007e-09 \n", + "2.011675e-146 \n", + "1.377139e-10 \n", + "9.817216e-07 \n", + "2.217997e-03 \n", + "2.043375e-150 \n", + "0.000321 \n", + "0.001429 \n", + "0.001 \n", + "1.000010 \n", + "\n", + " \n", + "2502497 \n", + "111.012434 \n", + "55.507512 \n", + "3.429764e-09 \n", + "7.460897e-148 \n", + "1.377819e-10 \n", + "9.706451e-07 \n", + "2.179066e-03 \n", + "7.578467e-152 \n", + "0.000324 \n", + "0.001412 \n", + "0.001 \n", + "1.000006 \n", + "\n", + " \n", + "2502498 \n", + "111.012434 \n", + "55.507520 \n", + "3.381745e-09 \n", + "2.767237e-149 \n", + "1.371144e-10 \n", + "9.621074e-07 \n", + "2.149820e-03 \n", + "2.810844e-153 \n", + "0.000326 \n", + "0.001400 \n", + "0.001 \n", + "1.000004 \n", + "\n", + " \n", + " \n", + "2502499 \n", + "111.012434 \n", + "55.507525 \n", + "3.348864e-09 \n", + "5.321610e-151 \n", + "1.376026e-10 \n", + "9.564401e-07 \n", + "2.129912e-03 \n", + "5.405468e-155 \n", + "0.000327 \n", + "0.001391 \n", + "0.001 \n", + "1.000001 \n", + "2502500 rows × 12 columns
\n", + "\n", + "\n", + "" + ], + "text/plain": [ + " H O Charge H_0_ O_0_ \\\n", + "0 4.71861 4.034386 8.109045 2.697041e-26 2.210590e-15 \n", + "1 4.71861 4.034390 8.324581 1.446346e-26 2.473481e-15 \n", + "2 4.71861 4.034394 8.882341 3.889826e-28 2.769320e-15 \n", + "3 4.71861 4.034395 8.913632 1.442658e-29 2.777193e-15 \n", + "4 4.71861 4.034395 8.914837 5.350528e-31 2.777485e-15 \n", + "... ... ... ... ... ... \n", + "2502495 4.71861 4.034373 -8.446878 5.424062e-145 1.375204e-10 \n", + "2502496 4.71861 4.034373 -8.456676 2.011675e-146 1.377139e-10 \n", + "2502497 4.71861 4.034374 -8.464736 7.460897e-148 1.377819e-10 \n", + "2502498 4.71861 4.034374 -8.470859 2.767237e-149 1.371144e-10 \n", + "2502499 4.71861 4.034374 -8.475102 5.321610e-151 1.376026e-10 \n", + "\n", + " Ba Cl S_2_ S_6_ Sr \\\n", + "0 2.020518e-02 4.001019e-02 0.000000e+00 0.000494 0.000494 \n", + "1 1.088620e-02 2.165516e-02 0.000000e+00 0.000552 0.000552 \n", + "2 2.943312e-04 5.885758e-04 0.000000e+00 0.000618 0.000618 \n", + "3 1.091770e-05 2.183528e-05 0.000000e+00 0.000620 0.000620 \n", + "4 4.049175e-07 8.098349e-07 0.000000e+00 0.000620 0.000620 \n", + "... ... ... ... ... ... \n", + "2502495 9.953515e-07 2.263990e-03 5.509534e-149 0.000318 0.001449 \n", + "2502496 9.817211e-07 2.215541e-03 2.043375e-150 0.000321 0.001428 \n", + "2502497 9.706446e-07 2.176695e-03 7.578467e-152 0.000324 0.001411 \n", + "2502498 9.621070e-07 2.147512e-03 2.810844e-153 0.000326 0.001399 \n", + "2502499 9.564396e-07 2.127647e-03 5.405468e-155 0.000327 0.001390 \n", + "\n", + " Barite Celestite \n", + "0 0.001000 0.693147 \n", + "1 0.001000 0.693147 \n", + "2 0.001000 0.693147 \n", + "3 0.001000 0.693147 \n", + "4 0.001000 0.693147 \n", + "... ... ... \n", + "2502495 0.000999 0.693154 \n", + "2502496 0.000999 0.693152 \n", + "2502497 0.000999 0.693150 \n", + "2502498 0.000999 0.693149 \n", + "2502499 0.000999 0.693148 \n", + "\n", + "[2502500 rows x 12 columns]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_design_log" + ] + }, + { + "cell_type": "code", + "execution_count": 74, "metadata": {}, "outputs": [], "source": [ @@ -687,7 +1518,7 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -697,7 +1528,7 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -737,7 +1568,7 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -757,11 +1588,11 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ - "X_train, X_val, y_train, y_val = sk.train_test_split(X_train_preprocess, y_train_preprocess, test_size = 0.1)\n" + "X_train, X_val, y_train, y_val = sk.train_test_split(X_train_preprocess, y_train_preprocess, test_size = 0.1)" ] }, { @@ -773,7 +1604,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 164, "metadata": {}, "outputs": [], "source": [ @@ -796,24 +1627,27 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": 71, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1/5\n", - "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 2ms/step - loss: 0.0014 - val_loss: 1.9722e-05\n", - "Epoch 2/5\n", - "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 2ms/step - loss: 1.8605e-05 - val_loss: 1.6460e-05\n", - "Epoch 3/5\n", - "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 2ms/step - loss: 1.7344e-05 - val_loss: 1.8609e-05\n", - "Epoch 4/5\n", - "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 2ms/step - loss: 1.6938e-05 - val_loss: 1.6669e-05\n", - "Epoch 5/5\n", - "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 2ms/step - loss: 1.6373e-05 - val_loss: 1.5985e-05\n", - "Training took 63.22352385520935 seconds\n" + "Epoch 1/5\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Attr 'Toutput_types' of 'OptionalFromValue' Op passed list of length 0 less than minimum 1.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[71], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# measure time\u001b[39;00m\n\u001b[1;32m 2\u001b[0m start \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n\u001b[0;32m----> 4\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel_simple\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_val\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_val\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m end \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTraining took \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m seconds\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(end \u001b[38;5;241m-\u001b[39m start))\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:122\u001b[0m, in \u001b[0;36mfilter_traceback.\n", + " \n", + "
\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " H \n", + "O \n", + "Charge \n", + "H_0_ \n", + "O_0_ \n", + "Ba \n", + "Cl \n", + "S_2_ \n", + "S_6_ \n", + "Sr \n", + "Barite \n", + "Celestite \n", + "\n", + " \n", + "0 \n", + "4.71861 \n", + "4.034386 \n", + "8.109045 \n", + "2.697041e-26 \n", + "2.210590e-15 \n", + "2.020518e-02 \n", + "4.001019e-02 \n", + "0.000000e+00 \n", + "0.000494 \n", + "0.000494 \n", + "0.001000 \n", + "0.693147 \n", + "\n", + " \n", + "1 \n", + "4.71861 \n", + "4.034390 \n", + "8.324581 \n", + "1.446346e-26 \n", + "2.473481e-15 \n", + "1.088620e-02 \n", + "2.165516e-02 \n", + "0.000000e+00 \n", + "0.000552 \n", + "0.000552 \n", + "0.001000 \n", + "0.693147 \n", + "\n", + " \n", + "2 \n", + "4.71861 \n", + "4.034394 \n", + "8.882341 \n", + "3.889826e-28 \n", + "2.769320e-15 \n", + "2.943312e-04 \n", + "5.885758e-04 \n", + "0.000000e+00 \n", + "0.000618 \n", + "0.000618 \n", + "0.001000 \n", + "0.693147 \n", + "\n", + " \n", + "3 \n", + "4.71861 \n", + "4.034395 \n", + "8.913632 \n", + "1.442658e-29 \n", + "2.777193e-15 \n", + "1.091770e-05 \n", + "2.183528e-05 \n", + "0.000000e+00 \n", + "0.000620 \n", + "0.000620 \n", + "0.001000 \n", + "0.693147 \n", + "\n", + " \n", + "4 \n", + "4.71861 \n", + "4.034395 \n", + "8.914837 \n", + "5.350528e-31 \n", + "2.777485e-15 \n", + "4.049175e-07 \n", + "8.098349e-07 \n", + "0.000000e+00 \n", + "0.000620 \n", + "0.000620 \n", + "0.001000 \n", + "0.693147 \n", + "\n", + " \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "... \n", + "\n", + " \n", + "2502495 \n", + "4.71861 \n", + "4.034373 \n", + "-8.446878 \n", + "5.424062e-145 \n", + "1.375204e-10 \n", + "9.953515e-07 \n", + "2.263990e-03 \n", + "5.509534e-149 \n", + "0.000318 \n", + "0.001449 \n", + "0.000999 \n", + "0.693154 \n", + "\n", + " \n", + "2502496 \n", + "4.71861 \n", + "4.034373 \n", + "-8.456676 \n", + "2.011675e-146 \n", + "1.377139e-10 \n", + "9.817211e-07 \n", + "2.215541e-03 \n", + "2.043375e-150 \n", + "0.000321 \n", + "0.001428 \n", + "0.000999 \n", + "0.693152 \n", + "\n", + " \n", + "2502497 \n", + "4.71861 \n", + "4.034374 \n", + "-8.464736 \n", + "7.460897e-148 \n", + "1.377819e-10 \n", + "9.706446e-07 \n", + "2.176695e-03 \n", + "7.578467e-152 \n", + "0.000324 \n", + "0.001411 \n", + "0.000999 \n", + "0.693150 \n", + "\n", + " \n", + "2502498 \n", + "4.71861 \n", + "4.034374 \n", + "-8.470859 \n", + "2.767237e-149 \n", + "1.371144e-10 \n", + "9.621070e-07 \n", + "2.147512e-03 \n", + "2.810844e-153 \n", + "0.000326 \n", + "0.001399 \n", + "0.000999 \n", + "0.693149 \n", + "\n", + " \n", + " \n", + "2502499 \n", + "4.71861 \n", + "4.034374 \n", + "-8.475102 \n", + "5.321610e-151 \n", + "1.376026e-10 \n", + "9.564396e-07 \n", + "2.127647e-03 \n", + "5.405468e-155 \n", + "0.000327 \n", + "0.001390 \n", + "0.000999 \n", + "0.693148 \n", + "2502500 rows × 12 columns
\n", + ".error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m 120\u001b[0m \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;66;03m# `keras.config.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m--> 122\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m~/miniconda3/envs/ai/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py:131\u001b[0m, in \u001b[0;36mTensorFlowTrainer._make_function. .multi_step_on_iterator\u001b[0;34m(iterator)\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[38;5;129m@tf\u001b[39m\u001b[38;5;241m.\u001b[39mautograph\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mdo_not_convert\n\u001b[1;32m 129\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmulti_step_on_iterator\u001b[39m(iterator):\n\u001b[1;32m 130\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msteps_per_execution \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 131\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexperimental\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mOptional\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_value\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 132\u001b[0m \u001b[43m \u001b[49m\u001b[43mone_step_on_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_next\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 133\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 135\u001b[0m \u001b[38;5;66;03m# the spec is set lazily during the tracing of `tf.while_loop`\u001b[39;00m\n\u001b[1;32m 136\u001b[0m empty_outputs \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mOptional\u001b[38;5;241m.\u001b[39mempty(\u001b[38;5;28;01mNone\u001b[39;00m)\n", + "\u001b[0;31mValueError\u001b[0m: Attr 'Toutput_types' of 'OptionalFromValue' Op passed list of length 0 less than minimum 1." ] } ], @@ -835,12 +1669,12 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": 146, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ " " ] @@ -861,12 +1695,12 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 147, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ " " ] @@ -893,86 +1727,86 @@ }, { "cell_type": "code", - "execution_count": 152, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m15641/15641\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1ms/step - loss: 0.0904\n" + "\u001b[1m15641/15641\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 233us/step - loss: 0.0324\n" ] }, { "data": { "text/plain": [ - "0.09046255797147751" + "0.032423071563243866" ] }, - "execution_count": 152, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# test on all test data\n", - "model_large.evaluate(X_test_preprocess.iloc[:,:-1], y_test_preprocess.iloc[:, :-1])" + "model_simple.evaluate(X_test_preprocess.iloc[:,:-1], y_test_preprocess.iloc[:, :-1])" ] }, { "cell_type": "code", - "execution_count": 153, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m15455/15455\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 996us/step - loss: 0.0902\n" + "\u001b[1m15451/15451\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 234us/step - loss: 0.0313\n" ] }, { "data": { "text/plain": [ - "0.0901983454823494" + "0.031290605664253235" ] }, - "execution_count": 153, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# test on non-reactive data\n", - "model_large.evaluate(X_test_preprocess[X_test_preprocess['Class'] == 0].iloc[:,:-1], y_test_preprocess[X_test_preprocess['Class'] == 0].iloc[:,:-1])" + "model_simple.evaluate(X_test_preprocess[X_test_preprocess['Class'] == 0].iloc[:,:-1], y_test_preprocess[X_test_preprocess['Class'] == 0].iloc[:,:-1])" ] }, { "cell_type": "code", - "execution_count": 155, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m186/186\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step - loss: 0.1127\n" + "\u001b[1m190/190\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 295us/step - loss: 0.1246\n" ] }, { "data": { "text/plain": [ - "0.11247223615646362" + "0.12462512403726578" ] }, - "execution_count": 155, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# test on reactive data\n", - "model_large.evaluate(X_test_preprocess[X_test_preprocess['Class'] == 1].iloc[:,:-1], y_test_preprocess[X_test_preprocess['Class'] == 1].iloc[:, :-1])" + "model_simple.evaluate(X_test_preprocess[X_test_preprocess['Class'] == 1].iloc[:,:-1], y_test_preprocess[X_test_preprocess['Class'] == 1].iloc[:, :-1])" ] }, { @@ -995,7 +1829,7 @@ ], "metadata": { "kernelspec": { - "display_name": "training", + "display_name": "ai", "language": "python", "name": "python3" }, diff --git a/preprocessing.py b/preprocessing.py new file mode 100644 index 0000000..7cb8acd --- /dev/null +++ b/preprocessing.py @@ -0,0 +1,87 @@ +import keras +print("Running Keras in version {}".format(keras.__version__)) + +import h5py +import numpy as np +import pandas as pd +import time +import sklearn.model_selection as sk +import matplotlib.pyplot as plt +from sklearn.cluster import KMeans +from imblearn.over_sampling import SMOTE +from imblearn.under_sampling import RandomUnderSampler +from imblearn.over_sampling import RandomOverSampler +from collections import Counter +import os + +# preprocessing pipeline +# + +def Safelog(val): + # get range of vector + if val > 0: + return np.log10(val) + elif val < 0: + return -np.log10(-val) + else: + return 0 + +def Safeexp(val): + if val > 0: + return -10 ** -val + elif val < 0: + return 10 ** val + else: + return 0 + + +class FuncTransform(): + ''' + Class to transform and inverse transform data with given functions. + Transform and inverse transform functions have to be given as dictionaries in the following format: + {'key1': function1, 'key2': function2, ...} + ''' + + def __init__(self, func_transform, func_inverse): + self.func_transform = func_transform + self.func_inverse = func_inverse + + def fit(self, X): + return self + + def transform(self, X): + X = X.copy() + for key in X.keys(): + if "Class" not in key: + X[key] = X[key].apply(self.func_transform[key]) + return X + + def fit_transform(self, X): + return self.fit(X).transform(X) + + def inverse_transform(self, X_log): + X_log = X_log.copy() + for key in X_log.keys(): + if "Class" not in key: + X_log[key] = X_log[key].apply(self.func_inverse[key]) + return X_log + +class DataSetSampling(): + + def __init__(self, X, y, sampling_strategy): + self.X = X + self.y = y + self.sampling_strategy = sampling_strategy + + def fit(self, X): + return self + + def transform(self): + return self + + +class Scaling(): + + + +