/*
 * File:        DatasetCreator.java
 * Author:      Justin Basilico
 * Course:      PO CS 152: Neural Networks
 * Assignment:  Final Project
 * Updated:     2001.12.18
 * Created:     2001.12.05
 *
 * Description:
 * This file contains the DatasetCreator abstract class, which is just a
 * program for creating the datasets used in the program.
 *
 * Copyright:   Justin Basilico (2001).
 */

import java.io.*;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Random;

/**
 * DatasetCreator abstract class
 *
 * This abstract class implements a program for creating datasets for the
 * simulator sigma-pi network to simulate. The user specifies the architecture
 * of the fully-connected feed-forward network of sigma units with linear
 * activation functions and the number of such networks to create and it
 * creates a dataset of that many random networks of that architecture and
 * saves them in a specified file that can be read in by the DatasetReader
 * class. The created dataset has input that is the input of the network to
 * simulate plus all of the weights in that network. The target output is
 * the output that the network produces on that input.
 *
 * To run the program, just do
 *    java DatasetCreator <parameters>
 * where the parameters are:
 *
 * -f <file to write into>
 * This parameter specifies the file to write the dataset into. It must be
 * given for the dataset to be created.
 *
 * -n <number to create>
 * This parameter specifies the number of random networks to create in the
 * dataset. It must be at least 1. The default is 100.
 *
 * -i <input size for network>
 * This parameter specifies the number of units on the input layer of the
 * network. It must be at least 1. The default is 2.
 *
 * -o <output size for network>
 * This parameter specifies the number of units on the output layer of the
 * network. It must be at least 1. The default is 1.
 *
 * -h <next hidden layer size>
 * This parameter specifies to use another hidden layer of the given size.
 * This parameter can be used multiple times to specify multiple hidden
 * layers, which will be organized in the order the parameters are given. Each
 * one must be at least 1. The default has no hidden layers.
 *
 * -s <random seed number>
 * This parameter uses the specified seed as the seed for the random number
 * generator. The default is 1234567.
 *
 * -H
 * Prints the usage of this program.
 *
 * @author  Justin Basilico
 * @version 2001.12.18
 * @see     NetworkEvolver
 * @see     NetworkTester
 * @see     SigmaPiNetwork
 * @see     DatasetReader
 */
