public int getNullsCount(int codTask, DecisionSupportField c)
{
using (DbConnection cn = b.CreateConnection())
{
using (DbCommand cmd = b.CreateCommand(cn))
{
cmd.CommandText = "wfSP_GET_NULL_COUNT";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(CreateParameter("@CodTask", DbType.Int32, codTask));
cmd.Parameters.Add(CreateParameter("@CodField", DbType.Int32, c.codigo));
cn.Open();
return(Convert.ToInt32(cmd.ExecuteScalar()));
}
}
}
public List <string> getValuesListFromExecution(DataTable executionData, Dictionary <dynamic, int> fieldSymbols)
{
List <string> fieldValuesList = new List <string>();
foreach (DataRow dr2 in executionData.Rows)
{
// Loop para montar o translate dos campos que se quer a resposta. - Loop nos campos relevantes
foreach (KeyValuePair <dynamic, int> entry in fieldSymbols)
{
DecisionSupportField c = entry.Key;
if (c.relevante)
{
fieldValuesList.Add(dr2[c.codigo.ToString()].ToString());
}
}
}
return(fieldValuesList);
}
public List <string> prepareFieldList(
ref Dictionary <dynamic, int> fieldSymbols,
ref StringBuilder CodFieldListSB,
ref StringBuilder CodFieldListSBIsNull,
ref StringBuilder DsFieldNameList,
ref List <string> codFieldList
)
{
bool isNotFirst = false;
foreach (KeyValuePair <dynamic, int> entry in fieldSymbols)
{
DecisionSupportField field = entry.Key;
if (isNotFirst)
{
if (field.relevante)
{
CodFieldListSB.Append(",");
CodFieldListSBIsNull.Append(",");
DsFieldNameList.Append(",");
}
}
if (field.relevante)
{
CodFieldListSB.Append("[" + field.codigo.ToString() + "]");
CodFieldListSBIsNull.Append("isnull([" + field.codigo.ToString() + "],'0') as '" + field.codigo.ToString() + "'");
DsFieldNameList.Append("[" + field.nome + "]");
codFieldList.Add(field.codigo.ToString());
isNotFirst = true;
}
}
List <string> codFieldListComDsFlowResult = new List <string>(codFieldList);
codFieldListComDsFlowResult.Add("DsFlowResult");
return(codFieldListComDsFlowResult);
}
public int getNullsCount(int codTask, DecisionSupportField c)
{
return(new Database.DecisionSupport().getNullsCount(codTask, c));
}
public Data.DecisionTree runDecisionSupport(int codTask, int totalExecutions, int classCount)
{
Data.DecisionTree decisionTree = new Data.DecisionTree();
// Utilizado se já existe uma árvore de decisão prévia criada, serve para reutilização de alguns parâmetros
Data.DecisionTree serializedTree = null;
// Verifica se já existe uma árvore gerada anteriormente
bool hasSerializedTree = decisionTree.Serialization.hasSerializedTree(codTask);
// Carregar a árvore existente
if (hasSerializedTree)
{
serializedTree = decisionTree.deserializeTree(codTask);
}
// Número total de execuções da tarefa
//int totalExecutions = getTotalExecutions(codTask);
Dictionary <dynamic, int> fieldSymbols = new Dictionary <dynamic, int>();
// Preenche o dicionário com a lista de campos do processo e a quantidade de símbolos para cada campo
fillSymbolsCount(codTask, ref fieldSymbols);
// Preenche a relevância dos campos de acordo com a taxa de variação e de nulos
setSymbolsRelevance(ref fieldSymbols, totalExecutions, codTask);
StringBuilder CodFieldListSB = new StringBuilder();
StringBuilder CodFieldListSBIsNull = new StringBuilder();
StringBuilder DsFieldNameList = new StringBuilder();
List <string> codFieldList = new List <string>();
// Prepara lista de campos
List <string> codFieldListComDsFlowResult = prepareFieldList(ref fieldSymbols, ref CodFieldListSB, ref CodFieldListSBIsNull, ref DsFieldNameList, ref codFieldList);
// Consulta os dados de treino
DataTable data = getData(codTask, CodFieldListSB, CodFieldListSBIsNull);
decisionTree.Data = data;
// Criando o objeto TRAINING
decisionTree.Training.setTrainingData(data);
// Preenchendo o VALIDATION do DecisionTree
decisionTree.Validation.setValidationData(data);
// ############################################# Passado para a classe Training.
// Passando o data para criação do codebook
// Converte em números inteiros as strings
Codification codebook = new Codification(data, codFieldListComDsFlowResult.ToArray());
// Montando a tabela de variáveis de decisão
List <DecisionVariable> decisionaVariableList = new List <DecisionVariable>();
foreach (KeyValuePair <dynamic, int> entry in fieldSymbols.Where(p => ((DecisionSupportField)p.Key).relevante == true))
{
DecisionSupportField c = entry.Key;
c.simbolos = entry.Value;
decisionaVariableList.Add(new DecisionVariable(c.codigo.ToString(), c.simbolos + 1)); // Adicionando + 1 do possível nulo
}
int qtdCamposRelevantes = fieldSymbols.Count(i => ((DecisionSupportField)i.Key).relevante == true);
DecisionVariable[] attributes = new DecisionVariable[qtdCamposRelevantes];
// Tabela de variáveis que impactam na decisão
attributes = decisionaVariableList.ToArray();
//List<string> DsFlowResults = getTaskResults(codTask);
// Número de possíveis resultados para a tarefa sendo analisada
//int classCount = DsFlowResults.Count;
// Cria a árvore de decisão
Accord.MachineLearning.DecisionTrees.DecisionTree tree = new Accord.MachineLearning.DecisionTrees.DecisionTree(attributes, classCount);
// Cria uma instância do algoritmo de aprendizado utilizado, o ID3
ID3Learning id3learning = new ID3Learning(tree);
// Traduz os dados de treino em simbolos inteiros utilizando o codebook
DataTable symbols = codebook.Apply(decisionTree.Training.TrainingData);
// Colunas de entrada
// *** Quantidade de colunas dos inputs deve ser o mesmo número de DecisionVariables(attributes)
int[][] inputs = symbols.ToArray <int>(codFieldList.ToArray());
// Coluna com a saída
int[] outputs = symbols.ToArray <int>("DsFlowResult");
// Aprendendo com as instâncias de treino
id3learning.Run(inputs, outputs);
// ############################################# Passado para a classe Training.
decisionTree.Tree = tree;
// Atribuindo as listas de códigos de campos e nomes ao objeto decisionTree
// Utilizado para manter o uso da palavra chave 'ref'
decisionTree.CodFieldListSB = CodFieldListSB;
decisionTree.CodFieldListSBIsNull = CodFieldListSBIsNull;
decisionTree.DsFieldNameList = DsFieldNameList;
decisionTree.codFieldList = codFieldList;
decisionTree.codFieldListComDsFlowResult = codFieldListComDsFlowResult;
decisionTree.fieldSymbols = fieldSymbols;
decisionTree.Codebook = codebook;
decisionTree.serializeTree(codTask);
return(decisionTree);
}
public void setSymbolsRelevance(ref Dictionary <dynamic, int> fieldSymbols, int totalExecutions, int codTask)
{
// ### Para cada campo, verificar se o campo tem uma variação de símbolos aceitável para utiliza-lo na árvore ###
foreach (KeyValuePair <dynamic, int> entry in fieldSymbols)
{
DecisionSupportField field = entry.Key;
field.simbolos = entry.Value;
// Constante
if (field.simbolos <= 1)
{
field.relevante = false;
}
double indice = ((entry.Value * 100) / totalExecutions);
int indexLimit = 100;
if (totalExecutions >= 100)
{
indexLimit = 12;
}
else if (totalExecutions < 100 && totalExecutions >= 50)
{
indexLimit = 15;
}
else if (totalExecutions < 50 && totalExecutions >= 25)
{
indexLimit = 20;
}
else if (totalExecutions < 25 && totalExecutions > 10)
{
indexLimit = 30;
}
else if (totalExecutions <= 10 && totalExecutions > 5)
{
indexLimit = 50;
}
else if (totalExecutions <= 5)
{
indexLimit = 100;
}
// ? Verificar aqui se possui fonte de dados(Verificar tb o tamanho da fonte) ?
// Se a variação de valores é pequena, este campo será utilizado
if (indice <= indexLimit) //12
{
field.relevante = true;
}
else
{
field.relevante = false;
}
}
// #### IMPORTANTE #### - Checar se os campos selecionados possuem muitos nulos. Se o número for alto, deverá ser descartado
foreach (KeyValuePair <dynamic, int> entry in fieldSymbols)
{
DecisionSupportField c = entry.Key;
if (c.relevante)
{
// Gargalo - Contagem de nulos está incorreta
int nulls = getNullsCount(codTask, c);
int indiceNulls = (nulls * 100) / totalExecutions;
// ? CodOrder ? - Dividir nulls pelo quantidade de opções(Campo do tipo checkbox)
if (indiceNulls > 30)
{
c.relevante = false;
}
// Constante
if (c.simbolos <= 1)
{
c.relevante = false;
}
}
}
}