train=True,
download=True,
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('data',
train=False,
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=args.test_batch_size,
shuffle=False,
**kwargs)
# Define which model to use
model = LeNet(mask=False).to(device)
# NOTE : `weight_decay` term denotes L2 regularization loss term
optimizer = optim.Adam(model.parameters(), lr=args.lr)
initial_optimizer_state_dict = optimizer.state_dict()
def train(epochs):
model.train()
pbar = tqdm(range(epochs), total=epochs)
for epoch in pbar:
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(datasets.MNIST(
'data',
train=False,
transform=transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])),
batch_size=args.test_batch_size,
shuffle=False,
**kwargs)
# Define which model to use
if args.architecture == 'lenet':
model = LeNet(mask=True).to(device)
else:
model = AE(mask=False, input_shape=784).to(device)
print(model)
util.print_model_parameters(model)
# NOTE : `weight_decay` term denotes L2 regularization loss term
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=0.00001)
initial_optimizer_state_dict = optimizer.state_dict()
def train(epochs):
model.train()
for epoch in range(epochs):
pbar = tqdm(enumerate(train_loader), total=len(train_loader))
for batch_idx, (data, target) in pbar:
# Loader
kwargs = {'num_workers': 5, 'pin_memory': True} if use_cuda else {}
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor()])),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('data', train=False, transform=transforms.Compose([
transforms.ToTensor()])),
batch_size=args.test_batch_size, shuffle=False, **kwargs)
# Define which model to use
model = LeNet(mask=False).to(device)
print(model)
util.print_model_parameters(model)
# NOTE : `weight_decay` term denotes L2 regularization loss term
optimizer = optim.Adam(model.parameters(), lr=args.lr)
initial_optimizer_state_dict = optimizer.state_dict()
def train(epochs, decay=0, threshold=0.0):
model.train()
pbar = tqdm(range(epochs), total=epochs)
curves = np.zeros((epochs,14))
for epoch in pbar:
for batch_idx, (data, target) in enumerate(train_loader):
transforms.Normalize((0.1307, ), (0.3081, ))])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(datasets.MNIST(
'data',
train=False,
transform=transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])),
batch_size=args.test_batch_size,
shuffle=False,
**kwargs)
# Define which model to use
model = LeNet(mask=True).to(device)
print(model)
util.print_model_parameters(model)
def add_100_to_10(a):
b = torch.empty(10, dtype=torch.float)
b.fill_(0)
for i in range(10):
for j in range(10):
b[i].add_(a[i * 10 + j])
return b
help='directory of encoded model')
parser.add_argument('--test-batch-size',
type=int,
default=1000,
metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else 'cpu')
model = LeNet(mask=True).to(device)
huffman_decode_model(model, 'encodings-48X')
util.print_nonzeros(model)
# Loader
kwargs = {'num_workers': 5, 'pin_memory': True} if use_cuda else {}
test_loader = torch.utils.data.DataLoader(datasets.MNIST(
'data',
train=False,
transform=transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])),
batch_size=args.test_batch_size,
shuffle=False,
**kwargs)
# Loader
kwargs = {'num_workers': 5, 'pin_memory': True} if use_cuda else {}
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor()])),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('data', train=False, transform=transforms.Compose([
transforms.ToTensor()])),
batch_size=args.test_batch_size, shuffle=False, **kwargs)
# Define which model to use
model = LeNet(mask=False).to(device)
# NOTE : `weight_decay` term denotes L2 regularization loss term
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=1e-4)
initial_optimizer_state_dict = optimizer.state_dict()
def train(epochs):
best = 0.0
pbar = tqdm(range(epochs), total=epochs)
for epoch in pbar:
accuracy = test()
if accuracy > best:
best = accuracy
torch.save(model.state_dict(), args.model+'_V_'+str(args.sensitivity)+'.pth')
model.train()
# Loader
kwargs = {'num_workers': 5, 'pin_memory': True} if use_cuda else {}
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor()])),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('data', train=False, transform=transforms.Compose([
transforms.ToTensor()])),
batch_size=args.test_batch_size, shuffle=False, **kwargs)
# Define which model to use
model = LeNet(mask=False).to(device)
# NOTE : `weight_decay` term denotes L2 regularization loss term
optimizer = optim.Adam(model.parameters(), lr=args.lr)
initial_optimizer_state_dict = optimizer.state_dict()
def train(epochs):
model.train()
pbar = tqdm(range(epochs), total=epochs)
for epoch in pbar:
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
total_loss = loss
train=True,
download=True,
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('data',
train=False,
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=args.test_batch_size,
shuffle=False,
**kwargs)
# Define which model to use
model = LeNet(mask=False).to(device)
print(model)
util.print_model_parameters(model)
# NOTE : `weight_decay` term denotes L2 regularization loss term
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=1e-4)
initial_optimizer_state_dict = optimizer.state_dict()
def train(epochs, decay=0, threshold=0.0):
model.train()
pbar = tqdm(range(epochs), total=epochs)
for epoch in pbar:
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)