retry uploading

.gitattributes

@@ -25,3 +25,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*ubyte* filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,154 @@
+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()
+

files/MNIST/raw/t10k-images-idx3-ubyte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fa7898d509279e482958e8ce81c8e77db3f2f8254e26661ceb7762c4d494ce7
+size 7840016

files/MNIST/raw/t10k-images-idx3-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d422c7b0a1c1c79245a5bcf07fe86e33eeafee792b84584aec276f5a2dbc4e6
+size 1648877

files/MNIST/raw/t10k-labels-idx1-ubyte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff7bcfd416de33731a308c3f266cc351222c34898ecbeaf847f06e48f7ec33f2
+size 10008

files/MNIST/raw/t10k-labels-idx1-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7ae60f92e00ec6debd23a6088c31dbd2371eca3ffa0defaefb259924204aec6
+size 4542

files/MNIST/raw/train-images-idx3-ubyte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba891046e6505d7aadcbbe25680a0738ad16aec93bde7f9b65e87a2fc25776db
+size 47040016

files/MNIST/raw/train-images-idx3-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:440fcabf73cc546fa21475e81ea370265605f56be210a4024d2ca8f203523609
+size 9912422

files/MNIST/raw/train-labels-idx1-ubyte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65a50cbbf4e906d70832878ad85ccda5333a97f0f4c3dd2ef09a8a9eef7101c5
+size 60008

files/MNIST/raw/train-labels-idx1-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3552534a0a558bbed6aed32b30c495cca23d567ec52cac8be1a0730e8010255c
+size 28881

model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffe16177c76477e22a35b45ac44d3a06f758d07df5ca37379a490ed69f7ff80e
+size 89871

optimizer.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea0b9cee5af7847bf896b2c9692b1cf36fe447d67be87d1b98634091f20babe6
+size 89807