AI-Red-Teaming-CSCD94/sparsity/elasticnet.ipynb

In [1]:

# no torch no example womp womp
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from pathlib import Path
import warnings
warnings.filterwarnings('ignore')

# Import utilities from HTB Evasion Library
from htb_ai_library.utils import (
    set_reproducibility,
    save_model,
    load_model,
    HTB_GREEN,
    NODE_BLACK,
    HACKER_GREY,
    WHITE,
    AZURE,
    NUGGET_YELLOW,
    MALWARE_RED,
    VIVID_PURPLE,
    AQUAMARINE,
)
from htb_ai_library.data import get_mnist_loaders
from htb_ai_library.models import MNISTClassifierWithDropout
from htb_ai_library.training import train_model, evaluate_accuracy
from htb_ai_library.visualization import use_htb_style

# Apply HTB theme globally to all plots
use_htb_style()

# Set reproducibility
set_reproducibility(1337)

# Configure device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")
if device.type == "cuda":
    print(f"GPU: {torch.cuda.get_device_name(0)}")

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
Cell In[1], line 5
      3 import torch.nn.functional as F
      4 from torch.utils.data import DataLoader
----> 5 from torchvision import datasets, transforms
      6 import numpy as np
      7 import matplotlib.pyplot as plt

File ~/.conda/envs/ai/lib/python3.11/site-packages/torchvision/__init__.py:10
      7 # Don't re-order these, we need to load the _C extension (done when importing
      8 # .extensions) before entering _meta_registrations.
      9 from .extension import _HAS_OPS  # usort:skip
---> 10 from torchvision import _meta_registrations, datasets, io, models, ops, transforms, utils  # usort:skip
     12 try:
     13     from .version import __version__  # noqa: F401

File ~/.conda/envs/ai/lib/python3.11/site-packages/torchvision/_meta_registrations.py:163
    153     torch._check(
    154         grad.dtype == rois.dtype,
    155         lambda: (
   (...)    158         ),
    159     )
    160     return grad.new_empty((batch_size, channels, height, width))
--> 163 @torch.library.register_fake("torchvision::nms")
    164 def meta_nms(dets, scores, iou_threshold):
    165     torch._check(dets.dim() == 2, lambda: f"boxes should be a 2d tensor, got {dets.dim()}D")
    166     torch._check(dets.size(1) == 4, lambda: f"boxes should have 4 elements in dimension 1, got {dets.size(1)}")

File ~/.conda/envs/ai/lib/python3.11/site-packages/torch/library.py:1073, in register_fake.<locals>.register(func)
   1071 else:
   1072     use_lib = lib
-> 1073 use_lib._register_fake(
   1074     op_name, func, _stacklevel=stacklevel + 1, allow_override=allow_override
   1075 )
   1076 return func

File ~/.conda/envs/ai/lib/python3.11/site-packages/torch/library.py:203, in Library._register_fake(self, op_name, fn, _stacklevel, allow_override)
    200 else:
    201     func_to_register = fn
--> 203 handle = entry.fake_impl.register(
    204     func_to_register, source, lib=self, allow_override=allow_override
    205 )
    206 self._registration_handles.append(handle)

File ~/.conda/envs/ai/lib/python3.11/site-packages/torch/_library/fake_impl.py:50, in FakeImplHolder.register(self, func, source, lib, allow_override)
     44 if self.kernel is not None:
     45     raise RuntimeError(
     46         f"register_fake(...): the operator {self.qualname} "
     47         f"already has an fake impl registered at "
     48         f"{self.kernel.source}."
     49     )
---> 50 if torch._C._dispatch_has_kernel_for_dispatch_key(self.qualname, "Meta"):
     51     raise RuntimeError(
     52         f"register_fake(...): the operator {self.qualname} "
     53         f"already has an DispatchKey::Meta implementation via a "
   (...)     56         f"register_fake."
     57     )
     59 if torch._C._dispatch_has_kernel_for_dispatch_key(
     60     self.qualname, "CompositeImplicitAutograd"
     61 ):

RuntimeError: operator torchvision::nms does not exist

In [2]:

# Get data loaders using library function
train_loader, test_loader = get_mnist_loaders(batch_size=128)
print(f"Training samples: {len(train_loader.dataset)}")
print(f"Test samples: {len(test_loader.dataset)}")

# Create output directory for saving models and results
output_dir = Path("output")
output_dir.mkdir(exist_ok=True)

# Define model checkpoint path in output directory
model_path = output_dir / "mnist_target.pth"

# Initialize model using MNISTClassifierWithDropout from library
model = MNISTClassifierWithDropout(num_classes=10).to(device)

# Check if trained model exists, otherwise train from scratch
if model_path.exists():
    print(f"\nLoading existing model from {model_path}")
    model = load_model(model, model_path, device)
else:
    print(f"\nNo existing model found. Training new model...")
    model = train_model(model, train_loader, test_loader, epochs=5, device=device)
    print(f"Saving trained model to {model_path}")
    save_model(model, model_path)

# Evaluate the trained model
accuracy = evaluate_accuracy(model, test_loader, device)
print(f"\nTest accuracy: {accuracy:.2f}%")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[2], line 2
      1 # Get data loaders using library function
----> 2 train_loader, test_loader = get_mnist_loaders(batch_size=128)
      3 print(f"Training samples: {len(train_loader.dataset)}")
      4 print(f"Test samples: {len(test_loader.dataset)}")

NameError: name 'get_mnist_loaders' is not defined

In [ ]: