In [1]:

    

%pwd


    

    
Out[1]:





u'/yandexsdc/notebooks'

In [2]:

    

import re
import os
import cv2
import time
import glob
import numpy as np
import tensorflow as tf
from tensorflow.python.client import timeline
import matplotlib.pyplot as plt

%matplotlib inline


    

In [3]:

    

ft3d_path = '../datasets/FlyingThings3D'
ft3d_samples_filenames = {}
for prefix in ["TRAIN", "TEST"]:
    ft3d_train_data_path = os.path.join(ft3d_path, 'frames_cleanpass/TRAIN')
    ft3d_train_labels_path = os.path.join(ft3d_path, 'disparity/TRAIN')
    left_images_filenames = sorted(glob.glob(ft3d_train_data_path + "/*/*/left/*"))
    right_images_filenames = sorted(glob.glob(ft3d_train_data_path + "/*/*/right/*"))
    disparity_filenames = sorted(glob.glob(ft3d_train_labels_path + "/*/*/left/*"))

    ft3d_samples_filenames[prefix] = [(left_images_filenames[i],
                                       right_images_filenames[i],
                                       disparity_filenames[i]) for i in range(len(left_images_filenames))]


    

In [4]:

    

#https://lmb.informatik.uni-freiburg.de/resources/datasets/SceneFlow/assets/code/python_pfm.py

def readPFM(file):
    file = open(file, 'rb')

    color = None
    width = None
    height = None
    scale = None
    endian = None

    header = file.readline().rstrip()
    if header == 'PF':
        color = True
    elif header == 'Pf':
        color = False
    else:
        raise Exception('Not a PFM file.')

    dim_match = re.match(r'^(\d+)\s(\d+)\s$', file.readline())
    if dim_match:
        width, height = map(int, dim_match.groups())
    else:
        raise Exception('Malformed PFM header.')

    scale = float(file.readline().rstrip())
    if scale < 0: # little-endian
        endian = '<'
        scale = -scale
    else:
        endian = '>' # big-endian

    data = np.fromfile(file, endian + 'f')
    shape = (height, width, 3) if color else (height, width)

    data = np.reshape(data, shape)
    data = np.flipud(data)
    return data#, scale


    

In [5]:

    

def viz_sample(i):
    left_img = cv2.imread(left_images_filenames[i])
    right_img = cv2.imread(right_images_filenames[i])
    disparity = readPFM(disparity_filenames[i])
    plt.figure(figsize=(30,30))
    plt.subplot(131)
    plt.imshow(left_img)
    plt.subplot(132)
    plt.imshow(right_img)
    plt.subplot(133)
    plt.imshow(disparity)
    plt.show()


    

In [6]:

    

i = np.random.randint(len(left_images_filenames))
viz_sample(i)


    

In [7]:

    

batch_size = 4
n_channels = 3
height = 384
orig_width = 960
width = 768


    

In [77]:

    

def preprocess(left_img, right_img, target):
    left_img = tf.image.convert_image_dtype(left_img, tf.float32)
    mean = tf.reduce_mean(left_img)
    left_img = left_img - mean
    right_img = tf.image.convert_image_dtype(right_img, tf.float32)
    right_img = right_img - mean
    left_img = tf.image.resize_bilinear(left_img[np.newaxis, :, :, :], [height, width])[0]
    right_img = tf.image.resize_bilinear(right_img[np.newaxis, :, :, :], [height, width])[0]
    target = tf.image.resize_nearest_neighbor(target[np.newaxis, :, :, np.newaxis], [height, width])[0]
    target = target * width / float(orig_width)
    left_img.set_shape([height, width, n_channels])
    right_img.set_shape([height, width, n_channels])
    target.set_shape([height, width, 1])
    return left_img, right_img, target


    

In [73]:

    

def read_sample(filename_queue):
    filenames = filename_queue.dequeue()
    left_fn, right_fn, disp_fn = filenames[0], filenames[1], filenames[2]
    left_img = tf.image.decode_image(tf.read_file(left_fn))
    right_img = tf.image.decode_image(tf.read_file(right_fn))
    target = tf.py_func(readPFM, [disp_fn], tf.float32)
    left_img, right_img, target = preprocess(left_img, right_img, target)
    return left_img, right_img, target

def input_pipeline(filenames, batch_size, num_epochs=None):
    filename_queue = tf.train.input_producer(
        filenames, element_shape = [3], num_epochs=num_epochs, shuffle=True)
    left_image, right_image, target = read_sample(filename_queue)
    min_after_dequeue = 100
    capacity = min_after_dequeue + 3 * batch_size
    left_image_batch, right_image_batch, target_batch = tf.train.shuffle_batch(
        [left_image, right_image, target], batch_size=batch_size, capacity=capacity,
        min_after_dequeue=min_after_dequeue)
    return left_image_batch, right_image_batch, target_batch


    

In [74]:

    

def correlation_map(x, y, max_disp):
    corr_tensors = []
    for i in range(-max_disp, 0, 1):
        shifted = tf.pad(tf.slice(y, [0, 0, -i, 0], [-1]*4),
                                  [[0, 0], [0, 0], [-i, 0], [0, 0]], "CONSTANT")
        corr = tf.reduce_mean(tf.multiply(shifted, y), axis=3)
        corr_tensors.append(corr)
    for i in range(max_disp + 1):
        shifted = tf.pad(tf.slice(y, [0]*4, [-1, -1, y.shape[2].value - i, -1]),
                                  [[0, 0], [0, 0], [0, i], [0, 0]], "CONSTANT")
        corr = tf.reduce_mean(tf.multiply(shifted, y), axis=3)
        corr_tensors.append(corr)
    return tf.transpose(tf.stack(corr_tensors),
                        perm=[1,2,3,0])


    

In [11]:

    

shift_corr_module = tf.load_op_library('../tensorflow-1.1.0-rc2/tensorflow/core/user_ops/shift_corr.so')

def correlation(x, y, max_disp):
    x = tf.pad(x, [[0, 0], [0, 0], [max_disp, max_disp], [0, 0]], "CONSTANT")
    y = tf.pad(y, [[0, 0], [0, 0], [max_disp, max_disp], [0, 0]], "CONSTANT")
    corr = shift_corr_module.shift_corr(x, y, max_disp=max_disp)
    return tf.transpose(corr, perm=[0, 2, 3, 1])


    

In [ ]:

    

@tf.RegisterGradient("ShiftCorr")
def _ShiftCorrOpGrad(op, grad):
    return shift_corr_module.shift_corr_grad(op.inputs[0], op.inputs[1], grad, max_disp=max_disp)


    

In [99]:

    

leaky_alpha = 0.1
max_disp=40

initializer = tf.contrib.layers.xavier_initializer_conv2d(uniform=False)

def conv2d(x, kernel_shape, strides=1, relu=True, padding='SAME'):
    W = tf.get_variable("weights", kernel_shape, initializer=initializer)
    b = tf.get_variable("biases", kernel_shape[3], initializer=tf.constant_initializer(0.0))
    with tf.name_scope("conv"):
        x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding=padding)
        x = tf.nn.bias_add(x, b)
        tf.summary.histogram("W", W)
        tf.summary.histogram("b", b)
        if kernel_shape[2] == 3:
            x_min = tf.reduce_min(W)
            x_max = tf.reduce_max(W)
            kernel_0_to_1 = (W - x_min) / (x_max - x_min)
            kernel_transposed = tf.transpose (kernel_0_to_1, [3, 0, 1, 2])
            tf.summary.image('filters', kernel_transposed, max_outputs=3)       
        if relu : x = tf.maximum(leaky_alpha * x, x)
    return x

def conv2d_transpose(x, kernel_shape, strides=1, relu=True):
    W = tf.get_variable("weights", kernel_shape, initializer=initializer)
    b = tf.get_variable("biases", kernel_shape[2], initializer=tf.constant_initializer(0.0))
    output_shape = [batch_size,
                    x.get_shape()[1].value*strides, x.get_shape()[2].value*strides, kernel_shape[2]]
    with tf.name_scope("deconv"):
        x = tf.nn.conv2d_transpose(x, W, output_shape, strides=[1, strides, strides, 1],
                                   padding='SAME')
        x = tf.nn.bias_add(x, b)
        if relu : x = tf.maximum(leaky_alpha * x, x)
    return x

def upsampling_block(bottom, skip_connection, input_channels, output_channels, skip_input_channels):
    with tf.variable_scope("deconv"):
        deconv = conv2d_transpose(bottom, [4, 4, output_channels, input_channels], strides=2)
    with tf.variable_scope("predict"):
        predict = conv2d(bottom, [3, 3, input_channels, 1], strides=1, relu=False)
        tf.summary.histogram("predict", predict)
    with tf.variable_scope("up_predict"):
        upsampled_predict = conv2d_transpose(predict, [4, 4, 1, 1], strides=2, relu=False)
    with tf.variable_scope("concat"):
        concat = conv2d(tf.concat([skip_connection, deconv, upsampled_predict], axis=3),
                        [3, 3, output_channels + skip_input_channels + 1, output_channels],
                        strides=1, relu=False)
    return concat, predict
    

