model_dl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model description (deep learning)\n",
    "packages used: tensorflow, keras, wandb  \n",
    "Environment: WSL-2 Ubuntu 22.04  \n",
    "Hardware: NVIDIA RTX 3060 Ti (local)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-06 22:44:21.437574: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-12-06 22:44:22.692775: E tensorflow/stream_executor/cuda/cuda_blas.cc:2981] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-06 22:44:23.861009: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
      "2023-12-06 22:44:23.861099: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
      "2023-12-06 22:44:23.861106: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "GPU device: NVIDIA GeForce RTX 3060 Ti\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-06 22:44:25.068568: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:44:25.603492: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:44:25.603554: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:44:25.604103: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "gpu_devices = tf.config.list_physical_devices('GPU')\n",
    "if gpu_devices:\n",
    "  details = tf.config.experimental.get_device_details(gpu_devices[0])\n",
    "  print(f\"\\nGPU device: {details.get('device_name', 'Unknown GPU')}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define column sets\n",
    "feature_columns = {\n",
    "    \"market\" : ['volume_eth', 'price_p5_eth_lag1', 'price_max_eth_lag1', 'price_min_eth_lag1'],\n",
    "    \"traits_rarity\" : ['rarity_rank', 'Background_count', 'Mouth_count', 'Eyes_count', 'Fur_count', 'Hat_count', 'Clothes_count', 'Earring_count'],\n",
    "    \"last_trade\" : ['last_trade_timediff', 'last_trade_price'],\n",
    "}\n",
    "\n",
    "outcome_columns = {\n",
    "    'trade_price' : 'trade_price',\n",
    "    'amount_usd' : 'amount_usd',\n",
    "    'trade_price_log' : 'trade_price_log'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_cols = feature_columns['market'] + feature_columns['traits_rarity'] + feature_columns['last_trade']\n",
    "y_col = \"trade_price\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"data/bayc_cleaned.csv\")\n",
    "\n",
    "data = data.dropna(subset=X_cols+[y_col])\n",
    "X = data[X_cols]\n",
    "y = data[y_col]\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Standardizing the data\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "# resize for CNN\n",
    "X_train = np.expand_dims(X_train, axis=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build keras model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Input, Dense, Conv1D, MaxPooling1D, Flatten, Dropout\n",
    "import keras_tuner\n",
    "\n",
    "\n",
    "def build_model(hp):\n",
    "    \"\"\"\n",
    "    Build a CNN model for predicting trade price of NFTs\n",
    "    hp: HyperParameters object from keras_tuner\n",
    "    Tunable hyperparameters:\n",
    "        filters: Int\n",
    "        kernel_size: Int\n",
    "        units: Int Choice [64, 128, 256, 512]\n",
    "        dropout: Boolean\n",
    "        learning_rate: Float Choice [1e-2, 1e-3]\n",
    "    \"\"\"\n",
    "\n",
    "    model = Sequential()\n",
    "    \n",
    "    # Input layer\n",
    "    model.add(Input(shape=(X_train.shape[1],1)))\n",
    "    \n",
    "    # Conv1D layer\n",
    "    model.add(Conv1D(\n",
    "        filters=hp.Int(\"filters\", min_value=32, max_value=256, step=32),\n",
    "        kernel_size=hp.Int(\"kernel_size\", min_value=2, max_value=5, step=1), \n",
    "        activation='relu'\n",
    "        ))\n",
    "    \n",
    "    # MaxPooling layer\n",
    "    model.add(MaxPooling1D(pool_size=2))\n",
    "    \n",
    "    # Flatten layer\n",
    "    model.add(Flatten())\n",
    "    \n",
    "    # Dense layers    \n",
    "    model.add(Dense(\n",
    "        units=hp.Choice('units', values=[64, 128, 256, 512]),\n",
    "        activation='relu'\n",
    "        ))\n",
    "    \n",
    "    model.add(Dense(\n",
    "        units=32, \n",
    "        activation='relu'\n",
    "        ))\n",
    "    \n",
    "    # Dropout layer\n",
    "    if hp.Boolean(\"dropout\"):\n",
    "        model.add(Dropout(0.25))\n",
    "    \n",
    "    # Output layer\n",
    "    model.add(Dense(1, activation='linear'))\n",
    "    \n",
    "    # Compile model\n",
    "    optimizer = tf.keras.optimizers.Adam(\n",
    "        hp.Choice('learning_rate', values=[1e-2, 1e-3])\n",
    "        )\n",
    "    \n",
    "    model.compile(\n",
    "        optimizer=optimizer,\n",
    "        loss='mean_squared_error'\n",
    "        )\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Integrate with weights & biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import wandb\n",
    "from wandb.keras import WandbCallback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mmingxuan-he\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# login weights & biases (requires .env or CLI login)\n",
    "wandb.login()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# # not used\n",
    "\n",
    "# class MyTuner(keras_tuner.RandomSearch):\n",
    "#     \"\"\"\n",
    "#     Custom tuner class for displaying keras_tuner progress in wandb\n",
    "#     \"\"\"\n",
    "    \n",
    "#     def run_trial(self, trial, X, y, batch_size, epochs, objective):\n",
    "#         \"\"\"\n",
    "#         modify run_trial method to display progress in wandb\n",
    "#         \"\"\"\n",
    "        \n",
    "#         hp = trial.hyperparameters\n",
    "        \n",
    "#         model = self.hypermodel.build(hp)\n",
    "        \n",
    "#         # initialize wandb run\n",
    "#         run = wandb.init(\n",
    "#             project=\"bayc\",\n",
    "#             entity=\"mingxuan-he\",\n",
    "#             config=hp.values\n",
    "#         )\n",
    "        \n",
    "#         history = model.fit(\n",
    "#             X, y,\n",
    "#             batch_size=batch_size,\n",
    "#             epochs=epochs,\n",
    "#             validation_split=0.2,\n",
    "#             callbacks=[WandbCallback()]\n",
    "#         )\n",
    "        \n",
    "#         val_loss = history.history['val_loss'][-1]\n",
    "        \n",
    "#         self.oracle.update_trial(trial.trial_id, {objective:val_loss})\n",
    "        \n",
    "#         run.finish()\n",
    "    \n",
    "#     # def save_model(self, trial_id, model, step=0):\n",
    "#     #     \"\"\"Save a model for a given trial.\"\"\"\n",
    "#     #     fname = f'model_{trial_id}.h5'\n",
    "#     #     model_dir = os.path.join(self.get_trial_dir(trial_id), 'model')\n",
    "#     #     if not os.path.exists(model_dir):\n",
    "#     #         os.makedirs(model_dir)\n",
    "#     #     model_path = os.path.join(model_dir, fname)\n",
    "#     #     model.save(model_path)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create custom HyperModel class for integration with w&b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyHyperModel(keras_tuner.HyperModel):\n",
    "    \n",
    "    \"\"\" \n",
    "    Custom hypermodel class for keras_tuner, with integrated wandb logging\n",
    "    \"\"\"\n",
    "    \n",
    "    def build(self, hp):\n",
    "        \n",
    "        run = wandb.init(\n",
    "            project=\"NFT_Pred\",\n",
    "            entity=\"mingxuan-he\",\n",
    "            config=hp.values\n",
    "        )\n",
    "        \n",
    "        model = build_model(hp)\n",
    "        \n",
    "        return model\n",
    "\n",
    "    def fit(self, hp, model, *args, **kwargs):\n",
    "        \n",
    "        if 'callbacks' in kwargs:\n",
    "            kwargs['callbacks'].append(WandbCallback())\n",
    "        else:\n",
    "            kwargs['callbacks'] = [WandbCallback()]\n",
    "        \n",
    "        history = model.fit(\n",
    "            *args,\n",
    "            **kwargs,\n",
    "        )\n",
    "        \n",
    "        wandb.finish()\n",
    "        \n",
    "        return history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model training with hyperparam tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Tracking run with wandb version 0.16.1"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Run data is saved locally in <code>/home/mingxuanh/NFT-pred/wandb/run-20231206_224536-8nhyu6ks</code>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Syncing run <strong><a href='https://wandb.ai/mingxuan-he/NFT_pred/runs/8nhyu6ks' target=\"_blank\">youthful-sun-34</a></strong> to <a href='https://wandb.ai/mingxuan-he/NFT_pred' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View project at <a href='https://wandb.ai/mingxuan-he/NFT_pred' target=\"_blank\">https://wandb.ai/mingxuan-he/NFT_pred</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View run at <a href='https://wandb.ai/mingxuan-he/NFT_pred/runs/8nhyu6ks' target=\"_blank\">https://wandb.ai/mingxuan-he/NFT_pred/runs/8nhyu6ks</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-06 22:45:38.502583: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-12-06 22:45:38.506342: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:45:38.506460: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:45:38.506509: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:45:49.028474: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:45:49.033427: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:45:49.033444: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.\n",
      "2023-12-06 22:45:49.033543: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:966] could not open file to read NUMA node: /sys/bus/pci/devices/0000:29:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-06 22:45:49.034936: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1616] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 5438 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3060 Ti, pci bus id: 0000:29:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "# instantiate RandomSearch tuner\n",
    "tuner = keras_tuner.tuners.RandomSearch(\n",
    "    MyHyperModel(),\n",
    "    objective='val_loss',\n",
    "    max_trials=50,\n",
    "    executions_per_trial=1,\n",
    "    directory='./tuner',\n",
    "    project_name='NFT_Pred'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search space summary\n",
      "Default search space size: 5\n",
      "filters (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 32, 'max_value': 256, 'step': 32, 'sampling': 'linear'}\n",
      "kernel_size (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 2, 'max_value': 5, 'step': 1, 'sampling': 'linear'}\n",
      "units (Choice)\n",
      "{'default': 64, 'conditions': [], 'values': [64, 128, 256, 512], 'ordered': True}\n",
      "dropout (Boolean)\n",
      "{'default': False, 'conditions': []}\n",
      "learning_rate (Choice)\n",
      "{'default': 0.01, 'conditions': [], 'values': [0.01, 0.001], 'ordered': True}\n"
     ]
    }
   ],
   "source": [
    "# search space for hyperparameters\n",
    "tuner.search_space_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 50 Complete [00h 01m 42s]\n",
      "val_loss: 222.58212280273438\n",
      "\n",
      "Best val_loss So Far: 206.18983459472656\n",
      "Total elapsed time: 01h 30m 47s\n"
     ]
    }
   ],
   "source": [
    "# main training function\n",
    "tuner.search(\n",
    "    X_train,\n",
    "    y_train,\n",
    "    batch_size=32,\n",
    "    epochs=25,\n",
    "    validation_data=(X_test, y_test),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Tracking run with wandb version 0.16.1"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Run data is saved locally in <code>/home/mingxuanh/NFT-pred/wandb/run-20231207_002122-m6cegw88</code>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Syncing run <strong><a href='https://wandb.ai/mingxuan-he/NFT_pred/runs/m6cegw88' target=\"_blank\">zesty-forest-85</a></strong> to <a href='https://wandb.ai/mingxuan-he/NFT_pred' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View project at <a href='https://wandb.ai/mingxuan-he/NFT_pred' target=\"_blank\">https://wandb.ai/mingxuan-he/NFT_pred</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View run at <a href='https://wandb.ai/mingxuan-he/NFT_pred/runs/m6cegw88' target=\"_blank\">https://wandb.ai/mingxuan-he/NFT_pred/runs/m6cegw88</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best hyperparameters:\n",
      "{'filters': 224, 'kernel_size': 3, 'units': 512, 'dropout': True, 'learning_rate': 0.001}\n",
      "best model architecture:\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv1d (Conv1D)             (None, 12, 224)           896       \n",
      "                                                                 \n",
      " max_pooling1d (MaxPooling1D  (None, 6, 224)           0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 1344)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               688640    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 32)                16416     \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 32)                0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 1)                 33        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 705,985\n",
      "Trainable params: 705,985\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "wandb: WARNING Source type is set to 'repo' but some required information is missing from the environment. A job will not be created from this run. See https://docs.wandb.ai/guides/launch/create-job\n"
     ]
    },
    {
     "data": {
      "text/html": [
       " View run <strong style=\"color:#cdcd00\">zesty-forest-85</strong> at: <a href='https://wandb.ai/mingxuan-he/NFT_pred/runs/m6cegw88' target=\"_blank\">https://wandb.ai/mingxuan-he/NFT_pred/runs/m6cegw88</a><br/>Synced 6 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Find logs at: <code>./wandb/run-20231207_002122-m6cegw88/logs</code>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get best model & hyperparameters\n",
    "best_model = tuner.get_best_models(num_models=1)[0]\n",
    "best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
    "print(\"best hyperparameters:\")\n",
    "print(best_hps.values)\n",
    "print(\"best model architecture:\")\n",
    "print(best_model.summary())\n",
    "wandb.finish() # end wandb run initiated by get_best_models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "215/215 [==============================] - 0s 1ms/step\n"
     ]
    }
   ],
   "source": [
    "predictions = best_model.predict(X_test)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}