Spaces:
Runtime error
Runtime error
import os | |
import torch | |
import gradio as gr | |
import torchvision | |
import torch.nn as nn | |
import torch.nn.functional as F | |
import torch.optim as optim | |
n_epochs = 3 | |
batch_size_train = 64 | |
batch_size_test = 1000 | |
learning_rate = 0.01 | |
momentum = 0.5 | |
log_interval = 10 | |
random_seed = 1 | |
torch.backends.cudnn.enabled = False | |
torch.manual_seed(random_seed) | |
train_loader = torch.utils.data.DataLoader( | |
torchvision.datasets.MNIST('files/', train=True, download=True, | |
transform=torchvision.transforms.Compose([ | |
torchvision.transforms.ToTensor(), | |
torchvision.transforms.Normalize( | |
(0.1307,), (0.3081,)) | |
])), | |
batch_size=batch_size_train, shuffle=True) | |
test_loader = torch.utils.data.DataLoader( | |
torchvision.datasets.MNIST('files/', train=False, download=True, | |
transform=torchvision.transforms.Compose([ | |
torchvision.transforms.ToTensor(), | |
torchvision.transforms.Normalize( | |
(0.1307,), (0.3081,)) | |
])), | |
batch_size=batch_size_test, shuffle=True) | |
# Source: https://nextjournal.com/gkoehler/pytorch-mnist | |
class MNIST_Model(nn.Module): | |
def __init__(self): | |
super(MNIST_Model, self).__init__() | |
self.conv1 = nn.Conv2d(1, 10, kernel_size=5) | |
self.conv2 = nn.Conv2d(10, 20, kernel_size=5) | |
self.conv2_drop = nn.Dropout2d() | |
self.fc1 = nn.Linear(320, 50) | |
self.fc2 = nn.Linear(50, 10) | |
def forward(self, x): | |
x = F.relu(F.max_pool2d(self.conv1(x), 2)) | |
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) | |
x = x.view(-1, 320) | |
x = F.relu(self.fc1(x)) | |
x = F.dropout(x, training=self.training) | |
x = self.fc2(x) | |
return F.log_softmax(x) | |
def train(epochs,network,optimizer): | |
train_losses=[] | |
network.train() | |
for epoch in range(epochs): | |
for batch_idx, (data, target) in enumerate(train_loader): | |
optimizer.zero_grad() | |
output = network(data) | |
loss = F.nll_loss(output, target) | |
loss.backward() | |
optimizer.step() | |
if batch_idx % log_interval == 0: | |
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( | |
epoch, batch_idx * len(data), len(train_loader.dataset), | |
100. * batch_idx / len(train_loader), loss.item())) | |
train_losses.append(loss.item()) | |
torch.save(network.state_dict(), 'model.pth') | |
torch.save(optimizer.state_dict(), 'optimizer.pth') | |
def test(): | |
test_losses=[] | |
network.eval() | |
test_loss = 0 | |
correct = 0 | |
with torch.no_grad(): | |
for data, target in test_loader: | |
output = network(data) | |
test_loss += F.nll_loss(output, target, size_average=False).item() | |
pred = output.data.max(1, keepdim=True)[1] | |
correct += pred.eq(target.data.view_as(pred)).sum() | |
test_loss /= len(test_loader.dataset) | |
test_losses.append(test_loss) | |
print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( | |
test_loss, correct, len(test_loader.dataset), | |
100. * correct / len(test_loader.dataset))) | |
random_seed = 1 | |
torch.backends.cudnn.enabled = False | |
torch.manual_seed(random_seed) | |
network = MNIST_Model() | |
optimizer = optim.SGD(network.parameters(), lr=learning_rate, | |
momentum=momentum) | |
model_state_dict = 'model.pth' | |
optimizer_state_dict = 'optmizer.pth' | |
if os.path.exists(model_state_dict): | |
network_state_dict = torch.load(model_state_dict) | |
network.load_state_dict(network_state_dict) | |
if os.path.exists(optimizer_state_dict): | |
optimizer_state_dict = torch.load(optimizer_state_dict) | |
optimizer.load_state_dict(optimizer_state_dict) | |
# Train | |
#train(n_epochs,network,optimizer) | |
def image_classifier(inp): | |
input_image = torchvision.transforms.ToTensor()(inp).unsqueeze(0) | |
with torch.no_grad(): | |
prediction = torch.nn.functional.softmax(network(input_image)[0], dim=0) | |
#pred_number = prediction.data.max(1, keepdim=True)[1] | |
sorted_prediction = torch.sort(prediction,descending=True) | |
confidences={} | |
for s,v in zip(sorted_prediction.indices.numpy().tolist(),sorted_prediction.values.numpy().tolist()): | |
confidences.update({s:v}) | |
return confidences | |
TITLE = "MNIST Adversarial: Try to fool the MNIST model" | |
description = """This project is about dynamic adversarial data collection (DADC). | |
The basic idea is to do data collection, but specifically collect “adversarial data”, the kind of data that is difficult for a model to predict correctly. | |
This kind of data is presumably the most valuable for a model, so this can be helpful in low-resource settings where data is hard to collect and label. | |
### What to do: | |
- Draw a number from 0-9. | |
- Click `Submit` and see the model's prediciton. | |
- If the model misclassifies it, Flag that example. | |
- This will add your (adversarial) example to a dataset on which the model will be trained later. | |
""" | |
gr.Interface(fn=image_classifier, | |
inputs=gr.Image(source="canvas",shape=(28,28),invert_colors=True,image_mode="L",type="pil"), | |
outputs=gr.outputs.Label(num_top_classes=10), | |
allow_flagging="manual", | |
title = TITLE, | |
description=description).launch() | |