Example #1
0
def learn_curve(network, training_input, training_target, validation_input, validation_target, epochs=50):
    '''Plots the erros w.r.t the number of epochs of training. Assumes no regularisation.
    Returns two lists containing the training and validation errors.'''
    
    training_errors = []
    validation_errors = []

    num_training = len(training_input)
    
    #Train mini batches of 10s
    minibatches = [(training_input[i:i+10, :], training_target[i:i+10, :]) for i in range(0, num_training, 10)]
    for epoch in range(epochs):
        for batch in minibatches:
            backprop.train(network, batch[0], batch[1])

        #Get errors for this epoch
        train_error = error(network, training_input, training_target)
        val_error = error(network, validation_input, validation_target)
        training_errors.append(train_error)
        validation_errors.append(val_error)

    #Plot the data
    pylab.plot(training_errors, label="Training Error")
    pylab.plot(validation_errors, label="Validation Error")
    pylab.title("Training and Validation Errors w.r.t. Number of Epochs")
    pylab.xlabel("Epochs")
    pylab.ylabel("Error")
    pylab.legend()
    pylab.show()

    return training_errors, validation_errors
Example #2
0
def train_ae(ae,
             training_inputs,
             epochs=100,
             learning_rate=0.2,
             batch_size=100,
             noise=0.4,
             tau=0,
             get_error=False):
    '''Trains an autoencoder on data.'''
    errors = []

    for epoch in range(epochs):
        corrupt_training_inputs = dropout(
            training_inputs, noise)  #Add noise to input if you want
        input_batches = [
            training_inputs[i:i + batch_size]
            for i in range(0, training_inputs.shape[0], batch_size)
        ]  #Split to mini-batches
        corrupt_input_batches = [
            corrupt_training_inputs[i:i + batch_size]
            for i in range(0, training_inputs.shape[0], batch_size)
        ]
        print 'Epoch Number: ', epoch
        for i in range(len(input_batches)):
            train(ae, corrupt_input_batches[i], input_batches[i],
                  learning_rate, tau)
            if i % 100 == 0 and get_error:
                e = error(ae, input_batches[i], input_batches[i], tau)
                print e
                errors.append(e)
    if get_error:
        return errors
Example #3
0
def vary_data(network, training_input, training_target, validation_input, validation_target, epochs=5):
    '''Plots training and validation errors of a net w.r.t. the number of training
    cases used in learning. Useful for determining if the issue is in the amount of data
    Returns two lists containing the training and validation errors'''
    training_errors = []
    validation_errors = []

    num_training = len(training_input)
    
    for percent in range(5, 105, 5): #Sweep through percentages from 5 to 100%
        train_length = num_training*percent/100.0
        validation_length = len(validation_input)*percent/100.0
        network_copy = network
    #Train mini batches of 10s
        minibatches = [(training_input[i:i+10, :], training_target[i:i+10, :]) for i in range(0, int(train_length), 10)]
        for epoch in range(epochs):
            for batch in minibatches:
                backprop.train(network_copy, batch[0], batch[1])

        #Get errors for this percent of data
        train_error = error(network_copy, training_input[0:train_length], training_target[0:train_length])
        val_error = error(network_copy, validation_input[0:validation_length], validation_target[0:validation_length])
        training_errors.append(train_error)
        validation_errors.append(val_error)

    #Plot the data
    pylab.plot(range(5,105,5), training_errors, label="Training Error")
    pylab.plot(range(5,105,5), validation_errors, label="Validation Error")
    pylab.title("Training and Validation Errors w.r.t. % of Data used")
    pylab.xlabel("Data Used (%)")
    pylab.ylabel("Error After "+ str(epochs)+ " Epochs")
    pylab.legend()
    pylab.show()

    return training_errors, validation_errors
Example #4
0
def reg_parameter(network,
                  training_input,
                  training_target,
                  validation_input,
                  validation_target,
                  sweep_range=(0.01, 20),
                  epochs=10):
    '''Plots training and validation errors of a net varying the regularisation parameter over a set range. Useful for determining 
    where network is underfitting and overfitting. Sweep Range is a tuple, where the first value is the initial decay rate to test, 
    and the second value is the number of parameters to test. Each parameter will be 1.2 times the one before it.
    Returns two lists containing the training and validation errors'''
    training_errors = []
    validation_errors = []

    num_training = len(training_input)
    start_rate = sweep_range[0]
    num_parameters = sweep_range[1]
    decay_rates = [
        start_rate * (1.2**i) for i in range(num_parameters)
    ]  #Create a list of different regularisation parameters to try.
    decay_rates.insert(0, 0)
    for rate in decay_rates:
        #Train mini batches of 10s
        new_net = network
        minibatches = [(training_input[i:i + 10, :],
                        training_target[i:i + 10, :])
                       for i in range(0, num_training, 10)]
        for epoch in range(epochs):
            for batch in minibatches:
                backprop.train(new_net, batch[0], batch[1], rate)

        #Get errors for this decay rate
        train_error = error(new_net, training_input, training_target, rate)
        val_error = error(new_net, validation_input, validation_target, rate)
        training_errors.append(train_error)
        validation_errors.append(val_error)

    #Plot the data
    pylab.plot(decay_rates, training_errors, label="Training Error")
    pylab.plot(decay_rates, validation_errors, label="Validation Error")
    pylab.title(
        "Training and Validation Errors w.r.t. Regularisation Parameter")
    pylab.xlabel("Regularisation Parameter")
    pylab.ylabel("Error After 10 Epochs")
    pylab.legend()
    pylab.show()

    return training_errors, validation_errors
