init

.gitignore

@@ -0,0 +1,21 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Other
+.env
+cmds.txt
+uv.lock
+.vscode
+test.drawio
+test.py
+models/*
+Fashion-MNIST/
+MNIST/

evaluate.py

@@ -0,0 +1,38 @@
+import argparse
+
+import pandas as pd
+from sklearn.metrics import accuracy_score, confusion_matrix
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--ground-truth", required=True)
+    parser.add_argument("--predictions", required=True)
+
+    args = parser.parse_args()
+
+    df_true = pd.read_csv(args.ground_truth)
+    df_pred = pd.read_csv(args.predictions)
+
+    if "label" not in df_true.columns or "label" not in df_pred.columns:
+        raise ValueError("Оба файла должны содержать колонку 'label'")
+
+    if len(df_true) != len(df_pred):
+        raise ValueError(
+            f"Разная длина файлов: ground-truth={len(df_true)}, "
+            f"predictions={len(df_pred)}"
+        )
+
+    y_true = df_true["label"].values
+    y_pred = df_pred["label"].values
+
+    acc = accuracy_score(y_true, y_pred)
+    cm = confusion_matrix(y_true, y_pred)
+
+    print(f"Accuracy: {acc:.4f}")
+    print("Confusion matrix:")
+    print(cm)
+
+
+if __name__ == "__main__":
+    main()

mnist.py

@@ -0,0 +1,178 @@
+import argparse
+
+import numpy as np
+import pandas as pd
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+
+
+class ModelCNN(nn.Module):
+    """
+    Архитектура:
+    INPUT (1x28x28) ->
+      [CONV -> RELU -> CONV -> RELU -> POOL] * 3 ->
+      [FC -> RELU] * 2 ->
+      FC (num_classes)
+    """
+
+    def __init__(self, num_classes=10):
+        super(ModelCNN, self).__init__()
+
+        self.features = nn.Sequential(
+            # блок 1
+            nn.Conv2d(1, 32, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),  # 28 -> 14
+            # блок 2
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),  # 14 -> 7
+            # блок 3
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),  # 7 -> 3
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Linear(128 * 3 * 3, 256),
+            nn.ReLU(inplace=True),
+            nn.Linear(256, 128),
+            nn.ReLU(inplace=True),
+            nn.Linear(128, num_classes),
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)  # (N, 128*3*3)
+        x = self.classifier(x)
+        return x
+
+
+def train_mode(args):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Устройство: {device}")
+
+    df = pd.read_csv(args.input)
+
+    labels = df["label"].astype(np.int64).values
+    pixels = df.drop(columns=["label"]).values.astype(np.float32) / 255.0
+
+    images = torch.from_numpy(pixels.reshape(-1, 1, 28, 28))
+    labels = torch.from_numpy(labels)
+
+    dataset = TensorDataset(images, labels)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
+
+    model = ModelCNN(num_classes=args.num_classes).to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=args.lr)
+
+    model.train()
+    for epoch in range(args.epochs):
+        for i, (images, labels) in enumerate(dataloader):
+            images = images.to(device)
+            labels = labels.to(device)
+
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+            if (i + 1) % 100 == 0:
+                print(
+                    f"Epoch [{epoch+1}/{args.epochs}], Step [{i+1}/{len(dataloader)}], Loss: {loss.item():.4f}"
+                )
+
+    checkpoint = {
+        "state_dict": model.state_dict(),
+        "num_classes": args.num_classes,
+    }
+    torch.save(checkpoint, args.model)
+
+
+def inference_mode(args):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Устройство: {device}")
+
+    checkpoint = torch.load(args.model, map_location=device)
+    num_classes = checkpoint.get("num_classes", 10)
+
+    model = ModelCNN(num_classes=num_classes).to(device)
+    model.load_state_dict(checkpoint["state_dict"])
+    model.eval()
+
+    df_test = pd.read_csv(args.input)
+
+    has_label = "label" in df_test.columns
+    if has_label:
+        pixels = df_test.drop(columns=["label"]).values
+    else:
+        pixels = df_test.values
+
+    pixels = pixels.astype(np.float32) / 255.0
+    images = torch.from_numpy(pixels.reshape(-1, 1, 28, 28))
+
+    dataset = TensorDataset(images)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False)
+
+    all_preds = []
+
+    with torch.no_grad():
+        for (batch_images,) in dataloader:
+            batch_images = batch_images.to(device)
+            outputs = model(batch_images)
+            _, preds = torch.max(outputs, 1)
+            all_preds.extend(preds.cpu().numpy().tolist())
+
+    df_pred = df_test.copy()
+    df_pred["label"] = all_preds
+
+    df_pred.to_csv(args.output, index=False)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--mode", choices=["train", "inference"], required=True)
+    parser.add_argument("--input", type=str)
+    parser.add_argument("--output", type=str)
+    parser.add_argument("--model", type=str, required=True)
+
+    parser.add_argument("--epochs", type=int, default=5)
+    parser.add_argument("--batch-size", type=int, default=64)
+    parser.add_argument("--lr", type=float, default=0.001)
+    parser.add_argument("--num-classes", type=int, default=10)
+
+    args = parser.parse_args()
+
+    if args.mode == "train":
+        if args.input is None:
+            parser.error("--input обязателен в режиме train")
+    elif args.mode == "inference":
+        if args.input is None or args.output is None:
+            parser.error("--input и --output обязательны в режиме inference")
+
+    return args
+
+
+def main():
+    args = parse_args()
+    if args.mode == "train":
+        train_mode(args)
+    else:
+        inference_mode(args)
+
+
+if __name__ == "__main__":
+    main()