Take out storage

Author: truell20

include/Adadelta.h

@@ -35,12 +35,6 @@ namespace net {
 		 */
 		void train(net::NeuralNet *network, const std::vector< std::vector<double> > &input, const std::vector< std::vector<double> > &correctOutput);
 
-    /**
-		 * \brief Stores an Adadelta object using specified ofstream.
-		 *
-		 * \param output pointer to the output stream which the neural network will be written to
-		**/
-		void store(std::ofstream *output);
 
 		double targetErrorLevel; /**< The target error level, set by constructor */
 		int maximumEpochs; /**< The maximum number of epochs for one training run, set by constructor */

include/Fido.h

@@ -13,7 +13,6 @@
 #include "LSInterpolator.h"
 #include "NeuralNet.h"
 #include "Neuron.h"
-#include "Pruner.h"
 #include "QLearn.h"
 #include "Trainer.h"
 #include "WireFitQLearn.h"

include/FidoControlSystem.h

@@ -17,6 +17,10 @@ namespace rl {
 		 */
 		FidoControlSystem(int stateDimensions, Action minAction, Action maxAction, int baseOfDimensions);
 
+		/** Choose an action using a non-specified, dynamically adjusted exploration level.
+		 *
+		 * \param state a vector of the current sensor values
+		*/
 		std::vector<double> chooseBoltzmanActionDynamic(State state);
 
 		/** Update the control system's model, by giving it reward for its last action.
@@ -32,12 +36,6 @@ namespace rl {
 		*/
 		void reset();
 
-		const double initialExploration = 1;
-		//const double initialExploration = 0.4;
-		const int samplesOfHistory = 10;
-		double explorationLevel;
-		double lastError;
-
 	private:
 		struct History {
 			State initialState, newState;
@@ -52,6 +50,11 @@ namespace rl {
 			}
 		};
 
+		const double initialExploration = 1;
+		const int samplesOfHistory = 10;
+		double explorationLevel;
+		double lastError;
+
 		std::vector<History> histories;
 
 		std::vector<FidoControlSystem::History> selectHistories();

include/Interpolator.h

@@ -15,12 +15,6 @@ namespace rl {
 	class Interpolator {
 	public:
 
-		/** Initializes the parameters of an interpolator from a file. Returns false if the interpolator stored in the file is not the correct type */
-		virtual bool initFromStream(std::ifstream *in) = 0;
-
-		/** Stores the parameters of an interpolator in a file */
-		virtual void store(std::ofstream *out) = 0;
-
 		/** Uses the interpolator function to compute the reward of an action vector given a set of control wires */
 		virtual double getReward(const std::vector<Wire> &controlWires, const std::vector<double> &action) = 0;
 
@@ -29,9 +23,7 @@ namespace rl {
 
 		/** The partial derivative of the interpolator function with respect to the value of one term of the action vector of a control wire */
 		virtual double actionTermDerivative(double actionTerm, double wireActionTerm, const std::vector<double> &action, const Wire &wire, const std::vector<Wire> &controlWires) = 0;
-
-		/** Gets an interpolator from a file. Tries out every interpolator and throws an error none of the interpolators successfully read from the file */
-		static Interpolator * getAnyInterpolatorFromFile(std::ifstream *in);
+		
 	};
 }
 

include/LSInterpolator.h

@@ -26,22 +26,6 @@ namespace rl {
 		 */
 		LSInterpolator(double smoothingFactor_, double e_);
 
-		/**
-		 * \brief Initializes a LSInterpolator using the information from a file.
-		 *
-		 * \param in the file from which initialize the LSInterpolator
-		 *
-		 * \return False if the interpolator stored in the file is not a LSInterpolator.
-		 */
-		bool initFromStream(std::ifstream *in);
-
-		/**
-		 * \brief Stores the interpolator object in a file
-		 *
-		 * \param out the file to which to write the LSInterpolator
-		 */
-		void store(std::ofstream *out);
-
 		/**
 		 * \brief Uses the interpolator function to compute the reward of an action vector given a set of control wires
 		 *

include/QLearn.h

@@ -83,8 +83,6 @@ namespace rl {
 		*/
 		void reset();
 
-		/** Stores this model in a stream. */
-		void store(std::ofstream *output);
 	private:
 		net::Backpropagation backprop;
 		std::vector<Model> models;

include/Trainer.h

@@ -22,13 +22,6 @@ namespace net {
 		 * \param correctOutput network is trained to output an element of correctOutput when fed a corresponding element of the input vector
 		 */
 		virtual void train(net::NeuralNet *network, const std::vector< std::vector<double> > &input, const std::vector< std::vector<double> > &correctOutput) = 0;
-
-		/**
-		 * \brief Stores a Trainer object using specified stream.
-		 *
-		 * \param output pointer to the output stream which the neural network will be written to
-		**/
-		virtual void store(std::ofstream *output) = 0;
 	};
 }
 

include/WireFitQLearn.h

@@ -52,9 +52,6 @@ namespace rl {
 		/** Initializes an empty, non-valid WireFitQLearn object. */
 		WireFitQLearn();
 
-		/** Initializes a WireFitQLearn object from a stream */
-		WireFitQLearn(std::ifstream *input);
-
 		/** Gets the action that the network deems most benificial for the current state
 		 *
 		 * \param currentState a vector of doubles representing the "inputs" or sensor values of the system
@@ -80,9 +77,6 @@ namespace rl {
 		/** Resets the system's model so that to a newely initialized state */
 		void reset();
 
-		/** Stores this model in a stream. */
-		void store(std::ofstream *output);
-
 	protected:
 		// Feeds the state into the network, parses to the output of the network into wire form, and outputs these wires
 		std::vector<Wire> getWires(State state);

src/Adadelta.cpp

@@ -61,10 +61,6 @@ double Adadelta::trainOnDataPoint(net::NeuralNet *network, const std::vector<dou
 	return networkError;
 }
 
-void Adadelta::store(std::ofstream *output) {
-
-}
-
 void Adadelta::resetAccumulatedVectors(net::NeuralNet *network) {
   accumulatedGradients.clear();
   accumulatedUpdates.clear();

src/FidoControlSystem.cpp

@@ -1,7 +1,7 @@
 #include "../include/FidoControlSystem.h"
 
 #include "../include/NeuralNet.h"
-#include "../include/Pruner.h"
+#include "../include/Backpropagation.h"
 #include "../include/LSInterpolator.h"
 
 

src/Interpolator.cpp

@@ -18,25 +18,6 @@ LSInterpolator::LSInterpolator(double smoothingFactor_, double e_) {
 	e = e_;
 }
 
-bool LSInterpolator::initFromStream(std::ifstream *in) {
-	std::string name;
-	if (!(*in >> name)) {
-		std::cout << "Interpolator could not read ifstrem\n";
-		throw 1;
-	}
-
-	if (name != "LS") {
-		return false;
-	}
-
-	*in >> smoothingFactor >> e;
-	return true;
-}
-
-void LSInterpolator::store(std::ofstream *out) {
-	*out << " LS " << smoothingFactor << " " << e << " ";
-}
-
 double LSInterpolator::getReward(const std::vector<Wire> &controlWires, const std::vector<double> &action) {
 	double maxReward = -9999999;
 	for (std::vector<Wire>::const_iterator a = controlWires.begin(); a != controlWires.end(); ++a) if (a->reward > maxReward) maxReward = a->reward;

src/LSInterpolator.cpp

@@ -46,14 +46,6 @@ WireFitQLearn::WireFitQLearn(unsigned int stateDimensions, unsigned int actionDi
 	baseOfDimensions = baseOfDimensions_;
 }
 
-WireFitQLearn::WireFitQLearn() {
-
-}
-
-WireFitQLearn::WireFitQLearn(std::ifstream *input) {
-
-}
-
 Action WireFitQLearn::chooseBestAction(State currentState) {
 	std::vector<double> action = bestAction(currentState);
 	lastAction = action;
@@ -111,27 +103,6 @@ void WireFitQLearn::reset() {
 	network->randomizeWeights();
 }
 
-void WireFitQLearn::store(std::ofstream *output) {
-	if(output->is_open()) {
-		*output << learningRate << " " << devaluationFactor << "\n";
-		*output << actionDimensions << " " << numberOfWires << "\n";
-		*output << controlPointsGDErrorTarget << " " << controlPointsGDLearningRate << " " << controlPointsGDMaxIterations <<  " " << baseOfDimensions << "\n";
-
-		for(unsigned int a = 0; a < minAction.size(); a++) *output << minAction[a] << " ";
-		for(unsigned int a = 0; a < maxAction.size(); a++) *output << maxAction[a] << " ";
-		for(unsigned int a = 0; a < lastAction.size(); a++) *output << lastAction[a] << " ";
-
-		trainer->store(output);
-		interpolator->store(output);
-		network->store(output);
-
-		output->close();
-	} else {
-		std::cout << "Could not store wirefitqlearn in file\n";
-		throw 1;
-	}
-}
-
 std::vector<Wire> WireFitQLearn::getWires(State state) {
 	std::vector<Wire> wires(numberOfWires);
 	std::vector<double> rawOutput = network->getOutput(state);