// Método que realiza o monitoramento e executa as tarefas pendentes autorizadas
public void monitorAndExecute(System.Diagnostics.EventLog log)
{
//string authToken = "uQLhVpS2kx2%2b95sRUwiq1uh8iRycp%2bWro6efT7eNTFM%3d";
string authToken = "T%2bVgaQPEbcfz%2bMbQPMd38d2pU7wL678T4nHb%2b%2fQjNI8WeISiIPYYh%2f62AqV3Uo0%2b";
List <AutomaticTask> tarefasAutorizadas = new Business.AutomaticTaskExecution().automaticTaskExecutionList();
// Se tem tarefas autorizadas
if (tarefasAutorizadas.Count > 0)
{
foreach (AutomaticTask at in tarefasAutorizadas)
{
// Para cada tarefa autorizada por um usuário, verificar a existência destas tarefas em pendência de
// execução sob a responsabilidade do usuário que autorizou
// Chama query que consulta tarefas pendentes com o codTask e na responsabilidade do usuário em questão
List <Data.Task> pendingTasks = new Business.Task().getPendingTasks(at.CodUser, at.CodTask);
// Tem dessa tarefa em andamento?
// Se sim, // Chamar o apoio à decisão para a tarefa, assim chama uma vez só para várias
// Se não tem tarefa pendente, não há por que chamar trecho de apoio à decisão e nem de finalizar
if (pendingTasks.Count > 0)
{
// Número total de execuções da tarefa
int totalExecutions = getTotalExecutions(at.CodTask);
// Lista de resultados da tarefa
List <string> DsFlowResults = getTaskResults(at.CodTask);
// Número de possíveis resultados para a tarefa sendo analisada
int classCount = DsFlowResults.Count;
// Chama a árvore de decisão // TODO: Usar árvore serializada
Data.DecisionTree dTree = runDecisionSupport(at.CodTask, totalExecutions, classCount);
// Para cada tarefa autorizada e pendente com o usuário, chama o apoio a decisão e depois finaliza a tarefa
foreach (Data.Task t in pendingTasks)
{
// Pegar a sugestão de ação para a tarefa
string action = getActionSuggestion(dTree, t.CodFlowExecute);
// Cria o objeto de referência ao webservice
Instance.Instance inst = new Instance.Instance();
//FinalizeTask02 - Finaliza a tarefa
XmlNode xml = inst.FinalizeTask02(authToken, t.CodFlowExecuteTask, action, "");
if (log != null && xml.Name == "success")
{
log.WriteEntry("A Tarefa " + t.DsTask + " do processo " + t.CodFlowExecute.ToString() + " foi finalizada automaticamente com a opção " + action + ".");
}
if (xml.Name == "success")
{
// Notificar o usuário sobre a conclusão da tarefa
new Business.AutomaticTaskExecution().notifyAutomaticExecution(at.CodTask, at.CodUser, t.CodFlowExecute);
}
}
}
}
}
}
/**
* <summary> Converts discrete attributes of a single instance to binary discrete version using 1-of-L encoding. For example, if
* an attribute has values red, green, blue; this attribute will be converted to 3 binary attributes where
* red will have the value true false false, green will have the value false true false, and blue will have the value false false true.</summary>
*
* <param name="instance">The instance to be converted.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
var size = instance.AttributeSize();
for (var i = 0; i < size; i++)
{
if (attributeDistributions[i].Count > 0)
{
var index = attributeDistributions[i].GetIndex(instance.GetAttribute(i).ToString());
for (var j = 0; j < attributeDistributions[i].Count; j++)
{
if (j != index)
{
instance.AddAttribute(new BinaryAttribute(false));
}
else
{
instance.AddAttribute(new BinaryAttribute(true));
}
}
}
}
RemoveDiscreteAttributes(instance, size);
}
/**
* <summary> The satisfy method takes an {@link Instance} as an input.
* <p/>
* If defined {@link Attribute} value is a {@link DiscreteIndexedAttribute} it compares the index of {@link Attribute} of instance at the
* attributeIndex and the index of {@link Attribute} value and returns the result.
* <p/>
* If defined {@link Attribute} value is a {@link DiscreteAttribute} it compares the value of {@link Attribute} of instance at the
* attributeIndex and the value of {@link Attribute} value and returns the result.
* <p/>
* If defined {@link Attribute} value is a {@link ContinuousAttribute} it compares the value of {@link Attribute} of instance at the
* attributeIndex and the value of {@link Attribute} value and returns the result according to the comparison character whether it is
* less than or greater than signs.</summary>
*
* <param name="instance">Instance to compare.</param>
* <returns>True if gicen instance satisfies the conditions.</returns>
*/
public bool Satisfy(Instance.Instance instance)
{
if (_value is DiscreteIndexedAttribute discreteIndexedAttribute)
{
if (discreteIndexedAttribute.GetIndex() != -1)
{
return(((DiscreteIndexedAttribute)instance.GetAttribute(_attributeIndex)).GetIndex() ==
discreteIndexedAttribute.GetIndex());
}
return(true);
}
if (_value is DiscreteAttribute discreteAttribute)
{
return(((DiscreteAttribute)instance.GetAttribute(_attributeIndex)).GetValue()
== discreteAttribute.GetValue());
}
if (_value is ContinuousAttribute continuousAttribute)
{
if (_comparison == '<')
{
return(((ContinuousAttribute)instance.GetAttribute(_attributeIndex)).GetValue() <=
continuousAttribute.GetValue());
}
if (_comparison == '>')
{
return(((ContinuousAttribute)instance.GetAttribute(_attributeIndex)).GetValue() >
continuousAttribute.GetValue());
}
}
return(false);
}
/**
* <summary> Calculates Euclidian distance between two instances. For continuous features: \sum_{i=1}^d (x_i^(1) - x_i^(2))^2,
* For discrete features: \sum_{i=1}^d 1(x_i^(1) == x_i^(2))</summary>
*
* <param name="instance1">First instance</param>
* <param name="instance2">Second instance</param>
* <returns>Euclidian distance between two instances.</returns>
*/
public double Distance(Instance.Instance instance1, Instance.Instance instance2)
{
double result = 0;
for (var i = 0; i < instance1.AttributeSize(); i++)
{
if (instance1.GetAttribute(i) is DiscreteAttribute && instance2.GetAttribute(i) is DiscreteAttribute)
{
if (((DiscreteAttribute)instance1.GetAttribute(i)).GetValue() != null &&
string.Compare(((DiscreteAttribute)instance1.GetAttribute(i)).GetValue(),
((DiscreteAttribute)instance2.GetAttribute(i)).GetValue(), StringComparison.Ordinal) != 0)
{
result += 1;
}
}
else
{
if (instance1.GetAttribute(i) is ContinuousAttribute && instance2.GetAttribute(i) is
ContinuousAttribute)
{
result += System.Math.Pow(
((ContinuousAttribute)instance1.GetAttribute(i)).GetValue() -
((ContinuousAttribute)instance2.GetAttribute(i)).GetValue(), 2);
}
}
}
return(result);
}
/**
* <summary> Adds the attribute types according to given {@link Instance}. For instance, if the attribute type of given {@link Instance}
* is a Discrete type, it than adds a discrete attribute type to the list of attribute types.</summary>
*
* <param name="instance">{@link Instance} input.</param>
*/
private void SetDefinition(Instance.Instance instance)
{
var attributeTypes = new List <AttributeType>();
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is BinaryAttribute)
{
attributeTypes.Add(AttributeType.BINARY);
}
else
{
if (instance.GetAttribute(i) is DiscreteIndexedAttribute)
{
attributeTypes.Add(AttributeType.DISCRETE_INDEXED);
}
else
{
if (instance.GetAttribute(i) is DiscreteAttribute)
{
attributeTypes.Add(AttributeType.DISCRETE);
}
else
{
if (instance.GetAttribute(i) is ContinuousAttribute)
{
attributeTypes.Add(AttributeType.CONTINUOUS);
}
}
}
}
}
_definition = new DataDefinition(attributeTypes);
}
/**
* <summary> The calculateMetric method takes an {@link Instance} and a String as inputs. It returns the dot product of given Instance
* and wi plus w0i.</summary>
*
* <param name="instance">{@link Instance} input.</param>
* <param name="Ci"> String input.</param>
* <returns>The dot product of given Instance and wi plus w0i.</returns>
*/
protected override double CalculateMetric(Instance.Instance instance, string ci)
{
var xi = instance.ToVector();
var wi = w[ci];
var w0i = w0[ci];
return(wi.DotProduct(xi) + w0i);
}
/**
* <summary> The calculateRMinusY method creates a new {@link java.util.Vector} with given Instance, then it multiplies given
* input Vector with given weights Matrix. After normalizing the output, it return the difference between the newly created
* Vector and normalized output.</summary>
*
* <param name="instance">Instance is used to get class labels.</param>
* <param name="input"> Vector to multiply weights.</param>
* <param name="weights"> Matrix of weights/</param>
* <returns>Difference between newly created Vector and normalized output.</returns>
*/
protected Vector CalculateRMinusY(Instance.Instance instance, Vector input, Matrix weights)
{
r = new Vector(K, classLabels.IndexOf(instance.GetClassLabel()), 1.0);
var o = weights.MultiplyWithVectorFromRight(input);
y = NormalizeOutput(o);
return(r.Difference(y));
}
/**
* <summary> The calculateMetric method takes an {@link Instance} and a String as inputs. It multiplies Matrix Wi with Vector xi
* then calculates the dot product of it with xi. Then, again it finds the dot product of wi and xi and returns the summation with w0i.</summary>
*
* <param name="instance">{@link Instance} input.</param>
* <param name="ci"> String input.</param>
* <returns>The result of Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i.</returns>
*/
protected override double CalculateMetric(Instance.Instance instance, string ci)
{
var xi = instance.ToVector();
var Wi = _W[ci];
var wi = w[ci];
var w0i = w0[ci];
return(Wi.MultiplyWithVectorFromLeft(xi).DotProduct(xi) + wi.DotProduct(xi) + w0i);
}
/**
* <summary> The calculateMetric method takes an {@link Instance} and a String as inputs and it returns the log likelihood of</summary>
* these inputs.
*
* <param name="instance">{@link Instance} input.</param>
* <param name="ci"> String input.</param>
* <returns>The log likelihood of inputs.</returns>
*/
protected override double CalculateMetric(Instance.Instance instance, string ci)
{
if (_classAttributeDistributions == null)
{
return(LogLikelihoodContinuous(ci, instance));
}
return(LogLikelihoodDiscrete(ci, instance));
}
/**
* <summary> The predict method takes an {@link Instance} as an input and finds the nearest neighbors of given instance. Then
* it returns the first possible class label as the predicted class.</summary>
*
* <param name="instance">{@link Instance} to make prediction.</param>
* <returns>The first possible class label as the predicted class.</returns>
*/
public override string Predict(Instance.Instance instance)
{
var nearestNeighbors = NearestNeighbors(instance);
string predictedClass;
if (instance is CompositeInstance compositeInstance && nearestNeighbors.Size() == 0)
{
predictedClass = compositeInstance.GetPossibleClassLabels()[0];
}
/**
* <summary> The predict method performs prediction on the root node of given instance, and if it is null, it returns the possible class labels.
* Otherwise it returns the returned class labels.</summary>
*
* <param name="instance">Instance make prediction.</param>
* <returns>Possible class labels.</returns>
*/
public override string Predict(Instance.Instance instance)
{
var predictedClass = _root.Predict(instance);
if (predictedClass == null && instance is CompositeInstance)
{
predictedClass = ((CompositeInstance)instance).GetPossibleClassLabels()[0];
}
return(predictedClass);
}
public override Dictionary <string, double> PredictProbability(Instance.Instance instance)
{
var distribution = new DiscreteDistribution();
foreach (var tree in _forest)
{
distribution.AddItem(tree.Predict(instance));
}
return(distribution.GetProbabilityDistribution());
}
/**
* <summary> The predict method takes an {@link Instance} as an input and loops through the {@link ArrayList} of {@link DecisionTree}s.
* Makes prediction for the items of that ArrayList and returns the maximum item of that ArrayList.</summary>
*
* <param name="instance">Instance to make prediction.</param>
* <returns>The maximum prediction of a given Instance.</returns>
*/
public override string Predict(Instance.Instance instance)
{
var distribution = new DiscreteDistribution();
foreach (var tree in _forest)
{
distribution.AddItem(tree.Predict(instance));
}
return(distribution.GetMaxItem());
}
/**
* <summary> The convertInstance method takes an {@link Instance} as an input and creates a {@link java.util.Vector} attributes from continuousAttributes.
* After removing all attributes of given instance, it then adds new {@link ContinuousAttribute} by using the dot
* product of attributes Vector and the eigenvectors.</summary>
*
* <param name="instance">Instance that will be converted to {@link ContinuousAttribute} by using eigenvectors.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
var attributes = new Vector(instance.ContinuousAttributes());
instance.RemoveAllAttributes();
foreach (var eigenvector in _eigenvectors)
{
instance.AddAttribute(new ContinuousAttribute(attributes.DotProduct(eigenvector)));
}
}
/**
* <summary> The predict method takes an Instance as an input and returns the entry of distribution which has the maximum value.</summary>
*
* <param name="instance">Instance to make prediction.</param>
* <returns>The entry of distribution which has the maximum value.</returns>
*/
public override string Predict(Instance.Instance instance)
{
if (instance is CompositeInstance compositeInstance)
{
var possibleClassLabels = compositeInstance.GetPossibleClassLabels();
return(_distribution.GetMaxItem(possibleClassLabels));
}
return(_distribution.GetMaxItem());
}
/**
* <summary> Calculates Mahalanobis distance between two instances. (x^(1) - x^(2)) S (x^(1) - x^(2))^T</summary>
*
* <param name="instance1">First instance.</param>
* <param name="instance2">Second instance.</param>
* <returns>Mahalanobis distance between two instances.</returns>
*/
public double Distance(Instance.Instance instance1, Instance.Instance instance2)
{
var v1 = instance1.ToVector();
var v2 = instance2.ToVector();
v1.Subtract(v2);
var v3 = _covarianceInverse.MultiplyWithVectorFromLeft(v1);
return(v3.DotProduct(v1));
}
/**
* <summary> Returns the standard deviation of attributes for instances.</summary>
*
* <returns>Standard deviation of attributes for instances.</returns>
*/
public Instance.Instance StandardDeviation()
{
var result = new Instance.Instance(_list[0].GetClassLabel());
for (var i = 0; i < _list[0].AttributeSize(); i++)
{
result.AddAttribute(AttributeStandardDeviation(i));
}
return(result);
}
public override Dictionary <string, double> PredictProbability(Instance.Instance instance)
{
var result = new Dictionary <string, double>();
foreach (string classLabel in _classLabels)
{
result[classLabel] = 1.0 / _classLabels.Count;
}
return(result);
}
/**
* <summary> The calculateMetric method takes an {@link Instance} and a String as inputs. It loops through the class means, if
* the corresponding class label is same as the given String it returns the negated distance between given instance and the
* current item of class means. Otherwise it returns the smallest negative number.</summary>
*
* <param name="instance">{@link Instance} input.</param>
* <param name="Ci"> String input.</param>
* <returns>The negated distance between given instance and the current item of class means.</returns>
*/
protected override double CalculateMetric(Instance.Instance instance, string ci)
{
for (var i = 0; i < _classMeans.Size(); i++)
{
if (_classMeans.Get(i).GetClassLabel() == ci)
{
return(-_distanceMetric.Distance(instance, _classMeans.Get(i)));
}
}
return(double.MinValue);
}
/**
* <summary> The predict method takes an {@link Instance} as an input, converts it to a Vector and calculates the {@link Matrix} y by
* multiplying Matrix W with {@link Vector} x. Then it returns the class label which has the maximum y value.</summary>
*
* <param name="instance">Instance to predict.</param>
* <returns>The class label which has the maximum y.</returns>
*/
public override string Predict(Instance.Instance instance)
{
CreateInputVector(instance);
CalculateOutput();
if (instance is CompositeInstance compositeInstance)
{
return(PredictWithCompositeInstance(compositeInstance.GetPossibleClassLabels()));
}
return(classLabels[y.MaxIndex()]);
}
/**
* <summary> The logLikelihoodDiscrete method takes an {@link Instance} and a class label as inputs. First it gets the logarithm</summary>
* of given class label's probability via prior distribution as logLikelihood and gets the class attribute distribution of given class label.
* Then it loops times of given instance attribute size, and accumulates the logLikelihood by calculating the logarithm of
* corresponding attribute distribution's smoothed probability by using laplace smoothing on xi.
*
* <param name="classLabel">String input class label.</param>
* <param name="instance"> {@link Instance} input.</param>
* <returns>The log likelihood of given class label and {@link Instance}.</returns>
*/
private double LogLikelihoodDiscrete(string classLabel, Instance.Instance instance)
{
var logLikelihood = System.Math.Log(priorDistribution.GetProbability(classLabel));
var attributeDistributions = _classAttributeDistributions[classLabel];
for (var i = 0; i < instance.AttributeSize(); i++)
{
var xi = ((DiscreteAttribute)instance.GetAttribute(i)).GetValue();
logLikelihood += System.Math.Log(attributeDistributions[i].GetProbabilityLaplaceSmoothing(xi));
}
return(logLikelihood);
}
/**
* <summary> Checks given instance's attribute and returns true if it is a discrete indexed attribute, false otherwise.</summary>
*
* <param name="instance">Instance to check.</param>
* <returns>True if instance is a discrete indexed attribute, false otherwise.</returns>
*/
public bool DiscreteCheck(Instance.Instance instance)
{
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is DiscreteAttribute && !(instance.GetAttribute(i) is
DiscreteIndexedAttribute))
{
return(false);
}
}
return(true);
}
/**
* <summary> Normalizes the continuous attributes of a single instance. For all i, new x_i = (x_i - m_i) / s_i.</summary>
*
* <param name="instance">Instance whose attributes will be normalized.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is ContinuousAttribute)
{
var xi = (ContinuousAttribute)instance.GetAttribute(i);
var mi = (ContinuousAttribute)_averageInstance.GetAttribute(i);
var si = (ContinuousAttribute)_standardDeviationInstance.GetAttribute(i);
xi.SetValue((xi.GetValue() - mi.GetValue()) / si.GetValue());
}
}
}
/**
* <summary> The logLikelihoodContinuous method takes an {@link Instance} and a class label as inputs. First it gets the logarithm</summary>
* of given class label's probability via prior distribution as logLikelihood. Then it loops times of given instance attribute size, and accumulates the
* logLikelihood by calculating -0.5 * ((xi - mi) / si )** 2).
*
* <param name="classLabel">String input class label.</param>
* <param name="instance"> {@link Instance} input.</param>
* <returns>The log likelihood of given class label and {@link Instance}.</returns>
*/
private double LogLikelihoodContinuous(string classLabel, Instance.Instance instance)
{
var logLikelihood = System.Math.Log(priorDistribution.GetProbability(classLabel));
for (var i = 0; i < instance.AttributeSize(); i++)
{
var xi = ((ContinuousAttribute)instance.GetAttribute(i)).GetValue();
var mi = _classMeans[classLabel].GetValue(i);
var si = _classDeviations[classLabel].GetValue(i);
logLikelihood += -0.5 * System.Math.Pow((xi - mi) / si, 2);
}
return(logLikelihood);
}
public override Dictionary <string, double> PredictProbability(Instance.Instance instance)
{
CreateInputVector(instance);
CalculateOutput();
var result = new Dictionary <string, double>();
for (var i = 0; i < classLabels.Count; i++)
{
result[classLabels[i]] = y.GetValue(i);
}
return(result);
}
/**
* <summary> Adds a new instance to the {@link InstanceList}.</summary>
*
* <param name="current">{@link Instance} to add.</param>
*/
public void AddInstance(Instance.Instance current)
{
if (_definition == null)
{
SetDefinition(current);
_instances.Add(current);
}
else
{
if (CheckDefinition(current))
{
_instances.Add(current);
}
}
}
/**
* <summary> The removeDiscreteAttributes method takes an {@link Instance} as an input, and removes the discrete attributes from
* given instance.</summary>
*
* <param name="instance">Instance to removes attributes from.</param>
* <param name="size"> Size of the given instance.</param>
*/
protected void RemoveDiscreteAttributes(Instance.Instance instance, int size)
{
var k = 0;
for (var i = 0; i < size; i++)
{
if (attributeDistributions[i].Count > 0)
{
instance.RemoveAttribute(k);
}
else
{
k++;
}
}
}
/**
* <summary> The predict method gets an Instance as an input and retrieves the possible class labels as an List. Then selects a
* random number as an index and returns the class label at this selected index.</summary>
*
* <param name="instance">{@link Instance} to make prediction.</param>
* <returns>The class label at the randomly selected index.</returns>
*/
public override string Predict(Instance.Instance instance)
{
if (instance is CompositeInstance compositeInstance)
{
var possibleClassLabels = compositeInstance.GetPossibleClassLabels();
var size = possibleClassLabels.Count;
var index = random.Next(size);
return(possibleClassLabels[index]);
}
else
{
var size = _classLabels.Count;
var index = random.Next(size);
return(_classLabels[index]);
}
}
/**
* <summary> Converts discrete attributes of a single instance to indexed version.</summary>
*
* <param name="instance">The instance to be converted.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
var size = instance.AttributeSize();
for (var i = 0; i < size; i++)
{
if (attributeDistributions[i].Count > 0)
{
var index = attributeDistributions[i].GetIndex(instance.GetAttribute(i).ToString());
instance.AddAttribute(new DiscreteIndexedAttribute(instance.GetAttribute(i).ToString(), index,
attributeDistributions[i].Count));
}
}
RemoveDiscreteAttributes(instance, size);
}
public Dictionary <string, double> PredictProbabilityDistribution(Instance.Instance instance)
{
if (_leaf)
{
return(_data.ClassDistribution().GetProbabilityDistribution());
}
foreach (var node in _children)
{
if (node._condition.Satisfy(instance))
{
return(node.PredictProbabilityDistribution(instance));
}
}
return(_data.ClassDistribution().GetProbabilityDistribution());
}
