brain.cpp

#include <iostream>
#include <chrono>       // std::chrono::system_clock
#include <string>
#include <regex>
#include "net.h"
#include "verylong.h"
 
#include "string.h"
 
int main()
{
  std::vector<std::string> result;
 
  //std::string regex = "[\\s,]+";
  //std::string regex = "([A-Za-z])*";
  //std::string regex = "([\\d]+)";
  //std::string regex = "([\\d]+).*([\\d]+)";
//  std::string regex = "([\\d]+).+([\\d]+)";
  //std::string regex = "\\b([\\d])([^ ]*)";
  std::string regex = "([A-Z]+)([\\d]+)";
 
  std::regex reg(regex);
  std::cout << "RS=" << reg.mark_count() << std::endl;
 
 
  //std::string ss = "The1White2Rabbit,333is4very,late.";
  //std::string ss = "5yz0ab1cde2fgh";
  //std::string ss = "MAY14";
  std::string ss = "aaaMAY14bbbJUNE4";
 
  result = string_find(ss, regex);
 
  for (int i = 0; i < result.size(); i++)
  {
    std::cout << "[" << i << "]=" << result[i] << "#" << std::endl;
  }
 
  //   std::string s("This is a catfish");
  //   std::string regex("(cat)");
  //   std::string r("(dog)");
  ss = "This cat is a catfish";
  regex = "(cat)";
  std::string result2;
  result2 = string_replace(ss, regex, "dog", std::regex_constants::format_first_only);
  std::cout << result2 << std::endl;
  result2 = string_replace(ss, regex, "ha ha $$1 boo");
  std::cout << result2 << std::endl;
  result2 = string_replace(ss, regex, "ha ha $$1 boo", false);
  std::cout << result2 << std::endl;
 
 
  ss = "there is a subsequence in the string\n";
  regex = "(sub)";
  result2 = string_replace(ss, regex, "xyz");
  std::cout << result2 << std::endl;
 
  ss = "April 15, 2003";
  regex = "(\\w+) (\\d+), (\\d+)";
  result2 = string_replace(ss, regex, "$011,$3");
  std::cout << result2 << std::endl;
 
  ss = "  14MAY  15JUNE ";
  std::cout << "[" << ss << "]" << std::endl;
  //regex = "([\\d]+)([A+Z]+)";
  regex = "(\\d+)([A-Z]+)";
  result2 = string_replace(ss, regex, "$1 $2");
  std::cout << "[" << result2 << "]" << std::endl;
  result2 = string_replace(ss, regex, "$1 $2", std::regex_constants::format_no_copy);
  std::cout << "[" << result2 << "]" << std::endl;
  result2 = string_replace(ss, regex, "$1 $2", false);
  std::cout << "[" << result2 << "]" << std::endl;
 
 
  /*
  std::string s3("there is a subsequence in the string\n");
  std::regex e("\\b(sub)([^ ]*)");   // matches words beginning by "sub"
 
  // using string/c-string (3) version:
  std::cout << std::regex_replace(s3, e, "sub-$2");
 
  // using range/c-string (6) version:
  std::string result2;
  std::regex_replace(std::back_inserter(result2), s3.begin(), s3.end(), e, "$2");
  std::cout << result2;
 
  // with flags:
  std::cout << std::regex_replace(s3, e, "$1 and $2", std::regex_constants::format_no_copy);
  std::cout << std::endl;
  */
 
  std::cout << "HEAD" << std::endl;
  ss = "0 HEAD";
  regex = "([\\d]+)[\\s]+([A-Z]*)$";
  //regex = "([\\d]+)([A-Z]*)";
  // regex = "[\\d]+[A-Z]*";
 
  result.clear();
  result = string_tokenize(ss, regex);
  for (int i = 0; i < result.size(); i++)
  {
    std::cout << "[" << i << "]=" << result[i] << "#" << std::endl;
  }
 
 
 
  /*
 
  show_matches("abcdef", "abc|def");
  show_matches("abc", "ab|abc"); // left Alernative matched first
  show_matches("abc", "((a)|(ab))((c)|(bc))");
  */
#ifdef _MSC_VER
  std::string s1;
  std::getline(std::cin, s1);
#endif
 
 
  //return 0;
 
 
 
 
  /*
	Verylong v1("12345678901234567890123456789");
	v1 = 2;
	std::cout << "V1=" << v1 << std::endl;
	Verylong v2(1);
	v1 += v2;
	std::cout << "V1=" << v1 << std::endl;
	v1 ^= 80;
	//v1 ^= 5;
	std::cout << "V1=" << v1 << std::endl;
 
 
	Verylong v3(0);
	v1 = 12;
	v2 = 2;
	v3 = v1 ^ v2;
	std::cout << "V3=" << v3 << std::endl;
 
	Verylong v4(0);
	v4 = v1;
	std::cout << "V4=" << v4 << std::endl;
 
	//return 0;
  */
 
  std::vector<int> myvector;
 
  // set some values (from 1 to 10)
  for (int i = 1; i <= 10; i++) myvector.push_back(i);
 
  // erase the 6th element
  myvector.erase(myvector.begin() + 5);
 
  // erase the first 3 elements:
  myvector.erase(myvector.begin(), myvector.begin() + 3);
 
  std::cout << "myvector contains:";
  for (unsigned i = 0; i<myvector.size(); ++i)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';
 
  myvector.push_back(2);
 
  std::cout << "myvector now contains:";
  for (unsigned i = 0; i<myvector.size(); ++i)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';
 
 
  std::cout << "****************DQN***********************" << std::endl;
 
  /*
  To learn to get out to room 5 from any other room as quick as possible.
 
        [1]---
         |    |
         |     |
         |      |
  [2]---[3]    [5]
         |      |
         |    |
         |   |
  [0]---[4]---
 
  otherwise shown as 
 
  [0]---[1]---[5]
   |     |      
   |     |
   |     |
  [4]---[3]---[2]
   |
   |
   |
  [5]
 
  */
 
 
  srand((unsigned int)time(NULL));
  std::vector<unsigned int> myDQNTopology;
  myDQNTopology.push_back(6); // 6 neurons. (in layer 0).
 
  std::cout << myDQNTopology.size() << std::endl << std::endl; // myTopology == {3, 4, 2 ,1}
 
  Net myDQN(myDQNTopology);
 
  myDQN.setGoalAmount(100);
 
  const std::vector< std::vector<double> > connections = {
    //{ 0, 0, 0, 0, 0 },
    { 0, 0, 0, 4, 0 }, // from Layer 0, Neuron 0 to Layer 0, Neuron 4 give a value of zero.
    { 0, 1, 0, 1, 0 },
    { 0, 1, 0, 3, 0 },
    { 0, 1, 0, 5, 100 },
    //{ 0, 2, 0, 2, 0 },
    { 0, 2, 0, 3, 0 },
    //{ 0, 3, 0, 3, 0 },
    { 0, 3, 0, 1, 0 },
    { 0, 3, 0, 2, 0 },
    { 0, 3, 0, 4, 0 },
    //{ 0, 4, 0, 4, 0 },
    { 0, 4, 0, 0, 0 },
    { 0, 4, 0, 3, 0 },
    { 0, 4, 0, 5, 100 },
    { 0, 5, 0, 5, 100 },
    { 0, 5, 0, 1, 0 },
    { 0, 5, 0, 4, 0 }
  };
 
 
  /*
  const std::vector< std::vector<double> > connections = {
    { 0, 0, 0, 0, 0 },
    { 0, 0, 0, 1, 0 },
    { 0, 0, 0, 3, 0 },
    { 0, 1, 0, 1, 0 },
    { 0, 1, 0, 0, 0 },
    { 0, 1, 0, 2, 100 },
    { 0, 2, 0, 2, 100 },
    { 0, 2, 0, 1, 0 },
    { 0, 2, 0, 5, 0 },
    { 0, 3, 0, 3, 0 },
    { 0, 3, 0, 0, 0 },
    { 0, 2, 0, 4, 0 },
    { 0, 4, 0, 4, 0 },
    { 0, 4, 0, 1, 0 },
    { 0, 4, 0, 3, 0 },
    { 0, 4, 0, 5, 0 },
    { 0, 5, 0, 5, 0 },
    { 0, 5, 0, 2, 100 },
    { 0, 5, 0, 4, 0 }
  };
  */
 
  myDQN.connect(connections);
 
 
  /*
  unsigned int connection_idx = 0;
 
  myDQN.connect(0, 0, 0, 0, 0, connection_idx++);
  myDQN.connect(0, 0, 0, 4, 0, connection_idx++);
  myDQN.connect(0, 1, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 1, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 1, 0, 5, 100, connection_idx++);
  myDQN.connect(0, 2, 0, 2, 0, connection_idx++);
  myDQN.connect(0, 2, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 2, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 4, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 4, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 0, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 5, 100, connection_idx++);
  myDQN.connect(0, 5, 0, 5, 100, connection_idx++);
  myDQN.connect(0, 5, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 5, 0, 4, 0, connection_idx++);
  */
 
  /*
  myDQN.connect(0, 0, 0, 0, 0, connection_idx++);
  myDQN.connect(0, 0, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 0, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 1, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 1, 0, 0, 0, connection_idx++);
  myDQN.connect(0, 1, 0, 2, 100, connection_idx++);
  myDQN.connect(0, 2, 0, 2, 100, connection_idx++);
  myDQN.connect(0, 2, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 2, 0, 5, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 0, 0, connection_idx++);
  myDQN.connect(0, 3, 0, 4, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 4, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 1, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 3, 0, connection_idx++);
  myDQN.connect(0, 4, 0, 5, 0, connection_idx++);
  myDQN.connect(0, 5, 0, 5, 0, connection_idx++);
  myDQN.connect(0, 5, 0, 4, 0, connection_idx++);
  myDQN.connect(0, 5, 0, 2, 100, connection_idx++);
  */
 
 
  myDQN.printOutput();
 
  for (unsigned int i = 0; i<1000; ++i)
    myDQN.DQN();
 
  myDQN.printOutput();
  myDQN.printResult();
  myDQN.showPolicy();
 
#ifdef _MSC_VER
  std::string s2;
  std::getline(std::cin, s2);
#endif
 
//  return 0;
 
  std::cout << "****************BACKPROP***********************" << std::endl;
	srand((unsigned int)time(NULL));
	std::vector<unsigned int> myTopology;
	myTopology.push_back(2);
	//myTopology.push_back(3); 1 for bias.
	myTopology.push_back(4);
	//myTopology.push_back(8);
	//myTopology.push_back(2);
	myTopology.push_back(1);
 
	std::cout << myTopology.size() << std::endl << std::endl; // myTopology == {3, 4, 2 ,1}
	//Neural::Net myNet(myTopology);
	Net myNet(myTopology);
 
 
	std::cout << "****************SET VALS***********************" << std::endl;
 
  myNet.connectForward();
	//myNet.setTest();
 
	std::cout << "****************FORWARD***********************" << std::endl;
 
	/*
	for (unsigned int i = 0; i<50; ++i)
	{
		myNet.feedForward({ 1, 1 });
		myNet.backPropagate({ 0 });
	}
 
	for (unsigned int i = 0; i<50; ++i)
	{
		myNet.feedForward({ 0, 0 });
		myNet.backPropagate({ 1 });
	}
	*/
 
	for (unsigned int i = 0; i<50000; ++i)
  //for (unsigned int i = 0; i<100000; ++i)
  //for (unsigned int i = 0; i<500000; ++i)
	{
		myNet.feedForward({ 0, 0 });
		myNet.backPropagate({ 0 });
 
		myNet.feedForward({ 1, 0 });
		myNet.backPropagate({ 1 });
 
		myNet.feedForward({ 0, 1 });
		myNet.backPropagate({ 1 });
 
		myNet.feedForward({ 1, 1 });
		myNet.backPropagate({ 0 });
	}
 
	/*
	std::cout << "Feeding 0,0" << std::endl;
	myNet.feedForward({ 0, 0 });
	myNet.printOutput();
 
	std::cout << "Feeding 1,1" << std::endl;
	myNet.feedForward({ 1, 1 });
	myNet.printOutput();
	*/
 
	std::cout << "****************BACK**************************" << std::endl;
 
	//myNet.backPropagate({0});
	std::cout << "Feeding 0,0" << std::endl;
	myNet.feedForward({ 0, 0 });
	//myNet.printOutput();
	myNet.printResult();
 
	//myNet.backPropagate({1});
	std::cout << "Feeding 1,0" << std::endl;
	myNet.feedForward({ 1, 0 });
	//myNet.printOutput();
	myNet.printResult();
 
	//myNet.backPropagate({1});
	std::cout << "Feeding 1,1" << std::endl;
	myNet.feedForward({ 1, 1 });
	//myNet.printOutput();
	myNet.printResult();
 
	//myNet.backPropagate({1});
	std::cout << "Feeding 0,1" << std::endl;
	myNet.feedForward({ 0, 1 });
	//myNet.printOutput();
	myNet.printResult();
 
 
#ifdef _MSC_VER
  std::string s;
  std::getline(std::cin, s);
#endif
 
 
	return 0;
}