Orphan commit of all the previous changes

.gitignore

@@ -0,0 +1,8 @@
+Debug
+/*.sdf
+/*.suo
+/*.opensdf
+Release
+Data
+tinyxml
+opencv300

ANNLib/ANN.cpp

@@ -0,0 +1,224 @@
+#define ANNDLL_EXPORTS
+#include <ANN.h>
+#include <fstream>
+#include <iomanip>
+
+
+bool ANN::NeuralNetwork::Load(std::string filepath)
+{
+	std::ifstream file(filepath);
+	if (!file.is_open()) return false;
+	int buffer;
+	const int CHAR_BUF_LEN = 100;
+	char char_buffer[CHAR_BUF_LEN];
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	std::string string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("activation type:"))
+		throw "incorrect file format";
+	file >> buffer;
+	activation_type = (ActivationType)buffer;
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("activation scale:"))
+		throw "incorrect file format";
+	file >> scale;
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("configuration:"))
+		throw "incorrect file format";
+	file >> buffer;
+	configuration.resize(buffer);
+	for (size_t i = 0; i < configuration.size(); i++) {
+		file >> configuration[i];
+	}
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("weights:"))
+		throw "incorrect file format";
+	weights.resize(configuration.size() - 1);
+	for (size_t i = 0; i < weights.size(); i++) {
+		weights[i].resize(configuration[i + 1]);
+		for (size_t j = 0; j < weights[i].size(); j++) {
+			weights[i][j].resize(configuration[i]);
+			for (size_t k = 0; k < weights[i][j].size(); k++) {
+				file >> weights[i][j][k];
+			}
+		}
+	}
+	file.close();
+	is_trained = true;
+	return true;
+}
+
+bool ANN::NeuralNetwork::Save(std::string filepath)
+{
+	if (!is_trained) return false;
+	std::ofstream file(filepath);
+	if (!file.is_open()) return false;
+	file << std::setprecision(9);
+	file << "activation type:" << std::endl;
+	file << (int)activation_type << std::endl;
+	file << "activation scale:" << std::endl;
+	file << scale << std::endl;
+	file << "configuration:" << std::endl;
+	file << configuration.size() << "\t";
+	for each (int neuron_count in configuration) {
+		file << neuron_count << "\t";
+	}
+	file << std::endl << "weights:" << std::endl;
+	for each (auto weight_matrix in weights) {
+		for each (auto weight_line in weight_matrix) {
+			for each (auto weight in weight_line) {
+				file << weight << " ";
+			}
+			file << std::endl;
+		}
+	}
+	file.close();
+	return true;
+}
+
+bool ANN::LoadData(
+	std::string filepath,
+	std::vector<std::vector<float>> & inputs,
+	std::vector<std::vector<float>> & outputs)
+{
+	std::ifstream file(filepath);
+	if (!file.is_open()) return false;
+	int buffer;
+	const int CHAR_BUF_LEN = 100;
+	char char_buffer[CHAR_BUF_LEN];
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	std::string string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("input_count:"))
+		throw "incorrect file format";
+	int input_count;
+	file >> input_count;
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("output_count:"))
+		throw "incorrect file format";
+	int output_count;
+	file >> output_count;
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("primer_count:"))
+		throw "incorrect file format";
+	int primer_count;
+	file >> primer_count;
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	file.getline(char_buffer, CHAR_BUF_LEN);
+	string_buffer = std::string(char_buffer);
+	memset(char_buffer, 0, CHAR_BUF_LEN);
+	if (string_buffer != std::string("data:"))
+		throw "incorrect file format";
+	inputs.resize(primer_count);
+	outputs.resize(primer_count);
+	//öèêë ïî ïðèìåðàì
+	for (int i = 0; i < primer_count; i++) {
+		inputs[i].resize(input_count);
+		//ñ÷èòûâàåì âõîäû
+		for (int j = 0; j < input_count; j++) {
+			file >> inputs[i][j];
+		}
+		file.getline(char_buffer, CHAR_BUF_LEN);
+		//ñ÷èòûâàåì âûõîäû
+		outputs[i].resize(output_count);
+		for (int j = 0; j < output_count; j++) {
+			file >> outputs[i][j];
+		}
+		file.getline(char_buffer, CHAR_BUF_LEN);
+		file.getline(char_buffer, CHAR_BUF_LEN);
+	}
+	file.close();
+	return true;
+}
+
+bool ANN::SaveData(
+	std::string filepath,
+	std::vector<std::vector<float>> & inputs,
+	std::vector<std::vector<float>> & outputs)
+{
+	if (inputs.size() != outputs.size())
+		throw "input size and output size must be the same";
+	if (inputs.size() * outputs.size() == 0)
+		throw "empty data";
+	size_t input_count = inputs[0].size();
+	size_t output_count = outputs[0].size();
+	for (size_t i = 0; i < inputs.size(); i++) {
+		if (inputs[i].size() != input_count)
+			throw "incorrect input size";
+		if (outputs[i].size() != output_count)
+			throw "incorrect output size";
+	}
+	std::ofstream file(filepath);
+	if (!file.is_open()) return false;
+	file << std::setprecision(9);
+	file << "input_count:" << std::endl;
+	file << inputs[0].size() << std::endl;
+	file << "output_count:" << std::endl;
+	file << outputs[0].size() << std::endl;
+	file << "primer_count:" << std::endl;
+	file << inputs.size() << std::endl;
+	file << "data:" << std::endl;
+	for (int i = 0; i < inputs.size(); i++) {
+		for (int j = 0; j < input_count; j++) {
+			file << inputs[i][j] << "\t";
+		}
+		file << std::endl;
+		for (int j = 0; j < output_count; j++) {
+			file << outputs[i][j] << "\t";
+		}
+		file << std::endl;
+		file << std::endl;
+	}
+	file.close();
+	return true;
+}
+
+std::vector<int> ANN::NeuralNetwork::GetConfiguration()
+{
+	return configuration;
+}
+
+float ANN::NeuralNetwork::Activation(float neuronInput)
+{
+	if (activation_type == POSITIVE_SYGMOID) {
+		return (1.f / (1.f + expf(-scale * neuronInput)));
+	}
+	else if (activation_type == BIPOLAR_SYGMOID) {
+		return (2.f / (1.f + expf(-scale * neuronInput)) - 1.f);
+	}
+	return -1.f;
+}
+
+float ANN::NeuralNetwork::ActivationDerivative(float activation)
+{
+	if (activation_type == POSITIVE_SYGMOID) {
+		return scale * activation * (1.f - activation);
+	}
+	else if (activation_type == BIPOLAR_SYGMOID) {
+		return scale * 0.5f * (1.f + activation) * (1.f - activation);
+	}
+	return -1;
+}
+
+ANN::NeuralNetwork::~NeuralNetwork()
+{}
+
+std::string ANN::GetTestString()
+{
+	return "Hello! You succesfully plug ANN library!";
+}

ANNLib/ANN.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#ifdef ANNDLL_EXPORTS
+#define ANNDLL_API __declspec(dllexport) 
+#else
+#define ANNDLL_API __declspec(dllimport) 
+#endif
+
+#include <vector>
+#include <memory>
+
+namespace ANN
+{
+	ANNDLL_API class NeuralNetwork
+	{
+	public:
+		enum ActivationType
+		{
+			POSITIVE_SYGMOID,
+			BIPOLAR_SYGMOID
+		};
+		/**Прочитать нейронную сеть из файла. Сеть сохраняется вызовом метода Save
+		 * @param filepath - имя и путь до файла с сеткой
+		 * @return - успешность считывания
+		 */
+		ANNDLL_API virtual bool Load(std::string filepath);
+		/**Сохранить нейронную сеть в файл. Сеть загружается вызовом метода Load
+		 * @param filepath - имя и путь до файла с сеткой
+		 * @return - успешность сохранения
+		 */
+		ANNDLL_API virtual bool Save(std::string filepath);
+		/**Получить конфигурацию сети.
+		 * @return конфигурация сети - массив - в каждом элементе хранится количество нейронов в слое.
+		 *			Номер элемента соответствует номеру слоя.
+		 */
+		ANNDLL_API virtual std::vector<int> GetConfiguration();
+
+		/**************************************************************************/
+		/**********************ЭТО ВАМ НАДО РЕАЛИЗОВАТЬ САМИМ**********************/
+		/**************************************************************************/
+		/**Получить строку с типом сети
+		 * @return описание сети
+		 */
+		ANNDLL_API virtual std::string GetType() = 0;
+		/**Спрогнозировать выход по заданному входу
+		 * @param input - вход, длина должна соответствовать количеству нейронов во входном слое
+		 * @param output -выход, длина должна соответствовать количеству нейронов в выходном слое
+		 */
+		ANNDLL_API virtual std::vector<float> Predict(std::vector<float> & input) = 0;
+		/**Обучить сеть
+		 * @param inputs - входы для обучения
+		 * @param outputs - выходы для обучения
+		 * @param max_iters - максимальное количество итераций при обучении
+		 * @param eps - средняя ошибка по всем примерам при которой происходит остановка обучения
+		 * @param speed - скорость обучения
+		 * @param std_dump - сбрасывать ли информацию о процессе обучения в стандартный поток вывода?
+		 */
+		ANNDLL_API virtual float MakeTrain(
+			std::vector<std::vector<float>> & inputs,
+			std::vector<std::vector<float>> & outputs,
+			int max_iters = 10000,
+			float eps = 0.1,
+			float speed = 0.1,
+			bool std_dump = false
+		) = 0;
+		/***************************************************************************/
+		/***************************************************************************/
+		ANNDLL_API virtual ~NeuralNetwork();
+	protected:
+		/**Веса сети*/
+		std::vector<std::vector<std::vector<float> > > weights;
+		/**Конфигурация сети.
+		 * номер элемета в массиве соответсвует номеру слоя
+		 * значение - количеству нейронов
+		 */
+		std::vector<int> configuration;
+		/**Обучена ли сеть?*/
+		bool is_trained;
+		/**Масштабирующий коэффициент аргумента сигмоиды*/
+		float scale;
+		/**Тип активационной функции*/
+		ActivationType activation_type;
+		/**Вычислить значение активационной функции
+		 * @param neuron_input - входное значение нейрона
+		 * @return - значение активационной фунции
+		 */
+		ANNDLL_API float Activation(float neuron_input);
+		/**Вычислить значение производной активационной функции
+		 * @param activation - значение активационной фнункции, для которой хотим вычислить производную
+		 * @return - значение производной активационной фунции
+		 */
+		ANNDLL_API float ActivationDerivative(float activation);
+	};
+
+	/**Создать нейронную сеть
+	 * @param configuration - конфигурация нейронной сети
+	 */
+	ANNDLL_API std::shared_ptr<ANN::NeuralNetwork> CreateNeuralNetwork(
+		std::vector<int> & configuration = std::vector<int>(),
+		NeuralNetwork::ActivationType activation_type = NeuralNetwork::POSITIVE_SYGMOID
+	);
+
+	/**Тестовая функция для проверки подключения библиотеки
+	 * @return строка с поздравлениями
+	 */
+	ANNDLL_API std::string GetTestString();
+
+	/**Считать данные из файла
+	 * @param filepath - путь и имя к файлу с данными.
+	 * @param inputs - буфер для записи входов
+	 * @param outputs - буфер для записи выходов
+	 * @return - успешность чтения
+	 */
+	ANNDLL_API bool LoadData(
+		std::string filepath,
+		std::vector<std::vector<float>> & inputs,
+		std::vector<std::vector<float>> & outputs
+	);
+
+	/**Записать данные в файл
+	* @param filepath - путь и имя к файлу с данными.
+	* @param inputs - входы для записи
+	* @param outputs - выходы для записи
+	* @return - успешность записи
+	*/
+	ANNDLL_API bool SaveData(
+		std::string filepath,
+		std::vector<std::vector<float>> & inputs,
+		std::vector<std::vector<float>> & outputs
+	);
+}