def disp_net(left_image_batch, right_image_batch):
    with tf.variable_scope("conv1") as scope:
        conv1a = conv2d(left_image_batch, [7, 7, 3, 64], strides=2)
        scope.reuse_variables()
        conv1b = conv2d(right_image_batch, [7, 7, 3, 64], strides=2)
    with tf.variable_scope("conv2") as scope:
        conv2a = conv2d(conv1a, [5, 5, 64, 128], strides=2)
        scope.reuse_variables()
        conv2b = conv2d(conv1b, [5, 5, 64, 128], strides=2)
    with tf.variable_scope("conv_redir"):
        conv_redir = conv2d(conv2a, [1, 1, 128, 64], strides=1)
    with tf.name_scope("correlation"):
        corr = correlation_map(conv2a, conv2b, max_disp=max_disp)
    with tf.variable_scope("conv3"):
        conv3 = conv2d(tf.concat([corr, conv_redir], axis=3), [5, 5, 145, 256], strides=2)
        with tf.variable_scope("1"):
            conv3_1 = conv2d(conv3, [3, 3, 256, 256], strides=1)
    with tf.variable_scope("conv4"):
        conv4 = conv2d(conv3_1, [3, 3, 256, 512], strides=2)
        with tf.variable_scope("1"):
            conv4_1 = conv2d(conv4, [3, 3, 512, 512], strides=1)
    with tf.variable_scope("conv5"):
        conv5 = conv2d(conv4_1, [3, 3, 512, 512], strides=2)
        with tf.variable_scope("1"):
            conv5_1 = conv2d(conv5, [3, 3, 512, 512], strides=1)
    with tf.variable_scope("conv6"):
        conv6 = conv2d(conv5_1, [3, 3, 512, 1024], strides=2)
        with tf.variable_scope("1"):
            conv6_1 = conv2d(conv6, [3, 3, 1024, 1024], strides=1)
    with tf.variable_scope("up5"):
        concat5, predict6 = upsampling_block(conv6_1, conv5_1, 1024, 512, 512)
    with tf.variable_scope("up4"):
        concat4, predict5 = upsampling_block(concat5, conv4_1, 512, 256, 512)
    with tf.variable_scope("up3"):
        concat3, predict4 = upsampling_block(concat4, conv3_1, 256, 128, 256)
    with tf.variable_scope("up2"):
        concat2, predict3 = upsampling_block(concat3, conv2a, 128, 64, 128)
    with tf.variable_scope("up1"):
        concat1, predict2 = upsampling_block(concat2, conv1a, 64, 32, 64)
    with tf.variable_scope("prediction"):
        predict1 = conv2d(concat1, [3, 3, 32, 1], strides=1, relu=False)
    return (predict1, predict2, predict3,
            predict4, predict5, predict6)


    

In [120]:

    

tf.reset_default_graph()

graph = tf.Graph()

def L1_loss(x, y):
    return tf.reduce_mean(tf.abs(x - y))

with graph.as_default():
    
    loss_weights = tf.placeholder(tf.float32, shape=(6),
                                  name="loss_weights")
    learning_rate = tf.placeholder(tf.float32, shape=(), name="learning_rate")
    beta1 = tf.placeholder_with_default(shape=(), name="beta1", input=0.9)
    beta2 = tf.placeholder_with_default(shape=(), name="beta2", input=0.99)
    
    training_mode = tf.placeholder_with_default(shape=(), input=True)
    
    train_pipeline = input_pipeline(ft3d_samples_filenames["TRAIN"],
                                    batch_size=batch_size, num_epochs=None)
    
    val_pipeline = input_pipeline(ft3d_samples_filenames["TEST"], batch_size=batch_size, num_epochs=None)
    
    left_image_batch, right_image_batch, target = tf.cond(training_mode,
                                                          lambda: train_pipeline,
                                                          lambda: val_pipeline)
    
    predictions = disp_net(left_image_batch, right_image_batch)
    
    with tf.name_scope("loss"):
        targets = [tf.image.resize_nearest_neighbor(target, [height / np.power(2, n),
                                                         width / np.power(2, n)])
                   for n in range(1, 7)]
        losses = [L1_loss(targets[i], predictions[i]) for i in range(6)]
        for i in range(6):
            tf.summary.scalar('loss' + str(i), losses[i])
            tf.summary.scalar('loss_weight' + str(i), loss_weights[i])
        loss = tf.add_n([losses[i]*loss_weights[i] for i in range(6)])
        tf.summary.scalar('loss', loss)

    tf.summary.image("left", tf.slice(left_image_batch, [0, 0, 0, 0], [1, -1, -1, -1]))
    tf.summary.image("right", tf.slice(right_image_batch, [0, 0, 0, 0], [1, -1, -1, -1]))
    for i in range(6):
        tf.summary.image("disp" + str(i), tf.slice(predictions[i], [0, 0, 0, 0], [1, -1, -1, -1]))
        tf.summary.image("target" + str(i), tf.slice(targets[i], [0, 0, 0, 0], [1, -1, -1, -1]))
    
    with tf.name_scope("error"):
        error = L1_loss(targets[0], predictions[0])
        tf.summary.scalar("error", error)
        
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=beta1, beta2=beta2)
    train_step = optimizer.minimize(loss)

    init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())

    mean_loss = tf.placeholder(tf.float32)
    tf.summary.scalar('mean_loss', mean_loss)

    merged_summary = tf.summary.merge_all()

    test_error = tf.placeholder(tf.float32)
    test_error_summary = tf.summary.scalar('test_error', test_error)
    
    saver = tf.train.Saver(max_to_keep=2)


    

In [51]:

    

import sys
import logging
import datetime

root = logging.getLogger()
root.setLevel(logging.NOTSET)
logfile = "../tflogs/dipspnet-%s.log" % datetime.datetime.today()
fileHandler = logging.FileHandler(logfile)
fileHandler.setLevel(logging.INFO)
root.addHandler(fileHandler)
consoleHandler = logging.StreamHandler(sys.stdout)
consoleHandler.setLevel(logging.DEBUG)
consoleHandler.terminator = ""
root.addHandler(consoleHandler)

logging.debug("Logging to %s" % logfile)


    

    




Logging to ../tflogs/dipspnet-2017-04-27 12:42:53.014243.log

In [101]:

    

weights_schedule = [[0., 0., 0., 0., 0., 1.],
                    [0., 0., 0., 0., .7, .3],
                    [0., 0., 0., .6, .3, .1],
                    [0., 0., .5, .3, .1, .1],
                    [0., .5, .3, .1, .1, 0.],
                    [.5, .3, .1, .1, 0., 0.],
                    [.6, .3, .1, 0., 0., 0.],
                    [.7, .3, 0., 0., 0., 0.],
                    [1., 0., 0., 0., 0., 0.]]


    

In [117]:

    

step = 0
LOGDIR = "/yandexsdc/tflogs/34"
MODEL_NAME = "dispnet"

try:
    os.mkdir(LOGDIR)
except:
    pass
writer = tf.summary.FileWriter(LOGDIR)

log_step = 10
schedule_step = 10000
save_step = 5000
test_step = save_step
N_test = len(ft3d_samples_filenames["TEST"]) / 20

gpu_options = tf.GPUOptions(allow_growth=True)


    

In [ ]:

    

