cv-study-utils 0.1.0__py3-none-any.whl

cv_study_utils/practice_solutions.py

@@ -0,0 +1,1091 @@
+PRACTICE = [
+    {
+        "id": 1,
+        "task": "Предобработка изображений и анализ цветовых пространств",
+        "description": "Resize, normalization, RGB/HSV/Grayscale, histograms and simple statistics.",
+        "code": r'''
+# Task 1. Image preprocessing and color-space analysis.
+# pip install opencv-python pillow matplotlib scikit-image
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+
+
+def load_rgb(image_path=None):
+    if image_path is None:
+        from skimage import data
+        return data.astronaut()  # RGB uint8 sample
+    pil_img = Image.open(image_path).convert("RGB")
+    return np.array(pil_img)
+
+
+img_rgb = load_rgb(None)  # replace None with "your_image.jpg"
+img_resized = cv2.resize(img_rgb, (224, 224), interpolation=cv2.INTER_AREA)
+img_float = img_resized.astype(np.float32) / 255.0
+img_hsv = cv2.cvtColor(img_resized, cv2.COLOR_RGB2HSV)
+img_gray = cv2.cvtColor(img_resized, cv2.COLOR_RGB2GRAY)
+
+print("shape:", img_resized.shape)
+print("dtype:", img_resized.dtype)
+print("RGB mean:", img_resized.mean(axis=(0, 1)))
+print("RGB std:", img_resized.std(axis=(0, 1)))
+print("normalized range:", img_float.min(), img_float.max())
+
+fig, ax = plt.subplots(2, 3, figsize=(12, 7))
+ax[0, 0].imshow(img_rgb)
+ax[0, 0].set_title("Original RGB")
+ax[0, 1].imshow(img_resized)
+ax[0, 1].set_title("Resized 224x224")
+ax[0, 2].imshow(img_gray, cmap="gray")
+ax[0, 2].set_title("Grayscale")
+
+colors = ["r", "g", "b"]
+for c, color in enumerate(colors):
+    ax[1, 0].hist(img_resized[:, :, c].ravel(), bins=256, range=(0, 255), color=color, alpha=0.5)
+ax[1, 0].set_title("RGB channel histograms")
+
+ax[1, 1].hist(img_gray.ravel(), bins=256, range=(0, 255), color="gray")
+ax[1, 1].set_title("Brightness histogram")
+
+h, s, v = cv2.split(img_hsv)
+ax[1, 2].hist(h.ravel(), bins=180, range=(0, 179), color="orange", alpha=0.7, label="H")
+ax[1, 2].hist(s.ravel(), bins=256, range=(0, 255), color="purple", alpha=0.4, label="S")
+ax[1, 2].hist(v.ravel(), bins=256, range=(0, 255), color="black", alpha=0.3, label="V")
+ax[1, 2].legend()
+ax[1, 2].set_title("HSV histograms")
+
+for a in ax.ravel():
+    a.axis("off") if a in ax[0] else None
+plt.tight_layout()
+plt.show()
+''',
+    },
+    {
+        "id": 2,
+        "task": "Подавление шума и фильтрация изображений",
+        "description": "Gaussian noise, salt-and-pepper noise, Gaussian/median/bilateral filtering, PSNR and SSIM.",
+        "code": r'''
+# Task 2. Noise suppression and filtering.
+# pip install opencv-python matplotlib scikit-image
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage import data
+from skimage.metrics import peak_signal_noise_ratio, structural_similarity
+
+
+img = data.astronaut()
+img = cv2.resize(img, (256, 256), interpolation=cv2.INTER_AREA)
+
+
+def gaussian_noise(image, sigma=25):
+    noise = np.random.normal(0, sigma, image.shape)
+    return np.clip(image.astype(np.float32) + noise, 0, 255).astype(np.uint8)
+
+
+def salt_pepper_noise(image, amount=0.04):
+    noisy = image.copy()
+    h, w = noisy.shape[:2]
+    n = int(amount * h * w)
+    ys = np.random.randint(0, h, n)
+    xs = np.random.randint(0, w, n)
+    half = n // 2
+    noisy[ys[:half], xs[:half]] = 0
+    noisy[ys[half:], xs[half:]] = 255
+    return noisy
+
+
+def score(reference, test):
+    psnr = peak_signal_noise_ratio(reference, test, data_range=255)
+    ssim = structural_similarity(reference, test, data_range=255, channel_axis=-1)
+    return psnr, ssim
+
+
+noisy_gauss = gaussian_noise(img, sigma=25)
+noisy_sp = salt_pepper_noise(img, amount=0.05)
+
+variants = {
+    "gaussian noise": noisy_gauss,
+    "gaussian blur": cv2.GaussianBlur(noisy_gauss, (5, 5), 0),
+    "median filter": cv2.medianBlur(noisy_sp, 5),
+    "bilateral filter": cv2.bilateralFilter(noisy_gauss, d=9, sigmaColor=75, sigmaSpace=75),
+}
+
+for name, image in variants.items():
+    psnr, ssim = score(img, image)
+    print(f"{name:16s} PSNR={psnr:6.2f}, SSIM={ssim:.4f}")
+
+fig, ax = plt.subplots(2, 3, figsize=(12, 8))
+show = [("original", img), ("gaussian noise", noisy_gauss), ("salt-pepper", noisy_sp),
+        ("gaussian blur", variants["gaussian blur"]), ("median", variants["median filter"]),
+        ("bilateral", variants["bilateral filter"])]
+for a, (title, image) in zip(ax.ravel(), show):
+    a.imshow(image)
+    a.set_title(title)
+    a.axis("off")
+plt.tight_layout()
+plt.show()
+''',
+    },
+    {
+        "id": 3,
+        "task": "Обнаружение границ и выделение контуров",
+        "description": "Sobel, Laplacian, Canny, threshold selection and contours.",
+        "code": r'''
+# Task 3. Edges and contours.
+# pip install opencv-python matplotlib scikit-image
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage import data
+
+
+img_rgb = data.camera()
+if img_rgb.ndim == 2:
+    gray = img_rgb
+else:
+    gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+
+gray = cv2.resize(gray, (320, 320), interpolation=cv2.INTER_AREA)
+blur = cv2.GaussianBlur(gray, (5, 5), 0)
+
+sobel_x = cv2.Sobel(blur, cv2.CV_64F, 1, 0, ksize=3)
+sobel_y = cv2.Sobel(blur, cv2.CV_64F, 0, 1, ksize=3)
+sobel_mag = cv2.magnitude(sobel_x, sobel_y)
+sobel_mag = cv2.normalize(sobel_mag, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+
+laplacian = cv2.Laplacian(blur, cv2.CV_64F)
+laplacian = cv2.convertScaleAbs(laplacian)
+
+threshold_pairs = [(30, 90), (50, 150), (100, 200)]
+canny_maps = [cv2.Canny(blur, lo, hi) for lo, hi in threshold_pairs]
+
+# Contours from the middle Canny result.
+contours, _ = cv2.findContours(canny_maps[1], cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+canvas = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
+cv2.drawContours(canvas, contours, -1, (255, 0, 0), 1)
+print("number of contours:", len(contours))
+
+fig, ax = plt.subplots(2, 4, figsize=(14, 7))
+items = [("gray", gray), ("sobel", sobel_mag), ("laplacian", laplacian)]
+items += [(f"canny {lo}-{hi}", c) for (lo, hi), c in zip(threshold_pairs, canny_maps)]
+items += [("contours", canvas)]
+
+for a, (title, image) in zip(ax.ravel(), items):
+    if image.ndim == 2:
+        a.imshow(image, cmap="gray")
+    else:
+        a.imshow(image)
+    a.set_title(title)
+    a.axis("off")
+
+for a in ax.ravel()[len(items):]:
+    a.axis("off")
+plt.tight_layout()
+plt.show()
+''',
+    },
+    {
+        "id": 4,
+        "task": "Классификация изображений традиционными методами МО",
+        "description": "HOG and LBP features, k-NN/SVM classifiers, metrics and confusion matrix.",
+        "code": r'''
+# Task 4. Classical image classification with HOG/LBP + k-NN/SVM.
+# pip install scikit-image scikit-learn matplotlib
+
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage.feature import hog, local_binary_pattern
+from sklearn.datasets import load_digits
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import make_pipeline
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.metrics import accuracy_score, classification_report, ConfusionMatrixDisplay
+
+
+digits = load_digits()
+X_img = digits.images  # 8x8 grayscale images
+y = digits.target
+
+
+def extract_features(image):
+    image = image.astype(np.float32) / 16.0
+    hog_feat = hog(image, orientations=8, pixels_per_cell=(4, 4), cells_per_block=(1, 1), feature_vector=True)
+    lbp = local_binary_pattern(image, P=8, R=1, method="uniform")
+    lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, 11), range=(0, 10), density=True)
+    return np.hstack([hog_feat, lbp_hist])
+
+
+X = np.vstack([extract_features(im) for im in X_img])
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, stratify=y, random_state=42)
+
+models = {
+    "kNN": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)),
+    "SVM": make_pipeline(StandardScaler(), SVC(kernel="rbf", C=10, gamma="scale")),
+}
+
+for name, model in models.items():
+    model.fit(X_train, y_train)
+    pred = model.predict(X_test)
+    print("\n", name)
+    print("accuracy:", accuracy_score(y_test, pred))
+    print(classification_report(y_test, pred))
+    ConfusionMatrixDisplay.from_predictions(y_test, pred, cmap="Blues")
+    plt.title(f"{name} confusion matrix")
+    plt.show()
+''',
+    },
+    {
+        "id": 5,
+        "task": "Сравнение ИНС и классических алгоритмов",
+        "description": "Compare SVM + HOG and MLP by accuracy, train/inference time and robustness to noise.",
+        "code": r'''
+# Task 5. SVM+HOG vs MLP: quality, time, robustness.
+# pip install scikit-image scikit-learn matplotlib
+
+import time
+import numpy as np
+from skimage.feature import hog
+from sklearn.datasets import load_digits
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import LinearSVC
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import accuracy_score
+
+
+digits = load_digits()
+images = digits.images.astype(np.float32) / 16.0
+y = digits.target
+
+
+def hog_features(batch):
+    return np.vstack([
+        hog(im, orientations=8, pixels_per_cell=(4, 4), cells_per_block=(1, 1), feature_vector=True)
+        for im in batch
+    ])
+
+
+X_hog = hog_features(images)
+X_flat = images.reshape(len(images), -1)
+idx_train, idx_test = train_test_split(np.arange(len(images)), test_size=0.25, stratify=y, random_state=42)
+
+svm = make_pipeline(StandardScaler(), LinearSVC(C=1.0, max_iter=5000))
+mlp = make_pipeline(
+    StandardScaler(),
+    MLPClassifier(hidden_layer_sizes=(128, 64), activation="relu", max_iter=80, random_state=42)
+)
+
+experiments = [
+    ("SVM + HOG", svm, X_hog[idx_train], X_hog[idx_test]),
+    ("MLP + pixels", mlp, X_flat[idx_train], X_flat[idx_test]),
+]
+
+for name, model, Xtr, Xte in experiments:
+    t0 = time.perf_counter()
+    model.fit(Xtr, y[idx_train])
+    train_time = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    pred = model.predict(Xte)
+    infer_time = time.perf_counter() - t0
+    print(f"{name:14s} acc={accuracy_score(y[idx_test], pred):.4f}, "
+          f"train={train_time:.3f}s, inference={infer_time:.4f}s")
+
+
+def add_noise(batch, sigma=0.25):
+    return np.clip(batch + np.random.normal(0, sigma, batch.shape), 0, 1)
+
+
+noisy = add_noise(images[idx_test], sigma=0.25)
+svm_pred = svm.predict(hog_features(noisy))
+mlp_pred = mlp.predict(noisy.reshape(len(noisy), -1))
+print("noise robustness:")
+print("SVM + HOG:", accuracy_score(y[idx_test], svm_pred))
+print("MLP + pixels:", accuracy_score(y[idx_test], mlp_pred))
+''',
+    },
+    {
+        "id": 6,
+        "task": "Классификация изображений с использованием CNN",
+        "description": "PyTorch CNN with two convolutional layers, pooling, loss/accuracy plots and overfitting check.",
+        "code": r'''
+# Task 6. CNN image classification in PyTorch.
+# pip install torch torchvision matplotlib
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+import matplotlib.pyplot as plt
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
+
+train_ds = datasets.FashionMNIST(root="data", train=True, download=True, transform=transform)
+test_ds = datasets.FashionMNIST(root="data", train=False, download=True, transform=transform)
+train_loader = DataLoader(train_ds, batch_size=128, shuffle=True, num_workers=2)
+test_loader = DataLoader(test_ds, batch_size=256, shuffle=False, num_workers=2)
+
+
+class SmallCNN(nn.Module):
+    def __init__(self, num_classes=10):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(64 * 7 * 7, 128), nn.ReLU(), nn.Dropout(0.3),
+            nn.Linear(128, num_classes),
+        )
+
+    def forward(self, x):
+        return self.classifier(self.features(x))
+
+
+model = SmallCNN().to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)
+
+
+def run_epoch(loader, train=True):
+    model.train(train)
+    total_loss, correct, total = 0.0, 0, 0
+    for x, y in loader:
+        x, y = x.to(device), y.to(device)
+        with torch.set_grad_enabled(train):
+            logits = model(x)
+            loss = criterion(logits, y)
+            if train:
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+        total_loss += loss.item() * x.size(0)
+        correct += (logits.argmax(1) == y).sum().item()
+        total += x.size(0)
+    return total_loss / total, correct / total
+
+
+history = {"train_loss": [], "test_loss": [], "train_acc": [], "test_acc": []}
+for epoch in range(5):
+    tr_loss, tr_acc = run_epoch(train_loader, train=True)
+    te_loss, te_acc = run_epoch(test_loader, train=False)
+    history["train_loss"].append(tr_loss)
+    history["test_loss"].append(te_loss)
+    history["train_acc"].append(tr_acc)
+    history["test_acc"].append(te_acc)
+    print(f"epoch {epoch+1}: train acc={tr_acc:.3f}, test acc={te_acc:.3f}")
+
+plt.figure(figsize=(10, 4))
+plt.subplot(1, 2, 1)
+plt.plot(history["train_loss"], label="train")
+plt.plot(history["test_loss"], label="test")
+plt.title("Loss")
+plt.legend()
+plt.subplot(1, 2, 2)
+plt.plot(history["train_acc"], label="train")
+plt.plot(history["test_acc"], label="test")
+plt.title("Accuracy")
+plt.legend()
+plt.show()
+''',
+    },
+    {
+        "id": 7,
+        "task": "Transfer Learning и дообучение моделей",
+        "description": "Fine-tune ResNet/VGG on a custom ImageFolder dataset and compare with training from scratch.",
+        "code": r'''
+# Task 7. Transfer learning with torchvision.
+# Dataset format:
+# data/train/class_a/*.jpg, data/train/class_b/*.jpg
+# data/val/class_a/*.jpg,   data/val/class_b/*.jpg
+# pip install torch torchvision
+
+import copy
+import time
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms, models
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+data_dir = "data"  # change to your dataset root
+
+weights = models.ResNet50_Weights.DEFAULT
+preprocess = weights.transforms()
+train_tf = transforms.Compose([
+    transforms.Resize((256, 256)),
+    transforms.RandomResizedCrop(224),
+    transforms.RandomHorizontalFlip(),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=weights.meta["mean"], std=weights.meta["std"]),
+])
+val_tf = preprocess
+
+train_ds = datasets.ImageFolder(f"{data_dir}/train", transform=train_tf)
+val_ds = datasets.ImageFolder(f"{data_dir}/val", transform=val_tf)
+train_loader = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=2)
+val_loader = DataLoader(val_ds, batch_size=64, shuffle=False, num_workers=2)
+num_classes = len(train_ds.classes)
+
+
+def make_resnet50(pretrained=True, freeze_backbone=True):
+    model = models.resnet50(weights=weights if pretrained else None)
+    if freeze_backbone:
+        for p in model.parameters():
+            p.requires_grad = False
+    model.fc = nn.Linear(model.fc.in_features, num_classes)
+    return model.to(device)
+
+
+def train_model(model, epochs=3, lr=1e-3):
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=lr)
+    best_acc, best_state = 0.0, copy.deepcopy(model.state_dict())
+    for epoch in range(epochs):
+        for phase, loader in [("train", train_loader), ("val", val_loader)]:
+            model.train(phase == "train")
+            correct, total, loss_sum = 0, 0, 0.0
+            for x, y in loader:
+                x, y = x.to(device), y.to(device)
+                with torch.set_grad_enabled(phase == "train"):
+                    logits = model(x)
+                    loss = criterion(logits, y)
+                    if phase == "train":
+                        optimizer.zero_grad()
+                        loss.backward()
+                        optimizer.step()
+                correct += (logits.argmax(1) == y).sum().item()
+                total += y.numel()
+                loss_sum += loss.item() * y.numel()
+            acc = correct / total
+            print(f"epoch {epoch+1} {phase}: loss={loss_sum/total:.4f}, acc={acc:.4f}")
+            if phase == "val" and acc > best_acc:
+                best_acc, best_state = acc, copy.deepcopy(model.state_dict())
+    model.load_state_dict(best_state)
+    return best_acc
+
+
+start = time.perf_counter()
+transfer_model = make_resnet50(pretrained=True, freeze_backbone=True)
+transfer_acc = train_model(transfer_model, epochs=3, lr=1e-3)
+print("transfer learning best acc:", transfer_acc, "time:", time.perf_counter() - start)
+
+# Baseline from scratch. Usually needs more data/epochs.
+scratch_model = make_resnet50(pretrained=False, freeze_backbone=False)
+scratch_acc = train_model(scratch_model, epochs=3, lr=1e-4)
+print("scratch best acc:", scratch_acc)
+''',
+    },
+    {
+        "id": 8,
+        "task": "Детекция объектов на изображениях",
+        "description": "YOLO inference on images/video and simple IoU/mAP placeholders.",
+        "code": r'''
+# Task 8. Object detection with YOLO.
+# pip install ultralytics opencv-python matplotlib
+
+from ultralytics import YOLO
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+model = YOLO("yolo11n.pt")  # or "yolov8n.pt" if that is what your environment has
+
+# Image inference.
+image_path = "image.jpg"  # replace with your file
+results = model.predict(source=image_path, conf=0.25, save=True)
+result = results[0]
+print(result.boxes)
+
+annotated = result.plot()  # BGR array
+plt.imshow(cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB))
+plt.axis("off")
+plt.show()
+
+# Video inference.
+# model.predict(source="video.mp4", conf=0.25, save=True, stream=False)
+
+
+def iou_xyxy(box_a, box_b):
+    ax1, ay1, ax2, ay2 = box_a
+    bx1, by1, bx2, by2 = box_b
+    ix1, iy1 = max(ax1, bx1), max(ay1, by1)
+    ix2, iy2 = min(ax2, bx2), min(ay2, by2)
+    inter = max(0, ix2 - ix1) * max(0, iy2 - iy1)
+    area_a = max(0, ax2 - ax1) * max(0, ay2 - ay1)
+    area_b = max(0, bx2 - bx1) * max(0, by2 - by1)
+    union = area_a + area_b - inter
+    return inter / union if union else 0.0
+
+
+# Example: evaluate one predicted box against one ground-truth box.
+pred_box = np.array([50, 40, 180, 200])
+true_box = np.array([60, 50, 170, 210])
+print("IoU example:", iou_xyxy(pred_box, true_box))
+
+# For real mAP use dataset YAML and validation:
+# metrics = model.val(data="coco8.yaml")
+# print(metrics.box.map, metrics.box.map50)
+''',
+    },
+    {
+        "id": 9,
+        "task": "Семантическая сегментация изображений",
+        "description": "Threshold segmentation, watershed, small U-Net and Dice/IoU metrics.",
+        "code": r'''
+# Task 9. Semantic segmentation: threshold, watershed, U-Net metrics.
+# pip install opencv-python scikit-image matplotlib tensorflow
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage import data
+from skimage.segmentation import watershed
+from skimage.feature import peak_local_max
+from scipy import ndimage as ndi
+
+
+gray = data.coins()
+gray = cv2.resize(gray, (256, 256), interpolation=cv2.INTER_AREA)
+blur = cv2.GaussianBlur(gray, (5, 5), 0)
+_, otsu = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+distance = ndi.distance_transform_edt(otsu)
+coords = peak_local_max(distance, footprint=np.ones((15, 15)), labels=otsu)
+markers = np.zeros(distance.shape, dtype=np.int32)
+markers[tuple(coords.T)] = np.arange(1, len(coords) + 1)
+labels = watershed(-distance, markers, mask=otsu.astype(bool))
+
+
+def dice_coef(y_true, y_pred, eps=1e-7):
+    y_true = y_true.astype(bool)
+    y_pred = y_pred.astype(bool)
+    return (2 * np.logical_and(y_true, y_pred).sum() + eps) / (y_true.sum() + y_pred.sum() + eps)
+
+
+def iou_mask(y_true, y_pred, eps=1e-7):
+    y_true = y_true.astype(bool)
+    y_pred = y_pred.astype(bool)
+    inter = np.logical_and(y_true, y_pred).sum()
+    union = np.logical_or(y_true, y_pred).sum()
+    return (inter + eps) / (union + eps)
+
+
+print("Example Dice self-check:", dice_coef(otsu > 0, otsu > 0))
+print("Example IoU self-check:", iou_mask(otsu > 0, otsu > 0))
+
+fig, ax = plt.subplots(1, 4, figsize=(14, 4))
+for a, (title, image) in zip(ax, [("gray", gray), ("otsu", otsu), ("distance", distance), ("watershed", labels)]):
+    a.imshow(image, cmap="gray" if title != "watershed" else "nipy_spectral")
+    a.set_title(title)
+    a.axis("off")
+plt.show()
+
+# Minimal U-Net skeleton for real image/mask tensors X_train, Y_train.
+import tensorflow as tf
+from tensorflow.keras import layers, Model
+
+
+def conv_block(x, filters):
+    x = layers.Conv2D(filters, 3, padding="same", activation="relu")(x)
+    x = layers.Conv2D(filters, 3, padding="same", activation="relu")(x)
+    return x
+
+
+def build_unet(input_shape=(128, 128, 3), num_classes=1):
+    inputs = layers.Input(input_shape)
+    c1 = conv_block(inputs, 32); p1 = layers.MaxPool2D()(c1)
+    c2 = conv_block(p1, 64); p2 = layers.MaxPool2D()(c2)
+    b = conv_block(p2, 128)
+    u2 = layers.UpSampling2D()(b); u2 = layers.Concatenate()([u2, c2]); c3 = conv_block(u2, 64)
+    u1 = layers.UpSampling2D()(c3); u1 = layers.Concatenate()([u1, c1]); c4 = conv_block(u1, 32)
+    outputs = layers.Conv2D(num_classes, 1, activation="sigmoid")(c4)
+    return Model(inputs, outputs)
+
+
+unet = build_unet()
+unet.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
+unet.summary()
+# unet.fit(X_train, Y_train, validation_data=(X_val, Y_val), epochs=10, batch_size=8)
+''',
+    },
+    {
+        "id": 10,
+        "task": "Сегментация медицинских изображений",
+        "description": "U-Net/Mask R-CNN direction, Dice/IoU, connected components and error analysis.",
+        "code": r'''
+# Task 10. Medical image segmentation template.
+# pip install tensorflow opencv-python scikit-image matplotlib
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage.measure import label, regionprops
+import tensorflow as tf
+from tensorflow.keras import layers, Model
+
+
+def dice_coef_np(y_true, y_pred, eps=1e-7):
+    y_true = y_true.astype(bool)
+    y_pred = y_pred.astype(bool)
+    return (2 * np.logical_and(y_true, y_pred).sum() + eps) / (y_true.sum() + y_pred.sum() + eps)
+
+
+def iou_np(y_true, y_pred, eps=1e-7):
+    y_true = y_true.astype(bool)
+    y_pred = y_pred.astype(bool)
+    inter = np.logical_and(y_true, y_pred).sum()
+    union = np.logical_or(y_true, y_pred).sum()
+    return (inter + eps) / (union + eps)
+
+
+def build_unet(input_shape=(256, 256, 1)):
+    def block(x, f):
+        x = layers.Conv2D(f, 3, padding="same", activation="relu")(x)
+        x = layers.BatchNormalization()(x)
+        x = layers.Conv2D(f, 3, padding="same", activation="relu")(x)
+        return x
+
+    inp = layers.Input(input_shape)
+    c1 = block(inp, 32); p1 = layers.MaxPooling2D()(c1)
+    c2 = block(p1, 64); p2 = layers.MaxPooling2D()(c2)
+    c3 = block(p2, 128); p3 = layers.MaxPooling2D()(c3)
+    b = block(p3, 256)
+    u3 = layers.UpSampling2D()(b); u3 = layers.Concatenate()([u3, c3]); d3 = block(u3, 128)
+    u2 = layers.UpSampling2D()(d3); u2 = layers.Concatenate()([u2, c2]); d2 = block(u2, 64)
+    u1 = layers.UpSampling2D()(d2); u1 = layers.Concatenate()([u1, c1]); d1 = block(u1, 32)
+    out = layers.Conv2D(1, 1, activation="sigmoid")(d1)
+    return Model(inp, out)
+
+
+model = build_unet()
+model.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss="binary_crossentropy")
+
+# Real data placeholders:
+# X_train: float32 images in [0, 1], shape (N, 256, 256, 1)
+# Y_train: binary masks, shape (N, 256, 256, 1)
+# model.fit(X_train, Y_train, validation_data=(X_val, Y_val), epochs=20, batch_size=4)
+
+
+def analyze_errors(image, true_mask, prob_mask, threshold=0.5):
+    pred = prob_mask > threshold
+    true = true_mask > 0
+    fp = np.logical_and(pred, ~true)
+    fn = np.logical_and(~pred, true)
+    print("Dice:", dice_coef_np(true, pred))
+    print("IoU:", iou_np(true, pred))
+    print("false positive pixels:", fp.sum())
+    print("false negative pixels:", fn.sum())
+
+    labeled = label(pred)
+    areas = [r.area for r in regionprops(labeled)]
+    print("predicted connected components:", len(areas), "areas:", areas[:10])
+
+    fig, ax = plt.subplots(1, 4, figsize=(14, 4))
+    for a, (title, arr, cmap) in zip(ax, [
+        ("image", image.squeeze(), "gray"),
+        ("true", true, "gray"),
+        ("pred", pred, "gray"),
+        ("errors: FP red, FN blue", np.dstack([fp, np.zeros_like(fp), fn]).astype(float), None),
+    ]):
+        a.imshow(arr, cmap=cmap)
+        a.set_title(title)
+        a.axis("off")
+    plt.show()
+
+
+# Example call after prediction:
+# probs = model.predict(X_val[:1])[0, ..., 0]
+# analyze_errors(X_val[0], Y_val[0, ..., 0], probs)
+
+# If instance segmentation is required, use Mask R-CNN from torchvision/detectron2/ultralytics
+# when annotations are object instances rather than one semantic mask.
+''',
+    },
+    {
+        "id": 11,
+        "task": "Классификация изображений с использованием Vision Transformer",
+        "description": "Fine-tune torchvision ViT and compare it with a small CNN.",
+        "code": r'''
+# Task 11. Vision Transformer classification and CNN comparison.
+# pip install torch torchvision
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader, Subset
+from torchvision import datasets, transforms, models
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+weights = models.ViT_B_16_Weights.DEFAULT
+vit_tf = weights.transforms()
+train_ds = datasets.CIFAR10(root="data", train=True, download=True, transform=vit_tf)
+test_ds = datasets.CIFAR10(root="data", train=False, download=True, transform=vit_tf)
+
+# Keep a small subset for an exam demo; remove Subset for full training.
+train_ds = Subset(train_ds, range(2000))
+test_ds = Subset(test_ds, range(500))
+train_loader = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=2)
+test_loader = DataLoader(test_ds, batch_size=64, shuffle=False, num_workers=2)
+
+
+def train_one(model, epochs=1, lr=1e-4):
+    model.to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=lr)
+    for epoch in range(epochs):
+        model.train()
+        for x, y in train_loader:
+            x, y = x.to(device), y.to(device)
+            logits = model(x)
+            loss = criterion(logits, y)
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+    model.eval()
+    correct, total = 0, 0
+    with torch.no_grad():
+        for x, y in test_loader:
+            x, y = x.to(device), y.to(device)
+            pred = model(x).argmax(1)
+            correct += (pred == y).sum().item()
+            total += y.numel()
+    return correct / total
+
+
+vit = models.vit_b_16(weights=weights)
+for p in vit.parameters():
+    p.requires_grad = False
+vit.heads.head = nn.Linear(vit.heads.head.in_features, 10)
+vit_acc = train_one(vit, epochs=1, lr=1e-3)
+print("ViT transfer acc:", vit_acc)
+
+
+class SmallCNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)),
+            nn.Flatten(), nn.Linear(64, 10)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+cnn_acc = train_one(SmallCNN(), epochs=1, lr=1e-3)
+print("Small CNN acc:", cnn_acc)
+
+print("Comparison notes: ViT has global self-attention and benefits from pretraining; "
+      "CNN has locality/translation bias and is often cheaper on small data.")
+''',
+    },
+    {
+        "id": 12,
+        "task": "Генерация текстовых описаний изображений",
+        "description": "CNN encoder + Transformer decoder skeleton and BLEU evaluation.",
+        "code": r'''
+# Task 12. Image captioning: CNN encoder + Transformer decoder skeleton.
+# pip install torch torchvision nltk pillow
+
+import math
+import torch
+from torch import nn
+from torchvision import models
+from nltk.translate.bleu_score import corpus_bleu
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+class CNNEncoder(nn.Module):
+    def __init__(self, embed_dim=256):
+        super().__init__()
+        weights = models.ResNet18_Weights.DEFAULT
+        resnet = models.resnet18(weights=weights)
+        self.backbone = nn.Sequential(*list(resnet.children())[:-2])
+        self.proj = nn.Conv2d(512, embed_dim, kernel_size=1)
+
+    def forward(self, images):
+        feats = self.backbone(images)          # B, 512, H/32, W/32
+        feats = self.proj(feats)               # B, D, h, w
+        tokens = feats.flatten(2).permute(2, 0, 1)  # S, B, D
+        return tokens
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, max_len=256):
+        super().__init__()
+        pe = torch.zeros(max_len, d_model)
+        pos = torch.arange(0, max_len).unsqueeze(1)
+        div = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(pos * div)
+        pe[:, 1::2] = torch.cos(pos * div)
+        self.register_buffer("pe", pe.unsqueeze(1))
+
+    def forward(self, x):
+        return x + self.pe[: x.size(0)]
+
+
+class CaptionModel(nn.Module):
+    def __init__(self, vocab_size, embed_dim=256, nhead=8, layers=3, pad_id=0):
+        super().__init__()
+        self.encoder = CNNEncoder(embed_dim)
+        self.embed = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_id)
+        self.pos = PositionalEncoding(embed_dim)
+        dec_layer = nn.TransformerDecoderLayer(embed_dim, nhead, dim_feedforward=512)
+        self.decoder = nn.TransformerDecoder(dec_layer, num_layers=layers)
+        self.out = nn.Linear(embed_dim, vocab_size)
+        self.pad_id = pad_id
+
+    def forward(self, images, captions_in):
+        memory = self.encoder(images)
+        tgt = self.pos(self.embed(captions_in).transpose(0, 1))
+        seq_len = tgt.size(0)
+        causal_mask = nn.Transformer.generate_square_subsequent_mask(seq_len).to(tgt.device)
+        decoded = self.decoder(tgt, memory, tgt_mask=causal_mask)
+        return self.out(decoded).transpose(0, 1)
+
+
+# Training idea:
+# captions_in  = [BOS, w1, w2, ...]
+# captions_out = [w1,  w2, ..., EOS]
+# logits = model(images, captions_in)
+# loss = CrossEntropyLoss(ignore_index=pad_id)(logits.reshape(-1, vocab), captions_out.reshape(-1))
+
+
+def evaluate_bleu(references, hypotheses):
+    # references: list[list[list[str]]], e.g. [[["a", "cat", "sits"]]]
+    # hypotheses: list[list[str]], e.g. [["a", "cat", "sits"]]
+    return corpus_bleu(references, hypotheses)
+
+
+refs = [[["a", "cat", "on", "a", "sofa"]], [["a", "dog", "runs"]]]
+hyps = [["a", "cat", "on", "sofa"], ["a", "dog", "runs"]]
+print("BLEU example:", evaluate_bleu(refs, hyps))
+''',
+    },
+    {
+        "id": 13,
+        "task": "Ручная реализация 2D-свёртки и фильтрации",
+        "description": "NumPy convolution with stride, padding, several kernels, comparison with cv2.filter2D and timing.",
+        "code": r'''
+# Task 13. Manual 2D convolution and filters.
+# pip install opencv-python matplotlib scikit-image
+
+import time
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage import data
+
+
+def conv2d_numpy(image, kernel, stride=1, padding=0):
+    image = image.astype(np.float32)
+    kernel = np.asarray(kernel, dtype=np.float32)
+    if padding:
+        image = np.pad(image, ((padding, padding), (padding, padding)), mode="constant")
+    kh, kw = kernel.shape
+    oh = (image.shape[0] - kh) // stride + 1
+    ow = (image.shape[1] - kw) // stride + 1
+    out = np.zeros((oh, ow), dtype=np.float32)
+    flipped = np.flipud(np.fliplr(kernel))
+    for y in range(oh):
+        for x in range(ow):
+            patch = image[y * stride:y * stride + kh, x * stride:x * stride + kw]
+            out[y, x] = np.sum(patch * flipped)
+    return out
+
+
+gray = data.camera().astype(np.float32)
+gray = cv2.resize(gray, (256, 256), interpolation=cv2.INTER_AREA)
+
+kernels = {
+    "blur": np.ones((3, 3), dtype=np.float32) / 9,
+    "sharpen": np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], dtype=np.float32),
+    "sobel_x": np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float32),
+    "sobel_y": np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float32),
+}
+
+fig, ax = plt.subplots(1, len(kernels) + 1, figsize=(14, 4))
+ax[0].imshow(gray, cmap="gray")
+ax[0].set_title("input")
+ax[0].axis("off")
+
+for i, (name, kernel) in enumerate(kernels.items(), start=1):
+    t0 = time.perf_counter()
+    manual = conv2d_numpy(gray, kernel, stride=1, padding=1)
+    t_manual = time.perf_counter() - t0
+
+    t0 = time.perf_counter()
+    cv = cv2.filter2D(gray, ddepth=-1, kernel=kernel)
+    t_cv = time.perf_counter() - t0
+
+    diff = np.mean(np.abs(manual - cv))
+    print(f"{name:8s} manual={t_manual:.4f}s, cv2={t_cv:.6f}s, mean_abs_diff={diff:.4f}")
+    ax[i].imshow(manual, cmap="gray")
+    ax[i].set_title(name)
+    ax[i].axis("off")
+
+plt.tight_layout()
+plt.show()
+''',
+    },
+    {
+        "id": 14,
+        "task": "Ручная реализация pooling и простого CNN-блока",
+        "description": "Manual max/average pooling, Conv -> ReLU -> Pool block and comparison with PyTorch.",
+        "code": r'''
+# Task 14. Manual pooling and simple CNN block.
+# pip install torch opencv-python scikit-image
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from skimage import data
+import cv2
+
+
+def pool2d_numpy(x, kernel_size=2, stride=2, mode="max"):
+    h, w = x.shape
+    oh = (h - kernel_size) // stride + 1
+    ow = (w - kernel_size) // stride + 1
+    out = np.zeros((oh, ow), dtype=x.dtype)
+    for y in range(oh):
+        for x0 in range(ow):
+            patch = x[y * stride:y * stride + kernel_size, x0 * stride:x0 * stride + kernel_size]
+            out[y, x0] = patch.max() if mode == "max" else patch.mean()
+    return out
+
+
+def conv2d_valid(x, kernel):
+    kh, kw = kernel.shape
+    oh, ow = x.shape[0] - kh + 1, x.shape[1] - kw + 1
+    out = np.zeros((oh, ow), dtype=np.float32)
+    for y in range(oh):
+        for x0 in range(ow):
+            out[y, x0] = np.sum(x[y:y+kh, x0:x0+kw] * kernel)
+    return out
+
+
+img = data.camera().astype(np.float32) / 255.0
+img = cv2.resize(img, (64, 64), interpolation=cv2.INTER_AREA)
+kernel = np.array([[1, 0, -1], [1, 0, -1], [1, 0, -1]], dtype=np.float32)
+
+conv = conv2d_valid(img, kernel)
+relu = np.maximum(conv, 0)
+max_pool = pool2d_numpy(relu, kernel_size=2, stride=2, mode="max")
+avg_pool = pool2d_numpy(relu, kernel_size=2, stride=2, mode="avg")
+
+print("input:", img.shape)
+print("after conv:", conv.shape)
+print("after relu:", relu.shape)
+print("after max pool:", max_pool.shape)
+print("after avg pool:", avg_pool.shape)
+
+# Compare pooling with PyTorch for the same input.
+t = torch.tensor(relu)[None, None, :, :]
+torch_max = F.max_pool2d(t, kernel_size=2, stride=2).squeeze().numpy()
+torch_avg = F.avg_pool2d(t, kernel_size=2, stride=2).squeeze().numpy()
+print("max pool diff:", np.abs(torch_max - max_pool).max())
+print("avg pool diff:", np.abs(torch_avg - avg_pool).max())
+''',
+    },
+    {
+        "id": 15,
+        "task": "Ручная реализация self-attention и позиционного кодирования",
+        "description": "Patchify, scaled dot-product attention, sinusoidal positional encoding and tensor shapes.",
+        "code": r'''
+# Task 15. Patchify, positional encoding and self-attention.
+# pip install torch
+
+import math
+import torch
+
+
+def patchify(images, patch_size=16):
+    # images: B, C, H, W
+    b, c, h, w = images.shape
+    assert h % patch_size == 0 and w % patch_size == 0
+    patches = images.unfold(2, patch_size, patch_size).unfold(3, patch_size, patch_size)
+    # B, C, nH, nW, p, p -> B, N, C*p*p
+    patches = patches.permute(0, 2, 3, 1, 4, 5).contiguous()
+    return patches.view(b, -1, c * patch_size * patch_size)
+
+
+def sinusoidal_positional_encoding(seq_len, dim, device="cpu"):
+    pe = torch.zeros(seq_len, dim, device=device)
+    pos = torch.arange(seq_len, device=device).unsqueeze(1)
+    div = torch.exp(torch.arange(0, dim, 2, device=device) * (-math.log(10000.0) / dim))
+    pe[:, 0::2] = torch.sin(pos * div)
+    pe[:, 1::2] = torch.cos(pos * div)
+    return pe
+
+
+def scaled_dot_product_attention(q, k, v, mask=None):
+    # q, k, v: B, heads, N, d
+    d = q.size(-1)
+    scores = q @ k.transpose(-2, -1) / math.sqrt(d)
+    if mask is not None:
+        scores = scores.masked_fill(mask == 0, float("-inf"))
+    attn = torch.softmax(scores, dim=-1)
+    out = attn @ v
+    return out, attn
+
+
+def split_heads(x, num_heads):
+    # x: B, N, D -> B, heads, N, D/heads
+    b, n, d = x.shape
+    assert d % num_heads == 0
+    return x.view(b, n, num_heads, d // num_heads).transpose(1, 2)
+
+
+B, C, H, W = 2, 3, 32, 32
+patch_size = 8
+embed_dim = 64
+num_heads = 4
+
+images = torch.randn(B, C, H, W)
+patches = patchify(images, patch_size=patch_size)
+proj = torch.nn.Linear(patches.size(-1), embed_dim)
+tokens = proj(patches)
+tokens = tokens + sinusoidal_positional_encoding(tokens.size(1), embed_dim, tokens.device)
+
+q_proj = torch.nn.Linear(embed_dim, embed_dim)
+k_proj = torch.nn.Linear(embed_dim, embed_dim)
+v_proj = torch.nn.Linear(embed_dim, embed_dim)
+
+q = split_heads(q_proj(tokens), num_heads)
+k = split_heads(k_proj(tokens), num_heads)
+v = split_heads(v_proj(tokens), num_heads)
+out, attn = scaled_dot_product_attention(q, k, v)
+
+print("images:", images.shape)
+print("patches:", patches.shape)
+print("tokens:", tokens.shape)
+print("Q/K/V:", q.shape, k.shape, v.shape)
+print("attention matrix:", attn.shape)
+print("attention output:", out.shape)
+
+# Compare with PyTorch MultiheadAttention on the same token shape.
+mha = torch.nn.MultiheadAttention(embed_dim=embed_dim, num_heads=num_heads, batch_first=True)
+lib_out, lib_attn = mha(tokens, tokens, tokens)
+print("library output:", lib_out.shape)
+print("library attention:", lib_attn.shape)
+''',
+    },
+]