User Tools

Site Tools


hacknite2026

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision
Previous revision
hacknite2026 [2026/11/16 15:30] – [Sigurnost Umjetne Inteligencije] mbunichacknite2026 [2026/11/16 20:44] (current) – [Sigurnost Umjetne Inteligencije] mbunic
Line 1589: Line 1589:
 [[mathscriptbuilder|CTF writeup - Math ScriptBuilder]] [[mathscriptbuilder|CTF writeup - Math ScriptBuilder]]
  
-======Flask Autocomplete====== 
  
-====Permission Security Check System Showcase====+======Sigurnost Umjetne Inteligencije====== 
 + 
 +====Unknown Image Detection Model 1==== 
 +<code> 
 +Trenirali smo model da prepoznaje nešto na slikama, 
 +ali smo zaboravili za što smo ga točno trenirali!  
 +Možete li otkriti za što je model treniran i dobiti flag? 
 + 
 +http://chal.platforma.hacknite.hr:14039/ 
 +</code> 
 + 
 +Uz zadatak je dan izvorni kod. 
 + 
 +Potrebno je uploadati PNG sliku traženog formata za koju će izračunata vrijednost ''visual structure score'' biti veća od ''7.5 / 10'' kako se slika ne bi odbacila. Nakon toga se slika šalje ''YOLO'' (__You Only Look Once__) modelu za detekciju i klasifikaciju objekata. Potrebno je da model detektira traženi objekt na slici s 90% sigurnosti. Problem je što nije poznato što model traži. 
 + 
 +Kako bi se riješio zadatak, može se koristiti automatizirana skripta koja iterativno generira slike te nad njima izvršava i skriptu za izračun vrijednosti vizualne strukture i pokreće model nad slikama. Tako se traži i otkriva koji oblici i atributi rezultiraju većim traženim vrijednostima. 
 + 
 +Druga tehnika je **gradient ascent**, gdje se optimiziraju vrijednosti piksela ulazne slike kako bi se maksimizirala aktivacija neurona modela.  
 + 
 +Na temelju funkcija neurona modela u odnosu na vrijednosti piksela, derivacijom se pronađe na koji način mijenjanje piksela slike najviše povećava aktivaciju neurona. Ovako se pronalazi gradijent, vektor koji pokazuje smjer najvećeg povećanja aktivacije neurona. 
 + 
 +Nakon toga se slika iterativno generira u skladu s pronađenim gradijentom, "penjući" se postupno prema najvišoj aktivaciji. 
 + 
 +Rezultirajuća slika je često mutna i nejasna pa se mogu koristiti dodatne tehnike pri generaciji slike kako bi bilo jasnije što je traženi objekt. 
 + 
 +Kako bi se smanjila pojava više detektiranih objekata, kojima se rubovi mogu preklapati i učiniti sliku nejasnijom, može se koristiti dodavanje prosjeka sigurnosti svih detekcija objekata kao negativnog doprinosa rezultatu pojedine iteracije uz maksimiziranje detekcije s najvećom sigurnošću. Time se postupak generacije slike usmjerava da generira samo jedan objekt za kojeg je sigurnost detekcije jako visoka, dok se ostale pojave sa slabijom detekcijom potiskuju. 
 + 
 +Također se mogu koristiti i tehnike **jittering** i **zamućivanje slike uz postupno smanjivanje intenziteta**. Slika se u svakoj iteraciji nasumično pomiče za nekoliko piksela te se na pomaknutoj slici računa gradijent. Tako se smanjuju artefakti, odnosno neželjene lokalizirane strukture na točno određenim dijelovima slike koje zbog svoje prostorne pozicije povećavaju sigurnost modela, a ne doprinose prepoznatljivosti traženog objekta (prepoznatljivosti u smislu da je čovjeku jasno što taj objekt predstavlja). Ovako se potiče da se sigurnost detekcije objekta temelji na njegovim karakteristikama bez obzira na njegovu poziciju na slici, odnosno smanjuje se osjetljivost na točan položaj pojedinih struktura na slici. 
 + 
 +Zamućivanje se snažnije koristi pri prvim iteracijama te se naknadno postupno smanjuje kako bi generirana slika u ranijim iteracijama bila mutnija, čime se potiče definiranje općenitog oblika objekta, a u kasnijim iteracijama postaje oštrija kako bi se jasnije vidjele granice traženog objekta nakon što je oblik već "ustanovljen". 
 + 
 +Bash skripta za postavljanje virtualnog okruženja: 
 + 
 +<code bash> 
 +#!/bin/bash 
 + 
 +set -e 
 + 
 +echo "==========================================" 
 +echo " YOLO environment setup" 
 +echo "==========================================" 
 + 
 +cd "$(dirname "$0")" 
 + 
 +if [ ! -d ".venv" ]; then 
 +    echo "Creating virtual environment..." 
 +    python3 -m venv .venv 
 +else 
 +    echo "Virtual environment already exists." 
 +fi 
 + 
 +source .venv/bin/activate 
 + 
 +echo "Using Python:" 
 +python --version 
 + 
 +echo 
 +echo "Upgrading pip..." 
 +python -m pip install --upgrade pip 
 + 
 +echo 
 +echo "Installing compatible packages..." 
 +python -m pip install --upgrade \ 
 +    "numpy<2" \ 
 +    ultralytics \ 
 +    opencv-python 
 + 
 +echo 
 +echo "Testing installation..." 
 +python -c " 
 +import numpy 
 +import cv2 
 +import ultralytics 
 + 
 +print('NumPy:', numpy.__version__) 
 +print('OpenCV:', cv2.__version__) 
 +print('Ultralytics:', ultralytics.__version__) 
 +print() 
 +print('Everything is installed correctly!') 
 +" 
 + 
 +echo 
 +echo "==========================================" 
 +echo " Setup complete!" 
 +echo "==========================================" 
 +</code> 
 + 
 + 
 +Python skripta za generiranje slike objekta koji je model treniran da prepoznaje: 
 + 
 +<code python> 
 +import torch 
 +import torch.nn as nn 
 +import torch.optim as optim 
 +import cv2 
 +import numpy as np 
 +from ultralytics import YOLO 
 + 
 +# 1. Load the model 
 +model_wrapper = YOLO('model.pt') 
 +model = model_wrapper.model 
 +model.eval() 
 + 
 +# 2. Parameters 
 +img_size = 416 
 +iterations = 2000  
 +input_image = torch.randn(1, 3, img_size, img_size).mul(0.1).add(0.5).requires_grad_(True) 
 +optimizer = optim.Adam([input_image], lr=0.05) 
 + 
 +def total_variation_loss(img): 
 +    tv_h = torch.pow(img[:,:,1:,:] - img[:,:,:-1,:], 2).sum() 
 +    tv_w = torch.pow(img[:,:,:,1:] - img[:,:,:,:-1], 2).sum() 
 +    return (tv_h + tv_w) 
 + 
 +for i in range(iterations): 
 +    optimizer.zero_grad() 
 +     
 +    # Forward pass 
 +    output = model(input_image)[0] 
 +     
 +    # --- 1.st class --- 
 +    scores = output[0, 4, :]  
 +    max_score = scores.max() 
 +    suppression_loss = scores.mean()  
 +     
 +    # Force stronger color (maximize diff between R,G,B) 
 +    r, g, b = input_image[0, 0], input_image[0, 1], input_image[0, 2] 
 +    color_variance = torch.var(torch.stack([r, g, b]), dim=0).mean() 
 +     
 +    # Primary Loss 
 +    # Subtract max_score (maximize it) and subtract color_variance (maximize it) 
 +    class_loss = -max_score + (suppression_loss * 0.5) 
 +    color_loss = -color_variance * 2.0 # "Force" the model to show its preferred color 
 +     
 +    # General Regularization 
 +    tv_loss = total_variation_loss(input_image) * 0.00001 
 +    l2_loss = torch.norm(input_image) * 0.001 
 +     
 +    total_loss = class_loss + color_loss + tv_loss + l2_loss 
 + 
 +    # Find gradient 
 +    total_loss.backward() 
 +    optimizer.step() 
 + 
 +    # --- DECAYED BLURRING --- 
 +    with torch.no_grad(): 
 +        input_image.clamp_(0, 1) 
 +         
 +        # Slower blur decay 
 +        if i < 600: k, s = 9, 4 
 +        elif i < 1100: k, s = 5, 2 
 +        elif i < 1600: k, s = 3, 1 
 +        else: k, s = 0, 0 
 +             
 +        if k > 0 and i % 10 == 0: 
 +            input_image.data = torch.nn.functional.avg_pool2d( 
 +                input_image.data, kernel_size=k, stride=1, padding=s 
 +            ) 
 + 
 +    if i % 100 == 0: 
 +        print(f"Iter {i} | Conf: {max_score.item():.4f} | Color Var: {color_variance.item():.4f}") 
 + 
 +# Output 
 +final_img = input_image.detach().squeeze().permute(1, 2, 0).numpy() 
 +final_img = (final_img * 255).astype(np.uint8) 
 +final_img = cv2.cvtColor(final_img, cv2.COLOR_RGB2BGR) 
 +cv2.imwrite("reverse_attempt.png", final_img) 
 +</code> 
 + 
 +Korištenjem opisane tehnike može se vidjeti da se na generiranoj slici pojavljuje zeleni krug. Ako generirana slika ne zadovoljava uvjet minimalne vrijednosti ''visual structure score'', može se ručno generirati slika zelenog kruga na crnoj pozadini i poslati, nakon čega je zadatak riješen. 
 + 
 +====Unknown Image Detection Model 2==== 
 +<code> 
 +Ne zna se što točno model klasificira kao "FLAG", možete li otkriti? 
 + 
 +Izvorni kod zadatka: https://ferhr-my.sharepoint.com/:u:/g/personal/mbunic_fer_hr/IQCMbl8Xz86XR6JI2z1WZiaGAcGEZYrk_2dEmQ37TZjpEXs?e=REAI3Y 
 + 
 +http://chal.platforma.hacknite.hr:14040/ 
 +</code> 
 + 
 +Uz zadatak je dan izvorni kod. 
 + 
 +Zadatak je vrlo sličan prošlom, razlika je što se ne koristi ''YOLO'' model, nego ResNet klasifikacijski model. Također, ovaj model ima 4 definirane klase, pri čemu se svaka slika svrstava u jednu od tih klasa, ovisno o tome koja za koju klasu je detektirana najviša sigurnost. 
 + 
 +Kako bi se zadatak riješio, potrebno je poslati sliku koja će se detektirati kao klasa ''FLAG'' s barem 90% sigurnosti. 
 + 
 +Jedna od prepreka je to što se na poslužitelj ne mogu slati slike direktno, nego se šalje JSON iz kojeg se na strani poslužitelja konstruira slika koja se potom daje modelu na klasifikaciju. Na stranici zadatka je dostupno sučelje za izradu slike koje automatski napravljenu sliku šalje kao JSON na server gdje se ista slika rekonstruira. 
 + 
 +U ovom zadatku traženi je objekt značajno kompleksniji od zelenog kruga, a slika koja bi se dobila s pomoću tehnike ''gradient ascent'' ne može se direktno poslati, nego je potrebno rekonstruirati njezin zapis u JSON formatu koji se šalje pa je potrebno dobro detektirati što model ''FLAG'' predstavlja. 
 + 
 +Skripta koja također koristi ''gradient ascent'' i dodatne tehnike za povećanje jasnoće generirane slike: 
 + 
 +<code python> 
 +#!/usr/bin/env python3 
 + 
 +import argparse 
 +from pathlib import Path 
 + 
 +import cv2 
 +import numpy as np 
 +import torch 
 +import torch.nn as nn 
 +import torch.nn.functional as F 
 +from torchvision import models 
 + 
 + 
 +# ============================================================ 
 +# Configuration 
 +# ============================================================ 
 + 
 +IMAGE_SIZE = 224 
 + 
 +ITERATIONS = 1250 
 +RESTARTS = 1 
 + 
 +LEARNING_RATE = 0.05 
 + 
 +# Regularization 
 +TV_WEIGHT = 0.00002 
 +L2_WEIGHT = 0.0005 
 +HIGH_FREQ_WEIGHT = 0.00005 
 + 
 +# How often to save progress 
 +SAVE_EVERY = 250 
 + 
 +OUTPUT_DIR = Path("reverse_output") 
 + 
 +DEVICE = torch.device("cpu") 
 + 
 + 
 +# ============================================================ 
 +# ImageNet normalization 
 +# defined in app.py (used by pretrained models, ResNet18 ) 
 +# ============================================================ 
 + 
 +IMAGENET_MEAN = torch.tensor( 
 +    [0.485, 0.456, 0.406] 
 +).view(1, 3, 1, 1) 
 + 
 +IMAGENET_STD = torch.tensor( 
 +    [0.229, 0.224, 0.225] 
 +).view(1, 3, 1, 1) 
 + 
 + 
 +# ============================================================ 
 +# Helpers 
 +# ============================================================ 
 + 
 +def normalize_image(x): 
 +    mean = IMAGENET_MEAN.to(x.device) 
 +    std = IMAGENET_STD.to(x.device) 
 + 
 +    return (x - mean) / std 
 + 
 + 
 +def total_variation_loss(img): 
 +    """ 
 +    -> neighboring pixels should be similar. 
 +    """ 
 + 
 +    vertical = img[:, :, 1:, :] - img[:, :, :-1, :] 
 +    horizontal = img[:, :, :, 1:] - img[:, :, :, :-1] 
 + 
 +    return ( 
 +        vertical.pow(2).mean() 
 +        + horizontal.pow(2).mean() 
 +    ) 
 + 
 + 
 +def high_frequency_loss(img): 
 +    """ 
 +    -> discourage very high-frequency patterns. 
 + 
 +    classifier can otherwise exploit tiny pixel-level 
 +    structures (imperceptible to humans). 
 +    """ 
 + 
 +    blurred = F.avg_pool2d( 
 +        img, 
 +        kernel_size=3, 
 +        stride=1, 
 +        padding=1, 
 +    ) 
 + 
 +    return (img - blurred).pow(2).mean() 
 + 
 + 
 +def random_jitter(img, amount=8): 
 + 
 +    shift_x = torch.randint( 
 +        -amount, 
 +        amount + 1, 
 +        (1,), 
 +        device=img.device, 
 +    ).item() 
 + 
 +    shift_y = torch.randint( 
 +        -amount, 
 +        amount + 1, 
 +        (1,), 
 +        device=img.device, 
 +    ).item() 
 + 
 +    return torch.roll( 
 +        img, 
 +        shifts=(shift_x, shift_y), 
 +        dims=(2, 3), 
 +    ) 
 + 
 + 
 +def save_image(tensor, path): 
 + 
 +    image = ( 
 +        tensor.detach() 
 +        .clamp(0, 1) 
 +        .squeeze(0) 
 +        .permute(1, 2, 0) 
 +        .cpu() 
 +        .numpy() 
 +    ) 
 + 
 +    image = (image * 255).astype(np.uint8) 
 + 
 +    # RGB -> BGR for OpenCV 
 +    image = cv2.cvtColor( 
 +        image, 
 +        cv2.COLOR_RGB2BGR, 
 +    ) 
 + 
 +    cv2.imwrite( 
 +        str(path), 
 +        image, 
 +    ) 
 + 
 + 
 +def load_model(checkpoint_path): 
 + 
 +    print("=" * 70) 
 +    print("Loading model") 
 +    print("=" * 70) 
 + 
 +    checkpoint = torch.load( 
 +        checkpoint_path, 
 +        map_location=DEVICE, 
 +    ) 
 + 
 +    class_names = None 
 + 
 +    if isinstance(checkpoint, dict): 
 +        if "model_state_dict" in checkpoint: 
 +            state_dict = checkpoint["model_state_dict"] 
 +            class_names = checkpoint.get("class_names") 
 + 
 +        else: 
 +            state_dict = checkpoint 
 +    else: 
 +        raise ValueError( 
 +            "Unsupported format." 
 +        ) 
 + 
 +    # -------------------------------------------------------- 
 +    # Determine output size from fc.weight 
 +    # -------------------------------------------------------- 
 + 
 +    fc_weight = state_dict.get("fc.weight") 
 + 
 +    if fc_weight is None: 
 +        raise ValueError( 
 +            "Could not find 'fc.weight'." 
 +        ) 
 + 
 +    num_classes = fc_weight.shape[0] 
 + 
 +    print(f"Classes          : {num_classes}") 
 + 
 +    if class_names: 
 +        print(f"Class names      : {class_names}") 
 + 
 + 
 +    model = models.resnet18( 
 +        weights=None 
 +    ) 
 + 
 +    model.fc = nn.Linear( 
 +        model.fc.in_features, 
 +        num_classes, 
 +    ) 
 + 
 +    model.load_state_dict( 
 +        state_dict 
 +    ) 
 + 
 +    model.eval() 
 +    model.to(DEVICE) 
 + 
 +    # Disable gradients for model parameters. 
 +    for parameter in model.parameters(): 
 +        parameter.requires_grad_(False) 
 + 
 +    print("Model loaded successfully.") 
 +    print() 
 + 
 +    return model, class_names 
 + 
 + 
 +# ============================================================ 
 +# Activation maximization 
 +# ============================================================ 
 + 
 +def optimize_class( 
 +    model, 
 +    class_index, 
 +    class_name, 
 +    output_dir, 
 +    model_name 
 +): 
 +    """ 
 +    -> maximize the selected class. 
 +    """ 
 + 
 +    print(model_name) 
 + 
 +    print() 
 +    print("=" * 70) 
 +    print( 
 +        f"Optimizing class {class_index}: {class_name}" 
 +    ) 
 +    print("=" * 70) 
 + 
 +    best_score = -float("inf") 
 +    best_image = None 
 + 
 +    for restart in range(1, RESTARTS + 1): 
 + 
 +        print() 
 +        print( 
 +            f"Restart {restart}/{RESTARTS}" 
 +        ) 
 + 
 +        # ---------------------------------------------------- 
 +        # Starting image 
 +        # 
 +        # Start close to gray rather than random noise. 
 +        # ---------------------------------------------------- 
 + 
 +        image = ( 
 +            torch.randn( 
 +                1, 
 +                3, 
 +                IMAGE_SIZE, 
 +                IMAGE_SIZE, 
 +                device=DEVICE, 
 +            ) 
 +            * 0.15 
 +            + 0.5 
 +        ) 
 + 
 +        image = image.clamp(0, 1) 
 + 
 +        image.requires_grad_(True) 
 + 
 +        optimizer = torch.optim.Adam( 
 +            [image], 
 +            lr=LEARNING_RATE, 
 +        ) 
 + 
 +        restart_best_score = -float("inf") 
 +        restart_best_image = None 
 + 
 +        for iteration in range( 
 +            1, 
 +            ITERATIONS + 1, 
 +        ): 
 + 
 +            optimizer.zero_grad() 
 + 
 +            # ------------------------------------------------ 
 +            #  jitter 
 +            # ------------------------------------------------ 
 + 
 +            jittered = random_jitter( 
 +                image, 
 +                amount=8, 
 +            ) 
 + 
 +            # ------------------------------------------------ 
 +            #  input normalization 
 +            # ------------------------------------------------ 
 + 
 +            model_input = normalize_image( 
 +                jittered 
 +            ) 
 + 
 +            # ------------------------------------------------ 
 +            # Forward pass 
 +            # ------------------------------------------------ 
 + 
 +            logits = model( 
 +                model_input 
 +            ) 
 + 
 +            target_logit = logits[ 
 +                0, 
 +                class_index, 
 +            ] 
 + 
 +            # Encourage differentiation relative to other classes. 
 +            other_logits = torch.cat( 
 +                [ 
 +                    logits[:, :class_index], 
 +                    logits[:, class_index + 1:], 
 +                ], 
 +                dim=1, 
 +            ) 
 + 
 +            if other_logits.shape[1] > 0: 
 +                competing_logit = other_logits.mean() 
 +                class_objective = ( 
 +                    target_logit 
 +                    - competing_logit 
 +                ) 
 +            else: 
 +                class_objective = target_logit 
 + 
 +            # ------------------------------------------------ 
 +            # Regularization 
 +            # ------------------------------------------------ 
 + 
 +            tv = total_variation_loss(image) 
 + 
 +            l2 = ( 
 +                image - 0.5 
 +            ).pow(2).mean() 
 + 
 +            hf = high_frequency_loss(image) 
 + 
 +            # ------------------------------------------------ 
 +            # Total loss 
 +            # ------------------------------------------------ 
 + 
 +            loss = ( 
 +                -class_objective 
 +                + TV_WEIGHT * tv 
 +                + L2_WEIGHT * l2 
 +                + HIGH_FREQ_WEIGHT * hf 
 +            ) 
 + 
 +            loss.backward() 
 + 
 +            optimizer.step() 
 + 
 +            # ------------------------------------------------ 
 +            # Keep valid pixel range 
 +            # ------------------------------------------------ 
 + 
 +            with torch.no_grad(): 
 +                image.clamp_(0, 1) 
 + 
 +            # ------------------------------------------------ 
 +            # Track best candidate 
 +            # ------------------------------------------------ 
 + 
 +            score = target_logit.item() 
 + 
 +            if score > restart_best_score: 
 +                restart_best_score = score 
 +                restart_best_image = image.detach().clone() 
 + 
 +            if score > best_score: 
 +                best_score = score 
 +                best_image = image.detach().clone() 
 + 
 +            # ------------------------------------------------ 
 +            # Progressive blur 
 +            # Strong early, gradually relax 
 +            # ------------------------------------------------ 
 + 
 +            if iteration % 10 == 0: 
 + 
 +                if iteration < 500: 
 +                    kernel = 9 
 +                elif iteration < 1000: 
 +                    kernel = 7 
 +                elif iteration < 1600: 
 +                    kernel = 5 
 +                elif iteration < 2100: 
 +                    kernel = 3 
 +                else: 
 +                    kernel = 0 
 + 
 +                if kernel > 0: 
 + 
 +                    with torch.no_grad(): 
 + 
 +                        padding = kernel // 2 
 + 
 +                        image.copy_( 
 +                            F.avg_pool2d( 
 +                                image, 
 +                                kernel_size=kernel, 
 +                                stride=1, 
 +                                padding=padding, 
 +                            ) 
 +                        ) 
 + 
 +            # ------------------------------------------------ 
 +            # Progress 
 +            # ------------------------------------------------ 
 + 
 +            if iteration == 1 or iteration % 100 == 0: 
 + 
 +                probabilities = torch.softmax( 
 +                    logits, 
 +                    dim=1, 
 +                ) 
 + 
 +                probability = probabilities[ 
 +                    0, 
 +                    class_index, 
 +                ].item() 
 + 
 +                print( 
 +                    f"\r" 
 +                    f"Iteration " 
 +                    f"{iteration:4d}/{ITERATIONS} | " 
 +                    f"Logit: {score:9.4f} | " 
 +                    f"Prob: {probability * 100:7.3f}% | " 
 +                    f"TV: {tv.item():.5f}", 
 +                    end="", 
 +                    flush=True, 
 +                ) 
 +            # ------------------------------------------------ 
 +            # Save intermediate  
 +            # ------------------------------------------------ 
 + 
 +            if iteration % SAVE_EVERY == 0: 
 + 
 +                path = ( 
 +                    output_dir 
 +                    / f"class_{class_index}" 
 +                    / f"restart_{restart}_{model_name}" 
 +                    / f"iteration_{iteration:04d}.png" 
 +                ) 
 + 
 +                path.parent.mkdir( 
 +                    parents=True, 
 +                    exist_ok=True, 
 +                ) 
 + 
 +                save_image( 
 +                    image, 
 +                    path, 
 +                ) 
 + 
 +        print() 
 + 
 +        # ---------------------------------------------------- 
 +        # Save best result 
 +        # ---------------------------------------------------- 
 + 
 +        restart_path = ( 
 +            output_dir 
 +            / f"class_{class_index}" 
 +            / f"restart_{restart}_best.png" 
 +        ) 
 + 
 +        save_image( 
 +            restart_best_image, 
 +            restart_path, 
 +        ) 
 + 
 +        print( 
 +            f"Restart best score: " 
 +            f"{restart_best_score:.4f}" 
 +        ) 
 + 
 +    # -------------------------------------------------------- 
 +    # Save global best 
 +    # -------------------------------------------------------- 
 + 
 +    final_path = ( 
 +        output_dir 
 +        / f"class_{class_index}_BEST.png" 
 +    ) 
 + 
 +    save_image( 
 +        best_image, 
 +        final_path, 
 +    ) 
 + 
 +    print() 
 +    print( 
 +        f"BEST activation: {best_score:.6f}" 
 +    ) 
 + 
 +    print( 
 +        f"Saved to: {final_path}" 
 +    ) 
 + 
 +    return best_image, best_score 
 + 
 +def main(): 
 + 
 +    parser = argparse.ArgumentParser( 
 +        description=( 
 +            "activation-maximized  gen images " 
 +            "ResNet classifier." 
 +        ) 
 +    ) 
 + 
 +    parser.add_argument( 
 +        "model", 
 +        help="Path to .pt model/checkpoint", 
 +    ) 
 + 
 +    parser.add_argument( 
 +        "--output", 
 +        default="reverse_output", 
 +        help="Output directory", 
 +    ) 
 + 
 +    args = parser.parse_args() 
 + 
 + 
 +    model_name = args.model.split(".")[0] 
 + 
 + 
 + 
 +    global OUTPUT_DIR 
 + 
 +    OUTPUT_DIR = Path(args.output) 
 +    OUTPUT_DIR.mkdir( 
 +        parents=True, 
 +        exist_ok=True, 
 +    ) 
 + 
 +    # -------------------------------------------------------- 
 +    # Load model 
 +    # -------------------------------------------------------- 
 + 
 +    model, class_names = load_model( 
 +        Path(args.model) 
 +    ) 
 + 
 +    # -------------------------------------------------------- 
 +    # class names 
 +    # -------------------------------------------------------- 
 + 
 +    num_classes = model.fc.out_features 
 + 
 +    if class_names is None: 
 + 
 +        class_names = [ 
 +            f"class_{i}" 
 +            for i in range(num_classes) 
 +        ] 
 + 
 +    # -------------------------------------------------------- 
 +    # Optimize every class 
 +    # -------------------------------------------------------- 
 + 
 +    results = [] 
 + 
 +    for class_index in range(num_classes): 
 + 
 +        name = class_names[class_index] 
 + 
 +        image, score = optimize_class( 
 +            model=model, 
 +            class_index=class_index, 
 +            class_name=name, 
 +            output_dir=OUTPUT_DIR, 
 +            model_name=model_name 
 +        ) 
 + 
 +        results.append( 
 +            ( 
 +                class_index, 
 +                name, 
 +                score, 
 +            ) 
 +        ) 
 + 
 +    # -------------------------------------------------------- 
 +    # Summary 
 +    # -------------------------------------------------------- 
 + 
 +    print() 
 +    print("=" * 70) 
 +    print("ACTIVATION MAXIMIZATION COMPLETE") 
 +    print("=" * 70) 
 + 
 +    for class_index, name, score in results: 
 + 
 +        print( 
 +            f"Class {class_index}: " 
 +            f"{name:<20} " 
 +            f"best logit = {score:.6f}" 
 +        ) 
 + 
 +    print() 
 +    print( 
 +        f"Images saved in: " 
 +        f"{OUTPUT_DIR.resolve()}" 
 +    ) 
 + 
 + 
 +if __name__ == "__main__": 
 +    main() 
 +</code> 
 + 
 + 
 +Pokretanjem ove skripte dobiva se uzorak nalik cvijetu ili leptiru koji se potom može nacrtati u dostupnom sučelju na stranici zadatka kako bi se riješio zadatak. 
 + 
 +====Unknown Image Detection Model 3==== 
 +<code> 
 +Imate na odabir dostupna 3 modela koji su svi vrlo slični,  
 +trenirani su s istom raspodjelom klasa i s istom namjenom,  
 +no s različitim varijacijama broja epoha i podataka za treniranje. 
 +Ako za bilo koji model zadovoljite traženu kombinaciju, riješili ste zadatak. 
 + 
 +Izvorni kod zadatka: https://ferhr-my.sharepoint.com/:u:/g/personal/mbunic_fer_hr/IQAzHGhDR_hDQIeVMT9pfBheASoHJ_BZoPcuD3a9kHYpGck?e=dpqoof 
 + 
 +http://chal.platforma.hacknite.hr:14041/ 
 +</code> 
 + 
 +Uz zadatak je dan izvorni kod. 
 + 
 +U ovom se zadatku koristi model ''MobileNetV3''. Model nad svakom slikom daje tri izlazne klasifikacije, odnosno model ima tri "glave". Za svaku sliku će biti utvrđene tri klase. 
 + 
 +Također, slike se ne šalju direktno, nego kao JSON objekt koji se rekonstruira na strani poslužitelja. Dostupno je sučelje na stranici zadatka za generiranje slike koja se potom prevedena u JSON šalje na poslužitelj. 
 + 
 +Kako bi se riješio zadatak, za poslanu sliku potrebno je dobiti točno određenu kombinaciju triju klasa, pri čemu sigurnost za svaku mora biti veća od 90%. 
 + 
 +Također je moguć odabir jednog od tri modela koji će klasificirati generiranu sliku korisnika. Naziv jednog modela je ''balanced'', a nazivi druga dva modela su ''overtrained''. 
 + 
 +Ovdje je problem što se, ako se radi ''gradient ascent'' nad sve tri klase istovremeno tijekom generiranja slike, povećavanje sigurnosti za jednu klasu može negativno utjecati na sigurnost druge klase. Npr. jedna klasa detektira oblik, a druga količinu određene boje na slici, tad će fokusiranje na jednu klasu smanjiti sigurnost za drugu. 
 + 
 +Kako bi se riješio zadatak, najbolje je prvo za svaku od triju ciljanih klasa generirati sliku koja ih najviše aktivira, a potom pokušati generirati sliku za sve tri istovremeno, kako bi se shvatilo što model točno detektira. Pritom se mogu analizirati sva tri dostupna modela. 
 + 
 +Analizom svih klasifikacija i klasa koje model detektira s pomoću tehnike ''gradient ascent'' može se ustanoviti da model ima tri klasifikacijske kategorije: kontrast, geometrijsko tijelo/oblik i uzorak. 
 + 
 +Tražena kombinacija je slika piramide s uzorkom sinusoidnih valova i visokim kontrastom između boja. 
 + 
 + 
 +Skripta za generiranje slika korištenjem tehnike ''gradient ascent'' nad svim trima klasifikacijama istovremeno: 
 + 
 +<code python> 
 +import argparse 
 +import json 
 +import random 
 +from pathlib import Path 
 + 
 +import cv2 
 +import numpy as np 
 +import torch 
 +import torch.nn as nn 
 +import torch.optim as optim 
 +import torch.nn.functional as F 
 +from torchvision import models, transforms 
 + 
 +# ============================================================ 
 +# 1. Command Line & Configuration 
 +# ============================================================ 
 + 
 +parser = argparse.ArgumentParser(description="Gradascent.") 
 +parser.add_argument("model_path", help="Path to checkpoint/model file") 
 +parser.add_argument( 
 +    "combo",  
 +    nargs="?",  
 +    default="030",  
 +    help="Chose combo classes combo" 
 +) 
 + 
 +args = parser.parse_args() 
 + 
 + 
 + 
 +combo = int(args.combo) 
 + 
 +MODEL_PATH = args.model_path 
 + 
 +IMAGE_SIZE = 224 
 +ITERATIONS = 1500 
 +LEARNING_RATE = 0.05 
 +DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
 + 
 +SHAPE_CLASSES = ["Pyramid3", "Cube", "Cone", "Sphere"] 
 +PATTERN_CLASSES = ["Solid", "SineWaves", "ZigZag", "StraightLines"] 
 +CONTRAST_CLASSES = ["HighContrast", "LowContrast"] 
 + 
 + 
 +# quickfix 
 +TARGET_SHAPE =    combo // 100     
 +TARGET_PATTERN =    (combo % 100 - combo % 10) // 10     
 +TARGET_CONTRAST =   combo %10      
 + 
 + 
 +print([TARGET_CONTRAST, TARGET_PATTERN, TARGET_SHAPE][::-1]) 
 +print(SHAPE_CLASSES[TARGET_SHAPE], PATTERN_CLASSES[TARGET_PATTERN], CONTRAST_CLASSES[TARGET_CONTRAST]) 
 + 
 + 
 + 
 +MODEL_NAME = Path(MODEL_PATH).stem 
 +TARGET_NAME = f"{SHAPE_CLASSES[TARGET_SHAPE]}_{PATTERN_CLASSES[TARGET_PATTERN]}_{CONTRAST_CLASSES[TARGET_CONTRAST]}" 
 +RUN_DIR = Path("solutions") / TARGET_NAME / MODEL_NAME 
 +RUN_DIR.mkdir(parents=True, exist_ok=True) 
 + 
 +# ============================================================ 
 +# Spatial Priors (single, centered object) 
 +# ============================================================ 
 + 
 +# 2D distance map from the center 
 +Y, X = torch.meshgrid(torch.arange(IMAGE_SIZE), torch.arange(IMAGE_SIZE), indexing='ij') 
 +dist_from_center = torch.sqrt((X - IMAGE_SIZE//2)**2 + (Y - IMAGE_SIZE//2)**2).float().to(DEVICE) 
 + 
 +FG_MASK = torch.clamp(1.0 - (dist_from_center - 50) / 40, 0.0, 1.0).view(1, 1, IMAGE_SIZE, IMAGE_SIZE) 
 +BG_MASK = 1.0 - FG_MASK  
 + 
 +class MathVisionNet(nn.Module): 
 +    def __init__(self): 
 +        super().__init__() 
 +        self.backbone = models.mobilenet_v3_small(weights=models.MobileNet_V3_Small_Weights.DEFAULT).features 
 +        self.pool = nn.AdaptiveAvgPool2d(1) 
 +        self.dropout = nn.Dropout(0.2) 
 +        self.head_shape = nn.Linear(576, len(SHAPE_CLASSES)) 
 +        self.head_pattern = nn.Linear(576, len(PATTERN_CLASSES)) 
 +        self.head_contrast = nn.Linear(576, len(CONTRAST_CLASSES)) 
 + 
 +    def forward(self, x): 
 +        x = self.dropout(torch.flatten(self.pool(self.backbone(x)), 1)) 
 +        return self.head_shape(x), self.head_pattern(x), self.head_contrast(x) 
 + 
 +normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) 
 + 
 +def total_variation_loss_L1(img): 
 +    """preserve HARD EDGES and flat colors""" 
 +    tv_h = torch.abs(img[:, :, 1:, :] - img[:, :, :-1, :]).sum() 
 +    tv_w = torch.abs(img[:, :, :, 1:] - img[:, :, :, :-1]).sum() 
 +    return tv_h + tv_w 
 + 
 +def canvas_to_bgr(canvas): 
 +    img = (canvas.detach().squeeze(0).permute(1, 2, 0).cpu().numpy().clip(0.0, 1.0) * 255.0).astype(np.uint8) 
 +    return cv2.cvtColor(img, cv2.COLOR_RGB2BGR) 
 + 
 +# ============================================================ 
 +# Loop 
 +# ============================================================ 
 + 
 +def solve(): 
 +    print("=" * 72 + "\n Single-Object Hard-Edge Optimization\n" + "=" * 72) 
 +    model = MathVisionNet().to(DEVICE) 
 +    checkpoint = torch.load(MODEL_PATH, map_location=DEVICE) 
 +     
 +    state_dict = checkpoint["model_state_dict"] if "model_state_dict" in checkpoint else checkpoint 
 +    model.load_state_dict(state_dict, strict=True) 
 +    model.eval() 
 +    for param in model.parameters(): param.requires_grad_(False) 
 + 
 +    # Initialize canvas with neutral gray + slight noise 
 +    canvas = (torch.randn(1, 3, IMAGE_SIZE, IMAGE_SIZE, device=DEVICE) * 0.05 + 0.5).requires_grad_(True) 
 +    optimizer = optim.Adam([canvas], lr=LEARNING_RATE) 
 + 
 +    best_shape, best_pattern, best_contrast, best_overall = 0.0, 0.0, 0.0, 0.0 
 +    best_imgs = {"shape": None, "pattern": None, "contrast": None, "overall": None} 
 +    best_iters = {"shape": 0, "pattern": 0, "contrast": 0, "overall": 0} 
 +    last_metrics = {} 
 + 
 +    target_s_tensor = torch.tensor([TARGET_SHAPE], device=DEVICE) 
 +    target_p_tensor = torch.tensor([TARGET_PATTERN], device=DEVICE) 
 +    target_c_tensor = torch.tensor([TARGET_CONTRAST], device=DEVICE) 
 + 
 +    for i in range(ITERATIONS): 
 +        optimizer.zero_grad() 
 + 
 +        # Force background to be a solid flat color 
 +        bg_mean = (canvas * BG_MASK).sum(dim=(2,3), keepdim=True) / (BG_MASK.sum() + 1e-5) 
 +        fg_mean = (canvas * FG_MASK).sum(dim=(2,3), keepdim=True) / (FG_MASK.sum() + 1e-5) 
 +         
 +        bg_variance_loss = torch.mean(BG_MASK * torch.abs(canvas - bg_mean)) 
 +         
 +        # Maximize RGB distance between Foreground and Background 
 +        fg_bg_dist_loss = -torch.norm(fg_mean - bg_mean) 
 + 
 +        # ---Transformation Robustness --- 
 +        scale_factor = random.uniform(0.9, 1.1) 
 +        new_size = int(IMAGE_SIZE * scale_factor) 
 +         
 +        transformed = F.interpolate(canvas, size=(new_size, new_size), mode='bilinear', align_corners=False) 
 +        ox, oy = random.randint(-4, 4), random.randint(-4, 4) 
 +        transformed = torch.roll(transformed, shifts=(ox, oy), dims=(2, 3)) 
 +         
 +        if new_size > IMAGE_SIZE: 
 +            start = (new_size - IMAGE_SIZE) // 2 
 +            transformed = transformed[:, :, start:start+IMAGE_SIZE, start:start+IMAGE_SIZE] 
 +        elif new_size < IMAGE_SIZE: 
 +            pad = (IMAGE_SIZE - new_size) // 2 
 +            transformed = F.pad(transformed, (pad, IMAGE_SIZE - new_size - pad, pad, IMAGE_SIZE - new_size - pad), mode='reflect') 
 + 
 +        # --- Forward Pass --- 
 +        out_shape, out_pattern, out_contrast = model(normalize(transformed)) 
 + 
 +        loss_shape = F.cross_entropy(out_shape, target_s_tensor) 
 +        loss_pattern = F.cross_entropy(out_pattern, target_p_tensor) 
 +        loss_contrast = F.cross_entropy(out_contrast, target_c_tensor) 
 + 
 +        # --- Total Loss  --- 
 +        # Color diversity to foreground mask 
 +        color_var = torch.var(torch.stack([canvas[0, 0]*FG_MASK[0,0], canvas[0, 1]*FG_MASK[0,0], canvas[0, 2]*FG_MASK[0,0]]), dim=0).mean() 
 +         
 +        total_loss = ( 
 +            loss_shape  
 +            + loss_pattern  
 +            + loss_contrast  
 +            + (bg_variance_loss * 15.0)          # Enforce flat background 
 +            + (fg_bg_dist_loss * 2.0)            # Push FG/BG colors apart 
 +            - (color_var * 5.0)                  # Shape detail 
 +            + (total_variation_loss_L1(transformed) * 0.005) # L1 TV for HARD EDGES 
 +        ) 
 +         
 +        total_loss.backward() 
 +        optimizer.step() 
 + 
 +        # --- Reduced Blurring --- 
 +        with torch.no_grad(): 
 +            canvas.clamp_(0.0, 1.0) 
 +             
 +            if i < 400: k, s = 5, 2 
 +            elif i < 800: k, s = 3, 1 
 +            else: k, s = 0, 0 
 +             
 +            if k > 0 and i % 20 == 0:  
 +                canvas.copy_(F.avg_pool2d(canvas, kernel_size=k, stride=1, padding=s)) 
 + 
 +            # --- Evaluation Pass --- 
 +            c_shape, c_pattern, c_contrast = model(normalize(canvas)) 
 +             
 +            prob_s = torch.softmax(c_shape, dim=1)[0, TARGET_SHAPE].item() 
 +            prob_p = torch.softmax(c_pattern, dim=1)[0, TARGET_PATTERN].item() 
 +            prob_c = torch.softmax(c_contrast, dim=1)[0, TARGET_CONTRAST].item() 
 +            prob_overall = (prob_s * prob_p * prob_c) ** (1.0 / 3.0) 
 + 
 +            current_img = canvas_to_bgr(canvas) 
 +            last_metrics = {"S": prob_s, "P": prob_p, "C": prob_c, "O": prob_overall,  
 +                            "Pred_S": c_shape.argmax(1).item(), "Pred_P": c_pattern.argmax(1).item(), "Pred_C": c_contrast.argmax(1).item()} 
 + 
 +            # Track Bests 
 +            if prob_s > best_shape: best_shape, best_iters["shape"], best_imgs["shape"] = prob_s, i, current_img.copy() 
 +            if prob_p > best_pattern: best_pattern, best_iters["pattern"], best_imgs["pattern"] = prob_p, i, current_img.copy() 
 +            if prob_c > best_contrast: best_contrast, best_iters["contrast"], best_imgs["contrast"] = prob_c, i, current_img.copy() 
 +            if prob_overall > best_overall: best_overall, best_iters["overall"], best_imgs["overall"] = prob_overall, i, current_img.copy() 
 + 
 +        if i % 100 == 0 or i == ITERATIONS - 1: 
 +            print(f"Iter {i:4d}/{ITERATIONS} | Shape: {prob_s*100:5.1f}% | Pat: {prob_p*100:5.1f}% | Con: {prob_c*100:5.1f}% | Overall: {prob_overall*100:5.1f}%") 
 + 
 +    # ============================================================ 
 +    # 7. Save Outputs 
 +    # ============================================================ 
 +    print("\n" + "=" * 72 + "\n Optimization Complete! Saving Files...\n" + "=" * 72) 
 +     
 +    cv2.imwrite(str(RUN_DIR / "best_shape.png"), best_imgs["shape"]) 
 +    cv2.imwrite(str(RUN_DIR / "best_pattern.png"), best_imgs["pattern"]) 
 +    cv2.imwrite(str(RUN_DIR / "best_contrast.png"), best_imgs["contrast"]) 
 +    cv2.imwrite(str(RUN_DIR / "best_overall.png"), best_imgs["overall"]) 
 +    cv2.imwrite(str(RUN_DIR / "last.png"), current_img) 
 + 
 +    results = { 
 +        "model": str(MODEL_PATH), 
 +        "iterations": ITERATIONS, 
 +        "targets": {"shape": SHAPE_CLASSES[TARGET_SHAPE], "pattern": PATTERN_CLASSES[TARGET_PATTERN], "contrast": CONTRAST_CLASSES[TARGET_CONTRAST]}, 
 +        "best_scores": { 
 +            "shape": {"iter": best_iters["shape"], "prob": best_shape * 100}, 
 +            "pattern": {"iter": best_iters["pattern"], "prob": best_pattern * 100}, 
 +            "contrast": {"iter": best_iters["contrast"], "prob": best_contrast * 100}, 
 +            "overall": {"iter": best_iters["overall"], "prob": best_overall * 100} 
 +        }, 
 +        "last_iteration_predictions": { 
 +            "shape_pred": SHAPE_CLASSES[last_metrics["Pred_S"]], 
 +            "pattern_pred": PATTERN_CLASSES[last_metrics["Pred_P"]], 
 +            "contrast_pred": CONTRAST_CLASSES[last_metrics["Pred_C"]] 
 +        } 
 +    } 
 + 
 +    with open(RUN_DIR / "results.json", "w") as f: 
 +        json.dump(results, f, indent=4) 
 + 
 +    print(f" Best Shape:    {best_shape * 100:6.2f}% (Iter {best_iters['shape']})") 
 +    print(f" Best Pattern:  {best_pattern * 100:6.2f}% (Iter {best_iters['pattern']})") 
 +    print(f" Best Overall:  {best_overall * 100:6.2f}% (Iter {best_iters['overall']})") 
 +    print(f"\nFiles saved to: {RUN_DIR.resolve()}") 
 + 
 +if __name__ == "__main__": 
 +    solve() 
 +</code> 
 + 
 + 
 + 
 +JSON koji definira opisanu sliku koju će ''balanced'' model detektirati kao traženu kombinaciju i vratiti flag: 
 + 
 +<code JSON> 
 +{"target_model":"modelBalanced.pt", 
 +"background":[240,240,240], 
 +"objects":[ 
 +    {"type":"polygon","points":[[69,176],[134,34],[201,169],[68,178],[68,178]], 
 +    "color":[100,100,100], 
 +    "gradient":false, 
 +    "gradStart":[0,0], 
 +    "gradEnd":[224,224], 
 +    "colorStart":[255,255,255], 
 +    "colorEnd":[0,0,0]}, 
 +    {"type":"polygon","points":[[67,178],[50,118],[133,34],[133,34]], 
 +    "color":[100,100,100], 
 +    "gradient":false, 
 +    "gradStart":[0,0], 
 +    "gradEnd":[224,224], 
 +    "colorStart":[255,255,255], 
 +    "colorEnd":[0,0,0]}, 
 +    {"type":"path","points":[[141,173],[136,83]], 
 +    "color":[255,0,0], 
 +    "thickness":2, 
 +    "amplitude":100, 
 +    "frequency":20}, 
 +    {"type":"path","points":[[134,33],[67,179]], 
 +    "color":[0,0,0],"thickness":2,"amplitude":100, 
 +    "frequency":20}, 
 +    {"type":"path","points":[[134,34],[50,118],[67,179],[135,33],[201,170],[67,179]], 
 +    "color":[0,0,0],"thickness":2,"amplitude":0,"frequency":0}]} 
 +</code> 
 + 
 + 
 + 
 +====Flask Autocomplete====
  
 Rješenje zadatka dostupno je ovdje: Rješenje zadatka dostupno je ovdje:
hacknite2026.1794843052.txt.gz · Last modified: 2026/11/16 15:30 by mbunic

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki