CNNbyMate.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This might take a significant amount of time!\n",
    "# Print a list of single channel coin images and other images\n",
    "import os\n",
    "from PIL import Image\n",
    "\n",
    "coin_path = r'C:\\Users\\Mate\\Projects\\Coin\\data\\coin_256x256' # Replace with path to coin images\n",
    "others_path = r'C:\\Users\\Mate\\Projects\\Coin\\data\\others_256x256' # Replace with path to other images\n",
    "\n",
    "def list_monochromes(input_path):\n",
    "    file_list = os.listdir(input_path)\n",
    "    monochrome_list = []\n",
    "\n",
    "    for item in file_list:\n",
    "        if item != 'desktop.ini':\n",
    "            current_image = Image.open(input_path + '\\\\' + item)\n",
    "            if len(current_image.getbands()) == 1:\n",
    "                monochrome_list.append(item)\n",
    "            current_image.close()    \n",
    "\n",
    "    return monochrome_list\n",
    "\n",
    "print(list_monochromes(coin_path))\n",
    "print(list_monochromes(others_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Only use 10k images from coin and other each (20k total)\n",
    "import os\n",
    "import random\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader, random_split\n",
    "from torchvision import transforms\n",
    "from PIL import Image\n",
    "\n",
    "# Define the paths to the subfolders\n",
    "folder_path1 = r'C:\\Users\\Mate\\Projects\\Coin\\data\\coin_256x256'\n",
    "folder_path2 = r'C:\\Users\\Mate\\Projects\\Coin\\data\\others_256x256'\n",
    "\n",
    "# Function to load a subset of images from a folder\n",
    "def load_subset_images(folder_path, num_images):\n",
    "    file_list = os.listdir(folder_path)\n",
    "    # Ensure you have a maximum of num_images\n",
    "    num_images = min(num_images, len(file_list))\n",
    "    \n",
    "    # Randomly select num_images from the list of files\n",
    "    selected_files = random.sample(file_list, num_images)\n",
    "    \n",
    "    # Create a list of (image_path, label) pairs\n",
    "    image_paths = [os.path.join(folder_path, file) for file in selected_files]\n",
    "    \n",
    "    # Label for this subset can be determined based on the folder it came from\n",
    "    label = 1 if \"coin_\" in folder_path else 0\n",
    "    \n",
    "    # Create a list of (image_path, label) pairs\n",
    "    dataset = [(image_path, label) for image_path in image_paths]\n",
    "    \n",
    "    return dataset\n",
    "\n",
    "# Load subsets of images from the two subfolders\n",
    "num_images_per_folder = 10000\n",
    "subset1 = load_subset_images(folder_path1, num_images_per_folder)\n",
    "subset2 = load_subset_images(folder_path2, num_images_per_folder)\n",
    "\n",
    "# Combine the subsets\n",
    "combined_dataset = subset1 + subset2\n",
    "\n",
    "# Create a custom dataset\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, dataset, transform=None):\n",
    "        self.dataset = dataset\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.dataset)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        image_path, label = self.dataset[idx]\n",
    "        image = Image.open(image_path)\n",
    "        if self.transform:\n",
    "            image = self.transform(image)\n",
    "        label = torch.tensor(label)\n",
    "        image = image.to(\"cuda\")\n",
    "        label = label.to(\"cuda\")\n",
    "        return image, label\n",
    "\n",
    "# Transform the data \n",
    "transforms = transforms.Compose([\n",
    "    # transforms.Resize((128,128)),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ToTensor(),\n",
    "    # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) -> Investigate!\n",
    "])\n",
    "\n",
    "# Create a custom dataset\n",
    "custom_dataset = CustomDataset(combined_dataset, transform=transforms)\n",
    "\n",
    "# Define dataset sizes\n",
    "train_size = int(0.7 * len(custom_dataset))\n",
    "val_size = int(0.15 * len(custom_dataset))\n",
    "test_size = len(custom_dataset) - train_size - val_size\n",
    "\n",
    "# Split the data\n",
    "train_dataset, val_dataset, test_dataset = random_split(custom_dataset, [train_size, val_size, test_size])\n",
    "\n",
    "# Create data loaders for the splits\n",
    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device\n",
      "CoinClassifier(\n",
      "  (conv1): Conv2d(3, 12, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "  (bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1), padding=(1, 1))\n",
      "  (bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1), padding=(1, 1))\n",
      "  (bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1), padding=(1, 1))\n",
      "  (bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc1): Linear(in_features=83544, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Pytorch CNN: \n",
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn \n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "# Get cpu, gpu or mps device for training.\n",
    "device = (\n",
    "    \"cuda\"\n",
    "    if torch.cuda.is_available()\n",
    "    else \"mps\"\n",
    "    if torch.backends.mps.is_available()\n",
    "    else \"cpu\"\n",
    ")\n",
    "print(f\"Using {device} device\")\n",
    "\n",
    "# Docs: \n",
    "# https://learn.microsoft.com/en-us/windows/ai/windows-ml/tutorials/pytorch-train-model \n",
    "# https://medium.com/thecyphy/train-cnn-model-with-pytorch-21dafb918f48\n",
    "\n",
    "class CoinClassifier(nn.Module):\n",
    "    def __init__(self, input_size):\n",
    "        super(CoinClassifier, self).__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=3, stride=2, padding=1)\n",
    "        self.bn1 = nn.BatchNorm2d(12) # -> Investigate!\n",
    "        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(12)\n",
    "        self.pool = nn.MaxPool2d(2,2)\n",
    "        self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=1)\n",
    "        self.bn4 = nn.BatchNorm2d(24)\n",
    "        self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=1)\n",
    "        self.bn5 = nn.BatchNorm2d(24)\n",
    "        #self.fc1 = nn.Linear(24*10*10, 10)\n",
    "        \n",
    "        # Calculate the size of the first linear layer based on the input size\n",
    "        self.first_linear_size = self.calculate_first_linear_size(input_size)\n",
    "\n",
    "        self.fc1 = nn.Linear(self.first_linear_size, 1)\n",
    "\n",
    "    def calculate_first_linear_size(self, input_size):\n",
    "        # Compute the output size after passing through the convolutional and pooling layers\n",
    "        conv1_output = ((input_size - 3 + 2 * 1) // 2) + 1\n",
    "        conv2_output = ((conv1_output - 5 + 2 * 1) + 1)\n",
    "        pool_output = conv2_output // 2\n",
    "        conv4_output = ((pool_output - 5 + 2 * 1) + 1)\n",
    "        conv5_output = ((conv4_output - 5 + 2 * 1) + 1)\n",
    "\n",
    "        # Calculate the size of the flattened vector for the linear layer\n",
    "        first_linear_size = 24 * conv5_output * conv5_output\n",
    "\n",
    "        return first_linear_size\n",
    "\n",
    "    def forward(self, input):\n",
    "        output = F.relu(self.bn1(self.conv1(input)))      \n",
    "        output = F.relu(self.bn2(self.conv2(output)))     \n",
    "        output = self.pool(output)                        \n",
    "        output = F.relu(self.bn4(self.conv4(output)))     \n",
    "        output = F.relu(self.bn5(self.conv5(output)))     \n",
    "        #output = output.view(-1, 24*10*10)\n",
    "        output = output.view(-1, self.first_linear_size)\n",
    "        output = self.fc1(output)\n",
    "        output = torch.sigmoid(output)\n",
    "\n",
    "        return output\n",
    "\n",
    "# Define the input size based on your data\n",
    "input_size = 256\n",
    "\n",
    "model = CoinClassifier(input_size).to(device)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loss function and optimizer algorithm\n",
    "from torch.optim import Adam\n",
    "\n",
    "# Binary Cross Entropy - https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html \n",
    "loss_fn = nn.BCELoss(reduction='mean')\n",
    "# Adam - Gradient Descent\n",
    "optimizer = Adam(model.parameters(), lr=0.001, weight_decay=0.0001) # -> Investigate the lr and weight-decay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6733\n",
      "Precision: 0.6623\n",
      "Recall: 0.7511\n",
      "F1 Score: 0.7039\n",
      "ROC AUC: 0.7354\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Training loop\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, roc_curve\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epochs = 1\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    model.train()\n",
    "    for data, labels in train_loader:\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(data)\n",
    "        labels = labels.view(-1, 1).float()\n",
    "        loss = loss_fn(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "\n",
    "#Validation Loop\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for data, labels in val_loader:\n",
    "        outputs = model(data)\n",
    "model.train()\n",
    "\n",
    "#Testing Loop\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for data, labels in test_loader:\n",
    "        outputs = model(data)\n",
    "\n",
    "\n",
    "#Collect and calculate metrics\n",
    "true_labels = []  # List to store true labels\n",
    "predicted_probs = []  # List to store predicted probabilities\n",
    "predicted_labels = []  # List to store predicted labels\n",
    "model.eval()  # Set the model in evaluation mode\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data, labels in test_loader:\n",
    "        outputs = model(data)\n",
    "        outputs = outputs.cpu()\n",
    "        labels = labels.cpu().numpy()\n",
    "        true_labels.extend(labels)\n",
    "        predicted_probs.extend(torch.sigmoid(outputs).cpu().numpy())\n",
    "        predicted_labels.extend((outputs >= 0.5).numpy())\n",
    "\n",
    "true_labels = np.array(true_labels)\n",
    "predicted_probs = np.array(predicted_probs)\n",
    "predicted_labels = np.array(predicted_labels)\n",
    "\n",
    "accuracy = accuracy_score(true_labels, predicted_labels)\n",
    "precision = precision_score(true_labels, predicted_labels)\n",
    "recall = recall_score(true_labels, predicted_labels)\n",
    "f1 = f1_score(true_labels, predicted_labels)\n",
    "roc_auc = roc_auc_score(true_labels, predicted_probs)\n",
    "\n",
    "print(f\"Accuracy: {accuracy:.4f}\")\n",
    "print(f\"Precision: {precision:.4f}\")\n",
    "print(f\"Recall: {recall:.4f}\")\n",
    "print(f\"F1 Score: {f1:.4f}\")\n",
    "print(f\"ROC AUC: {roc_auc:.4f}\")\n",
    "\n",
    "# Plot the ROC curve\n",
    "fpr, tpr, _ = roc_curve(true_labels, predicted_probs)\n",
    "plt.figure()\n",
    "plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC)')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameter tuning with Ray Tune for the CNN\n",
    "\n",
    "# CNN\n",
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn \n",
    "import torch.nn.functional as F \n",
    "import numpy as np\n",
    "from torch.optim import Adam\n",
    "\n",
    "# Ray Tune \n",
    "import ray \n",
    "from ray import tune, train \n",
    "from ray.tune.schedulers import ASHAScheduler\n",
    "\n",
    "# Const variables\n",
    "RGB = 3 \n",
    "N_CLASSES = 1 # Coin -Coin\n",
    "IMAGE_SIZE = 256 # 256x256\n",
    "\n",
    "\n",
    "# Output size = Floor((Input_size − Kernel_size + 2 × padding) / Stride)​ + 1 \n",
    "# Note: The + 2 is due to the padding which is done on both x and y times 2. The + 1 is making sure that the output is an integer\n",
    "def calculated_output_dimension_conv(config: dict, input_size, kernel_size, padding, stride):\n",
    "    return int(\n",
    "        np.floor((input_size - config[\"kernel_Size_conv\"] + 2 * config[\"padding_conv\"]) / config[\"stride_pool\"]) + 1    \n",
    "    ) \n",
    "\n",
    "# Output size = Floor((Input_size − Kernel_size) / Stride) ​ + 1\n",
    "def calculated_output_dimension_pool(config: dict, input_size, kernel_size, stride):\n",
    "    return int(\n",
    "        np.floor((calculated_output_dimension_conv(config, input_size, kernel_size, config[\"padding_conv\"], stride) - config[\"kernel_Size_pool\"]) / config[\"stride_pool\"]) + 1\n",
    "    )\n",
    "        \n",
    "\n",
    "class CNN_Coin_classifier_model(nn.Module): \n",
    "    def __init__(\n",
    "        self,\n",
    "        config: dict \n",
    "    ):\n",
    "        super(CNN_Coin_classifier_model, self).__init__()\n",
    "\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(\n",
    "            in_channels = RGB,\n",
    "            out_channels = config[\"out_channels_first_conv_layer\"],\n",
    "            kernel_size = config[\"kernel_Size_conv\"], # They are automatically squared \n",
    "            stride = config[\"stride_conv\"],\n",
    "            bias = True,\n",
    "            padding = config[\"padding_conv\"],\n",
    "            padding_mode = \"zeros\",\n",
    "            groups = 1\n",
    "        )\n",
    "    \n",
    "        self.pool1 = nn.MaxPool2d(\n",
    "            kernel_size = config[\"kernel_Size_pool\"],\n",
    "            stride = config[\"stride_pool\"]\n",
    "        )\n",
    "\n",
    "        self.output_dim_conv1 = calculated_output_dimension_conv(\n",
    "            config = config,\n",
    "            input_size = IMAGE_SIZE, \n",
    "            kernel_size = config[\"kernel_Size_conv\"], \n",
    "            padding = config[\"padding_conv\"],\n",
    "            stride = config[\"stride_conv\"]\n",
    "        )\n",
    "\n",
    "        self.output_dim_pool1 = calculated_output_dimension_pool(\n",
    "            config = config,\n",
    "            input_size = output_dim_conv1,\n",
    "            kernel_size = config[\"kernel_Size_pool\"],\n",
    "            stride = config[\"stride_pool\"]\n",
    "        )\n",
    "    \n",
    "        self.conv2 = nn.Conv2d(\n",
    "            in_channels = self.output_dim_pool1,\n",
    "            out_channels = config[\"out_channels_second_conv_layer\"],\n",
    "            kernel_size = config[\"kernel_Size_conv\"], # They are automatically squared \n",
    "            stride = config[\"stride_conv\"],\n",
    "            bias = True,\n",
    "            padding = config[\"padding_conv\"],\n",
    "            padding_mode = \"zeros\",\n",
    "            groups = 1\n",
    "        )\n",
    "    \n",
    "        self.pool2 = nn.MaxPool2d(\n",
    "            kernel_size = config[\"kernel_Size_pool\"],\n",
    "            stride = config[\"stride_pool\"]\n",
    "        )\n",
    "\n",
    "        self.output_dim_conv2 = calculated_output_dimension_conv(\n",
    "            config = config,\n",
    "            input_size = output_dim_pool1, \n",
    "            kernel_size = config[\"kernel_Size_conv\"], \n",
    "            padding = config[\"padding_conv\"],\n",
    "            stride = config[\"stride_conv\"] \n",
    "        )\n",
    "\n",
    "        self.output_dim_pool2 = calculated_output_dimension_pool(\n",
    "            config = config,\n",
    "            input_size = output_dim_conv2,\n",
    "            kernel_size = config[\"kernel_Size_pool\"],\n",
    "            stride = config[\"stride_pool\"]\n",
    "        )\n",
    "    \n",
    "        # Number of input feature_maps * (H_out, W_out)^2 from the last pooling layer \n",
    "        self.fully_connected_dimension_size = int(\n",
    "            np.floor(config[\"out_channels_second_conv_layer\"] * (self.calculated_output_dimension_pool_2 ** 2)) + 1\n",
    "        )\n",
    "        \n",
    "        self.fc1 = nn.Linear(\n",
    "            in_features = self.fully_connected_dimension_size,\n",
    "            out_features = config[\"ffn_out_features\"],\n",
    "            bias = True\n",
    "        )\n",
    "    \n",
    "        self.fc2 = nn.Linear(\n",
    "            in_features = config[\"ffn_out_features\"],\n",
    "            out_features = N_CLASSES,\n",
    "            bias = True\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.pool1(x)\n",
    "\n",
    "        x = self.conv2(x)\n",
    "        x = F.relu(x)  \n",
    "        x = self.pool2(x)\n",
    "\n",
    "        # Flatten maps for FC layers\n",
    "        nUnits = x.shape.numel() / x.shape[0]  \n",
    "        x = x.view(-1,int(nUnits))\n",
    "        \n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "\n",
    "        return x \n",
    "\n",
    "\n",
    "def ray_tune(config: dict, train_loader = None, val_loader = None): \n",
    "    \n",
    "    device = \"cpu\"\n",
    "    if torch.cuda.is_available(): \n",
    "        device = \"cuda:0\"\n",
    "\n",
    "    cnn_model = CNN_Coin_classifier_model(config = config)\n",
    "\n",
    "    # Loss function\n",
    "    loss_func = nn.BCEWithLogitsLoss() # BCE=−1/n​∑i=1​(y_i​log(yHat_​i​)+(1−y_i​)log(1−yHat_i​))\n",
    "\n",
    "    # Put model and data into ray object store\n",
    "    model_id = ray.put(cnn_model)\n",
    "    train_loader_id = ray.put(train_loader)\n",
    "    val_loader_id = ray.put(val_loader)\n",
    "    \n",
    "    # Optimizer \n",
    "    optimizer = Adam(\n",
    "        cnn_model.parameters(), \n",
    "        lr = config['lr'],\n",
    "        weight_decay = config['weight_decay']\n",
    "    )\n",
    "\n",
    "    model = ray.get(model_id)\n",
    "    model = model.to(device)\n",
    "    train_loader = ray.get(train_loader_id)\n",
    "    val_loader = ray.get(val_loader_id)\n",
    "\n",
    "    train_loader = DataLoader(\n",
    "        train_set, \n",
    "        batch_size = config['batch_size'], \n",
    "        shuffle=True\n",
    "    ) # Shuffle the training set\n",
    "    val_loader = DataLoader(\n",
    "        val_set, \n",
    "        batch_size = config['batch_size'], \n",
    "        shuffle=False\n",
    "    )\n",
    "\n",
    "    nEpochs = config['nEpochs']\n",
    "    for epoch in range(nEpochs):\n",
    "        running_loss = 0.0\n",
    "        epoch_steps = 0\n",
    "        model.train()\n",
    "        # Training \n",
    "        for i, data, in enumerate(train_loader, 0):\n",
    "            inputs, labels = data\n",
    "            inputs, labels = inputs.to(device), labels.to(device) \n",
    "\n",
    "            labels = labels.float()\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            output = model(inputs)\n",
    "            loss = loss_func(output, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            epoch_steps += 1 \n",
    "\n",
    "        # Validation \n",
    "        val_loss = 0.0\n",
    "        val_steps = 0\n",
    "        total = 0 \n",
    "        correct = 0 \n",
    "        model.eval()\n",
    "        for i, data in enumerate(val_loader, 0):\n",
    "            with torch.no_grad():\n",
    "                inputs, labels = data\n",
    "                inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "                labels = labels.float()\n",
    "\n",
    "                output = model(inputs)\n",
    "                predicted = torch.sigmoid(output) > config[\"threshold\"]\n",
    "                total += labels\n",
    "                correct += (predicted == labels).sum().item() \n",
    "                loss = loss_func(output, labels.float())\n",
    "                val_loss += loss.cpu().numpy() \n",
    "                val_steps += 1 \n",
    "\n",
    "        train.report({\"accuracy\": correct / total})\n",
    "        \n",
    "\n",
    "\n",
    "def setup_ray_tune_and_run():\n",
    "    # Configs/Hyperparameters\n",
    "    config = {\n",
    "        # Number of images?\n",
    "        \"threshold\": tune.uniform(0.1, 0.9),\n",
    "        \"nEpochs\": tune.grid_search([10, 15, 20]),\n",
    "        \"batch_size\": tune.randint(8, 32),\n",
    "        \"out_channels_first_conv_layer\": tune.grid_search([10, 20, 30]),\n",
    "        \"out_channels_second_conv_layer\": tune.grid_search([10, 20, 30]), \n",
    "        \"padding_conv\": tune.grid_search([0, 1, 2]),\n",
    "        \"stride_conv\": tune.grid_search([1, 2, 3]),\n",
    "        \"stride_pool\": tune.grid_search([3, 4, 5]),\n",
    "        \"kernel_Size_conv\": tune.grid_search([3, 4, 5]),\n",
    "        \"kernel_Size_pool\": tune.grid_search([3, 4, 5]),\n",
    "        \"lr\": tune.loguniform(1e-4, 1e-1),\n",
    "        \"ffn_out_features\": tune.grid_search([300, 500, 600]),\n",
    "        \"weight_decay\": tune.loguniform(1e-3, 1), # [0.001, 1.0]\n",
    "    }\n",
    "    \n",
    "    scheduler = ASHAScheduler(\n",
    "        grace_period = 1, \n",
    "        reduction_factor = 2,\n",
    "        max_t = 10 \n",
    "    )\n",
    "\n",
    "    resources = {\n",
    "        \"cpu\": 3,  # Number of CPU cores per trial\n",
    "        \"gpu\": 0.5,  # Fraction of a GPU per trial (0.5 means half a GPU)\n",
    "    }\n",
    "\n",
    "    tuner = tune.Tuner(\n",
    "        tune.with_resources(\n",
    "            tune.with_parameters(ray_tune),\n",
    "            resources = resources\n",
    "        ),\n",
    "        tune_config = tune.TuneConfig(\n",
    "            metric = \"accuracy\",\n",
    "            mode = \"max\",\n",
    "            scheduler = scheduler,\n",
    "            num_samples = 5 # Number of samples drawn from search space\n",
    "        ),\n",
    "        param_space = config,\n",
    "    )\n",
    "    results = tuner.fit()\n",
    "    best_result = results.get_best_result(\"accuracy\", \"max\")\n",
    "    print(f'Best trial config: {best_result.config}')\n",
    "\n",
    "# Start \n",
    "setup_ray_tune_and_run()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "coinvenv",
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}