Example #5
0
def train_ae(ae, training_inputs, epochs=100, learning_rate=0.2, batch_size=100, noise=0.4, tau=0, get_error=False):
    '''Trains an autoencoder on data.'''
    errors = []

    for epoch in range(epochs):
        corrupt_training_inputs = dropout(training_inputs, noise) #Add noise to input if you want
        input_batches = [training_inputs[i:i+batch_size] for i in range(0, training_inputs.shape[0], batch_size)] #Split to mini-batches
        corrupt_input_batches = [corrupt_training_inputs[i:i+batch_size] for i in range(0, training_inputs.shape[0], batch_size)]
        print 'Epoch Number: ', epoch
        for i in range(len(input_batches)):
            train(ae, corrupt_input_batches[i], input_batches[i], learning_rate, tau)
            if i%100 == 0 and get_error:
                e = error(ae, input_batches[i], input_batches[i], tau)
                print e
                errors.append(e)
    if get_error:
        return errors
Example #6
0
def vary_data(network,
              training_input,
              training_target,
              validation_input,
              validation_target,
              epochs=5):
    '''Plots training and validation errors of a net w.r.t. the number of training
    cases used in learning. Useful for determining if the issue is in the amount of data
    Returns two lists containing the training and validation errors'''
    training_errors = []
    validation_errors = []

    num_training = len(training_input)

    for percent in range(5, 105, 5):  #Sweep through percentages from 5 to 100%
        train_length = num_training * percent / 100.0
        validation_length = len(validation_input) * percent / 100.0
        network_copy = network
        #Train mini batches of 10s
        minibatches = [(training_input[i:i + 10, :],
                        training_target[i:i + 10, :])
                       for i in range(0, int(train_length), 10)]
        for epoch in range(epochs):
            for batch in minibatches:
                backprop.train(network_copy, batch[0], batch[1])

        #Get errors for this percent of data
        train_error = error(network_copy, training_input[0:train_length],
                            training_target[0:train_length])
        val_error = error(network_copy, validation_input[0:validation_length],
                          validation_target[0:validation_length])
        training_errors.append(train_error)
        validation_errors.append(val_error)

    #Plot the data
    pylab.plot(range(5, 105, 5), training_errors, label="Training Error")
    pylab.plot(range(5, 105, 5), validation_errors, label="Validation Error")
    pylab.title("Training and Validation Errors w.r.t. % of Data used")
    pylab.xlabel("Data Used (%)")
    pylab.ylabel("Error After " + str(epochs) + " Epochs")
    pylab.legend()
    pylab.show()

    return training_errors, validation_errors
Example #7
0
def reg_parameter(network, training_input, training_target, validation_input, validation_target, sweep_range=(0.01, 20), epochs=10):
    '''Plots training and validation errors of a net varying the regularisation parameter over a set range. Useful for determining 
    where network is underfitting and overfitting. Sweep Range is a tuple, where the first value is the initial decay rate to test, 
    and the second value is the number of parameters to test. Each parameter will be 1.2 times the one before it.
    Returns two lists containing the training and validation errors'''
    training_errors = []
    validation_errors = []

    num_training = len(training_input)
    start_rate = sweep_range[0]
    num_parameters = sweep_range[1]
    decay_rates = [start_rate*(1.2**i) for i in range(num_parameters)] #Create a list of different regularisation parameters to try.
    decay_rates.insert(0,0)
    for rate in decay_rates:
        #Train mini batches of 10s
        new_net = network
        minibatches = [(training_input[i:i+10, :], training_target[i:i+10, :]) for i in range(0, num_training, 10)]
        for epoch in range(epochs):
            for batch in minibatches:
                backprop.train(new_net, batch[0], batch[1], rate)

        #Get errors for this decay rate
        train_error = error(new_net, training_input, training_target, rate)
        val_error = error(new_net, validation_input, validation_target, rate)
        training_errors.append(train_error)
        validation_errors.append(val_error)

    #Plot the data
    pylab.plot(decay_rates, training_errors, label="Training Error")
    pylab.plot(decay_rates,validation_errors, label="Validation Error")
    pylab.title("Training and Validation Errors w.r.t. Regularisation Parameter")
    pylab.xlabel("Regularisation Parameter")
    pylab.ylabel("Error After 10 Epochs")
    pylab.legend()
    pylab.show()

    return training_errors, validation_errors
Example #8
0
def learn_curve(network,
                training_input,
                training_target,
                validation_input,
                validation_target,
                epochs=50):
    '''Plots the erros w.r.t the number of epochs of training. Assumes no regularisation.
    Returns two lists containing the training and validation errors.'''

    training_errors = []
    validation_errors = []

    num_training = len(training_input)

    #Train mini batches of 10s
    minibatches = [(training_input[i:i + 10, :], training_target[i:i + 10, :])
                   for i in range(0, num_training, 10)]
    for epoch in range(epochs):
        for batch in minibatches:
            backprop.train(network, batch[0], batch[1])

        #Get errors for this epoch
        train_error = error(network, training_input, training_target)
        val_error = error(network, validation_input, validation_target)
        training_errors.append(train_error)
        validation_errors.append(val_error)

    #Plot the data
    pylab.plot(training_errors, label="Training Error")
    pylab.plot(validation_errors, label="Validation Error")
    pylab.title("Training and Validation Errors w.r.t. Number of Epochs")
    pylab.xlabel("Epochs")
    pylab.ylabel("Error")
    pylab.legend()
    pylab.show()

    return training_errors, validation_errors
Example #9
0
from sys import argv
from backprop import train
from backprop import test

if __name__ == "__main__":
    if len(argv) == 1:
        pass
    elif argv[1] == 'train':
        train()
    elif argv[1] == 'test':
        test()
    else:
        pass