{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":5441,"databundleVersionId":38425,"isSourceIdPinned":false,"sourceType":"competition"}],"dockerImageVersionId":31153,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:23.323250Z","iopub.execute_input":"2025-10-30T14:13:23.323647Z","iopub.status.idle":"2025-10-30T14:13:23.332800Z","shell.execute_reply.started":"2025-10-30T14:13:23.323623Z","shell.execute_reply":"2025-10-30T14:13:23.331054Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!unzip -q \"/kaggle/input/dogs-vs-cats-redux-kernels-edition/train.zip\"\n!unzip -q \"/kaggle/input/dogs-vs-cats-redux-kernels-edition/test.zip\"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T17:17:09.965736Z","iopub.execute_input":"2025-10-30T17:17:09.966051Z","iopub.status.idle":"2025-10-30T17:17:27.465726Z","shell.execute_reply.started":"2025-10-30T17:17:09.966021Z","shell.execute_reply":"2025-10-30T17:17:27.464557Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\n\ndef prepare_data(train_path, val_size=0.2, random_state=42):\n    train_filenames = os.listdir(train_path)\n    train_categories = ['dog' if filename.split(\".\")[0] == 'dog' else 'cat' for filename in train_filenames]\n\n    df = pd.DataFrame({\n        'filename': train_filenames,\n        'category': train_categories\n    })\n\n    train_df, val_df = train_test_split(df, test_size=val_size, stratify=df[\"category\"], random_state=random_state)\n    return train_df, val_df","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:44.933771Z","iopub.execute_input":"2025-10-30T14:13:44.934112Z","iopub.status.idle":"2025-10-30T14:13:44.941750Z","shell.execute_reply.started":"2025-10-30T14:13:44.934085Z","shell.execute_reply":"2025-10-30T14:13:44.940425Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_path = \"/kaggle/working/train\"\ntrain_df, val_df = prepare_data(train_path)\nprint(f\"Total Training Images: {len(train_df)}\")\nprint(f\"Total Validation Images: {len(val_df)}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:44.945073Z","iopub.execute_input":"2025-10-30T14:13:44.945461Z","iopub.status.idle":"2025-10-30T14:13:45.052983Z","shell.execute_reply.started":"2025-10-30T14:13:44.945435Z","shell.execute_reply":"2025-10-30T14:13:45.051783Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\nfrom PIL import Image","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:45.054766Z","iopub.execute_input":"2025-10-30T14:13:45.055214Z","iopub.status.idle":"2025-10-30T14:13:53.009047Z","shell.execute_reply.started":"2025-10-30T14:13:45.055184Z","shell.execute_reply":"2025-10-30T14:13:53.007496Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class TrainDataset(Dataset):\n    def __init__(self, df, root_dir, transform=None):\n        self.df = df.reset_index(drop=True)\n        self.root_dir = root_dir\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.df)\n\n    def __getitem__(self, idx):\n        img_name = self.df.loc[idx, 'filename']\n        label_str = self.df.loc[idx, 'category']\n        label = 1 if label_str == 'dog' else 0\n\n        img_path = os.path.join(self.root_dir, img_name)\n        image = Image.open(img_path).convert('RGB')\n\n        if self.transform:\n            image = self.transform(image)\n\n        return image, label","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:53.011677Z","iopub.execute_input":"2025-10-30T14:13:53.012273Z","iopub.status.idle":"2025-10-30T14:13:53.023075Z","shell.execute_reply.started":"2025-10-30T14:13:53.012172Z","shell.execute_reply":"2025-10-30T14:13:53.020243Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class TestDataset(Dataset):\n    def __init__(self, folder, transform=None):\n        self.folder = folder\n        self.images = os.listdir(folder)\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.images)\n\n    def __getitem__(self, idx):\n        img_name = self.images[idx]\n        img_path = os.path.join(self.folder, img_name)\n        image = Image.open(img_path).convert('RGB')\n\n        if self.transform:\n            image = self.transform(image)\n\n        img_id = int(img_name.split('.')[0])\n        return image, img_id","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:53.024881Z","iopub.execute_input":"2025-10-30T14:13:53.025172Z","iopub.status.idle":"2025-10-30T14:13:53.050345Z","shell.execute_reply.started":"2025-10-30T14:13:53.025151Z","shell.execute_reply":"2025-10-30T14:13:53.048880Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class CNN(nn.Module):\n    def __init__(self):\n        super(CNN, self).__init__()\n        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, padding=1)\n        self.pool = nn.MaxPool2d(2, 2)\n        self.fc1 = nn.Linear(8 * 64 * 64, 2)\n\n    def forward(self, x):\n        x = self.pool(F.relu(self.conv1(x)))\n        x = torch.flatten(x, 1)\n        x = self.fc1(x)\n        return x","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:53.051859Z","iopub.execute_input":"2025-10-30T14:13:53.052234Z","iopub.status.idle":"2025-10-30T14:13:53.079971Z","shell.execute_reply.started":"2025-10-30T14:13:53.052209Z","shell.execute_reply":"2025-10-30T14:13:53.078572Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"transform = transforms.Compose([\n    transforms.Resize((128, 128)),  \n    transforms.ToTensor(),\n])\n\ntrain_dataset = TrainDataset(train_df, train_path, transform)\nval_dataset = TrainDataset(val_df, train_path, transform)\n\ntrain_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\nval_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:53.081367Z","iopub.execute_input":"2025-10-30T14:13:53.081834Z","iopub.status.idle":"2025-10-30T14:13:53.107195Z","shell.execute_reply.started":"2025-10-30T14:13:53.081808Z","shell.execute_reply":"2025-10-30T14:13:53.105379Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel = CNN().to(device)\n\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n\nfor epoch in range(5):\n    model.train()\n    total_loss = 0\n    for imgs, labels in train_loader:\n        imgs, labels = imgs.to(device), labels.to(device)\n        optimizer.zero_grad()\n        outputs = model(imgs)\n        loss = criterion(outputs, labels)\n        loss.backward()\n        optimizer.step()\n        total_loss += loss.item()\n\n    model.eval()\n    correct, total = 0, 0\n    with torch.no_grad():\n        for imgs, labels in val_loader:\n            imgs, labels = imgs.to(device), labels.to(device)\n            outputs = model(imgs)\n            _, preds = torch.max(outputs, 1)\n            correct += (preds == labels).sum().item()\n            total += labels.size(0)\n\n\n    print(f\"Epoch [{epoch+1}/5] | Loss: {total_loss/len(train_loader)} | Val Acc: {100*correct/total}%\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:13:53.112767Z","iopub.execute_input":"2025-10-30T14:13:53.113259Z","iopub.status.idle":"2025-10-30T14:24:40.824574Z","shell.execute_reply.started":"2025-10-30T14:13:53.113217Z","shell.execute_reply":"2025-10-30T14:24:40.823286Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Для соревнования [Dogs vs. Cats](https://www.kaggle.com/competitions/dogs-vs-cats). Участие уже недоступно, так что узнать точность не получится.**","metadata":{}},{"cell_type":"code","source":"test_path = \"/kaggle/working/test\"\ntest_dataset = TestDataset(test_path, transform)\ntest_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n\nmodel.eval()\npredictions = []\n\nwith torch.no_grad():\n    for imgs, img_ids in test_loader:\n        imgs = imgs.to(device)\n        outputs = model(imgs)\n        _, preds = torch.max(outputs, 1)\n        for img_id, pred in zip(img_ids, preds.cpu().numpy()):\n            predictions.append([int(img_id.item()), pred])\n\nsubmission = pd.DataFrame(predictions, columns=[\"id\", \"label\"])\nsubmission = submission.sort_values(\"id\")  \nsubmission.to_csv(\"/kaggle/working/submission1.csv\", index=False)\n\nprint(submission.head())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:34:18.288289Z","iopub.execute_input":"2025-10-30T14:34:18.288689Z","iopub.status.idle":"2025-10-30T14:35:13.209129Z","shell.execute_reply.started":"2025-10-30T14:34:18.288665Z","shell.execute_reply":"2025-10-30T14:35:13.207801Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Для сревнования [Dogs vs. Cats Redux: Kernels Edition](https://www.kaggle.com/competitions/dogs-vs-cats-redux-kernels-edition/overview). Используются такие же датасеты как и в [Dogs vs. Cats](https://www.kaggle.com/competitions/dogs-vs-cats). Для каждого изображения тестового набора необходимо указать вероятность того, что на нем изображена собака. Заявки оцениваются по [log los](https://www.kaggle.com/competitions/dogs-vs-cats-redux-kernels-edition/overview/evaluation).**","metadata":{}},{"cell_type":"code","source":"test_path = \"/kaggle/working/test\"\ntest_dataset = TestDataset(test_path, transform)\ntest_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n\nmodel.eval()\npredictions = []\n\nwith torch.no_grad():\n    for imgs, img_ids in test_loader:\n        imgs = imgs.to(device)\n        outputs = model(imgs)\n        probs = F.softmax(outputs, dim=1)[:, 1] \n        for img_id, prob in zip(img_ids, probs.cpu().numpy()):\n            predictions.append([int(img_id.item()), float(prob)])\n\nsubmission = pd.DataFrame(predictions, columns=[\"id\", \"label\"])\nsubmission = submission.sort_values(\"id\")\nsubmission.to_csv(\"/kaggle/working/submission.csv\", index=False)\n\nprint(submission.head())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-30T14:35:17.495161Z","iopub.execute_input":"2025-10-30T14:35:17.495533Z","iopub.status.idle":"2025-10-30T14:36:15.044423Z","shell.execute_reply.started":"2025-10-30T14:35:17.495490Z","shell.execute_reply":"2025-10-30T14:36:15.042657Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Косенко Кирилл гр. 25.М81\n\n\n![image.png](attachment:d7603ea9-7a30-47c7-b88e-fd4dd2f6841a.png)\n","metadata":{},"attachments":{"d7603ea9-7a30-47c7-b88e-fd4dd2f6841a.png":{"image/png":"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"}}}]}