Examples

import torch
import torch.nn as nn
import torch.nn.functional as F
from arc import ArcV2

model = nn.Linear(10, 5)
optimizer = torch.optim.Adam(model.parameters())
arc = ArcV2.auto(model, optimizer)

for epoch in range(100):
    for batch in range(10):
        x = torch.randn(32, 10)
        y = torch.randint(0, 5, (32,))
        optimizer.zero_grad()
        loss = F.cross_entropy(model(x), y)
        loss.backward()
        optimizer.step()
        arc.step(loss)
    arc.end_epoch(epoch)

from arc import ArcV2

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2)
        self.fc = nn.Linear(64 * 8 * 8, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        return self.fc(x.view(x.size(0), -1))

model = SimpleCNN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
arc = ArcV2.auto(model, optimizer)

for epoch in range(50):
    for images, labels in train_loader:
        optimizer.zero_grad()
        loss = F.cross_entropy(model(images), labels)
        loss.backward()
        optimizer.step()
        arc.step(loss)
    arc.end_epoch(epoch)

class SimpleYOLO(nn.Module):
    def __init__(self, num_classes=80):
        super().__init__()
        self.backbone = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.head = nn.Conv2d(64, num_classes + 5, 1)

    def forward(self, x):
        return self.head(self.backbone(x))

model = SimpleYOLO()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
arc = ArcV2.auto(model, optimizer)

for epoch in range(300):
    for images in train_loader:
        optimizer.zero_grad()
        loss = compute_yolo_loss(model(images))
        loss.backward()
        optimizer.step()
        arc.step(loss)
    arc.end_epoch(epoch)

class TextClassifier(nn.Module):
    def __init__(self, vocab=10000, d_model=256, nhead=4):
        super().__init__()
        self.emb = nn.Embedding(vocab, d_model)
        self.encoder = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model, nhead, batch_first=True),
            num_layers=2
        )
        self.fc = nn.Linear(d_model, 2)

    def forward(self, x):
        return self.fc(self.encoder(self.emb(x)).mean(dim=1))

model = TextClassifier()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
arc = ArcV2.auto(model, optimizer)

for epoch in range(10):
    for tokens, labels in dataloader:
        optimizer.zero_grad()
        loss = F.cross_entropy(model(tokens), labels)
        loss.backward()
        optimizer.step()
        arc.step(loss)
    arc.end_epoch(epoch)

from arc import PINNStabilizer

class HeatPINN(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(2, 64), nn.Tanh(),
            nn.Linear(64, 64), nn.Tanh(),
            nn.Linear(64, 1)
        )

    def forward(self, x):
        return self.net(x)

model = HeatPINN()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
stabilizer = PINNStabilizer(model, n_loss_terms=3)

for epoch in range(5000):
    inputs = torch.rand(100, 2, requires_grad=True)
    u = model(inputs)
    pde_loss = compute_pde_residual(u, inputs)
    bc_loss  = compute_boundary_loss(model)
    ic_loss  = compute_initial_loss(model)
    total = stabilizer.get_stabilized_loss([pde_loss, bc_loss, ic_loss])
    optimizer.zero_grad()
    total.backward()
    stabilizer.stabilize_step()
    optimizer.step()
    stabilizer.update(epoch, total)

arc = ArcV2.auto(model, optimizer)

arc.begin_task("mnist")
for epoch in range(10):
    for x, y in mnist_loader:
        optimizer.zero_grad()
        loss = F.cross_entropy(model(x), y)
        loss.backward()
        optimizer.step()
        arc.step(loss)
    arc.end_epoch(epoch)

arc.consolidate_task(mnist_loader)

arc.begin_task("fashion_mnist")
for epoch in range(10):
    for x, y in fashion_loader:
        optimizer.zero_grad()
        loss = F.cross_entropy(model(x), y) + arc.get_ewc_loss()
        loss.backward()
        optimizer.step()
        arc.step(loss)
    arc.end_epoch(epoch)

from arc import ConformalPredictor

cp = ConformalPredictor(model, alpha=0.1)
cp.calibrate(calibration_loader)

result = cp.predict(test_input)
print(result.prediction, result.confidence, result.set_members)

from arc import AdversarialDetector

detector = AdversarialDetector(model)
detector.fit(clean_data_loader)

clean_alert = detector.detect(normal_input)
bad_alert = detector.detect(adversarial_input)

print(clean_alert.is_adversarial)
print(bad_alert.is_adversarial)