public DadosTermostato(float temp, float setPoint, bool estado)
{
TemperaturaNormalizado = Normalizacao.Norm_Temp(temp);
SetPointNormalizado = Normalizacao.Norm_Temp(setPoint);
TemperaturaReal = temp;
SetPointReal = setPoint;
Estado = estado;
}
public static DadosMemoryDateTime UpdateValueDateTime(DateTime value)
{
var obj = new DadosMemoryDateTime
{
DataHora = value,
DataHoraNormalizado = Normalizacao.Norm_DataHoraSeg(value)
};
return(obj);
}
static void Main(string[] args)
{
BasicMLDataSet data_training = new BasicMLDataSet();
Random rdn = new Random();
////////////////////////////////////////////////////////////////////////////
//simulação de dados por arquivo:
var neuralFile = File.ReadAllLines(@"C:\Users\bredi\Desktop\TCC\TCC\neural_1.txt");
List <string> NeuralList = new List <string>(neuralFile);
double[][] entradafull = new double[NeuralList.Count][];
double[][] saidafull = new double[NeuralList.Count][];
int i = 0;
foreach (var item in NeuralList)
{
var t = item.Split(new string[] { "::" }, StringSplitOptions.None);
double[] entrada = new double[]
{
//System.Convert.ToDouble(t[0]),//hora
System.Convert.ToDouble(t[1]), //tempA
System.Convert.ToDouble(t[2]) //setA
//System.Convert.ToDouble(t[3]),//tempB
//System.Convert.ToDouble(t[4])//setB
};
entradafull[i] = entrada;
/*double a = System.Convert.ToDouble(t[5]);
* if (a == 1)
* a = 0.5f;
* else
* a = 0.5f;
* double b = System.Convert.ToDouble(t[6]);
* if (b == 1)
* b = 0.5f;
* else if (b == 0)
* b = 0.5f;*/
double[] saida = new double[]
{
System.Convert.ToDouble(t[5])//saidaA
//System.Convert.ToDouble(t[6])//saidaB
};
saidafull[i] = saida;
i++;
data_training.Add(new BasicMLData(entrada), null);
}
//IMLDataSet data_training = new BasicMLDataSet(entradafull, saidafull);//ANTIGO COM SAIDA
//////////////////////////////////////////////////////////
int N_entradas = 2;
int tamanho_X = 100; //100
int tamanho_Y = 100; //100
int N_saidas = tamanho_X * tamanho_Y;
int interacoesPlanejada = 1000;
int vizinho_inicial = 50;//50
int vizinho_final = 1;
double rate_inicial = 1;
double rate_final = 0.1;
//Criação de rede SOM.(número de entradas, número de saídas)
SOMNetwork network = new SOMNetwork(N_entradas, N_saidas);
network.Reset();
//Criação da função de ativação.(função gaussiana 2D, largura da rede, altura da rede)
NeighborhoodRBF gaussian = new NeighborhoodRBF(RBFEnum.MexicanHat, tamanho_X, tamanho_Y);
//(rede neural, taxa de aprendizado, conjunto de treinamento, função de vizinhança)
BasicTrainSOM train = new BasicTrainSOM(network, 0.01, null, gaussian);
train.ForceWinner = false;
train.SetAutoDecay(interacoesPlanejada, rate_inicial, rate_final, vizinho_inicial, vizinho_final);
//TREINAMENTO RANDOMICO:
for (int decay = 0; decay < interacoesPlanejada; decay++)
{
var idx = int.Parse(Math.Round(rdn.NextDouble() * saidafull.Length).ToString()) - 1;
if (idx == -1)
{
idx = 0;
}
var data = data_training[idx].Input;
train.TrainPattern(data);
train.AutoDecay();
Console.WriteLine(string.Format("Epoch {0}, Rate: {1}, Radius: {2}, Error: {3}", decay, train.LearningRate, train.Neighborhood.Radius, train.Error));
}
/*for (int tx = 0; tx < interacoesPlanejada; tx++)
* {
* train.Iteration();
* train.AutoDecay();
* Console.WriteLine(string.Format("Epoch {0}, Rate: {1}, Radius: {2}, Error: {3}", i, train.LearningRate, train.Neighborhood.Radius, train.Error));
* }*/
//////////////////////////////////////////////////////////
//arquivo visual//////////////////////////////////////////////////////////
string[,] arrayprint = new string[tamanho_X, tamanho_Y];
for (int x = 0; x < tamanho_X; x++)
{
for (int y = 0; y < tamanho_Y; y++)
{
arrayprint[x, y] = " ";
}
}
/*for (int TempA = 15; TempA < 25; TempA++)
* {
* for (int SetA = 15; SetA < 25; SetA++)
* {
* for (int TempB = 15; TempB < 25; TempB++)
* {
* for (int SetB = 15; SetB < 25; SetB++)
* {
* BasicMLData dataentradateste = new BasicMLData(new double[] { TempA, SetA, TempB, SetB });
* var retorno = network.Classify(dataentradateste);
* //Console.WriteLine(retorno + " ||| SetA: " + SetA + " | TempA: " + TempA + " ||| SetB: " + 20 + " | TempB: " + 0);
* var tuple = convertToXY(retorno, tamanho_X, tamanho_Y);
* var array_v = arrayprint[tuple.Item1, tuple.Item2];
* if(array_v == " ")
* {
* string saida = "";
* if(TempA >= SetA)
* saida += "a";
* else if(TempA < SetA)
* saida += "A";
* else
* saida += "#";
*
* if (TempB >= SetB)
* saida += "b";
* else if (TempB < SetB)
* saida += "B";
* else
* saida += "#";
*
* arrayprint[tuple.Item1, tuple.Item2] = saida;
* }
* }
* }
*
* }
* }*/
List <int> Lista_0 = new List <int>();
List <int> Lista_1 = new List <int>();
for (int TempA = -49; TempA < 50; TempA++)
{
for (int SetA = -49; SetA < 50; SetA++)
{
BasicMLData dataentradateste = new BasicMLData(new double[] { Normalizacao.Norm_Temp(TempA), Normalizacao.Norm_Temp(SetA) });
var retorno = network.Classify(dataentradateste);
//Console.WriteLine(retorno + " ||| SetA: " + SetA + " | TempA: " + TempA + " ||| SetB: " + 20 + " | TempB: " + 0);
var tuple = convertToXY(retorno, tamanho_X, tamanho_Y);
var array_v = arrayprint[tuple.Item1, tuple.Item2];
if (array_v == " ")
{
string saida = " ";
if (TempA >= SetA)
{
if (Lista_1.Contains(retorno))
{
saida += "#";
}
else
{
Lista_0.Add(retorno);
saida += "0";
}
}
else if (TempA < SetA)
{
if (Lista_0.Contains(retorno))
{
saida += "#";
}
else
{
Lista_1.Add(retorno);
saida += "1";
}
}
else
{
saida += "#";
}
arrayprint[tuple.Item1, tuple.Item2] = saida;
}
}
}
StringBuilder fileContents = new StringBuilder();
for (int x = 0; x < tamanho_X; x++)
{
for (int y = 0; y < tamanho_Y; y++)
{
fileContents.Append(arrayprint[x, y]);
}
fileContents.AppendLine("|");
}
File.WriteAllText(@"C:\Users\bredi\Documents\mapaneural.txt", fileContents.ToString());
//////////////////////////////////////////////////////////
////salvar network:
string path = Path.Combine(@"C:\Users\bredi\Desktop\TCC\TCC", "redeneural" + DateTime.Now.Ticks + ".txt");
if (File.Exists(path))
{
File.Delete(path);
}
FileStream fs = new FileStream(path, FileMode.CreateNew, FileAccess.Write);
PersistSOM persistSOM = new PersistSOM();
persistSOM.Save(fs, network);
fs.Close();
//////////////////////////////////////////////////////////
//testes//////////////////////////////////////////////////////////
DateTime datahora_atual = DateTime.MinValue;
do
{
DateTime datahora = Simulation.Memory.Get().dmDateTime.DataHora;
var Dados_D = Simulation.Input.Termostato_D();
var Dados_E = Simulation.Input.Termostato_E();
if (datahora >= datahora_atual.AddSeconds(.5))
{
datahora_atual = datahora;
//double hora = Normalizacao.Norm_DataHoraSeg(datahora);
//BasicMLData dataentradateste = new BasicMLData(new double[] { hora, TempA, SetA, TempB, SetB });
//BasicMLData dataentradateste = new BasicMLData(new double[] { TempA, SetA, TempB, SetB });
BasicMLData dataentradateste = new BasicMLData(new double[] { Dados_D.TemperaturaNormalizado, Dados_D.SetPointNormalizado });
var retorno = network.Winner(dataentradateste);
if (Lista_0.Contains(retorno))
{
//desligar
Simulation.Output.DesligarAquecedor_D();
Simulation.Output.DesligarAquecedor_E();
Console.WriteLine(retorno + " | OFF | ");
}
else if (Lista_1.Contains(retorno))
{
//ligar
Simulation.Output.LigarAquecedor_D();
Simulation.Output.LigarAquecedor_E();
Console.WriteLine(retorno + " | ON | ");
}
else
{
Console.WriteLine(retorno + " | OUT | ");
}
}
}while (true);
}
static void Main(string[] args)
{
ListPoints = new List <Points>();
DateTime datahora_atual = DateTime.MinValue;
bool started = false;
do
{
var datahora = Simulation.Memory.Get().dmDateTime;
var Dados_A = Simulation.Input.Termostato_A();
var Dados_D = Simulation.Input.Termostato_D();
var Dados_E = Simulation.Input.Termostato_E();
var Dados_G = Simulation.Input.Termostato_G();
bool saida_heater_A = Decisao.ResultadoAquecedorSimplificado(Dados_A.TemperaturaReal, Dados_A.SetPointReal);
bool saida_heater_D = Decisao.ResultadoAquecedorSimplificado(Dados_D.TemperaturaReal, Dados_D.SetPointReal);
bool saida_heater_E = Decisao.ResultadoAquecedorSimplificado(Dados_E.TemperaturaReal, Dados_E.SetPointReal);
bool saida_heater_G = Decisao.ResultadoAquecedorSimplificado(Dados_G.TemperaturaReal, Dados_G.SetPointReal);
if (saida_heater_A)
{
Simulation.Output.LigarAquecedor_A();
}
else
{
Simulation.Output.DesligarAquecedor_A();
}
/////////////////
if (saida_heater_D)
{
Simulation.Output.LigarAquecedor_D();
}
else
{
Simulation.Output.DesligarAquecedor_D();
}
/////////////////
if (saida_heater_E)
{
Simulation.Output.LigarAquecedor_E();
}
else
{
Simulation.Output.DesligarAquecedor_E();
}
/////////////////
if (saida_heater_G)
{
Simulation.Output.LigarAquecedor_G();
}
else
{
Simulation.Output.DesligarAquecedor_G();
}
if (datahora.DataHora.Hour == 0 && datahora.DataHora.Minute == 0 && datahora.DataHora.Second > 0)
{
started = true;
}
if (started == true)
{
if (datahora.DataHora >= datahora_atual.AddSeconds(1))
{
datahora_atual = datahora.DataHora;
var p = new Points();
p.Hora = datahora.DataHoraNormalizado;
p.TempA = Dados_A.TemperaturaNormalizado;
p.SetA = Dados_A.SetPointNormalizado;
p.TempD = Dados_D.TemperaturaNormalizado;
p.SetD = Dados_D.SetPointNormalizado;
p.TempE = Dados_E.TemperaturaNormalizado;
p.SetE = Dados_E.SetPointNormalizado;
p.TempG = Dados_G.TemperaturaNormalizado;
p.SetG = Dados_G.SetPointNormalizado;
p.SaidaEsperada.AquecedorA = Normalizacao.Norm_Bool(saida_heater_A);
p.SaidaEsperada.AquecedorD = Normalizacao.Norm_Bool(saida_heater_D);
p.SaidaEsperada.AquecedorE = Normalizacao.Norm_Bool(saida_heater_E);
p.SaidaEsperada.AquecedorG = Normalizacao.Norm_Bool(saida_heater_G);
ListPoints.Add(p);
Console.WriteLine(ListPoints.Count);
/*if (datahora.Hour == 23 && datahora.Minute == 59 && datahora.Second > 0)
* break;*/
}
}
}while (ListPoints.Count < 10000);
Salvar();
Console.WriteLine("Total points: " + ListPoints.Count);
Console.ReadKey();
}
static void Main(string[] args)
{
ListPoints = new List <Points>(10000);
Random random = new Random();
int total = 10000;
//A
for (int A = 0; A < total; A++)
{
double SetA = random.Next(5, 30) + random.NextDouble();
double SetD = random.Next(5, 30) + random.NextDouble();
double SetE = random.Next(5, 30) + random.NextDouble();
double SetG = random.Next(5, 30) + random.NextDouble();
double TempA = random.Next(-20, 50) + random.NextDouble();
double TempD = random.Next(-20, 50) + random.NextDouble();
double TempE = random.Next(-20, 50) + random.NextDouble();
double TempG = random.Next(-20, 50) + random.NextDouble();
bool estadoA = false;
bool estadoD = false;
bool estadoE = false;
bool estadoG = false;
if (SetA > TempA)
{
estadoA = true;
}
if (SetD > TempD)
{
estadoD = true;
}
if (SetE > TempE)
{
estadoE = true;
}
if (SetG > TempG)
{
estadoG = true;
}
Points p = new Points()
{
Hora = 0,
SetA = Normalizacao.Norm_Temp((float)SetA),
TempA = Normalizacao.Norm_Temp((float)TempA),
SetD = Normalizacao.Norm_Temp((float)SetD),
TempD = Normalizacao.Norm_Temp((float)TempD),
SetE = Normalizacao.Norm_Temp((float)SetE),
TempE = Normalizacao.Norm_Temp((float)TempE),
SetG = Normalizacao.Norm_Temp((float)SetG),
TempG = Normalizacao.Norm_Temp((float)TempG),
SaidaEsperada = new PointsSaida()
{
AquecedorA = Normalizacao.Norm_Bool(estadoA),
AquecedorD = Normalizacao.Norm_Bool(estadoD),
AquecedorE = Normalizacao.Norm_Bool(estadoE),
AquecedorG = Normalizacao.Norm_Bool(estadoG)
}
};
ListPoints.Add(p);
}
Salvar();
Console.WriteLine("total: " + ListPoints.Count);
Console.ReadKey();
}
