def train():
mnist_train, mnist_train_target, mnist_test, mnist_test_target = \
prologue.load_data(cifar=False, one_hot_labels=True, normalize=True)
mnist_test_target *= 0.9
mnist_train_target *= 0.9
eps = 0.000001
print(eps)
w1 = torch.zeros(50, 784).normal_(0, eps)
b1 = torch.zeros(50, 1).normal_(0, eps)
w2 = torch.zeros(10, 50).normal_(0, eps)
b2 = torch.zeros(10, 1).normal_(0, eps)
eta = 0.1 / mnist_train.shape[0]
for i in progressbar.progressbar(range(1000)):
dl_dw1 = torch.zeros(50, 784)
dl_db1 = torch.zeros(50, 1)
dl_dw2 = torch.zeros(10, 50)
dl_db2 = torch.zeros(10, 1)
for j in range(1000):
x = mnist_train[j].resize_(mnist_train[j].shape[0], 1)
t = mnist_train_target[j].resize_(mnist_train_target[j].shape[0],
1)
x0, s1, x1, s2, x2 = forward_pass(w1, b1, w2, b2, x)
backward_pass(w1, b1, w2, b2, t, x, s1, x1, s2, x2, dl_dw1, dl_db1,
dl_dw2, dl_db2)
w1 = w1 - eta * dl_dw1
w2 = w2 - eta * dl_dw2
b1 = b1 - eta * dl_db1
b2 = b2 - eta * dl_db2
print("Training error: ",
compute_error(mnist_train, mnist_train_target, w1, b1, w2, b2))
print("Test error: ",
compute_error(mnist_test, mnist_test_target, w1, b1, w2, b2))
def main():
for c in [False, True]:
train_input, train_target, test_input, test_target = prologue.load_data(
cifar=c)
## Baseline errors
nb_errors = compute_nb_errors(train_input, train_target,
test_input, test_target)
print('Baseline nb_errors {:d} error {:.02f}%'.format(
nb_errors, 100 * nb_errors / test_input.size(0)))
## Random errors
basis = train_input.new(100, train_input.size(1)).normal_()
nb_errors = compute_nb_errors(train_input, train_target,
test_input, test_target, None, basis)
print('Random {:d}d nb_errors {:d} error {:.02f}%'.format(
basis.size(0), nb_errors,
100 * nb_errors / test_input.size(0)))
## PCA errors
mean, basis = PCA(train_input)
for d in [100, 50, 10, 3]:
nb_errors = compute_nb_errors(train_input, train_target,
test_input, test_target, mean,
basis[:d])
print('PCA {:d}d nb_errors {:d} error {:.02f}%'.format(
d, nb_errors, 100 * nb_errors / test_input.size(0)))
#!/usr/bin/env python
import torchvision
import dlc_practical_prologue as prologue
train_input, _, _, _ = prologue.load_data(cifar=False)
images = train_input.narrow(0, 0, 64).view(-1, 1, 28, 28)
images /= images.max()
print('Writing check-mnist.png')
torchvision.utils.save_image(images, 'check-mnist.png')
train_input, _, _, _ = prologue.load_data(cifar=True)
images = train_input.narrow(0, 0, 64).view(-1, 3, 32, 32)
images /= images.max()
print('Writing check-cifar.png')
torchvision.utils.save_image(images, 'check-cifar.png')
nb_errors = 0
# With loop, but I prefer clearer code when counting errors
for n in range(0, test_input.size(0)):
if test_target[n] != nearest_classification(train_input, train_target,
test_input[n]):
nb_errors = nb_errors + 1
return nb_errors
######################################################################
for c in [False, True]:
train_input, train_target, test_input, test_target = prologue.load_data(
cifar=c)
nb_errors = compute_nb_errors(train_input, train_target, test_input,
test_target)
print('Baseline nb_errors {:d} error {:.02f}%'.format(
nb_errors, 100 * nb_errors / test_input.size(0)))
##
basis = train_input.new(100, train_input.size(1)).normal_()
nb_errors = compute_nb_errors(train_input, train_target, test_input,
test_target, None, basis)
print('Random {:d}d nb_errors {:d} error {:.02f}%'.format(
basis.size(0), nb_errors, 100 * nb_errors / test_input.size(0)))
x, s1, x1, s2, x2,
dl_dw1, dl_db1, dl_dw2, dl_db2):
x0 = x
dl_dx2 = dloss(x2, t)
dl_ds2 = dsigma(s2) * dl_dx2
dl_dx1 = w2.t().mv(dl_ds2)
dl_ds1 = dsigma(s1) * dl_dx1
dl_dw2.add_(dl_ds2.view(-1, 1).mm(x1.view(1, -1)))
dl_db2.add_(dl_ds2)
dl_dw1.add_(dl_ds1.view(-1, 1).mm(x0.view(1, -1)))
dl_db1.add_(dl_ds1)
######################################################################
train_input, train_target, test_input, test_target = prologue.load_data(one_hot_labels = True,
normalize = True)
nb_classes = train_target.size(1)
nb_train_samples = train_input.size(0)
zeta = 0.90
train_target = train_target * zeta
test_target = test_target * zeta
nb_hidden = 50
eta = 1e-1 / nb_train_samples
epsilon = 1e-6
w1 = torch.empty(nb_hidden, train_input.size(1)).normal_(0, epsilon)
b1 = torch.empty(nb_hidden).normal_(0, epsilon)
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
# For more information, please refer to <http://unlicense.org/>
#
######################################################################
import torch
from torch.autograd import Variable
from torch import nn
from torch.nn import functional as F
import dlc_practical_prologue as prologue
train_input, train_target, test_input, test_target = \
prologue.load_data(one_hot_labels = True, normalize = True, flatten = False)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
self.fc1 = nn.Linear(256, 200)
self.fc2 = nn.Linear(200, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), kernel_size=3, stride=3))
x = F.relu(F.max_pool2d(self.conv2(x), kernel_size=2, stride=2))
x = F.relu(self.fc1(x.view(-1, 256)))
x = self.fc2(x)
return mean, proj
if __name__ == '__main__':
# parse arguments
parser = prologue.parser
parser.add_argument('pca_dim',
metavar='PCA_DIM',
type=int,
help='dimension of PCA subspace')
args = parser.parse_args()
pca_dim = args.pca_dim
# load data
prologue.init(args)
train_input, train_target, test_input, test_target = prologue.load_data(
args)
print 'data loaded'
# compute transform
mean, proj = PCA(train_input)
proj = proj[:pca_dim]
print 'transform computed'
# test
err = compute_nb_errors(train_input,
train_target,
test_input,
test_target,
mean=mean,
proj=proj)
print '# of Error : %d' % err
def main():
train_input, train_target, test_input, test_target = prologue.load_data(
one_hot_labels=True, normalize=True)
n_train_input = train_input.size(0)
n_train_output = train_target.size(1)
zeta = 0.9
epsilon = 1e-16
n_steps = 1000
eta = 1e-1 / n_train_input
n_hidden = 50
print(
f'\nPARAMETERS\n'
f' zeta = {zeta}\n epsilon = {epsilon}\n n_steps = {n_steps}\n'
f' eta = {eta}\n n_hidden = {n_hidden}\n')
train_target.mul_(zeta)
test_target.mul_(zeta)
w1 = torch.empty(n_hidden, train_input.size(1)).normal_(0, epsilon)
b1 = torch.empty(n_hidden).normal_(0, epsilon)
w2 = torch.empty(n_train_output, n_hidden).normal_(0, epsilon)
b2 = torch.empty(n_train_output).normal_(0, epsilon)
dl_dw1 = torch.empty(w1.size())
dl_db1 = torch.empty(b1.size())
dl_dw2 = torch.empty(w2.size())
dl_db2 = torch.empty(b2.size())
print('RUNNING')
print(' Step Acc. Loss Train Err. Test Err.')
for i in range(n_steps):
dl_dw1.zero_()
dl_db1.zero_()
dl_dw2.zero_()
dl_db2.zero_()
acc_loss = 0
n_train_errors = 0
n_test_errors = 0
for j in range(train_input.size(0)):
x0, s1, x1, s2, x2 = forward_pass(w1, b1, w2, b2,
train_input[j])
pred_idx = x2.max(dim=0).indices.item()
if train_target[j, pred_idx] < 0.5:
n_train_errors += 1
acc_loss += loss(x2, train_target[j])
backward_pass(w1, b1, w2, b2, train_target[j], x0, s1, x1, s2,
x2, dl_dw1, dl_db1, dl_dw2, dl_db2)
w1 = w1 - eta * dl_dw1
b1 = b1 - eta * dl_db1
w2 = w2 - eta * dl_dw2
b2 = b2 - eta * dl_db2
for j in range(test_input.size(0)):
_, _, _, _, x2 = forward_pass(w1, b1, w2, b2, test_input[j])
pred_idx = x2.max(dim=0).indices.item()
if test_target[j, pred_idx] < 0.5:
n_test_errors += 1
print(f' {i+1:04d}'
f' {acc_loss:9.3f}'
f' {n_train_errors/train_input.size(0):10.3f}'
f' {n_test_errors/test_input.size(0):9.3f}')
def get_cifar_datasets():
cifar_train, cifar_train_target, cifar_test, cifar_test_target = prologue.load_data(
cifar=True)
return cifar_train, cifar_train_target, cifar_test, cifar_test_target
def get_mnist_datasets():
mnist_train, mnist_train_target, mnist_test, mnist_test_target = prologue.load_data(
cifar=False)
return mnist_train, mnist_train_target, mnist_test, mnist_test_target