public abstract class DatasetCreator
    extends Object
{
    /**
     * main
     *
     * This is the main method where execution begins. It parses the command-
     * line arguments and then creates the dataset by creating random networks
     * with random inputs and then outputting the information about the
     * network into a file to be used as a dataset for a sigma-pi simulator
     * network.
     *
     * @param  args The String array of command-line arguments.
     * @throws IOException If a FileOutputStream can't be created to write to
     *         the specified file.
     */
    public static void main (
        String              args[])             // The command-line arguments.
        throws IOException
    {
        String              fileName    = null;
        int                 numToCreate = 100;
        long                seed        = 1234567L;
        int                 numInputs   = 2;
        int                 numOutputs  = 1;
        LinkedList          hiddenList  = new LinkedList();
        boolean             runProgram  = true;

        // Parse the command-line arguments.
        for (int i = 0; i < args.length && runProgram; i++)
        {
            if ( args[i].equalsIgnoreCase("-f") )
                fileName = args[++i];
            else if ( args[i].equalsIgnoreCase("-n") )
                numToCreate = Integer.parseInt(args[++i]);
            else if ( args[i].equalsIgnoreCase("-i") )
                numInputs = Integer.parseInt(args[++i]);
            else if ( args[i].equalsIgnoreCase("-o") )
                numOutputs = Integer.parseInt(args[++i]);
            else if ( args[i].equalsIgnoreCase("-h") )
                hiddenList.addLast(new Integer(Integer.parseInt(args[++i])));
            else if ( args[i].equalsIgnoreCase("-s") )
                seed = Long.parseLong(args[++i]);
            else if ( args[i].equalsIgnoreCase("-H") )
                runProgram = false;
            else
            {
                // Error: Bad parameter.
                System.err.println("Unknown option: " + args[i]);
                runProgram = false;
            }
        }

        if ( fileName == null )
        {
            // Error: No file specified.
            System.err.println("You need to specify an output file.");
            runProgram = false;
        }
        else if ( numInputs < 1 )
        {
            // Error: Input size is too small.
            System.err.println("The input size must be at least 1.");
            runProgram = false;
        }
        else if ( numOutputs < 1 )
        {
            // Error: Output size is too small.
            System.err.println("The output size must be at least 1.");
            runProgram = false;
        }
        else if ( numToCreate < 1 )
        {
            // Error: No networks to create.
            System.err.println("The number to create must be at least 1.");
            runProgram = false;
        }

        // Load in the hidden units.
        int[] hiddenUnits = Utilities.integerListToArray(hiddenList);

        for (int i = 0; runProgram && i < hiddenUnits.length; i++)
        {
            if ( hiddenUnits[i] < 1 )
            {
                System.err.println("The number of hidden units on each layer "
                    + "must be at least 1.");
                runProgram = false;
            }
            // else - This hidden unit is good.
        }

        if ( !runProgram )
        {
            printUsage();
            return;
        }

        // Create the input and output encoders.
        UnitEncoder inputEncoder =
            new DoubleArrayEncoder(InputOutputPair.PROPERTY_INPUT,
                0,  numInputs, 1);
        UnitEncoder outputEncoder =
            new DoubleArrayEncoder(InputOutputPair.PROPERTY_OUTPUT,
                0, numOutputs, 1);

        // Create the random number generator.
        Random random = new Random(seed);

        // Create the backpropagation network.
        SimpleNetwork network = new SimpleNetwork(
            inputEncoder, outputEncoder, hiddenUnits, random);

        int numLayers = network.getNumLayers();
        int inputSize = numInputs;
        int outputSize = numOutputs;

        // Calculate the total size of the input we are creating.
        for (int i = 1; i < numLayers; i++)
            inputSize +=    network.getLayerSize(i)
                         * (network.getLayerSize(i - 1) + 1);

        // Output information about what we are creating.
        System.out.println("Creating a new dataset with the following "
            + "parameters:");
        System.out.println("Output file: " + fileName);
        System.out.println("Generator seed: " + seed);
        System.out.println("Number generated: " + numToCreate);
        System.out.print("Network size: " + numInputs + " ");
        Utilities.printArray(hiddenUnits);
        System.out.println("" + numOutputs);
        System.out.println("Input size for sigma-pi network: " + inputSize);
        System.out.println("Output size for sigma-pi network: " + outputSize);

        // Open a PrintWriter to write to a file.
        PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));

        // This is the header for the double array dataset.
        pw.println("" + inputSize + " " + outputSize);


        // Create the input units.
        double[] inputUnits = new double[numInputs];
        Utilities.zeroArray(inputUnits);

        // Create the InputOutputPair.
        InputOutputPair inputPair = new InputOutputPair(inputUnits, null);
        for (int n = 0; n < numToCreate; n++)
        {
            // Make the random networks.
            Utilities.randomizeArray(inputUnits, random, -1.0, 1.0);
            network.randomizeWeights(-5.0, 5.0);

            // Load the random input into the random network.
            network.loadInput(inputPair);

            // Feed the activation through the random network.
            network.feedForward();

            for (int i = 1; i <= numInputs; i++)
                // Print the random input values.
                pw.print(network.getInput(i) + " ");

            // Print out the random weights.
            for (int i = 1; i < numLayers; i++)
            {
                int fromNum = network.getLayerSize(i - 1);
                int toNum = network.getLayerSize(i);

                for (int j = 1; j <= toNum; j++)
                    for (int k = 0; k <= fromNum; k++)
                        pw.print(network.getWeight(i, j, k) + " ");
            }

            // Done with the input.
            pw.println();

            // Print the output of the network.
            for (int i = 1; i <= numOutputs; i++)
                pw.print(network.getOutput(i) + " ");

            pw.println();
        }

        // Done generating the random networks.
        pw.close();
    }

    /**
     * printUsage
     *
     * This method prints the usage of this program to System.out.
     */
    public static void printUsage()
    {
        System.out.println("Usage: java DatasetCreator <parameters>");
        System.out.println("Parameters:");
        System.out.println("    -f <file to write into>");
        System.out.println("    -n <number to create>");
        System.out.println("    -i <input size for network>");
        System.out.println("    -o <output size for network>");
        System.out.println("    -h <next hidden layer size>");
        System.out.println("    -s <random seed number>");
        System.out.println("    -H (print usage message)");
    }

    /**
     * SimpleNetwork class
     *
     * This class is a simple class for a FeedForwardNetwork where each unit
     * uses a linear activation function and only sigma layers of units.
     */
    private static class SimpleNetwork
        extends FeedForwardNetwork
    {
        /**
         * SimpleNetwork basic constructor
         *
         * This constructor takes an input and output UnitEncoder, an array of
         * integers that specify the sizes of the hidden layers (null for no
         * hidden layers), and the Random object that can be used by the
         * network for random number generation. It initializes the network to
         * have the given number of layers (at least 2, one for input and one
         * for output) and uses the dimensionality of the input encoder for
         * the size of the input layer, the dimensionality of the output
         * encoder for the size of the output layer, and the array of hidden
         * layer sizes for the size of each hidden layer. The network is
         * initialized to have bias units on each layer with an activation of
         * 1.0 and all other units have an activation of 0.0. In addition, all
         * weights in the network are set to 0.0.
         *
         * @param  inputEncoder The UnitEncoder used for encoding
         *         NetworkInputs into the input layer of the network.
         * @param  outputEncoder The UnitEncoder used for encoding
         *         NetworkInputs into the target output for the network.
         * @param  hiddenLayserSizes The array of integers that specifies the
         *         number of hidden layers by its length and the number of
         *         units on each hidden layer by its values. If it is of
         *         length 0 or is null, no hidden layers are created.
         * @param  randomGenerator The Random object used for random number
         *         generation in the network.
         */
        private SimpleNetwork(
            UnitEncoder     inputEncoder,       // Encoder for input units.
            UnitEncoder     outputEncoder,      // Encoder for target output.
            int[]           hiddenLayerSizes,   // Sizes of hidden layers.
            Random          randomGenerator)    // Random number generator.
        {
            super(inputEncoder, outputEncoder, hiddenLayerSizes,
                randomGenerator);
        }

        /**
         * randomizeWeights
         *
         * This method takes the minimum and a maximum value for the weights
         * in a network and randomizes them using the Random object for the
         * network.
         *
         * @param  min The double minimum value for a weight in the network.
         * @param  max The double maximum value for a weight in the network.
         */
        private void randomizeWeights(
            double              min,            // Minimum weight value.
            double              max)            // Maximum weight value.
        {
            // Randomize all the layers of weights.
            for (int i = 0; i < weights.length; i++)
                Utilities.randomizeMatrix(weights[i], randomGenerator,
                    min, max);
        }

        /**
         * feedForward
         *
         * This method uses the current values on the input layer to feed
         * those values through the network to the output layer. It uses
         * linear activation values along with just doing the sum to calculate
         * the activation.
         */
        public void feedForward()
        {
            // Propagate each layer.
            for (int i = 0; i < (numLayers - 1); i++)
                propagateLayer(units[i], units[i + 1], weights[i]);
        }

        /**
         * propagateLayer
         *
         * This method takes the array of units the activation is coming from,
         * the array of units the activation is going to, the matrix of
         * weights indexed by the input layer, and the array of activation
         * functions for the units the values are going to. It propagates the
         * values from the given from layer to the given to layer by assuming
         * that the to layer is sigma units.
         *
         * @param  from The array of double unit activation values of the
         *         units to propagate from.
         * @param  to The array of double unit activation values of the units
         *         to propagate to as a sigma layer.
         * @param  weights The weight matrix of the weight values going into
         *         the layer.
         */
        private void propagateLayer(
            double[]            from,           // From unit values.
            double[]            to,             // To unit values.
            double[][]          weightsIn)      // Weights values.
        {
            // Calculate the sum for each unit.
            double sum = 0.0;
            for (int i = 1; i < to.length; i++)
            {
                // Start out with a sum of 0.0.
                sum = 0.0;

                // Calculate the sum of the weights time the input
                //activations.
                for (int j = 0; j < from.length; j++)
                    // Multiply the weight times the activation and add it to
                    // the current sum.
                    sum += weightsIn[i][j] * from[j];

                // Set the value of the ith unit by using the activation
                // function on the total sum.
                to[i] = sum;
            }
        }
    }
}