bikesharing_nn.py

import numpy as np

class NeuralNetwork(object):

    def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate):

        # Set number of nodes in input, hidden and output layers.
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        # Initialize weights
        self.weights_input_to_hidden = np.random.normal(0.0, self.input_nodes**-0.5,
                                       (self.input_nodes, self.hidden_nodes))

        self.weights_hidden_to_output = np.random.normal(0.0, self.hidden_nodes**-0.5,
                                       (self.hidden_nodes, self.output_nodes))

        # Save learning rate
        self.lr = learning_rate

        # Set the Activation function using lambda expression
        self.activation_function = lambda x : 1 / (1 + np.exp(-x))

    def print_nn(self):

        # Print some useful information
        print('---------------------------------------------------------------')
        print('Bikesharing NeuralNetwork')
        print('---------------------------------------------------------------')
        print('')
        print('Nodes    Input        Hidden        Output')
        print("          [{}] ======> [{}]  ======> [{}]".format(
            self.input_nodes,
            self.hidden_nodes,
            self.output_nodes))
        print("Weights          Wi           Wo")
        print("               {}       {}".format(
            self.weights_input_to_hidden.shape,
            self.weights_hidden_to_output.shape))
        print("")

    def train(self, features, targets):
        ''' Train the network on batch of features and targets.

            Arguments
            ---------

            features: 2D array, each row is one data record, each column is a feature
            targets: 1D array of target values

        '''

        n_records = features.shape[0]

        # Clear all the weights
        delta_weights_i_h = np.zeros(self.weights_input_to_hidden.shape)
        delta_weights_h_o = np.zeros(self.weights_hidden_to_output.shape)

        for X, y in zip(features, targets):

            # Implement the forward pass function below
            final_outputs, hidden_outputs = self.forward_pass_train(X)

            # Implement the backproagation function below
            delta_weights_i_h, delta_weights_h_o = self.backpropagation(
                final_outputs,
                hidden_outputs,
                X,
                y,
                delta_weights_i_h,
                delta_weights_h_o)

        self.update_weights(delta_weights_i_h, delta_weights_h_o, n_records)

    def forward_pass_train(self, X):
        ''' Implement forward pass here

            Arguments
            ---------
            X: features batch

        '''

        ### Forward pass ###

        # Hidden layer
        # X [ n_records(always 128) x N_i ] * weights_input_to_hidden [ N_i x hidden_nodes ]
        hidden_inputs = np.dot(X, self.weights_input_to_hidden)
        hidden_outputs = self.activation_function(hidden_inputs)

        # Output layer
        # hidden_outputs [ n_records(always 128) x hidden_nodes ] * weights_hidden_to_output [ hidden_nodes x 1 ]
        final_inputs = np.dot(hidden_outputs, self.weights_hidden_to_output)
        final_outputs = final_inputs

        return final_outputs, hidden_outputs

    def backpropagation(self, final_outputs, hidden_outputs, X, y, delta_weights_i_h, delta_weights_h_o):
        ''' Implement backpropagation

            Arguments
            ---------
            final_outputs: output from forward pass
            y: target (i.e. label) batch
            delta_weights_i_h: change in weights from input to hidden layers
            delta_weights_h_o: change in weights from hidden to output layers

        '''

        ### Backward pass ###

        # Output error: difference between desired target and actual output
        error_term = y - final_outputs

        # Hidden layer's contribution to the error
        hidden_error = np.dot(self.weights_hidden_to_output, error_term)

        # Backpropagated error terms
        hidden_error_term = hidden_error * hidden_outputs * (1 - hidden_outputs)

        # Weight step (input to hidden) 56,18
        delta_weights_i_h += np.dot(X[:, None], hidden_error_term[None, :])

        # Weight step (hidden to output)
        delta_weights_h_o += np.dot(hidden_outputs[:, None], error_term[None, :])

        return delta_weights_i_h, delta_weights_h_o

    def update_weights(self, delta_weights_i_h, delta_weights_h_o, n_records):
        ''' Update weights on gradient descent step

            Arguments
            ---------
            delta_weights_i_h: change in weights from input to hidden layers
            delta_weights_h_o: change in weights from hidden to output layers
            n_records: number of records

        '''

        # update hidden-to-output weights with gradient descent step
        self.weights_hidden_to_output += self.lr * delta_weights_h_o/n_records

        # update input-to-hidden weights with gradient descent step
        self.weights_input_to_hidden += self.lr * delta_weights_i_h/n_records

    def run(self, features):
        ''' Run a forward pass through the network with input features

            Arguments
            ---------
            features: 1D array of feature values
        '''

        # Forward pass

        # Hidden layer
        hidden_inputs = np.dot(features, self.weights_input_to_hidden)
        hidden_outputs = self.activation_function(hidden_inputs)

        # Output layer
        final_inputs = np.dot(hidden_outputs, self.weights_hidden_to_output)
        final_outputs = final_inputs

        return final_outputs