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