with tf.Session(graph=graph, config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
    sess.run(init)
    logging.debug("initialized")
#    writer.add_graph(sess.graph)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    logging.debug("queue runners started")
    try:
        feed_dict = {}
        feed_dict[training_mode] = True
        ckpt = tf.train.latest_checkpoint(".")
        if ckpt:
            logging.info("Restoring from %s" % ckpt)
            saver.restore(sess=sess, save_path=ckpt)
            step = int(ckpt[len(MODEL_NAME)+3:])
            feed_dict[loss_weights] = np.array(weights_schedule[min(step / schedule_step, len(weights_schedule)-1)])
        l_mean = 0
        start = time.time()
        feed_dict[learning_rate] = 5e-5
        feed_dict[beta1] = 0.9
        feed_dict[beta2] = 0.999
        while step < 1e5:
            if step % schedule_step == 0:
#                feed_dict[loss_weights] = np.array(weights_schedule[min(step / schedule_step, len(weights_schedule)-1)])
#                print("switching weights:")
                print(feed_dict[learning_rate])
                feed_dict[learning_rate] = feed_dict[learning_rate] / 1.4
            _, l, err  = sess.run([train_step, loss, error], feed_dict=feed_dict)
            l_mean += l
            step += 1
            if step % log_step == 0:
                l_mean = np.array(l_mean / float(log_step))
                feed_dict[mean_loss] = l_mean
                s = sess.run(merged_summary, feed_dict=feed_dict)
                writer.add_summary(s, step)
                logging.debug("iter: %d, f/b pass time: %f, loss: %f, error %f" % (step,
                    ((time.time() - start) / float(log_step)), l_mean, err))
                if np.isnan(l):
                    break
                l_mean = 0
                start = time.time()
            if step % save_step == 0:   
                logging.info("saving to file %s." % (""))
                saver.save(sess, MODEL_NAME, global_step=step)
            if step % test_step == 0:
                test_err = 0
                feed_dict[training_mode] = False
                logging.info("Testing...")
                for j in range(N_test):
                    err = sess.run([error], feed_dict=feed_dict)
                    test_err += err[0]
                test_err = test_err / float(N_test)
                logging.info("Test error %f" % test_err)
                feed_dict[test_error] = test_err
                s = sess.run(test_error_summary, feed_dict=feed_dict)
                
    except tf.errors.OutOfRangeError:
        logging.INFO('Done training for %d epochs, %d steps.' % (FLAGS.num_epochs, step))

    finally:
        coord.request_stop()
        coord.join(threads)
        sess.close()


    

    




initialized
queue runners started
Restoring from ./dispnet-90000
INFO:tensorflow:Restoring parameters from ./dispnet-90000
Restoring parameters from ./dispnet-90000
5e-05
iter: 90010, f/b pass time: 2.236852, loss: 5.934606, error 16.800577
iter: 90020, f/b pass time: 2.092398, loss: 6.426744, error 3.420483
iter: 90030, f/b pass time: 1.960537, loss: 4.347700, error 4.047184
iter: 90040, f/b pass time: 1.944237, loss: 5.253694, error 3.541281
iter: 90050, f/b pass time: 1.948414, loss: 4.132449, error 3.684876
iter: 90060, f/b pass time: 1.950235, loss: 4.150868, error 3.835644
iter: 90070, f/b pass time: 1.952570, loss: 4.171578, error 4.182681
iter: 90080, f/b pass time: 1.948278, loss: 5.393753, error 5.388224
iter: 90090, f/b pass time: 1.956631, loss: 5.067452, error 6.361891
iter: 90100, f/b pass time: 1.956548, loss: 4.336492, error 4.196795
iter: 90110, f/b pass time: 1.952049, loss: 5.461562, error 4.518213
iter: 90120, f/b pass time: 1.944312, loss: 4.775621, error 5.215955
iter: 90130, f/b pass time: 1.956041, loss: 4.970765, error 2.824337
iter: 90140, f/b pass time: 1.954668, loss: 4.551376, error 6.806813
iter: 90150, f/b pass time: 1.950502, loss: 5.801186, error 4.190920
iter: 90160, f/b pass time: 1.936597, loss: 4.611151, error 2.826536
iter: 90170, f/b pass time: 1.943723, loss: 4.672201, error 6.418635
iter: 90180, f/b pass time: 1.935088, loss: 4.661960, error 5.084694
iter: 90190, f/b pass time: 1.960023, loss: 3.826139, error 6.713863
iter: 90200, f/b pass time: 1.936559, loss: 4.418629, error 7.403496
iter: 90210, f/b pass time: 1.939768, loss: 6.651581, error 3.309921
iter: 90220, f/b pass time: 1.954251, loss: 4.593327, error 7.008129
iter: 90230, f/b pass time: 1.951648, loss: 8.227886, error 3.354816
iter: 90240, f/b pass time: 1.935487, loss: 3.850625, error 3.772427
iter: 90250, f/b pass time: 1.934917, loss: 3.666955, error 3.390352
iter: 90260, f/b pass time: 1.942506, loss: 4.174862, error 3.442009
iter: 90270, f/b pass time: 1.951937, loss: 4.013814, error 4.111112
iter: 90280, f/b pass time: 1.940052, loss: 4.208330, error 4.380397
iter: 90290, f/b pass time: 1.934464, loss: 10.891945, error 33.489601
iter: 90300, f/b pass time: 1.946187, loss: 4.716826, error 3.106071
iter: 90310, f/b pass time: 1.947143, loss: 4.605587, error 4.714979
iter: 90320, f/b pass time: 1.954496, loss: 4.062306, error 3.678624
iter: 90330, f/b pass time: 1.961015, loss: 6.672053, error 5.968897
iter: 90340, f/b pass time: 1.950293, loss: 4.565027, error 3.867073
iter: 90350, f/b pass time: 1.944810, loss: 3.737117, error 2.402330
iter: 90360, f/b pass time: 1.946507, loss: 5.276774, error 3.030862
iter: 90370, f/b pass time: 1.953842, loss: 4.240753, error 4.322391
iter: 90380, f/b pass time: 1.949720, loss: 3.763473, error 3.642528
iter: 90390, f/b pass time: 1.943925, loss: 4.424855, error 3.433841
iter: 90400, f/b pass time: 1.941765, loss: 5.635392, error 3.288789
iter: 90410, f/b pass time: 1.957120, loss: 3.896376, error 2.178108
iter: 90420, f/b pass time: 1.945233, loss: 5.190871, error 3.592974
iter: 90430, f/b pass time: 1.955177, loss: 6.366489, error 3.495704
iter: 90440, f/b pass time: 1.944580, loss: 4.627829, error 3.454868
iter: 90450, f/b pass time: 1.942021, loss: 3.151339, error 2.862886
iter: 90460, f/b pass time: 1.950194, loss: 21.641497, error 4.898410
iter: 90470, f/b pass time: 1.951510, loss: 6.217258, error 7.411933
iter: 90480, f/b pass time: 1.953788, loss: 8.443134, error 11.173642
iter: 90490, f/b pass time: 1.943968, loss: 5.808854, error 2.955450
iter: 90500, f/b pass time: 1.953254, loss: 5.293762, error 3.822963
iter: 90510, f/b pass time: 1.953569, loss: 7.271045, error 5.418105
iter: 90520, f/b pass time: 1.949115, loss: 4.409772, error 4.111864
iter: 90530, f/b pass time: 1.944395, loss: 5.555187, error 4.143013
iter: 90540, f/b pass time: 1.950145, loss: 4.056016, error 3.482077
iter: 90550, f/b pass time: 1.948673, loss: 7.418234, error 8.316537
iter: 90560, f/b pass time: 1.950615, loss: 4.511666, error 3.617023
iter: 90570, f/b pass time: 1.949826, loss: 3.584894, error 4.130156
iter: 90580, f/b pass time: 1.950010, loss: 6.068688, error 4.018569
iter: 90590, f/b pass time: 1.945867, loss: 3.412693, error 2.689833
iter: 90600, f/b pass time: 1.953184, loss: 11.914893, error 2.547565
iter: 90610, f/b pass time: 1.948621, loss: 5.868449, error 5.213013
iter: 90620, f/b pass time: 1.953713, loss: 4.071411, error 2.437699
iter: 90630, f/b pass time: 1.946960, loss: 4.877137, error 6.237243
iter: 90640, f/b pass time: 1.940614, loss: 4.879839, error 4.134394
iter: 90650, f/b pass time: 1.953640, loss: 4.477067, error 2.596069
iter: 90660, f/b pass time: 1.936235, loss: 3.458944, error 2.867569
iter: 90670, f/b pass time: 1.958876, loss: 4.516076, error 2.611849
iter: 90680, f/b pass time: 1.947215, loss: 3.565182, error 4.331818
iter: 90690, f/b pass time: 1.950364, loss: 11.399617, error 3.756710
iter: 90700, f/b pass time: 1.955242, loss: 4.982765, error 6.035007
iter: 90710, f/b pass time: 1.958426, loss: 5.569036, error 6.191154
iter: 90720, f/b pass time: 1.951860, loss: 4.218335, error 3.350807
iter: 90730, f/b pass time: 1.954991, loss: 3.738258, error 3.103390
iter: 90740, f/b pass time: 1.957179, loss: 3.764931, error 4.477495
iter: 90750, f/b pass time: 1.960133, loss: 4.858447, error 11.127617
iter: 90760, f/b pass time: 1.942926, loss: 4.451662, error 3.610668
iter: 90770, f/b pass time: 1.954799, loss: 4.004706, error 2.798260
iter: 90780, f/b pass time: 1.950371, loss: 4.470315, error 4.410544
iter: 90790, f/b pass time: 1.954953, loss: 4.637528, error 4.313193
iter: 90800, f/b pass time: 1.949694, loss: 3.948325, error 4.902467
iter: 90810, f/b pass time: 1.942560, loss: 4.197598, error 3.556276
iter: 90820, f/b pass time: 1.947735, loss: 4.643802, error 3.976468
iter: 90830, f/b pass time: 1.949965, loss: 4.169993, error 5.074694
iter: 90840, f/b pass time: 1.937329, loss: 5.246827, error 3.296838
iter: 90850, f/b pass time: 1.947998, loss: 3.570327, error 2.250854
iter: 90860, f/b pass time: 1.941731, loss: 4.268663, error 4.103075
iter: 90870, f/b pass time: 1.946619, loss: 3.322922, error 2.582522
iter: 90880, f/b pass time: 1.947403, loss: 3.715343, error 3.133526
iter: 90890, f/b pass time: 1.947679, loss: 6.448376, error 5.223241
iter: 90900, f/b pass time: 1.945912, loss: 3.682674, error 2.934727
iter: 90910, f/b pass time: 1.946972, loss: 9.222227, error 2.770331
iter: 90920, f/b pass time: 1.950697, loss: 3.788830, error 3.627847
iter: 90930, f/b pass time: 1.947083, loss: 4.787807, error 3.670068
iter: 90940, f/b pass time: 1.945625, loss: 3.452027, error 3.082202
iter: 90950, f/b pass time: 1.954261, loss: 4.070928, error 3.150344
iter: 90960, f/b pass time: 1.957027, loss: 3.589173, error 2.409998
iter: 90970, f/b pass time: 1.949493, loss: 4.783803, error 3.342785
iter: 90980, f/b pass time: 1.944713, loss: 3.510081, error 4.422548
iter: 90990, f/b pass time: 1.945793, loss: 3.620785, error 2.435999
iter: 91000, f/b pass time: 1.950718, loss: 3.789705, error 3.808365
iter: 91010, f/b pass time: 1.949553, loss: 8.661733, error 2.555900
iter: 91020, f/b pass time: 1.958207, loss: 3.442662, error 5.633384
iter: 91030, f/b pass time: 1.950398, loss: 3.862764, error 3.356428
iter: 91040, f/b pass time: 1.935764, loss: 3.335549, error 3.419890
iter: 91050, f/b pass time: 1.952403, loss: 3.829158, error 2.236816
iter: 91060, f/b pass time: 1.948692, loss: 4.364027, error 2.367020
iter: 91070, f/b pass time: 1.952114, loss: 3.305692, error 5.832751
iter: 91080, f/b pass time: 1.955919, loss: 5.341735, error 2.789109
iter: 91090, f/b pass time: 1.950224, loss: 3.378391, error 4.475441
iter: 91100, f/b pass time: 1.955611, loss: 3.445622, error 3.926157
iter: 91110, f/b pass time: 1.960960, loss: 4.342612, error 3.995320
iter: 91120, f/b pass time: 1.960469, loss: 3.643803, error 4.156760
iter: 91130, f/b pass time: 1.961586, loss: 4.435626, error 3.269295
iter: 91140, f/b pass time: 1.960373, loss: 4.524757, error 7.623303
iter: 91150, f/b pass time: 1.944215, loss: 3.582306, error 2.273477
iter: 91160, f/b pass time: 1.948864, loss: 5.030240, error 2.234683
iter: 91170, f/b pass time: 1.946886, loss: 4.638143, error 3.327349
iter: 91180, f/b pass time: 1.950279, loss: 4.655131, error 1.797189
iter: 91190, f/b pass time: 1.955825, loss: 5.627721, error 2.390557
iter: 91200, f/b pass time: 1.946807, loss: 3.412973, error 2.075012
iter: 91210, f/b pass time: 1.938191, loss: 3.570318, error 3.217667
iter: 91220, f/b pass time: 1.944566, loss: 3.261289, error 2.827093
iter: 91230, f/b pass time: 1.954336, loss: 3.530964, error 3.200297
iter: 91240, f/b pass time: 1.951883, loss: 3.680777, error 3.551363
iter: 91250, f/b pass time: 1.943455, loss: 4.690253, error 3.813499
iter: 91260, f/b pass time: 1.950244, loss: 4.059984, error 2.295188
iter: 91270, f/b pass time: 1.950119, loss: 4.343798, error 3.583217
iter: 91280, f/b pass time: 1.951033, loss: 3.389160, error 4.028808
iter: 91290, f/b pass time: 1.951199, loss: 3.653372, error 2.960593
iter: 91300, f/b pass time: 1.949962, loss: 3.380055, error 3.272227
iter: 91310, f/b pass time: 1.951097, loss: 3.847807, error 9.836067
iter: 91320, f/b pass time: 1.957905, loss: 3.680843, error 1.952966
iter: 91330, f/b pass time: 1.947785, loss: 3.487482, error 4.412889
iter: 91340, f/b pass time: 1.946983, loss: 5.748899, error 3.163868
iter: 91350, f/b pass time: 1.944707, loss: 3.469488, error 2.426343
iter: 91360, f/b pass time: 1.949343, loss: 4.019518, error 3.960924
iter: 91370, f/b pass time: 1.948059, loss: 7.615747, error 2.410969
iter: 91380, f/b pass time: 1.947093, loss: 6.200201, error 14.181596
iter: 91390, f/b pass time: 1.944412, loss: 3.991487, error 6.135973
iter: 91400, f/b pass time: 1.945979, loss: 5.406783, error 5.036854
iter: 91410, f/b pass time: 1.954701, loss: 3.530233, error 2.414627
iter: 91420, f/b pass time: 1.949825, loss: 5.104866, error 3.853857
iter: 91430, f/b pass time: 1.956706, loss: 4.084528, error 3.466055
iter: 91440, f/b pass time: 1.946074, loss: 5.072671, error 8.470948
iter: 91450, f/b pass time: 1.951946, loss: 3.889017, error 4.455773
iter: 91460, f/b pass time: 1.949475, loss: 2.940760, error 2.920730
iter: 91470, f/b pass time: 1.944483, loss: 3.724316, error 3.434440
iter: 91480, f/b pass time: 1.945219, loss: 4.731329, error 3.022069
iter: 91490, f/b pass time: 1.962637, loss: 4.927665, error 2.711404
iter: 91500, f/b pass time: 1.950306, loss: 6.584783, error 5.704060
iter: 91510, f/b pass time: 1.949765, loss: 3.864606, error 3.317285
iter: 91520, f/b pass time: 1.960416, loss: 3.718578, error 2.555938
iter: 91530, f/b pass time: 1.954389, loss: 3.298804, error 3.530608
iter: 91540, f/b pass time: 1.950174, loss: 4.385509, error 3.624082
iter: 91550, f/b pass time: 1.949442, loss: 3.611274, error 3.433027
iter: 91560, f/b pass time: 1.950329, loss: 3.543452, error 4.021445
iter: 91570, f/b pass time: 1.953475, loss: 3.471372, error 3.391909
iter: 91580, f/b pass time: 1.960715, loss: 3.355751, error 3.612725
iter: 91590, f/b pass time: 1.945136, loss: 3.475221, error 2.992752
iter: 91600, f/b pass time: 1.944238, loss: 8.109230, error 3.138076
iter: 91610, f/b pass time: 1.943335, loss: 4.569602, error 4.325583
iter: 91620, f/b pass time: 1.947335, loss: 3.204607, error 3.956603
iter: 91630, f/b pass time: 1.950595, loss: 3.306582, error 2.673615
iter: 91640, f/b pass time: 1.947437, loss: 3.529780, error 3.498624
iter: 91650, f/b pass time: 1.942351, loss: 5.702995, error 8.748243
iter: 91660, f/b pass time: 1.945506, loss: 3.055164, error 2.521273
iter: 91670, f/b pass time: 1.942348, loss: 16.597720, error 133.837128
iter: 91680, f/b pass time: 1.953692, loss: 4.506037, error 3.585928
iter: 91690, f/b pass time: 1.951411, loss: 4.252292, error 7.496500
iter: 91700, f/b pass time: 1.949867, loss: 5.926575, error 2.858919
iter: 91710, f/b pass time: 1.954028, loss: 3.189175, error 3.846015
iter: 91720, f/b pass time: 1.956203, loss: 3.525185, error 2.701219
iter: 91730, f/b pass time: 1.943728, loss: 3.198349, error 3.256226
iter: 91740, f/b pass time: 1.950283, loss: 4.655339, error 5.095415
iter: 91750, f/b pass time: 1.941926, loss: 4.279046, error 3.011899
iter: 91760, f/b pass time: 1.950950, loss: 5.074408, error 2.414961
iter: 91770, f/b pass time: 1.954420, loss: 5.763795, error 2.601989
iter: 91780, f/b pass time: 1.953667, loss: 4.102903, error 3.318807
iter: 91790, f/b pass time: 1.946900, loss: 12.311375, error 86.535606
iter: 91800, f/b pass time: 1.944490, loss: 4.456164, error 2.965393
iter: 91810, f/b pass time: 1.944864, loss: 4.816458, error 5.122841
iter: 91820, f/b pass time: 1.950120, loss: 4.344379, error 4.421520
iter: 91830, f/b pass time: 1.941650, loss: 3.359457, error 4.880923
iter: 91840, f/b pass time: 1.949999, loss: 6.488732, error 20.511730
iter: 91850, f/b pass time: 1.953781, loss: 6.039831, error 3.227699
iter: 91860, f/b pass time: 1.957055, loss: 3.664460, error 2.995683
iter: 91870, f/b pass time: 1.943657, loss: 3.502276, error 2.918668
iter: 91880, f/b pass time: 1.953559, loss: 3.751888, error 3.659335
iter: 91890, f/b pass time: 1.951361, loss: 3.524228, error 3.050380
iter: 91900, f/b pass time: 1.946331, loss: 18.409018, error 3.171862
iter: 91910, f/b pass time: 1.945094, loss: 3.423470, error 3.042600
iter: 91920, f/b pass time: 1.945339, loss: 24.074754, error 8.118988
iter: 91930, f/b pass time: 1.947740, loss: 9.843402, error 4.082771
iter: 91940, f/b pass time: 1.939083, loss: 5.457818, error 5.143846
iter: 91950, f/b pass time: 1.946233, loss: 5.752714, error 5.013123
iter: 91960, f/b pass time: 1.951988, loss: 5.079095, error 4.009369
iter: 91970, f/b pass time: 1.948182, loss: 3.726291, error 2.789338
iter: 91980, f/b pass time: 1.952043, loss: 12.957976, error 5.269272
iter: 91990, f/b pass time: 1.951335, loss: 5.177692, error 6.948252
iter: 92000, f/b pass time: 1.947421, loss: 3.996030, error 2.413226
iter: 92010, f/b pass time: 1.949212, loss: 4.959210, error 5.682538
iter: 92020, f/b pass time: 1.951916, loss: 4.386615, error 2.865004
iter: 92030, f/b pass time: 1.952768, loss: 4.199708, error 10.553287
iter: 92040, f/b pass time: 1.954266, loss: 3.699602, error 4.982704
iter: 92050, f/b pass time: 1.942743, loss: 3.800641, error 3.601494
iter: 92060, f/b pass time: 1.953191, loss: 5.042318, error 2.582804
iter: 92070, f/b pass time: 1.951287, loss: 4.997140, error 8.535871
iter: 92080, f/b pass time: 1.954056, loss: 3.865757, error 5.392590
iter: 92090, f/b pass time: 1.958560, loss: 9.054125, error 3.438334
iter: 92100, f/b pass time: 1.954480, loss: 4.689582, error 3.713214
iter: 92110, f/b pass time: 1.953140, loss: 3.578003, error 3.696039
iter: 92120, f/b pass time: 1.954417, loss: 5.464964, error 3.403877
iter: 92130, f/b pass time: 1.950434, loss: 4.897811, error 2.550241
iter: 92140, f/b pass time: 1.943243, loss: 3.464778, error 2.274248
iter: 92150, f/b pass time: 1.948704, loss: 3.439827, error 3.476984
iter: 92160, f/b pass time: 1.953452, loss: 4.755614, error 5.896678
iter: 92170, f/b pass time: 1.952752, loss: 3.604784, error 3.779978
iter: 92180, f/b pass time: 1.951598, loss: 3.496233, error 2.152359
iter: 92190, f/b pass time: 1.946249, loss: 3.905093, error 4.059748
iter: 92200, f/b pass time: 1.959376, loss: 3.744398, error 3.730105
iter: 92210, f/b pass time: 1.951863, loss: 3.438011, error 3.391140
iter: 92220, f/b pass time: 1.955161, loss: 3.793517, error 3.692636
iter: 92230, f/b pass time: 1.950115, loss: 5.411770, error 3.104325
iter: 92240, f/b pass time: 1.955144, loss: 4.274821, error 3.331471
iter: 92250, f/b pass time: 1.951471, loss: 3.662264, error 7.285299
iter: 92260, f/b pass time: 1.951826, loss: 4.092795, error 8.115013
iter: 92270, f/b pass time: 1.955150, loss: 3.478296, error 3.041952
iter: 92280, f/b pass time: 1.947439, loss: 4.491840, error 2.525610
iter: 92290, f/b pass time: 1.948100, loss: 3.663176, error 4.091191
iter: 92300, f/b pass time: 1.957356, loss: 4.467123, error 2.980725
iter: 92310, f/b pass time: 1.944404, loss: 3.745114, error 3.435937
iter: 92320, f/b pass time: 1.957009, loss: 3.212611, error 2.270301
iter: 92330, f/b pass time: 1.947434, loss: 4.111932, error 6.622596
iter: 92340, f/b pass time: 1.946601, loss: 4.043772, error 5.110140
iter: 92350, f/b pass time: 1.946315, loss: 3.235359, error 3.510427
iter: 92360, f/b pass time: 1.949464, loss: 4.022872, error 13.443448
iter: 92370, f/b pass time: 1.954573, loss: 3.313247, error 2.685387
iter: 92380, f/b pass time: 1.959486, loss: 3.731936, error 3.319960
iter: 92390, f/b pass time: 1.944963, loss: 2.798076, error 2.669968
iter: 92400, f/b pass time: 1.948729, loss: 8.078109, error 2.277565
iter: 92410, f/b pass time: 1.954172, loss: 4.782398, error 5.453888
iter: 92420, f/b pass time: 1.953843, loss: 5.475618, error 2.755265
iter: 92430, f/b pass time: 1.953845, loss: 4.723868, error 5.225779
iter: 92440, f/b pass time: 1.966346, loss: 4.746423, error 4.641041
iter: 92450, f/b pass time: 1.946474, loss: 3.640392, error 4.236234
iter: 92460, f/b pass time: 1.951466, loss: 3.111292, error 2.428227
iter: 92470, f/b pass time: 1.947954, loss: 4.023941, error 3.263006
iter: 92480, f/b pass time: 1.949826, loss: 2.746489, error 2.555739
iter: 92490, f/b pass time: 1.941264, loss: 3.027401, error 3.500201
iter: 92500, f/b pass time: 1.953754, loss: 3.037072, error 3.344866
iter: 92510, f/b pass time: 1.949440, loss: 6.588346, error 2.476986
iter: 92520, f/b pass time: 1.947792, loss: 3.884018, error 4.263730
iter: 92530, f/b pass time: 1.948060, loss: 3.406799, error 2.050407
iter: 92540, f/b pass time: 1.954678, loss: 5.803182, error 3.358024
iter: 92550, f/b pass time: 1.949820, loss: 4.690112, error 7.917131
iter: 92560, f/b pass time: 1.954805, loss: 4.095044, error 2.473476
iter: 92570, f/b pass time: 1.954564, loss: 3.003040, error 3.379646
iter: 92580, f/b pass time: 1.955229, loss: 4.133720, error 3.756966
iter: 92590, f/b pass time: 1.951188, loss: 5.165079, error 3.012585
iter: 92600, f/b pass time: 1.942961, loss: 3.893403, error 2.929958
iter: 92610, f/b pass time: 1.954670, loss: 4.500950, error 8.808150
iter: 92620, f/b pass time: 1.956307, loss: 3.329390, error 3.634005
iter: 92630, f/b pass time: 1.950803, loss: 4.418018, error 5.385229
iter: 92640, f/b pass time: 1.944814, loss: 4.817341, error 3.327133
iter: 92650, f/b pass time: 1.952806, loss: 3.320895, error 2.871497
iter: 92660, f/b pass time: 1.948218, loss: 4.420486, error 3.932131
iter: 92670, f/b pass time: 1.952660, loss: 3.486185, error 4.931606
iter: 92680, f/b pass time: 1.943203, loss: 5.556501, error 3.278282
iter: 92690, f/b pass time: 1.941655, loss: 5.216543, error 14.290338
iter: 92700, f/b pass time: 1.949162, loss: 3.431053, error 2.268471
iter: 92710, f/b pass time: 1.956442, loss: 3.533057, error 2.890549
iter: 92720, f/b pass time: 1.949878, loss: 3.691828, error 5.570320
iter: 92730, f/b pass time: 1.941777, loss: 6.078925, error 2.746898
iter: 92740, f/b pass time: 1.949431, loss: 3.967428, error 4.364700
iter: 92750, f/b pass time: 1.951034, loss: 3.719530, error 3.380629
iter: 92760, f/b pass time: 1.945956, loss: 3.027176, error 2.149395
iter: 92770, f/b pass time: 1.948913, loss: 3.773273, error 3.702323
iter: 92780, f/b pass time: 1.948272, loss: 4.568275, error 3.196792
iter: 92790, f/b pass time: 1.945954, loss: 2.958509, error 2.639500
iter: 92800, f/b pass time: 1.947992, loss: 3.583932, error 2.930171
iter: 92810, f/b pass time: 1.946871, loss: 3.637710, error 3.757796
iter: 92820, f/b pass time: 1.948144, loss: 5.653000, error 3.234640
iter: 92830, f/b pass time: 1.954619, loss: 3.695033, error 2.349975
iter: 92840, f/b pass time: 1.944763, loss: 3.064845, error 3.125270
iter: 92850, f/b pass time: 1.947264, loss: 3.000017, error 3.324266
iter: 92860, f/b pass time: 1.946131, loss: 3.787812, error 4.893216
iter: 92870, f/b pass time: 1.951400, loss: 12.876016, error 2.382585
iter: 92880, f/b pass time: 1.942994, loss: 4.060988, error 2.656901
iter: 92890, f/b pass time: 1.937489, loss: 4.619431, error 2.860279
iter: 92900, f/b pass time: 1.951466, loss: 3.218206, error 2.396056
iter: 92910, f/b pass time: 1.953220, loss: 3.849281, error 2.980643
iter: 92920, f/b pass time: 1.951167, loss: 3.638331, error 3.070045
iter: 92930, f/b pass time: 1.944360, loss: 4.802266, error 7.458694
iter: 92940, f/b pass time: 1.952997, loss: 4.200810, error 7.103097
iter: 92950, f/b pass time: 1.954984, loss: 3.871817, error 2.381022
iter: 92960, f/b pass time: 1.952714, loss: 3.826131, error 3.195642
iter: 92970, f/b pass time: 1.954316, loss: 3.678543, error 4.224171
iter: 92980, f/b pass time: 1.949958, loss: 3.467295, error 7.329516
iter: 92990, f/b pass time: 1.947528, loss: 3.447018, error 2.668973
iter: 93000, f/b pass time: 1.936240, loss: 3.386257, error 2.282265
iter: 93010, f/b pass time: 1.946489, loss: 3.693834, error 5.266721
iter: 93020, f/b pass time: 1.943138, loss: 5.859082, error 6.411439
iter: 93030, f/b pass time: 1.948040, loss: 4.123931, error 2.060260
iter: 93040, f/b pass time: 1.958031, loss: 4.365565, error 3.272052
iter: 93050, f/b pass time: 1.951708, loss: 3.180642, error 3.068678
iter: 93060, f/b pass time: 1.946626, loss: 3.616541, error 2.100383
iter: 93070, f/b pass time: 1.952164, loss: 3.573081, error 2.185201
iter: 93080, f/b pass time: 1.946122, loss: 3.830744, error 4.641213
iter: 93090, f/b pass time: 1.950198, loss: 3.256289, error 4.290638
iter: 93100, f/b pass time: 1.953089, loss: 2.842871, error 2.828260
iter: 93110, f/b pass time: 1.950617, loss: 5.835551, error 5.955842
iter: 93120, f/b pass time: 1.941511, loss: 5.301475, error 4.596696
iter: 93130, f/b pass time: 1.948076, loss: 3.470053, error 3.258807
iter: 93140, f/b pass time: 1.949779, loss: 3.766958, error 2.926407
iter: 93150, f/b pass time: 1.958599, loss: 3.115750, error 3.409855
iter: 93160, f/b pass time: 1.949289, loss: 3.779858, error 4.182297
iter: 93170, f/b pass time: 1.943365, loss: 3.757737, error 2.568219
iter: 93180, f/b pass time: 1.943363, loss: 3.587322, error 1.884892
iter: 93190, f/b pass time: 1.948616, loss: 3.521163, error 2.340489
iter: 93200, f/b pass time: 1.940692, loss: 4.268986, error 6.202327
iter: 93210, f/b pass time: 1.937973, loss: 3.844336, error 3.995931
iter: 93220, f/b pass time: 1.942766, loss: 3.299468, error 3.554821
iter: 93230, f/b pass time: 1.950295, loss: 3.425286, error 2.236374
iter: 93240, f/b pass time: 1.949654, loss: 3.299143, error 3.445012
iter: 93250, f/b pass time: 1.944346, loss: 5.767215, error 5.122647
iter: 93260, f/b pass time: 1.945281, loss: 3.489939, error 5.985053
iter: 93270, f/b pass time: 1.951872, loss: 3.377449, error 3.561169
iter: 93280, f/b pass time: 1.949894, loss: 3.465502, error 2.356892
iter: 93290, f/b pass time: 1.946419, loss: 3.240706, error 3.940455
iter: 93300, f/b pass time: 1.949119, loss: 2.757038, error 2.518954
iter: 93310, f/b pass time: 1.947180, loss: 3.218448, error 2.899534
iter: 93320, f/b pass time: 1.944495, loss: 5.251548, error 2.935085
iter: 93330, f/b pass time: 1.946384, loss: 3.318460, error 2.640543
iter: 93340, f/b pass time: 1.945495, loss: 4.107960, error 3.041787
iter: 93350, f/b pass time: 1.945398, loss: 6.120207, error 14.171045
iter: 93360, f/b pass time: 1.955329, loss: 4.038533, error 2.693279
iter: 93370, f/b pass time: 1.949137, loss: 3.368523, error 3.125721
iter: 93380, f/b pass time: 1.955020, loss: 3.447946, error 5.119700
iter: 93390, f/b pass time: 1.960013, loss: 4.606855, error 2.469315
iter: 93400, f/b pass time: 1.955780, loss: 7.532213, error 6.256733
iter: 93410, f/b pass time: 1.948456, loss: 7.199032, error 2.230242
iter: 93420, f/b pass time: 1.958523, loss: 3.320482, error 6.371852
iter: 93430, f/b pass time: 1.950567, loss: 3.505012, error 3.755489
iter: 93440, f/b pass time: 1.942143, loss: 8.651593, error 49.718338
iter: 93450, f/b pass time: 1.947167, loss: 5.399770, error 3.688877
iter: 93460, f/b pass time: 1.952230, loss: 3.238507, error 2.659597
iter: 93470, f/b pass time: 1.943881, loss: 4.400361, error 3.068165
iter: 93480, f/b pass time: 1.949621, loss: 3.676544, error 2.375739
iter: 93490, f/b pass time: 1.952285, loss: 4.006443, error 3.586483
iter: 93500, f/b pass time: 1.943916, loss: 4.243319, error 4.863300
iter: 93510, f/b pass time: 1.949699, loss: 3.993265, error 3.351588
iter: 93520, f/b pass time: 1.941436, loss: 3.276803, error 3.401095
iter: 93530, f/b pass time: 1.939100, loss: 3.666799, error 2.581479
iter: 93540, f/b pass time: 1.952761, loss: 3.600333, error 3.387324
iter: 93550, f/b pass time: 1.944785, loss: 2.898677, error 2.642874
iter: 93560, f/b pass time: 1.945346, loss: 2.969045, error 2.676332
iter: 93570, f/b pass time: 1.944362, loss: 5.135146, error 3.614546
iter: 93580, f/b pass time: 1.938005, loss: 3.638569, error 2.810024
iter: 93590, f/b pass time: 1.952313, loss: 4.564580, error 11.023343
iter: 93600, f/b pass time: 1.959218, loss: 3.355823, error 3.604608
iter: 93610, f/b pass time: 1.938906, loss: 2.950483, error 4.634326
iter: 93620, f/b pass time: 1.945717, loss: 5.409150, error 2.289166
iter: 93630, f/b pass time: 1.941452, loss: 3.220255, error 3.554943
iter: 93640, f/b pass time: 1.943387, loss: 4.145359, error 2.984443
iter: 93650, f/b pass time: 1.938063, loss: 3.291755, error 3.123251
iter: 93660, f/b pass time: 1.948432, loss: 5.785002, error 2.420108
iter: 93670, f/b pass time: 1.938092, loss: 3.524343, error 4.274566
iter: 93680, f/b pass time: 1.938405, loss: 3.718415, error 8.944726
iter: 93690, f/b pass time: 1.950911, loss: 3.397907, error 2.986604
iter: 93700, f/b pass time: 1.950455, loss: 3.634708, error 2.454000
iter: 93710, f/b pass time: 1.953659, loss: 4.501319, error 6.067561
iter: 93720, f/b pass time: 1.948623, loss: 2.964387, error 2.529138
iter: 93730, f/b pass time: 1.953477, loss: 3.499137, error 2.949414
iter: 93740, f/b pass time: 1.946637, loss: 4.765209, error 4.412028
iter: 93750, f/b pass time: 1.953395, loss: 5.647747, error 3.765361
iter: 93760, f/b pass time: 1.950921, loss: 5.178562, error 2.673664
iter: 93770, f/b pass time: 1.953870, loss: 5.529885, error 9.245370
iter: 93780, f/b pass time: 1.960575, loss: 4.608612, error 12.799783
iter: 93790, f/b pass time: 1.949507, loss: 3.257935, error 2.796727
iter: 93800, f/b pass time: 1.948321, loss: 3.627900, error 3.763591
iter: 93810, f/b pass time: 1.940889, loss: 3.666232, error 2.956643
iter: 93820, f/b pass time: 1.944741, loss: 3.402241, error 4.465135
iter: 93830, f/b pass time: 1.956142, loss: 4.960340, error 2.805555
iter: 93840, f/b pass time: 1.946503, loss: 6.069278, error 4.904097
iter: 93850, f/b pass time: 1.943460, loss: 3.533363, error 4.762303
iter: 93860, f/b pass time: 1.946827, loss: 114.558434, error 12.347233
iter: 93870, f/b pass time: 1.955372, loss: 9.341569, error 6.331345
iter: 93880, f/b pass time: 1.953765, loss: 15.905292, error 7.601852
iter: 93890, f/b pass time: 1.954459, loss: 8.357130, error 4.969997
iter: 93900, f/b pass time: 1.948174, loss: 6.366902, error 4.785193
iter: 93910, f/b pass time: 1.959141, loss: 5.146615, error 5.572349
iter: 93920, f/b pass time: 1.949045, loss: 6.378435, error 13.889676
iter: 93930, f/b pass time: 1.950026, loss: 4.726208, error 5.752162
iter: 93940, f/b pass time: 1.949672, loss: 3.803045, error 3.733563
iter: 93950, f/b pass time: 1.948736, loss: 4.549806, error 4.781232
iter: 93960, f/b pass time: 1.950384, loss: 16.265538, error 23.651751
iter: 93970, f/b pass time: 1.952547, loss: 4.292443, error 4.219801
iter: 93980, f/b pass time: 1.954633, loss: 4.348912, error 2.731477
iter: 93990, f/b pass time: 1.945398, loss: 3.519230, error 1.629509
iter: 94000, f/b pass time: 1.948067, loss: 4.474570, error 4.069513
iter: 94010, f/b pass time: 1.944739, loss: 6.161426, error 5.644807
iter: 94020, f/b pass time: 1.950940, loss: 4.792116, error 8.817258
iter: 94030, f/b pass time: 1.942086, loss: 3.672908, error 3.305100
iter: 94040, f/b pass time: 1.948426, loss: 4.021354, error 3.960052
iter: 94050, f/b pass time: 1.949040, loss: 4.648961, error 3.718683
iter: 94060, f/b pass time: 1.945776, loss: 3.451295, error 3.448655
iter: 94070, f/b pass time: 1.948529, loss: 27.891599, error 4.840413
iter: 94080, f/b pass time: 1.950381, loss: 6.825796, error 3.357264
iter: 94090, f/b pass time: 1.945541, loss: 6.078644, error 8.644773
iter: 94100, f/b pass time: 1.950447, loss: 4.652025, error 2.799694
iter: 94110, f/b pass time: 1.949842, loss: 3.450262, error 2.950755
iter: 94120, f/b pass time: 1.943350, loss: 9.251198, error 3.754834
iter: 94130, f/b pass time: 1.948657, loss: 3.641279, error 3.537042
iter: 94140, f/b pass time: 1.949521, loss: 6.966470, error 5.963185
iter: 94150, f/b pass time: 1.951928, loss: 4.966664, error 6.592633
iter: 94160, f/b pass time: 1.946294, loss: 3.692974, error 4.126076
iter: 94170, f/b pass time: 1.941745, loss: 6.634461, error 6.119252
iter: 94180, f/b pass time: 1.957119, loss: 4.430441, error 4.783022
iter: 94190, f/b pass time: 1.953020, loss: 3.901837, error 3.523194
iter: 94200, f/b pass time: 1.955042, loss: 3.917858, error 4.477170
iter: 94210, f/b pass time: 1.938114, loss: 4.688973, error 3.730748
iter: 94220, f/b pass time: 1.950743, loss: 5.178766, error 3.496077
iter: 94230, f/b pass time: 1.945182, loss: 12.037147, error 2.534486
iter: 94240, f/b pass time: 1.954691, loss: 4.263645, error 3.523600
iter: 94250, f/b pass time: 1.946366, loss: 3.745970, error 3.561280
iter: 94260, f/b pass time: 1.951646, loss: 4.846223, error 2.073776
iter: 94270, f/b pass time: 1.946654, loss: 4.753639, error 2.142501
iter: 94280, f/b pass time: 1.942095, loss: 4.001113, error 3.170789
iter: 94290, f/b pass time: 1.950647, loss: 6.256630, error 4.303588
iter: 95600, f/b pass time: 1.953902, loss: 4.365831, error 2.392933
iter: 95610, f/b pass time: 1.953997, loss: 4.841582, error 3.112292
iter: 95620, f/b pass time: 1.955341, loss: 3.104028, error 2.992397
iter: 95630, f/b pass time: 1.946278, loss: 3.128553, error 2.100973
iter: 95640, f/b pass time: 1.943280, loss: 3.581727, error 2.706303
iter: 95650, f/b pass time: 1.947367, loss: 3.664698, error 2.272994
iter: 95660, f/b pass time: 1.949303, loss: 3.191871, error 2.629565
iter: 95670, f/b pass time: 1.939370, loss: 3.005558, error 1.891965
iter: 95680, f/b pass time: 1.968617, loss: 3.885510, error 3.379593
iter: 95690, f/b pass time: 1.937182, loss: 3.749011, error 2.315317
iter: 95700, f/b pass time: 1.935515, loss: 4.027509, error 5.806592
iter: 95710, f/b pass time: 1.946036, loss: 3.153099, error 3.644153
iter: 95720, f/b pass time: 1.945211, loss: 2.771175, error 2.071653
iter: 95730, f/b pass time: 1.941660, loss: 3.468638, error 2.294400
iter: 95740, f/b pass time: 1.940150, loss: 3.660206, error 2.914639
iter: 95750, f/b pass time: 1.949563, loss: 2.691531, error 2.737789
iter: 95760, f/b pass time: 1.953051, loss: 3.503481, error 3.965896
iter: 95770, f/b pass time: 1.947513, loss: 2.819705, error 1.459745
iter: 95780, f/b pass time: 1.948019, loss: 2.603046, error 2.145693
iter: 95790, f/b pass time: 1.948686, loss: 16.353148, error 2.435094
iter: 95800, f/b pass time: 1.948891, loss: 4.471938, error 4.259238
iter: 95810, f/b pass time: 1.960725, loss: 3.599263, error 2.489686
iter: 95820, f/b pass time: 1.950308, loss: 4.521003, error 1.966515
iter: 95830, f/b pass time: 1.947843, loss: 3.063752, error 2.489064
iter: 95840, f/b pass time: 1.939829, loss: 4.163478, error 3.628021
iter: 95850, f/b pass time: 1.956300, loss: 3.739341, error 2.335250
iter: 95860, f/b pass time: 1.934696, loss: 3.195190, error 2.373478
iter: 95870, f/b pass time: 1.948524, loss: 3.112698, error 3.351055
iter: 95880, f/b pass time: 1.947985, loss: 4.663278, error 2.228680
iter: 95890, f/b pass time: 1.940348, loss: 7.874966, error 3.069601
iter: 95900, f/b pass time: 1.945740, loss: 3.870005, error 3.605855
iter: 95910, f/b pass time: 1.955015, loss: 3.629363, error 4.563175
iter: 95920, f/b pass time: 1.952731, loss: 3.828816, error 2.578598
iter: 95930, f/b pass time: 1.950988, loss: 3.364750, error 2.597277
iter: 95940, f/b pass time: 1.957116, loss: 3.294731, error 2.166911
iter: 95950, f/b pass time: 1.948509, loss: 3.390195, error 4.516494
iter: 95960, f/b pass time: 1.953470, loss: 2.946691, error 3.255605
iter: 95970, f/b pass time: 1.949655, loss: 3.355542, error 3.597236
iter: 95980, f/b pass time: 1.948091, loss: 3.241142, error 2.234809
iter: 95990, f/b pass time: 1.948763, loss: 4.003526, error 1.948919
iter: 96000, f/b pass time: 1.957173, loss: 3.765596, error 2.601385
iter: 96010, f/b pass time: 1.949895, loss: 5.943443, error 3.919149
iter: 96020, f/b pass time: 1.944144, loss: 3.976463, error 2.243059
iter: 96030, f/b pass time: 1.945829, loss: 3.056210, error 4.043575
iter: 96040, f/b pass time: 1.947449, loss: 3.706734, error 2.237975
iter: 96050, f/b pass time: 1.947614, loss: 3.062665, error 3.588197
iter: 96060, f/b pass time: 1.955636, loss: 4.297390, error 3.245070
iter: 96070, f/b pass time: 1.949068, loss: 3.249202, error 2.384455
iter: 96080, f/b pass time: 1.950402, loss: 3.459976, error 3.417512
iter: 96090, f/b pass time: 1.943206, loss: 6.032774, error 4.096028
iter: 96100, f/b pass time: 1.945634, loss: 3.068994, error 2.707461
iter: 96110, f/b pass time: 1.948704, loss: 3.330837, error 2.670929
iter: 96120, f/b pass time: 1.946725, loss: 3.283248, error 2.186963
iter: 96130, f/b pass time: 1.943717, loss: 3.055418, error 2.435682
iter: 96140, f/b pass time: 1.934453, loss: 3.483710, error 2.162249
iter: 96150, f/b pass time: 1.947742, loss: 3.635989, error 4.063816
iter: 96160, f/b pass time: 1.949481, loss: 3.738624, error 2.608807
iter: 96170, f/b pass time: 1.949605, loss: 2.805718, error 2.519990
iter: 96180, f/b pass time: 1.946816, loss: 3.136988, error 2.327584
iter: 96190, f/b pass time: 1.946458, loss: 3.062866, error 4.457911
iter: 96200, f/b pass time: 1.943971, loss: 3.078531, error 3.987514
iter: 96210, f/b pass time: 1.945484, loss: 5.260531, error 3.319400
iter: 96220, f/b pass time: 1.949175, loss: 3.443363, error 3.515994
iter: 96230, f/b pass time: 1.958068, loss: 2.800747, error 3.122397
iter: 96240, f/b pass time: 1.946877, loss: 3.480593, error 4.523548
iter: 96250, f/b pass time: 1.944663, loss: 3.691569, error 2.717651
iter: 96260, f/b pass time: 1.946032, loss: 3.869940, error 3.987689
iter: 96270, f/b pass time: 1.936335, loss: 3.563502, error 2.865956
iter: 96280, f/b pass time: 1.946181, loss: 4.182430, error 2.387509
iter: 96290, f/b pass time: 1.951568, loss: 2.987124, error 2.889550
iter: 96300, f/b pass time: 1.952511, loss: 4.174598, error 3.297034
iter: 96310, f/b pass time: 1.954259, loss: 3.873105, error 8.640435
iter: 96320, f/b pass time: 1.946066, loss: 2.648957, error 2.715305
iter: 96330, f/b pass time: 1.950073, loss: 3.088241, error 2.479074
iter: 96340, f/b pass time: 1.947324, loss: 3.391554, error 3.720169
iter: 96350, f/b pass time: 1.943993, loss: 2.724752, error 2.853097
iter: 96360, f/b pass time: 1.938338, loss: 3.230248, error 3.286063
iter: 96370, f/b pass time: 1.949750, loss: 3.352574, error 3.241945
iter: 96380, f/b pass time: 1.946713, loss: 4.194343, error 3.313967
iter: 96390, f/b pass time: 1.947708, loss: 3.852404, error 2.649487
iter: 96400, f/b pass time: 1.950443, loss: 3.031638, error 2.022123
iter: 96410, f/b pass time: 1.944242, loss: 3.657656, error 4.057024
iter: 96420, f/b pass time: 1.944385, loss: 4.599297, error 6.126427
iter: 96430, f/b pass time: 1.948209, loss: 3.459573, error 2.698011
iter: 96440, f/b pass time: 1.954159, loss: 3.260589, error 3.139987
iter: 96450, f/b pass time: 1.962935, loss: 6.906791, error 2.598231
iter: 96460, f/b pass time: 1.957436, loss: 5.586681, error 6.236435
iter: 96470, f/b pass time: 1.951066, loss: 4.747659, error 6.687941
iter: 96480, f/b pass time: 1.952426, loss: 4.766233, error 3.922860
iter: 96490, f/b pass time: 1.948043, loss: 4.165572, error 2.609123
iter: 96500, f/b pass time: 1.937547, loss: 3.945067, error 2.637047
iter: 96510, f/b pass time: 1.959432, loss: 3.086483, error 3.123197
iter: 96520, f/b pass time: 1.952514, loss: 3.352232, error 4.237532
iter: 96530, f/b pass time: 1.949842, loss: 3.352770, error 3.156258
iter: 96540, f/b pass time: 1.948888, loss: 3.363626, error 2.468432
iter: 96550, f/b pass time: 1.951311, loss: 3.533421, error 2.342050
iter: 96560, f/b pass time: 1.948652, loss: 3.947222, error 3.345659
iter: 96570, f/b pass time: 1.956500, loss: 8.312810, error 4.240189
iter: 96580, f/b pass time: 1.948186, loss: 3.242605, error 2.433494
iter: 96590, f/b pass time: 1.949368, loss: 55.000300, error 2.796607
iter: 96600, f/b pass time: 1.949364, loss: 15.995565, error 4.359665
iter: 96610, f/b pass time: 1.949710, loss: 4.798037, error 3.060104
iter: 96620, f/b pass time: 1.946495, loss: 9.123742, error 6.317284
iter: 96630, f/b pass time: 1.944703, loss: 5.289990, error 4.159549
iter: 96640, f/b pass time: 1.946925, loss: 3.605196, error 2.583641
iter: 96650, f/b pass time: 1.945405, loss: 3.272923, error 3.831786
iter: 96660, f/b pass time: 1.946717, loss: 3.644066, error 2.821042
iter: 96670, f/b pass time: 1.955482, loss: 3.244803, error 2.908864
iter: 96680, f/b pass time: 1.941754, loss: 3.452092, error 2.761256
iter: 96690, f/b pass time: 1.948489, loss: 4.717616, error 5.275951
iter: 96700, f/b pass time: 1.952093, loss: 2.830784, error 2.591506
iter: 96710, f/b pass time: 1.949576, loss: 3.755523, error 7.522892
iter: 96720, f/b pass time: 1.948863, loss: 3.365721, error 4.316324
iter: 96730, f/b pass time: 1.944850, loss: 3.305893, error 2.378431
iter: 96740, f/b pass time: 1.953248, loss: 4.106027, error 3.622715
iter: 96750, f/b pass time: 1.947092, loss: 3.285387, error 4.080271
iter: 96760, f/b pass time: 1.948536, loss: 3.355905, error 2.821863
iter: 96770, f/b pass time: 1.945086, loss: 4.000461, error 3.302238
iter: 96780, f/b pass time: 1.946206, loss: 3.410235, error 2.649333
iter: 96790, f/b pass time: 1.937685, loss: 5.155874, error 2.996377
iter: 96800, f/b pass time: 1.948913, loss: 4.287878, error 7.101588
iter: 96810, f/b pass time: 1.958478, loss: 3.273815, error 2.101189
iter: 96820, f/b pass time: 1.947410, loss: 9.253325, error 64.590446
iter: 96830, f/b pass time: 1.948975, loss: 4.542614, error 2.717405
iter: 96840, f/b pass time: 1.950968, loss: 3.730797, error 4.079262
iter: 96850, f/b pass time: 1.952500, loss: 6.854714, error 3.143196
iter: 96860, f/b pass time: 1.950303, loss: 11.336373, error 2.542431
iter: 96870, f/b pass time: 1.951465, loss: 3.433916, error 2.305436
iter: 96880, f/b pass time: 1.949935, loss: 2.790182, error 1.920380
iter: 96890, f/b pass time: 1.937903, loss: 3.281509, error 8.731339
iter: 96900, f/b pass time: 1.949524, loss: 3.036134, error 3.275869
iter: 96910, f/b pass time: 1.952198, loss: 4.908909, error 3.346658
iter: 96920, f/b pass time: 1.952217, loss: 3.161092, error 2.729741
iter: 96930, f/b pass time: 1.942021, loss: 3.495366, error 2.266306
iter: 96940, f/b pass time: 1.938156, loss: 5.118124, error 4.451939
iter: 96950, f/b pass time: 1.946150, loss: 3.375115, error 3.173568
iter: 96960, f/b pass time: 1.951606, loss: 2.787959, error 2.243934
iter: 96970, f/b pass time: 1.952679, loss: 2.760996, error 3.016158
iter: 96980, f/b pass time: 1.941326, loss: 3.929406, error 2.712822
iter: 96990, f/b pass time: 1.946123, loss: 14.442366, error 3.331242
iter: 97000, f/b pass time: 1.943745, loss: 4.487144, error 4.025751
iter: 97010, f/b pass time: 1.949678, loss: 4.568176, error 3.072033
iter: 97020, f/b pass time: 1.956758, loss: 3.780421, error 3.442348
iter: 97030, f/b pass time: 1.952608, loss: 6.542282, error 31.303984
iter: 97040, f/b pass time: 1.950591, loss: 4.499241, error 3.225048
iter: 97050, f/b pass time: 1.946934, loss: 10.140783, error 7.565650
iter: 97060, f/b pass time: 1.950459, loss: 3.922940, error 7.313307
iter: 97070, f/b pass time: 1.960706, loss: 5.961058, error 2.483855
iter: 97080, f/b pass time: 1.941383, loss: 4.714283, error 8.311859
iter: 97090, f/b pass time: 1.948237, loss: 3.059615, error 2.647519
iter: 97100, f/b pass time: 1.945093, loss: 4.138396, error 4.995126
iter: 97110, f/b pass time: 1.949487, loss: 4.191656, error 2.280817
iter: 97120, f/b pass time: 1.943187, loss: 4.019840, error 7.177416
iter: 97130, f/b pass time: 1.954973, loss: 3.359845, error 4.506214
iter: 97140, f/b pass time: 1.950569, loss: 4.215795, error 3.948866
iter: 97150, f/b pass time: 1.947181, loss: 3.876607, error 3.315259
iter: 97160, f/b pass time: 1.946244, loss: 2.951265, error 2.829933
iter: 97170, f/b pass time: 1.938041, loss: 3.162733, error 3.195751
iter: 97180, f/b pass time: 1.949114, loss: 2.963702, error 4.199241
iter: 97190, f/b pass time: 1.942954, loss: 3.227367, error 7.073110
iter: 97200, f/b pass time: 1.945228, loss: 3.094288, error 4.667922
iter: 97210, f/b pass time: 1.947587, loss: 3.844526, error 2.281937
iter: 97220, f/b pass time: 1.936827, loss: 3.462534, error 2.947506
iter: 97230, f/b pass time: 1.945783, loss: 2.928126, error 3.303955
iter: 97240, f/b pass time: 1.949434, loss: 4.367029, error 8.369851
iter: 97250, f/b pass time: 1.935783, loss: 4.033364, error 4.253960
iter: 97260, f/b pass time: 1.950962, loss: 3.277820, error 2.457838
iter: 97270, f/b pass time: 1.948030, loss: 5.459870, error 4.054774
iter: 97280, f/b pass time: 1.948359, loss: 2.880950, error 2.475626
iter: 97290, f/b pass time: 1.957095, loss: 3.957876, error 2.077686
iter: 97300, f/b pass time: 1.945926, loss: 6.261569, error 2.189761
iter: 97310, f/b pass time: 1.942188, loss: 3.612989, error 3.312030
iter: 97320, f/b pass time: 1.945963, loss: 3.192348, error 2.734174
iter: 97330, f/b pass time: 1.969556, loss: 3.712720, error 3.072497
iter: 97340, f/b pass time: 1.943803, loss: 2.657881, error 1.873293
iter: 97350, f/b pass time: 1.945989, loss: 4.437334, error 3.465835
iter: 97360, f/b pass time: 1.945404, loss: 4.183767, error 2.670190
iter: 97370, f/b pass time: 1.951198, loss: 4.074065, error 3.722518
iter: 97380, f/b pass time: 1.952256, loss: 3.823408, error 3.909777
iter: 97390, f/b pass time: 1.957696, loss: 3.259528, error 2.604594
iter: 97400, f/b pass time: 1.949198, loss: 3.026462, error 4.585520
iter: 97410, f/b pass time: 1.948237, loss: 3.793599, error 3.421077
iter: 97420, f/b pass time: 1.942691, loss: 3.179025, error 2.364813
iter: 97430, f/b pass time: 1.956095, loss: 3.193263, error 2.097585
iter: 97440, f/b pass time: 1.947020, loss: 3.897761, error 2.090303
iter: 97450, f/b pass time: 1.952226, loss: 3.627952, error 5.347103
iter: 97460, f/b pass time: 1.944481, loss: 3.677343, error 2.295160
iter: 97470, f/b pass time: 1.954543, loss: 2.907398, error 2.156223
iter: 97480, f/b pass time: 1.954046, loss: 3.425021, error 4.384959
iter: 97490, f/b pass time: 1.951936, loss: 3.326840, error 2.133566
iter: 97500, f/b pass time: 1.948181, loss: 3.356011, error 2.044103
iter: 97510, f/b pass time: 1.948038, loss: 2.939790, error 3.229422
iter: 97520, f/b pass time: 1.958530, loss: 2.840312, error 2.692160
iter: 97530, f/b pass time: 1.953038, loss: 3.309401, error 2.025076
iter: 97540, f/b pass time: 1.945727, loss: 5.280045, error 2.475623
iter: 97550, f/b pass time: 1.956027, loss: 3.554930, error 3.124212
iter: 97560, f/b pass time: 1.950892, loss: 8.613122, error 5.407525
iter: 97570, f/b pass time: 1.953604, loss: 3.314180, error 3.465386
iter: 97580, f/b pass time: 1.943880, loss: 3.529785, error 2.960722
iter: 97590, f/b pass time: 1.951582, loss: 3.268543, error 2.841483
iter: 97600, f/b pass time: 1.943075, loss: 3.948934, error 2.745193
iter: 97610, f/b pass time: 1.959777, loss: 3.471471, error 3.278653
iter: 97620, f/b pass time: 1.950058, loss: 2.813197, error 3.235238
iter: 97630, f/b pass time: 1.953899, loss: 3.014565, error 3.306625
iter: 97640, f/b pass time: 1.941316, loss: 3.078621, error 3.642280
iter: 97650, f/b pass time: 1.950148, loss: 3.372136, error 3.975784
iter: 97660, f/b pass time: 1.948713, loss: 3.000477, error 2.200840
iter: 97670, f/b pass time: 1.946161, loss: 3.514790, error 2.772145
iter: 97680, f/b pass time: 1.961822, loss: 3.487137, error 4.157023
iter: 97690, f/b pass time: 1.949508, loss: 2.733160, error 2.115308
iter: 97700, f/b pass time: 1.943257, loss: 3.918509, error 2.189988
iter: 97710, f/b pass time: 1.947570, loss: 3.754262, error 1.941676
iter: 97720, f/b pass time: 1.952817, loss: 3.190052, error 2.860346
iter: 97730, f/b pass time: 1.954165, loss: 3.304594, error 3.293792
iter: 97740, f/b pass time: 1.949431, loss: 4.160920, error 5.828652
iter: 97750, f/b pass time: 1.946911, loss: 3.857122, error 2.626763
iter: 97760, f/b pass time: 1.953870, loss: 3.878994, error 2.093331
iter: 97770, f/b pass time: 1.946410, loss: 3.474949, error 1.650268
iter: 97780, f/b pass time: 1.953720, loss: 2.964722, error 3.753467
iter: 97790, f/b pass time: 1.945151, loss: 3.004239, error 3.411449
iter: 97800, f/b pass time: 1.949616, loss: 3.060345, error 3.304402
iter: 97810, f/b pass time: 1.947767, loss: 6.025364, error 2.047935
iter: 97820, f/b pass time: 1.955804, loss: 3.580419, error 3.003150
iter: 97830, f/b pass time: 1.942472, loss: 4.276672, error 9.262731
iter: 97840, f/b pass time: 1.948324, loss: 3.311722, error 3.978988
iter: 97850, f/b pass time: 1.943031, loss: 3.455093, error 3.578681
iter: 97860, f/b pass time: 1.943499, loss: 5.312299, error 2.946768
iter: 97870, f/b pass time: 1.950390, loss: 3.281444, error 2.124443
iter: 97880, f/b pass time: 1.950910, loss: 4.688657, error 3.114567
iter: 97890, f/b pass time: 1.944409, loss: 3.636029, error 4.105935
iter: 97900, f/b pass time: 1.950026, loss: 3.903389, error 2.311789
iter: 97910, f/b pass time: 1.952329, loss: 3.575179, error 2.866311
iter: 97920, f/b pass time: 1.960266, loss: 3.496099, error 3.384808
iter: 97930, f/b pass time: 1.953824, loss: 3.047087, error 2.200018
iter: 97940, f/b pass time: 1.948109, loss: 2.485653, error 2.155059
iter: 97950, f/b pass time: 1.942940, loss: 3.620542, error 2.671192
iter: 97960, f/b pass time: 1.954679, loss: 2.757556, error 2.801011
iter: 97970, f/b pass time: 1.949486, loss: 2.790700, error 2.908773
iter: 97980, f/b pass time: 1.946968, loss: 3.278378, error 2.985192
iter: 97990, f/b pass time: 1.950342, loss: 4.213812, error 2.534711
iter: 98000, f/b pass time: 1.944169, loss: 3.526518, error 3.770228
iter: 98010, f/b pass time: 1.947919, loss: 4.664392, error 3.611442
iter: 98020, f/b pass time: 1.954653, loss: 4.820994, error 2.604028
iter: 98030, f/b pass time: 1.942562, loss: 4.970946, error 2.791154
iter: 98040, f/b pass time: 1.943715, loss: 2.731575, error 2.047994
iter: 98050, f/b pass time: 1.954477, loss: 3.885744, error 4.129778
iter: 98060, f/b pass time: 1.943377, loss: 5.335352, error 3.676930
iter: 98070, f/b pass time: 1.947703, loss: 2.776677, error 3.464999
iter: 98080, f/b pass time: 1.949898, loss: 2.879244, error 2.367318
iter: 98090, f/b pass time: 1.944239, loss: 14.020135, error 4.261437
iter: 98100, f/b pass time: 1.954067, loss: 5.266438, error 3.365727
iter: 98110, f/b pass time: 1.955867, loss: 4.441369, error 3.343624
iter: 98120, f/b pass time: 1.948730, loss: 3.685922, error 2.813831
iter: 98130, f/b pass time: 1.950981, loss: 6.975040, error 3.021048
iter: 98140, f/b pass time: 1.954743, loss: 3.649158, error 3.331628
iter: 98150, f/b pass time: 1.938744, loss: 2.877523, error 3.493124
iter: 98160, f/b pass time: 1.946669, loss: 3.591779, error 2.058015
iter: 98170, f/b pass time: 1.946569, loss: 10.088647, error 4.629848
iter: 98180, f/b pass time: 1.944951, loss: 3.835512, error 1.772446
iter: 98190, f/b pass time: 1.944307, loss: 3.947122, error 2.409386
iter: 98200, f/b pass time: 1.945638, loss: 3.329816, error 2.729534

In [126]:

    

err


    

    
Out[126]:





[8.664403]

In [128]:

    

min(step / schedule_step, len(weights_schedule)-1)


    

    
Out[128]:





9

In [ ]: