Med_Imaging_CNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Import Libs"
      ],
      "metadata": {
        "id": "xWzxYPaDCNjG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import cv2\n",
        "import glob\n",
        "import random\n",
        "import numpy as np\n",
        "\n",
        "from PIL import Image\n",
        "import skimage.measure\n",
        "from skimage import data\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "from skimage.morphology import disk\n",
        "from skimage.util import img_as_ubyte"
      ],
      "metadata": {
        "id": "bfuiKmeeFPe-"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "752EWVNIB4PY"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets, transforms\n",
        "from sklearn.metrics import accuracy_score\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## DATASET\n",
        "\n"
      ],
      "metadata": {
        "id": "LaqXEpA6CmH2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NsyU4pp-EWPp",
        "outputId": "6c302014-dfff-45bd-dd2e-847b9263b2d6"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "main_dir = \"/content/drive/MyDrive/TCC - Parte II/\"\n",
        "dataset_path = main_dir + \"Brain Tumor Classification Dataset\""
      ],
      "metadata": {
        "id": "kHpjl4A8EzJN"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "-uLyOAOPQ-9F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Getting Info from dataset"
      ],
      "metadata": {
        "id": "tg8IESkWFLXm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_glioma = glob.glob(dataset_path + \"/Training/glioma_tumor/*.jpg\")\n",
        "train_menignioma = glob.glob(dataset_path + '/Training/meningioma_tumor/*.jpg')\n",
        "train_pituitary = glob.glob( dataset_path + '/Training/pituitary_tumor/*.jpg')\n",
        "train_no = glob.glob(dataset_path + '/Training/no_tumor/*.jpg')\n",
        "\n",
        "#Test\n",
        "test_glioma = glob.glob( dataset_path + '/Testing/glioma_tumor/*.jpg')\n",
        "test_menignioma = glob.glob(dataset_path +  '/Testing/meningioma_tumor/*.jpg')\n",
        "test_pituitary = glob.glob(dataset_path + '/Testing/pituitary_tumor/*.jpg')\n",
        "test_no = glob.glob(dataset_path + '/Testing/no_tumor/*.jpg')\n"
      ],
      "metadata": {
        "id": "GOOCqgygFWZ0"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_glioma_number = len(train_glioma)\n",
        "train_menignioma_number = len(train_menignioma)\n",
        "train_pituitary_number = len(train_pituitary)\n",
        "train_no_number = len(train_no)\n",
        "\n",
        "test_glioma_number = len(test_glioma)\n",
        "test_menignioma_number = len(test_menignioma)\n",
        "test_pituitary_number = len(test_pituitary)\n",
        "test_no_number = len(test_no)\n",
        "\n",
        "print(\"Number of train_glioma: \",train_glioma_number)\n",
        "print(\"Number of train_menignioma: \",train_menignioma_number)\n",
        "print(\"Number of train_pituitary: \",train_pituitary_number)\n",
        "print(\"Number of train_no: \",train_no_number)\n",
        "print(\"Number of test_glioma: \",test_glioma_number)\n",
        "print(\"Number of test_menignioma: \",train_menignioma_number)\n",
        "print(\"Number of test_pituitary: \",train_pituitary_number)\n",
        "print(\"Number of test_no: \",train_no_number)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zDLU1W6WFWUW",
        "outputId": "ca8ff5ad-f352-4361-ebe0-f507c7c37cbb"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of train_glioma:  826\n",
            "Number of train_menignioma:  822\n",
            "Number of train_pituitary:  827\n",
            "Number of train_no:  395\n",
            "Number of test_glioma:  100\n",
            "Number of test_menignioma:  822\n",
            "Number of test_pituitary:  827\n",
            "Number of test_no:  395\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "full_glioma = train_glioma_number + test_glioma_number\n",
        "full_no_tumor = train_no_number + test_no_number\n",
        "full_menignioma = train_menignioma_number + test_menignioma_number\n",
        "full_pituitary = train_pituitary_number + test_pituitary_number\n",
        "\n",
        "plt.figure(figsize=(5,5))\n",
        "colors = ['#8CAF99','#E198AB',\"#89BEDB\",\"#C6A7D2\"]\n",
        "labels = ['Glioma', 'Meningioma', 'Glândula Pituitária', 'Sem tumor']\n",
        "\n",
        "plt.rcParams.update({'font.size': 8})\n",
        "plt.pie([full_glioma,\n",
        "         full_menignioma,full_pituitary,full_no_tumor],\n",
        "        labels=labels,\n",
        "        colors=colors, autopct='%.1f%%', explode=(0.025,0.025,0.025,0.025),\n",
        "        startangle=30);\n",
        "# plt.savefig(\"Distribuição do dataset.png\", dpi=300)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 422
        },
        "id": "2t-KfEe-FKwI",
        "outputId": "336d6e70-2426-4eaa-b16b-7dcf2680185f"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Pre Processing"
      ],
      "metadata": {
        "id": "i9oh6d8IrXcV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "import os\n",
        "\n",
        "def resize_images(dataset_path, output_path, target_size=(256, 256)):\n",
        "    \"\"\"\n",
        "    Redimensiona todas as imagens em um dataset para o mesmo tamanho.\n",
        "\n",
        "    Parâmetros:\n",
        "    - dataset_path: Caminho para o diretório que contém as imagens do dataset.\n",
        "    - output_path: Caminho para o diretório de saída onde as imagens redimensionadas serão salvas.\n",
        "    - target_size: Tupla representando o tamanho desejado das imagens (largura, altura).\n",
        "\n",
        "    Retorna:\n",
        "    - None\n",
        "    \"\"\"\n",
        "\n",
        "    # Certifique-se de que o diretório de saída existe\n",
        "    os.makedirs(output_path, exist_ok=True)\n",
        "\n",
        "    # Lista todos os arquivos no diretório do dataset\n",
        "    image_files = [f for f in os.listdir(dataset_path) if os.path.isfile(os.path.join(dataset_path, f))]\n",
        "\n",
        "    for image_file in image_files:\n",
        "      add_pixels = 0\n",
        "      # Caminho completo da imagem original\n",
        "      input_image_path = os.path.join(dataset_path, image_file)\n",
        "      # Carregue a imagem\n",
        "      img = cv2.imread(input_image_path)\n",
        "      img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "\n",
        "\n",
        "\n",
        "      thresh = cv2.threshold(img_gray, 45, 255, cv2.THRESH_BINARY)[1]\n",
        "      # find contours in thresholded image, then grab the largest one\n",
        "      cnts, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
        "      c = max(cnts, key=cv2.contourArea)\n",
        "      # find the extreme points\n",
        "      extLeft = tuple(c[c[:, :, 0].argmin()][0])\n",
        "      extRight = tuple(c[c[:, :, 0].argmax()][0])\n",
        "      extTop = tuple(c[c[:, :, 1].argmin()][0])\n",
        "      extBot = tuple(c[c[:, :, 1].argmax()][0])\n",
        "\n",
        "      # create a new image by cropping the region defined by extreme points\n",
        "      new_img = img[extTop[1] - add_pixels:extBot[1] + add_pixels, extLeft[0] - add_pixels:extRight[0] + add_pixels].copy()\n",
        "\n",
        "\n",
        "      #Carrega a imagem\n",
        "      resized_img = cv2.resize(new_img, target_size)\n",
        "\n",
        "\n",
        "      # Redimensione a imagem\n",
        "\n",
        "\n",
        "      # Crie o caminho de saída e salve a imagem redimensionada\n",
        "      output_image_path = os.path.join(output_path, image_file)\n",
        "      cv2.imwrite(output_image_path, resized_img)\n",
        "\n",
        "\n",
        "# Exemplo de uso\n",
        "main_dir = \"/content/drive/MyDrive/TCC - Parte II/\"\n",
        "dataset_path = main_dir + \"Brain Tumor Classification Dataset\"\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "5P1Gs1ZOrZmZ"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "##Testing\n",
        "\n",
        "glioma_dataset = dataset_path + \"/Testing/glioma_tumor\"\n",
        "glioma_output = dataset_path + \"/preprocessing\" + \"/Testing/glioma_tumor\"\n",
        "\n",
        "resize_images(glioma_dataset, glioma_output, target_size=(256, 256))\n",
        "\n",
        "meningioma_dataset = dataset_path + \"/Testing/meningioma_tumor\"\n",
        "meningioma_output = dataset_path + \"/preprocessing\" + \"/Testing/meningioma_tumor\"\n",
        "\n",
        "resize_images(meningioma_dataset, meningioma_output, target_size=(256, 256))\n",
        "\n",
        "no_tumor_dataset = dataset_path + \"/Testing/no_tumor\"\n",
        "no_tumor_output = dataset_path + \"/preprocessing\" + \"/Testing/no_tumor\"\n",
        "\n",
        "resize_images(no_tumor_dataset, no_tumor_output, target_size=(256, 256))\n",
        "\n",
        "pituitary_dataset = dataset_path + \"/Testing/pituitary_tumor\"\n",
        "pituitary_output = dataset_path + \"/preprocessing\" + \"/Testing/pituitary_tumor\"\n",
        "\n",
        "resize_images(pituitary_dataset, pituitary_output, target_size=(256, 256))\n",
        "\n",
        "#############\n",
        "\n",
        "glioma_dataset = dataset_path + \"/Training/glioma_tumor\"\n",
        "glioma_output = dataset_path + \"/preprocessing\" + \"/Training/glioma_tumor\"\n",
        "\n",
        "resize_images(glioma_dataset, glioma_output, target_size=(256, 256))\n",
        "\n",
        "meningioma_dataset = dataset_path + \"/Training/meningioma_tumor\"\n",
        "meningioma_output = dataset_path + \"/preprocessing\" + \"/Training/meningioma_tumor\"\n",
        "\n",
        "resize_images(meningioma_dataset, meningioma_output, target_size=(256, 256))\n",
        "\n",
        "no_tumor_dataset = dataset_path + \"/Training/no_tumor\"\n",
        "no_tumor_output = dataset_path + \"/preprocessing\" + \"/Training/no_tumor\"\n",
        "\n",
        "resize_images(no_tumor_dataset, no_tumor_output, target_size=(256, 256))\n",
        "\n",
        "pituitary_dataset = dataset_path + \"/Training/pituitary_tumor\"\n",
        "pituitary_output = dataset_path + \"/preprocessing\" + \"/Training/pituitary_tumor\"\n",
        "\n",
        "resize_images(pituitary_dataset, pituitary_output, target_size=(256, 256))\n",
        "\n"
      ],
      "metadata": {
        "id": "3ixr-ukHzHOL"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Building the model"
      ],
      "metadata": {
        "id": "Ugy_R9E8CTUO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def validate_model(model, val_loader, criterion, device='cuda'):\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    all_val_outputs = []\n",
        "    all_val_targets = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for val_inputs, val_targets in val_loader:\n",
        "            # Mova os dados para o dispositivo\n",
        "            val_inputs, val_targets = val_inputs.to(device), val_targets.to(device)\n",
        "\n",
        "            # Obtenha as previsões do modelo\n",
        "            val_outputs = model(val_inputs)\n",
        "\n",
        "            # Calcule a perda\n",
        "            loss = criterion(val_outputs, val_targets)\n",
        "            val_loss += loss.item()\n",
        "\n",
        "            all_val_outputs.append(val_outputs)\n",
        "            all_val_targets.append(val_targets)\n",
        "\n",
        "    val_loss /= len(val_loader)\n",
        "\n",
        "    val_outputs = torch.cat(all_val_outputs, dim=0)\n",
        "    val_targets = torch.cat(all_val_targets, dim=0)\n",
        "\n",
        "    # Mova as previsões e alvos para a CPU para calcular a acurácia\n",
        "    val_outputs_cpu = val_outputs.cpu()\n",
        "    val_predictions = torch.argmax(val_outputs_cpu, axis=1)\n",
        "    val_targets_cpu = val_targets.cpu()\n",
        "\n",
        "    # Calcula as previsões e acurácia\n",
        "    val_accuracy = accuracy_score(val_targets_cpu.numpy(), val_predictions.numpy())\n",
        "\n",
        "    return val_loss, val_accuracy\n"
      ],
      "metadata": {
        "id": "GscMoif9h6N6"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Verifique se o ambiente do Google Colab possui GPU habilitada\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Transformações de pré-processamento das imagens\n",
        "# Verificar Melhor isso\n",
        "\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.RandomRotation(10),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "])\n",
        "\n",
        "# Carregar o conjunto de dados\n",
        "train_dataset = datasets.ImageFolder(root= dataset_path + '/Training', transform = transform)\n",
        "val_dataset = datasets.ImageFolder(root = dataset_path + '/Testing', transform = transform)\n",
        "\n",
        "# Definir DataLoader para carregar os dados em lotes\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=1)\n",
        "val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# Definir arquitetura da rede neural\n",
        "class SimpleCNN(nn.Module):\n",
        "    def __init__(self, num_classes):\n",
        "        super(SimpleCNN, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)\n",
        "        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)\n",
        "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n",
        "        self.fc1 = nn.Linear(128 * 56 * 56, num_classes)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 128 * 56 * 56)\n",
        "        x = self.fc1(x)\n",
        "        return x\n",
        "\n",
        "# Instanciar o modelo\n",
        "model = SimpleCNN(num_classes=4).to(device)\n",
        "\n",
        "# Definir a função de perda e otimizador\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "# Treinar o modelo\n",
        "num_epochs = 10\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    for inputs, targets in train_loader:\n",
        "        inputs, targets = inputs.to(device), targets.to(device)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(inputs)\n",
        "        loss = criterion(outputs, targets)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    # Validação\n",
        "    val_loss, val_accuracy = validate_model(model, val_loader, criterion)\n",
        "\n",
        "    print(f'Epoch [{epoch+1}/{num_epochs}], Val Loss: {val_loss:.2f}, Val Accuracy: {val_accuracy:.2f}')\n",
        "\n",
        "\n",
        "torch.save({\n",
        "    'epoch': num_epochs,\n",
        "    'model_state_dict': model.state_dict(),\n",
        "    'optimizer_state_dict': optimizer.state_dict(),\n",
        "    'loss': loss,\n",
        "}, main_dir + 'Models/modelo_treinado.pth')\n",
        "\n",
        "print(\"Treinamento concluído.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 477
        },
        "id": "pn_WO65yCYXg",
        "outputId": "89aa5f38-f41e-4d29-8196-160921f5a00e"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "Found no NVIDIA driver on your system. Please check that you have an NVIDIA GPU and installed a driver from http://www.nvidia.com/Download/index.aspx",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-86e7335acc31>\u001b[0m in \u001b[0;36m<cell line: 50>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     60\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     61\u001b[0m     \u001b[0;31m# Validação\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m     \u001b[0mval_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_accuracy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalidate_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'Epoch [{epoch+1}/{num_epochs}], Val Loss: {val_loss:.2f}, Val Accuracy: {val_accuracy:.2f}'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-10-7ce72e793f99>\u001b[0m in \u001b[0;36mvalidate_model\u001b[0;34m(model, val_loader, criterion, device)\u001b[0m\n\u001b[1;32m      8\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mval_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_targets\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m             \u001b[0;31m# Mova os dados para o dispositivo\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m             \u001b[0mval_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_targets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval_inputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_targets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m             \u001b[0;31m# Obtenha as previsões do modelo\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/cuda/__init__.py\u001b[0m in \u001b[0;36m_lazy_init\u001b[0;34m()\u001b[0m\n\u001b[1;32m    296\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;34m\"CUDA_MODULE_LOADING\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menviron\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    297\u001b[0m             \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menviron\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"CUDA_MODULE_LOADING\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"LAZY\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 298\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_C\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cuda_init\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    299\u001b[0m         \u001b[0;31m# Some of the queued calls may reentrantly call _lazy_init();\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    300\u001b[0m         \u001b[0;31m# we need to just return without initializing in that case.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mRuntimeError\u001b[0m: Found no NVIDIA driver on your system. Please check that you have an NVIDIA GPU and installed a driver from http://www.nvidia.com/Download/index.aspx"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Obtém informações sobre o dispositivo\n",
        "print(\"Dispositivo atual:\", device)\n",
        "print(\"Nome do dispositivo:\", torch.cuda.get_device_name(device) if device.type == \"cuda\" else \"CPU\")\n",
        "print(\"Capacidade de computação da GPU:\", torch.cuda.get_device_capability(device) if device.type == \"cuda\" else \"N/A\")\n",
        "print(\"Número de GPUs disponíveis:\", torch.cuda.device_count() if torch.cuda.is_available() else 0)"
      ],
      "metadata": {
        "id": "aPXupwxcMHf_"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}