{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":7327,"databundleVersionId":861871,"sourceType":"competition"}],"dockerImageVersionId":30648,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport os\nimport matplotlib.pyplot as plt\nimport torch\nfrom torchvision import datasets, transforms, models\nfrom torch import nn, optim\nfrom torch.autograd import Variable\nfrom torch.utils.data.sampler import SubsetRandomSampler\nfrom torch.utils.data import Dataset, DataLoader\nfrom PIL import Image\nfrom skimage import io, transform\nimport torch.utils.data as data_utils\nimport torchvision.models as models\nfrom tabulate import tabulate\nfrom sklearn.model_selection import StratifiedKFold\nfrom torch.utils.data import Subset\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-02-18T21:30:04.742287Z","iopub.execute_input":"2024-02-18T21:30:04.742616Z","iopub.status.idle":"2024-02-18T21:30:12.128830Z","shell.execute_reply.started":"2024-02-18T21:30:04.742590Z","shell.execute_reply":"2024-02-18T21:30:12.128050Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class DogBreedsDataset(Dataset):\n    \n    def __init__(self, csv_file, root_dir, transform=None):\n        self.labels_frame = pd.read_csv(csv_file)\n        self.class_to_idx = {breed: idx for idx, breed in enumerate(self.labels_frame['breed'].unique())}\n        self.idx_to_class = {idx: breed for breed, idx in self.class_to_idx.items()}\n        self.map = dict(zip(self.labels_frame['breed'].unique(), range(0, len(self.labels_frame['breed'].unique()))))\n        self.labels_frame['breed'] = self.labels_frame['breed'].map(self.map)\n        self.root_dir = root_dir\n        self.transform = transform\n        \n    def getmap(self):\n        return self.class_to_idx\n        \n    def __getclasses__(self):\n        return self.labels_frame['breed'].unique().tolist()\n\n    def __len__(self):\n        return len(self.labels_frame)\n\n    def __getitem__(self, idx):\n        img_name = os.path.join(self.root_dir, self.labels_frame.iloc[idx, 0] + '.jpg')\n        image = io.imread(img_name)\n        PIL_image = Image.fromarray(image)\n        label = self.labels_frame.iloc[idx, 1]\n        label = np.array(label)\n        label = torch.from_numpy(label).long()\n        if self.transform:\n            image = self.transform(PIL_image)\n        return image, label\n    \ncsv='/kaggle/input/dog-breed-identification/labels.csv'\nroot='/kaggle/input/dog-breed-identification/train'\n\ntransformer =  transforms.Compose([\n        transforms.RandomResizedCrop(size=256, scale=(0.95, 1.0)),\n        transforms.RandomRotation(degrees=15),\n        transforms.ColorJitter(),\n        transforms.RandomHorizontalFlip(),\n        transforms.CenterCrop(size=224),\n        transforms.ToTensor(),\n        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n    ])\n\nalldata = DogBreedsDataset(csv_file=csv, root_dir=root, transform=transformer)\nprint(\"Dispositif utilisé:\", device)\nprint('**'*40)\nprint(\"Nombre d'éléments dans le dataset :\", len(alldata))\nprint(\"Classes uniques :\", len(alldata.__getclasses__()))\nprint('**'*40)\nclass_map = alldata.getmap()\nclass_table = [(key, value) for key, value in class_map.items()]\nprint(\"Correspondance des classes :\")\nprint(tabulate(class_table, headers=['Classe', 'Index']))\nprint('**'*40)\n\nbatch_size = 32\ndata_loader = DataLoader(alldata, batch_size=batch_size, shuffle=True)\n\ndef show_images_with_labels(images, labels, class_map):\n    class_names = list(class_map.keys())\n    num_images = len(images)\n    num_cols = 8 \n    num_rows = (num_images - 1) // num_cols + 1\n    plt.figure(figsize=(15, 3*num_rows))\n    for i, (image, label) in enumerate(zip(images, labels)):\n        plt.subplot(num_rows, num_cols, i + 1)\n        plt.imshow(image.permute(1, 2, 0))\n        plt.title(class_names[label.item()])\n        plt.axis('off')\n    plt.show()\n\nfor batch in data_loader:\n    images, labels = batch\n    show_images_with_labels(images[:], labels[:], class_map)\n    break","metadata":{"execution":{"iopub.status.busy":"2024-02-18T21:30:12.130622Z","iopub.execute_input":"2024-02-18T21:30:12.131097Z","iopub.status.idle":"2024-02-18T21:30:15.002567Z","shell.execute_reply.started":"2024-02-18T21:30:12.131070Z","shell.execute_reply":"2024-02-18T21:30:15.001651Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class CustomVGG16MultiClass(nn.Module):\n    def __init__(self, num_classes):\n        super(CustomVGG16MultiClass, self).__init__()\n        \n        # Charger le modèle VGG16 avec des poids pré-entraînés\n        vgg16 = models.vgg16(pretrained=True)\n        \n        # Fixer les couches de features pour qu'elles ne soient pas entraînables\n        for param in vgg16.features.parameters():\n            param.requires_grad = False\n        \n        # Extraire les couches de features\n        self.features = vgg16.features\n        \n        # Extraire le classificateur\n        self.classifier = vgg16.classifier\n        \n        # Remplacer la dernière couche linéaire pour s'adapter au nombre de classes de votre problème\n        in_features = vgg16.classifier[-1].in_features\n        self.classifier[-1] = nn.Linear(in_features, num_classes)\n\n    def forward(self, x):\n        x = self.features(x)\n        x = x.view(x.size(0), -1)\n        x = self.classifier(x)\n        return x\n\n# Définir les paramètres\nnum_classes = 120\n# Créer une instance du modèle\nmodel = CustomVGG16MultiClass(num_classes).to(device)\n\n# Charger les données\nall_data_loader = DataLoader(alldata, batch_size=batch_size, shuffle=True)\n\nfor i, (x, y) in enumerate(all_data_loader):\n    x = x.to(device)\n    output = model(x)\n    break\n\nprint(\"Le modèle est prêt.\")","metadata":{"execution":{"iopub.status.busy":"2024-02-18T21:30:15.004197Z","iopub.execute_input":"2024-02-18T21:30:15.004522Z","iopub.status.idle":"2024-02-18T21:30:21.758974Z","shell.execute_reply.started":"2024-02-18T21:30:15.004493Z","shell.execute_reply":"2024-02-18T21:30:21.758048Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def accuracy(output, target):\n    _, predicted = torch.max(output, 1)\n    correct = (predicted == target).sum().item()\n    total = target.size(0)\n    acc = correct / total * 100\n    return acc\n\nprint('bien')","metadata":{"execution":{"iopub.status.busy":"2024-02-18T21:30:21.760533Z","iopub.execute_input":"2024-02-18T21:30:21.760922Z","iopub.status.idle":"2024-02-18T21:30:21.766980Z","shell.execute_reply.started":"2024-02-18T21:30:21.760889Z","shell.execute_reply":"2024-02-18T21:30:21.765938Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def train_model(model, train_loader, criterion, optimizer):\n    model.train()\n    train_loss = 0.0\n    train_accuracy = 0.0\n\n    for batch_i, (data, target) in enumerate(train_loader):\n        data, target = data.to(device), target.to(device)\n        optimizer.zero_grad()\n        output = model(data)\n        loss = criterion(output, target)\n        loss.backward()\n        optimizer.step()\n        train_loss += loss.item()\n        train_accuracy += accuracy(output, target)\n        print('Batch %d loss: %.16f | accuracy: %.4f' % (batch_i + 1, train_loss / 20, train_accuracy / 20))\n        train_loss = 0.0\n        train_accuracy = 0.0","metadata":{"execution":{"iopub.status.busy":"2024-02-18T21:30:21.769428Z","iopub.execute_input":"2024-02-18T21:30:21.769723Z","iopub.status.idle":"2024-02-18T21:30:21.776701Z","shell.execute_reply.started":"2024-02-18T21:30:21.769694Z","shell.execute_reply":"2024-02-18T21:30:21.775830Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def evaluate_model(model, data_loader, criterion, train_on_gpu):\n    model.eval()\n    total_loss = 0.0\n    total_accuracy = 0.0\n    num_batches = len(data_loader)\n\n    for batch_i, (data, target) in enumerate(data_loader):\n        if train_on_gpu:\n            data, target = data.cuda(), target.cuda()\n\n        with torch.no_grad():\n            output = model(data)\n            loss = criterion(output, target)\n            total_loss += loss.item()\n            total_accuracy += accuracy(output, target)\n\n        if (batch_i + 1) % 20 == 0 or (batch_i + 1) == num_batches:\n            avg_loss = total_loss / (batch_i + 1)\n            avg_accuracy = total_accuracy / (batch_i + 1)\n            print(f'Batch {batch_i + 1}/{num_batches} | '\n                  f'Average Loss: {avg_loss:.4f} | '\n                  f'Average Accuracy: {avg_accuracy:.2f}%')\n\n    return total_loss / len(data_loader)\nprint('bien')","metadata":{"execution":{"iopub.status.busy":"2024-02-18T21:30:21.777862Z","iopub.execute_input":"2024-02-18T21:30:21.778305Z","iopub.status.idle":"2024-02-18T21:30:21.790472Z","shell.execute_reply.started":"2024-02-18T21:30:21.778282Z","shell.execute_reply":"2024-02-18T21:30:21.789611Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"num_classes = len(alldata.__getclasses__())\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\nnum_folds = 5\ncv = StratifiedKFold(n_splits=num_folds, shuffle=True, random_state=0)\ntrain_on_gpu = torch.cuda.is_available()\n\n# Create empty lists to store history for each fold\nhistory_train_loss = []\nhistory_train_accuracy = []\nhistory_valid_loss = []\n\nif train_on_gpu:\n    model.cuda()\n\n# Loop over folds\nfor fold, (train_idx, val_idx) in enumerate(cv.split(X=alldata.labels_frame, y=alldata.labels_frame['breed'])):\n    print(f'****************  FOLD {fold}  *********************')\n\n    train_dataset = Subset(alldata, train_idx)\n    val_dataset = Subset(alldata, val_idx)\n    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n\n    # Initialize history for this fold\n    fold_train_loss = []\n    fold_train_accuracy = []\n\n    for epoch in range(10):\n        model.train()\n        train_loss = 0.0\n        train_accuracy = 0.0\n\n        for batch_i, (data, target) in enumerate(train_loader):\n            if train_on_gpu:\n                data, target = data.cuda(), target.cuda()\n            optimizer.zero_grad()\n            output = model(data)\n            loss = criterion(output, target)\n            loss.backward()\n            optimizer.step()\n            train_loss += loss.item()\n            train_accuracy += accuracy(output, target)\n\n            if batch_i % 20 == 19:\n                print(f'Batch {batch_i + 1} loss: {train_loss / 20:.4f} | accuracy: {train_accuracy / 20:.2f}%')\n                fold_train_loss.append(train_loss / 20)\n                fold_train_accuracy.append(train_accuracy / 20)\n                train_loss = 0.0\n                train_accuracy = 0.0\n\n    # Record training history for this fold\n    history_train_loss.append(fold_train_loss)\n    history_train_accuracy.append(fold_train_accuracy)\n\n    # Evaluate on validation set\n    validation_loss = evaluate_model(model, val_loader, criterion, train_on_gpu)\n    history_valid_loss.append(validation_loss)\n    print(f'Fold {fold + 1}, Validation Loss: {validation_loss} %')","metadata":{"execution":{"iopub.status.busy":"2024-02-18T21:30:21.791536Z","iopub.execute_input":"2024-02-18T21:30:21.791844Z","iopub.status.idle":"2024-02-18T22:59:59.926412Z","shell.execute_reply.started":"2024-02-18T21:30:21.791815Z","shell.execute_reply":"2024-02-18T22:59:59.925457Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\n\n# Plot training loss\nplt.figure(figsize=(10, 6))\nfor fold in range(num_folds):\n    plt.plot(history_train_loss[fold], label=f'Fold {fold + 1}')\nplt.title('Training Loss')\nplt.xlabel('Batch')\nplt.ylabel('Loss')\nplt.legend()\nplt.show()\n\n# Plot training accuracy\nplt.figure(figsize=(10, 6))\nfor fold in range(num_folds):\n    plt.plot(history_train_accuracy[fold], label=f'Fold {fold + 1}')\nplt.title('Training Accuracy')\nplt.xlabel('Batch')\nplt.ylabel('Accuracy')\nplt.legend()\nplt.show()\n\n# Plot validation loss\nplt.figure(figsize=(10, 6))\nplt.plot(history_valid_loss, label='Validation')\nplt.title('Validation Loss')\nplt.xlabel('Fold')\nplt.ylabel('Loss')\nplt.legend()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-02-18T22:59:59.927664Z","iopub.execute_input":"2024-02-18T22:59:59.927998Z","iopub.status.idle":"2024-02-18T23:00:00.702572Z","shell.execute_reply.started":"2024-02-18T22:59:59.927971Z","shell.execute_reply":"2024-02-18T23:00:00.701616Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"criterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n# num_epochs = 6\n\n# for epoch in range(num_epochs):\n#     train_model(model, train_loader, criterion, optimizer)\n#     evaluate_model(model, val_loader, criterion, train_on_gpu)\n\n    \nimport pandas as pd\ndef predict(model, sample_sub, test_path, transform, dataset):\n    sub = pd.DataFrame(columns=sample_sub.columns)\n    for index, rows in sample_sub.iterrows():\n        image_id = rows[\"id\"]\n        image = Image.open(test_path + f\"/{image_id}.jpg\")\n        image_processed = transform(image).unsqueeze(dim=0).to(device)\n        \n        y_logits = model(image_processed).squeeze()\n        y_probs = torch.softmax(y_logits, dim=0)\n        \n        sub_classes = {dataset.idx_to_class[index]: [prob.item()] for index, prob in enumerate(y_probs)}\n        sub_classes[\"id\"] = image_id\n        \n        sub = pd.concat([sub, pd.DataFrame(sub_classes)])\n    return sub","metadata":{"execution":{"iopub.status.busy":"2024-02-18T23:00:00.703843Z","iopub.execute_input":"2024-02-18T23:00:00.704150Z","iopub.status.idle":"2024-02-18T23:00:00.712984Z","shell.execute_reply.started":"2024-02-18T23:00:00.704125Z","shell.execute_reply":"2024-02-18T23:00:00.712062Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sample_sub = pd.read_csv('/kaggle/input/dog-breed-identification/sample_submission.csv')\nDATA_TEST_PATH = '/kaggle/input/dog-breed-identification/test'\ntrain_transform = transforms.Compose([\n   transforms.RandomResizedCrop(size=256, scale=(0.95, 1.0)),\n        transforms.RandomRotation(degrees=15),\n        transforms.RandomHorizontalFlip(),\n        transforms.CenterCrop(size=224),\n        transforms.ToTensor(),\n        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n])\ntrain_data = alldata  # Assuming train_data contains classes_to_idx attribute\nmy_sub = predict(model, sample_sub, DATA_TEST_PATH, train_transform, train_data)\n\nmy_sub = my_sub.reset_index(drop=True)\nmy_sub.to_csv(\"sub_1.csv\", index=False)","metadata":{"execution":{"iopub.status.busy":"2024-02-18T23:00:00.714251Z","iopub.execute_input":"2024-02-18T23:00:00.714761Z","iopub.status.idle":"2024-02-18T23:06:31.433192Z","shell.execute_reply.started":"2024-02-18T23:00:00.714733Z","shell.execute_reply":"2024-02-18T23:06:31.432240Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n\n# Convertir toutes les colonnes sauf la colonne 'id' en valeurs numériques\nmy_sub_numeric = my_sub.drop(columns=['id']).apply(pd.to_numeric)\n\n# Calculer la somme de chaque ligne de my_sub_numeric\nrow_sums = my_sub_numeric.sum(axis=1)\n\n# Calculer la somme des valeurs dans chaque colonne de my_sub_numeric\ncol_sums = my_sub_numeric.sum(axis=0)\n\nprint(\"Somme de chaque ligne de my_sub :\")\nprint(row_sums)\n\nmy_sub","metadata":{"execution":{"iopub.status.busy":"2024-02-18T23:06:31.434375Z","iopub.execute_input":"2024-02-18T23:06:31.434696Z","iopub.status.idle":"2024-02-18T23:06:31.509746Z","shell.execute_reply.started":"2024-02-18T23:06:31.434668Z","shell.execute_reply":"2024-02-18T23:06:31.508727Z"},"trusted":true},"execution_count":null,"outputs":[]}]}