Assignments/assignment1/features.ipynb

{"cells":[{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Q577ISvCfTBX","executionInfo":{"status":"ok","timestamp":1642142451710,"user_tz":-120,"elapsed":22770,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"6d576505-0c76-4723-f5f1-207d91b92da9"},"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n","/content/drive/My Drive/cs231n/assignments/assignment1/cs231n/datasets\n","/content/drive/My Drive/cs231n/assignments/assignment1\n"]}],"source":["# This mounts your Google Drive to the Colab VM.\n","from google.colab import drive\n","drive.mount('/content/drive', force_remount=True)\n","\n","# Enter the foldername in your Drive where you have saved the unzipped\n","# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n","FOLDERNAME = \"cs231n/assignments/assignment1/\"\n","assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n","\n","# Now that we've mounted your Drive, this ensures that\n","# the Python interpreter of the Colab VM can load\n","# python files from within it.\n","import sys\n","sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n","\n","# This downloads the CIFAR-10 dataset to your Drive\n","# if it doesn't already exist.\n","%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n","!bash get_datasets.sh\n","%cd /content/drive/My\\ Drive/$FOLDERNAME"]},{"cell_type":"markdown","metadata":{"tags":["pdf-title"],"id":"nxaFTVtXfTBZ"},"source":["# Image features exercise\n","*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n","\n","We have seen that we can achieve reasonable performance on an image classification task by training a linear classifier on the pixels of the input image. In this exercise we will show that we can improve our classification performance by training linear classifiers not on raw pixels but on features that are computed from the raw pixels.\n","\n","All of your work for this exercise will be done in this notebook."]},{"cell_type":"code","execution_count":2,"metadata":{"tags":["pdf-ignore"],"id":"k26Gp6sCfTBc","executionInfo":{"status":"ok","timestamp":1642142452572,"user_tz":-120,"elapsed":868,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}}},"outputs":[],"source":["import random\n","import numpy as np\n","from cs231n.data_utils import load_CIFAR10\n","import matplotlib.pyplot as plt\n","\n","\n","%matplotlib inline\n","plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n","plt.rcParams['image.interpolation'] = 'nearest'\n","plt.rcParams['image.cmap'] = 'gray'\n","\n","# for auto-reloading extenrnal modules\n","# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n","%load_ext autoreload\n","%autoreload 2"]},{"cell_type":"markdown","metadata":{"tags":["pdf-ignore"],"id":"lw_9RIyrfTBe"},"source":["## Load data\n","Similar to previous exercises, we will load CIFAR-10 data from disk."]},{"cell_type":"code","execution_count":3,"metadata":{"tags":["pdf-ignore"],"id":"GMzzJwPAfTBf","executionInfo":{"status":"ok","timestamp":1642142464261,"user_tz":-120,"elapsed":11703,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}}},"outputs":[],"source":["from cs231n.features import color_histogram_hsv, hog_feature\n","\n","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n","    # Load the raw CIFAR-10 data\n","    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n","\n","    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n","    try:\n","       del X_train, y_train\n","       del X_test, y_test\n","       print('Clear previously loaded data.')\n","    except:\n","       pass\n","\n","    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n","    \n","    # Subsample the data\n","    mask = list(range(num_training, num_training + num_validation))\n","    X_val = X_train[mask]\n","    y_val = y_train[mask]\n","    mask = list(range(num_training))\n","    X_train = X_train[mask]\n","    y_train = y_train[mask]\n","    mask = list(range(num_test))\n","    X_test = X_test[mask]\n","    y_test = y_test[mask]\n","    \n","    return X_train, y_train, X_val, y_val, X_test, y_test\n","\n","X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()"]},{"cell_type":"markdown","metadata":{"tags":["pdf-ignore"],"id":"J1lJ9JdzfTBh"},"source":["## Extract Features\n","For each image we will compute a Histogram of Oriented\n","Gradients (HOG) as well as a color histogram using the hue channel in HSV\n","color space. We form our final feature vector for each image by concatenating\n","the HOG and color histogram feature vectors.\n","\n","Roughly speaking, HOG should capture the texture of the image while ignoring\n","color information, and the color histogram represents the color of the input\n","image while ignoring texture. As a result, we expect that using both together\n","ought to work better than using either alone. Verifying this assumption would\n","be a good thing to try for your own interest.\n","\n","The `hog_feature` and `color_histogram_hsv` functions both operate on a single\n","image and return a feature vector for that image. The extract_features\n","function takes a set of images and a list of feature functions and evaluates\n","each feature function on each image, storing the results in a matrix where\n","each column is the concatenation of all feature vectors for a single image."]},{"cell_type":"code","execution_count":4,"metadata":{"scrolled":true,"tags":["pdf-ignore"],"colab":{"base_uri":"https://localhost:8080/"},"id":"_f7LxOqbfTBi","executionInfo":{"status":"ok","timestamp":1642142526373,"user_tz":-120,"elapsed":62120,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"101c2141-da60-42a8-86b7-5de21477917a"},"outputs":[{"output_type":"stream","name":"stdout","text":["Done extracting features for 1000 / 49000 images\n","Done extracting features for 2000 / 49000 images\n","Done extracting features for 3000 / 49000 images\n","Done extracting features for 4000 / 49000 images\n","Done extracting features for 5000 / 49000 images\n","Done extracting features for 6000 / 49000 images\n","Done extracting features for 7000 / 49000 images\n","Done extracting features for 8000 / 49000 images\n","Done extracting features for 9000 / 49000 images\n","Done extracting features for 10000 / 49000 images\n","Done extracting features for 11000 / 49000 images\n","Done extracting features for 12000 / 49000 images\n","Done extracting features for 13000 / 49000 images\n","Done extracting features for 14000 / 49000 images\n","Done extracting features for 15000 / 49000 images\n","Done extracting features for 16000 / 49000 images\n","Done extracting features for 17000 / 49000 images\n","Done extracting features for 18000 / 49000 images\n","Done extracting features for 19000 / 49000 images\n","Done extracting features for 20000 / 49000 images\n","Done extracting features for 21000 / 49000 images\n","Done extracting features for 22000 / 49000 images\n","Done extracting features for 23000 / 49000 images\n","Done extracting features for 24000 / 49000 images\n","Done extracting features for 25000 / 49000 images\n","Done extracting features for 26000 / 49000 images\n","Done extracting features for 27000 / 49000 images\n","Done extracting features for 28000 / 49000 images\n","Done extracting features for 29000 / 49000 images\n","Done extracting features for 30000 / 49000 images\n","Done extracting features for 31000 / 49000 images\n","Done extracting features for 32000 / 49000 images\n","Done extracting features for 33000 / 49000 images\n","Done extracting features for 34000 / 49000 images\n","Done extracting features for 35000 / 49000 images\n","Done extracting features for 36000 / 49000 images\n","Done extracting features for 37000 / 49000 images\n","Done extracting features for 38000 / 49000 images\n","Done extracting features for 39000 / 49000 images\n","Done extracting features for 40000 / 49000 images\n","Done extracting features for 41000 / 49000 images\n","Done extracting features for 42000 / 49000 images\n","Done extracting features for 43000 / 49000 images\n","Done extracting features for 44000 / 49000 images\n","Done extracting features for 45000 / 49000 images\n","Done extracting features for 46000 / 49000 images\n","Done extracting features for 47000 / 49000 images\n","Done extracting features for 48000 / 49000 images\n","Done extracting features for 49000 / 49000 images\n"]}],"source":["from cs231n.features import *\n","\n","num_color_bins = 10 # Number of bins in the color histogram\n","feature_fns = [hog_feature, lambda img: color_histogram_hsv(img, nbin=num_color_bins)]\n","X_train_feats = extract_features(X_train, feature_fns, verbose=True)\n","X_val_feats = extract_features(X_val, feature_fns)\n","X_test_feats = extract_features(X_test, feature_fns)\n","\n","# Preprocessing: Subtract the mean feature\n","mean_feat = np.mean(X_train_feats, axis=0, keepdims=True)\n","X_train_feats -= mean_feat\n","X_val_feats -= mean_feat\n","X_test_feats -= mean_feat\n","\n","# Preprocessing: Divide by standard deviation. This ensures that each feature\n","# has roughly the same scale.\n","std_feat = np.std(X_train_feats, axis=0, keepdims=True)\n","X_train_feats /= std_feat\n","X_val_feats /= std_feat\n","X_test_feats /= std_feat\n","\n","# Preprocessing: Add a bias dimension\n","X_train_feats = np.hstack([X_train_feats, np.ones((X_train_feats.shape[0], 1))])\n","X_val_feats = np.hstack([X_val_feats, np.ones((X_val_feats.shape[0], 1))])\n","X_test_feats = np.hstack([X_test_feats, np.ones((X_test_feats.shape[0], 1))])"]},{"cell_type":"markdown","metadata":{"id":"UFxIpdmKfTBk"},"source":["## Train SVM on features\n","Using the multiclass SVM code developed earlier in the assignment, train SVMs on top of the features extracted above; this should achieve better results than training SVMs directly on top of raw pixels."]},{"cell_type":"code","execution_count":5,"metadata":{"tags":["code"],"colab":{"base_uri":"https://localhost:8080/"},"id":"J8spEnwcfTBl","executionInfo":{"status":"ok","timestamp":1642142540195,"user_tz":-120,"elapsed":13831,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"ec43e2fa-fffc-45a1-c508-684593ed0189"},"outputs":[{"output_type":"stream","name":"stdout","text":["[(1e-09, 50000.0), (1e-09, 500000.0), (1e-09, 5000000.0), (1e-08, 50000.0), (1e-08, 500000.0), (1e-08, 5000000.0), (1e-07, 50000.0), (1e-07, 500000.0), (1e-07, 5000000.0)]\n","lr 1.000000e-09 reg 5.000000e+04 train accuracy: 0.094612 val accuracy: 0.106000\n","lr 1.000000e-09 reg 5.000000e+05 train accuracy: 0.098653 val accuracy: 0.092000\n","lr 1.000000e-09 reg 5.000000e+06 train accuracy: 0.357612 val accuracy: 0.332000\n","lr 1.000000e-08 reg 5.000000e+04 train accuracy: 0.092531 val accuracy: 0.104000\n","lr 1.000000e-08 reg 5.000000e+05 train accuracy: 0.408980 val accuracy: 0.404000\n","lr 1.000000e-08 reg 5.000000e+06 train accuracy: 0.410571 val accuracy: 0.405000\n","lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.413163 val accuracy: 0.413000\n","lr 1.000000e-07 reg 5.000000e+05 train accuracy: 0.405347 val accuracy: 0.401000\n","lr 1.000000e-07 reg 5.000000e+06 train accuracy: 0.376816 val accuracy: 0.373000\n","best validation accuracy achieved: 0.413000\n"]}],"source":["# Use the validation set to tune the learning rate and regularization strength\n","\n","from cs231n.classifiers.linear_classifier import LinearSVM\n","\n","learning_rates = [1e-9, 1e-8, 1e-7]\n","regularization_strengths = [5e4, 5e5, 5e6]\n","\n","results = {}\n","best_val = -1\n","best_svm = None\n","\n","################################################################################\n","# TODO:                                                                        #\n","# Use the validation set to set the learning rate and regularization strength. #\n","# This should be identical to the validation that you did for the SVM; save    #\n","# the best trained classifer in best_svm. You might also want to play          #\n","# with different numbers of bins in the color histogram. If you are careful    #\n","# you should be able to get accuracy of near 0.44 on the validation set.       #\n","################################################################################\n","# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","np.random.seed(0)\n","\n","grid_search = [ (lr,reg) for lr in learning_rates for reg in regularization_strengths ]\n","print(grid_search)\n","for lr, reg in grid_search:\n","    # Create SVM model\n","    svm = LinearSVM()\n","    \n","    \n","    # Train phase\n","    svm.train(X_train_feats, y_train, learning_rate=lr, reg=reg, num_iters=2000,\n","            batch_size=200, verbose=False)\n","    y_train_pred = svm.predict(X_train_feats)\n","    \n","    # Train accuracy\n","    train_accuracy = np.mean( y_train_pred == y_train )\n","    \n","\n","    # Validation phase\n","    y_val_pred = svm.predict(X_val_feats)\n","    \n","    # Validation accuracy\n","    val_accuracy = np.mean( y_val_pred == y_val )\n","    \n","    results[lr,reg] = (train_accuracy,val_accuracy)\n","    \n","    # Save best model\n","    if val_accuracy > best_val:\n","        best_val = val_accuracy\n","        best_svm = svm\n","\n","# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","# Print out results.\n","for lr, reg in sorted(results):\n","    train_accuracy, val_accuracy = results[(lr, reg)]\n","    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n","                lr, reg, train_accuracy, val_accuracy))\n","    \n","print('best validation accuracy achieved: %f' % best_val)"]},{"cell_type":"code","execution_count":6,"metadata":{"id":"svm_test_accuracy","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642142540198,"user_tz":-120,"elapsed":15,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"0db5e43a-276d-4481-f504-233b22d97ad6"},"outputs":[{"output_type":"stream","name":"stdout","text":["0.416\n"]}],"source":["# Evaluate your trained SVM on the test set: you should be able to get at least 0.40\n","y_test_pred = best_svm.predict(X_test_feats)\n","test_accuracy = np.mean(y_test == y_test_pred)\n","print(test_accuracy)"]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":482},"id":"IFQxp4vKfTBp","executionInfo":{"status":"ok","timestamp":1642142543327,"user_tz":-120,"elapsed":3135,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"865e7583-a7dc-4631-ee5b-7ea39611efc5"},"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 720x576 with 80 Axes>"]},"metadata":{"needs_background":"light"}}],"source":["# An important way to gain intuition about how an algorithm works is to\n","# visualize the mistakes that it makes. In this visualization, we show examples\n","# of images that are misclassified by our current system. The first column\n","# shows images that our system labeled as \"plane\" but whose true label is\n","# something other than \"plane\".\n","\n","examples_per_class = 8\n","classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n","for cls, cls_name in enumerate(classes):\n","    idxs = np.where((y_test != cls) & (y_test_pred == cls))[0]\n","    idxs = np.random.choice(idxs, examples_per_class, replace=False)\n","    for i, idx in enumerate(idxs):\n","        plt.subplot(examples_per_class, len(classes), i * len(classes) + cls + 1)\n","        plt.imshow(X_test[idx].astype('uint8'))\n","        plt.axis('off')\n","        if i == 0:\n","            plt.title(cls_name)\n","plt.show()"]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"DCI7O4VxfTBp"},"source":["### Inline question 1:\n","Describe the misclassification results that you see. Do they make sense?\n","\n","\n","$\\color{blue}{\\textit Your Answer:}$\n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"fqN8RYbxfTBr"},"source":["## Neural Network on image features\n","Earlier in this assigment we saw that training a two-layer neural network on raw pixels achieved better classification performance than linear classifiers on raw pixels. In this notebook we have seen that linear classifiers on image features outperform linear classifiers on raw pixels. \n","\n","For completeness, we should also try training a neural network on image features. This approach should outperform all previous approaches: you should easily be able to achieve over 55% classification accuracy on the test set; our best model achieves about 60% classification accuracy."]},{"cell_type":"code","execution_count":8,"metadata":{"tags":["pdf-ignore"],"colab":{"base_uri":"https://localhost:8080/"},"id":"0EN_dbi5fTBr","executionInfo":{"status":"ok","timestamp":1642142543328,"user_tz":-120,"elapsed":13,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"b144a493-8de8-4456-b075-28c9520e3d25"},"outputs":[{"output_type":"stream","name":"stdout","text":["(49000, 155)\n","(49000, 154)\n"]}],"source":["# Preprocessing: Remove the bias dimension\n","# Make sure to run this cell only ONCE\n","print(X_train_feats.shape)\n","X_train_feats = X_train_feats[:, :-1]\n","X_val_feats = X_val_feats[:, :-1]\n","X_test_feats = X_test_feats[:, :-1]\n","\n","print(X_train_feats.shape)"]},{"cell_type":"code","execution_count":12,"metadata":{"tags":["code"],"colab":{"base_uri":"https://localhost:8080/"},"id":"wzi8UbVwfTBs","executionInfo":{"status":"ok","timestamp":1642144141305,"user_tz":-120,"elapsed":344178,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"7ac72b82-3b7e-41e3-88bb-412fef6ebd25"},"outputs":[{"output_type":"stream","name":"stdout","text":["\u001b[1;30;43mStreaming output truncated to the last 5000 lines.\u001b[0m\n","(Iteration 391 / 4900) loss: 1.409468\n","(Iteration 401 / 4900) loss: 1.354254\n","(Iteration 411 / 4900) loss: 1.349942\n","(Iteration 421 / 4900) loss: 1.316077\n","(Iteration 431 / 4900) loss: 1.371164\n","(Iteration 441 / 4900) loss: 1.365387\n","(Iteration 451 / 4900) loss: 1.391962\n","(Iteration 461 / 4900) loss: 1.750682\n","(Iteration 471 / 4900) loss: 1.407459\n","(Iteration 481 / 4900) loss: 1.328772\n","(Epoch 1 / 10) train acc: 0.529000; val_acc: 0.487000\n","(Iteration 491 / 4900) loss: 1.454718\n","(Iteration 501 / 4900) loss: 1.301141\n","(Iteration 511 / 4900) loss: 1.314363\n","(Iteration 521 / 4900) loss: 1.411283\n","(Iteration 531 / 4900) loss: 1.337729\n","(Iteration 541 / 4900) loss: 1.239746\n","(Iteration 551 / 4900) loss: 1.375511\n","(Iteration 561 / 4900) loss: 1.251144\n","(Iteration 571 / 4900) loss: 1.477984\n","(Iteration 581 / 4900) loss: 1.277199\n","(Iteration 591 / 4900) loss: 1.286883\n","(Iteration 601 / 4900) loss: 1.480879\n","(Iteration 611 / 4900) loss: 1.344193\n","(Iteration 621 / 4900) loss: 1.391492\n","(Iteration 631 / 4900) loss: 1.412784\n","(Iteration 641 / 4900) loss: 1.385252\n","(Iteration 651 / 4900) loss: 1.355859\n","(Iteration 661 / 4900) loss: 1.292409\n","(Iteration 671 / 4900) loss: 1.364945\n","(Iteration 681 / 4900) loss: 1.351295\n","(Iteration 691 / 4900) loss: 1.365868\n","(Iteration 701 / 4900) loss: 1.373798\n","(Iteration 711 / 4900) loss: 1.370517\n","(Iteration 721 / 4900) loss: 1.342213\n","(Iteration 731 / 4900) loss: 1.266743\n","(Iteration 741 / 4900) loss: 1.314310\n","(Iteration 751 / 4900) loss: 1.395489\n","(Iteration 761 / 4900) loss: 1.140622\n","(Iteration 771 / 4900) loss: 1.342857\n","(Iteration 781 / 4900) loss: 1.180491\n","(Iteration 791 / 4900) loss: 1.201405\n","(Iteration 801 / 4900) loss: 1.155587\n","(Iteration 811 / 4900) loss: 1.292783\n","(Iteration 821 / 4900) loss: 1.396570\n","(Iteration 831 / 4900) loss: 1.273468\n","(Iteration 841 / 4900) loss: 1.141048\n","(Iteration 851 / 4900) loss: 1.392605\n","(Iteration 861 / 4900) loss: 1.192220\n","(Iteration 871 / 4900) loss: 1.303484\n","(Iteration 881 / 4900) loss: 1.236014\n","(Iteration 891 / 4900) loss: 1.235969\n","(Iteration 901 / 4900) loss: 1.117638\n","(Iteration 911 / 4900) loss: 1.283778\n","(Iteration 921 / 4900) loss: 1.308218\n","(Iteration 931 / 4900) loss: 1.090860\n","(Iteration 941 / 4900) loss: 1.143386\n","(Iteration 951 / 4900) loss: 1.232099\n","(Iteration 961 / 4900) loss: 1.295312\n","(Iteration 971 / 4900) loss: 1.167828\n","(Epoch 2 / 10) train acc: 0.554000; val_acc: 0.533000\n","(Iteration 981 / 4900) loss: 1.267133\n","(Iteration 991 / 4900) loss: 1.306796\n","(Iteration 1001 / 4900) loss: 1.276258\n","(Iteration 1011 / 4900) loss: 1.265108\n","(Iteration 1021 / 4900) loss: 1.247995\n","(Iteration 1031 / 4900) loss: 1.313981\n","(Iteration 1041 / 4900) loss: 1.239621\n","(Iteration 1051 / 4900) loss: 1.419831\n","(Iteration 1061 / 4900) loss: 1.268314\n","(Iteration 1071 / 4900) loss: 1.331781\n","(Iteration 1081 / 4900) loss: 1.336262\n","(Iteration 1091 / 4900) loss: 1.420698\n","(Iteration 1101 / 4900) loss: 1.376244\n","(Iteration 1111 / 4900) loss: 1.168872\n","(Iteration 1121 / 4900) loss: 1.214475\n","(Iteration 1131 / 4900) loss: 1.171594\n","(Iteration 1141 / 4900) loss: 1.393386\n","(Iteration 1151 / 4900) loss: 1.176615\n","(Iteration 1161 / 4900) loss: 1.188745\n","(Iteration 1171 / 4900) loss: 1.151504\n","(Iteration 1181 / 4900) loss: 1.382062\n","(Iteration 1191 / 4900) loss: 1.340857\n","(Iteration 1201 / 4900) loss: 1.230360\n","(Iteration 1211 / 4900) loss: 0.942618\n","(Iteration 1221 / 4900) loss: 1.005393\n","(Iteration 1231 / 4900) loss: 1.205032\n","(Iteration 1241 / 4900) loss: 1.184733\n","(Iteration 1251 / 4900) loss: 1.206709\n","(Iteration 1261 / 4900) loss: 1.197250\n","(Iteration 1271 / 4900) loss: 1.099051\n","(Iteration 1281 / 4900) loss: 1.221699\n","(Iteration 1291 / 4900) loss: 1.231669\n","(Iteration 1301 / 4900) loss: 1.223355\n","(Iteration 1311 / 4900) loss: 1.115994\n","(Iteration 1321 / 4900) loss: 1.148154\n","(Iteration 1331 / 4900) loss: 0.967384\n","(Iteration 1341 / 4900) loss: 1.277122\n","(Iteration 1351 / 4900) loss: 1.169647\n","(Iteration 1361 / 4900) loss: 1.332612\n","(Iteration 1371 / 4900) loss: 1.199208\n","(Iteration 1381 / 4900) loss: 1.076100\n","(Iteration 1391 / 4900) loss: 1.114580\n","(Iteration 1401 / 4900) loss: 1.017955\n","(Iteration 1411 / 4900) loss: 1.121328\n","(Iteration 1421 / 4900) loss: 1.078708\n","(Iteration 1431 / 4900) loss: 1.274423\n","(Iteration 1441 / 4900) loss: 1.118055\n","(Iteration 1451 / 4900) loss: 1.213548\n","(Iteration 1461 / 4900) loss: 1.117587\n","(Epoch 3 / 10) train acc: 0.577000; val_acc: 0.547000\n","(Iteration 1471 / 4900) loss: 1.169589\n","(Iteration 1481 / 4900) loss: 1.184980\n","(Iteration 1491 / 4900) loss: 1.201103\n","(Iteration 1501 / 4900) loss: 1.114541\n","(Iteration 1511 / 4900) loss: 1.130164\n","(Iteration 1521 / 4900) loss: 1.183062\n","(Iteration 1531 / 4900) loss: 1.271044\n","(Iteration 1541 / 4900) loss: 1.120297\n","(Iteration 1551 / 4900) loss: 1.368295\n","(Iteration 1561 / 4900) loss: 1.109343\n","(Iteration 1571 / 4900) loss: 1.052402\n","(Iteration 1581 / 4900) loss: 1.205272\n","(Iteration 1591 / 4900) loss: 1.306205\n","(Iteration 1601 / 4900) loss: 1.233106\n","(Iteration 1611 / 4900) loss: 1.154715\n","(Iteration 1621 / 4900) loss: 1.211791\n","(Iteration 1631 / 4900) loss: 1.078449\n","(Iteration 1641 / 4900) loss: 1.264704\n","(Iteration 1651 / 4900) loss: 1.177109\n","(Iteration 1661 / 4900) loss: 1.216592\n","(Iteration 1671 / 4900) loss: 1.078035\n","(Iteration 1681 / 4900) loss: 1.220095\n","(Iteration 1691 / 4900) loss: 1.151882\n","(Iteration 1701 / 4900) loss: 1.206186\n","(Iteration 1711 / 4900) loss: 1.199758\n","(Iteration 1721 / 4900) loss: 1.035512\n","(Iteration 1731 / 4900) loss: 1.144709\n","(Iteration 1741 / 4900) loss: 1.210214\n","(Iteration 1751 / 4900) loss: 1.174712\n","(Iteration 1761 / 4900) loss: 1.116567\n","(Iteration 1771 / 4900) loss: 1.192804\n","(Iteration 1781 / 4900) loss: 1.132382\n","(Iteration 1791 / 4900) loss: 1.152870\n","(Iteration 1801 / 4900) loss: 1.088369\n","(Iteration 1811 / 4900) loss: 1.204702\n","(Iteration 1821 / 4900) loss: 1.097694\n","(Iteration 1831 / 4900) loss: 1.219800\n","(Iteration 1841 / 4900) loss: 1.110602\n","(Iteration 1851 / 4900) loss: 1.011601\n","(Iteration 1861 / 4900) loss: 1.057645\n","(Iteration 1871 / 4900) loss: 1.029907\n","(Iteration 1881 / 4900) loss: 0.952081\n","(Iteration 1891 / 4900) loss: 1.247491\n","(Iteration 1901 / 4900) loss: 1.124694\n","(Iteration 1911 / 4900) loss: 1.027298\n","(Iteration 1921 / 4900) loss: 1.292327\n","(Iteration 1931 / 4900) loss: 1.082385\n","(Iteration 1941 / 4900) loss: 1.095398\n","(Iteration 1951 / 4900) loss: 1.376242\n","(Epoch 4 / 10) train acc: 0.589000; val_acc: 0.553000\n","(Iteration 1961 / 4900) loss: 1.116906\n","(Iteration 1971 / 4900) loss: 1.126200\n","(Iteration 1981 / 4900) loss: 0.967786\n","(Iteration 1991 / 4900) loss: 1.348838\n","(Iteration 2001 / 4900) loss: 1.073403\n","(Iteration 2011 / 4900) loss: 1.025544\n","(Iteration 2021 / 4900) loss: 0.984633\n","(Iteration 2031 / 4900) loss: 0.985355\n","(Iteration 2041 / 4900) loss: 1.035783\n","(Iteration 2051 / 4900) loss: 1.266996\n","(Iteration 2061 / 4900) loss: 1.335368\n","(Iteration 2071 / 4900) loss: 1.157782\n","(Iteration 2081 / 4900) loss: 1.077036\n","(Iteration 2091 / 4900) loss: 1.056897\n","(Iteration 2101 / 4900) loss: 0.986471\n","(Iteration 2111 / 4900) loss: 1.234374\n","(Iteration 2121 / 4900) loss: 1.339412\n","(Iteration 2131 / 4900) loss: 1.213339\n","(Iteration 2141 / 4900) loss: 1.255010\n","(Iteration 2151 / 4900) loss: 1.053560\n","(Iteration 2161 / 4900) loss: 0.979278\n","(Iteration 2171 / 4900) loss: 1.009157\n","(Iteration 2181 / 4900) loss: 1.088413\n","(Iteration 2191 / 4900) loss: 1.139925\n","(Iteration 2201 / 4900) loss: 1.260170\n","(Iteration 2211 / 4900) loss: 0.884164\n","(Iteration 2221 / 4900) loss: 1.216460\n","(Iteration 2231 / 4900) loss: 1.005469\n","(Iteration 2241 / 4900) loss: 1.113751\n","(Iteration 2251 / 4900) loss: 1.149398\n","(Iteration 2261 / 4900) loss: 1.146734\n","(Iteration 2271 / 4900) loss: 1.113170\n","(Iteration 2281 / 4900) loss: 1.079762\n","(Iteration 2291 / 4900) loss: 1.336018\n","(Iteration 2301 / 4900) loss: 1.075443\n","(Iteration 2311 / 4900) loss: 0.945691\n","(Iteration 2321 / 4900) loss: 1.010979\n","(Iteration 2331 / 4900) loss: 0.941454\n","(Iteration 2341 / 4900) loss: 1.176637\n","(Iteration 2351 / 4900) loss: 1.142125\n","(Iteration 2361 / 4900) loss: 1.039447\n","(Iteration 2371 / 4900) loss: 0.903280\n","(Iteration 2381 / 4900) loss: 1.099339\n","(Iteration 2391 / 4900) loss: 1.085408\n","(Iteration 2401 / 4900) loss: 1.054099\n","(Iteration 2411 / 4900) loss: 1.126657\n","(Iteration 2421 / 4900) loss: 1.135437\n","(Iteration 2431 / 4900) loss: 1.025709\n","(Iteration 2441 / 4900) loss: 1.153154\n","(Epoch 5 / 10) train acc: 0.613000; val_acc: 0.565000\n","(Iteration 2451 / 4900) loss: 1.108120\n","(Iteration 2461 / 4900) loss: 1.234367\n","(Iteration 2471 / 4900) loss: 1.139268\n","(Iteration 2481 / 4900) loss: 1.164409\n","(Iteration 2491 / 4900) loss: 0.957918\n","(Iteration 2501 / 4900) loss: 1.082375\n","(Iteration 2511 / 4900) loss: 1.313753\n","(Iteration 2521 / 4900) loss: 1.016475\n","(Iteration 2531 / 4900) loss: 0.990802\n","(Iteration 2541 / 4900) loss: 1.211771\n","(Iteration 2551 / 4900) loss: 0.851141\n","(Iteration 2561 / 4900) loss: 1.227351\n","(Iteration 2571 / 4900) loss: 1.267881\n","(Iteration 2581 / 4900) loss: 1.171434\n","(Iteration 2591 / 4900) loss: 1.139972\n","(Iteration 2601 / 4900) loss: 0.949105\n","(Iteration 2611 / 4900) loss: 1.061254\n","(Iteration 2621 / 4900) loss: 1.120493\n","(Iteration 2631 / 4900) loss: 1.040956\n","(Iteration 2641 / 4900) loss: 0.917401\n","(Iteration 2651 / 4900) loss: 0.925366\n","(Iteration 2661 / 4900) loss: 0.981590\n","(Iteration 2671 / 4900) loss: 1.019121\n","(Iteration 2681 / 4900) loss: 1.101237\n","(Iteration 2691 / 4900) loss: 1.135768\n","(Iteration 2701 / 4900) loss: 0.981928\n","(Iteration 2711 / 4900) loss: 1.069141\n","(Iteration 2721 / 4900) loss: 1.112875\n","(Iteration 2731 / 4900) loss: 1.151702\n","(Iteration 2741 / 4900) loss: 1.095016\n","(Iteration 2751 / 4900) loss: 1.042195\n","(Iteration 2761 / 4900) loss: 1.015915\n","(Iteration 2771 / 4900) loss: 1.274114\n","(Iteration 2781 / 4900) loss: 1.129898\n","(Iteration 2791 / 4900) loss: 0.973878\n","(Iteration 2801 / 4900) loss: 1.068398\n","(Iteration 2811 / 4900) loss: 1.105241\n","(Iteration 2821 / 4900) loss: 1.091197\n","(Iteration 2831 / 4900) loss: 1.090771\n","(Iteration 2841 / 4900) loss: 1.060759\n","(Iteration 2851 / 4900) loss: 1.042575\n","(Iteration 2861 / 4900) loss: 0.878450\n","(Iteration 2871 / 4900) loss: 1.008586\n","(Iteration 2881 / 4900) loss: 1.000387\n","(Iteration 2891 / 4900) loss: 1.114567\n","(Iteration 2901 / 4900) loss: 1.008442\n","(Iteration 2911 / 4900) loss: 0.981948\n","(Iteration 2921 / 4900) loss: 1.055401\n","(Iteration 2931 / 4900) loss: 1.001597\n","(Epoch 6 / 10) train acc: 0.632000; val_acc: 0.575000\n","(Iteration 2941 / 4900) loss: 0.917736\n","(Iteration 2951 / 4900) loss: 1.108852\n","(Iteration 2961 / 4900) loss: 1.079776\n","(Iteration 2971 / 4900) loss: 0.926550\n","(Iteration 2981 / 4900) loss: 0.968178\n","(Iteration 2991 / 4900) loss: 1.091699\n","(Iteration 3001 / 4900) loss: 1.199868\n","(Iteration 3011 / 4900) loss: 1.061483\n","(Iteration 3021 / 4900) loss: 1.196749\n","(Iteration 3031 / 4900) loss: 1.219839\n","(Iteration 3041 / 4900) loss: 1.147925\n","(Iteration 3051 / 4900) loss: 0.953180\n","(Iteration 3061 / 4900) loss: 1.066035\n","(Iteration 3071 / 4900) loss: 0.998063\n","(Iteration 3081 / 4900) loss: 1.010483\n","(Iteration 3091 / 4900) loss: 1.227926\n","(Iteration 3101 / 4900) loss: 1.156792\n","(Iteration 3111 / 4900) loss: 1.038067\n","(Iteration 3121 / 4900) loss: 1.041688\n","(Iteration 3131 / 4900) loss: 0.985012\n","(Iteration 3141 / 4900) loss: 1.012776\n","(Iteration 3151 / 4900) loss: 0.962707\n","(Iteration 3161 / 4900) loss: 0.957774\n","(Iteration 3171 / 4900) loss: 1.084966\n","(Iteration 3181 / 4900) loss: 0.946000\n","(Iteration 3191 / 4900) loss: 1.073534\n","(Iteration 3201 / 4900) loss: 1.043487\n","(Iteration 3211 / 4900) loss: 1.001561\n","(Iteration 3221 / 4900) loss: 1.036534\n","(Iteration 3231 / 4900) loss: 1.271371\n","(Iteration 3241 / 4900) loss: 1.096437\n","(Iteration 3251 / 4900) loss: 0.970779\n","(Iteration 3261 / 4900) loss: 1.081308\n","(Iteration 3271 / 4900) loss: 0.857881\n","(Iteration 3281 / 4900) loss: 1.181079\n","(Iteration 3291 / 4900) loss: 1.143979\n","(Iteration 3301 / 4900) loss: 1.075905\n","(Iteration 3311 / 4900) loss: 1.211674\n","(Iteration 3321 / 4900) loss: 0.879936\n","(Iteration 3331 / 4900) loss: 0.982527\n","(Iteration 3341 / 4900) loss: 1.042075\n","(Iteration 3351 / 4900) loss: 1.092445\n","(Iteration 3361 / 4900) loss: 0.773718\n","(Iteration 3371 / 4900) loss: 1.050659\n","(Iteration 3381 / 4900) loss: 1.160022\n","(Iteration 3391 / 4900) loss: 1.096236\n","(Iteration 3401 / 4900) loss: 1.025894\n","(Iteration 3411 / 4900) loss: 0.942874\n","(Iteration 3421 / 4900) loss: 1.036408\n","(Epoch 7 / 10) train acc: 0.644000; val_acc: 0.547000\n","(Iteration 3431 / 4900) loss: 1.044234\n","(Iteration 3441 / 4900) loss: 1.009110\n","(Iteration 3451 / 4900) loss: 1.145718\n","(Iteration 3461 / 4900) loss: 1.114262\n","(Iteration 3471 / 4900) loss: 1.000342\n","(Iteration 3481 / 4900) loss: 0.933439\n","(Iteration 3491 / 4900) loss: 1.121729\n","(Iteration 3501 / 4900) loss: 0.890052\n","(Iteration 3511 / 4900) loss: 1.185670\n","(Iteration 3521 / 4900) loss: 1.075755\n","(Iteration 3531 / 4900) loss: 0.944594\n","(Iteration 3541 / 4900) loss: 1.148034\n","(Iteration 3551 / 4900) loss: 1.069112\n","(Iteration 3561 / 4900) loss: 1.017638\n","(Iteration 3571 / 4900) loss: 1.237945\n","(Iteration 3581 / 4900) loss: 0.956646\n","(Iteration 3591 / 4900) loss: 1.306507\n","(Iteration 3601 / 4900) loss: 1.031026\n","(Iteration 3611 / 4900) loss: 0.985768\n","(Iteration 3621 / 4900) loss: 1.068905\n","(Iteration 3631 / 4900) loss: 0.951036\n","(Iteration 3641 / 4900) loss: 0.917502\n","(Iteration 3651 / 4900) loss: 0.808411\n","(Iteration 3661 / 4900) loss: 1.241223\n","(Iteration 3671 / 4900) loss: 0.765718\n","(Iteration 3681 / 4900) loss: 0.919194\n","(Iteration 3691 / 4900) loss: 0.924099\n","(Iteration 3701 / 4900) loss: 1.003542\n","(Iteration 3711 / 4900) loss: 1.073885\n","(Iteration 3721 / 4900) loss: 1.034487\n","(Iteration 3731 / 4900) loss: 1.192842\n","(Iteration 3741 / 4900) loss: 0.946836\n","(Iteration 3751 / 4900) loss: 0.804919\n","(Iteration 3761 / 4900) loss: 0.929743\n","(Iteration 3771 / 4900) loss: 1.009614\n","(Iteration 3781 / 4900) loss: 1.132909\n","(Iteration 3791 / 4900) loss: 1.108443\n","(Iteration 3801 / 4900) loss: 1.164944\n","(Iteration 3811 / 4900) loss: 0.989618\n","(Iteration 3821 / 4900) loss: 1.060065\n","(Iteration 3831 / 4900) loss: 1.072594\n","(Iteration 3841 / 4900) loss: 1.042645\n","(Iteration 3851 / 4900) loss: 1.069478\n","(Iteration 3861 / 4900) loss: 1.257901\n","(Iteration 3871 / 4900) loss: 0.902107\n","(Iteration 3881 / 4900) loss: 0.892334\n","(Iteration 3891 / 4900) loss: 0.945142\n","(Iteration 3901 / 4900) loss: 0.978099\n","(Iteration 3911 / 4900) loss: 0.917107\n","(Epoch 8 / 10) train acc: 0.659000; val_acc: 0.553000\n","(Iteration 3921 / 4900) loss: 1.240398\n","(Iteration 3931 / 4900) loss: 0.979525\n","(Iteration 3941 / 4900) loss: 1.090286\n","(Iteration 3951 / 4900) loss: 0.960404\n","(Iteration 3961 / 4900) loss: 1.104110\n","(Iteration 3971 / 4900) loss: 1.201234\n","(Iteration 3981 / 4900) loss: 1.107805\n","(Iteration 3991 / 4900) loss: 1.178224\n","(Iteration 4001 / 4900) loss: 0.983759\n","(Iteration 4011 / 4900) loss: 1.110738\n","(Iteration 4021 / 4900) loss: 1.007940\n","(Iteration 4031 / 4900) loss: 1.071669\n","(Iteration 4041 / 4900) loss: 0.885067\n","(Iteration 4051 / 4900) loss: 0.807395\n","(Iteration 4061 / 4900) loss: 0.957822\n","(Iteration 4071 / 4900) loss: 1.298983\n","(Iteration 4081 / 4900) loss: 0.922881\n","(Iteration 4091 / 4900) loss: 0.915280\n","(Iteration 4101 / 4900) loss: 1.112861\n","(Iteration 4111 / 4900) loss: 0.845288\n","(Iteration 4121 / 4900) loss: 1.154131\n","(Iteration 4131 / 4900) loss: 0.888120\n","(Iteration 4141 / 4900) loss: 1.164342\n","(Iteration 4151 / 4900) loss: 1.079935\n","(Iteration 4161 / 4900) loss: 1.052318\n","(Iteration 4171 / 4900) loss: 1.186499\n","(Iteration 4181 / 4900) loss: 1.054423\n","(Iteration 4191 / 4900) loss: 0.996227\n","(Iteration 4201 / 4900) loss: 0.904455\n","(Iteration 4211 / 4900) loss: 1.106619\n","(Iteration 4221 / 4900) loss: 1.225230\n","(Iteration 4231 / 4900) loss: 0.974877\n","(Iteration 4241 / 4900) loss: 1.100175\n","(Iteration 4251 / 4900) loss: 0.994983\n","(Iteration 4261 / 4900) loss: 0.872452\n","(Iteration 4271 / 4900) loss: 0.976119\n","(Iteration 4281 / 4900) loss: 1.121275\n","(Iteration 4291 / 4900) loss: 1.234220\n","(Iteration 4301 / 4900) loss: 0.913128\n","(Iteration 4311 / 4900) loss: 0.959292\n","(Iteration 4321 / 4900) loss: 0.810034\n","(Iteration 4331 / 4900) loss: 1.069360\n","(Iteration 4341 / 4900) loss: 0.864451\n","(Iteration 4351 / 4900) loss: 0.934307\n","(Iteration 4361 / 4900) loss: 0.985374\n","(Iteration 4371 / 4900) loss: 1.002550\n","(Iteration 4381 / 4900) loss: 0.987545\n","(Iteration 4391 / 4900) loss: 0.906704\n","(Iteration 4401 / 4900) loss: 0.845817\n","(Epoch 9 / 10) train acc: 0.664000; val_acc: 0.548000\n","(Iteration 4411 / 4900) loss: 1.007782\n","(Iteration 4421 / 4900) loss: 1.024712\n","(Iteration 4431 / 4900) loss: 1.046636\n","(Iteration 4441 / 4900) loss: 0.914884\n","(Iteration 4451 / 4900) loss: 0.948789\n","(Iteration 4461 / 4900) loss: 0.992996\n","(Iteration 4471 / 4900) loss: 0.965444\n","(Iteration 4481 / 4900) loss: 0.894704\n","(Iteration 4491 / 4900) loss: 1.117848\n","(Iteration 4501 / 4900) loss: 1.059656\n","(Iteration 4511 / 4900) loss: 0.927121\n","(Iteration 4521 / 4900) loss: 0.977785\n","(Iteration 4531 / 4900) loss: 0.883684\n","(Iteration 4541 / 4900) loss: 1.077848\n","(Iteration 4551 / 4900) loss: 1.025050\n","(Iteration 4561 / 4900) loss: 1.052802\n","(Iteration 4571 / 4900) loss: 1.101123\n","(Iteration 4581 / 4900) loss: 1.013561\n","(Iteration 4591 / 4900) loss: 1.101919\n","(Iteration 4601 / 4900) loss: 0.944531\n","(Iteration 4611 / 4900) loss: 0.884687\n","(Iteration 4621 / 4900) loss: 1.058536\n","(Iteration 4631 / 4900) loss: 1.101540\n","(Iteration 4641 / 4900) loss: 1.006494\n","(Iteration 4651 / 4900) loss: 1.033889\n","(Iteration 4661 / 4900) loss: 1.018560\n","(Iteration 4671 / 4900) loss: 1.123550\n","(Iteration 4681 / 4900) loss: 0.904234\n","(Iteration 4691 / 4900) loss: 1.334968\n","(Iteration 4701 / 4900) loss: 1.062973\n","(Iteration 4711 / 4900) loss: 0.965748\n","(Iteration 4721 / 4900) loss: 0.928206\n","(Iteration 4731 / 4900) loss: 1.100641\n","(Iteration 4741 / 4900) loss: 0.868808\n","(Iteration 4751 / 4900) loss: 0.777990\n","(Iteration 4761 / 4900) loss: 0.994198\n","(Iteration 4771 / 4900) loss: 0.948425\n","(Iteration 4781 / 4900) loss: 0.822942\n","(Iteration 4791 / 4900) loss: 1.065054\n","(Iteration 4801 / 4900) loss: 0.932481\n","(Iteration 4811 / 4900) loss: 0.807351\n","(Iteration 4821 / 4900) loss: 0.851858\n","(Iteration 4831 / 4900) loss: 1.037758\n","(Iteration 4841 / 4900) loss: 1.039493\n","(Iteration 4851 / 4900) loss: 0.917239\n","(Iteration 4861 / 4900) loss: 0.923582\n","(Iteration 4871 / 4900) loss: 1.062082\n","(Iteration 4881 / 4900) loss: 0.809719\n","(Iteration 4891 / 4900) loss: 0.821513\n","(Epoch 10 / 10) train acc: 0.649000; val_acc: 0.554000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.117000; val_acc: 0.126000\n","(Iteration 11 / 4900) loss: 2.301795\n","(Iteration 21 / 4900) loss: 2.303009\n","(Iteration 31 / 4900) loss: 2.305035\n","(Iteration 41 / 4900) loss: 2.301754\n","(Iteration 51 / 4900) loss: 2.307602\n","(Iteration 61 / 4900) loss: 2.303248\n","(Iteration 71 / 4900) loss: 2.300571\n","(Iteration 81 / 4900) loss: 2.299187\n","(Iteration 91 / 4900) loss: 2.288713\n","(Iteration 101 / 4900) loss: 2.254344\n","(Iteration 111 / 4900) loss: 2.195030\n","(Iteration 121 / 4900) loss: 2.051592\n","(Iteration 131 / 4900) loss: 2.054056\n","(Iteration 141 / 4900) loss: 1.907718\n","(Iteration 151 / 4900) loss: 1.837101\n","(Iteration 161 / 4900) loss: 1.766216\n","(Iteration 171 / 4900) loss: 1.817588\n","(Iteration 181 / 4900) loss: 1.692008\n","(Iteration 191 / 4900) loss: 1.667714\n","(Iteration 201 / 4900) loss: 1.831587\n","(Iteration 211 / 4900) loss: 1.515953\n","(Iteration 221 / 4900) loss: 1.654075\n","(Iteration 231 / 4900) loss: 1.610924\n","(Iteration 241 / 4900) loss: 1.658928\n","(Iteration 251 / 4900) loss: 1.495142\n","(Iteration 261 / 4900) loss: 1.697717\n","(Iteration 271 / 4900) loss: 1.503235\n","(Iteration 281 / 4900) loss: 1.401777\n","(Iteration 291 / 4900) loss: 1.496938\n","(Iteration 301 / 4900) loss: 1.606607\n","(Iteration 311 / 4900) loss: 1.484534\n","(Iteration 321 / 4900) loss: 1.398455\n","(Iteration 331 / 4900) loss: 1.392118\n","(Iteration 341 / 4900) loss: 1.582167\n","(Iteration 351 / 4900) loss: 1.380349\n","(Iteration 361 / 4900) loss: 1.308736\n","(Iteration 371 / 4900) loss: 1.334557\n","(Iteration 381 / 4900) loss: 1.414980\n","(Iteration 391 / 4900) loss: 1.308170\n","(Iteration 401 / 4900) loss: 1.277706\n","(Iteration 411 / 4900) loss: 1.363077\n","(Iteration 421 / 4900) loss: 1.453950\n","(Iteration 431 / 4900) loss: 1.287366\n","(Iteration 441 / 4900) loss: 1.633849\n","(Iteration 451 / 4900) loss: 1.346214\n","(Iteration 461 / 4900) loss: 1.470217\n","(Iteration 471 / 4900) loss: 1.217629\n","(Iteration 481 / 4900) loss: 1.325312\n","(Epoch 1 / 10) train acc: 0.487000; val_acc: 0.487000\n","(Iteration 491 / 4900) loss: 1.444137\n","(Iteration 501 / 4900) loss: 1.318389\n","(Iteration 511 / 4900) loss: 1.334705\n","(Iteration 521 / 4900) loss: 1.468466\n","(Iteration 531 / 4900) loss: 1.267086\n","(Iteration 541 / 4900) loss: 1.382325\n","(Iteration 551 / 4900) loss: 1.255698\n","(Iteration 561 / 4900) loss: 1.218656\n","(Iteration 571 / 4900) loss: 1.182988\n","(Iteration 581 / 4900) loss: 1.285935\n","(Iteration 591 / 4900) loss: 1.363521\n","(Iteration 601 / 4900) loss: 1.205786\n","(Iteration 611 / 4900) loss: 1.312492\n","(Iteration 621 / 4900) loss: 1.375138\n","(Iteration 631 / 4900) loss: 1.387673\n","(Iteration 641 / 4900) loss: 1.320023\n","(Iteration 651 / 4900) loss: 1.251704\n","(Iteration 661 / 4900) loss: 1.238929\n","(Iteration 671 / 4900) loss: 1.295750\n","(Iteration 681 / 4900) loss: 1.413257\n","(Iteration 691 / 4900) loss: 1.294523\n","(Iteration 701 / 4900) loss: 1.408176\n","(Iteration 711 / 4900) loss: 1.475416\n","(Iteration 721 / 4900) loss: 1.156612\n","(Iteration 731 / 4900) loss: 1.302825\n","(Iteration 741 / 4900) loss: 1.282995\n","(Iteration 751 / 4900) loss: 1.421417\n","(Iteration 761 / 4900) loss: 1.349198\n","(Iteration 771 / 4900) loss: 1.459109\n","(Iteration 781 / 4900) loss: 1.147637\n","(Iteration 791 / 4900) loss: 1.472395\n","(Iteration 801 / 4900) loss: 1.204357\n","(Iteration 811 / 4900) loss: 1.433277\n","(Iteration 821 / 4900) loss: 1.250539\n","(Iteration 831 / 4900) loss: 1.119971\n","(Iteration 841 / 4900) loss: 1.173409\n","(Iteration 851 / 4900) loss: 1.287730\n","(Iteration 861 / 4900) loss: 1.337439\n","(Iteration 871 / 4900) loss: 1.298709\n","(Iteration 881 / 4900) loss: 1.223709\n","(Iteration 891 / 4900) loss: 1.189158\n","(Iteration 901 / 4900) loss: 1.272469\n","(Iteration 911 / 4900) loss: 1.231670\n","(Iteration 921 / 4900) loss: 1.393778\n","(Iteration 931 / 4900) loss: 1.109871\n","(Iteration 941 / 4900) loss: 1.207393\n","(Iteration 951 / 4900) loss: 1.482616\n","(Iteration 961 / 4900) loss: 1.213991\n","(Iteration 971 / 4900) loss: 1.159690\n","(Epoch 2 / 10) train acc: 0.528000; val_acc: 0.533000\n","(Iteration 981 / 4900) loss: 1.225366\n","(Iteration 991 / 4900) loss: 1.445237\n","(Iteration 1001 / 4900) loss: 1.393217\n","(Iteration 1011 / 4900) loss: 1.265644\n","(Iteration 1021 / 4900) loss: 1.266352\n","(Iteration 1031 / 4900) loss: 1.298578\n","(Iteration 1041 / 4900) loss: 1.312417\n","(Iteration 1051 / 4900) loss: 1.147825\n","(Iteration 1061 / 4900) loss: 1.350042\n","(Iteration 1071 / 4900) loss: 1.055627\n","(Iteration 1081 / 4900) loss: 1.111878\n","(Iteration 1091 / 4900) loss: 1.141539\n","(Iteration 1101 / 4900) loss: 1.095238\n","(Iteration 1111 / 4900) loss: 1.189965\n","(Iteration 1121 / 4900) loss: 0.968388\n","(Iteration 1131 / 4900) loss: 1.182122\n","(Iteration 1141 / 4900) loss: 1.148905\n","(Iteration 1151 / 4900) loss: 1.168770\n","(Iteration 1161 / 4900) loss: 1.102532\n","(Iteration 1171 / 4900) loss: 1.095423\n","(Iteration 1181 / 4900) loss: 1.274885\n","(Iteration 1191 / 4900) loss: 1.068084\n","(Iteration 1201 / 4900) loss: 1.210726\n","(Iteration 1211 / 4900) loss: 1.208305\n","(Iteration 1221 / 4900) loss: 1.226394\n","(Iteration 1231 / 4900) loss: 1.188889\n","(Iteration 1241 / 4900) loss: 1.361518\n","(Iteration 1251 / 4900) loss: 1.135120\n","(Iteration 1261 / 4900) loss: 1.269477\n","(Iteration 1271 / 4900) loss: 1.414355\n","(Iteration 1281 / 4900) loss: 1.287173\n","(Iteration 1291 / 4900) loss: 1.146166\n","(Iteration 1301 / 4900) loss: 1.186721\n","(Iteration 1311 / 4900) loss: 1.216718\n","(Iteration 1321 / 4900) loss: 1.311654\n","(Iteration 1331 / 4900) loss: 1.160625\n","(Iteration 1341 / 4900) loss: 1.116392\n","(Iteration 1351 / 4900) loss: 1.120885\n","(Iteration 1361 / 4900) loss: 1.152529\n","(Iteration 1371 / 4900) loss: 1.246094\n","(Iteration 1381 / 4900) loss: 1.369347\n","(Iteration 1391 / 4900) loss: 1.316469\n","(Iteration 1401 / 4900) loss: 1.137207\n","(Iteration 1411 / 4900) loss: 1.129295\n","(Iteration 1421 / 4900) loss: 1.086774\n","(Iteration 1431 / 4900) loss: 1.132024\n","(Iteration 1441 / 4900) loss: 1.009628\n","(Iteration 1451 / 4900) loss: 1.071692\n","(Iteration 1461 / 4900) loss: 1.211556\n","(Epoch 3 / 10) train acc: 0.596000; val_acc: 0.553000\n","(Iteration 1471 / 4900) loss: 1.108219\n","(Iteration 1481 / 4900) loss: 1.199349\n","(Iteration 1491 / 4900) loss: 1.172944\n","(Iteration 1501 / 4900) loss: 1.191215\n","(Iteration 1511 / 4900) loss: 1.251270\n","(Iteration 1521 / 4900) loss: 1.062395\n","(Iteration 1531 / 4900) loss: 1.344133\n","(Iteration 1541 / 4900) loss: 1.105210\n","(Iteration 1551 / 4900) loss: 1.358177\n","(Iteration 1561 / 4900) loss: 1.168769\n","(Iteration 1571 / 4900) loss: 1.288296\n","(Iteration 1581 / 4900) loss: 0.892180\n","(Iteration 1591 / 4900) loss: 1.250937\n","(Iteration 1601 / 4900) loss: 1.135152\n","(Iteration 1611 / 4900) loss: 1.139547\n","(Iteration 1621 / 4900) loss: 1.028704\n","(Iteration 1631 / 4900) loss: 0.985229\n","(Iteration 1641 / 4900) loss: 1.251394\n","(Iteration 1651 / 4900) loss: 1.000414\n","(Iteration 1661 / 4900) loss: 1.078001\n","(Iteration 1671 / 4900) loss: 1.136496\n","(Iteration 1681 / 4900) loss: 1.053550\n","(Iteration 1691 / 4900) loss: 1.299169\n","(Iteration 1701 / 4900) loss: 1.006844\n","(Iteration 1711 / 4900) loss: 1.275278\n","(Iteration 1721 / 4900) loss: 1.111701\n","(Iteration 1731 / 4900) loss: 1.124522\n","(Iteration 1741 / 4900) loss: 1.098888\n","(Iteration 1751 / 4900) loss: 1.289260\n","(Iteration 1761 / 4900) loss: 1.153675\n","(Iteration 1771 / 4900) loss: 1.060164\n","(Iteration 1781 / 4900) loss: 1.266317\n","(Iteration 1791 / 4900) loss: 1.184567\n","(Iteration 1801 / 4900) loss: 0.983532\n","(Iteration 1811 / 4900) loss: 1.084435\n","(Iteration 1821 / 4900) loss: 1.054935\n","(Iteration 1831 / 4900) loss: 1.058894\n","(Iteration 1841 / 4900) loss: 1.239191\n","(Iteration 1851 / 4900) loss: 1.007594\n","(Iteration 1861 / 4900) loss: 0.934633\n","(Iteration 1871 / 4900) loss: 0.960925\n","(Iteration 1881 / 4900) loss: 0.963639\n","(Iteration 1891 / 4900) loss: 1.181927\n","(Iteration 1901 / 4900) loss: 1.057508\n","(Iteration 1911 / 4900) loss: 1.183147\n","(Iteration 1921 / 4900) loss: 1.099943\n","(Iteration 1931 / 4900) loss: 0.862960\n","(Iteration 1941 / 4900) loss: 1.079606\n","(Iteration 1951 / 4900) loss: 1.250347\n","(Epoch 4 / 10) train acc: 0.610000; val_acc: 0.551000\n","(Iteration 1961 / 4900) loss: 1.134014\n","(Iteration 1971 / 4900) loss: 1.058315\n","(Iteration 1981 / 4900) loss: 1.167386\n","(Iteration 1991 / 4900) loss: 1.122125\n","(Iteration 2001 / 4900) loss: 1.148943\n","(Iteration 2011 / 4900) loss: 1.242838\n","(Iteration 2021 / 4900) loss: 1.165313\n","(Iteration 2031 / 4900) loss: 1.177045\n","(Iteration 2041 / 4900) loss: 1.195204\n","(Iteration 2051 / 4900) loss: 1.104242\n","(Iteration 2061 / 4900) loss: 1.067009\n","(Iteration 2071 / 4900) loss: 0.953137\n","(Iteration 2081 / 4900) loss: 0.933946\n","(Iteration 2091 / 4900) loss: 1.082964\n","(Iteration 2101 / 4900) loss: 1.109990\n","(Iteration 2111 / 4900) loss: 1.110750\n","(Iteration 2121 / 4900) loss: 1.089962\n","(Iteration 2131 / 4900) loss: 1.368271\n","(Iteration 2141 / 4900) loss: 1.095877\n","(Iteration 2151 / 4900) loss: 1.162625\n","(Iteration 2161 / 4900) loss: 1.238524\n","(Iteration 2171 / 4900) loss: 1.038029\n","(Iteration 2181 / 4900) loss: 0.934486\n","(Iteration 2191 / 4900) loss: 1.118786\n","(Iteration 2201 / 4900) loss: 1.060272\n","(Iteration 2211 / 4900) loss: 1.086914\n","(Iteration 2221 / 4900) loss: 1.116694\n","(Iteration 2231 / 4900) loss: 0.772553\n","(Iteration 2241 / 4900) loss: 1.148326\n","(Iteration 2251 / 4900) loss: 0.942180\n","(Iteration 2261 / 4900) loss: 1.184521\n","(Iteration 2271 / 4900) loss: 1.131758\n","(Iteration 2281 / 4900) loss: 1.034582\n","(Iteration 2291 / 4900) loss: 1.063456\n","(Iteration 2301 / 4900) loss: 1.198370\n","(Iteration 2311 / 4900) loss: 0.953783\n","(Iteration 2321 / 4900) loss: 1.157797\n","(Iteration 2331 / 4900) loss: 1.075110\n","(Iteration 2341 / 4900) loss: 0.876241\n","(Iteration 2351 / 4900) loss: 0.960520\n","(Iteration 2361 / 4900) loss: 0.995608\n","(Iteration 2371 / 4900) loss: 0.972755\n","(Iteration 2381 / 4900) loss: 1.058497\n","(Iteration 2391 / 4900) loss: 1.013730\n","(Iteration 2401 / 4900) loss: 1.123365\n","(Iteration 2411 / 4900) loss: 1.145653\n","(Iteration 2421 / 4900) loss: 1.019894\n","(Iteration 2431 / 4900) loss: 0.870203\n","(Iteration 2441 / 4900) loss: 0.940972\n","(Epoch 5 / 10) train acc: 0.640000; val_acc: 0.583000\n","(Iteration 2451 / 4900) loss: 1.048743\n","(Iteration 2461 / 4900) loss: 1.206023\n","(Iteration 2471 / 4900) loss: 1.038015\n","(Iteration 2481 / 4900) loss: 1.012648\n","(Iteration 2491 / 4900) loss: 1.068356\n","(Iteration 2501 / 4900) loss: 1.100168\n","(Iteration 2511 / 4900) loss: 1.165096\n","(Iteration 2521 / 4900) loss: 0.930540\n","(Iteration 2531 / 4900) loss: 0.929499\n","(Iteration 2541 / 4900) loss: 0.942654\n","(Iteration 2551 / 4900) loss: 1.022556\n","(Iteration 2561 / 4900) loss: 1.002096\n","(Iteration 2571 / 4900) loss: 0.952327\n","(Iteration 2581 / 4900) loss: 0.963169\n","(Iteration 2591 / 4900) loss: 0.839692\n","(Iteration 2601 / 4900) loss: 1.183029\n","(Iteration 2611 / 4900) loss: 1.010884\n","(Iteration 2621 / 4900) loss: 0.970017\n","(Iteration 2631 / 4900) loss: 1.089770\n","(Iteration 2641 / 4900) loss: 0.853778\n","(Iteration 2651 / 4900) loss: 1.066169\n","(Iteration 2661 / 4900) loss: 0.821237\n","(Iteration 2671 / 4900) loss: 1.046105\n","(Iteration 2681 / 4900) loss: 1.068048\n","(Iteration 2691 / 4900) loss: 0.909031\n","(Iteration 2701 / 4900) loss: 0.998631\n","(Iteration 2711 / 4900) loss: 1.013499\n","(Iteration 2721 / 4900) loss: 1.171438\n","(Iteration 2731 / 4900) loss: 0.983699\n","(Iteration 2741 / 4900) loss: 0.916904\n","(Iteration 2751 / 4900) loss: 1.068366\n","(Iteration 2761 / 4900) loss: 0.947207\n","(Iteration 2771 / 4900) loss: 0.890517\n","(Iteration 2781 / 4900) loss: 0.899686\n","(Iteration 2791 / 4900) loss: 0.794444\n","(Iteration 2801 / 4900) loss: 0.792096\n","(Iteration 2811 / 4900) loss: 0.969059\n","(Iteration 2821 / 4900) loss: 0.869860\n","(Iteration 2831 / 4900) loss: 0.975784\n","(Iteration 2841 / 4900) loss: 1.089248\n","(Iteration 2851 / 4900) loss: 0.868823\n","(Iteration 2861 / 4900) loss: 1.091710\n","(Iteration 2871 / 4900) loss: 1.187610\n","(Iteration 2881 / 4900) loss: 1.116857\n","(Iteration 2891 / 4900) loss: 0.799145\n","(Iteration 2901 / 4900) loss: 0.768715\n","(Iteration 2911 / 4900) loss: 0.918655\n","(Iteration 2921 / 4900) loss: 0.898130\n","(Iteration 2931 / 4900) loss: 0.902463\n","(Epoch 6 / 10) train acc: 0.690000; val_acc: 0.575000\n","(Iteration 2941 / 4900) loss: 0.876303\n","(Iteration 2951 / 4900) loss: 0.752784\n","(Iteration 2961 / 4900) loss: 0.974776\n","(Iteration 2971 / 4900) loss: 0.839963\n","(Iteration 2981 / 4900) loss: 0.979132\n","(Iteration 2991 / 4900) loss: 0.717627\n","(Iteration 3001 / 4900) loss: 0.921242\n","(Iteration 3011 / 4900) loss: 0.946994\n","(Iteration 3021 / 4900) loss: 1.095612\n","(Iteration 3031 / 4900) loss: 0.967852\n","(Iteration 3041 / 4900) loss: 0.846419\n","(Iteration 3051 / 4900) loss: 0.932770\n","(Iteration 3061 / 4900) loss: 0.902502\n","(Iteration 3071 / 4900) loss: 1.100613\n","(Iteration 3081 / 4900) loss: 0.763756\n","(Iteration 3091 / 4900) loss: 1.238265\n","(Iteration 3101 / 4900) loss: 0.934836\n","(Iteration 3111 / 4900) loss: 0.795301\n","(Iteration 3121 / 4900) loss: 0.745092\n","(Iteration 3131 / 4900) loss: 0.966005\n","(Iteration 3141 / 4900) loss: 0.914167\n","(Iteration 3151 / 4900) loss: 0.932670\n","(Iteration 3161 / 4900) loss: 0.867488\n","(Iteration 3171 / 4900) loss: 0.939626\n","(Iteration 3181 / 4900) loss: 1.085292\n","(Iteration 3191 / 4900) loss: 1.228236\n","(Iteration 3201 / 4900) loss: 1.030813\n","(Iteration 3211 / 4900) loss: 0.912834\n","(Iteration 3221 / 4900) loss: 0.907965\n","(Iteration 3231 / 4900) loss: 1.067104\n","(Iteration 3241 / 4900) loss: 0.914266\n","(Iteration 3251 / 4900) loss: 0.813997\n","(Iteration 3261 / 4900) loss: 0.952646\n","(Iteration 3271 / 4900) loss: 0.787108\n","(Iteration 3281 / 4900) loss: 0.906781\n","(Iteration 3291 / 4900) loss: 0.967773\n","(Iteration 3301 / 4900) loss: 0.985570\n","(Iteration 3311 / 4900) loss: 1.035596\n","(Iteration 3321 / 4900) loss: 0.943173\n","(Iteration 3331 / 4900) loss: 0.895747\n","(Iteration 3341 / 4900) loss: 0.839740\n","(Iteration 3351 / 4900) loss: 0.795469\n","(Iteration 3361 / 4900) loss: 0.651271\n","(Iteration 3371 / 4900) loss: 0.944561\n","(Iteration 3381 / 4900) loss: 0.827971\n","(Iteration 3391 / 4900) loss: 1.059656\n","(Iteration 3401 / 4900) loss: 0.870464\n","(Iteration 3411 / 4900) loss: 0.943728\n","(Iteration 3421 / 4900) loss: 0.847367\n","(Epoch 7 / 10) train acc: 0.688000; val_acc: 0.575000\n","(Iteration 3431 / 4900) loss: 0.978273\n","(Iteration 3441 / 4900) loss: 0.905167\n","(Iteration 3451 / 4900) loss: 0.929142\n","(Iteration 3461 / 4900) loss: 0.933637\n","(Iteration 3471 / 4900) loss: 0.974301\n","(Iteration 3481 / 4900) loss: 0.766319\n","(Iteration 3491 / 4900) loss: 0.810774\n","(Iteration 3501 / 4900) loss: 0.965556\n","(Iteration 3511 / 4900) loss: 0.855771\n","(Iteration 3521 / 4900) loss: 0.816221\n","(Iteration 3531 / 4900) loss: 0.819784\n","(Iteration 3541 / 4900) loss: 0.892070\n","(Iteration 3551 / 4900) loss: 0.902186\n","(Iteration 3561 / 4900) loss: 1.027837\n","(Iteration 3571 / 4900) loss: 1.033678\n","(Iteration 3581 / 4900) loss: 0.817992\n","(Iteration 3591 / 4900) loss: 0.900644\n","(Iteration 3601 / 4900) loss: 0.785065\n","(Iteration 3611 / 4900) loss: 0.902818\n","(Iteration 3621 / 4900) loss: 0.855708\n","(Iteration 3631 / 4900) loss: 1.127429\n","(Iteration 3641 / 4900) loss: 0.934047\n","(Iteration 3651 / 4900) loss: 0.900414\n","(Iteration 3661 / 4900) loss: 0.831378\n","(Iteration 3671 / 4900) loss: 0.802054\n","(Iteration 3681 / 4900) loss: 0.792562\n","(Iteration 3691 / 4900) loss: 0.832841\n","(Iteration 3701 / 4900) loss: 0.989074\n","(Iteration 3711 / 4900) loss: 1.026686\n","(Iteration 3721 / 4900) loss: 0.904065\n","(Iteration 3731 / 4900) loss: 1.018333\n","(Iteration 3741 / 4900) loss: 0.965341\n","(Iteration 3751 / 4900) loss: 0.900769\n","(Iteration 3761 / 4900) loss: 0.913218\n","(Iteration 3771 / 4900) loss: 0.877694\n","(Iteration 3781 / 4900) loss: 1.041109\n","(Iteration 3791 / 4900) loss: 0.803971\n","(Iteration 3801 / 4900) loss: 0.984073\n","(Iteration 3811 / 4900) loss: 1.080322\n","(Iteration 3821 / 4900) loss: 0.831387\n","(Iteration 3831 / 4900) loss: 0.920666\n","(Iteration 3841 / 4900) loss: 0.768406\n","(Iteration 3851 / 4900) loss: 0.972592\n","(Iteration 3861 / 4900) loss: 0.933272\n","(Iteration 3871 / 4900) loss: 0.877390\n","(Iteration 3881 / 4900) loss: 0.633650\n","(Iteration 3891 / 4900) loss: 0.895246\n","(Iteration 3901 / 4900) loss: 0.985096\n","(Iteration 3911 / 4900) loss: 0.657363\n","(Epoch 8 / 10) train acc: 0.712000; val_acc: 0.561000\n","(Iteration 3921 / 4900) loss: 1.019446\n","(Iteration 3931 / 4900) loss: 0.814501\n","(Iteration 3941 / 4900) loss: 0.795732\n","(Iteration 3951 / 4900) loss: 0.851998\n","(Iteration 3961 / 4900) loss: 0.805643\n","(Iteration 3971 / 4900) loss: 0.801951\n","(Iteration 3981 / 4900) loss: 0.951237\n","(Iteration 3991 / 4900) loss: 0.798542\n","(Iteration 4001 / 4900) loss: 0.895652\n","(Iteration 4011 / 4900) loss: 0.906602\n","(Iteration 4021 / 4900) loss: 1.033815\n","(Iteration 4031 / 4900) loss: 0.939684\n","(Iteration 4041 / 4900) loss: 1.095170\n","(Iteration 4051 / 4900) loss: 0.803672\n","(Iteration 4061 / 4900) loss: 0.932424\n","(Iteration 4071 / 4900) loss: 0.863706\n","(Iteration 4081 / 4900) loss: 0.827084\n","(Iteration 4091 / 4900) loss: 0.820374\n","(Iteration 4101 / 4900) loss: 0.935905\n","(Iteration 4111 / 4900) loss: 0.750067\n","(Iteration 4121 / 4900) loss: 0.647124\n","(Iteration 4131 / 4900) loss: 0.881460\n","(Iteration 4141 / 4900) loss: 0.863034\n","(Iteration 4151 / 4900) loss: 0.756094\n","(Iteration 4161 / 4900) loss: 0.815225\n","(Iteration 4171 / 4900) loss: 0.769652\n","(Iteration 4181 / 4900) loss: 0.921381\n","(Iteration 4191 / 4900) loss: 0.740904\n","(Iteration 4201 / 4900) loss: 0.954806\n","(Iteration 4211 / 4900) loss: 0.882944\n","(Iteration 4221 / 4900) loss: 0.789222\n","(Iteration 4231 / 4900) loss: 0.877888\n","(Iteration 4241 / 4900) loss: 1.150358\n","(Iteration 4251 / 4900) loss: 0.725081\n","(Iteration 4261 / 4900) loss: 0.835918\n","(Iteration 4271 / 4900) loss: 0.749092\n","(Iteration 4281 / 4900) loss: 0.912350\n","(Iteration 4291 / 4900) loss: 0.771084\n","(Iteration 4301 / 4900) loss: 0.864263\n","(Iteration 4311 / 4900) loss: 0.855528\n","(Iteration 4321 / 4900) loss: 0.984162\n","(Iteration 4331 / 4900) loss: 0.751884\n","(Iteration 4341 / 4900) loss: 0.788596\n","(Iteration 4351 / 4900) loss: 0.907220\n","(Iteration 4361 / 4900) loss: 0.893982\n","(Iteration 4371 / 4900) loss: 0.944634\n","(Iteration 4381 / 4900) loss: 0.728140\n","(Iteration 4391 / 4900) loss: 0.832972\n","(Iteration 4401 / 4900) loss: 0.895106\n","(Epoch 9 / 10) train acc: 0.713000; val_acc: 0.582000\n","(Iteration 4411 / 4900) loss: 0.980970\n","(Iteration 4421 / 4900) loss: 0.812345\n","(Iteration 4431 / 4900) loss: 0.852968\n","(Iteration 4441 / 4900) loss: 0.911625\n","(Iteration 4451 / 4900) loss: 0.777918\n","(Iteration 4461 / 4900) loss: 0.688094\n","(Iteration 4471 / 4900) loss: 0.932750\n","(Iteration 4481 / 4900) loss: 0.759763\n","(Iteration 4491 / 4900) loss: 0.674685\n","(Iteration 4501 / 4900) loss: 0.713165\n","(Iteration 4511 / 4900) loss: 0.744095\n","(Iteration 4521 / 4900) loss: 0.766842\n","(Iteration 4531 / 4900) loss: 0.822160\n","(Iteration 4541 / 4900) loss: 0.942806\n","(Iteration 4551 / 4900) loss: 0.921067\n","(Iteration 4561 / 4900) loss: 0.801099\n","(Iteration 4571 / 4900) loss: 0.648434\n","(Iteration 4581 / 4900) loss: 0.825434\n","(Iteration 4591 / 4900) loss: 0.718506\n","(Iteration 4601 / 4900) loss: 0.739586\n","(Iteration 4611 / 4900) loss: 0.765339\n","(Iteration 4621 / 4900) loss: 0.788946\n","(Iteration 4631 / 4900) loss: 0.744208\n","(Iteration 4641 / 4900) loss: 0.813086\n","(Iteration 4651 / 4900) loss: 0.684751\n","(Iteration 4661 / 4900) loss: 0.824099\n","(Iteration 4671 / 4900) loss: 0.638003\n","(Iteration 4681 / 4900) loss: 0.982949\n","(Iteration 4691 / 4900) loss: 0.555999\n","(Iteration 4701 / 4900) loss: 0.833904\n","(Iteration 4711 / 4900) loss: 0.596624\n","(Iteration 4721 / 4900) loss: 0.804648\n","(Iteration 4731 / 4900) loss: 0.663443\n","(Iteration 4741 / 4900) loss: 0.695032\n","(Iteration 4751 / 4900) loss: 0.690553\n","(Iteration 4761 / 4900) loss: 0.687873\n","(Iteration 4771 / 4900) loss: 0.651728\n","(Iteration 4781 / 4900) loss: 0.919553\n","(Iteration 4791 / 4900) loss: 0.698356\n","(Iteration 4801 / 4900) loss: 0.929686\n","(Iteration 4811 / 4900) loss: 0.687019\n","(Iteration 4821 / 4900) loss: 0.728101\n","(Iteration 4831 / 4900) loss: 0.724936\n","(Iteration 4841 / 4900) loss: 0.962456\n","(Iteration 4851 / 4900) loss: 0.790179\n","(Iteration 4861 / 4900) loss: 0.835710\n","(Iteration 4871 / 4900) loss: 0.874838\n","(Iteration 4881 / 4900) loss: 0.858388\n","(Iteration 4891 / 4900) loss: 0.820621\n","(Epoch 10 / 10) train acc: 0.720000; val_acc: 0.582000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.093000; val_acc: 0.079000\n","(Iteration 11 / 4900) loss: 2.302356\n","(Iteration 21 / 4900) loss: 2.304045\n","(Iteration 31 / 4900) loss: 2.297619\n","(Iteration 41 / 4900) loss: 2.303387\n","(Iteration 51 / 4900) loss: 2.303555\n","(Iteration 61 / 4900) loss: 2.304077\n","(Iteration 71 / 4900) loss: 2.303386\n","(Iteration 81 / 4900) loss: 2.308769\n","(Iteration 91 / 4900) loss: 2.304366\n","(Iteration 101 / 4900) loss: 2.300164\n","(Iteration 111 / 4900) loss: 2.299081\n","(Iteration 121 / 4900) loss: 2.304899\n","(Iteration 131 / 4900) loss: 2.304300\n","(Iteration 141 / 4900) loss: 2.292443\n","(Iteration 151 / 4900) loss: 2.276654\n","(Iteration 161 / 4900) loss: 2.218858\n","(Iteration 171 / 4900) loss: 2.107414\n","(Iteration 181 / 4900) loss: 1.970600\n","(Iteration 191 / 4900) loss: 1.926498\n","(Iteration 201 / 4900) loss: 1.952634\n","(Iteration 211 / 4900) loss: 1.732858\n","(Iteration 221 / 4900) loss: 1.798217\n","(Iteration 231 / 4900) loss: 1.848058\n","(Iteration 241 / 4900) loss: 1.657067\n","(Iteration 251 / 4900) loss: 1.633811\n","(Iteration 261 / 4900) loss: 1.630861\n","(Iteration 271 / 4900) loss: 1.815801\n","(Iteration 281 / 4900) loss: 1.731054\n","(Iteration 291 / 4900) loss: 1.684885\n","(Iteration 301 / 4900) loss: 1.566759\n","(Iteration 311 / 4900) loss: 1.662494\n","(Iteration 321 / 4900) loss: 1.570435\n","(Iteration 331 / 4900) loss: 1.467599\n","(Iteration 341 / 4900) loss: 1.554059\n","(Iteration 351 / 4900) loss: 1.447107\n","(Iteration 361 / 4900) loss: 1.632491\n","(Iteration 371 / 4900) loss: 1.572186\n","(Iteration 381 / 4900) loss: 1.548427\n","(Iteration 391 / 4900) loss: 1.410558\n","(Iteration 401 / 4900) loss: 1.275018\n","(Iteration 411 / 4900) loss: 1.318257\n","(Iteration 421 / 4900) loss: 1.609483\n","(Iteration 431 / 4900) loss: 1.323513\n","(Iteration 441 / 4900) loss: 1.375616\n","(Iteration 451 / 4900) loss: 1.336930\n","(Iteration 461 / 4900) loss: 1.201851\n","(Iteration 471 / 4900) loss: 1.391205\n","(Iteration 481 / 4900) loss: 1.452989\n","(Epoch 1 / 10) train acc: 0.503000; val_acc: 0.487000\n","(Iteration 491 / 4900) loss: 1.197577\n","(Iteration 501 / 4900) loss: 1.410201\n","(Iteration 511 / 4900) loss: 1.344213\n","(Iteration 521 / 4900) loss: 1.416281\n","(Iteration 531 / 4900) loss: 1.259767\n","(Iteration 541 / 4900) loss: 1.448259\n","(Iteration 551 / 4900) loss: 1.345073\n","(Iteration 561 / 4900) loss: 1.397442\n","(Iteration 571 / 4900) loss: 1.378860\n","(Iteration 581 / 4900) loss: 1.299497\n","(Iteration 591 / 4900) loss: 1.334836\n","(Iteration 601 / 4900) loss: 1.385000\n","(Iteration 611 / 4900) loss: 1.283927\n","(Iteration 621 / 4900) loss: 1.145769\n","(Iteration 631 / 4900) loss: 1.535158\n","(Iteration 641 / 4900) loss: 1.530287\n","(Iteration 651 / 4900) loss: 1.296630\n","(Iteration 661 / 4900) loss: 1.295034\n","(Iteration 671 / 4900) loss: 1.323044\n","(Iteration 681 / 4900) loss: 1.388872\n","(Iteration 691 / 4900) loss: 1.254570\n","(Iteration 701 / 4900) loss: 1.477448\n","(Iteration 711 / 4900) loss: 1.034378\n","(Iteration 721 / 4900) loss: 1.501711\n","(Iteration 731 / 4900) loss: 1.424449\n","(Iteration 741 / 4900) loss: 1.318295\n","(Iteration 751 / 4900) loss: 1.267569\n","(Iteration 761 / 4900) loss: 1.382009\n","(Iteration 771 / 4900) loss: 1.363270\n","(Iteration 781 / 4900) loss: 1.369666\n","(Iteration 791 / 4900) loss: 1.229494\n","(Iteration 801 / 4900) loss: 1.156831\n","(Iteration 811 / 4900) loss: 1.337947\n","(Iteration 821 / 4900) loss: 1.195396\n","(Iteration 831 / 4900) loss: 1.312200\n","(Iteration 841 / 4900) loss: 1.232351\n","(Iteration 851 / 4900) loss: 1.393872\n","(Iteration 861 / 4900) loss: 1.114434\n","(Iteration 871 / 4900) loss: 1.366863\n","(Iteration 881 / 4900) loss: 1.213541\n","(Iteration 891 / 4900) loss: 1.331767\n","(Iteration 901 / 4900) loss: 1.144453\n","(Iteration 911 / 4900) loss: 1.274133\n","(Iteration 921 / 4900) loss: 1.323112\n","(Iteration 931 / 4900) loss: 1.345862\n","(Iteration 941 / 4900) loss: 1.301881\n","(Iteration 951 / 4900) loss: 1.279582\n","(Iteration 961 / 4900) loss: 1.299655\n","(Iteration 971 / 4900) loss: 1.327360\n","(Epoch 2 / 10) train acc: 0.557000; val_acc: 0.521000\n","(Iteration 981 / 4900) loss: 1.077465\n","(Iteration 991 / 4900) loss: 1.267680\n","(Iteration 1001 / 4900) loss: 1.253859\n","(Iteration 1011 / 4900) loss: 1.137390\n","(Iteration 1021 / 4900) loss: 1.108880\n","(Iteration 1031 / 4900) loss: 1.084911\n","(Iteration 1041 / 4900) loss: 1.316709\n","(Iteration 1051 / 4900) loss: 1.381561\n","(Iteration 1061 / 4900) loss: 1.139305\n","(Iteration 1071 / 4900) loss: 1.336640\n","(Iteration 1081 / 4900) loss: 1.158577\n","(Iteration 1091 / 4900) loss: 1.233748\n","(Iteration 1101 / 4900) loss: 1.347800\n","(Iteration 1111 / 4900) loss: 1.024111\n","(Iteration 1121 / 4900) loss: 1.322133\n","(Iteration 1131 / 4900) loss: 1.265705\n","(Iteration 1141 / 4900) loss: 1.160220\n","(Iteration 1151 / 4900) loss: 1.266848\n","(Iteration 1161 / 4900) loss: 1.104206\n","(Iteration 1171 / 4900) loss: 1.282693\n","(Iteration 1181 / 4900) loss: 1.314680\n","(Iteration 1191 / 4900) loss: 1.339780\n","(Iteration 1201 / 4900) loss: 1.095251\n","(Iteration 1211 / 4900) loss: 1.253990\n","(Iteration 1221 / 4900) loss: 1.310484\n","(Iteration 1231 / 4900) loss: 1.538056\n","(Iteration 1241 / 4900) loss: 1.182725\n","(Iteration 1251 / 4900) loss: 1.376835\n","(Iteration 1261 / 4900) loss: 1.197575\n","(Iteration 1271 / 4900) loss: 1.445593\n","(Iteration 1281 / 4900) loss: 1.086374\n","(Iteration 1291 / 4900) loss: 1.091297\n","(Iteration 1301 / 4900) loss: 1.261231\n","(Iteration 1311 / 4900) loss: 1.089933\n","(Iteration 1321 / 4900) loss: 1.329163\n","(Iteration 1331 / 4900) loss: 1.076623\n","(Iteration 1341 / 4900) loss: 1.082765\n","(Iteration 1351 / 4900) loss: 1.267425\n","(Iteration 1361 / 4900) loss: 1.069361\n","(Iteration 1371 / 4900) loss: 1.102352\n","(Iteration 1381 / 4900) loss: 1.188362\n","(Iteration 1391 / 4900) loss: 1.070521\n","(Iteration 1401 / 4900) loss: 1.295306\n","(Iteration 1411 / 4900) loss: 1.160283\n","(Iteration 1421 / 4900) loss: 1.182202\n","(Iteration 1431 / 4900) loss: 1.408274\n","(Iteration 1441 / 4900) loss: 1.153129\n","(Iteration 1451 / 4900) loss: 1.151939\n","(Iteration 1461 / 4900) loss: 1.199731\n","(Epoch 3 / 10) train acc: 0.580000; val_acc: 0.554000\n","(Iteration 1471 / 4900) loss: 1.226678\n","(Iteration 1481 / 4900) loss: 0.998747\n","(Iteration 1491 / 4900) loss: 1.180343\n","(Iteration 1501 / 4900) loss: 1.082040\n","(Iteration 1511 / 4900) loss: 1.193537\n","(Iteration 1521 / 4900) loss: 1.063965\n","(Iteration 1531 / 4900) loss: 0.810834\n","(Iteration 1541 / 4900) loss: 1.054405\n","(Iteration 1551 / 4900) loss: 1.233663\n","(Iteration 1561 / 4900) loss: 1.056622\n","(Iteration 1571 / 4900) loss: 1.147584\n","(Iteration 1581 / 4900) loss: 1.239542\n","(Iteration 1591 / 4900) loss: 1.114546\n","(Iteration 1601 / 4900) loss: 1.300602\n","(Iteration 1611 / 4900) loss: 1.105898\n","(Iteration 1621 / 4900) loss: 1.144062\n","(Iteration 1631 / 4900) loss: 1.042660\n","(Iteration 1641 / 4900) loss: 1.176459\n","(Iteration 1651 / 4900) loss: 1.253904\n","(Iteration 1661 / 4900) loss: 1.033904\n","(Iteration 1671 / 4900) loss: 1.295403\n","(Iteration 1681 / 4900) loss: 1.324406\n","(Iteration 1691 / 4900) loss: 1.084437\n","(Iteration 1701 / 4900) loss: 1.186779\n","(Iteration 1711 / 4900) loss: 1.300616\n","(Iteration 1721 / 4900) loss: 1.173425\n","(Iteration 1731 / 4900) loss: 1.164106\n","(Iteration 1741 / 4900) loss: 1.179172\n","(Iteration 1751 / 4900) loss: 0.997884\n","(Iteration 1761 / 4900) loss: 1.049847\n","(Iteration 1771 / 4900) loss: 1.005405\n","(Iteration 1781 / 4900) loss: 1.186638\n","(Iteration 1791 / 4900) loss: 1.070808\n","(Iteration 1801 / 4900) loss: 1.277447\n","(Iteration 1811 / 4900) loss: 0.946334\n","(Iteration 1821 / 4900) loss: 0.986956\n","(Iteration 1831 / 4900) loss: 0.911827\n","(Iteration 1841 / 4900) loss: 1.047177\n","(Iteration 1851 / 4900) loss: 1.255638\n","(Iteration 1861 / 4900) loss: 0.987438\n","(Iteration 1871 / 4900) loss: 1.187220\n","(Iteration 1881 / 4900) loss: 1.010466\n","(Iteration 1891 / 4900) loss: 1.315543\n","(Iteration 1901 / 4900) loss: 1.292725\n","(Iteration 1911 / 4900) loss: 1.130084\n","(Iteration 1921 / 4900) loss: 1.009752\n","(Iteration 1931 / 4900) loss: 0.976996\n","(Iteration 1941 / 4900) loss: 1.234387\n","(Iteration 1951 / 4900) loss: 1.215758\n","(Epoch 4 / 10) train acc: 0.605000; val_acc: 0.556000\n","(Iteration 1961 / 4900) loss: 1.011888\n","(Iteration 1971 / 4900) loss: 1.243208\n","(Iteration 1981 / 4900) loss: 1.131870\n","(Iteration 1991 / 4900) loss: 1.158014\n","(Iteration 2001 / 4900) loss: 1.283916\n","(Iteration 2011 / 4900) loss: 0.962237\n","(Iteration 2021 / 4900) loss: 1.083365\n","(Iteration 2031 / 4900) loss: 0.969939\n","(Iteration 2041 / 4900) loss: 1.208859\n","(Iteration 2051 / 4900) loss: 1.003106\n","(Iteration 2061 / 4900) loss: 1.225329\n","(Iteration 2071 / 4900) loss: 1.018392\n","(Iteration 2081 / 4900) loss: 0.997996\n","(Iteration 2091 / 4900) loss: 1.101948\n","(Iteration 2101 / 4900) loss: 1.213696\n","(Iteration 2111 / 4900) loss: 0.883208\n","(Iteration 2121 / 4900) loss: 1.212909\n","(Iteration 2131 / 4900) loss: 1.033611\n","(Iteration 2141 / 4900) loss: 1.082870\n","(Iteration 2151 / 4900) loss: 0.951038\n","(Iteration 2161 / 4900) loss: 1.010528\n","(Iteration 2171 / 4900) loss: 1.126733\n","(Iteration 2181 / 4900) loss: 0.883089\n","(Iteration 2191 / 4900) loss: 1.311510\n","(Iteration 2201 / 4900) loss: 0.989315\n","(Iteration 2211 / 4900) loss: 0.937789\n","(Iteration 2221 / 4900) loss: 1.061789\n","(Iteration 2231 / 4900) loss: 1.097851\n","(Iteration 2241 / 4900) loss: 1.153306\n","(Iteration 2251 / 4900) loss: 0.964496\n","(Iteration 2261 / 4900) loss: 1.090247\n","(Iteration 2271 / 4900) loss: 1.088999\n","(Iteration 2281 / 4900) loss: 0.846099\n","(Iteration 2291 / 4900) loss: 0.946597\n","(Iteration 2301 / 4900) loss: 1.081920\n","(Iteration 2311 / 4900) loss: 1.116895\n","(Iteration 2321 / 4900) loss: 1.228571\n","(Iteration 2331 / 4900) loss: 1.221006\n","(Iteration 2341 / 4900) loss: 1.048768\n","(Iteration 2351 / 4900) loss: 1.144981\n","(Iteration 2361 / 4900) loss: 0.798417\n","(Iteration 2371 / 4900) loss: 1.147789\n","(Iteration 2381 / 4900) loss: 1.145306\n","(Iteration 2391 / 4900) loss: 1.052193\n","(Iteration 2401 / 4900) loss: 1.042972\n","(Iteration 2411 / 4900) loss: 1.108588\n","(Iteration 2421 / 4900) loss: 1.113984\n","(Iteration 2431 / 4900) loss: 0.981434\n","(Iteration 2441 / 4900) loss: 0.922676\n","(Epoch 5 / 10) train acc: 0.659000; val_acc: 0.565000\n","(Iteration 2451 / 4900) loss: 1.061602\n","(Iteration 2461 / 4900) loss: 1.041592\n","(Iteration 2471 / 4900) loss: 1.107812\n","(Iteration 2481 / 4900) loss: 0.942897\n","(Iteration 2491 / 4900) loss: 0.998510\n","(Iteration 2501 / 4900) loss: 1.143359\n","(Iteration 2511 / 4900) loss: 0.943850\n","(Iteration 2521 / 4900) loss: 0.880695\n","(Iteration 2531 / 4900) loss: 1.146900\n","(Iteration 2541 / 4900) loss: 1.111783\n","(Iteration 2551 / 4900) loss: 1.172978\n","(Iteration 2561 / 4900) loss: 1.129677\n","(Iteration 2571 / 4900) loss: 1.007303\n","(Iteration 2581 / 4900) loss: 1.046302\n","(Iteration 2591 / 4900) loss: 1.072929\n","(Iteration 2601 / 4900) loss: 1.001353\n","(Iteration 2611 / 4900) loss: 1.149254\n","(Iteration 2621 / 4900) loss: 1.134990\n","(Iteration 2631 / 4900) loss: 0.979200\n","(Iteration 2641 / 4900) loss: 1.170363\n","(Iteration 2651 / 4900) loss: 1.036343\n","(Iteration 2661 / 4900) loss: 1.129888\n","(Iteration 2671 / 4900) loss: 0.896726\n","(Iteration 2681 / 4900) loss: 0.894591\n","(Iteration 2691 / 4900) loss: 0.989703\n","(Iteration 2701 / 4900) loss: 0.967305\n","(Iteration 2711 / 4900) loss: 1.011261\n","(Iteration 2721 / 4900) loss: 1.001878\n","(Iteration 2731 / 4900) loss: 0.800163\n","(Iteration 2741 / 4900) loss: 1.013193\n","(Iteration 2751 / 4900) loss: 0.998115\n","(Iteration 2761 / 4900) loss: 0.797884\n","(Iteration 2771 / 4900) loss: 1.177290\n","(Iteration 2781 / 4900) loss: 1.006864\n","(Iteration 2791 / 4900) loss: 0.944303\n","(Iteration 2801 / 4900) loss: 0.841985\n","(Iteration 2811 / 4900) loss: 0.890702\n","(Iteration 2821 / 4900) loss: 0.894154\n","(Iteration 2831 / 4900) loss: 1.022770\n","(Iteration 2841 / 4900) loss: 1.067549\n","(Iteration 2851 / 4900) loss: 1.042233\n","(Iteration 2861 / 4900) loss: 1.084075\n","(Iteration 2871 / 4900) loss: 1.026127\n","(Iteration 2881 / 4900) loss: 1.129313\n","(Iteration 2891 / 4900) loss: 1.133278\n","(Iteration 2901 / 4900) loss: 0.807189\n","(Iteration 2911 / 4900) loss: 1.006558\n","(Iteration 2921 / 4900) loss: 1.073440\n","(Iteration 2931 / 4900) loss: 0.974240\n","(Epoch 6 / 10) train acc: 0.667000; val_acc: 0.560000\n","(Iteration 2941 / 4900) loss: 0.985113\n","(Iteration 2951 / 4900) loss: 1.053553\n","(Iteration 2961 / 4900) loss: 0.778476\n","(Iteration 2971 / 4900) loss: 1.051785\n","(Iteration 2981 / 4900) loss: 0.952021\n","(Iteration 2991 / 4900) loss: 1.239918\n","(Iteration 3001 / 4900) loss: 0.947865\n","(Iteration 3011 / 4900) loss: 0.993336\n","(Iteration 3021 / 4900) loss: 0.891528\n","(Iteration 3031 / 4900) loss: 0.868633\n","(Iteration 3041 / 4900) loss: 0.928116\n","(Iteration 3051 / 4900) loss: 1.108640\n","(Iteration 3061 / 4900) loss: 0.858781\n","(Iteration 3071 / 4900) loss: 1.018836\n","(Iteration 3081 / 4900) loss: 0.888850\n","(Iteration 3091 / 4900) loss: 0.939005\n","(Iteration 3101 / 4900) loss: 0.895714\n","(Iteration 3111 / 4900) loss: 0.772710\n","(Iteration 3121 / 4900) loss: 0.906326\n","(Iteration 3131 / 4900) loss: 1.093017\n","(Iteration 3141 / 4900) loss: 1.061662\n","(Iteration 3151 / 4900) loss: 0.927810\n","(Iteration 3161 / 4900) loss: 0.821276\n","(Iteration 3171 / 4900) loss: 1.005335\n","(Iteration 3181 / 4900) loss: 0.966104\n","(Iteration 3191 / 4900) loss: 1.075230\n","(Iteration 3201 / 4900) loss: 0.982587\n","(Iteration 3211 / 4900) loss: 1.035344\n","(Iteration 3221 / 4900) loss: 0.864827\n","(Iteration 3231 / 4900) loss: 0.934142\n","(Iteration 3241 / 4900) loss: 0.966514\n","(Iteration 3251 / 4900) loss: 0.994170\n","(Iteration 3261 / 4900) loss: 1.067723\n","(Iteration 3271 / 4900) loss: 1.068627\n","(Iteration 3281 / 4900) loss: 1.115471\n","(Iteration 3291 / 4900) loss: 0.973544\n","(Iteration 3301 / 4900) loss: 0.732736\n","(Iteration 3311 / 4900) loss: 0.878848\n","(Iteration 3321 / 4900) loss: 0.923330\n","(Iteration 3331 / 4900) loss: 0.926350\n","(Iteration 3341 / 4900) loss: 0.953768\n","(Iteration 3351 / 4900) loss: 0.959115\n","(Iteration 3361 / 4900) loss: 0.892265\n","(Iteration 3371 / 4900) loss: 0.837841\n","(Iteration 3381 / 4900) loss: 0.828357\n","(Iteration 3391 / 4900) loss: 0.891260\n","(Iteration 3401 / 4900) loss: 1.001666\n","(Iteration 3411 / 4900) loss: 0.939858\n","(Iteration 3421 / 4900) loss: 0.854818\n","(Epoch 7 / 10) train acc: 0.666000; val_acc: 0.583000\n","(Iteration 3431 / 4900) loss: 0.975395\n","(Iteration 3441 / 4900) loss: 1.014512\n","(Iteration 3451 / 4900) loss: 0.894405\n","(Iteration 3461 / 4900) loss: 1.045332\n","(Iteration 3471 / 4900) loss: 1.041956\n","(Iteration 3481 / 4900) loss: 0.995929\n","(Iteration 3491 / 4900) loss: 0.734924\n","(Iteration 3501 / 4900) loss: 0.924349\n","(Iteration 3511 / 4900) loss: 1.067488\n","(Iteration 3521 / 4900) loss: 0.756093\n","(Iteration 3531 / 4900) loss: 0.893472\n","(Iteration 3541 / 4900) loss: 0.838715\n","(Iteration 3551 / 4900) loss: 0.890908\n","(Iteration 3561 / 4900) loss: 0.902173\n","(Iteration 3571 / 4900) loss: 1.070471\n","(Iteration 3581 / 4900) loss: 0.819705\n","(Iteration 3591 / 4900) loss: 0.822077\n","(Iteration 3601 / 4900) loss: 0.942418\n","(Iteration 3611 / 4900) loss: 0.844968\n","(Iteration 3621 / 4900) loss: 1.279952\n","(Iteration 3631 / 4900) loss: 1.114643\n","(Iteration 3641 / 4900) loss: 0.876129\n","(Iteration 3651 / 4900) loss: 0.838724\n","(Iteration 3661 / 4900) loss: 0.909707\n","(Iteration 3671 / 4900) loss: 0.907530\n","(Iteration 3681 / 4900) loss: 0.827974\n","(Iteration 3691 / 4900) loss: 0.687965\n","(Iteration 3701 / 4900) loss: 1.050495\n","(Iteration 3711 / 4900) loss: 0.810878\n","(Iteration 3721 / 4900) loss: 0.790965\n","(Iteration 3731 / 4900) loss: 0.768062\n","(Iteration 3741 / 4900) loss: 0.782211\n","(Iteration 3751 / 4900) loss: 0.908664\n","(Iteration 3761 / 4900) loss: 0.781280\n","(Iteration 3771 / 4900) loss: 0.800803\n","(Iteration 3781 / 4900) loss: 0.805720\n","(Iteration 3791 / 4900) loss: 1.038250\n","(Iteration 3801 / 4900) loss: 0.745794\n","(Iteration 3811 / 4900) loss: 0.871457\n","(Iteration 3821 / 4900) loss: 0.848869\n","(Iteration 3831 / 4900) loss: 0.844361\n","(Iteration 3841 / 4900) loss: 0.893544\n","(Iteration 3851 / 4900) loss: 0.850567\n","(Iteration 3861 / 4900) loss: 0.810318\n","(Iteration 3871 / 4900) loss: 0.849963\n","(Iteration 3881 / 4900) loss: 0.938739\n","(Iteration 3891 / 4900) loss: 0.702630\n","(Iteration 3901 / 4900) loss: 0.937003\n","(Iteration 3911 / 4900) loss: 0.661939\n","(Epoch 8 / 10) train acc: 0.690000; val_acc: 0.554000\n","(Iteration 3921 / 4900) loss: 0.863122\n","(Iteration 3931 / 4900) loss: 0.949254\n","(Iteration 3941 / 4900) loss: 0.897210\n","(Iteration 3951 / 4900) loss: 0.727321\n","(Iteration 3961 / 4900) loss: 0.885022\n","(Iteration 3971 / 4900) loss: 0.616148\n","(Iteration 3981 / 4900) loss: 0.839402\n","(Iteration 3991 / 4900) loss: 0.755847\n","(Iteration 4001 / 4900) loss: 0.805526\n","(Iteration 4011 / 4900) loss: 0.885802\n","(Iteration 4021 / 4900) loss: 0.887372\n","(Iteration 4031 / 4900) loss: 0.909647\n","(Iteration 4041 / 4900) loss: 0.672660\n","(Iteration 4051 / 4900) loss: 1.080787\n","(Iteration 4061 / 4900) loss: 0.774891\n","(Iteration 4071 / 4900) loss: 0.771492\n","(Iteration 4081 / 4900) loss: 0.941875\n","(Iteration 4091 / 4900) loss: 0.958020\n","(Iteration 4101 / 4900) loss: 0.895081\n","(Iteration 4111 / 4900) loss: 0.767814\n","(Iteration 4121 / 4900) loss: 1.031549\n","(Iteration 4131 / 4900) loss: 0.961403\n","(Iteration 4141 / 4900) loss: 0.857470\n","(Iteration 4151 / 4900) loss: 0.874087\n","(Iteration 4161 / 4900) loss: 0.984169\n","(Iteration 4171 / 4900) loss: 0.818890\n","(Iteration 4181 / 4900) loss: 0.803262\n","(Iteration 4191 / 4900) loss: 0.824253\n","(Iteration 4201 / 4900) loss: 0.840093\n","(Iteration 4211 / 4900) loss: 0.996134\n","(Iteration 4221 / 4900) loss: 0.944096\n","(Iteration 4231 / 4900) loss: 0.795879\n","(Iteration 4241 / 4900) loss: 0.814526\n","(Iteration 4251 / 4900) loss: 0.767132\n","(Iteration 4261 / 4900) loss: 1.184433\n","(Iteration 4271 / 4900) loss: 0.812172\n","(Iteration 4281 / 4900) loss: 0.834411\n","(Iteration 4291 / 4900) loss: 0.743823\n","(Iteration 4301 / 4900) loss: 0.818054\n","(Iteration 4311 / 4900) loss: 0.693137\n","(Iteration 4321 / 4900) loss: 0.894186\n","(Iteration 4331 / 4900) loss: 0.790336\n","(Iteration 4341 / 4900) loss: 0.796466\n","(Iteration 4351 / 4900) loss: 0.684058\n","(Iteration 4361 / 4900) loss: 0.960717\n","(Iteration 4371 / 4900) loss: 0.757760\n","(Iteration 4381 / 4900) loss: 0.807759\n","(Iteration 4391 / 4900) loss: 0.807163\n","(Iteration 4401 / 4900) loss: 0.870277\n","(Epoch 9 / 10) train acc: 0.713000; val_acc: 0.576000\n","(Iteration 4411 / 4900) loss: 0.849217\n","(Iteration 4421 / 4900) loss: 1.060202\n","(Iteration 4431 / 4900) loss: 0.763160\n","(Iteration 4441 / 4900) loss: 0.875330\n","(Iteration 4451 / 4900) loss: 0.929308\n","(Iteration 4461 / 4900) loss: 0.773284\n","(Iteration 4471 / 4900) loss: 0.741506\n","(Iteration 4481 / 4900) loss: 0.822956\n","(Iteration 4491 / 4900) loss: 0.888884\n","(Iteration 4501 / 4900) loss: 0.750294\n","(Iteration 4511 / 4900) loss: 0.910878\n","(Iteration 4521 / 4900) loss: 0.796845\n","(Iteration 4531 / 4900) loss: 1.046066\n","(Iteration 4541 / 4900) loss: 0.951516\n","(Iteration 4551 / 4900) loss: 0.874068\n","(Iteration 4561 / 4900) loss: 0.918062\n","(Iteration 4571 / 4900) loss: 0.829390\n","(Iteration 4581 / 4900) loss: 0.905865\n","(Iteration 4591 / 4900) loss: 0.826523\n","(Iteration 4601 / 4900) loss: 0.824137\n","(Iteration 4611 / 4900) loss: 0.995457\n","(Iteration 4621 / 4900) loss: 0.781999\n","(Iteration 4631 / 4900) loss: 0.930462\n","(Iteration 4641 / 4900) loss: 0.717695\n","(Iteration 4651 / 4900) loss: 0.981834\n","(Iteration 4661 / 4900) loss: 0.828139\n","(Iteration 4671 / 4900) loss: 0.737910\n","(Iteration 4681 / 4900) loss: 0.852783\n","(Iteration 4691 / 4900) loss: 0.791113\n","(Iteration 4701 / 4900) loss: 0.830652\n","(Iteration 4711 / 4900) loss: 0.598006\n","(Iteration 4721 / 4900) loss: 0.862639\n","(Iteration 4731 / 4900) loss: 0.667923\n","(Iteration 4741 / 4900) loss: 0.661808\n","(Iteration 4751 / 4900) loss: 0.738492\n","(Iteration 4761 / 4900) loss: 0.733495\n","(Iteration 4771 / 4900) loss: 0.774688\n","(Iteration 4781 / 4900) loss: 0.856588\n","(Iteration 4791 / 4900) loss: 0.838918\n","(Iteration 4801 / 4900) loss: 0.582980\n","(Iteration 4811 / 4900) loss: 0.716170\n","(Iteration 4821 / 4900) loss: 0.830786\n","(Iteration 4831 / 4900) loss: 0.705065\n","(Iteration 4841 / 4900) loss: 0.689789\n","(Iteration 4851 / 4900) loss: 0.807096\n","(Iteration 4861 / 4900) loss: 0.959054\n","(Iteration 4871 / 4900) loss: 0.845452\n","(Iteration 4881 / 4900) loss: 0.758875\n","(Iteration 4891 / 4900) loss: 0.896129\n","(Epoch 10 / 10) train acc: 0.735000; val_acc: 0.580000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.127000; val_acc: 0.119000\n","(Iteration 11 / 4900) loss: 2.304032\n","(Iteration 21 / 4900) loss: 2.306107\n","(Iteration 31 / 4900) loss: 2.305065\n","(Iteration 41 / 4900) loss: 2.306624\n","(Iteration 51 / 4900) loss: 2.302304\n","(Iteration 61 / 4900) loss: 2.303206\n","(Iteration 71 / 4900) loss: 2.265397\n","(Iteration 81 / 4900) loss: 2.196979\n","(Iteration 91 / 4900) loss: 2.077247\n","(Iteration 101 / 4900) loss: 1.945323\n","(Iteration 111 / 4900) loss: 1.921706\n","(Iteration 121 / 4900) loss: 1.836135\n","(Iteration 131 / 4900) loss: 1.703452\n","(Iteration 141 / 4900) loss: 1.583166\n","(Iteration 151 / 4900) loss: 1.516811\n","(Iteration 161 / 4900) loss: 1.656926\n","(Iteration 171 / 4900) loss: 1.457096\n","(Iteration 181 / 4900) loss: 1.454955\n","(Iteration 191 / 4900) loss: 1.471596\n","(Iteration 201 / 4900) loss: 1.437571\n","(Iteration 211 / 4900) loss: 1.592947\n","(Iteration 221 / 4900) loss: 1.586183\n","(Iteration 231 / 4900) loss: 1.500930\n","(Iteration 241 / 4900) loss: 1.415938\n","(Iteration 251 / 4900) loss: 1.573570\n","(Iteration 261 / 4900) loss: 1.482028\n","(Iteration 271 / 4900) loss: 1.373964\n","(Iteration 281 / 4900) loss: 1.558121\n","(Iteration 291 / 4900) loss: 1.373225\n","(Iteration 301 / 4900) loss: 1.316437\n","(Iteration 311 / 4900) loss: 1.495285\n","(Iteration 321 / 4900) loss: 1.309549\n","(Iteration 331 / 4900) loss: 1.546849\n","(Iteration 341 / 4900) loss: 1.466215\n","(Iteration 351 / 4900) loss: 1.349634\n","(Iteration 361 / 4900) loss: 1.346029\n","(Iteration 371 / 4900) loss: 1.299404\n","(Iteration 381 / 4900) loss: 1.238946\n","(Iteration 391 / 4900) loss: 1.369892\n","(Iteration 401 / 4900) loss: 1.369407\n","(Iteration 411 / 4900) loss: 1.399943\n","(Iteration 421 / 4900) loss: 1.509625\n","(Iteration 431 / 4900) loss: 1.501968\n","(Iteration 441 / 4900) loss: 1.387296\n","(Iteration 451 / 4900) loss: 1.407649\n","(Iteration 461 / 4900) loss: 1.535625\n","(Iteration 471 / 4900) loss: 1.384541\n","(Iteration 481 / 4900) loss: 1.387832\n","(Epoch 1 / 10) train acc: 0.517000; val_acc: 0.502000\n","(Iteration 491 / 4900) loss: 1.264475\n","(Iteration 501 / 4900) loss: 1.378680\n","(Iteration 511 / 4900) loss: 1.094972\n","(Iteration 521 / 4900) loss: 1.278238\n","(Iteration 531 / 4900) loss: 1.246519\n","(Iteration 541 / 4900) loss: 1.408949\n","(Iteration 551 / 4900) loss: 1.313528\n","(Iteration 561 / 4900) loss: 1.320324\n","(Iteration 571 / 4900) loss: 1.323963\n","(Iteration 581 / 4900) loss: 1.388996\n","(Iteration 591 / 4900) loss: 1.279625\n","(Iteration 601 / 4900) loss: 1.134225\n","(Iteration 611 / 4900) loss: 1.449738\n","(Iteration 621 / 4900) loss: 1.441497\n","(Iteration 631 / 4900) loss: 1.309336\n","(Iteration 641 / 4900) loss: 1.401191\n","(Iteration 651 / 4900) loss: 1.311507\n","(Iteration 661 / 4900) loss: 1.228352\n","(Iteration 671 / 4900) loss: 1.435062\n","(Iteration 681 / 4900) loss: 1.167869\n","(Iteration 691 / 4900) loss: 1.356607\n","(Iteration 701 / 4900) loss: 1.272783\n","(Iteration 711 / 4900) loss: 1.088579\n","(Iteration 721 / 4900) loss: 1.248823\n","(Iteration 731 / 4900) loss: 1.292368\n","(Iteration 741 / 4900) loss: 1.282979\n","(Iteration 751 / 4900) loss: 1.254828\n","(Iteration 761 / 4900) loss: 1.314157\n","(Iteration 771 / 4900) loss: 1.232641\n","(Iteration 781 / 4900) loss: 1.239607\n","(Iteration 791 / 4900) loss: 1.202880\n","(Iteration 801 / 4900) loss: 1.136839\n","(Iteration 811 / 4900) loss: 1.301344\n","(Iteration 821 / 4900) loss: 1.288681\n","(Iteration 831 / 4900) loss: 1.114247\n","(Iteration 841 / 4900) loss: 1.185391\n","(Iteration 851 / 4900) loss: 1.378274\n","(Iteration 861 / 4900) loss: 1.450911\n","(Iteration 871 / 4900) loss: 1.295855\n","(Iteration 881 / 4900) loss: 1.392572\n","(Iteration 891 / 4900) loss: 1.239681\n","(Iteration 901 / 4900) loss: 1.306643\n","(Iteration 911 / 4900) loss: 1.434504\n","(Iteration 921 / 4900) loss: 1.308675\n","(Iteration 931 / 4900) loss: 1.099723\n","(Iteration 941 / 4900) loss: 1.170277\n","(Iteration 951 / 4900) loss: 1.404101\n","(Iteration 961 / 4900) loss: 1.257716\n","(Iteration 971 / 4900) loss: 1.317007\n","(Epoch 2 / 10) train acc: 0.523000; val_acc: 0.531000\n","(Iteration 981 / 4900) loss: 1.140520\n","(Iteration 991 / 4900) loss: 1.072476\n","(Iteration 1001 / 4900) loss: 1.366257\n","(Iteration 1011 / 4900) loss: 1.317516\n","(Iteration 1021 / 4900) loss: 1.133061\n","(Iteration 1031 / 4900) loss: 1.255429\n","(Iteration 1041 / 4900) loss: 1.377149\n","(Iteration 1051 / 4900) loss: 1.237576\n","(Iteration 1061 / 4900) loss: 1.262735\n","(Iteration 1071 / 4900) loss: 1.125491\n","(Iteration 1081 / 4900) loss: 1.148617\n","(Iteration 1091 / 4900) loss: 1.068489\n","(Iteration 1101 / 4900) loss: 1.392371\n","(Iteration 1111 / 4900) loss: 1.238208\n","(Iteration 1121 / 4900) loss: 1.110415\n","(Iteration 1131 / 4900) loss: 1.361191\n","(Iteration 1141 / 4900) loss: 1.068982\n","(Iteration 1151 / 4900) loss: 1.062841\n","(Iteration 1161 / 4900) loss: 1.259787\n","(Iteration 1171 / 4900) loss: 1.014100\n","(Iteration 1181 / 4900) loss: 1.255228\n","(Iteration 1191 / 4900) loss: 1.220547\n","(Iteration 1201 / 4900) loss: 1.126919\n","(Iteration 1211 / 4900) loss: 1.182887\n","(Iteration 1221 / 4900) loss: 1.213047\n","(Iteration 1231 / 4900) loss: 1.399228\n","(Iteration 1241 / 4900) loss: 1.245837\n","(Iteration 1251 / 4900) loss: 1.080625\n","(Iteration 1261 / 4900) loss: 1.091578\n","(Iteration 1271 / 4900) loss: 1.239485\n","(Iteration 1281 / 4900) loss: 1.239058\n","(Iteration 1291 / 4900) loss: 1.190236\n","(Iteration 1301 / 4900) loss: 1.082112\n","(Iteration 1311 / 4900) loss: 1.083406\n","(Iteration 1321 / 4900) loss: 1.032136\n","(Iteration 1331 / 4900) loss: 0.861921\n","(Iteration 1341 / 4900) loss: 1.470591\n","(Iteration 1351 / 4900) loss: 1.284042\n","(Iteration 1361 / 4900) loss: 1.323702\n","(Iteration 1371 / 4900) loss: 1.132977\n","(Iteration 1381 / 4900) loss: 1.174049\n","(Iteration 1391 / 4900) loss: 1.165646\n","(Iteration 1401 / 4900) loss: 1.155281\n","(Iteration 1411 / 4900) loss: 1.190849\n","(Iteration 1421 / 4900) loss: 1.135698\n","(Iteration 1431 / 4900) loss: 1.031163\n","(Iteration 1441 / 4900) loss: 1.125616\n","(Iteration 1451 / 4900) loss: 1.068705\n","(Iteration 1461 / 4900) loss: 1.275054\n","(Epoch 3 / 10) train acc: 0.591000; val_acc: 0.555000\n","(Iteration 1471 / 4900) loss: 1.084045\n","(Iteration 1481 / 4900) loss: 1.138519\n","(Iteration 1491 / 4900) loss: 1.091142\n","(Iteration 1501 / 4900) loss: 1.218831\n","(Iteration 1511 / 4900) loss: 1.132186\n","(Iteration 1521 / 4900) loss: 1.266328\n","(Iteration 1531 / 4900) loss: 1.222695\n","(Iteration 1541 / 4900) loss: 1.226156\n","(Iteration 1551 / 4900) loss: 1.026130\n","(Iteration 1561 / 4900) loss: 1.003472\n","(Iteration 1571 / 4900) loss: 1.103929\n","(Iteration 1581 / 4900) loss: 1.091648\n","(Iteration 1591 / 4900) loss: 1.012692\n","(Iteration 1601 / 4900) loss: 1.242227\n","(Iteration 1611 / 4900) loss: 1.054199\n","(Iteration 1621 / 4900) loss: 1.139244\n","(Iteration 1631 / 4900) loss: 1.235204\n","(Iteration 1641 / 4900) loss: 0.953816\n","(Iteration 1651 / 4900) loss: 1.046693\n","(Iteration 1661 / 4900) loss: 1.133222\n","(Iteration 1671 / 4900) loss: 1.268872\n","(Iteration 1681 / 4900) loss: 1.205298\n","(Iteration 1691 / 4900) loss: 1.039950\n","(Iteration 1701 / 4900) loss: 1.138385\n","(Iteration 1711 / 4900) loss: 1.112986\n","(Iteration 1721 / 4900) loss: 1.221643\n","(Iteration 1731 / 4900) loss: 0.940646\n","(Iteration 1741 / 4900) loss: 1.064057\n","(Iteration 1751 / 4900) loss: 1.147398\n","(Iteration 1761 / 4900) loss: 1.257889\n","(Iteration 1771 / 4900) loss: 1.284398\n","(Iteration 1781 / 4900) loss: 1.164847\n","(Iteration 1791 / 4900) loss: 1.182896\n","(Iteration 1801 / 4900) loss: 1.150881\n","(Iteration 1811 / 4900) loss: 1.124045\n","(Iteration 1821 / 4900) loss: 1.100523\n","(Iteration 1831 / 4900) loss: 1.214863\n","(Iteration 1841 / 4900) loss: 1.201021\n","(Iteration 1851 / 4900) loss: 1.105341\n","(Iteration 1861 / 4900) loss: 1.110431\n","(Iteration 1871 / 4900) loss: 0.896384\n","(Iteration 1881 / 4900) loss: 1.213047\n","(Iteration 1891 / 4900) loss: 1.065028\n","(Iteration 1901 / 4900) loss: 1.137959\n","(Iteration 1911 / 4900) loss: 1.274573\n","(Iteration 1921 / 4900) loss: 1.113917\n","(Iteration 1931 / 4900) loss: 1.053168\n","(Iteration 1941 / 4900) loss: 0.981319\n","(Iteration 1951 / 4900) loss: 1.085886\n","(Epoch 4 / 10) train acc: 0.613000; val_acc: 0.570000\n","(Iteration 1961 / 4900) loss: 1.187999\n","(Iteration 1971 / 4900) loss: 1.039143\n","(Iteration 1981 / 4900) loss: 1.219392\n","(Iteration 1991 / 4900) loss: 1.022359\n","(Iteration 2001 / 4900) loss: 1.090914\n","(Iteration 2011 / 4900) loss: 0.993164\n","(Iteration 2021 / 4900) loss: 0.993813\n","(Iteration 2031 / 4900) loss: 1.017330\n","(Iteration 2041 / 4900) loss: 1.233471\n","(Iteration 2051 / 4900) loss: 1.061147\n","(Iteration 2061 / 4900) loss: 1.118037\n","(Iteration 2071 / 4900) loss: 1.113009\n","(Iteration 2081 / 4900) loss: 1.051625\n","(Iteration 2091 / 4900) loss: 1.164673\n","(Iteration 2101 / 4900) loss: 0.849159\n","(Iteration 2111 / 4900) loss: 1.190941\n","(Iteration 2121 / 4900) loss: 1.134050\n","(Iteration 2131 / 4900) loss: 1.228191\n","(Iteration 2141 / 4900) loss: 1.096926\n","(Iteration 2151 / 4900) loss: 1.164055\n","(Iteration 2161 / 4900) loss: 0.871067\n","(Iteration 2171 / 4900) loss: 1.000233\n","(Iteration 2181 / 4900) loss: 0.983848\n","(Iteration 2191 / 4900) loss: 1.136333\n","(Iteration 2201 / 4900) loss: 1.070390\n","(Iteration 2211 / 4900) loss: 1.112497\n","(Iteration 2221 / 4900) loss: 1.005632\n","(Iteration 2231 / 4900) loss: 1.127065\n","(Iteration 2241 / 4900) loss: 0.931883\n","(Iteration 2251 / 4900) loss: 1.168120\n","(Iteration 2261 / 4900) loss: 0.998899\n","(Iteration 2271 / 4900) loss: 1.286462\n","(Iteration 2281 / 4900) loss: 1.135451\n","(Iteration 2291 / 4900) loss: 0.981451\n","(Iteration 2301 / 4900) loss: 1.241214\n","(Iteration 2311 / 4900) loss: 1.054126\n","(Iteration 2321 / 4900) loss: 1.098804\n","(Iteration 2331 / 4900) loss: 0.954966\n","(Iteration 2341 / 4900) loss: 0.943148\n","(Iteration 2351 / 4900) loss: 0.964864\n","(Iteration 2361 / 4900) loss: 0.982363\n","(Iteration 2371 / 4900) loss: 1.109720\n","(Iteration 2381 / 4900) loss: 0.991626\n","(Iteration 2391 / 4900) loss: 1.114946\n","(Iteration 2401 / 4900) loss: 1.182819\n","(Iteration 2411 / 4900) loss: 1.162373\n","(Iteration 2421 / 4900) loss: 1.285240\n","(Iteration 2431 / 4900) loss: 1.104700\n","(Iteration 2441 / 4900) loss: 0.965086\n","(Epoch 5 / 10) train acc: 0.601000; val_acc: 0.553000\n","(Iteration 2451 / 4900) loss: 1.074980\n","(Iteration 2461 / 4900) loss: 1.096514\n","(Iteration 2471 / 4900) loss: 1.292281\n","(Iteration 2481 / 4900) loss: 1.078719\n","(Iteration 2491 / 4900) loss: 0.991083\n","(Iteration 2501 / 4900) loss: 1.056139\n","(Iteration 2511 / 4900) loss: 1.121025\n","(Iteration 2521 / 4900) loss: 0.928216\n","(Iteration 2531 / 4900) loss: 1.079800\n","(Iteration 2541 / 4900) loss: 1.191162\n","(Iteration 2551 / 4900) loss: 1.043800\n","(Iteration 2561 / 4900) loss: 1.254103\n","(Iteration 2571 / 4900) loss: 1.135802\n","(Iteration 2581 / 4900) loss: 1.202445\n","(Iteration 2591 / 4900) loss: 1.018461\n","(Iteration 2601 / 4900) loss: 1.038737\n","(Iteration 2611 / 4900) loss: 1.178410\n","(Iteration 2621 / 4900) loss: 1.125695\n","(Iteration 2631 / 4900) loss: 1.061423\n","(Iteration 2641 / 4900) loss: 1.330332\n","(Iteration 2651 / 4900) loss: 1.023432\n","(Iteration 2661 / 4900) loss: 1.046275\n","(Iteration 2671 / 4900) loss: 1.188620\n","(Iteration 2681 / 4900) loss: 1.050530\n","(Iteration 2691 / 4900) loss: 1.106726\n","(Iteration 2701 / 4900) loss: 0.867348\n","(Iteration 2711 / 4900) loss: 1.086718\n","(Iteration 2721 / 4900) loss: 0.980873\n","(Iteration 2731 / 4900) loss: 1.081228\n","(Iteration 2741 / 4900) loss: 0.958076\n","(Iteration 2751 / 4900) loss: 1.290643\n","(Iteration 2761 / 4900) loss: 0.897363\n","(Iteration 2771 / 4900) loss: 0.866373\n","(Iteration 2781 / 4900) loss: 0.954670\n","(Iteration 2791 / 4900) loss: 1.211893\n","(Iteration 2801 / 4900) loss: 1.058767\n","(Iteration 2811 / 4900) loss: 0.949199\n","(Iteration 2821 / 4900) loss: 1.200983\n","(Iteration 2831 / 4900) loss: 1.168010\n","(Iteration 2841 / 4900) loss: 1.167410\n","(Iteration 2851 / 4900) loss: 1.093971\n","(Iteration 2861 / 4900) loss: 1.113884\n","(Iteration 2871 / 4900) loss: 1.102770\n","(Iteration 2881 / 4900) loss: 1.004042\n","(Iteration 2891 / 4900) loss: 1.004440\n","(Iteration 2901 / 4900) loss: 0.936454\n","(Iteration 2911 / 4900) loss: 1.119573\n","(Iteration 2921 / 4900) loss: 1.023704\n","(Iteration 2931 / 4900) loss: 0.906557\n","(Epoch 6 / 10) train acc: 0.645000; val_acc: 0.573000\n","(Iteration 2941 / 4900) loss: 0.937497\n","(Iteration 2951 / 4900) loss: 0.966787\n","(Iteration 2961 / 4900) loss: 0.876519\n","(Iteration 2971 / 4900) loss: 1.132180\n","(Iteration 2981 / 4900) loss: 1.164967\n","(Iteration 2991 / 4900) loss: 0.939454\n","(Iteration 3001 / 4900) loss: 1.128102\n","(Iteration 3011 / 4900) loss: 0.896542\n","(Iteration 3021 / 4900) loss: 1.017112\n","(Iteration 3031 / 4900) loss: 1.146818\n","(Iteration 3041 / 4900) loss: 1.030367\n","(Iteration 3051 / 4900) loss: 1.054340\n","(Iteration 3061 / 4900) loss: 1.239871\n","(Iteration 3071 / 4900) loss: 0.893572\n","(Iteration 3081 / 4900) loss: 1.038159\n","(Iteration 3091 / 4900) loss: 1.094648\n","(Iteration 3101 / 4900) loss: 1.135385\n","(Iteration 3111 / 4900) loss: 1.036059\n","(Iteration 3121 / 4900) loss: 1.155422\n","(Iteration 3131 / 4900) loss: 0.894066\n","(Iteration 3141 / 4900) loss: 1.098950\n","(Iteration 3151 / 4900) loss: 0.889092\n","(Iteration 3161 / 4900) loss: 0.999984\n","(Iteration 3171 / 4900) loss: 1.184275\n","(Iteration 3181 / 4900) loss: 0.968819\n","(Iteration 3191 / 4900) loss: 1.032465\n","(Iteration 3201 / 4900) loss: 0.927668\n","(Iteration 3211 / 4900) loss: 0.956752\n","(Iteration 3221 / 4900) loss: 0.873427\n","(Iteration 3231 / 4900) loss: 1.081046\n","(Iteration 3241 / 4900) loss: 1.136981\n","(Iteration 3251 / 4900) loss: 0.862671\n","(Iteration 3261 / 4900) loss: 1.014936\n","(Iteration 3271 / 4900) loss: 1.095529\n","(Iteration 3281 / 4900) loss: 1.131853\n","(Iteration 3291 / 4900) loss: 1.005670\n","(Iteration 3301 / 4900) loss: 1.035377\n","(Iteration 3311 / 4900) loss: 1.314454\n","(Iteration 3321 / 4900) loss: 0.985794\n","(Iteration 3331 / 4900) loss: 0.801637\n","(Iteration 3341 / 4900) loss: 0.884485\n","(Iteration 3351 / 4900) loss: 1.147085\n","(Iteration 3361 / 4900) loss: 1.081664\n","(Iteration 3371 / 4900) loss: 0.924887\n","(Iteration 3381 / 4900) loss: 1.131399\n","(Iteration 3391 / 4900) loss: 0.969899\n","(Iteration 3401 / 4900) loss: 1.072722\n","(Iteration 3411 / 4900) loss: 0.948631\n","(Iteration 3421 / 4900) loss: 1.231576\n","(Epoch 7 / 10) train acc: 0.664000; val_acc: 0.591000\n","(Iteration 3431 / 4900) loss: 0.882342\n","(Iteration 3441 / 4900) loss: 0.935328\n","(Iteration 3451 / 4900) loss: 0.972510\n","(Iteration 3461 / 4900) loss: 1.189056\n","(Iteration 3471 / 4900) loss: 1.101928\n","(Iteration 3481 / 4900) loss: 0.945899\n","(Iteration 3491 / 4900) loss: 1.067996\n","(Iteration 3501 / 4900) loss: 1.056577\n","(Iteration 3511 / 4900) loss: 1.065846\n","(Iteration 3521 / 4900) loss: 1.051088\n","(Iteration 3531 / 4900) loss: 0.992863\n","(Iteration 3541 / 4900) loss: 0.981714\n","(Iteration 3551 / 4900) loss: 1.112586\n","(Iteration 3561 / 4900) loss: 0.964378\n","(Iteration 3571 / 4900) loss: 1.143025\n","(Iteration 3581 / 4900) loss: 0.908281\n","(Iteration 3591 / 4900) loss: 1.190233\n","(Iteration 3601 / 4900) loss: 1.272008\n","(Iteration 3611 / 4900) loss: 1.294445\n","(Iteration 3621 / 4900) loss: 1.105786\n","(Iteration 3631 / 4900) loss: 1.105331\n","(Iteration 3641 / 4900) loss: 0.990384\n","(Iteration 3651 / 4900) loss: 0.996705\n","(Iteration 3661 / 4900) loss: 1.070106\n","(Iteration 3671 / 4900) loss: 1.066162\n","(Iteration 3681 / 4900) loss: 0.916258\n","(Iteration 3691 / 4900) loss: 0.825096\n","(Iteration 3701 / 4900) loss: 0.903686\n","(Iteration 3711 / 4900) loss: 0.957427\n","(Iteration 3721 / 4900) loss: 1.199596\n","(Iteration 3731 / 4900) loss: 0.942868\n","(Iteration 3741 / 4900) loss: 0.789743\n","(Iteration 3751 / 4900) loss: 1.130747\n","(Iteration 3761 / 4900) loss: 0.841183\n","(Iteration 3771 / 4900) loss: 0.881358\n","(Iteration 3781 / 4900) loss: 1.092840\n","(Iteration 3791 / 4900) loss: 0.862190\n","(Iteration 3801 / 4900) loss: 0.938945\n","(Iteration 3811 / 4900) loss: 1.082739\n","(Iteration 3821 / 4900) loss: 1.151467\n","(Iteration 3831 / 4900) loss: 0.896821\n","(Iteration 3841 / 4900) loss: 0.747858\n","(Iteration 3851 / 4900) loss: 1.060305\n","(Iteration 3861 / 4900) loss: 1.086591\n","(Iteration 3871 / 4900) loss: 0.852109\n","(Iteration 3881 / 4900) loss: 0.913253\n","(Iteration 3891 / 4900) loss: 1.057420\n","(Iteration 3901 / 4900) loss: 0.911670\n","(Iteration 3911 / 4900) loss: 0.924060\n","(Epoch 8 / 10) train acc: 0.650000; val_acc: 0.575000\n","(Iteration 3921 / 4900) loss: 1.053177\n","(Iteration 3931 / 4900) loss: 1.277031\n","(Iteration 3941 / 4900) loss: 0.976243\n","(Iteration 3951 / 4900) loss: 0.960418\n","(Iteration 3961 / 4900) loss: 0.850513\n","(Iteration 3971 / 4900) loss: 1.056886\n","(Iteration 3981 / 4900) loss: 0.797756\n","(Iteration 3991 / 4900) loss: 0.951902\n","(Iteration 4001 / 4900) loss: 0.835813\n","(Iteration 4011 / 4900) loss: 1.115473\n","(Iteration 4021 / 4900) loss: 1.074533\n","(Iteration 4031 / 4900) loss: 0.993162\n","(Iteration 4041 / 4900) loss: 0.979429\n","(Iteration 4051 / 4900) loss: 0.643475\n","(Iteration 4061 / 4900) loss: 0.908649\n","(Iteration 4071 / 4900) loss: 0.919374\n","(Iteration 4081 / 4900) loss: 1.022199\n","(Iteration 4091 / 4900) loss: 1.131278\n","(Iteration 4101 / 4900) loss: 0.941441\n","(Iteration 4111 / 4900) loss: 1.121888\n","(Iteration 4121 / 4900) loss: 0.945071\n","(Iteration 4131 / 4900) loss: 1.137407\n","(Iteration 4141 / 4900) loss: 0.997007\n","(Iteration 4151 / 4900) loss: 0.984931\n","(Iteration 4161 / 4900) loss: 1.168475\n","(Iteration 4171 / 4900) loss: 0.905175\n","(Iteration 4181 / 4900) loss: 1.219259\n","(Iteration 4191 / 4900) loss: 0.872622\n","(Iteration 4201 / 4900) loss: 0.906013\n","(Iteration 4211 / 4900) loss: 0.968822\n","(Iteration 4221 / 4900) loss: 0.801648\n","(Iteration 4231 / 4900) loss: 0.897960\n","(Iteration 4241 / 4900) loss: 1.047299\n","(Iteration 4251 / 4900) loss: 1.087077\n","(Iteration 4261 / 4900) loss: 1.065618\n","(Iteration 4271 / 4900) loss: 1.062247\n","(Iteration 4281 / 4900) loss: 0.897228\n","(Iteration 4291 / 4900) loss: 0.905209\n","(Iteration 4301 / 4900) loss: 0.929678\n","(Iteration 4311 / 4900) loss: 0.963718\n","(Iteration 4321 / 4900) loss: 1.066817\n","(Iteration 4331 / 4900) loss: 0.901007\n","(Iteration 4341 / 4900) loss: 0.936379\n","(Iteration 4351 / 4900) loss: 1.017428\n","(Iteration 4361 / 4900) loss: 1.020007\n","(Iteration 4371 / 4900) loss: 1.121842\n","(Iteration 4381 / 4900) loss: 0.963367\n","(Iteration 4391 / 4900) loss: 1.062626\n","(Iteration 4401 / 4900) loss: 0.862813\n","(Epoch 9 / 10) train acc: 0.642000; val_acc: 0.557000\n","(Iteration 4411 / 4900) loss: 0.822753\n","(Iteration 4421 / 4900) loss: 1.018024\n","(Iteration 4431 / 4900) loss: 0.743947\n","(Iteration 4441 / 4900) loss: 0.855265\n","(Iteration 4451 / 4900) loss: 1.177718\n","(Iteration 4461 / 4900) loss: 0.669443\n","(Iteration 4471 / 4900) loss: 1.130073\n","(Iteration 4481 / 4900) loss: 1.122883\n","(Iteration 4491 / 4900) loss: 1.024181\n","(Iteration 4501 / 4900) loss: 1.038134\n","(Iteration 4511 / 4900) loss: 0.803744\n","(Iteration 4521 / 4900) loss: 1.018158\n","(Iteration 4531 / 4900) loss: 0.955329\n","(Iteration 4541 / 4900) loss: 1.187536\n","(Iteration 4551 / 4900) loss: 1.040493\n","(Iteration 4561 / 4900) loss: 0.936096\n","(Iteration 4571 / 4900) loss: 1.099181\n","(Iteration 4581 / 4900) loss: 1.119675\n","(Iteration 4591 / 4900) loss: 0.810606\n","(Iteration 4601 / 4900) loss: 0.907864\n","(Iteration 4611 / 4900) loss: 1.046178\n","(Iteration 4621 / 4900) loss: 0.983198\n","(Iteration 4631 / 4900) loss: 0.953246\n","(Iteration 4641 / 4900) loss: 1.001973\n","(Iteration 4651 / 4900) loss: 0.953021\n","(Iteration 4661 / 4900) loss: 1.340465\n","(Iteration 4671 / 4900) loss: 1.021713\n","(Iteration 4681 / 4900) loss: 1.003751\n","(Iteration 4691 / 4900) loss: 0.954154\n","(Iteration 4701 / 4900) loss: 0.771074\n","(Iteration 4711 / 4900) loss: 0.980785\n","(Iteration 4721 / 4900) loss: 1.017193\n","(Iteration 4731 / 4900) loss: 0.780066\n","(Iteration 4741 / 4900) loss: 1.133344\n","(Iteration 4751 / 4900) loss: 0.919101\n","(Iteration 4761 / 4900) loss: 1.134964\n","(Iteration 4771 / 4900) loss: 1.151853\n","(Iteration 4781 / 4900) loss: 1.052804\n","(Iteration 4791 / 4900) loss: 0.839203\n","(Iteration 4801 / 4900) loss: 1.053529\n","(Iteration 4811 / 4900) loss: 0.908518\n","(Iteration 4821 / 4900) loss: 0.871528\n","(Iteration 4831 / 4900) loss: 1.015467\n","(Iteration 4841 / 4900) loss: 0.822213\n","(Iteration 4851 / 4900) loss: 1.100530\n","(Iteration 4861 / 4900) loss: 1.037563\n","(Iteration 4871 / 4900) loss: 0.986873\n","(Iteration 4881 / 4900) loss: 1.166768\n","(Iteration 4891 / 4900) loss: 1.064809\n","(Epoch 10 / 10) train acc: 0.689000; val_acc: 0.558000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.100000; val_acc: 0.079000\n","(Iteration 11 / 4900) loss: 2.302856\n","(Iteration 21 / 4900) loss: 2.304182\n","(Iteration 31 / 4900) loss: 2.305828\n","(Iteration 41 / 4900) loss: 2.304787\n","(Iteration 51 / 4900) loss: 2.305440\n","(Iteration 61 / 4900) loss: 2.301977\n","(Iteration 71 / 4900) loss: 2.291533\n","(Iteration 81 / 4900) loss: 2.271449\n","(Iteration 91 / 4900) loss: 2.160608\n","(Iteration 101 / 4900) loss: 2.076606\n","(Iteration 111 / 4900) loss: 1.966446\n","(Iteration 121 / 4900) loss: 1.865945\n","(Iteration 131 / 4900) loss: 1.819510\n","(Iteration 141 / 4900) loss: 1.913117\n","(Iteration 151 / 4900) loss: 1.738799\n","(Iteration 161 / 4900) loss: 1.757661\n","(Iteration 171 / 4900) loss: 1.444462\n","(Iteration 181 / 4900) loss: 1.621678\n","(Iteration 191 / 4900) loss: 1.563613\n","(Iteration 201 / 4900) loss: 1.621723\n","(Iteration 211 / 4900) loss: 1.450137\n","(Iteration 221 / 4900) loss: 1.503464\n","(Iteration 231 / 4900) loss: 1.590363\n","(Iteration 241 / 4900) loss: 1.496305\n","(Iteration 251 / 4900) loss: 1.395866\n","(Iteration 261 / 4900) loss: 1.469307\n","(Iteration 271 / 4900) loss: 1.334271\n","(Iteration 281 / 4900) loss: 1.409580\n","(Iteration 291 / 4900) loss: 1.420748\n","(Iteration 301 / 4900) loss: 1.434079\n","(Iteration 311 / 4900) loss: 1.565992\n","(Iteration 321 / 4900) loss: 1.465264\n","(Iteration 331 / 4900) loss: 1.320280\n","(Iteration 341 / 4900) loss: 1.571849\n","(Iteration 351 / 4900) loss: 1.514093\n","(Iteration 361 / 4900) loss: 1.439278\n","(Iteration 371 / 4900) loss: 1.536912\n","(Iteration 381 / 4900) loss: 1.467356\n","(Iteration 391 / 4900) loss: 1.421848\n","(Iteration 401 / 4900) loss: 1.524893\n","(Iteration 411 / 4900) loss: 1.321279\n","(Iteration 421 / 4900) loss: 1.269986\n","(Iteration 431 / 4900) loss: 1.404241\n","(Iteration 441 / 4900) loss: 1.326768\n","(Iteration 451 / 4900) loss: 1.451011\n","(Iteration 461 / 4900) loss: 1.594446\n","(Iteration 471 / 4900) loss: 1.361660\n","(Iteration 481 / 4900) loss: 1.422114\n","(Epoch 1 / 10) train acc: 0.540000; val_acc: 0.506000\n","(Iteration 491 / 4900) loss: 1.332196\n","(Iteration 501 / 4900) loss: 1.500901\n","(Iteration 511 / 4900) loss: 1.380911\n","(Iteration 521 / 4900) loss: 1.174606\n","(Iteration 531 / 4900) loss: 1.210616\n","(Iteration 541 / 4900) loss: 1.425086\n","(Iteration 551 / 4900) loss: 1.360100\n","(Iteration 561 / 4900) loss: 1.350859\n","(Iteration 571 / 4900) loss: 1.334627\n","(Iteration 581 / 4900) loss: 1.581823\n","(Iteration 591 / 4900) loss: 1.405920\n","(Iteration 601 / 4900) loss: 1.497391\n","(Iteration 611 / 4900) loss: 1.212779\n","(Iteration 621 / 4900) loss: 1.421881\n","(Iteration 631 / 4900) loss: 1.350550\n","(Iteration 641 / 4900) loss: 1.425939\n","(Iteration 651 / 4900) loss: 1.368831\n","(Iteration 661 / 4900) loss: 1.335459\n","(Iteration 671 / 4900) loss: 1.166216\n","(Iteration 681 / 4900) loss: 1.429204\n","(Iteration 691 / 4900) loss: 1.437941\n","(Iteration 701 / 4900) loss: 1.239544\n","(Iteration 711 / 4900) loss: 1.344429\n","(Iteration 721 / 4900) loss: 1.375179\n","(Iteration 731 / 4900) loss: 1.243318\n","(Iteration 741 / 4900) loss: 1.260108\n","(Iteration 751 / 4900) loss: 1.131229\n","(Iteration 761 / 4900) loss: 1.341099\n","(Iteration 771 / 4900) loss: 1.131006\n","(Iteration 781 / 4900) loss: 1.628176\n","(Iteration 791 / 4900) loss: 1.306188\n","(Iteration 801 / 4900) loss: 1.118111\n","(Iteration 811 / 4900) loss: 1.196824\n","(Iteration 821 / 4900) loss: 1.282005\n","(Iteration 831 / 4900) loss: 1.246898\n","(Iteration 841 / 4900) loss: 1.215891\n","(Iteration 851 / 4900) loss: 1.088740\n","(Iteration 861 / 4900) loss: 1.428722\n","(Iteration 871 / 4900) loss: 1.075371\n","(Iteration 881 / 4900) loss: 1.481210\n","(Iteration 891 / 4900) loss: 1.190966\n","(Iteration 901 / 4900) loss: 1.195874\n","(Iteration 911 / 4900) loss: 1.159451\n","(Iteration 921 / 4900) loss: 1.059070\n","(Iteration 931 / 4900) loss: 1.219071\n","(Iteration 941 / 4900) loss: 1.122881\n","(Iteration 951 / 4900) loss: 1.264937\n","(Iteration 961 / 4900) loss: 1.130516\n","(Iteration 971 / 4900) loss: 1.075673\n","(Epoch 2 / 10) train acc: 0.569000; val_acc: 0.531000\n","(Iteration 981 / 4900) loss: 1.170940\n","(Iteration 991 / 4900) loss: 1.179314\n","(Iteration 1001 / 4900) loss: 1.209121\n","(Iteration 1011 / 4900) loss: 1.105654\n","(Iteration 1021 / 4900) loss: 1.298173\n","(Iteration 1031 / 4900) loss: 1.410357\n","(Iteration 1041 / 4900) loss: 1.197691\n","(Iteration 1051 / 4900) loss: 1.219073\n","(Iteration 1061 / 4900) loss: 1.312632\n","(Iteration 1071 / 4900) loss: 1.202561\n","(Iteration 1081 / 4900) loss: 1.391235\n","(Iteration 1091 / 4900) loss: 1.222608\n","(Iteration 1101 / 4900) loss: 1.105404\n","(Iteration 1111 / 4900) loss: 1.152517\n","(Iteration 1121 / 4900) loss: 1.074011\n","(Iteration 1131 / 4900) loss: 1.244488\n","(Iteration 1141 / 4900) loss: 1.242189\n","(Iteration 1151 / 4900) loss: 1.019742\n","(Iteration 1161 / 4900) loss: 1.249227\n","(Iteration 1171 / 4900) loss: 1.010506\n","(Iteration 1181 / 4900) loss: 1.215332\n","(Iteration 1191 / 4900) loss: 1.070243\n","(Iteration 1201 / 4900) loss: 1.200316\n","(Iteration 1211 / 4900) loss: 1.174694\n","(Iteration 1221 / 4900) loss: 1.067022\n","(Iteration 1231 / 4900) loss: 1.167198\n","(Iteration 1241 / 4900) loss: 1.190996\n","(Iteration 1251 / 4900) loss: 1.214445\n","(Iteration 1261 / 4900) loss: 1.119646\n","(Iteration 1271 / 4900) loss: 1.004100\n","(Iteration 1281 / 4900) loss: 1.512732\n","(Iteration 1291 / 4900) loss: 1.401016\n","(Iteration 1301 / 4900) loss: 1.031223\n","(Iteration 1311 / 4900) loss: 1.131423\n","(Iteration 1321 / 4900) loss: 1.472687\n","(Iteration 1331 / 4900) loss: 1.213364\n","(Iteration 1341 / 4900) loss: 1.199365\n","(Iteration 1351 / 4900) loss: 1.307185\n","(Iteration 1361 / 4900) loss: 1.308854\n","(Iteration 1371 / 4900) loss: 1.194715\n","(Iteration 1381 / 4900) loss: 1.093232\n","(Iteration 1391 / 4900) loss: 1.140074\n","(Iteration 1401 / 4900) loss: 1.065836\n","(Iteration 1411 / 4900) loss: 1.112909\n","(Iteration 1421 / 4900) loss: 1.250947\n","(Iteration 1431 / 4900) loss: 1.154611\n","(Iteration 1441 / 4900) loss: 1.088271\n","(Iteration 1451 / 4900) loss: 1.312945\n","(Iteration 1461 / 4900) loss: 1.000562\n","(Epoch 3 / 10) train acc: 0.582000; val_acc: 0.552000\n","(Iteration 1471 / 4900) loss: 1.179871\n","(Iteration 1481 / 4900) loss: 0.996612\n","(Iteration 1491 / 4900) loss: 0.990997\n","(Iteration 1501 / 4900) loss: 1.162562\n","(Iteration 1511 / 4900) loss: 1.038024\n","(Iteration 1521 / 4900) loss: 1.152702\n","(Iteration 1531 / 4900) loss: 1.121291\n","(Iteration 1541 / 4900) loss: 1.130017\n","(Iteration 1551 / 4900) loss: 1.233126\n","(Iteration 1561 / 4900) loss: 1.198537\n","(Iteration 1571 / 4900) loss: 1.406929\n","(Iteration 1581 / 4900) loss: 1.141165\n","(Iteration 1591 / 4900) loss: 1.192027\n","(Iteration 1601 / 4900) loss: 1.093978\n","(Iteration 1611 / 4900) loss: 0.889267\n","(Iteration 1621 / 4900) loss: 1.031593\n","(Iteration 1631 / 4900) loss: 1.019652\n","(Iteration 1641 / 4900) loss: 1.245050\n","(Iteration 1651 / 4900) loss: 1.203328\n","(Iteration 1661 / 4900) loss: 1.302057\n","(Iteration 1671 / 4900) loss: 1.231756\n","(Iteration 1681 / 4900) loss: 1.139228\n","(Iteration 1691 / 4900) loss: 1.143305\n","(Iteration 1701 / 4900) loss: 1.250070\n","(Iteration 1711 / 4900) loss: 1.396715\n","(Iteration 1721 / 4900) loss: 1.225568\n","(Iteration 1731 / 4900) loss: 1.255115\n","(Iteration 1741 / 4900) loss: 0.963271\n","(Iteration 1751 / 4900) loss: 1.150746\n","(Iteration 1761 / 4900) loss: 0.965322\n","(Iteration 1771 / 4900) loss: 0.965499\n","(Iteration 1781 / 4900) loss: 1.299194\n","(Iteration 1791 / 4900) loss: 1.264843\n","(Iteration 1801 / 4900) loss: 1.163234\n","(Iteration 1811 / 4900) loss: 1.055426\n","(Iteration 1821 / 4900) loss: 1.166238\n","(Iteration 1831 / 4900) loss: 0.994888\n","(Iteration 1841 / 4900) loss: 1.189636\n","(Iteration 1851 / 4900) loss: 1.003316\n","(Iteration 1861 / 4900) loss: 0.975364\n","(Iteration 1871 / 4900) loss: 0.859536\n","(Iteration 1881 / 4900) loss: 1.053612\n","(Iteration 1891 / 4900) loss: 1.137485\n","(Iteration 1901 / 4900) loss: 1.029719\n","(Iteration 1911 / 4900) loss: 1.052987\n","(Iteration 1921 / 4900) loss: 1.105457\n","(Iteration 1931 / 4900) loss: 1.087195\n","(Iteration 1941 / 4900) loss: 1.004435\n","(Iteration 1951 / 4900) loss: 1.034945\n","(Epoch 4 / 10) train acc: 0.628000; val_acc: 0.550000\n","(Iteration 1961 / 4900) loss: 1.003965\n","(Iteration 1971 / 4900) loss: 1.038812\n","(Iteration 1981 / 4900) loss: 1.233723\n","(Iteration 1991 / 4900) loss: 1.017158\n","(Iteration 2001 / 4900) loss: 1.109085\n","(Iteration 2011 / 4900) loss: 1.376443\n","(Iteration 2021 / 4900) loss: 1.264327\n","(Iteration 2031 / 4900) loss: 1.016426\n","(Iteration 2041 / 4900) loss: 0.874477\n","(Iteration 2051 / 4900) loss: 1.087602\n","(Iteration 2061 / 4900) loss: 1.227256\n","(Iteration 2071 / 4900) loss: 0.935168\n","(Iteration 2081 / 4900) loss: 1.212390\n","(Iteration 2091 / 4900) loss: 1.168493\n","(Iteration 2101 / 4900) loss: 1.095273\n","(Iteration 2111 / 4900) loss: 1.140424\n","(Iteration 2121 / 4900) loss: 1.062551\n","(Iteration 2131 / 4900) loss: 1.136875\n","(Iteration 2141 / 4900) loss: 0.954088\n","(Iteration 2151 / 4900) loss: 1.232621\n","(Iteration 2161 / 4900) loss: 0.917659\n","(Iteration 2171 / 4900) loss: 0.904889\n","(Iteration 2181 / 4900) loss: 1.315001\n","(Iteration 2191 / 4900) loss: 1.078637\n","(Iteration 2201 / 4900) loss: 0.987435\n","(Iteration 2211 / 4900) loss: 0.912944\n","(Iteration 2221 / 4900) loss: 1.166116\n","(Iteration 2231 / 4900) loss: 1.180685\n","(Iteration 2241 / 4900) loss: 1.028660\n","(Iteration 2251 / 4900) loss: 1.213920\n","(Iteration 2261 / 4900) loss: 1.161522\n","(Iteration 2271 / 4900) loss: 1.030172\n","(Iteration 2281 / 4900) loss: 1.012165\n","(Iteration 2291 / 4900) loss: 1.031080\n","(Iteration 2301 / 4900) loss: 1.116006\n","(Iteration 2311 / 4900) loss: 1.093297\n","(Iteration 2321 / 4900) loss: 1.126228\n","(Iteration 2331 / 4900) loss: 0.958441\n","(Iteration 2341 / 4900) loss: 1.215310\n","(Iteration 2351 / 4900) loss: 0.950044\n","(Iteration 2361 / 4900) loss: 1.108156\n","(Iteration 2371 / 4900) loss: 1.015728\n","(Iteration 2381 / 4900) loss: 0.927851\n","(Iteration 2391 / 4900) loss: 1.015280\n","(Iteration 2401 / 4900) loss: 1.085820\n","(Iteration 2411 / 4900) loss: 1.051880\n","(Iteration 2421 / 4900) loss: 0.969770\n","(Iteration 2431 / 4900) loss: 0.939446\n","(Iteration 2441 / 4900) loss: 1.173783\n","(Epoch 5 / 10) train acc: 0.620000; val_acc: 0.571000\n","(Iteration 2451 / 4900) loss: 1.093919\n","(Iteration 2461 / 4900) loss: 1.123090\n","(Iteration 2471 / 4900) loss: 0.952901\n","(Iteration 2481 / 4900) loss: 0.888798\n","(Iteration 2491 / 4900) loss: 1.038666\n","(Iteration 2501 / 4900) loss: 0.984865\n","(Iteration 2511 / 4900) loss: 0.830609\n","(Iteration 2521 / 4900) loss: 1.020171\n","(Iteration 2531 / 4900) loss: 0.989852\n","(Iteration 2541 / 4900) loss: 1.192418\n","(Iteration 2551 / 4900) loss: 0.976038\n","(Iteration 2561 / 4900) loss: 1.014916\n","(Iteration 2571 / 4900) loss: 0.960086\n","(Iteration 2581 / 4900) loss: 0.981052\n","(Iteration 2591 / 4900) loss: 0.982588\n","(Iteration 2601 / 4900) loss: 0.892556\n","(Iteration 2611 / 4900) loss: 0.970229\n","(Iteration 2621 / 4900) loss: 1.082239\n","(Iteration 2631 / 4900) loss: 0.989321\n","(Iteration 2641 / 4900) loss: 1.135467\n","(Iteration 2651 / 4900) loss: 0.851944\n","(Iteration 2661 / 4900) loss: 0.955026\n","(Iteration 2671 / 4900) loss: 1.227617\n","(Iteration 2681 / 4900) loss: 1.188793\n","(Iteration 2691 / 4900) loss: 0.958781\n","(Iteration 2701 / 4900) loss: 0.987006\n","(Iteration 2711 / 4900) loss: 1.114142\n","(Iteration 2721 / 4900) loss: 1.198153\n","(Iteration 2731 / 4900) loss: 0.866821\n","(Iteration 2741 / 4900) loss: 1.064383\n","(Iteration 2751 / 4900) loss: 1.120298\n","(Iteration 2761 / 4900) loss: 0.996929\n","(Iteration 2771 / 4900) loss: 0.937142\n","(Iteration 2781 / 4900) loss: 1.007175\n","(Iteration 2791 / 4900) loss: 0.931940\n","(Iteration 2801 / 4900) loss: 1.259567\n","(Iteration 2811 / 4900) loss: 0.898138\n","(Iteration 2821 / 4900) loss: 1.135256\n","(Iteration 2831 / 4900) loss: 1.168462\n","(Iteration 2841 / 4900) loss: 1.024603\n","(Iteration 2851 / 4900) loss: 1.194698\n","(Iteration 2861 / 4900) loss: 1.070695\n","(Iteration 2871 / 4900) loss: 0.832867\n","(Iteration 2881 / 4900) loss: 1.143692\n","(Iteration 2891 / 4900) loss: 1.004170\n","(Iteration 2901 / 4900) loss: 1.082939\n","(Iteration 2911 / 4900) loss: 0.934585\n","(Iteration 2921 / 4900) loss: 1.017966\n","(Iteration 2931 / 4900) loss: 0.911129\n","(Epoch 6 / 10) train acc: 0.640000; val_acc: 0.570000\n","(Iteration 2941 / 4900) loss: 1.264501\n","(Iteration 2951 / 4900) loss: 1.179948\n","(Iteration 2961 / 4900) loss: 1.152207\n","(Iteration 2971 / 4900) loss: 0.957723\n","(Iteration 2981 / 4900) loss: 0.998748\n","(Iteration 2991 / 4900) loss: 1.024398\n","(Iteration 3001 / 4900) loss: 1.002726\n","(Iteration 3011 / 4900) loss: 0.972144\n","(Iteration 3021 / 4900) loss: 1.361862\n","(Iteration 3031 / 4900) loss: 0.908504\n","(Iteration 3041 / 4900) loss: 0.945141\n","(Iteration 3051 / 4900) loss: 0.989722\n","(Iteration 3061 / 4900) loss: 0.942036\n","(Iteration 3071 / 4900) loss: 0.893372\n","(Iteration 3081 / 4900) loss: 0.885481\n","(Iteration 3091 / 4900) loss: 1.062069\n","(Iteration 3101 / 4900) loss: 1.236109\n","(Iteration 3111 / 4900) loss: 1.043169\n","(Iteration 3121 / 4900) loss: 0.949545\n","(Iteration 3131 / 4900) loss: 0.949709\n","(Iteration 3141 / 4900) loss: 0.959200\n","(Iteration 3151 / 4900) loss: 0.972929\n","(Iteration 3161 / 4900) loss: 0.876212\n","(Iteration 3171 / 4900) loss: 1.160198\n","(Iteration 3181 / 4900) loss: 1.260272\n","(Iteration 3191 / 4900) loss: 0.925661\n","(Iteration 3201 / 4900) loss: 1.053017\n","(Iteration 3211 / 4900) loss: 1.122608\n","(Iteration 3221 / 4900) loss: 0.782538\n","(Iteration 3231 / 4900) loss: 1.254077\n","(Iteration 3241 / 4900) loss: 0.727839\n","(Iteration 3251 / 4900) loss: 0.878410\n","(Iteration 3261 / 4900) loss: 0.999745\n","(Iteration 3271 / 4900) loss: 1.031200\n","(Iteration 3281 / 4900) loss: 1.073740\n","(Iteration 3291 / 4900) loss: 0.996671\n","(Iteration 3301 / 4900) loss: 1.059948\n","(Iteration 3311 / 4900) loss: 0.960839\n","(Iteration 3321 / 4900) loss: 0.896301\n","(Iteration 3331 / 4900) loss: 0.984508\n","(Iteration 3341 / 4900) loss: 1.136012\n","(Iteration 3351 / 4900) loss: 0.909651\n","(Iteration 3361 / 4900) loss: 0.948573\n","(Iteration 3371 / 4900) loss: 1.136715\n","(Iteration 3381 / 4900) loss: 0.931061\n","(Iteration 3391 / 4900) loss: 1.158122\n","(Iteration 3401 / 4900) loss: 0.962630\n","(Iteration 3411 / 4900) loss: 1.015990\n","(Iteration 3421 / 4900) loss: 1.008447\n","(Epoch 7 / 10) train acc: 0.655000; val_acc: 0.576000\n","(Iteration 3431 / 4900) loss: 1.026886\n","(Iteration 3441 / 4900) loss: 0.864662\n","(Iteration 3451 / 4900) loss: 1.039458\n","(Iteration 3461 / 4900) loss: 0.925747\n","(Iteration 3471 / 4900) loss: 1.050602\n","(Iteration 3481 / 4900) loss: 0.861436\n","(Iteration 3491 / 4900) loss: 0.855578\n","(Iteration 3501 / 4900) loss: 0.843958\n","(Iteration 3511 / 4900) loss: 1.089942\n","(Iteration 3521 / 4900) loss: 1.005542\n","(Iteration 3531 / 4900) loss: 1.130419\n","(Iteration 3541 / 4900) loss: 0.913464\n","(Iteration 3551 / 4900) loss: 1.008824\n","(Iteration 3561 / 4900) loss: 0.824056\n","(Iteration 3571 / 4900) loss: 0.959733\n","(Iteration 3581 / 4900) loss: 0.984320\n","(Iteration 3591 / 4900) loss: 0.976176\n","(Iteration 3601 / 4900) loss: 0.935613\n","(Iteration 3611 / 4900) loss: 0.999579\n","(Iteration 3621 / 4900) loss: 1.086496\n","(Iteration 3631 / 4900) loss: 0.990182\n","(Iteration 3641 / 4900) loss: 1.080113\n","(Iteration 3651 / 4900) loss: 0.970446\n","(Iteration 3661 / 4900) loss: 0.846869\n","(Iteration 3671 / 4900) loss: 0.988791\n","(Iteration 3681 / 4900) loss: 0.793206\n","(Iteration 3691 / 4900) loss: 0.803859\n","(Iteration 3701 / 4900) loss: 0.970009\n","(Iteration 3711 / 4900) loss: 0.970438\n","(Iteration 3721 / 4900) loss: 1.021860\n","(Iteration 3731 / 4900) loss: 1.065709\n","(Iteration 3741 / 4900) loss: 0.935471\n","(Iteration 3751 / 4900) loss: 0.942361\n","(Iteration 3761 / 4900) loss: 1.019580\n","(Iteration 3771 / 4900) loss: 1.022946\n","(Iteration 3781 / 4900) loss: 0.881413\n","(Iteration 3791 / 4900) loss: 1.094281\n","(Iteration 3801 / 4900) loss: 1.123392\n","(Iteration 3811 / 4900) loss: 1.050174\n","(Iteration 3821 / 4900) loss: 1.065884\n","(Iteration 3831 / 4900) loss: 0.973303\n","(Iteration 3841 / 4900) loss: 0.903439\n","(Iteration 3851 / 4900) loss: 0.998531\n","(Iteration 3861 / 4900) loss: 1.105897\n","(Iteration 3871 / 4900) loss: 0.998994\n","(Iteration 3881 / 4900) loss: 0.760168\n","(Iteration 3891 / 4900) loss: 0.915588\n","(Iteration 3901 / 4900) loss: 1.019895\n","(Iteration 3911 / 4900) loss: 0.926761\n","(Epoch 8 / 10) train acc: 0.652000; val_acc: 0.566000\n","(Iteration 3921 / 4900) loss: 1.131498\n","(Iteration 3931 / 4900) loss: 1.014800\n","(Iteration 3941 / 4900) loss: 1.079026\n","(Iteration 3951 / 4900) loss: 0.857985\n","(Iteration 3961 / 4900) loss: 1.022707\n","(Iteration 3971 / 4900) loss: 0.816578\n","(Iteration 3981 / 4900) loss: 0.921136\n","(Iteration 3991 / 4900) loss: 0.931611\n","(Iteration 4001 / 4900) loss: 0.845571\n","(Iteration 4011 / 4900) loss: 1.004907\n","(Iteration 4021 / 4900) loss: 0.884952\n","(Iteration 4031 / 4900) loss: 0.876411\n","(Iteration 4041 / 4900) loss: 1.061655\n","(Iteration 4051 / 4900) loss: 0.857664\n","(Iteration 4061 / 4900) loss: 1.059821\n","(Iteration 4071 / 4900) loss: 0.945930\n","(Iteration 4081 / 4900) loss: 0.944988\n","(Iteration 4091 / 4900) loss: 0.866713\n","(Iteration 4101 / 4900) loss: 0.872777\n","(Iteration 4111 / 4900) loss: 0.805311\n","(Iteration 4121 / 4900) loss: 0.915733\n","(Iteration 4131 / 4900) loss: 0.988816\n","(Iteration 4141 / 4900) loss: 0.891943\n","(Iteration 4151 / 4900) loss: 1.142252\n","(Iteration 4161 / 4900) loss: 1.108996\n","(Iteration 4171 / 4900) loss: 0.895964\n","(Iteration 4181 / 4900) loss: 1.093900\n","(Iteration 4191 / 4900) loss: 0.960189\n","(Iteration 4201 / 4900) loss: 0.959796\n","(Iteration 4211 / 4900) loss: 0.877687\n","(Iteration 4221 / 4900) loss: 0.926426\n","(Iteration 4231 / 4900) loss: 0.875986\n","(Iteration 4241 / 4900) loss: 0.655407\n","(Iteration 4251 / 4900) loss: 1.045142\n","(Iteration 4261 / 4900) loss: 0.754597\n","(Iteration 4271 / 4900) loss: 0.843638\n","(Iteration 4281 / 4900) loss: 1.054022\n","(Iteration 4291 / 4900) loss: 1.059024\n","(Iteration 4301 / 4900) loss: 1.004396\n","(Iteration 4311 / 4900) loss: 1.001794\n","(Iteration 4321 / 4900) loss: 0.724061\n","(Iteration 4331 / 4900) loss: 0.984377\n","(Iteration 4341 / 4900) loss: 0.861482\n","(Iteration 4351 / 4900) loss: 0.824162\n","(Iteration 4361 / 4900) loss: 1.066933\n","(Iteration 4371 / 4900) loss: 0.932095\n","(Iteration 4381 / 4900) loss: 1.016326\n","(Iteration 4391 / 4900) loss: 0.946973\n","(Iteration 4401 / 4900) loss: 0.899263\n","(Epoch 9 / 10) train acc: 0.657000; val_acc: 0.565000\n","(Iteration 4411 / 4900) loss: 0.585066\n","(Iteration 4421 / 4900) loss: 1.190975\n","(Iteration 4431 / 4900) loss: 0.900838\n","(Iteration 4441 / 4900) loss: 0.842964\n","(Iteration 4451 / 4900) loss: 1.080758\n","(Iteration 4461 / 4900) loss: 0.990833\n","(Iteration 4471 / 4900) loss: 0.877786\n","(Iteration 4481 / 4900) loss: 1.102440\n","(Iteration 4491 / 4900) loss: 1.063326\n","(Iteration 4501 / 4900) loss: 0.786420\n","(Iteration 4511 / 4900) loss: 0.931849\n","(Iteration 4521 / 4900) loss: 0.838325\n","(Iteration 4531 / 4900) loss: 1.126815\n","(Iteration 4541 / 4900) loss: 0.826096\n","(Iteration 4551 / 4900) loss: 0.930299\n","(Iteration 4561 / 4900) loss: 0.971456\n","(Iteration 4571 / 4900) loss: 0.878236\n","(Iteration 4581 / 4900) loss: 0.967188\n","(Iteration 4591 / 4900) loss: 0.900914\n","(Iteration 4601 / 4900) loss: 0.763154\n","(Iteration 4611 / 4900) loss: 0.858584\n","(Iteration 4621 / 4900) loss: 1.017918\n","(Iteration 4631 / 4900) loss: 0.835350\n","(Iteration 4641 / 4900) loss: 1.033993\n","(Iteration 4651 / 4900) loss: 0.812581\n","(Iteration 4661 / 4900) loss: 0.916714\n","(Iteration 4671 / 4900) loss: 0.710798\n","(Iteration 4681 / 4900) loss: 0.671239\n","(Iteration 4691 / 4900) loss: 0.948583\n","(Iteration 4701 / 4900) loss: 0.764018\n","(Iteration 4711 / 4900) loss: 0.825066\n","(Iteration 4721 / 4900) loss: 0.845873\n","(Iteration 4731 / 4900) loss: 0.891862\n","(Iteration 4741 / 4900) loss: 0.920761\n","(Iteration 4751 / 4900) loss: 0.918485\n","(Iteration 4761 / 4900) loss: 1.166031\n","(Iteration 4771 / 4900) loss: 1.043986\n","(Iteration 4781 / 4900) loss: 0.858509\n","(Iteration 4791 / 4900) loss: 0.809805\n","(Iteration 4801 / 4900) loss: 0.709373\n","(Iteration 4811 / 4900) loss: 0.907863\n","(Iteration 4821 / 4900) loss: 0.801691\n","(Iteration 4831 / 4900) loss: 1.099931\n","(Iteration 4841 / 4900) loss: 0.830921\n","(Iteration 4851 / 4900) loss: 0.916274\n","(Iteration 4861 / 4900) loss: 1.015437\n","(Iteration 4871 / 4900) loss: 0.982404\n","(Iteration 4881 / 4900) loss: 1.014129\n","(Iteration 4891 / 4900) loss: 0.840946\n","(Epoch 10 / 10) train acc: 0.692000; val_acc: 0.573000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.100000; val_acc: 0.087000\n","(Iteration 11 / 4900) loss: 2.301181\n","(Iteration 21 / 4900) loss: 2.316954\n","(Iteration 31 / 4900) loss: 2.301159\n","(Iteration 41 / 4900) loss: 2.086258\n","(Iteration 51 / 4900) loss: 1.889904\n","(Iteration 61 / 4900) loss: 1.908480\n","(Iteration 71 / 4900) loss: 1.670868\n","(Iteration 81 / 4900) loss: 1.809137\n","(Iteration 91 / 4900) loss: 1.475472\n","(Iteration 101 / 4900) loss: 1.555354\n","(Iteration 111 / 4900) loss: 1.622520\n","(Iteration 121 / 4900) loss: 1.560521\n","(Iteration 131 / 4900) loss: 1.533036\n","(Iteration 141 / 4900) loss: 1.261607\n","(Iteration 151 / 4900) loss: 1.592163\n","(Iteration 161 / 4900) loss: 1.322677\n","(Iteration 171 / 4900) loss: 1.537645\n","(Iteration 181 / 4900) loss: 1.319339\n","(Iteration 191 / 4900) loss: 1.322641\n","(Iteration 201 / 4900) loss: 1.493125\n","(Iteration 211 / 4900) loss: 1.271113\n","(Iteration 221 / 4900) loss: 1.284258\n","(Iteration 231 / 4900) loss: 1.249617\n","(Iteration 241 / 4900) loss: 1.482773\n","(Iteration 251 / 4900) loss: 1.431213\n","(Iteration 261 / 4900) loss: 1.470360\n","(Iteration 271 / 4900) loss: 1.614352\n","(Iteration 281 / 4900) loss: 1.311742\n","(Iteration 291 / 4900) loss: 1.602007\n","(Iteration 301 / 4900) loss: 1.320927\n","(Iteration 311 / 4900) loss: 1.311960\n","(Iteration 321 / 4900) loss: 1.202940\n","(Iteration 331 / 4900) loss: 1.434196\n","(Iteration 341 / 4900) loss: 1.602841\n","(Iteration 351 / 4900) loss: 1.529188\n","(Iteration 361 / 4900) loss: 1.447653\n","(Iteration 371 / 4900) loss: 1.301169\n","(Iteration 381 / 4900) loss: 1.346750\n","(Iteration 391 / 4900) loss: 1.305800\n","(Iteration 401 / 4900) loss: 1.387688\n","(Iteration 411 / 4900) loss: 1.130153\n","(Iteration 421 / 4900) loss: 1.321981\n","(Iteration 431 / 4900) loss: 1.276193\n","(Iteration 441 / 4900) loss: 1.529508\n","(Iteration 451 / 4900) loss: 1.355052\n","(Iteration 461 / 4900) loss: 1.258601\n","(Iteration 471 / 4900) loss: 1.389507\n","(Iteration 481 / 4900) loss: 1.302938\n","(Epoch 1 / 10) train acc: 0.515000; val_acc: 0.510000\n","(Iteration 491 / 4900) loss: 1.274116\n","(Iteration 501 / 4900) loss: 1.208816\n","(Iteration 511 / 4900) loss: 1.201263\n","(Iteration 521 / 4900) loss: 1.679252\n","(Iteration 531 / 4900) loss: 1.285602\n","(Iteration 541 / 4900) loss: 1.251877\n","(Iteration 551 / 4900) loss: 1.616029\n","(Iteration 561 / 4900) loss: 1.275880\n","(Iteration 571 / 4900) loss: 1.266078\n","(Iteration 581 / 4900) loss: 1.415660\n","(Iteration 591 / 4900) loss: 1.278422\n","(Iteration 601 / 4900) loss: 0.997025\n","(Iteration 611 / 4900) loss: 1.440336\n","(Iteration 621 / 4900) loss: 1.060368\n","(Iteration 631 / 4900) loss: 1.350609\n","(Iteration 641 / 4900) loss: 1.342471\n","(Iteration 651 / 4900) loss: 1.257558\n","(Iteration 661 / 4900) loss: 1.389283\n","(Iteration 671 / 4900) loss: 1.379187\n","(Iteration 681 / 4900) loss: 1.236511\n","(Iteration 691 / 4900) loss: 1.243272\n","(Iteration 701 / 4900) loss: 1.240890\n","(Iteration 711 / 4900) loss: 1.146799\n","(Iteration 721 / 4900) loss: 1.348363\n","(Iteration 731 / 4900) loss: 1.319132\n","(Iteration 741 / 4900) loss: 1.129644\n","(Iteration 751 / 4900) loss: 1.303331\n","(Iteration 761 / 4900) loss: 1.449115\n","(Iteration 771 / 4900) loss: 1.260731\n","(Iteration 781 / 4900) loss: 1.401874\n","(Iteration 791 / 4900) loss: 1.312601\n","(Iteration 801 / 4900) loss: 1.145749\n","(Iteration 811 / 4900) loss: 0.989608\n","(Iteration 821 / 4900) loss: 1.246570\n","(Iteration 831 / 4900) loss: 1.128316\n","(Iteration 841 / 4900) loss: 0.947993\n","(Iteration 851 / 4900) loss: 1.041143\n","(Iteration 861 / 4900) loss: 1.380615\n","(Iteration 871 / 4900) loss: 1.326701\n","(Iteration 881 / 4900) loss: 1.542471\n","(Iteration 891 / 4900) loss: 1.228693\n","(Iteration 901 / 4900) loss: 1.169785\n","(Iteration 911 / 4900) loss: 1.266569\n","(Iteration 921 / 4900) loss: 1.196461\n","(Iteration 931 / 4900) loss: 1.271187\n","(Iteration 941 / 4900) loss: 1.424449\n","(Iteration 951 / 4900) loss: 1.308563\n","(Iteration 961 / 4900) loss: 1.477300\n","(Iteration 971 / 4900) loss: 1.349568\n","(Epoch 2 / 10) train acc: 0.603000; val_acc: 0.539000\n","(Iteration 981 / 4900) loss: 1.183112\n","(Iteration 991 / 4900) loss: 1.157490\n","(Iteration 1001 / 4900) loss: 1.064507\n","(Iteration 1011 / 4900) loss: 1.317284\n","(Iteration 1021 / 4900) loss: 1.235942\n","(Iteration 1031 / 4900) loss: 1.298846\n","(Iteration 1041 / 4900) loss: 1.219596\n","(Iteration 1051 / 4900) loss: 1.097187\n","(Iteration 1061 / 4900) loss: 1.174058\n","(Iteration 1071 / 4900) loss: 1.147290\n","(Iteration 1081 / 4900) loss: 1.133234\n","(Iteration 1091 / 4900) loss: 1.182252\n","(Iteration 1101 / 4900) loss: 0.979491\n","(Iteration 1111 / 4900) loss: 1.163733\n","(Iteration 1121 / 4900) loss: 1.277722\n","(Iteration 1131 / 4900) loss: 1.328931\n","(Iteration 1141 / 4900) loss: 1.373782\n","(Iteration 1151 / 4900) loss: 1.152625\n","(Iteration 1161 / 4900) loss: 1.134060\n","(Iteration 1171 / 4900) loss: 1.181070\n","(Iteration 1181 / 4900) loss: 1.261002\n","(Iteration 1191 / 4900) loss: 1.098252\n","(Iteration 1201 / 4900) loss: 1.191107\n","(Iteration 1211 / 4900) loss: 1.260448\n","(Iteration 1221 / 4900) loss: 1.055292\n","(Iteration 1231 / 4900) loss: 1.146191\n","(Iteration 1241 / 4900) loss: 1.188320\n","(Iteration 1251 / 4900) loss: 1.199274\n","(Iteration 1261 / 4900) loss: 1.144517\n","(Iteration 1271 / 4900) loss: 1.017310\n","(Iteration 1281 / 4900) loss: 1.306210\n","(Iteration 1291 / 4900) loss: 0.971169\n","(Iteration 1301 / 4900) loss: 1.388482\n","(Iteration 1311 / 4900) loss: 1.244276\n","(Iteration 1321 / 4900) loss: 1.093926\n","(Iteration 1331 / 4900) loss: 1.573287\n","(Iteration 1341 / 4900) loss: 0.959950\n","(Iteration 1351 / 4900) loss: 1.169914\n","(Iteration 1361 / 4900) loss: 1.256005\n","(Iteration 1371 / 4900) loss: 1.154411\n","(Iteration 1381 / 4900) loss: 1.248916\n","(Iteration 1391 / 4900) loss: 1.053805\n","(Iteration 1401 / 4900) loss: 1.015981\n","(Iteration 1411 / 4900) loss: 1.160840\n","(Iteration 1421 / 4900) loss: 1.305092\n","(Iteration 1431 / 4900) loss: 1.173103\n","(Iteration 1441 / 4900) loss: 1.048528\n","(Iteration 1451 / 4900) loss: 1.185624\n","(Iteration 1461 / 4900) loss: 1.065253\n","(Epoch 3 / 10) train acc: 0.650000; val_acc: 0.549000\n","(Iteration 1471 / 4900) loss: 1.012949\n","(Iteration 1481 / 4900) loss: 1.319972\n","(Iteration 1491 / 4900) loss: 0.952246\n","(Iteration 1501 / 4900) loss: 1.005733\n","(Iteration 1511 / 4900) loss: 1.177922\n","(Iteration 1521 / 4900) loss: 1.247466\n","(Iteration 1531 / 4900) loss: 1.231417\n","(Iteration 1541 / 4900) loss: 1.158587\n","(Iteration 1551 / 4900) loss: 1.212871\n","(Iteration 1561 / 4900) loss: 0.943091\n","(Iteration 1571 / 4900) loss: 1.244811\n","(Iteration 1581 / 4900) loss: 1.043975\n","(Iteration 1591 / 4900) loss: 1.131377\n","(Iteration 1601 / 4900) loss: 1.050508\n","(Iteration 1611 / 4900) loss: 1.150228\n","(Iteration 1621 / 4900) loss: 1.227131\n","(Iteration 1631 / 4900) loss: 0.949356\n","(Iteration 1641 / 4900) loss: 1.252907\n","(Iteration 1651 / 4900) loss: 1.206574\n","(Iteration 1661 / 4900) loss: 1.096163\n","(Iteration 1671 / 4900) loss: 1.127353\n","(Iteration 1681 / 4900) loss: 1.293879\n","(Iteration 1691 / 4900) loss: 1.205129\n","(Iteration 1701 / 4900) loss: 1.021382\n","(Iteration 1711 / 4900) loss: 1.034523\n","(Iteration 1721 / 4900) loss: 0.988782\n","(Iteration 1731 / 4900) loss: 1.001137\n","(Iteration 1741 / 4900) loss: 0.912687\n","(Iteration 1751 / 4900) loss: 1.021312\n","(Iteration 1761 / 4900) loss: 1.213718\n","(Iteration 1771 / 4900) loss: 1.122736\n","(Iteration 1781 / 4900) loss: 0.814113\n","(Iteration 1791 / 4900) loss: 1.242990\n","(Iteration 1801 / 4900) loss: 0.999628\n","(Iteration 1811 / 4900) loss: 1.048414\n","(Iteration 1821 / 4900) loss: 1.169451\n","(Iteration 1831 / 4900) loss: 1.230914\n","(Iteration 1841 / 4900) loss: 1.221492\n","(Iteration 1851 / 4900) loss: 1.040416\n","(Iteration 1861 / 4900) loss: 1.117266\n","(Iteration 1871 / 4900) loss: 1.290666\n","(Iteration 1881 / 4900) loss: 1.117793\n","(Iteration 1891 / 4900) loss: 0.957273\n","(Iteration 1901 / 4900) loss: 0.912550\n","(Iteration 1911 / 4900) loss: 1.109087\n","(Iteration 1921 / 4900) loss: 1.011152\n","(Iteration 1931 / 4900) loss: 0.949317\n","(Iteration 1941 / 4900) loss: 1.112463\n","(Iteration 1951 / 4900) loss: 1.163249\n","(Epoch 4 / 10) train acc: 0.631000; val_acc: 0.535000\n","(Iteration 1961 / 4900) loss: 0.918456\n","(Iteration 1971 / 4900) loss: 1.025906\n","(Iteration 1981 / 4900) loss: 1.098692\n","(Iteration 1991 / 4900) loss: 1.073996\n","(Iteration 2001 / 4900) loss: 1.208738\n","(Iteration 2011 / 4900) loss: 0.993304\n","(Iteration 2021 / 4900) loss: 0.933678\n","(Iteration 2031 / 4900) loss: 0.998893\n","(Iteration 2041 / 4900) loss: 0.995759\n","(Iteration 2051 / 4900) loss: 0.947974\n","(Iteration 2061 / 4900) loss: 1.197175\n","(Iteration 2071 / 4900) loss: 1.204576\n","(Iteration 2081 / 4900) loss: 0.932466\n","(Iteration 2091 / 4900) loss: 1.019923\n","(Iteration 2101 / 4900) loss: 1.186603\n","(Iteration 2111 / 4900) loss: 1.186013\n","(Iteration 2121 / 4900) loss: 0.918228\n","(Iteration 2131 / 4900) loss: 1.062095\n","(Iteration 2141 / 4900) loss: 0.717965\n","(Iteration 2151 / 4900) loss: 1.205354\n","(Iteration 2161 / 4900) loss: 1.132209\n","(Iteration 2171 / 4900) loss: 0.903785\n","(Iteration 2181 / 4900) loss: 1.060583\n","(Iteration 2191 / 4900) loss: 1.164328\n","(Iteration 2201 / 4900) loss: 1.197238\n","(Iteration 2211 / 4900) loss: 1.310821\n","(Iteration 2221 / 4900) loss: 1.336351\n","(Iteration 2231 / 4900) loss: 1.033626\n","(Iteration 2241 / 4900) loss: 1.114332\n","(Iteration 2251 / 4900) loss: 1.245017\n","(Iteration 2261 / 4900) loss: 1.044405\n","(Iteration 2271 / 4900) loss: 1.001046\n","(Iteration 2281 / 4900) loss: 0.872624\n","(Iteration 2291 / 4900) loss: 1.181240\n","(Iteration 2301 / 4900) loss: 0.995507\n","(Iteration 2311 / 4900) loss: 1.222692\n","(Iteration 2321 / 4900) loss: 0.970100\n","(Iteration 2331 / 4900) loss: 1.163295\n","(Iteration 2341 / 4900) loss: 1.136636\n","(Iteration 2351 / 4900) loss: 0.922778\n","(Iteration 2361 / 4900) loss: 1.168369\n","(Iteration 2371 / 4900) loss: 1.072533\n","(Iteration 2381 / 4900) loss: 1.247282\n","(Iteration 2391 / 4900) loss: 0.916150\n","(Iteration 2401 / 4900) loss: 1.287419\n","(Iteration 2411 / 4900) loss: 1.029909\n","(Iteration 2421 / 4900) loss: 1.034801\n","(Iteration 2431 / 4900) loss: 1.128008\n","(Iteration 2441 / 4900) loss: 1.016063\n","(Epoch 5 / 10) train acc: 0.669000; val_acc: 0.566000\n","(Iteration 2451 / 4900) loss: 1.078512\n","(Iteration 2461 / 4900) loss: 0.948568\n","(Iteration 2471 / 4900) loss: 0.949241\n","(Iteration 2481 / 4900) loss: 0.777895\n","(Iteration 2491 / 4900) loss: 0.881531\n","(Iteration 2501 / 4900) loss: 1.139199\n","(Iteration 2511 / 4900) loss: 1.001474\n","(Iteration 2521 / 4900) loss: 0.883790\n","(Iteration 2531 / 4900) loss: 1.066886\n","(Iteration 2541 / 4900) loss: 0.953876\n","(Iteration 2551 / 4900) loss: 0.980756\n","(Iteration 2561 / 4900) loss: 1.096761\n","(Iteration 2571 / 4900) loss: 0.881096\n","(Iteration 2581 / 4900) loss: 0.945480\n","(Iteration 2591 / 4900) loss: 1.129274\n","(Iteration 2601 / 4900) loss: 1.026506\n","(Iteration 2611 / 4900) loss: 0.984188\n","(Iteration 2621 / 4900) loss: 1.088983\n","(Iteration 2631 / 4900) loss: 0.878404\n","(Iteration 2641 / 4900) loss: 0.820624\n","(Iteration 2651 / 4900) loss: 0.967308\n","(Iteration 2661 / 4900) loss: 1.182125\n","(Iteration 2671 / 4900) loss: 1.119894\n","(Iteration 2681 / 4900) loss: 1.075550\n","(Iteration 2691 / 4900) loss: 0.964983\n","(Iteration 2701 / 4900) loss: 0.874051\n","(Iteration 2711 / 4900) loss: 1.051944\n","(Iteration 2721 / 4900) loss: 0.785590\n","(Iteration 2731 / 4900) loss: 0.897576\n","(Iteration 2741 / 4900) loss: 0.734984\n","(Iteration 2751 / 4900) loss: 0.875668\n","(Iteration 2761 / 4900) loss: 0.927622\n","(Iteration 2771 / 4900) loss: 0.864581\n","(Iteration 2781 / 4900) loss: 0.965746\n","(Iteration 2791 / 4900) loss: 1.031537\n","(Iteration 2801 / 4900) loss: 0.732016\n","(Iteration 2811 / 4900) loss: 1.155832\n","(Iteration 2821 / 4900) loss: 1.132854\n","(Iteration 2831 / 4900) loss: 0.956204\n","(Iteration 2841 / 4900) loss: 1.103496\n","(Iteration 2851 / 4900) loss: 1.042658\n","(Iteration 2861 / 4900) loss: 1.136061\n","(Iteration 2871 / 4900) loss: 0.907905\n","(Iteration 2881 / 4900) loss: 0.773573\n","(Iteration 2891 / 4900) loss: 1.119089\n","(Iteration 2901 / 4900) loss: 1.044611\n","(Iteration 2911 / 4900) loss: 0.715267\n","(Iteration 2921 / 4900) loss: 0.916792\n","(Iteration 2931 / 4900) loss: 1.012200\n","(Epoch 6 / 10) train acc: 0.639000; val_acc: 0.522000\n","(Iteration 2941 / 4900) loss: 0.917569\n","(Iteration 2951 / 4900) loss: 0.891340\n","(Iteration 2961 / 4900) loss: 1.060697\n","(Iteration 2971 / 4900) loss: 1.092290\n","(Iteration 2981 / 4900) loss: 1.049988\n","(Iteration 2991 / 4900) loss: 1.058049\n","(Iteration 3001 / 4900) loss: 0.963408\n","(Iteration 3011 / 4900) loss: 1.216737\n","(Iteration 3021 / 4900) loss: 1.156673\n","(Iteration 3031 / 4900) loss: 0.876605\n","(Iteration 3041 / 4900) loss: 0.899346\n","(Iteration 3051 / 4900) loss: 0.824469\n","(Iteration 3061 / 4900) loss: 1.173923\n","(Iteration 3071 / 4900) loss: 0.976859\n","(Iteration 3081 / 4900) loss: 0.976811\n","(Iteration 3091 / 4900) loss: 0.991527\n","(Iteration 3101 / 4900) loss: 1.119820\n","(Iteration 3111 / 4900) loss: 0.890316\n","(Iteration 3121 / 4900) loss: 0.888382\n","(Iteration 3131 / 4900) loss: 0.697615\n","(Iteration 3141 / 4900) loss: 0.906729\n","(Iteration 3151 / 4900) loss: 1.064112\n","(Iteration 3161 / 4900) loss: 1.105749\n","(Iteration 3171 / 4900) loss: 1.108607\n","(Iteration 3181 / 4900) loss: 0.943678\n","(Iteration 3191 / 4900) loss: 1.003642\n","(Iteration 3201 / 4900) loss: 1.256259\n","(Iteration 3211 / 4900) loss: 0.849218\n","(Iteration 3221 / 4900) loss: 0.914537\n","(Iteration 3231 / 4900) loss: 0.935348\n","(Iteration 3241 / 4900) loss: 0.967213\n","(Iteration 3251 / 4900) loss: 0.782679\n","(Iteration 3261 / 4900) loss: 0.756207\n","(Iteration 3271 / 4900) loss: 0.618564\n","(Iteration 3281 / 4900) loss: 0.857322\n","(Iteration 3291 / 4900) loss: 0.951112\n","(Iteration 3301 / 4900) loss: 0.763832\n","(Iteration 3311 / 4900) loss: 1.104251\n","(Iteration 3321 / 4900) loss: 1.031168\n","(Iteration 3331 / 4900) loss: 1.128973\n","(Iteration 3341 / 4900) loss: 1.122241\n","(Iteration 3351 / 4900) loss: 0.952484\n","(Iteration 3361 / 4900) loss: 1.163855\n","(Iteration 3371 / 4900) loss: 0.798122\n","(Iteration 3381 / 4900) loss: 0.874355\n","(Iteration 3391 / 4900) loss: 0.742865\n","(Iteration 3401 / 4900) loss: 0.918444\n","(Iteration 3411 / 4900) loss: 0.791446\n","(Iteration 3421 / 4900) loss: 0.926680\n","(Epoch 7 / 10) train acc: 0.712000; val_acc: 0.526000\n","(Iteration 3431 / 4900) loss: 0.895313\n","(Iteration 3441 / 4900) loss: 0.822349\n","(Iteration 3451 / 4900) loss: 0.819351\n","(Iteration 3461 / 4900) loss: 0.736775\n","(Iteration 3471 / 4900) loss: 0.816518\n","(Iteration 3481 / 4900) loss: 0.809898\n","(Iteration 3491 / 4900) loss: 1.015516\n","(Iteration 3501 / 4900) loss: 1.018277\n","(Iteration 3511 / 4900) loss: 1.066395\n","(Iteration 3521 / 4900) loss: 0.885929\n","(Iteration 3531 / 4900) loss: 0.730741\n","(Iteration 3541 / 4900) loss: 1.137505\n","(Iteration 3551 / 4900) loss: 0.753341\n","(Iteration 3561 / 4900) loss: 1.030433\n","(Iteration 3571 / 4900) loss: 0.823987\n","(Iteration 3581 / 4900) loss: 0.940378\n","(Iteration 3591 / 4900) loss: 0.919344\n","(Iteration 3601 / 4900) loss: 0.946661\n","(Iteration 3611 / 4900) loss: 0.648967\n","(Iteration 3621 / 4900) loss: 0.931939\n","(Iteration 3631 / 4900) loss: 0.784053\n","(Iteration 3641 / 4900) loss: 1.036795\n","(Iteration 3651 / 4900) loss: 0.681043\n","(Iteration 3661 / 4900) loss: 1.032989\n","(Iteration 3671 / 4900) loss: 0.941528\n","(Iteration 3681 / 4900) loss: 0.931596\n","(Iteration 3691 / 4900) loss: 1.053654\n","(Iteration 3701 / 4900) loss: 1.031469\n","(Iteration 3711 / 4900) loss: 0.934377\n","(Iteration 3721 / 4900) loss: 0.982152\n","(Iteration 3731 / 4900) loss: 1.150258\n","(Iteration 3741 / 4900) loss: 0.890487\n","(Iteration 3751 / 4900) loss: 0.844668\n","(Iteration 3761 / 4900) loss: 1.081385\n","(Iteration 3771 / 4900) loss: 0.961138\n","(Iteration 3781 / 4900) loss: 1.036126\n","(Iteration 3791 / 4900) loss: 1.018571\n","(Iteration 3801 / 4900) loss: 0.954031\n","(Iteration 3811 / 4900) loss: 0.825023\n","(Iteration 3821 / 4900) loss: 1.121011\n","(Iteration 3831 / 4900) loss: 0.914667\n","(Iteration 3841 / 4900) loss: 0.840010\n","(Iteration 3851 / 4900) loss: 0.976364\n","(Iteration 3861 / 4900) loss: 0.794117\n","(Iteration 3871 / 4900) loss: 1.026947\n","(Iteration 3881 / 4900) loss: 0.905018\n","(Iteration 3891 / 4900) loss: 0.950499\n","(Iteration 3901 / 4900) loss: 0.886166\n","(Iteration 3911 / 4900) loss: 0.994792\n","(Epoch 8 / 10) train acc: 0.693000; val_acc: 0.538000\n","(Iteration 3921 / 4900) loss: 0.746101\n","(Iteration 3931 / 4900) loss: 1.013182\n","(Iteration 3941 / 4900) loss: 0.789923\n","(Iteration 3951 / 4900) loss: 1.048691\n","(Iteration 3961 / 4900) loss: 0.879224\n","(Iteration 3971 / 4900) loss: 0.855186\n","(Iteration 3981 / 4900) loss: 1.285470\n","(Iteration 3991 / 4900) loss: 0.952000\n","(Iteration 4001 / 4900) loss: 0.884748\n","(Iteration 4011 / 4900) loss: 0.947476\n","(Iteration 4021 / 4900) loss: 0.870992\n","(Iteration 4031 / 4900) loss: 1.060777\n","(Iteration 4041 / 4900) loss: 0.863926\n","(Iteration 4051 / 4900) loss: 1.015267\n","(Iteration 4061 / 4900) loss: 0.876200\n","(Iteration 4071 / 4900) loss: 0.702586\n","(Iteration 4081 / 4900) loss: 0.746602\n","(Iteration 4091 / 4900) loss: 1.173981\n","(Iteration 4101 / 4900) loss: 0.943106\n","(Iteration 4111 / 4900) loss: 0.886808\n","(Iteration 4121 / 4900) loss: 0.998882\n","(Iteration 4131 / 4900) loss: 0.841193\n","(Iteration 4141 / 4900) loss: 0.951016\n","(Iteration 4151 / 4900) loss: 0.997827\n","(Iteration 4161 / 4900) loss: 0.962904\n","(Iteration 4171 / 4900) loss: 0.794479\n","(Iteration 4181 / 4900) loss: 0.902236\n","(Iteration 4191 / 4900) loss: 0.654472\n","(Iteration 4201 / 4900) loss: 0.901940\n","(Iteration 4211 / 4900) loss: 0.708827\n","(Iteration 4221 / 4900) loss: 1.149094\n","(Iteration 4231 / 4900) loss: 1.066848\n","(Iteration 4241 / 4900) loss: 0.916728\n","(Iteration 4251 / 4900) loss: 0.835052\n","(Iteration 4261 / 4900) loss: 0.929290\n","(Iteration 4271 / 4900) loss: 1.017437\n","(Iteration 4281 / 4900) loss: 0.738082\n","(Iteration 4291 / 4900) loss: 0.823893\n","(Iteration 4301 / 4900) loss: 0.953647\n","(Iteration 4311 / 4900) loss: 0.699787\n","(Iteration 4321 / 4900) loss: 1.121854\n","(Iteration 4331 / 4900) loss: 0.857438\n","(Iteration 4341 / 4900) loss: 0.740187\n","(Iteration 4351 / 4900) loss: 0.865823\n","(Iteration 4361 / 4900) loss: 0.804682\n","(Iteration 4371 / 4900) loss: 1.029210\n","(Iteration 4381 / 4900) loss: 0.980284\n","(Iteration 4391 / 4900) loss: 0.836619\n","(Iteration 4401 / 4900) loss: 0.986283\n","(Epoch 9 / 10) train acc: 0.708000; val_acc: 0.547000\n","(Iteration 4411 / 4900) loss: 0.882519\n","(Iteration 4421 / 4900) loss: 0.680537\n","(Iteration 4431 / 4900) loss: 0.690506\n","(Iteration 4441 / 4900) loss: 0.848563\n","(Iteration 4451 / 4900) loss: 1.036122\n","(Iteration 4461 / 4900) loss: 0.817469\n","(Iteration 4471 / 4900) loss: 0.625925\n","(Iteration 4481 / 4900) loss: 0.833043\n","(Iteration 4491 / 4900) loss: 0.858426\n","(Iteration 4501 / 4900) loss: 0.734311\n","(Iteration 4511 / 4900) loss: 0.805000\n","(Iteration 4521 / 4900) loss: 0.929633\n","(Iteration 4531 / 4900) loss: 0.984067\n","(Iteration 4541 / 4900) loss: 0.731274\n","(Iteration 4551 / 4900) loss: 0.932562\n","(Iteration 4561 / 4900) loss: 0.744153\n","(Iteration 4571 / 4900) loss: 0.802316\n","(Iteration 4581 / 4900) loss: 0.889549\n","(Iteration 4591 / 4900) loss: 1.267504\n","(Iteration 4601 / 4900) loss: 0.808016\n","(Iteration 4611 / 4900) loss: 0.771720\n","(Iteration 4621 / 4900) loss: 1.129913\n","(Iteration 4631 / 4900) loss: 0.911956\n","(Iteration 4641 / 4900) loss: 0.799881\n","(Iteration 4651 / 4900) loss: 0.681432\n","(Iteration 4661 / 4900) loss: 0.648820\n","(Iteration 4671 / 4900) loss: 0.698225\n","(Iteration 4681 / 4900) loss: 0.845406\n","(Iteration 4691 / 4900) loss: 1.140916\n","(Iteration 4701 / 4900) loss: 0.866472\n","(Iteration 4711 / 4900) loss: 0.808014\n","(Iteration 4721 / 4900) loss: 0.735965\n","(Iteration 4731 / 4900) loss: 0.724254\n","(Iteration 4741 / 4900) loss: 0.843081\n","(Iteration 4751 / 4900) loss: 0.887087\n","(Iteration 4761 / 4900) loss: 0.960352\n","(Iteration 4771 / 4900) loss: 0.514167\n","(Iteration 4781 / 4900) loss: 0.987318\n","(Iteration 4791 / 4900) loss: 0.749965\n","(Iteration 4801 / 4900) loss: 0.891840\n","(Iteration 4811 / 4900) loss: 0.663075\n","(Iteration 4821 / 4900) loss: 0.658740\n","(Iteration 4831 / 4900) loss: 0.880376\n","(Iteration 4841 / 4900) loss: 0.840507\n","(Iteration 4851 / 4900) loss: 0.997043\n","(Iteration 4861 / 4900) loss: 0.716827\n","(Iteration 4871 / 4900) loss: 0.992872\n","(Iteration 4881 / 4900) loss: 0.699229\n","(Iteration 4891 / 4900) loss: 0.723010\n","(Epoch 10 / 10) train acc: 0.730000; val_acc: 0.526000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.094000; val_acc: 0.112000\n","(Iteration 11 / 4900) loss: 2.305279\n","(Iteration 21 / 4900) loss: 2.301828\n","(Iteration 31 / 4900) loss: 2.303521\n","(Iteration 41 / 4900) loss: 2.307218\n","(Iteration 51 / 4900) loss: 2.298963\n","(Iteration 61 / 4900) loss: 2.308866\n","(Iteration 71 / 4900) loss: 2.286008\n","(Iteration 81 / 4900) loss: 2.200803\n","(Iteration 91 / 4900) loss: 2.091048\n","(Iteration 101 / 4900) loss: 2.135508\n","(Iteration 111 / 4900) loss: 1.980802\n","(Iteration 121 / 4900) loss: 1.883707\n","(Iteration 131 / 4900) loss: 1.797826\n","(Iteration 141 / 4900) loss: 1.743345\n","(Iteration 151 / 4900) loss: 1.764261\n","(Iteration 161 / 4900) loss: 1.696674\n","(Iteration 171 / 4900) loss: 1.792117\n","(Iteration 181 / 4900) loss: 1.650672\n","(Iteration 191 / 4900) loss: 1.407576\n","(Iteration 201 / 4900) loss: 1.518287\n","(Iteration 211 / 4900) loss: 1.388849\n","(Iteration 221 / 4900) loss: 1.523201\n","(Iteration 231 / 4900) loss: 1.409556\n","(Iteration 241 / 4900) loss: 1.439203\n","(Iteration 251 / 4900) loss: 1.523349\n","(Iteration 261 / 4900) loss: 1.221682\n","(Iteration 271 / 4900) loss: 1.405804\n","(Iteration 281 / 4900) loss: 1.585436\n","(Iteration 291 / 4900) loss: 1.404444\n","(Iteration 301 / 4900) loss: 1.419519\n","(Iteration 311 / 4900) loss: 1.417306\n","(Iteration 321 / 4900) loss: 1.525848\n","(Iteration 331 / 4900) loss: 1.500036\n","(Iteration 341 / 4900) loss: 1.285267\n","(Iteration 351 / 4900) loss: 1.272087\n","(Iteration 361 / 4900) loss: 1.308076\n","(Iteration 371 / 4900) loss: 1.507664\n","(Iteration 381 / 4900) loss: 1.515338\n","(Iteration 391 / 4900) loss: 1.426250\n","(Iteration 401 / 4900) loss: 1.588085\n","(Iteration 411 / 4900) loss: 1.361604\n","(Iteration 421 / 4900) loss: 1.431501\n","(Iteration 431 / 4900) loss: 1.546468\n","(Iteration 441 / 4900) loss: 1.372618\n","(Iteration 451 / 4900) loss: 1.333340\n","(Iteration 461 / 4900) loss: 1.345947\n","(Iteration 471 / 4900) loss: 1.374839\n","(Iteration 481 / 4900) loss: 1.194517\n","(Epoch 1 / 10) train acc: 0.523000; val_acc: 0.505000\n","(Iteration 491 / 4900) loss: 1.023751\n","(Iteration 501 / 4900) loss: 1.468863\n","(Iteration 511 / 4900) loss: 1.460995\n","(Iteration 521 / 4900) loss: 1.166510\n","(Iteration 531 / 4900) loss: 1.621714\n","(Iteration 541 / 4900) loss: 1.418425\n","(Iteration 551 / 4900) loss: 1.213319\n","(Iteration 561 / 4900) loss: 1.228628\n","(Iteration 571 / 4900) loss: 1.253683\n","(Iteration 581 / 4900) loss: 1.249900\n","(Iteration 591 / 4900) loss: 1.233644\n","(Iteration 601 / 4900) loss: 1.242297\n","(Iteration 611 / 4900) loss: 1.100339\n","(Iteration 621 / 4900) loss: 1.144283\n","(Iteration 631 / 4900) loss: 1.332869\n","(Iteration 641 / 4900) loss: 1.165578\n","(Iteration 651 / 4900) loss: 1.486943\n","(Iteration 661 / 4900) loss: 1.378952\n","(Iteration 671 / 4900) loss: 1.322269\n","(Iteration 681 / 4900) loss: 1.197115\n","(Iteration 691 / 4900) loss: 1.190702\n","(Iteration 701 / 4900) loss: 1.555723\n","(Iteration 711 / 4900) loss: 1.266349\n","(Iteration 721 / 4900) loss: 1.092999\n","(Iteration 731 / 4900) loss: 1.180565\n","(Iteration 741 / 4900) loss: 1.328560\n","(Iteration 751 / 4900) loss: 1.364291\n","(Iteration 761 / 4900) loss: 1.039426\n","(Iteration 771 / 4900) loss: 1.207458\n","(Iteration 781 / 4900) loss: 1.436638\n","(Iteration 791 / 4900) loss: 1.254154\n","(Iteration 801 / 4900) loss: 1.330269\n","(Iteration 811 / 4900) loss: 1.354046\n","(Iteration 821 / 4900) loss: 1.172465\n","(Iteration 831 / 4900) loss: 1.260853\n","(Iteration 841 / 4900) loss: 1.232614\n","(Iteration 851 / 4900) loss: 1.179037\n","(Iteration 861 / 4900) loss: 1.367085\n","(Iteration 871 / 4900) loss: 1.281560\n","(Iteration 881 / 4900) loss: 1.332855\n","(Iteration 891 / 4900) loss: 1.098073\n","(Iteration 901 / 4900) loss: 1.253627\n","(Iteration 911 / 4900) loss: 1.319758\n","(Iteration 921 / 4900) loss: 1.308614\n","(Iteration 931 / 4900) loss: 1.214938\n","(Iteration 941 / 4900) loss: 1.112155\n","(Iteration 951 / 4900) loss: 1.121489\n","(Iteration 961 / 4900) loss: 1.400147\n","(Iteration 971 / 4900) loss: 1.182873\n","(Epoch 2 / 10) train acc: 0.567000; val_acc: 0.530000\n","(Iteration 981 / 4900) loss: 1.175704\n","(Iteration 991 / 4900) loss: 1.473634\n","(Iteration 1001 / 4900) loss: 1.247717\n","(Iteration 1011 / 4900) loss: 1.202832\n","(Iteration 1021 / 4900) loss: 1.170307\n","(Iteration 1031 / 4900) loss: 1.236380\n","(Iteration 1041 / 4900) loss: 1.162896\n","(Iteration 1051 / 4900) loss: 1.258877\n","(Iteration 1061 / 4900) loss: 1.092297\n","(Iteration 1071 / 4900) loss: 1.032369\n","(Iteration 1081 / 4900) loss: 1.400553\n","(Iteration 1091 / 4900) loss: 1.106095\n","(Iteration 1101 / 4900) loss: 1.107456\n","(Iteration 1111 / 4900) loss: 1.176532\n","(Iteration 1121 / 4900) loss: 1.231020\n","(Iteration 1131 / 4900) loss: 1.175721\n","(Iteration 1141 / 4900) loss: 1.160322\n","(Iteration 1151 / 4900) loss: 1.031520\n","(Iteration 1161 / 4900) loss: 1.049610\n","(Iteration 1171 / 4900) loss: 1.391531\n","(Iteration 1181 / 4900) loss: 1.291877\n","(Iteration 1191 / 4900) loss: 1.121194\n","(Iteration 1201 / 4900) loss: 1.212959\n","(Iteration 1211 / 4900) loss: 1.089561\n","(Iteration 1221 / 4900) loss: 1.289014\n","(Iteration 1231 / 4900) loss: 1.118533\n","(Iteration 1241 / 4900) loss: 1.309139\n","(Iteration 1251 / 4900) loss: 1.236006\n","(Iteration 1261 / 4900) loss: 1.070033\n","(Iteration 1271 / 4900) loss: 0.984761\n","(Iteration 1281 / 4900) loss: 1.076801\n","(Iteration 1291 / 4900) loss: 1.105119\n","(Iteration 1301 / 4900) loss: 1.089580\n","(Iteration 1311 / 4900) loss: 1.199835\n","(Iteration 1321 / 4900) loss: 1.132360\n","(Iteration 1331 / 4900) loss: 1.208142\n","(Iteration 1341 / 4900) loss: 1.132734\n","(Iteration 1351 / 4900) loss: 1.188951\n","(Iteration 1361 / 4900) loss: 1.157172\n","(Iteration 1371 / 4900) loss: 1.116271\n","(Iteration 1381 / 4900) loss: 1.400681\n","(Iteration 1391 / 4900) loss: 1.096213\n","(Iteration 1401 / 4900) loss: 1.042115\n","(Iteration 1411 / 4900) loss: 0.999128\n","(Iteration 1421 / 4900) loss: 1.097801\n","(Iteration 1431 / 4900) loss: 1.066217\n","(Iteration 1441 / 4900) loss: 1.015141\n","(Iteration 1451 / 4900) loss: 1.235202\n","(Iteration 1461 / 4900) loss: 1.207239\n","(Epoch 3 / 10) train acc: 0.573000; val_acc: 0.521000\n","(Iteration 1471 / 4900) loss: 1.078808\n","(Iteration 1481 / 4900) loss: 1.072138\n","(Iteration 1491 / 4900) loss: 1.213490\n","(Iteration 1501 / 4900) loss: 1.290786\n","(Iteration 1511 / 4900) loss: 1.147628\n","(Iteration 1521 / 4900) loss: 0.976017\n","(Iteration 1531 / 4900) loss: 1.138984\n","(Iteration 1541 / 4900) loss: 1.201846\n","(Iteration 1551 / 4900) loss: 0.962718\n","(Iteration 1561 / 4900) loss: 1.212232\n","(Iteration 1571 / 4900) loss: 1.067871\n","(Iteration 1581 / 4900) loss: 1.185459\n","(Iteration 1591 / 4900) loss: 1.057740\n","(Iteration 1601 / 4900) loss: 1.133664\n","(Iteration 1611 / 4900) loss: 1.060539\n","(Iteration 1621 / 4900) loss: 1.156039\n","(Iteration 1631 / 4900) loss: 1.040424\n","(Iteration 1641 / 4900) loss: 1.281096\n","(Iteration 1651 / 4900) loss: 1.017889\n","(Iteration 1661 / 4900) loss: 1.101615\n","(Iteration 1671 / 4900) loss: 1.136582\n","(Iteration 1681 / 4900) loss: 1.167911\n","(Iteration 1691 / 4900) loss: 0.996256\n","(Iteration 1701 / 4900) loss: 0.940966\n","(Iteration 1711 / 4900) loss: 1.166673\n","(Iteration 1721 / 4900) loss: 1.268368\n","(Iteration 1731 / 4900) loss: 1.117253\n","(Iteration 1741 / 4900) loss: 1.083992\n","(Iteration 1751 / 4900) loss: 0.969877\n","(Iteration 1761 / 4900) loss: 1.052232\n","(Iteration 1771 / 4900) loss: 1.321649\n","(Iteration 1781 / 4900) loss: 1.143266\n","(Iteration 1791 / 4900) loss: 1.020670\n","(Iteration 1801 / 4900) loss: 1.046839\n","(Iteration 1811 / 4900) loss: 1.225035\n","(Iteration 1821 / 4900) loss: 1.103872\n","(Iteration 1831 / 4900) loss: 0.886709\n","(Iteration 1841 / 4900) loss: 1.036422\n","(Iteration 1851 / 4900) loss: 1.037279\n","(Iteration 1861 / 4900) loss: 1.291265\n","(Iteration 1871 / 4900) loss: 1.153443\n","(Iteration 1881 / 4900) loss: 1.263213\n","(Iteration 1891 / 4900) loss: 1.060814\n","(Iteration 1901 / 4900) loss: 1.015122\n","(Iteration 1911 / 4900) loss: 1.164224\n","(Iteration 1921 / 4900) loss: 0.973107\n","(Iteration 1931 / 4900) loss: 1.147544\n","(Iteration 1941 / 4900) loss: 0.976252\n","(Iteration 1951 / 4900) loss: 1.076629\n","(Epoch 4 / 10) train acc: 0.615000; val_acc: 0.560000\n","(Iteration 1961 / 4900) loss: 1.181414\n","(Iteration 1971 / 4900) loss: 1.003647\n","(Iteration 1981 / 4900) loss: 1.234311\n","(Iteration 1991 / 4900) loss: 0.969181\n","(Iteration 2001 / 4900) loss: 1.154369\n","(Iteration 2011 / 4900) loss: 1.058336\n","(Iteration 2021 / 4900) loss: 1.228997\n","(Iteration 2031 / 4900) loss: 1.143749\n","(Iteration 2041 / 4900) loss: 1.412836\n","(Iteration 2051 / 4900) loss: 1.115956\n","(Iteration 2061 / 4900) loss: 1.064007\n","(Iteration 2071 / 4900) loss: 1.133686\n","(Iteration 2081 / 4900) loss: 0.905012\n","(Iteration 2091 / 4900) loss: 1.043589\n","(Iteration 2101 / 4900) loss: 1.010649\n","(Iteration 2111 / 4900) loss: 1.185505\n","(Iteration 2121 / 4900) loss: 1.166959\n","(Iteration 2131 / 4900) loss: 1.045203\n","(Iteration 2141 / 4900) loss: 1.025020\n","(Iteration 2151 / 4900) loss: 1.012872\n","(Iteration 2161 / 4900) loss: 0.931660\n","(Iteration 2171 / 4900) loss: 1.171165\n","(Iteration 2181 / 4900) loss: 1.014905\n","(Iteration 2191 / 4900) loss: 1.100854\n","(Iteration 2201 / 4900) loss: 1.051557\n","(Iteration 2211 / 4900) loss: 0.974288\n","(Iteration 2221 / 4900) loss: 1.302396\n","(Iteration 2231 / 4900) loss: 0.948534\n","(Iteration 2241 / 4900) loss: 1.094905\n","(Iteration 2251 / 4900) loss: 0.932100\n","(Iteration 2261 / 4900) loss: 0.907209\n","(Iteration 2271 / 4900) loss: 1.029280\n","(Iteration 2281 / 4900) loss: 1.388362\n","(Iteration 2291 / 4900) loss: 1.093372\n","(Iteration 2301 / 4900) loss: 1.001116\n","(Iteration 2311 / 4900) loss: 1.031920\n","(Iteration 2321 / 4900) loss: 0.933352\n","(Iteration 2331 / 4900) loss: 1.031943\n","(Iteration 2341 / 4900) loss: 1.040263\n","(Iteration 2351 / 4900) loss: 1.061941\n","(Iteration 2361 / 4900) loss: 0.894666\n","(Iteration 2371 / 4900) loss: 1.233064\n","(Iteration 2381 / 4900) loss: 0.939550\n","(Iteration 2391 / 4900) loss: 1.084902\n","(Iteration 2401 / 4900) loss: 1.086867\n","(Iteration 2411 / 4900) loss: 1.087595\n","(Iteration 2421 / 4900) loss: 1.056809\n","(Iteration 2431 / 4900) loss: 0.916005\n","(Iteration 2441 / 4900) loss: 1.036539\n","(Epoch 5 / 10) train acc: 0.645000; val_acc: 0.562000\n","(Iteration 2451 / 4900) loss: 1.054705\n","(Iteration 2461 / 4900) loss: 1.211012\n","(Iteration 2471 / 4900) loss: 1.263686\n","(Iteration 2481 / 4900) loss: 1.196520\n","(Iteration 2491 / 4900) loss: 0.919487\n","(Iteration 2501 / 4900) loss: 0.852330\n","(Iteration 2511 / 4900) loss: 1.081920\n","(Iteration 2521 / 4900) loss: 1.107256\n","(Iteration 2531 / 4900) loss: 1.075858\n","(Iteration 2541 / 4900) loss: 0.969803\n","(Iteration 2551 / 4900) loss: 1.042565\n","(Iteration 2561 / 4900) loss: 1.016880\n","(Iteration 2571 / 4900) loss: 0.817684\n","(Iteration 2581 / 4900) loss: 1.017621\n","(Iteration 2591 / 4900) loss: 0.913496\n","(Iteration 2601 / 4900) loss: 0.980631\n","(Iteration 2611 / 4900) loss: 1.089707\n","(Iteration 2621 / 4900) loss: 0.868210\n","(Iteration 2631 / 4900) loss: 0.893552\n","(Iteration 2641 / 4900) loss: 0.960720\n","(Iteration 2651 / 4900) loss: 1.027944\n","(Iteration 2661 / 4900) loss: 1.026444\n","(Iteration 2671 / 4900) loss: 1.101042\n","(Iteration 2681 / 4900) loss: 1.063307\n","(Iteration 2691 / 4900) loss: 1.150494\n","(Iteration 2701 / 4900) loss: 1.046323\n","(Iteration 2711 / 4900) loss: 0.869586\n","(Iteration 2721 / 4900) loss: 1.078464\n","(Iteration 2731 / 4900) loss: 1.180681\n","(Iteration 2741 / 4900) loss: 0.745234\n","(Iteration 2751 / 4900) loss: 1.153528\n","(Iteration 2761 / 4900) loss: 0.860702\n","(Iteration 2771 / 4900) loss: 1.233644\n","(Iteration 2781 / 4900) loss: 0.999409\n","(Iteration 2791 / 4900) loss: 1.104349\n","(Iteration 2801 / 4900) loss: 1.022262\n","(Iteration 2811 / 4900) loss: 1.145527\n","(Iteration 2821 / 4900) loss: 0.956381\n","(Iteration 2831 / 4900) loss: 1.006126\n","(Iteration 2841 / 4900) loss: 1.096236\n","(Iteration 2851 / 4900) loss: 1.076276\n","(Iteration 2861 / 4900) loss: 0.939305\n","(Iteration 2871 / 4900) loss: 1.043949\n","(Iteration 2881 / 4900) loss: 1.197787\n","(Iteration 2891 / 4900) loss: 1.053925\n","(Iteration 2901 / 4900) loss: 0.863735\n","(Iteration 2911 / 4900) loss: 0.980136\n","(Iteration 2921 / 4900) loss: 1.125744\n","(Iteration 2931 / 4900) loss: 1.023797\n","(Epoch 6 / 10) train acc: 0.636000; val_acc: 0.556000\n","(Iteration 2941 / 4900) loss: 0.956460\n","(Iteration 2951 / 4900) loss: 0.931479\n","(Iteration 2961 / 4900) loss: 0.964699\n","(Iteration 2971 / 4900) loss: 0.885622\n","(Iteration 2981 / 4900) loss: 1.105364\n","(Iteration 2991 / 4900) loss: 0.843003\n","(Iteration 3001 / 4900) loss: 1.055208\n","(Iteration 3011 / 4900) loss: 0.988707\n","(Iteration 3021 / 4900) loss: 0.981889\n","(Iteration 3031 / 4900) loss: 1.022607\n","(Iteration 3041 / 4900) loss: 1.014017\n","(Iteration 3051 / 4900) loss: 0.931480\n","(Iteration 3061 / 4900) loss: 1.022951\n","(Iteration 3071 / 4900) loss: 0.919172\n","(Iteration 3081 / 4900) loss: 0.898855\n","(Iteration 3091 / 4900) loss: 1.001937\n","(Iteration 3101 / 4900) loss: 0.858469\n","(Iteration 3111 / 4900) loss: 0.885978\n","(Iteration 3121 / 4900) loss: 0.903167\n","(Iteration 3131 / 4900) loss: 1.136745\n","(Iteration 3141 / 4900) loss: 0.989761\n","(Iteration 3151 / 4900) loss: 0.769035\n","(Iteration 3161 / 4900) loss: 0.941826\n","(Iteration 3171 / 4900) loss: 1.171943\n","(Iteration 3181 / 4900) loss: 0.907116\n","(Iteration 3191 / 4900) loss: 1.047591\n","(Iteration 3201 / 4900) loss: 0.953229\n","(Iteration 3211 / 4900) loss: 1.190068\n","(Iteration 3221 / 4900) loss: 0.959532\n","(Iteration 3231 / 4900) loss: 1.028778\n","(Iteration 3241 / 4900) loss: 1.016170\n","(Iteration 3251 / 4900) loss: 0.864117\n","(Iteration 3261 / 4900) loss: 0.979747\n","(Iteration 3271 / 4900) loss: 0.936920\n","(Iteration 3281 / 4900) loss: 0.856960\n","(Iteration 3291 / 4900) loss: 0.979709\n","(Iteration 3301 / 4900) loss: 1.085268\n","(Iteration 3311 / 4900) loss: 0.916902\n","(Iteration 3321 / 4900) loss: 1.240037\n","(Iteration 3331 / 4900) loss: 0.901524\n","(Iteration 3341 / 4900) loss: 1.092232\n","(Iteration 3351 / 4900) loss: 0.629068\n","(Iteration 3361 / 4900) loss: 1.073369\n","(Iteration 3371 / 4900) loss: 0.949733\n","(Iteration 3381 / 4900) loss: 0.960364\n","(Iteration 3391 / 4900) loss: 0.793990\n","(Iteration 3401 / 4900) loss: 1.069504\n","(Iteration 3411 / 4900) loss: 1.116262\n","(Iteration 3421 / 4900) loss: 0.909972\n","(Epoch 7 / 10) train acc: 0.665000; val_acc: 0.571000\n","(Iteration 3431 / 4900) loss: 0.958997\n","(Iteration 3441 / 4900) loss: 0.713795\n","(Iteration 3451 / 4900) loss: 1.061953\n","(Iteration 3461 / 4900) loss: 1.058777\n","(Iteration 3471 / 4900) loss: 0.933725\n","(Iteration 3481 / 4900) loss: 1.066316\n","(Iteration 3491 / 4900) loss: 1.037626\n","(Iteration 3501 / 4900) loss: 1.065195\n","(Iteration 3511 / 4900) loss: 1.015416\n","(Iteration 3521 / 4900) loss: 1.062347\n","(Iteration 3531 / 4900) loss: 0.925394\n","(Iteration 3541 / 4900) loss: 1.083253\n","(Iteration 3551 / 4900) loss: 0.862968\n","(Iteration 3561 / 4900) loss: 0.946615\n","(Iteration 3571 / 4900) loss: 0.983287\n","(Iteration 3581 / 4900) loss: 0.968043\n","(Iteration 3591 / 4900) loss: 0.937052\n","(Iteration 3601 / 4900) loss: 0.843361\n","(Iteration 3611 / 4900) loss: 1.030965\n","(Iteration 3621 / 4900) loss: 1.005790\n","(Iteration 3631 / 4900) loss: 1.176791\n","(Iteration 3641 / 4900) loss: 1.123128\n","(Iteration 3651 / 4900) loss: 1.234191\n","(Iteration 3661 / 4900) loss: 1.188831\n","(Iteration 3671 / 4900) loss: 1.013887\n","(Iteration 3681 / 4900) loss: 1.073547\n","(Iteration 3691 / 4900) loss: 0.919923\n","(Iteration 3701 / 4900) loss: 0.794052\n","(Iteration 3711 / 4900) loss: 1.045170\n","(Iteration 3721 / 4900) loss: 1.026640\n","(Iteration 3731 / 4900) loss: 0.814945\n","(Iteration 3741 / 4900) loss: 0.742627\n","(Iteration 3751 / 4900) loss: 0.786577\n","(Iteration 3761 / 4900) loss: 1.073782\n","(Iteration 3771 / 4900) loss: 1.078360\n","(Iteration 3781 / 4900) loss: 0.867893\n","(Iteration 3791 / 4900) loss: 1.411491\n","(Iteration 3801 / 4900) loss: 0.954490\n","(Iteration 3811 / 4900) loss: 0.842282\n","(Iteration 3821 / 4900) loss: 1.086738\n","(Iteration 3831 / 4900) loss: 1.189797\n","(Iteration 3841 / 4900) loss: 0.833036\n","(Iteration 3851 / 4900) loss: 0.876444\n","(Iteration 3861 / 4900) loss: 1.089947\n","(Iteration 3871 / 4900) loss: 0.848777\n","(Iteration 3881 / 4900) loss: 0.941961\n","(Iteration 3891 / 4900) loss: 1.048935\n","(Iteration 3901 / 4900) loss: 0.944798\n","(Iteration 3911 / 4900) loss: 0.926429\n","(Epoch 8 / 10) train acc: 0.651000; val_acc: 0.559000\n","(Iteration 3921 / 4900) loss: 0.807890\n","(Iteration 3931 / 4900) loss: 1.047315\n","(Iteration 3941 / 4900) loss: 0.912310\n","(Iteration 3951 / 4900) loss: 1.173247\n","(Iteration 3961 / 4900) loss: 0.972197\n","(Iteration 3971 / 4900) loss: 0.752132\n","(Iteration 3981 / 4900) loss: 1.112476\n","(Iteration 3991 / 4900) loss: 0.770532\n","(Iteration 4001 / 4900) loss: 0.828036\n","(Iteration 4011 / 4900) loss: 0.874826\n","(Iteration 4021 / 4900) loss: 0.802277\n","(Iteration 4031 / 4900) loss: 1.059237\n","(Iteration 4041 / 4900) loss: 0.937254\n","(Iteration 4051 / 4900) loss: 0.710863\n","(Iteration 4061 / 4900) loss: 0.883155\n","(Iteration 4071 / 4900) loss: 0.939337\n","(Iteration 4081 / 4900) loss: 1.004819\n","(Iteration 4091 / 4900) loss: 0.985224\n","(Iteration 4101 / 4900) loss: 0.688421\n","(Iteration 4111 / 4900) loss: 1.042228\n","(Iteration 4121 / 4900) loss: 0.804401\n","(Iteration 4131 / 4900) loss: 0.885656\n","(Iteration 4141 / 4900) loss: 0.932673\n","(Iteration 4151 / 4900) loss: 0.950972\n","(Iteration 4161 / 4900) loss: 0.865478\n","(Iteration 4171 / 4900) loss: 0.909303\n","(Iteration 4181 / 4900) loss: 0.980724\n","(Iteration 4191 / 4900) loss: 0.988539\n","(Iteration 4201 / 4900) loss: 1.008329\n","(Iteration 4211 / 4900) loss: 1.029079\n","(Iteration 4221 / 4900) loss: 0.865834\n","(Iteration 4231 / 4900) loss: 0.849305\n","(Iteration 4241 / 4900) loss: 1.176075\n","(Iteration 4251 / 4900) loss: 1.022766\n","(Iteration 4261 / 4900) loss: 1.233849\n","(Iteration 4271 / 4900) loss: 1.105871\n","(Iteration 4281 / 4900) loss: 0.874486\n","(Iteration 4291 / 4900) loss: 0.820882\n","(Iteration 4301 / 4900) loss: 0.971048\n","(Iteration 4311 / 4900) loss: 0.981353\n","(Iteration 4321 / 4900) loss: 0.791827\n","(Iteration 4331 / 4900) loss: 0.695370\n","(Iteration 4341 / 4900) loss: 0.908920\n","(Iteration 4351 / 4900) loss: 1.114303\n","(Iteration 4361 / 4900) loss: 0.848851\n","(Iteration 4371 / 4900) loss: 0.894865\n","(Iteration 4381 / 4900) loss: 0.966461\n","(Iteration 4391 / 4900) loss: 0.950410\n","(Iteration 4401 / 4900) loss: 0.851649\n","(Epoch 9 / 10) train acc: 0.704000; val_acc: 0.540000\n","(Iteration 4411 / 4900) loss: 0.782361\n","(Iteration 4421 / 4900) loss: 0.912247\n","(Iteration 4431 / 4900) loss: 1.022086\n","(Iteration 4441 / 4900) loss: 0.815467\n","(Iteration 4451 / 4900) loss: 0.806075\n","(Iteration 4461 / 4900) loss: 0.966748\n","(Iteration 4471 / 4900) loss: 1.106112\n","(Iteration 4481 / 4900) loss: 0.972648\n","(Iteration 4491 / 4900) loss: 1.125062\n","(Iteration 4501 / 4900) loss: 0.970504\n","(Iteration 4511 / 4900) loss: 1.028627\n","(Iteration 4521 / 4900) loss: 1.010507\n","(Iteration 4531 / 4900) loss: 0.925094\n","(Iteration 4541 / 4900) loss: 0.805238\n","(Iteration 4551 / 4900) loss: 0.632707\n","(Iteration 4561 / 4900) loss: 1.063581\n","(Iteration 4571 / 4900) loss: 0.898918\n","(Iteration 4581 / 4900) loss: 0.867468\n","(Iteration 4591 / 4900) loss: 0.912402\n","(Iteration 4601 / 4900) loss: 0.969573\n","(Iteration 4611 / 4900) loss: 0.841189\n","(Iteration 4621 / 4900) loss: 1.085304\n","(Iteration 4631 / 4900) loss: 0.876290\n","(Iteration 4641 / 4900) loss: 0.951973\n","(Iteration 4651 / 4900) loss: 0.975085\n","(Iteration 4661 / 4900) loss: 0.862876\n","(Iteration 4671 / 4900) loss: 0.799746\n","(Iteration 4681 / 4900) loss: 1.223950\n","(Iteration 4691 / 4900) loss: 0.723270\n","(Iteration 4701 / 4900) loss: 0.991468\n","(Iteration 4711 / 4900) loss: 0.841665\n","(Iteration 4721 / 4900) loss: 1.050787\n","(Iteration 4731 / 4900) loss: 0.662634\n","(Iteration 4741 / 4900) loss: 0.957573\n","(Iteration 4751 / 4900) loss: 1.061075\n","(Iteration 4761 / 4900) loss: 0.702869\n","(Iteration 4771 / 4900) loss: 0.920712\n","(Iteration 4781 / 4900) loss: 0.935755\n","(Iteration 4791 / 4900) loss: 0.754361\n","(Iteration 4801 / 4900) loss: 0.836141\n","(Iteration 4811 / 4900) loss: 0.803388\n","(Iteration 4821 / 4900) loss: 0.933243\n","(Iteration 4831 / 4900) loss: 0.973911\n","(Iteration 4841 / 4900) loss: 0.932220\n","(Iteration 4851 / 4900) loss: 0.942884\n","(Iteration 4861 / 4900) loss: 0.845868\n","(Iteration 4871 / 4900) loss: 0.806396\n","(Iteration 4881 / 4900) loss: 1.014006\n","(Iteration 4891 / 4900) loss: 0.982018\n","(Epoch 10 / 10) train acc: 0.668000; val_acc: 0.548000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.117000; val_acc: 0.119000\n","(Iteration 11 / 4900) loss: 2.303350\n","(Iteration 21 / 4900) loss: 2.301794\n","(Iteration 31 / 4900) loss: 2.299841\n","(Iteration 41 / 4900) loss: 2.301033\n","(Iteration 51 / 4900) loss: 2.304533\n","(Iteration 61 / 4900) loss: 2.302718\n","(Iteration 71 / 4900) loss: 2.303634\n","(Iteration 81 / 4900) loss: 2.303505\n","(Iteration 91 / 4900) loss: 2.304444\n","(Iteration 101 / 4900) loss: 2.303216\n","(Iteration 111 / 4900) loss: 2.304571\n","(Iteration 121 / 4900) loss: 2.306102\n","(Iteration 131 / 4900) loss: 2.307501\n","(Iteration 141 / 4900) loss: 2.303411\n","(Iteration 151 / 4900) loss: 2.302110\n","(Iteration 161 / 4900) loss: 2.291310\n","(Iteration 171 / 4900) loss: 2.290893\n","(Iteration 181 / 4900) loss: 2.244971\n","(Iteration 191 / 4900) loss: 2.168513\n","(Iteration 201 / 4900) loss: 2.097011\n","(Iteration 211 / 4900) loss: 2.116751\n","(Iteration 221 / 4900) loss: 2.061399\n","(Iteration 231 / 4900) loss: 2.035277\n","(Iteration 241 / 4900) loss: 2.130765\n","(Iteration 251 / 4900) loss: 1.939776\n","(Iteration 261 / 4900) loss: 1.773196\n","(Iteration 271 / 4900) loss: 1.944425\n","(Iteration 281 / 4900) loss: 1.808360\n","(Iteration 291 / 4900) loss: 1.709770\n","(Iteration 301 / 4900) loss: 1.835045\n","(Iteration 311 / 4900) loss: 1.663310\n","(Iteration 321 / 4900) loss: 1.756091\n","(Iteration 331 / 4900) loss: 1.755788\n","(Iteration 341 / 4900) loss: 1.742083\n","(Iteration 351 / 4900) loss: 1.585970\n","(Iteration 361 / 4900) loss: 1.502021\n","(Iteration 371 / 4900) loss: 1.658227\n","(Iteration 381 / 4900) loss: 1.843116\n","(Iteration 391 / 4900) loss: 1.503558\n","(Iteration 401 / 4900) loss: 1.538873\n","(Iteration 411 / 4900) loss: 1.381680\n","(Iteration 421 / 4900) loss: 1.419786\n","(Iteration 431 / 4900) loss: 1.396959\n","(Iteration 441 / 4900) loss: 1.392147\n","(Iteration 451 / 4900) loss: 1.640672\n","(Iteration 461 / 4900) loss: 1.501494\n","(Iteration 471 / 4900) loss: 1.394389\n","(Iteration 481 / 4900) loss: 1.533868\n","(Epoch 1 / 10) train acc: 0.452000; val_acc: 0.461000\n","(Iteration 491 / 4900) loss: 1.554717\n","(Iteration 501 / 4900) loss: 1.421857\n","(Iteration 511 / 4900) loss: 1.454767\n","(Iteration 521 / 4900) loss: 1.392263\n","(Iteration 531 / 4900) loss: 1.514002\n","(Iteration 541 / 4900) loss: 1.494018\n","(Iteration 551 / 4900) loss: 1.418137\n","(Iteration 561 / 4900) loss: 1.549903\n","(Iteration 571 / 4900) loss: 1.437324\n","(Iteration 581 / 4900) loss: 1.391822\n","(Iteration 591 / 4900) loss: 1.378142\n","(Iteration 601 / 4900) loss: 1.411312\n","(Iteration 611 / 4900) loss: 1.630015\n","(Iteration 621 / 4900) loss: 1.433998\n","(Iteration 631 / 4900) loss: 1.391024\n","(Iteration 641 / 4900) loss: 1.334268\n","(Iteration 651 / 4900) loss: 1.442965\n","(Iteration 661 / 4900) loss: 1.233370\n","(Iteration 671 / 4900) loss: 1.460190\n","(Iteration 681 / 4900) loss: 1.267842\n","(Iteration 691 / 4900) loss: 1.327613\n","(Iteration 701 / 4900) loss: 1.266923\n","(Iteration 711 / 4900) loss: 1.305680\n","(Iteration 721 / 4900) loss: 1.360747\n","(Iteration 731 / 4900) loss: 1.423365\n","(Iteration 741 / 4900) loss: 1.462670\n","(Iteration 751 / 4900) loss: 1.491187\n","(Iteration 761 / 4900) loss: 1.343994\n","(Iteration 771 / 4900) loss: 1.284198\n","(Iteration 781 / 4900) loss: 1.438487\n","(Iteration 791 / 4900) loss: 1.380595\n","(Iteration 801 / 4900) loss: 1.365203\n","(Iteration 811 / 4900) loss: 1.369440\n","(Iteration 821 / 4900) loss: 1.423936\n","(Iteration 831 / 4900) loss: 1.326492\n","(Iteration 841 / 4900) loss: 1.407163\n","(Iteration 851 / 4900) loss: 1.301863\n","(Iteration 861 / 4900) loss: 1.295123\n","(Iteration 871 / 4900) loss: 1.320685\n","(Iteration 881 / 4900) loss: 1.244747\n","(Iteration 891 / 4900) loss: 1.365837\n","(Iteration 901 / 4900) loss: 1.304933\n","(Iteration 911 / 4900) loss: 1.342735\n","(Iteration 921 / 4900) loss: 1.424638\n","(Iteration 931 / 4900) loss: 1.325761\n","(Iteration 941 / 4900) loss: 1.394510\n","(Iteration 951 / 4900) loss: 1.363849\n","(Iteration 961 / 4900) loss: 1.336249\n","(Iteration 971 / 4900) loss: 1.450306\n","(Epoch 2 / 10) train acc: 0.517000; val_acc: 0.510000\n","(Iteration 981 / 4900) loss: 1.155087\n","(Iteration 991 / 4900) loss: 1.309513\n","(Iteration 1001 / 4900) loss: 1.256283\n","(Iteration 1011 / 4900) loss: 1.380136\n","(Iteration 1021 / 4900) loss: 1.277009\n","(Iteration 1031 / 4900) loss: 1.245956\n","(Iteration 1041 / 4900) loss: 1.447251\n","(Iteration 1051 / 4900) loss: 1.359087\n","(Iteration 1061 / 4900) loss: 1.302522\n","(Iteration 1071 / 4900) loss: 1.282455\n","(Iteration 1081 / 4900) loss: 1.400397\n","(Iteration 1091 / 4900) loss: 1.361034\n","(Iteration 1101 / 4900) loss: 1.318585\n","(Iteration 1111 / 4900) loss: 1.241850\n","(Iteration 1121 / 4900) loss: 1.317750\n","(Iteration 1131 / 4900) loss: 1.370535\n","(Iteration 1141 / 4900) loss: 1.261562\n","(Iteration 1151 / 4900) loss: 1.395288\n","(Iteration 1161 / 4900) loss: 1.253466\n","(Iteration 1171 / 4900) loss: 1.228512\n","(Iteration 1181 / 4900) loss: 1.340572\n","(Iteration 1191 / 4900) loss: 1.238811\n","(Iteration 1201 / 4900) loss: 1.066758\n","(Iteration 1211 / 4900) loss: 1.299278\n","(Iteration 1221 / 4900) loss: 1.239852\n","(Iteration 1231 / 4900) loss: 1.403097\n","(Iteration 1241 / 4900) loss: 1.219340\n","(Iteration 1251 / 4900) loss: 1.255050\n","(Iteration 1261 / 4900) loss: 1.209659\n","(Iteration 1271 / 4900) loss: 1.236894\n","(Iteration 1281 / 4900) loss: 1.432991\n","(Iteration 1291 / 4900) loss: 1.178104\n","(Iteration 1301 / 4900) loss: 1.209851\n","(Iteration 1311 / 4900) loss: 1.343912\n","(Iteration 1321 / 4900) loss: 1.217448\n","(Iteration 1331 / 4900) loss: 1.443472\n","(Iteration 1341 / 4900) loss: 1.292692\n","(Iteration 1351 / 4900) loss: 1.332654\n","(Iteration 1361 / 4900) loss: 1.349504\n","(Iteration 1371 / 4900) loss: 1.173676\n","(Iteration 1381 / 4900) loss: 1.246950\n","(Iteration 1391 / 4900) loss: 1.367331\n","(Iteration 1401 / 4900) loss: 1.092543\n","(Iteration 1411 / 4900) loss: 1.326417\n","(Iteration 1421 / 4900) loss: 1.357792\n","(Iteration 1431 / 4900) loss: 1.296232\n","(Iteration 1441 / 4900) loss: 1.188761\n","(Iteration 1451 / 4900) loss: 1.250476\n","(Iteration 1461 / 4900) loss: 1.225578\n","(Epoch 3 / 10) train acc: 0.586000; val_acc: 0.533000\n","(Iteration 1471 / 4900) loss: 1.323172\n","(Iteration 1481 / 4900) loss: 1.279089\n","(Iteration 1491 / 4900) loss: 1.253680\n","(Iteration 1501 / 4900) loss: 1.353721\n","(Iteration 1511 / 4900) loss: 1.077772\n","(Iteration 1521 / 4900) loss: 1.070481\n","(Iteration 1531 / 4900) loss: 1.205263\n","(Iteration 1541 / 4900) loss: 1.220092\n","(Iteration 1551 / 4900) loss: 1.111860\n","(Iteration 1561 / 4900) loss: 1.252373\n","(Iteration 1571 / 4900) loss: 1.179406\n","(Iteration 1581 / 4900) loss: 1.054924\n","(Iteration 1591 / 4900) loss: 1.350394\n","(Iteration 1601 / 4900) loss: 1.067136\n","(Iteration 1611 / 4900) loss: 1.132164\n","(Iteration 1621 / 4900) loss: 1.128932\n","(Iteration 1631 / 4900) loss: 1.493107\n","(Iteration 1641 / 4900) loss: 1.078407\n","(Iteration 1651 / 4900) loss: 1.256571\n","(Iteration 1661 / 4900) loss: 1.130872\n","(Iteration 1671 / 4900) loss: 1.129492\n","(Iteration 1681 / 4900) loss: 1.184422\n","(Iteration 1691 / 4900) loss: 0.993110\n","(Iteration 1701 / 4900) loss: 0.858805\n","(Iteration 1711 / 4900) loss: 1.241984\n","(Iteration 1721 / 4900) loss: 1.192565\n","(Iteration 1731 / 4900) loss: 1.047335\n","(Iteration 1741 / 4900) loss: 1.199852\n","(Iteration 1751 / 4900) loss: 1.228263\n","(Iteration 1761 / 4900) loss: 1.265685\n","(Iteration 1771 / 4900) loss: 0.904091\n","(Iteration 1781 / 4900) loss: 1.026835\n","(Iteration 1791 / 4900) loss: 1.154860\n","(Iteration 1801 / 4900) loss: 1.212692\n","(Iteration 1811 / 4900) loss: 1.136226\n","(Iteration 1821 / 4900) loss: 1.060634\n","(Iteration 1831 / 4900) loss: 1.037415\n","(Iteration 1841 / 4900) loss: 1.180097\n","(Iteration 1851 / 4900) loss: 1.237729\n","(Iteration 1861 / 4900) loss: 1.137648\n","(Iteration 1871 / 4900) loss: 1.348887\n","(Iteration 1881 / 4900) loss: 1.153173\n","(Iteration 1891 / 4900) loss: 1.271504\n","(Iteration 1901 / 4900) loss: 0.937557\n","(Iteration 1911 / 4900) loss: 1.186668\n","(Iteration 1921 / 4900) loss: 1.204811\n","(Iteration 1931 / 4900) loss: 1.253918\n","(Iteration 1941 / 4900) loss: 1.239973\n","(Iteration 1951 / 4900) loss: 0.942183\n","(Epoch 4 / 10) train acc: 0.603000; val_acc: 0.563000\n","(Iteration 1961 / 4900) loss: 1.142277\n","(Iteration 1971 / 4900) loss: 1.094665\n","(Iteration 1981 / 4900) loss: 1.067392\n","(Iteration 1991 / 4900) loss: 1.023308\n","(Iteration 2001 / 4900) loss: 1.220849\n","(Iteration 2011 / 4900) loss: 1.043933\n","(Iteration 2021 / 4900) loss: 1.159114\n","(Iteration 2031 / 4900) loss: 1.141494\n","(Iteration 2041 / 4900) loss: 1.240508\n","(Iteration 2051 / 4900) loss: 1.014953\n","(Iteration 2061 / 4900) loss: 1.056336\n","(Iteration 2071 / 4900) loss: 1.121718\n","(Iteration 2081 / 4900) loss: 1.192561\n","(Iteration 2091 / 4900) loss: 1.026965\n","(Iteration 2101 / 4900) loss: 1.192985\n","(Iteration 2111 / 4900) loss: 1.267359\n","(Iteration 2121 / 4900) loss: 1.278132\n","(Iteration 2131 / 4900) loss: 1.081449\n","(Iteration 2141 / 4900) loss: 1.291672\n","(Iteration 2151 / 4900) loss: 1.044639\n","(Iteration 2161 / 4900) loss: 1.103737\n","(Iteration 2171 / 4900) loss: 1.158327\n","(Iteration 2181 / 4900) loss: 1.023453\n","(Iteration 2191 / 4900) loss: 1.102463\n","(Iteration 2201 / 4900) loss: 1.249526\n","(Iteration 2211 / 4900) loss: 1.087146\n","(Iteration 2221 / 4900) loss: 1.210976\n","(Iteration 2231 / 4900) loss: 1.144039\n","(Iteration 2241 / 4900) loss: 1.116260\n","(Iteration 2251 / 4900) loss: 1.149316\n","(Iteration 2261 / 4900) loss: 1.330001\n","(Iteration 2271 / 4900) loss: 1.081284\n","(Iteration 2281 / 4900) loss: 1.087897\n","(Iteration 2291 / 4900) loss: 1.085537\n","(Iteration 2301 / 4900) loss: 0.969573\n","(Iteration 2311 / 4900) loss: 1.151475\n","(Iteration 2321 / 4900) loss: 1.024684\n","(Iteration 2331 / 4900) loss: 1.050810\n","(Iteration 2341 / 4900) loss: 1.201847\n","(Iteration 2351 / 4900) loss: 1.130496\n","(Iteration 2361 / 4900) loss: 0.990069\n","(Iteration 2371 / 4900) loss: 0.946604\n","(Iteration 2381 / 4900) loss: 1.022668\n","(Iteration 2391 / 4900) loss: 1.140010\n","(Iteration 2401 / 4900) loss: 1.160062\n","(Iteration 2411 / 4900) loss: 1.122214\n","(Iteration 2421 / 4900) loss: 1.348600\n","(Iteration 2431 / 4900) loss: 1.123423\n","(Iteration 2441 / 4900) loss: 1.080892\n","(Epoch 5 / 10) train acc: 0.631000; val_acc: 0.576000\n","(Iteration 2451 / 4900) loss: 1.109901\n","(Iteration 2461 / 4900) loss: 1.220277\n","(Iteration 2471 / 4900) loss: 0.960030\n","(Iteration 2481 / 4900) loss: 1.004927\n","(Iteration 2491 / 4900) loss: 1.012550\n","(Iteration 2501 / 4900) loss: 1.092694\n","(Iteration 2511 / 4900) loss: 0.997399\n","(Iteration 2521 / 4900) loss: 1.179757\n","(Iteration 2531 / 4900) loss: 1.241450\n","(Iteration 2541 / 4900) loss: 1.073038\n","(Iteration 2551 / 4900) loss: 1.112798\n","(Iteration 2561 / 4900) loss: 1.060702\n","(Iteration 2571 / 4900) loss: 0.944489\n","(Iteration 2581 / 4900) loss: 1.043552\n","(Iteration 2591 / 4900) loss: 1.148586\n","(Iteration 2601 / 4900) loss: 1.080924\n","(Iteration 2611 / 4900) loss: 1.025309\n","(Iteration 2621 / 4900) loss: 1.100441\n","(Iteration 2631 / 4900) loss: 1.136134\n","(Iteration 2641 / 4900) loss: 1.228900\n","(Iteration 2651 / 4900) loss: 1.141933\n","(Iteration 2661 / 4900) loss: 1.085025\n","(Iteration 2671 / 4900) loss: 1.125443\n","(Iteration 2681 / 4900) loss: 1.171517\n","(Iteration 2691 / 4900) loss: 1.134307\n","(Iteration 2701 / 4900) loss: 0.995626\n","(Iteration 2711 / 4900) loss: 1.193333\n","(Iteration 2721 / 4900) loss: 0.967360\n","(Iteration 2731 / 4900) loss: 0.975161\n","(Iteration 2741 / 4900) loss: 1.047253\n","(Iteration 2751 / 4900) loss: 1.103940\n","(Iteration 2761 / 4900) loss: 1.077837\n","(Iteration 2771 / 4900) loss: 1.124391\n","(Iteration 2781 / 4900) loss: 1.072322\n","(Iteration 2791 / 4900) loss: 1.119726\n","(Iteration 2801 / 4900) loss: 0.960817\n","(Iteration 2811 / 4900) loss: 1.238124\n","(Iteration 2821 / 4900) loss: 0.992327\n","(Iteration 2831 / 4900) loss: 1.027205\n","(Iteration 2841 / 4900) loss: 1.054012\n","(Iteration 2851 / 4900) loss: 0.897224\n","(Iteration 2861 / 4900) loss: 1.095849\n","(Iteration 2871 / 4900) loss: 0.882506\n","(Iteration 2881 / 4900) loss: 1.346479\n","(Iteration 2891 / 4900) loss: 1.239963\n","(Iteration 2901 / 4900) loss: 0.909771\n","(Iteration 2911 / 4900) loss: 1.065548\n","(Iteration 2921 / 4900) loss: 1.096481\n","(Iteration 2931 / 4900) loss: 1.408362\n","(Epoch 6 / 10) train acc: 0.621000; val_acc: 0.564000\n","(Iteration 2941 / 4900) loss: 0.920804\n","(Iteration 2951 / 4900) loss: 0.988781\n","(Iteration 2961 / 4900) loss: 1.041589\n","(Iteration 2971 / 4900) loss: 1.300578\n","(Iteration 2981 / 4900) loss: 1.178766\n","(Iteration 2991 / 4900) loss: 1.068559\n","(Iteration 3001 / 4900) loss: 1.102390\n","(Iteration 3011 / 4900) loss: 0.969853\n","(Iteration 3021 / 4900) loss: 0.933123\n","(Iteration 3031 / 4900) loss: 1.237710\n","(Iteration 3041 / 4900) loss: 1.014421\n","(Iteration 3051 / 4900) loss: 1.156572\n","(Iteration 3061 / 4900) loss: 1.205228\n","(Iteration 3071 / 4900) loss: 1.228345\n","(Iteration 3081 / 4900) loss: 0.907555\n","(Iteration 3091 / 4900) loss: 1.101241\n","(Iteration 3101 / 4900) loss: 1.046748\n","(Iteration 3111 / 4900) loss: 1.028126\n","(Iteration 3121 / 4900) loss: 0.986544\n","(Iteration 3131 / 4900) loss: 1.087285\n","(Iteration 3141 / 4900) loss: 1.002694\n","(Iteration 3151 / 4900) loss: 1.154153\n","(Iteration 3161 / 4900) loss: 0.965316\n","(Iteration 3171 / 4900) loss: 0.963207\n","(Iteration 3181 / 4900) loss: 1.209281\n","(Iteration 3191 / 4900) loss: 1.270024\n","(Iteration 3201 / 4900) loss: 1.057621\n","(Iteration 3211 / 4900) loss: 1.010046\n","(Iteration 3221 / 4900) loss: 1.053262\n","(Iteration 3231 / 4900) loss: 1.069702\n","(Iteration 3241 / 4900) loss: 1.038240\n","(Iteration 3251 / 4900) loss: 1.011128\n","(Iteration 3261 / 4900) loss: 1.009430\n","(Iteration 3271 / 4900) loss: 0.962920\n","(Iteration 3281 / 4900) loss: 0.850926\n","(Iteration 3291 / 4900) loss: 1.092130\n","(Iteration 3301 / 4900) loss: 0.972509\n","(Iteration 3311 / 4900) loss: 1.175347\n","(Iteration 3321 / 4900) loss: 1.099329\n","(Iteration 3331 / 4900) loss: 1.129281\n","(Iteration 3341 / 4900) loss: 0.941166\n","(Iteration 3351 / 4900) loss: 0.939646\n","(Iteration 3361 / 4900) loss: 1.025384\n","(Iteration 3371 / 4900) loss: 1.016125\n","(Iteration 3381 / 4900) loss: 1.018489\n","(Iteration 3391 / 4900) loss: 1.207407\n","(Iteration 3401 / 4900) loss: 1.137465\n","(Iteration 3411 / 4900) loss: 0.975635\n","(Iteration 3421 / 4900) loss: 1.008833\n","(Epoch 7 / 10) train acc: 0.659000; val_acc: 0.587000\n","(Iteration 3431 / 4900) loss: 0.939494\n","(Iteration 3441 / 4900) loss: 1.007943\n","(Iteration 3451 / 4900) loss: 0.813162\n","(Iteration 3461 / 4900) loss: 0.951004\n","(Iteration 3471 / 4900) loss: 0.978532\n","(Iteration 3481 / 4900) loss: 1.111148\n","(Iteration 3491 / 4900) loss: 1.033881\n","(Iteration 3501 / 4900) loss: 0.884822\n","(Iteration 3511 / 4900) loss: 0.803825\n","(Iteration 3521 / 4900) loss: 1.013238\n","(Iteration 3531 / 4900) loss: 1.273615\n","(Iteration 3541 / 4900) loss: 0.982867\n","(Iteration 3551 / 4900) loss: 0.973762\n","(Iteration 3561 / 4900) loss: 1.074799\n","(Iteration 3571 / 4900) loss: 1.149098\n","(Iteration 3581 / 4900) loss: 1.026800\n","(Iteration 3591 / 4900) loss: 0.894577\n","(Iteration 3601 / 4900) loss: 1.167680\n","(Iteration 3611 / 4900) loss: 0.884997\n","(Iteration 3621 / 4900) loss: 0.941030\n","(Iteration 3631 / 4900) loss: 0.949960\n","(Iteration 3641 / 4900) loss: 0.846821\n","(Iteration 3651 / 4900) loss: 0.995893\n","(Iteration 3661 / 4900) loss: 0.907125\n","(Iteration 3671 / 4900) loss: 1.109656\n","(Iteration 3681 / 4900) loss: 0.965502\n","(Iteration 3691 / 4900) loss: 0.865002\n","(Iteration 3701 / 4900) loss: 0.878520\n","(Iteration 3711 / 4900) loss: 0.909656\n","(Iteration 3721 / 4900) loss: 1.101761\n","(Iteration 3731 / 4900) loss: 0.996544\n","(Iteration 3741 / 4900) loss: 0.852559\n","(Iteration 3751 / 4900) loss: 0.946083\n","(Iteration 3761 / 4900) loss: 0.735923\n","(Iteration 3771 / 4900) loss: 1.034377\n","(Iteration 3781 / 4900) loss: 0.955297\n","(Iteration 3791 / 4900) loss: 0.869763\n","(Iteration 3801 / 4900) loss: 0.889603\n","(Iteration 3811 / 4900) loss: 0.911069\n","(Iteration 3821 / 4900) loss: 1.115435\n","(Iteration 3831 / 4900) loss: 0.818750\n","(Iteration 3841 / 4900) loss: 0.851867\n","(Iteration 3851 / 4900) loss: 0.946987\n","(Iteration 3861 / 4900) loss: 1.222376\n","(Iteration 3871 / 4900) loss: 1.065993\n","(Iteration 3881 / 4900) loss: 1.035436\n","(Iteration 3891 / 4900) loss: 0.910738\n","(Iteration 3901 / 4900) loss: 1.130390\n","(Iteration 3911 / 4900) loss: 0.855058\n","(Epoch 8 / 10) train acc: 0.657000; val_acc: 0.572000\n","(Iteration 3921 / 4900) loss: 1.093604\n","(Iteration 3931 / 4900) loss: 1.071563\n","(Iteration 3941 / 4900) loss: 1.048502\n","(Iteration 3951 / 4900) loss: 0.862163\n","(Iteration 3961 / 4900) loss: 1.095176\n","(Iteration 3971 / 4900) loss: 0.919390\n","(Iteration 3981 / 4900) loss: 0.844418\n","(Iteration 3991 / 4900) loss: 0.935433\n","(Iteration 4001 / 4900) loss: 0.829706\n","(Iteration 4011 / 4900) loss: 1.140606\n","(Iteration 4021 / 4900) loss: 0.840440\n","(Iteration 4031 / 4900) loss: 0.939072\n","(Iteration 4041 / 4900) loss: 0.869439\n","(Iteration 4051 / 4900) loss: 0.881327\n","(Iteration 4061 / 4900) loss: 0.912867\n","(Iteration 4071 / 4900) loss: 0.957938\n","(Iteration 4081 / 4900) loss: 0.976865\n","(Iteration 4091 / 4900) loss: 0.773938\n","(Iteration 4101 / 4900) loss: 1.091398\n","(Iteration 4111 / 4900) loss: 0.912039\n","(Iteration 4121 / 4900) loss: 1.138153\n","(Iteration 4131 / 4900) loss: 0.931827\n","(Iteration 4141 / 4900) loss: 1.189238\n","(Iteration 4151 / 4900) loss: 1.108226\n","(Iteration 4161 / 4900) loss: 0.895227\n","(Iteration 4171 / 4900) loss: 0.768975\n","(Iteration 4181 / 4900) loss: 0.810203\n","(Iteration 4191 / 4900) loss: 1.014287\n","(Iteration 4201 / 4900) loss: 1.151576\n","(Iteration 4211 / 4900) loss: 0.788998\n","(Iteration 4221 / 4900) loss: 0.945079\n","(Iteration 4231 / 4900) loss: 0.838651\n","(Iteration 4241 / 4900) loss: 1.038848\n","(Iteration 4251 / 4900) loss: 0.908138\n","(Iteration 4261 / 4900) loss: 0.907535\n","(Iteration 4271 / 4900) loss: 0.889367\n","(Iteration 4281 / 4900) loss: 0.976640\n","(Iteration 4291 / 4900) loss: 0.932642\n","(Iteration 4301 / 4900) loss: 1.074778\n","(Iteration 4311 / 4900) loss: 1.026969\n","(Iteration 4321 / 4900) loss: 1.014359\n","(Iteration 4331 / 4900) loss: 1.220441\n","(Iteration 4341 / 4900) loss: 0.946932\n","(Iteration 4351 / 4900) loss: 0.864123\n","(Iteration 4361 / 4900) loss: 0.945094\n","(Iteration 4371 / 4900) loss: 0.982722\n","(Iteration 4381 / 4900) loss: 0.995350\n","(Iteration 4391 / 4900) loss: 0.899721\n","(Iteration 4401 / 4900) loss: 1.244757\n","(Epoch 9 / 10) train acc: 0.683000; val_acc: 0.557000\n","(Iteration 4411 / 4900) loss: 0.864982\n","(Iteration 4421 / 4900) loss: 0.956250\n","(Iteration 4431 / 4900) loss: 1.040337\n","(Iteration 4441 / 4900) loss: 0.963266\n","(Iteration 4451 / 4900) loss: 0.829062\n","(Iteration 4461 / 4900) loss: 0.994669\n","(Iteration 4471 / 4900) loss: 1.170706\n","(Iteration 4481 / 4900) loss: 1.035553\n","(Iteration 4491 / 4900) loss: 0.966283\n","(Iteration 4501 / 4900) loss: 0.933278\n","(Iteration 4511 / 4900) loss: 0.809243\n","(Iteration 4521 / 4900) loss: 0.967136\n","(Iteration 4531 / 4900) loss: 0.942078\n","(Iteration 4541 / 4900) loss: 1.096556\n","(Iteration 4551 / 4900) loss: 0.754441\n","(Iteration 4561 / 4900) loss: 1.061247\n","(Iteration 4571 / 4900) loss: 0.940571\n","(Iteration 4581 / 4900) loss: 0.759565\n","(Iteration 4591 / 4900) loss: 1.002176\n","(Iteration 4601 / 4900) loss: 1.006214\n","(Iteration 4611 / 4900) loss: 1.030936\n","(Iteration 4621 / 4900) loss: 0.899625\n","(Iteration 4631 / 4900) loss: 0.731970\n","(Iteration 4641 / 4900) loss: 0.885388\n","(Iteration 4651 / 4900) loss: 0.846223\n","(Iteration 4661 / 4900) loss: 0.851740\n","(Iteration 4671 / 4900) loss: 0.774597\n","(Iteration 4681 / 4900) loss: 1.016946\n","(Iteration 4691 / 4900) loss: 0.918660\n","(Iteration 4701 / 4900) loss: 0.949008\n","(Iteration 4711 / 4900) loss: 0.698643\n","(Iteration 4721 / 4900) loss: 0.917079\n","(Iteration 4731 / 4900) loss: 0.779360\n","(Iteration 4741 / 4900) loss: 1.094445\n","(Iteration 4751 / 4900) loss: 0.739740\n","(Iteration 4761 / 4900) loss: 1.142668\n","(Iteration 4771 / 4900) loss: 1.021845\n","(Iteration 4781 / 4900) loss: 0.892929\n","(Iteration 4791 / 4900) loss: 0.867058\n","(Iteration 4801 / 4900) loss: 0.995671\n","(Iteration 4811 / 4900) loss: 0.983289\n","(Iteration 4821 / 4900) loss: 0.898132\n","(Iteration 4831 / 4900) loss: 0.959252\n","(Iteration 4841 / 4900) loss: 0.760317\n","(Iteration 4851 / 4900) loss: 0.813570\n","(Iteration 4861 / 4900) loss: 1.056337\n","(Iteration 4871 / 4900) loss: 0.785798\n","(Iteration 4881 / 4900) loss: 0.909019\n","(Iteration 4891 / 4900) loss: 0.914921\n","(Epoch 10 / 10) train acc: 0.703000; val_acc: 0.578000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.098000; val_acc: 0.107000\n","(Iteration 11 / 4900) loss: 2.308009\n","(Iteration 21 / 4900) loss: 2.269937\n","(Iteration 31 / 4900) loss: 2.094080\n","(Iteration 41 / 4900) loss: 1.742380\n","(Iteration 51 / 4900) loss: 1.917963\n","(Iteration 61 / 4900) loss: 1.647365\n","(Iteration 71 / 4900) loss: 1.952157\n","(Iteration 81 / 4900) loss: 1.660374\n","(Iteration 91 / 4900) loss: 1.499392\n","(Iteration 101 / 4900) loss: 1.568039\n","(Iteration 111 / 4900) loss: 1.624365\n","(Iteration 121 / 4900) loss: 1.497107\n","(Iteration 131 / 4900) loss: 1.505392\n","(Iteration 141 / 4900) loss: 1.483704\n","(Iteration 151 / 4900) loss: 1.650005\n","(Iteration 161 / 4900) loss: 1.311382\n","(Iteration 171 / 4900) loss: 1.523304\n","(Iteration 181 / 4900) loss: 1.465928\n","(Iteration 191 / 4900) loss: 1.452246\n","(Iteration 201 / 4900) loss: 1.440839\n","(Iteration 211 / 4900) loss: 1.423359\n","(Iteration 221 / 4900) loss: 1.423931\n","(Iteration 231 / 4900) loss: 1.493049\n","(Iteration 241 / 4900) loss: 1.572636\n","(Iteration 251 / 4900) loss: 1.474553\n","(Iteration 261 / 4900) loss: 1.250976\n","(Iteration 271 / 4900) loss: 1.257562\n","(Iteration 281 / 4900) loss: 1.176395\n","(Iteration 291 / 4900) loss: 1.408847\n","(Iteration 301 / 4900) loss: 1.372820\n","(Iteration 311 / 4900) loss: 1.456924\n","(Iteration 321 / 4900) loss: 1.779756\n","(Iteration 331 / 4900) loss: 1.547714\n","(Iteration 341 / 4900) loss: 1.232224\n","(Iteration 351 / 4900) loss: 1.350406\n","(Iteration 361 / 4900) loss: 1.286327\n","(Iteration 371 / 4900) loss: 1.551882\n","(Iteration 381 / 4900) loss: 1.630624\n","(Iteration 391 / 4900) loss: 1.446153\n","(Iteration 401 / 4900) loss: 1.385926\n","(Iteration 411 / 4900) loss: 1.346413\n","(Iteration 421 / 4900) loss: 1.318148\n","(Iteration 431 / 4900) loss: 1.358772\n","(Iteration 441 / 4900) loss: 1.522442\n","(Iteration 451 / 4900) loss: 1.412184\n","(Iteration 461 / 4900) loss: 1.273782\n","(Iteration 471 / 4900) loss: 1.503518\n","(Iteration 481 / 4900) loss: 1.140430\n","(Epoch 1 / 10) train acc: 0.521000; val_acc: 0.528000\n","(Iteration 491 / 4900) loss: 1.295590\n","(Iteration 501 / 4900) loss: 1.504920\n","(Iteration 511 / 4900) loss: 1.248408\n","(Iteration 521 / 4900) loss: 1.342926\n","(Iteration 531 / 4900) loss: 1.355220\n","(Iteration 541 / 4900) loss: 1.040618\n","(Iteration 551 / 4900) loss: 1.240002\n","(Iteration 561 / 4900) loss: 1.478010\n","(Iteration 571 / 4900) loss: 1.461454\n","(Iteration 581 / 4900) loss: 1.113582\n","(Iteration 591 / 4900) loss: 1.274815\n","(Iteration 601 / 4900) loss: 1.084489\n","(Iteration 611 / 4900) loss: 1.160005\n","(Iteration 621 / 4900) loss: 1.357300\n","(Iteration 631 / 4900) loss: 1.628408\n","(Iteration 641 / 4900) loss: 1.168200\n","(Iteration 651 / 4900) loss: 1.486864\n","(Iteration 661 / 4900) loss: 1.178334\n","(Iteration 671 / 4900) loss: 0.959723\n","(Iteration 681 / 4900) loss: 1.310986\n","(Iteration 691 / 4900) loss: 1.454346\n","(Iteration 701 / 4900) loss: 1.720976\n","(Iteration 711 / 4900) loss: 1.034855\n","(Iteration 721 / 4900) loss: 1.468386\n","(Iteration 731 / 4900) loss: 1.496024\n","(Iteration 741 / 4900) loss: 1.464378\n","(Iteration 751 / 4900) loss: 1.406203\n","(Iteration 761 / 4900) loss: 1.310515\n","(Iteration 771 / 4900) loss: 1.487668\n","(Iteration 781 / 4900) loss: 1.291648\n","(Iteration 791 / 4900) loss: 1.408026\n","(Iteration 801 / 4900) loss: 1.126910\n","(Iteration 811 / 4900) loss: 1.172976\n","(Iteration 821 / 4900) loss: 1.014055\n","(Iteration 831 / 4900) loss: 1.232997\n","(Iteration 841 / 4900) loss: 1.420723\n","(Iteration 851 / 4900) loss: 1.527372\n","(Iteration 861 / 4900) loss: 1.288811\n","(Iteration 871 / 4900) loss: 1.050398\n","(Iteration 881 / 4900) loss: 1.183089\n","(Iteration 891 / 4900) loss: 1.316243\n","(Iteration 901 / 4900) loss: 1.281904\n","(Iteration 911 / 4900) loss: 1.192604\n","(Iteration 921 / 4900) loss: 1.275311\n","(Iteration 931 / 4900) loss: 1.246670\n","(Iteration 941 / 4900) loss: 1.249780\n","(Iteration 951 / 4900) loss: 1.307340\n","(Iteration 961 / 4900) loss: 1.443256\n","(Iteration 971 / 4900) loss: 1.065270\n","(Epoch 2 / 10) train acc: 0.559000; val_acc: 0.517000\n","(Iteration 981 / 4900) loss: 1.192935\n","(Iteration 991 / 4900) loss: 1.246171\n","(Iteration 1001 / 4900) loss: 1.148593\n","(Iteration 1011 / 4900) loss: 1.267180\n","(Iteration 1021 / 4900) loss: 1.154774\n","(Iteration 1031 / 4900) loss: 1.098278\n","(Iteration 1041 / 4900) loss: 1.317502\n","(Iteration 1051 / 4900) loss: 0.983591\n","(Iteration 1061 / 4900) loss: 1.177555\n","(Iteration 1071 / 4900) loss: 1.193135\n","(Iteration 1081 / 4900) loss: 1.107249\n","(Iteration 1091 / 4900) loss: 1.232699\n","(Iteration 1101 / 4900) loss: 1.053109\n","(Iteration 1111 / 4900) loss: 1.199264\n","(Iteration 1121 / 4900) loss: 1.310536\n","(Iteration 1131 / 4900) loss: 1.004529\n","(Iteration 1141 / 4900) loss: 1.287629\n","(Iteration 1151 / 4900) loss: 1.315771\n","(Iteration 1161 / 4900) loss: 1.152076\n","(Iteration 1171 / 4900) loss: 1.307525\n","(Iteration 1181 / 4900) loss: 1.114267\n","(Iteration 1191 / 4900) loss: 1.022832\n","(Iteration 1201 / 4900) loss: 1.248445\n","(Iteration 1211 / 4900) loss: 1.121985\n","(Iteration 1221 / 4900) loss: 1.609209\n","(Iteration 1231 / 4900) loss: 1.062130\n","(Iteration 1241 / 4900) loss: 1.220332\n","(Iteration 1251 / 4900) loss: 1.301386\n","(Iteration 1261 / 4900) loss: 1.350564\n","(Iteration 1271 / 4900) loss: 1.376132\n","(Iteration 1281 / 4900) loss: 1.404911\n","(Iteration 1291 / 4900) loss: 1.175563\n","(Iteration 1301 / 4900) loss: 1.386669\n","(Iteration 1311 / 4900) loss: 1.431880\n","(Iteration 1321 / 4900) loss: 1.164422\n","(Iteration 1331 / 4900) loss: 1.163237\n","(Iteration 1341 / 4900) loss: 1.294042\n","(Iteration 1351 / 4900) loss: 1.388433\n","(Iteration 1361 / 4900) loss: 1.152919\n","(Iteration 1371 / 4900) loss: 1.312651\n","(Iteration 1381 / 4900) loss: 1.230272\n","(Iteration 1391 / 4900) loss: 1.011774\n","(Iteration 1401 / 4900) loss: 1.198556\n","(Iteration 1411 / 4900) loss: 1.323475\n","(Iteration 1421 / 4900) loss: 0.971759\n","(Iteration 1431 / 4900) loss: 1.076176\n","(Iteration 1441 / 4900) loss: 1.396323\n","(Iteration 1451 / 4900) loss: 1.412408\n","(Iteration 1461 / 4900) loss: 1.036286\n","(Epoch 3 / 10) train acc: 0.625000; val_acc: 0.548000\n","(Iteration 1471 / 4900) loss: 1.329133\n","(Iteration 1481 / 4900) loss: 1.144729\n","(Iteration 1491 / 4900) loss: 1.167628\n","(Iteration 1501 / 4900) loss: 1.229252\n","(Iteration 1511 / 4900) loss: 1.119630\n","(Iteration 1521 / 4900) loss: 1.085423\n","(Iteration 1531 / 4900) loss: 1.146808\n","(Iteration 1541 / 4900) loss: 1.277942\n","(Iteration 1551 / 4900) loss: 1.246299\n","(Iteration 1561 / 4900) loss: 1.062544\n","(Iteration 1571 / 4900) loss: 1.170368\n","(Iteration 1581 / 4900) loss: 1.146711\n","(Iteration 1591 / 4900) loss: 1.071651\n","(Iteration 1601 / 4900) loss: 1.041085\n","(Iteration 1611 / 4900) loss: 1.115905\n","(Iteration 1621 / 4900) loss: 1.163410\n","(Iteration 1631 / 4900) loss: 1.316596\n","(Iteration 1641 / 4900) loss: 1.007739\n","(Iteration 1651 / 4900) loss: 1.133187\n","(Iteration 1661 / 4900) loss: 1.165225\n","(Iteration 1671 / 4900) loss: 1.332088\n","(Iteration 1681 / 4900) loss: 1.216708\n","(Iteration 1691 / 4900) loss: 0.994829\n","(Iteration 1701 / 4900) loss: 0.918875\n","(Iteration 1711 / 4900) loss: 0.969365\n","(Iteration 1721 / 4900) loss: 1.072618\n","(Iteration 1731 / 4900) loss: 1.428041\n","(Iteration 1741 / 4900) loss: 1.019771\n","(Iteration 1751 / 4900) loss: 1.210900\n","(Iteration 1761 / 4900) loss: 1.134627\n","(Iteration 1771 / 4900) loss: 0.941188\n","(Iteration 1781 / 4900) loss: 1.013282\n","(Iteration 1791 / 4900) loss: 1.257960\n","(Iteration 1801 / 4900) loss: 1.140342\n","(Iteration 1811 / 4900) loss: 0.832457\n","(Iteration 1821 / 4900) loss: 0.993411\n","(Iteration 1831 / 4900) loss: 0.925721\n","(Iteration 1841 / 4900) loss: 1.242259\n","(Iteration 1851 / 4900) loss: 0.993950\n","(Iteration 1861 / 4900) loss: 1.164753\n","(Iteration 1871 / 4900) loss: 0.897573\n","(Iteration 1881 / 4900) loss: 0.942212\n","(Iteration 1891 / 4900) loss: 1.132813\n","(Iteration 1901 / 4900) loss: 0.881903\n","(Iteration 1911 / 4900) loss: 1.114802\n","(Iteration 1921 / 4900) loss: 0.682547\n","(Iteration 1931 / 4900) loss: 1.297792\n","(Iteration 1941 / 4900) loss: 1.116374\n","(Iteration 1951 / 4900) loss: 1.078473\n","(Epoch 4 / 10) train acc: 0.653000; val_acc: 0.537000\n","(Iteration 1961 / 4900) loss: 1.143648\n","(Iteration 1971 / 4900) loss: 1.123628\n","(Iteration 1981 / 4900) loss: 1.260704\n","(Iteration 1991 / 4900) loss: 1.104909\n","(Iteration 2001 / 4900) loss: 1.248317\n","(Iteration 2011 / 4900) loss: 1.366654\n","(Iteration 2021 / 4900) loss: 1.419431\n","(Iteration 2031 / 4900) loss: 1.124452\n","(Iteration 2041 / 4900) loss: 0.825658\n","(Iteration 2051 / 4900) loss: 1.205871\n","(Iteration 2061 / 4900) loss: 0.989672\n","(Iteration 2071 / 4900) loss: 1.089329\n","(Iteration 2081 / 4900) loss: 1.050327\n","(Iteration 2091 / 4900) loss: 1.151784\n","(Iteration 2101 / 4900) loss: 0.959828\n","(Iteration 2111 / 4900) loss: 0.999815\n","(Iteration 2121 / 4900) loss: 0.910342\n","(Iteration 2131 / 4900) loss: 0.910154\n","(Iteration 2141 / 4900) loss: 1.088313\n","(Iteration 2151 / 4900) loss: 1.136317\n","(Iteration 2161 / 4900) loss: 1.311343\n","(Iteration 2171 / 4900) loss: 0.871427\n","(Iteration 2181 / 4900) loss: 1.010921\n","(Iteration 2191 / 4900) loss: 1.175494\n","(Iteration 2201 / 4900) loss: 0.869578\n","(Iteration 2211 / 4900) loss: 0.926968\n","(Iteration 2221 / 4900) loss: 1.117811\n","(Iteration 2231 / 4900) loss: 1.249784\n","(Iteration 2241 / 4900) loss: 1.012384\n","(Iteration 2251 / 4900) loss: 1.007700\n","(Iteration 2261 / 4900) loss: 1.161457\n","(Iteration 2271 / 4900) loss: 0.954043\n","(Iteration 2281 / 4900) loss: 0.947194\n","(Iteration 2291 / 4900) loss: 0.904427\n","(Iteration 2301 / 4900) loss: 1.166132\n","(Iteration 2311 / 4900) loss: 0.765399\n","(Iteration 2321 / 4900) loss: 1.016416\n","(Iteration 2331 / 4900) loss: 1.193756\n","(Iteration 2341 / 4900) loss: 1.070662\n","(Iteration 2351 / 4900) loss: 0.876545\n","(Iteration 2361 / 4900) loss: 0.953072\n","(Iteration 2371 / 4900) loss: 1.046876\n","(Iteration 2381 / 4900) loss: 0.911649\n","(Iteration 2391 / 4900) loss: 1.168839\n","(Iteration 2401 / 4900) loss: 0.989404\n","(Iteration 2411 / 4900) loss: 0.866788\n","(Iteration 2421 / 4900) loss: 1.105488\n","(Iteration 2431 / 4900) loss: 1.219875\n","(Iteration 2441 / 4900) loss: 0.851550\n","(Epoch 5 / 10) train acc: 0.657000; val_acc: 0.526000\n","(Iteration 2451 / 4900) loss: 0.907823\n","(Iteration 2461 / 4900) loss: 0.861951\n","(Iteration 2471 / 4900) loss: 1.019886\n","(Iteration 2481 / 4900) loss: 1.071392\n","(Iteration 2491 / 4900) loss: 1.187953\n","(Iteration 2501 / 4900) loss: 1.008841\n","(Iteration 2511 / 4900) loss: 1.150863\n","(Iteration 2521 / 4900) loss: 1.133040\n","(Iteration 2531 / 4900) loss: 1.295963\n","(Iteration 2541 / 4900) loss: 0.969214\n","(Iteration 2551 / 4900) loss: 0.991884\n","(Iteration 2561 / 4900) loss: 1.385496\n","(Iteration 2571 / 4900) loss: 0.923702\n","(Iteration 2581 / 4900) loss: 1.255411\n","(Iteration 2591 / 4900) loss: 1.316759\n","(Iteration 2601 / 4900) loss: 1.226785\n","(Iteration 2611 / 4900) loss: 0.975939\n","(Iteration 2621 / 4900) loss: 0.999294\n","(Iteration 2631 / 4900) loss: 1.238480\n","(Iteration 2641 / 4900) loss: 0.836647\n","(Iteration 2651 / 4900) loss: 0.975283\n","(Iteration 2661 / 4900) loss: 0.796865\n","(Iteration 2671 / 4900) loss: 0.986281\n","(Iteration 2681 / 4900) loss: 1.003732\n","(Iteration 2691 / 4900) loss: 0.967245\n","(Iteration 2701 / 4900) loss: 1.136507\n","(Iteration 2711 / 4900) loss: 1.092318\n","(Iteration 2721 / 4900) loss: 0.900950\n","(Iteration 2731 / 4900) loss: 1.136934\n","(Iteration 2741 / 4900) loss: 1.305616\n","(Iteration 2751 / 4900) loss: 1.034885\n","(Iteration 2761 / 4900) loss: 1.194975\n","(Iteration 2771 / 4900) loss: 0.898192\n","(Iteration 2781 / 4900) loss: 1.083244\n","(Iteration 2791 / 4900) loss: 1.153702\n","(Iteration 2801 / 4900) loss: 0.889858\n","(Iteration 2811 / 4900) loss: 1.001829\n","(Iteration 2821 / 4900) loss: 1.032757\n","(Iteration 2831 / 4900) loss: 0.976880\n","(Iteration 2841 / 4900) loss: 0.988570\n","(Iteration 2851 / 4900) loss: 0.982832\n","(Iteration 2861 / 4900) loss: 1.129914\n","(Iteration 2871 / 4900) loss: 0.921968\n","(Iteration 2881 / 4900) loss: 0.902612\n","(Iteration 2891 / 4900) loss: 1.133424\n","(Iteration 2901 / 4900) loss: 0.963744\n","(Iteration 2911 / 4900) loss: 0.979049\n","(Iteration 2921 / 4900) loss: 0.979413\n","(Iteration 2931 / 4900) loss: 0.922372\n","(Epoch 6 / 10) train acc: 0.672000; val_acc: 0.531000\n","(Iteration 2941 / 4900) loss: 0.905664\n","(Iteration 2951 / 4900) loss: 0.980675\n","(Iteration 2961 / 4900) loss: 0.972433\n","(Iteration 2971 / 4900) loss: 0.962065\n","(Iteration 2981 / 4900) loss: 1.090638\n","(Iteration 2991 / 4900) loss: 0.938843\n","(Iteration 3001 / 4900) loss: 0.936808\n","(Iteration 3011 / 4900) loss: 1.271977\n","(Iteration 3021 / 4900) loss: 0.903655\n","(Iteration 3031 / 4900) loss: 0.873598\n","(Iteration 3041 / 4900) loss: 1.275811\n","(Iteration 3051 / 4900) loss: 0.925750\n","(Iteration 3061 / 4900) loss: 0.742000\n","(Iteration 3071 / 4900) loss: 0.948367\n","(Iteration 3081 / 4900) loss: 1.001317\n","(Iteration 3091 / 4900) loss: 1.156860\n","(Iteration 3101 / 4900) loss: 1.075470\n","(Iteration 3111 / 4900) loss: 0.918556\n","(Iteration 3121 / 4900) loss: 0.949415\n","(Iteration 3131 / 4900) loss: 0.879660\n","(Iteration 3141 / 4900) loss: 0.722414\n","(Iteration 3151 / 4900) loss: 0.795101\n","(Iteration 3161 / 4900) loss: 0.851499\n","(Iteration 3171 / 4900) loss: 0.850975\n","(Iteration 3181 / 4900) loss: 0.866312\n","(Iteration 3191 / 4900) loss: 0.933896\n","(Iteration 3201 / 4900) loss: 1.020499\n","(Iteration 3211 / 4900) loss: 1.093007\n","(Iteration 3221 / 4900) loss: 0.833706\n","(Iteration 3231 / 4900) loss: 1.116397\n","(Iteration 3241 / 4900) loss: 1.184797\n","(Iteration 3251 / 4900) loss: 0.949241\n","(Iteration 3261 / 4900) loss: 1.049187\n","(Iteration 3271 / 4900) loss: 0.942337\n","(Iteration 3281 / 4900) loss: 1.056283\n","(Iteration 3291 / 4900) loss: 0.811159\n","(Iteration 3301 / 4900) loss: 0.940805\n","(Iteration 3311 / 4900) loss: 1.161296\n","(Iteration 3321 / 4900) loss: 1.273830\n","(Iteration 3331 / 4900) loss: 0.926868\n","(Iteration 3341 / 4900) loss: 0.804802\n","(Iteration 3351 / 4900) loss: 0.852176\n","(Iteration 3361 / 4900) loss: 1.047651\n","(Iteration 3371 / 4900) loss: 1.011095\n","(Iteration 3381 / 4900) loss: 1.033925\n","(Iteration 3391 / 4900) loss: 0.943187\n","(Iteration 3401 / 4900) loss: 1.298445\n","(Iteration 3411 / 4900) loss: 0.978339\n","(Iteration 3421 / 4900) loss: 1.156638\n","(Epoch 7 / 10) train acc: 0.675000; val_acc: 0.516000\n","(Iteration 3431 / 4900) loss: 0.784228\n","(Iteration 3441 / 4900) loss: 0.888168\n","(Iteration 3451 / 4900) loss: 0.867599\n","(Iteration 3461 / 4900) loss: 0.939314\n","(Iteration 3471 / 4900) loss: 1.015661\n","(Iteration 3481 / 4900) loss: 1.007558\n","(Iteration 3491 / 4900) loss: 1.088391\n","(Iteration 3501 / 4900) loss: 1.211654\n","(Iteration 3511 / 4900) loss: 0.914022\n","(Iteration 3521 / 4900) loss: 1.271665\n","(Iteration 3531 / 4900) loss: 0.761867\n","(Iteration 3541 / 4900) loss: 1.207816\n","(Iteration 3551 / 4900) loss: 0.887021\n","(Iteration 3561 / 4900) loss: 0.978272\n","(Iteration 3571 / 4900) loss: 1.161030\n","(Iteration 3581 / 4900) loss: 0.985445\n","(Iteration 3591 / 4900) loss: 1.098804\n","(Iteration 3601 / 4900) loss: 1.042894\n","(Iteration 3611 / 4900) loss: 0.895796\n","(Iteration 3621 / 4900) loss: 1.059123\n","(Iteration 3631 / 4900) loss: 1.105150\n","(Iteration 3641 / 4900) loss: 0.775352\n","(Iteration 3651 / 4900) loss: 1.071802\n","(Iteration 3661 / 4900) loss: 1.033503\n","(Iteration 3671 / 4900) loss: 0.798189\n","(Iteration 3681 / 4900) loss: 0.986434\n","(Iteration 3691 / 4900) loss: 0.960958\n","(Iteration 3701 / 4900) loss: 1.024097\n","(Iteration 3711 / 4900) loss: 0.784506\n","(Iteration 3721 / 4900) loss: 1.146949\n","(Iteration 3731 / 4900) loss: 1.196155\n","(Iteration 3741 / 4900) loss: 0.922948\n","(Iteration 3751 / 4900) loss: 0.932648\n","(Iteration 3761 / 4900) loss: 1.018790\n","(Iteration 3771 / 4900) loss: 0.712774\n","(Iteration 3781 / 4900) loss: 0.921701\n","(Iteration 3791 / 4900) loss: 0.842938\n","(Iteration 3801 / 4900) loss: 0.953499\n","(Iteration 3811 / 4900) loss: 0.873134\n","(Iteration 3821 / 4900) loss: 0.964541\n","(Iteration 3831 / 4900) loss: 1.067527\n","(Iteration 3841 / 4900) loss: 0.944045\n","(Iteration 3851 / 4900) loss: 0.860601\n","(Iteration 3861 / 4900) loss: 0.821969\n","(Iteration 3871 / 4900) loss: 0.854967\n","(Iteration 3881 / 4900) loss: 0.939392\n","(Iteration 3891 / 4900) loss: 0.883353\n","(Iteration 3901 / 4900) loss: 1.012524\n","(Iteration 3911 / 4900) loss: 0.921773\n","(Epoch 8 / 10) train acc: 0.691000; val_acc: 0.487000\n","(Iteration 3921 / 4900) loss: 1.203533\n","(Iteration 3931 / 4900) loss: 0.732601\n","(Iteration 3941 / 4900) loss: 1.066212\n","(Iteration 3951 / 4900) loss: 0.861355\n","(Iteration 3961 / 4900) loss: 0.988237\n","(Iteration 3971 / 4900) loss: 0.922491\n","(Iteration 3981 / 4900) loss: 0.841166\n","(Iteration 3991 / 4900) loss: 0.844518\n","(Iteration 4001 / 4900) loss: 0.840149\n","(Iteration 4011 / 4900) loss: 1.082468\n","(Iteration 4021 / 4900) loss: 1.006765\n","(Iteration 4031 / 4900) loss: 0.907172\n","(Iteration 4041 / 4900) loss: 0.972924\n","(Iteration 4051 / 4900) loss: 1.097054\n","(Iteration 4061 / 4900) loss: 0.883276\n","(Iteration 4071 / 4900) loss: 0.753975\n","(Iteration 4081 / 4900) loss: 1.219068\n","(Iteration 4091 / 4900) loss: 0.908380\n","(Iteration 4101 / 4900) loss: 0.867000\n","(Iteration 4111 / 4900) loss: 0.994541\n","(Iteration 4121 / 4900) loss: 0.818457\n","(Iteration 4131 / 4900) loss: 1.070441\n","(Iteration 4141 / 4900) loss: 1.239789\n","(Iteration 4151 / 4900) loss: 0.831370\n","(Iteration 4161 / 4900) loss: 1.003257\n","(Iteration 4171 / 4900) loss: 0.881314\n","(Iteration 4181 / 4900) loss: 0.719141\n","(Iteration 4191 / 4900) loss: 0.809994\n","(Iteration 4201 / 4900) loss: 0.797394\n","(Iteration 4211 / 4900) loss: 0.801485\n","(Iteration 4221 / 4900) loss: 0.746250\n","(Iteration 4231 / 4900) loss: 0.942531\n","(Iteration 4241 / 4900) loss: 0.772844\n","(Iteration 4251 / 4900) loss: 1.050636\n","(Iteration 4261 / 4900) loss: 0.842176\n","(Iteration 4271 / 4900) loss: 0.704830\n","(Iteration 4281 / 4900) loss: 0.851969\n","(Iteration 4291 / 4900) loss: 1.221573\n","(Iteration 4301 / 4900) loss: 0.968453\n","(Iteration 4311 / 4900) loss: 1.259205\n","(Iteration 4321 / 4900) loss: 0.995193\n","(Iteration 4331 / 4900) loss: 0.709692\n","(Iteration 4341 / 4900) loss: 1.002365\n","(Iteration 4351 / 4900) loss: 0.711846\n","(Iteration 4361 / 4900) loss: 1.173266\n","(Iteration 4371 / 4900) loss: 1.045862\n","(Iteration 4381 / 4900) loss: 0.984029\n","(Iteration 4391 / 4900) loss: 0.657862\n","(Iteration 4401 / 4900) loss: 0.895612\n","(Epoch 9 / 10) train acc: 0.701000; val_acc: 0.519000\n","(Iteration 4411 / 4900) loss: 1.012735\n","(Iteration 4421 / 4900) loss: 1.460928\n","(Iteration 4431 / 4900) loss: 1.169121\n","(Iteration 4441 / 4900) loss: 0.838664\n","(Iteration 4451 / 4900) loss: 0.897038\n","(Iteration 4461 / 4900) loss: 1.224142\n","(Iteration 4471 / 4900) loss: 0.836418\n","(Iteration 4481 / 4900) loss: 0.829165\n","(Iteration 4491 / 4900) loss: 1.077875\n","(Iteration 4501 / 4900) loss: 0.795696\n","(Iteration 4511 / 4900) loss: 0.778884\n","(Iteration 4521 / 4900) loss: 0.919219\n","(Iteration 4531 / 4900) loss: 0.778504\n","(Iteration 4541 / 4900) loss: 0.824720\n","(Iteration 4551 / 4900) loss: 0.678611\n","(Iteration 4561 / 4900) loss: 1.072789\n","(Iteration 4571 / 4900) loss: 0.910130\n","(Iteration 4581 / 4900) loss: 0.668048\n","(Iteration 4591 / 4900) loss: 1.221047\n","(Iteration 4601 / 4900) loss: 0.863410\n","(Iteration 4611 / 4900) loss: 0.799853\n","(Iteration 4621 / 4900) loss: 0.994609\n","(Iteration 4631 / 4900) loss: 0.867978\n","(Iteration 4641 / 4900) loss: 1.133524\n","(Iteration 4651 / 4900) loss: 0.983666\n","(Iteration 4661 / 4900) loss: 0.790392\n","(Iteration 4671 / 4900) loss: 0.883797\n","(Iteration 4681 / 4900) loss: 0.888080\n","(Iteration 4691 / 4900) loss: 0.699139\n","(Iteration 4701 / 4900) loss: 0.776345\n","(Iteration 4711 / 4900) loss: 1.404183\n","(Iteration 4721 / 4900) loss: 0.739416\n","(Iteration 4731 / 4900) loss: 1.108771\n","(Iteration 4741 / 4900) loss: 0.766949\n","(Iteration 4751 / 4900) loss: 0.999734\n","(Iteration 4761 / 4900) loss: 1.040974\n","(Iteration 4771 / 4900) loss: 0.657338\n","(Iteration 4781 / 4900) loss: 0.666470\n","(Iteration 4791 / 4900) loss: 0.827265\n","(Iteration 4801 / 4900) loss: 0.834625\n","(Iteration 4811 / 4900) loss: 0.874540\n","(Iteration 4821 / 4900) loss: 0.954102\n","(Iteration 4831 / 4900) loss: 0.813793\n","(Iteration 4841 / 4900) loss: 0.852477\n","(Iteration 4851 / 4900) loss: 1.005504\n","(Iteration 4861 / 4900) loss: 0.777877\n","(Iteration 4871 / 4900) loss: 0.871678\n","(Iteration 4881 / 4900) loss: 0.666184\n","(Iteration 4891 / 4900) loss: 0.877278\n","(Epoch 10 / 10) train acc: 0.715000; val_acc: 0.542000\n","(Iteration 1 / 4900) loss: 2.302585\n","(Epoch 0 / 10) train acc: 0.106000; val_acc: 0.113000\n","(Iteration 11 / 4900) loss: 2.297750\n","(Iteration 21 / 4900) loss: 2.297418\n","(Iteration 31 / 4900) loss: 2.300119\n","(Iteration 41 / 4900) loss: 2.303611\n","(Iteration 51 / 4900) loss: 2.302477\n","(Iteration 61 / 4900) loss: 2.301947\n","(Iteration 71 / 4900) loss: 2.304556\n","(Iteration 81 / 4900) loss: 2.303872\n","(Iteration 91 / 4900) loss: 2.303625\n","(Iteration 101 / 4900) loss: 2.301520\n","(Iteration 111 / 4900) loss: 2.283426\n","(Iteration 121 / 4900) loss: 2.230587\n","(Iteration 131 / 4900) loss: 2.199997\n","(Iteration 141 / 4900) loss: 2.175144\n","(Iteration 151 / 4900) loss: 1.947712\n","(Iteration 161 / 4900) loss: 1.991864\n","(Iteration 171 / 4900) loss: 1.844870\n","(Iteration 181 / 4900) loss: 1.972484\n","(Iteration 191 / 4900) loss: 1.822108\n","(Iteration 201 / 4900) loss: 1.815416\n","(Iteration 211 / 4900) loss: 1.718172\n","(Iteration 221 / 4900) loss: 1.686438\n","(Iteration 231 / 4900) loss: 1.613926\n","(Iteration 241 / 4900) loss: 1.569863\n","(Iteration 251 / 4900) loss: 1.602211\n","(Iteration 261 / 4900) loss: 1.714237\n","(Iteration 271 / 4900) loss: 1.701645\n","(Iteration 281 / 4900) loss: 1.432707\n","(Iteration 291 / 4900) loss: 1.462269\n","(Iteration 301 / 4900) loss: 1.667703\n","(Iteration 311 / 4900) loss: 1.570736\n","(Iteration 321 / 4900) loss: 1.514155\n","(Iteration 331 / 4900) loss: 1.492700\n","(Iteration 341 / 4900) loss: 1.385210\n","(Iteration 351 / 4900) loss: 1.352352\n","(Iteration 361 / 4900) loss: 1.459621\n","(Iteration 371 / 4900) loss: 1.527168\n","(Iteration 381 / 4900) loss: 1.582616\n","(Iteration 391 / 4900) loss: 1.503816\n","(Iteration 401 / 4900) loss: 1.196360\n","(Iteration 411 / 4900) loss: 1.462505\n","(Iteration 421 / 4900) loss: 1.239884\n","(Iteration 431 / 4900) loss: 1.289749\n","(Iteration 441 / 4900) loss: 1.584375\n","(Iteration 451 / 4900) loss: 1.546796\n","(Iteration 461 / 4900) loss: 1.617739\n","(Iteration 471 / 4900) loss: 1.581688\n","(Iteration 481 / 4900) loss: 1.500580\n","(Epoch 1 / 10) train acc: 0.546000; val_acc: 0.486000\n","(Iteration 491 / 4900) loss: 1.574511\n","(Iteration 501 / 4900) loss: 1.351881\n","(Iteration 511 / 4900) loss: 1.302359\n","(Iteration 521 / 4900) loss: 1.312167\n","(Iteration 531 / 4900) loss: 1.426621\n","(Iteration 541 / 4900) loss: 1.498817\n","(Iteration 551 / 4900) loss: 1.452341\n","(Iteration 561 / 4900) loss: 1.417706\n","(Iteration 571 / 4900) loss: 1.371931\n","(Iteration 581 / 4900) loss: 1.368225\n","(Iteration 591 / 4900) loss: 1.261239\n","(Iteration 601 / 4900) loss: 1.184151\n","(Iteration 611 / 4900) loss: 1.476756\n","(Iteration 621 / 4900) loss: 1.496713\n","(Iteration 631 / 4900) loss: 1.293917\n","(Iteration 641 / 4900) loss: 1.205082\n","(Iteration 651 / 4900) loss: 1.560059\n","(Iteration 661 / 4900) loss: 1.619623\n","(Iteration 671 / 4900) loss: 1.543955\n","(Iteration 681 / 4900) loss: 1.505721\n","(Iteration 691 / 4900) loss: 1.114676\n","(Iteration 701 / 4900) loss: 1.359275\n","(Iteration 711 / 4900) loss: 1.443714\n","(Iteration 721 / 4900) loss: 1.261477\n","(Iteration 731 / 4900) loss: 1.385267\n","(Iteration 741 / 4900) loss: 1.134313\n","(Iteration 751 / 4900) loss: 1.280244\n","(Iteration 761 / 4900) loss: 1.451800\n","(Iteration 771 / 4900) loss: 1.314083\n","(Iteration 781 / 4900) loss: 1.349437\n","(Iteration 791 / 4900) loss: 1.472211\n","(Iteration 801 / 4900) loss: 1.358375\n","(Iteration 811 / 4900) loss: 1.318402\n","(Iteration 821 / 4900) loss: 1.298611\n","(Iteration 831 / 4900) loss: 1.342615\n","(Iteration 841 / 4900) loss: 1.273723\n","(Iteration 851 / 4900) loss: 1.370069\n","(Iteration 861 / 4900) loss: 1.224356\n","(Iteration 871 / 4900) loss: 1.127048\n","(Iteration 881 / 4900) loss: 1.296764\n","(Iteration 891 / 4900) loss: 1.555874\n","(Iteration 901 / 4900) loss: 1.371809\n","(Iteration 911 / 4900) loss: 1.186885\n","(Iteration 921 / 4900) loss: 1.186633\n","(Iteration 931 / 4900) loss: 1.365476\n","(Iteration 941 / 4900) loss: 1.145163\n","(Iteration 951 / 4900) loss: 1.278244\n","(Iteration 961 / 4900) loss: 1.192235\n","(Iteration 971 / 4900) loss: 1.357092\n","(Epoch 2 / 10) train acc: 0.582000; val_acc: 0.528000\n","(Iteration 981 / 4900) loss: 1.200561\n","(Iteration 991 / 4900) loss: 1.336785\n","(Iteration 1001 / 4900) loss: 1.204217\n","(Iteration 1011 / 4900) loss: 1.014924\n","(Iteration 1021 / 4900) loss: 1.014078\n","(Iteration 1031 / 4900) loss: 1.203833\n","(Iteration 1041 / 4900) loss: 1.163017\n","(Iteration 1051 / 4900) loss: 1.192229\n","(Iteration 1061 / 4900) loss: 1.274727\n","(Iteration 1071 / 4900) loss: 1.075048\n","(Iteration 1081 / 4900) loss: 1.209414\n","(Iteration 1091 / 4900) loss: 1.150000\n","(Iteration 1101 / 4900) loss: 1.578837\n","(Iteration 1111 / 4900) loss: 1.521098\n","(Iteration 1121 / 4900) loss: 1.256411\n","(Iteration 1131 / 4900) loss: 1.128966\n","(Iteration 1141 / 4900) loss: 1.114819\n","(Iteration 1151 / 4900) loss: 1.108434\n","(Iteration 1161 / 4900) loss: 1.248597\n","(Iteration 1171 / 4900) loss: 1.167236\n","(Iteration 1181 / 4900) loss: 1.141219\n","(Iteration 1191 / 4900) loss: 1.334698\n","(Iteration 1201 / 4900) loss: 1.226372\n","(Iteration 1211 / 4900) loss: 1.282764\n","(Iteration 1221 / 4900) loss: 1.125705\n","(Iteration 1231 / 4900) loss: 0.975202\n","(Iteration 1241 / 4900) loss: 1.190851\n","(Iteration 1251 / 4900) loss: 1.079208\n","(Iteration 1261 / 4900) loss: 1.138395\n","(Iteration 1271 / 4900) loss: 1.154210\n","(Iteration 1281 / 4900) loss: 1.184226\n","(Iteration 1291 / 4900) loss: 1.273473\n","(Iteration 1301 / 4900) loss: 1.113588\n","(Iteration 1311 / 4900) loss: 1.375412\n","(Iteration 1321 / 4900) loss: 0.885430\n","(Iteration 1331 / 4900) loss: 1.221927\n","(Iteration 1341 / 4900) loss: 1.285686\n","(Iteration 1351 / 4900) loss: 1.150047\n","(Iteration 1361 / 4900) loss: 1.209535\n","(Iteration 1371 / 4900) loss: 1.260350\n","(Iteration 1381 / 4900) loss: 1.300126\n","(Iteration 1391 / 4900) loss: 1.255276\n","(Iteration 1401 / 4900) loss: 1.002946\n","(Iteration 1411 / 4900) loss: 1.164000\n","(Iteration 1421 / 4900) loss: 1.138434\n","(Iteration 1431 / 4900) loss: 1.258307\n","(Iteration 1441 / 4900) loss: 1.085959\n","(Iteration 1451 / 4900) loss: 1.071406\n","(Iteration 1461 / 4900) loss: 1.170585\n","(Epoch 3 / 10) train acc: 0.596000; val_acc: 0.557000\n","(Iteration 1471 / 4900) loss: 1.807357\n","(Iteration 1481 / 4900) loss: 1.156935\n","(Iteration 1491 / 4900) loss: 1.274778\n","(Iteration 1501 / 4900) loss: 1.109876\n","(Iteration 1511 / 4900) loss: 1.041576\n","(Iteration 1521 / 4900) loss: 1.392966\n","(Iteration 1531 / 4900) loss: 0.907301\n","(Iteration 1541 / 4900) loss: 1.203449\n","(Iteration 1551 / 4900) loss: 1.442736\n","(Iteration 1561 / 4900) loss: 1.170878\n","(Iteration 1571 / 4900) loss: 1.283007\n","(Iteration 1581 / 4900) loss: 1.025156\n","(Iteration 1591 / 4900) loss: 1.176938\n","(Iteration 1601 / 4900) loss: 1.200515\n","(Iteration 1611 / 4900) loss: 1.167216\n","(Iteration 1621 / 4900) loss: 1.086374\n","(Iteration 1631 / 4900) loss: 1.098480\n","(Iteration 1641 / 4900) loss: 0.996477\n","(Iteration 1651 / 4900) loss: 1.157080\n","(Iteration 1661 / 4900) loss: 0.993279\n","(Iteration 1671 / 4900) loss: 1.203010\n","(Iteration 1681 / 4900) loss: 1.048247\n","(Iteration 1691 / 4900) loss: 1.105557\n","(Iteration 1701 / 4900) loss: 1.115771\n","(Iteration 1711 / 4900) loss: 1.278590\n","(Iteration 1721 / 4900) loss: 1.254009\n","(Iteration 1731 / 4900) loss: 1.252760\n","(Iteration 1741 / 4900) loss: 1.102443\n","(Iteration 1751 / 4900) loss: 1.166110\n","(Iteration 1761 / 4900) loss: 1.030084\n","(Iteration 1771 / 4900) loss: 1.104728\n","(Iteration 1781 / 4900) loss: 1.399057\n","(Iteration 1791 / 4900) loss: 1.040915\n","(Iteration 1801 / 4900) loss: 1.098653\n","(Iteration 1811 / 4900) loss: 1.238472\n","(Iteration 1821 / 4900) loss: 0.981387\n","(Iteration 1831 / 4900) loss: 1.075083\n","(Iteration 1841 / 4900) loss: 1.087556\n","(Iteration 1851 / 4900) loss: 0.857928\n","(Iteration 1861 / 4900) loss: 1.034118\n","(Iteration 1871 / 4900) loss: 1.178668\n","(Iteration 1881 / 4900) loss: 1.006994\n","(Iteration 1891 / 4900) loss: 1.115030\n","(Iteration 1901 / 4900) loss: 1.019054\n","(Iteration 1911 / 4900) loss: 0.887474\n","(Iteration 1921 / 4900) loss: 1.084133\n","(Iteration 1931 / 4900) loss: 1.109053\n","(Iteration 1941 / 4900) loss: 1.272600\n","(Iteration 1951 / 4900) loss: 1.172940\n","(Epoch 4 / 10) train acc: 0.593000; val_acc: 0.560000\n","(Iteration 1961 / 4900) loss: 0.996695\n","(Iteration 1971 / 4900) loss: 1.165149\n","(Iteration 1981 / 4900) loss: 1.067245\n","(Iteration 1991 / 4900) loss: 1.042422\n","(Iteration 2001 / 4900) loss: 1.278533\n","(Iteration 2011 / 4900) loss: 1.243492\n","(Iteration 2021 / 4900) loss: 1.131838\n","(Iteration 2031 / 4900) loss: 1.207490\n","(Iteration 2041 / 4900) loss: 1.001796\n","(Iteration 2051 / 4900) loss: 0.891822\n","(Iteration 2061 / 4900) loss: 1.091965\n","(Iteration 2071 / 4900) loss: 1.069043\n","(Iteration 2081 / 4900) loss: 1.101376\n","(Iteration 2091 / 4900) loss: 0.980011\n","(Iteration 2101 / 4900) loss: 1.274605\n","(Iteration 2111 / 4900) loss: 0.980636\n","(Iteration 2121 / 4900) loss: 1.215146\n","(Iteration 2131 / 4900) loss: 1.007288\n","(Iteration 2141 / 4900) loss: 0.964532\n","(Iteration 2151 / 4900) loss: 1.054850\n","(Iteration 2161 / 4900) loss: 1.098635\n","(Iteration 2171 / 4900) loss: 1.286419\n","(Iteration 2181 / 4900) loss: 1.095045\n","(Iteration 2191 / 4900) loss: 0.956925\n","(Iteration 2201 / 4900) loss: 1.065454\n","(Iteration 2211 / 4900) loss: 1.053224\n","(Iteration 2221 / 4900) loss: 1.070596\n","(Iteration 2231 / 4900) loss: 1.037123\n","(Iteration 2241 / 4900) loss: 1.084944\n","(Iteration 2251 / 4900) loss: 0.975042\n","(Iteration 2261 / 4900) loss: 1.132050\n","(Iteration 2271 / 4900) loss: 1.065921\n","(Iteration 2281 / 4900) loss: 0.999448\n","(Iteration 2291 / 4900) loss: 1.129715\n","(Iteration 2301 / 4900) loss: 1.172648\n","(Iteration 2311 / 4900) loss: 0.968608\n","(Iteration 2321 / 4900) loss: 0.904941\n","(Iteration 2331 / 4900) loss: 0.928516\n","(Iteration 2341 / 4900) loss: 1.021219\n","(Iteration 2351 / 4900) loss: 0.909787\n","(Iteration 2361 / 4900) loss: 0.994014\n","(Iteration 2371 / 4900) loss: 1.192265\n","(Iteration 2381 / 4900) loss: 1.077926\n","(Iteration 2391 / 4900) loss: 1.191606\n","(Iteration 2401 / 4900) loss: 0.985483\n","(Iteration 2411 / 4900) loss: 1.083330\n","(Iteration 2421 / 4900) loss: 0.942014\n","(Iteration 2431 / 4900) loss: 1.005791\n","(Iteration 2441 / 4900) loss: 1.104690\n","(Epoch 5 / 10) train acc: 0.608000; val_acc: 0.565000\n","(Iteration 2451 / 4900) loss: 1.176886\n","(Iteration 2461 / 4900) loss: 1.069717\n","(Iteration 2471 / 4900) loss: 0.928614\n","(Iteration 2481 / 4900) loss: 0.829417\n","(Iteration 2491 / 4900) loss: 0.989411\n","(Iteration 2501 / 4900) loss: 1.155044\n","(Iteration 2511 / 4900) loss: 0.974870\n","(Iteration 2521 / 4900) loss: 1.001734\n","(Iteration 2531 / 4900) loss: 0.852290\n","(Iteration 2541 / 4900) loss: 1.083126\n","(Iteration 2551 / 4900) loss: 0.885817\n","(Iteration 2561 / 4900) loss: 1.055104\n","(Iteration 2571 / 4900) loss: 0.978379\n","(Iteration 2581 / 4900) loss: 1.050851\n","(Iteration 2591 / 4900) loss: 0.928921\n","(Iteration 2601 / 4900) loss: 1.104118\n","(Iteration 2611 / 4900) loss: 0.926535\n","(Iteration 2621 / 4900) loss: 1.155894\n","(Iteration 2631 / 4900) loss: 1.104944\n","(Iteration 2641 / 4900) loss: 1.017889\n","(Iteration 2651 / 4900) loss: 0.984790\n","(Iteration 2661 / 4900) loss: 0.924905\n","(Iteration 2671 / 4900) loss: 0.899252\n","(Iteration 2681 / 4900) loss: 0.760515\n","(Iteration 2691 / 4900) loss: 1.101201\n","(Iteration 2701 / 4900) loss: 0.967295\n","(Iteration 2711 / 4900) loss: 1.077089\n","(Iteration 2721 / 4900) loss: 0.974613\n","(Iteration 2731 / 4900) loss: 0.904470\n","(Iteration 2741 / 4900) loss: 0.949339\n","(Iteration 2751 / 4900) loss: 1.005083\n","(Iteration 2761 / 4900) loss: 0.980734\n","(Iteration 2771 / 4900) loss: 1.071221\n","(Iteration 2781 / 4900) loss: 0.931970\n","(Iteration 2791 / 4900) loss: 0.942304\n","(Iteration 2801 / 4900) loss: 0.986024\n","(Iteration 2811 / 4900) loss: 0.905173\n","(Iteration 2821 / 4900) loss: 1.031732\n","(Iteration 2831 / 4900) loss: 1.019446\n","(Iteration 2841 / 4900) loss: 0.933070\n","(Iteration 2851 / 4900) loss: 1.000688\n","(Iteration 2861 / 4900) loss: 0.898376\n","(Iteration 2871 / 4900) loss: 0.846082\n","(Iteration 2881 / 4900) loss: 1.131550\n","(Iteration 2891 / 4900) loss: 0.851579\n","(Iteration 2901 / 4900) loss: 1.218808\n","(Iteration 2911 / 4900) loss: 0.979679\n","(Iteration 2921 / 4900) loss: 0.890612\n","(Iteration 2931 / 4900) loss: 0.807141\n","(Epoch 6 / 10) train acc: 0.668000; val_acc: 0.562000\n","(Iteration 2941 / 4900) loss: 0.748816\n","(Iteration 2951 / 4900) loss: 1.003530\n","(Iteration 2961 / 4900) loss: 0.899919\n","(Iteration 2971 / 4900) loss: 1.105462\n","(Iteration 2981 / 4900) loss: 1.150866\n","(Iteration 2991 / 4900) loss: 0.778755\n","(Iteration 3001 / 4900) loss: 1.006619\n","(Iteration 3011 / 4900) loss: 0.936762\n","(Iteration 3021 / 4900) loss: 1.166534\n","(Iteration 3031 / 4900) loss: 1.206389\n","(Iteration 3041 / 4900) loss: 0.953895\n","(Iteration 3051 / 4900) loss: 0.875178\n","(Iteration 3061 / 4900) loss: 1.187422\n","(Iteration 3071 / 4900) loss: 1.254807\n","(Iteration 3081 / 4900) loss: 1.046484\n","(Iteration 3091 / 4900) loss: 1.040951\n","(Iteration 3101 / 4900) loss: 1.193038\n","(Iteration 3111 / 4900) loss: 0.957659\n","(Iteration 3121 / 4900) loss: 0.948969\n","(Iteration 3131 / 4900) loss: 0.963846\n","(Iteration 3141 / 4900) loss: 1.047817\n","(Iteration 3151 / 4900) loss: 0.997079\n","(Iteration 3161 / 4900) loss: 1.064255\n","(Iteration 3171 / 4900) loss: 0.913153\n","(Iteration 3181 / 4900) loss: 0.953593\n","(Iteration 3191 / 4900) loss: 0.829529\n","(Iteration 3201 / 4900) loss: 0.954236\n","(Iteration 3211 / 4900) loss: 1.100069\n","(Iteration 3221 / 4900) loss: 0.769120\n","(Iteration 3231 / 4900) loss: 0.727250\n","(Iteration 3241 / 4900) loss: 1.268292\n","(Iteration 3251 / 4900) loss: 1.107480\n","(Iteration 3261 / 4900) loss: 1.099172\n","(Iteration 3271 / 4900) loss: 0.966126\n","(Iteration 3281 / 4900) loss: 1.100230\n","(Iteration 3291 / 4900) loss: 0.900619\n","(Iteration 3301 / 4900) loss: 0.905609\n","(Iteration 3311 / 4900) loss: 1.122037\n","(Iteration 3321 / 4900) loss: 0.916946\n","(Iteration 3331 / 4900) loss: 0.887950\n","(Iteration 3341 / 4900) loss: 0.847493\n","(Iteration 3351 / 4900) loss: 0.929751\n","(Iteration 3361 / 4900) loss: 0.682920\n","(Iteration 3371 / 4900) loss: 1.027104\n","(Iteration 3381 / 4900) loss: 0.929814\n","(Iteration 3391 / 4900) loss: 1.050417\n","(Iteration 3401 / 4900) loss: 0.880570\n","(Iteration 3411 / 4900) loss: 0.936880\n","(Iteration 3421 / 4900) loss: 1.022895\n","(Epoch 7 / 10) train acc: 0.636000; val_acc: 0.567000\n","(Iteration 3431 / 4900) loss: 1.052243\n","(Iteration 3441 / 4900) loss: 0.883590\n","(Iteration 3451 / 4900) loss: 0.955641\n","(Iteration 3461 / 4900) loss: 0.899804\n","(Iteration 3471 / 4900) loss: 0.798550\n","(Iteration 3481 / 4900) loss: 0.872555\n","(Iteration 3491 / 4900) loss: 1.066082\n","(Iteration 3501 / 4900) loss: 0.854852\n","(Iteration 3511 / 4900) loss: 0.764248\n","(Iteration 3521 / 4900) loss: 0.858748\n","(Iteration 3531 / 4900) loss: 0.851511\n","(Iteration 3541 / 4900) loss: 0.819329\n","(Iteration 3551 / 4900) loss: 1.005273\n","(Iteration 3561 / 4900) loss: 0.755658\n","(Iteration 3571 / 4900) loss: 0.802949\n","(Iteration 3581 / 4900) loss: 1.026467\n","(Iteration 3591 / 4900) loss: 1.149289\n","(Iteration 3601 / 4900) loss: 1.099470\n","(Iteration 3611 / 4900) loss: 1.026505\n","(Iteration 3621 / 4900) loss: 0.865482\n","(Iteration 3631 / 4900) loss: 0.887875\n","(Iteration 3641 / 4900) loss: 0.832347\n","(Iteration 3651 / 4900) loss: 0.838793\n","(Iteration 3661 / 4900) loss: 0.852081\n","(Iteration 3671 / 4900) loss: 0.825376\n","(Iteration 3681 / 4900) loss: 0.837537\n","(Iteration 3691 / 4900) loss: 0.932940\n","(Iteration 3701 / 4900) loss: 0.976670\n","(Iteration 3711 / 4900) loss: 0.901494\n","(Iteration 3721 / 4900) loss: 1.087673\n","(Iteration 3731 / 4900) loss: 0.965325\n","(Iteration 3741 / 4900) loss: 1.126563\n","(Iteration 3751 / 4900) loss: 1.039338\n","(Iteration 3761 / 4900) loss: 0.913534\n","(Iteration 3771 / 4900) loss: 0.835392\n","(Iteration 3781 / 4900) loss: 1.089209\n","(Iteration 3791 / 4900) loss: 1.091958\n","(Iteration 3801 / 4900) loss: 0.913485\n","(Iteration 3811 / 4900) loss: 1.047623\n","(Iteration 3821 / 4900) loss: 0.947915\n","(Iteration 3831 / 4900) loss: 0.955521\n","(Iteration 3841 / 4900) loss: 0.988330\n","(Iteration 3851 / 4900) loss: 0.792701\n","(Iteration 3861 / 4900) loss: 0.999022\n","(Iteration 3871 / 4900) loss: 0.801205\n","(Iteration 3881 / 4900) loss: 0.856234\n","(Iteration 3891 / 4900) loss: 0.969127\n","(Iteration 3901 / 4900) loss: 0.873537\n","(Iteration 3911 / 4900) loss: 1.049571\n","(Epoch 8 / 10) train acc: 0.690000; val_acc: 0.575000\n","(Iteration 3921 / 4900) loss: 0.702704\n","(Iteration 3931 / 4900) loss: 0.867040\n","(Iteration 3941 / 4900) loss: 0.933232\n","(Iteration 3951 / 4900) loss: 0.935807\n","(Iteration 3961 / 4900) loss: 0.953686\n","(Iteration 3971 / 4900) loss: 0.652283\n","(Iteration 3981 / 4900) loss: 0.934395\n","(Iteration 3991 / 4900) loss: 0.998425\n","(Iteration 4001 / 4900) loss: 0.632845\n","(Iteration 4011 / 4900) loss: 0.780221\n","(Iteration 4021 / 4900) loss: 0.956166\n","(Iteration 4031 / 4900) loss: 0.879103\n","(Iteration 4041 / 4900) loss: 1.091611\n","(Iteration 4051 / 4900) loss: 0.949943\n","(Iteration 4061 / 4900) loss: 0.830600\n","(Iteration 4071 / 4900) loss: 0.875219\n","(Iteration 4081 / 4900) loss: 0.869935\n","(Iteration 4091 / 4900) loss: 0.903511\n","(Iteration 4101 / 4900) loss: 0.974792\n","(Iteration 4111 / 4900) loss: 1.019850\n","(Iteration 4121 / 4900) loss: 0.983544\n","(Iteration 4131 / 4900) loss: 0.857450\n","(Iteration 4141 / 4900) loss: 0.978004\n","(Iteration 4151 / 4900) loss: 1.063156\n","(Iteration 4161 / 4900) loss: 0.949402\n","(Iteration 4171 / 4900) loss: 0.914619\n","(Iteration 4181 / 4900) loss: 0.810732\n","(Iteration 4191 / 4900) loss: 0.930372\n","(Iteration 4201 / 4900) loss: 0.851269\n","(Iteration 4211 / 4900) loss: 0.601585\n","(Iteration 4221 / 4900) loss: 0.970555\n","(Iteration 4231 / 4900) loss: 0.797553\n","(Iteration 4241 / 4900) loss: 0.910267\n","(Iteration 4251 / 4900) loss: 1.183376\n","(Iteration 4261 / 4900) loss: 1.083397\n","(Iteration 4271 / 4900) loss: 1.129242\n","(Iteration 4281 / 4900) loss: 1.054659\n","(Iteration 4291 / 4900) loss: 0.984466\n","(Iteration 4301 / 4900) loss: 0.978595\n","(Iteration 4311 / 4900) loss: 0.937837\n","(Iteration 4321 / 4900) loss: 0.955614\n","(Iteration 4331 / 4900) loss: 0.713065\n","(Iteration 4341 / 4900) loss: 0.932628\n","(Iteration 4351 / 4900) loss: 0.730388\n","(Iteration 4361 / 4900) loss: 1.016892\n","(Iteration 4371 / 4900) loss: 0.986692\n","(Iteration 4381 / 4900) loss: 0.837868\n","(Iteration 4391 / 4900) loss: 0.875616\n","(Iteration 4401 / 4900) loss: 0.926992\n","(Epoch 9 / 10) train acc: 0.655000; val_acc: 0.556000\n","(Iteration 4411 / 4900) loss: 0.888510\n","(Iteration 4421 / 4900) loss: 0.906618\n","(Iteration 4431 / 4900) loss: 0.981256\n","(Iteration 4441 / 4900) loss: 0.930284\n","(Iteration 4451 / 4900) loss: 1.079477\n","(Iteration 4461 / 4900) loss: 0.798248\n","(Iteration 4471 / 4900) loss: 0.902723\n","(Iteration 4481 / 4900) loss: 0.880556\n","(Iteration 4491 / 4900) loss: 0.908696\n","(Iteration 4501 / 4900) loss: 0.814892\n","(Iteration 4511 / 4900) loss: 1.058815\n","(Iteration 4521 / 4900) loss: 0.866170\n","(Iteration 4531 / 4900) loss: 0.696750\n","(Iteration 4541 / 4900) loss: 0.915396\n","(Iteration 4551 / 4900) loss: 0.947022\n","(Iteration 4561 / 4900) loss: 0.762161\n","(Iteration 4571 / 4900) loss: 0.926535\n","(Iteration 4581 / 4900) loss: 0.592031\n","(Iteration 4591 / 4900) loss: 0.780835\n","(Iteration 4601 / 4900) loss: 0.756010\n","(Iteration 4611 / 4900) loss: 0.942583\n","(Iteration 4621 / 4900) loss: 0.839878\n","(Iteration 4631 / 4900) loss: 0.787663\n","(Iteration 4641 / 4900) loss: 0.846172\n","(Iteration 4651 / 4900) loss: 0.823523\n","(Iteration 4661 / 4900) loss: 1.067864\n","(Iteration 4671 / 4900) loss: 1.070950\n","(Iteration 4681 / 4900) loss: 0.831854\n","(Iteration 4691 / 4900) loss: 0.861830\n","(Iteration 4701 / 4900) loss: 0.809401\n","(Iteration 4711 / 4900) loss: 0.849572\n","(Iteration 4721 / 4900) loss: 0.956230\n","(Iteration 4731 / 4900) loss: 0.860959\n","(Iteration 4741 / 4900) loss: 0.986905\n","(Iteration 4751 / 4900) loss: 0.847808\n","(Iteration 4761 / 4900) loss: 1.155434\n","(Iteration 4771 / 4900) loss: 0.922708\n","(Iteration 4781 / 4900) loss: 0.652293\n","(Iteration 4791 / 4900) loss: 0.961775\n","(Iteration 4801 / 4900) loss: 1.082421\n","(Iteration 4811 / 4900) loss: 0.830886\n","(Iteration 4821 / 4900) loss: 0.882242\n","(Iteration 4831 / 4900) loss: 0.824267\n","(Iteration 4841 / 4900) loss: 0.777541\n","(Iteration 4851 / 4900) loss: 0.968854\n","(Iteration 4861 / 4900) loss: 0.888614\n","(Iteration 4871 / 4900) loss: 1.013597\n","(Iteration 4881 / 4900) loss: 0.950407\n","(Iteration 4891 / 4900) loss: 0.824410\n","(Epoch 10 / 10) train acc: 0.689000; val_acc: 0.560000\n","lr 1.000000e-09 reg 5.000000e+04 train accuracy: 0.096959 val accuracy: 0.095000\n","lr 1.000000e-09 reg 5.000000e+05 train accuracy: 0.096959 val accuracy: 0.095000\n","lr 1.000000e-09 reg 5.000000e+06 train accuracy: 0.099735 val accuracy: 0.113000\n","lr 1.000000e-08 reg 5.000000e+04 train accuracy: 0.099735 val accuracy: 0.113000\n","lr 1.000000e-08 reg 5.000000e+05 train accuracy: 0.099735 val accuracy: 0.113000\n","lr 1.000000e-08 reg 5.000000e+06 train accuracy: 0.099857 val accuracy: 0.107000\n","lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.099857 val accuracy: 0.107000\n","lr 1.000000e-07 reg 5.000000e+05 train accuracy: 0.099857 val accuracy: 0.107000\n","lr 1.000000e-07 reg 5.000000e+06 train accuracy: 0.099612 val accuracy: 0.119000\n","lr 1.039440e-01 reg 9.782550e-05 train accuracy: 0.640184 val accuracy: 0.595000\n","lr 1.064383e-01 reg 1.890825e-06 train accuracy: 0.612714 val accuracy: 0.586000\n","lr 1.314940e-01 reg 3.743959e-06 train accuracy: 0.680980 val accuracy: 0.585000\n","lr 1.791904e-01 reg 6.544518e-07 train accuracy: 0.648184 val accuracy: 0.587000\n","lr 2.080139e-01 reg 3.739249e-05 train accuracy: 0.646980 val accuracy: 0.583000\n","lr 2.104739e-01 reg 3.765365e-06 train accuracy: 0.665939 val accuracy: 0.573000\n","lr 2.300052e-01 reg 8.410907e-05 train accuracy: 0.659082 val accuracy: 0.576000\n","lr 2.362300e-01 reg 2.366650e-07 train accuracy: 0.679449 val accuracy: 0.583000\n","lr 2.560389e-01 reg 1.253648e-06 train accuracy: 0.680388 val accuracy: 0.575000\n","lr 2.850206e-01 reg 7.821922e-05 train accuracy: 0.641163 val accuracy: 0.591000\n","lr 3.087267e-01 reg 4.449649e-06 train accuracy: 0.630469 val accuracy: 0.575000\n","lr 3.112935e-01 reg 2.766987e-07 train accuracy: 0.639102 val accuracy: 0.566000\n","lr 3.295539e-01 reg 9.728124e-05 train accuracy: 0.753041 val accuracy: 0.580000\n","lr 3.615875e-01 reg 3.078794e-06 train accuracy: 0.666204 val accuracy: 0.571000\n","lr 4.566665e-01 reg 3.251052e-05 train accuracy: 0.664408 val accuracy: 0.559000\n","lr 5.782595e-01 reg 9.814474e-07 train accuracy: 0.679755 val accuracy: 0.567000\n","lr 7.421997e-01 reg 3.890198e-06 train accuracy: 0.673184 val accuracy: 0.566000\n","lr 7.727114e-01 reg 3.002425e-07 train accuracy: 0.685796 val accuracy: 0.564000\n","lr 8.564668e-01 reg 3.758493e-05 train accuracy: 0.625061 val accuracy: 0.548000\n","lr 9.209465e-01 reg 1.867254e-05 train accuracy: 0.617286 val accuracy: 0.543000\n","best validation accuracy achieved during cross-validation: 0.595000\n"]}],"source":["from cs231n.classifiers.fc_net import TwoLayerNet\n","from cs231n.solver import Solver\n","\n","input_dim = X_train_feats.shape[1]\n","hidden_dim = 500\n","num_classes = 10\n","\n","# net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n","best_net = None\n","\n","################################################################################\n","# TODO: Train a two-layer neural network on image features. You may want to    #\n","# cross-validate various parameters as in previous sections. Store your best   #\n","# model in the best_net variable.                                              #\n","################################################################################\n","# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","# learning_rates = [1e-9, 1e-8, 1e-7]\n","# regularization_strengths = [5e4, 5e5, 5e6]\n","\n","# grid_search = [(lr, reg) for lr in learning_rates \\\n","#                for reg in regularization_strengths]\n","# print(grid_search)\n","\n","def generate_random_hyperparams(lr_min, lr_max, reg_min, reg_max, h_min, h_max):\n","  lr = 10 ** np.random.uniform(lr_min, lr_max)\n","  reg = 10 ** np.random.uniform(reg_min, reg_max)\n","  hidden = np.random.randint(h_min, h_max)\n","  return lr, reg, hidden\n","\n","data = {\"X_train\": X_train_feats, \"y_train\": y_train,\n","        \"X_val\": X_val_feats, \"y_val\": y_val}\n","\n","for i in range(20):\n","    # lr, reg = config\n","    # net.reg = reg\n","    lr, reg, hidden_dim = generate_random_hyperparams(-1, 0, -7, -4, 10, 500)\n","    \n","    net = TwoLayerNet(input_dim, hidden_dim, num_classes, reg)\n","    \n","    solver = Solver(net, data, update_rule='sgd',\n","                    optim_config={'learning_rate': lr})\n","    solver.train()\n","\n","    # Train accuracy\n","    train_accuracy = solver.check_accuracy(data['X_train'], data['y_train'])\n","    \n","    # Validation accuracy\n","    val_accuracy = solver.check_accuracy(data['X_val'], data['y_val'])\n","\n","    \n","    results[lr,reg] = (train_accuracy,val_accuracy)\n","\n","    if val_accuracy > best_val:\n","      best_val = val_accuracy\n","      best_net = net\n","\n","# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","# Print out results.\n","for lr, reg in sorted(results):\n","    train_accuracy, val_accuracy = results[(lr, reg)]\n","    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n","                lr, reg, train_accuracy, val_accuracy))\n","    \n","print('best validation accuracy achieved during cross-validation: %f' % best_val)"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"nn_test_accuracy","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642144155637,"user_tz":-120,"elapsed":314,"user":{"displayName":"timu vlad","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GhFgmHxRAgWg4Qlv_Kn9Lgy4_RMwRdMZqFvcnPc=s64","userId":"08663526354782394137"}},"outputId":"b5d77d1b-7e85-47cf-d5f9-30fe4634c2ff"},"outputs":[{"output_type":"stream","name":"stdout","text":["0.57\n"]}],"source":["# Run your best neural net classifier on the test set. You should be able\n","# to get more than 55% accuracy.\n","\n","test_acc = solver.check_accuracy(X_test_feats, y_test)\n","print(test_acc)"]}],"metadata":{"colab":{"name":"features.ipynb","provenance":[],"collapsed_sections":[]},"language_info":{"name":"python"},"kernelspec":{"name":"python3","display_name":"Python 3"}},"nbformat":4,"nbformat_minor":0}