Пример #1
0
        internal void GetBestTagSequence(IList <FeatureVector> words, out double[] prob_c_w, out int[] c_w)
        {
            c_w      = new int[words.Count];
            prob_c_w = new double[words.Count];

            double[][] probs_v_c = new double[words.Count][];
            for (int v_i = 0; v_i < words.Count; v_i++)
            {
                double[] details;
                int      sysClass = classifier.Classify(words[v_i], out details);
                probs_v_c[v_i] = details;

                string prevT_name              = v_i - 1 < 0 ? "BOS" : classToClassId[c_w[v_i - 1]];
                string prevT_featureName       = string.Format("prevT={0}", prevT_name);
                string prevTwoTags_name        = v_i - 2 < 0 ? "BOS" : classToClassId[c_w[v_i - 2]];
                string prevTwoTags_featureName = string.Format("prevTwoTags={0}+{1}", prevTwoTags_name, prevT_name);
                var    prevT_f       = featureToFeatureId[prevT_featureName];
                var    prevTwoTags_f = featureToFeatureId[prevTwoTags_featureName];

                for (int c_i = 0; c_i < classToClassId.Count; c_i++)
                {
                    double logProb = Math.Log(probs_v_c[v_i][c_i], Math.E);
                    logProb            += classifier.CalculateLogProb_c_f(c_i, prevT_f);
                    logProb            += classifier.CalculateLogProb_c_f(c_i, prevTwoTags_f);
                    probs_v_c[v_i][c_i] = Math.Pow(Math.E, logProb);
                }
                NormalizationHelper.Normalize(probs_v_c[v_i]);
                int bestClass = StatisticsHelper.ArgMax(probs_v_c[v_i]);
                c_w[v_i]      = bestClass;
                prob_c_w[v_i] = probs_v_c[v_i][bestClass];
            }
        }
        public ActionResult Saaty([FromBody] Alternative[] array)
        {
            array.ToList().ForEach(x => x.Mark = Math.Round(x.Mark));
            var saaty = NormalizationHelper.DefaultSaaty(array);

            return(Ok(saaty));
        }
        public void traning(string traningexamplespath)
        {
            IVersatileDataSource source = new CSVDataSource(traningexamplespath, false, CSVFormat.DecimalPoint);
            var data = new VersatileMLDataSet(source);

            data.DefineSourceColumn("num1", 0, ColumnType.Continuous);
            data.DefineSourceColumn("num2", 1, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 2, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 3, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 4, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 5, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 6, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 7, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 8, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 9, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 10, ColumnType.Continuous);
            data.DefineSourceColumn("num1", 11, ColumnType.Continuous);
            ColumnDefinition outputColumn = data.DefineSourceColumn("kind", 12, ColumnType.Nominal);

            data.Analyze();
            data.DefineSingleOutputOthersInput(outputColumn);


            var model = new EncogModel(data);

            model.SelectMethod(data, MLMethodFactory.TypeFeedforward);

            // Send any output to the console.
            model.Report = new ConsoleStatusReportable();

            // Now normalize the data.  Encog will automatically determine the correct normalization
            // type based on the model you chose in the last step.
            data.Normalize();

            model.HoldBackValidation(0.3, true, 1001);

            // Choose whatever is the default training type for this model.
            model.SelectTrainingType(data);

            // Use a 5-fold cross-validated train.  Return the best method found.
            bestMethod = (IMLRegression)model.Crossvalidate(5, true);

            //Console.WriteLine(@"Training error: " + model.CalculateError(bestMethod, model.TrainingDataset));
            //Console.WriteLine(@"Validation error: " + model.CalculateError(bestMethod, model.ValidationDataset));

            // Display our normalization parameters.
            helper = data.NormHelper;
            // Console.WriteLine(helper.ToString());

            // Display the final model.
            //Console.WriteLine(@"Final model: " + bestMethod);
            source.Close();

            saveNetwork("save.eg");
            savehelper("helper.hp");
            //EncogFramework.Instance.Shutdown();
        }
        public ActionResult KolSaaty([FromBody] Alternative[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                array[i].Mark = NormalizationHelper.MarkToSaatyRange(array[i].Mark);
            }
            var saaty = NormalizationHelper.KolSaaty(array);

            return(Ok(saaty));
        }
Пример #5
0
        /// <summary>
        /// Handles an inferred equality theorem by communicating it with the normalization helper and scheduler, and also handling proof
        /// construction is the proof data is provided.
        /// </summary>
        /// <param name="equality">The equality theorem to be handled.</param>
        /// <param name="helper">The normalization helper that verifies and normalizes the theorem.</param>
        /// <param name="scheduler">The scheduler of inference rules used for the new objects and theorems this equality might have brought.</param>
        /// <param name="proofData">Either the data needed to mark the theorem's inference in case it's correct; or null, if we are not constructing proofs.</param>
        /// <param name="isValid">Indicates whether the theorem has been found geometrically valid.</param>
        /// <param name="anyChangeOfNormalVersion">Indicates whether this equality caused any change of the normal version of some object.</param>
        private void HandleEquality(Theorem equality, NormalizationHelper helper, Scheduler scheduler, ProofData proofData, out bool isValid, out bool anyChangeOfNormalVersion)
        {
            // Mark the equality to the helper
            helper.MarkProvedEquality(equality, out var isNew, out isValid, out var result);

            // If it turns out not new or valid, we're done
            if (!isNew || !isValid)
            {
                // No removed objects
                anyChangeOfNormalVersion = false;

                // We're done
                return;
            }

            // If we should construct proof, mark the inference to the proof builder
            proofData?.ProofBuilder.AddImplication(proofData.InferenceData, equality, proofData.Assumptions);

            #region Handling new normalized theorems

            // Go through all of them
            foreach (var(originalTheorem, equalities, normalizedTheorem) in result.NormalizedNewTheorems)
            {
                // If we should construct proof, mark the normalized theorem to the proof builder
                proofData?.ProofBuilder.AddImplication(ReformulatedTheorem, normalizedTheorem, assumptions: equalities.Concat(originalTheorem).ToArray());

                // Let the scheduler know about the new normalized theorem
                scheduler.ScheduleAfterProving(normalizedTheorem);
            }

            #endregion

            // Invalidate theorems
            result.DismissedTheorems.ForEach(scheduler.InvalidateTheorem);

            // Invalidate removed objects
            result.RemovedObjects.ForEach(scheduler.InvalidateObject);

            // Handle changed objects
            result.ChangedObjects.ForEach(changedObject =>
            {
                // First we will invalidate them
                scheduler.InvalidateObject(changedObject);

                // And now schedule for them again as if they were knew because now the results of schedules might be different
                scheduler.ScheduleAfterDiscoveringObject(changedObject);
            });

            // Handle entirely new objects
            result.NewObjects.ForEach(newObject => HandleNewObject(newObject, helper, scheduler, proofData?.ProofBuilder));

            // Set if there has been any change of normal version, which is indicated by removing
            // an object or changing its normal version
            anyChangeOfNormalVersion = result.RemovedObjects.Any() || result.ChangedObjects.Any();
        }
 public int loadHelper(string name)
 {
     try
     {
         helper = ReadFromBinaryFile <NormalizationHelper>(name);
         return(1);
     }
     catch
     {
         return(0);
     }
 }
Пример #7
0
        public IntegralCriterionMethodResult FindDecision(Model model)
        {
            var result = new IntegralCriterionMethodResult("Мультипликативный критерий", "Значение мультипликативного критерия");

            // Нормализуем критерии и определим их тип
            foreach (Criterion crit in model.Criteria.Values)
            {
                Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(model.Experiments, crit);
                result.AddNormalizedCriterion(normalizedCrit, crit.Id);
            }

            // Вычислим значения мультипликативного критерия для каждого из
            // экспериментов
            var multiplicativeCriterion = new Dictionary <TId, double>();

            foreach (Experiment exp in model.Experiments.Values)
            {
                if (exp.IsActive)
                {
                    double multiplicativeCriterionValue = 1;
                    foreach (Criterion crit in model.Criteria.Values)
                    {
                        double normalizedCriterionValue =
                            result.GetNormalizedCriterion(crit.Id)[exp.Id];
                        normalizedCriterionValue = Math.Pow(normalizedCriterionValue, crit.Weight);
                        // Вычислим
                        multiplicativeCriterionValue *= normalizedCriterionValue;
                    }

                    multiplicativeCriterion.Add(exp.Id, multiplicativeCriterionValue);
                }
            }

            // Отсортируем результаты по возрастанию
            List <SortableDouble> sortedValues = multiplicativeCriterion.Select <KeyValuePair <TId, double>, SortableDouble>(
                kvp => new SortableDouble()
            {
                Direction = SortDirection.Ascending, Id = kvp.Key, Value = kvp.Value
            }
                ).ToList();

            sortedValues.Sort();

            // Заполним результаты
            foreach (SortableDouble sortedValue in sortedValues)
            {
                result.SortedPoints.Add(sortedValue.Id);
                result.AdditionalData.Add(sortedValue.Id, sortedValue.Value);
            }

            return(result);
        }
Пример #8
0
        /// <summary>
        /// Handles an inferred theorem by communicating it with the normalization helper and scheduler, and also handling proof
        /// construction is the proof data is provided.
        /// </summary>
        /// <param name="theorem">The theorem to be handled.</param>
        /// <param name="helper">The normalization helper that verifies and normalizes the theorem.</param>
        /// <param name="scheduler">The scheduler of inference rules used for the theorem if it is correct.</param>
        /// <param name="proofData">Either the data needed to mark the theorem's inference in case it's correct; or null, if we are not constructing proofs.</param>
        /// <param name="isValid">Indicates whether the theorem has been found geometrically valid.</param>
        private void HandleNonequality(Theorem theorem, NormalizationHelper helper, Scheduler scheduler, ProofData proofData, out bool isValid)
        {
            // Mark the theorem to the helper
            helper.MarkProvedNonequality(theorem, out var isNew, out isValid, out var normalizedTheorem, out var equalities);

            // If it turns out not new or valid, we're done
            if (!isNew || !isValid)
            {
                return;
            }

            #region Handle proof construction

            // Mark the original theorem
            proofData?.ProofBuilder.AddImplication(proofData.InferenceData, theorem, proofData.Assumptions);

            // If any normalization happened
            if (equalities.Any())
            {
                // Mark the normalized theorem too
                proofData?.ProofBuilder.AddImplication(ReformulatedTheorem, normalizedTheorem, assumptions: equalities.Concat(theorem).ToArray());
            }

            #endregion

            // Let the scheduler know
            scheduler.ScheduleAfterProving(normalizedTheorem);

            #region Inference from symmetry

            // If the theorem use an object that is not part of the original configuration,
            // then we will not do any symmetry inference. If it could prove a new theorem,
            // then this new theorem would be inferable conventionally
            if (!normalizedTheorem.GetInnerConfigurationObjects().All(helper.Configuration.AllObjects.Contains))
            {
                return;
            }

            // Otherwise try to infer new theorems using this one
            foreach (var inferredTheorem in normalizedTheorem.InferTheoremsFromSymmetry(helper.Configuration))
            {
                // If it can be done, make sure the proof builder knows it
                proofData?.ProofBuilder.AddImplication(InferableFromSymmetry, inferredTheorem, assumptions: new[] { normalizedTheorem });

                // Call this method to handle this new inferred theorem, without caring if it is valid (it should be logically)
                HandleNonequality(inferredTheorem, helper, scheduler, proofData, isValid: out var _);
            }

            #endregion
        }
Пример #9
0
        private static Dictionary <TId, Experiment> PrepareCriteria(Model model)
        {
            var experiments = new Dictionary <TId, Experiment>();

            foreach (Experiment exp in model.Experiments.Values)
            {
                if (!exp.IsActive)
                {
                    continue;
                }

                experiments.Add(exp.Id, new Experiment(exp.Id, exp.Number));
            }

            foreach (Criterion crit in model.Criteria.Values)
            {
                foreach (Experiment exp in model.Experiments.Values)
                {
                    if (!exp.IsActive)
                    {
                        continue;
                    }

                    //if (crit.Type == CriterionType.Maximizing)
                    //{
                    //    double oldCriterionValue = exp.CriterionValues[crit.Id];
                    //    if (oldCriterionValue == 0.0)
                    //    {
                    //        oldCriterionValue = 0.00001;
                    //    }
                    //    experiments[exp.Id].CriterionValues.Add(crit.Id, 1.0/oldCriterionValue);
                    //}
                    //else
                    //{
                    experiments[exp.Id].CriterionValues.Add(crit.Id, exp.CriterionValues[crit.Id]);
                    //}
                }

                Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(experiments, crit);
                //Normalization.NormalizeCriterion(experiments, crit);

                foreach (Experiment exp in experiments.Values)
                {
                    exp.CriterionValues[crit.Id] = normalizedCrit[exp.Id];
                }
            }

            return(experiments);
        }
Пример #10
0
        /// <summary>
        /// Handles a new object by commuting it with the scheduler and finding its trivial theorems and passing those to be handled
        /// by the normalization helper and scheduler.
        /// </summary>
        /// <param name="newObject">The new object to be handled.</param>
        /// <param name="helper">The normalization helper used later for the trivial theorems of the object.</param>
        /// <param name="scheduler">The scheduler of inference rules used for the new object and later for its trivial theorems.</param>
        /// <param name="builder">Either the builder to build theorem proofs; or null, if we are not constructing proofs.</param>
        private void HandleNewObject(ConstructedConfigurationObject newObject, NormalizationHelper helper, Scheduler scheduler, TheoremProofBuilder builder)
        {
            // Schedule after finding this object
            scheduler.ScheduleAfterDiscoveringObject(newObject);

            // Look for its trivial theorems
            foreach (var trivialTheorem in _producer.InferTrivialTheoremsFromObject(newObject))
            {
                // Prepare the proof data in case we need to construct proofs
                var proofData = builder != null ? new ProofData(builder, new TheoremInferenceData(TrivialTheorem), assumptions: Array.Empty <Theorem>()) : null;

                // Let the other method handle this theorem, while ignoring whether it is geometrically valid (it just should be)
                HandleNonequality(trivialTheorem, helper, scheduler, proofData, out var _);
            }
        }
Пример #11
0
        public void Softmax_Create_Test()
        {
            var output = NormalizationHelper.CreateSoftmaxNormalization(givenInput);

            Assert.IsTrue(!object.ReferenceEquals(output, givenInput));
            double sum = 0;

            for (int i = 0; i < givenInput.Count; i++)
            {
                double diff = Math.Abs(expectedOutput[i] - output[i]);
                Assert.IsTrue(diff < Math.Pow(10, -6));
                sum += output[i];
            }
            Assert.IsTrue(StatisticsHelper.IsApproximatelyEqual(sum, 1D));
        }
Пример #12
0
        public void Softmax_InPlace_Test()
        {
            var values = givenInput.ToArray();

            Assert.IsTrue(!object.ReferenceEquals(values, givenInput));
            NormalizationHelper.Softmax(values);
            double sum = 0;

            for (int i = 0; i < values.Length; i++)
            {
                double diff = Math.Abs(expectedOutput[i] - values[i]);
                Assert.IsTrue(diff < Math.Pow(10, -6));
                sum += values[i];
            }
            Assert.IsTrue(StatisticsHelper.IsApproximatelyEqual(sum, 1D));
        }
Пример #13
0
        public IntegralCriterionMethodResult FindDecision(Model model)
        {
            IntegralCriterionMethodResult result = new IntegralCriterionMethodResult("Метод минимакса", "Максимальное из значений локальных критериев");

            // Нормализуем критерии
            foreach (Criterion criterion in model.Criteria.Values)
            {
                Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(model.Experiments, criterion);
                result.AddNormalizedCriterion(normalizedCrit, criterion.Id);
            }

            // Обнаружим максимальные значения
            List <SortableDouble> sortedMaxLocalCriterionValues = new List <SortableDouble>(model.Experiments.CountActiveExperiments());

            foreach (Experiment experiment in model.Experiments.Values)
            {
                if (experiment.IsActive)
                {
                    var normalizedCriteriaForExp = new List <double>();
                    foreach (Criterion crit in model.Criteria.Values)
                    {
                        double normalizedCriterionValue = result.GetNormalizedCriterion(crit.Id)[experiment.Id];
                        normalizedCriterionValue *= crit.Weight;
                        normalizedCriteriaForExp.Add(normalizedCriterionValue);
                    }

                    double maxLocalCriterion = normalizedCriteriaForExp.Max();
                    sortedMaxLocalCriterionValues.Add(new SortableDouble()
                    {
                        Direction = SortDirection.Ascending, Id = experiment.Id, Value = maxLocalCriterion
                    });
                }
            }

            sortedMaxLocalCriterionValues.Sort();

            // Заполним результаты
            foreach (SortableDouble sortedMaxLocalCriterionValue in sortedMaxLocalCriterionValues)
            {
                result.SortedPoints.Add(sortedMaxLocalCriterionValue.Id);
                result.AdditionalData.Add(sortedMaxLocalCriterionValue.Id, sortedMaxLocalCriterionValue.Value);
            }

            return(result);
        }
Пример #14
0
        public static Mat FindPoints(Mat mat, double threshold)
        {
            mat = NormalizationHelper.Normalization(mat);
            var result = new Mat(mat.Width, mat.Height);

            for (var x = 0; x < mat.Width; x++)
            {
                for (var y = 0; y < mat.Height; y++)
                {
                    if (mat.GetAt(x, y) <= threshold || HasBetterNeighbour(mat, x, y))
                    {
                        continue;
                    }
                    result.Set(x, y, mat.GetAt(x, y));
                }
            }

            return(result);
        }
Пример #15
0
        internal void GetBestTagSequence(IList <FeatureVector> vectors, out int[] sysClasses, out double[] distribution)
        {
            // Since we are working with logarithmic numbers, we want the weight of the root node to be zero.
            var beam = new BeamSearch <IdValuePair <double> >(0D);

            for (int beamDepth = 0; beamDepth < vectors.Count; beamDepth++)
            {
                Debug.Assert(beam.Level[beamDepth].Count > 0);
                foreach (BeamNode <IdValuePair <double> > node in beam.Level[beamDepth])
                {
                    double[] probs_v_c = new double[classToClassId.Count];
                    for (int c_i = 0; c_i < classToClassId.Count; c_i++)
                    {
                        probs_v_c[c_i] = CalculateProbability_v_c(vectors[beamDepth], c_i, node, beamDepth);
                    }
                    NormalizationHelper.NormalizeLogs(probs_v_c, Math.E);

                    // Prune: Idenitify N classes with highest probability:
                    IList <int> topNClasses = SearchHelper.GetMaxNItems(topN, probs_v_c);
                    for (int topN_i = 0; topN_i < topNClasses.Count; topN_i++)
                    {
                        int    c_i  = topNClasses[topN_i];
                        double prob = probs_v_c[c_i];
                        node.AddNextNode(new IdValuePair <double>(c_i, prob), Math.Log(prob, Math.E) + node.Weight);
                    }
                }
                beam.Prune(topK, beam_size);
            }
            // Repackage the sequence we just received in such a way that the consuming code will find it most digestable.
            var results = beam.GetBestSequence();

            sysClasses   = new int[results.Length];
            distribution = new double[results.Length];
            for (int i = 0; i < results.Length; i++)
            {
                sysClasses[i]   = results[i].Id;
                distribution[i] = results[i].Value;
            }
        }
Пример #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ObjectIntroductionHelper"/> class.
 /// </summary>
 /// <param name="introducer">The introducer of new objects to which deciding based on available objects is delegated.</param>
 /// <param name="helper">The normalization helper that needs to be know about all objects and therefore needs to be communicated with.</param>
 public ObjectIntroductionHelper(IObjectIntroducer introducer, NormalizationHelper helper)
 {
     _introducer = introducer ?? throw new ArgumentNullException(nameof(introducer));
     _helper     = helper ?? throw new ArgumentNullException(nameof(helper));
 }
Пример #17
0
        /// <summary>
        /// Proves given theorems that are true in the configuration drawn in a given picture.
        /// </summary>
        /// <param name="provenTheorems">The theorems that hold in the configuration without the last object.</param>
        /// <param name="theoremsToProve">The theorems that say something about the last object.</param>
        /// <param name="picture">The picture where the configuration in which the theorems hold is drawn.</param>
        /// <param name="shouldWeConstructProofs">Indicates whether we should construct proofs. This will affect the type of returned result.</param>
        /// <returns>
        /// Either the output as for <see cref="ProveTheoremsAndConstructProofs(TheoremMap, TheoremMap, ContextualPicture)"/>,
        /// if we are constructing proof, or the output as for <see cref="ProveTheorems(TheoremMap, TheoremMap, ContextualPicture)"/> otherwise.
        /// </returns>
        private dynamic ProveTheorems(TheoremMap provenTheorems, TheoremMap theoremsToProve, ContextualPicture picture, bool shouldWeConstructProofs)
        {
            // Pull the configuration for comfort
            var configuration = picture.Pictures.Configuration;

            // Find the trivial theorems based on whether we should do it only
            // for the last object of the configuration
            var trivialTheorems = _settings.FindTrivialTheoremsOnlyForLastObject
                                  // If yes, do so
                ? _producer.InferTrivialTheoremsFromObject(configuration.ConstructedObjects.Last())
                                  // Otherwise do it for all objects
                : configuration.ConstructedObjects.SelectMany(_producer.InferTrivialTheoremsFromObject)
                                  // And enumerate the results
                                  .ToList();

            #region Proof builder initialization

            // Prepare a proof builder in case we are supposed to construct proofs
            var proofBuilder = shouldWeConstructProofs ? new TheoremProofBuilder() : null;

            // Mark trivial theorems to the proof builder in case we are supposed to construct proofs
            trivialTheorems.ForEach(theorem => proofBuilder?.AddImplication(TrivialTheorem, theorem, assumptions: Array.Empty <Theorem>()));

            // Mark assumed theorems to the proof builder in case we are supposed to construct proofs
            provenTheorems.AllObjects.ForEach(theorem => proofBuilder?.AddImplication(AssumedProven, theorem, assumptions: Array.Empty <Theorem>()));

            #endregion

            #region Theorems definable simpler

            // Prepare the list of theorems definable simpler
            var theoremsDefinableSimpler = new List <Theorem>();

            // If we are supposed to assuming them proven...
            if (_settings.AssumeThatSimplifiableTheoremsAreTrue)
            {
                // Go through unproven theorems except for trivial ones
                foreach (var theoremToProve in theoremsToProve.AllObjects.Except(trivialTheorems))
                {
                    // Find the redundant objects
                    var redundantObjects = theoremToProve.GetUnnecessaryObjects(configuration);

                    // If there are none, then it cannot be defined simpler
                    if (redundantObjects.IsEmpty())
                    {
                        continue;
                    }

                    // Otherwise add it to the list
                    theoremsDefinableSimpler.Add(theoremToProve);

                    // And make sure the proof builder knows it
                    proofBuilder?.AddImplication(new DefinableSimplerInferenceData(redundantObjects), theoremToProve, assumptions: Array.Empty <Theorem>());
                }
            }

            #endregion

            #region Theorems inferable from symmetry

            // Prepare the set of theorems inferred from symmetry
            var theoremsInferredFromSymmetry = new List <Theorem>();

            // Go throw the theorems that are already inferred, i.e. assumed proven, trivial and definable simpler ones
            foreach (var provedTheorem in provenTheorems.AllObjects.Concat(trivialTheorems).Concat(theoremsDefinableSimpler))
            {
                // Try to infer new theorems using this one
                foreach (var inferredTheorem in provedTheorem.InferTheoremsFromSymmetry(configuration))
                {
                    // Add it to the list
                    theoremsInferredFromSymmetry.Add(inferredTheorem);

                    // Make sure the proof builds knows it
                    proofBuilder?.AddImplication(InferableFromSymmetry, inferredTheorem, assumptions: new[] { provedTheorem });
                }
            }

            #endregion

            #region Normalization helper initialization

            // Initially we are going to assume that the proved theorems are the passed ones
            var provedTheorems = provenTheorems.AllObjects
                                 // And trivial ones
                                 .Concat(trivialTheorems)
                                 // And ones with redundant objects
                                 .Concat(theoremsDefinableSimpler)
                                 // And ones inferred from symmetry
                                 .Concat(theoremsInferredFromSymmetry)
                                 // Distinct ones
                                 .Distinct();

            // The theorems to prove will be the new ones except for the proved ones
            var currentTheoremsToBeProven = theoremsToProve.AllObjects.Except(provedTheorems).ToArray();

            // Prepare the cloned pictures that will be used to numerically verify new theorems
            var clonedPictures = picture.Pictures.Clone();

            // Prepare a normalization helper with all this information
            var normalizationHelper = new NormalizationHelper(_verifier, clonedPictures, provedTheorems, currentTheoremsToBeProven);

            #endregion

            #region Scheduler initialization

            // Prepare a scheduler
            var scheduler = new Scheduler(_manager);

            // Do the initial scheduling
            scheduler.PerformInitialScheduling(currentTheoremsToBeProven, configuration);

            #endregion

            // Prepare the object introduction helper
            var objectIntroductionHelper = new ObjectIntroductionHelper(_introducer, normalizationHelper);

            #region Inference loop

            // Do until break
            while (true)
            {
                // Ask the scheduler for the next inference data to be used
                var data = scheduler.NextScheduledData();

                #region Object introduction

                // If there is no data, we will try to introduce objects
                if (data == null)
                {
                    // Call the introduction helper
                    var(removedObjects, introducedObject) = objectIntroductionHelper.IntroduceObject(
                        // With the theorems to prove obtained by excluding the proved ones
                        theoremsToProve: theoremsToProve.AllObjects.Except(normalizationHelper.ProvedTheorems));

                    // Invalidate removed objects
                    removedObjects.ForEach(scheduler.InvalidateObject);

                    // If there is something to be introduced
                    if (introducedObject != null)
                    {
                        // Call the appropriate method to handle introduced objects
                        HandleNewObject(introducedObject, normalizationHelper, scheduler, proofBuilder);

                        // Ask the scheduler for the next inference data to be used
                        data = scheduler.NextScheduledData();
                    }
                }

                #endregion

                // If all theorems are proven or there is no data even after object introduction, we're done
                if (!normalizationHelper.AnythingLeftToProve || data == null)
                {
                    // If we should construct proofs
                    return(shouldWeConstructProofs
                           // Build them for the theorems to be proven
                        ? (dynamic)proofBuilder.BuildProofs(theoremsToProve.AllObjects)
                           // Otherwise just take the theorems to be proven that happen to be proven
                        : theoremsToProve.AllObjects.Where(normalizationHelper.ProvedTheorems.Contains).ToReadOnlyHashSet());
                }

                #region Inference rule applier call

                // Try to apply the current scheduled data
                var applierResults = _applier.InferTheorems(new InferenceRuleApplierInput
                                                            (
                                                                // Pass the data provided by the scheduler
                                                                inferenceRule: data.InferenceRule,
                                                                premappedAssumption: data.PremappedAssumption,
                                                                premappedConclusion: data.PremappedConclusion,
                                                                premappedObject: data.PremappedObject,

                                                                // Pass the methods that the normalization helper offers
                                                                mappableTheoremsFactory: normalizationHelper.GetProvedTheoremOfType,
                                                                mappableObjectsFactory: normalizationHelper.GetObjectsWithConstruction,
                                                                equalObjectsFactory: normalizationHelper.GetEqualObjects,
                                                                normalizationFunction: normalizationHelper.GetNormalVersionOfObjectOrNull
                                                            ))
                                     // Enumerate results. This step is needed because the applier could iterate over the
                                     // collections of objects and theorems used by the normalization helper
                                     .ToArray();

                // Before handling results prepare a variable that will indicate whether there has been any change of the
                // normal version of an object.
                var anyNormalVersionChange = false;

                // Handle every inferred theorems
                foreach (var(theorem, negativeAssumptions, possitiveAssumptions) in applierResults)
                {
                    // If in some previous iteration there has been a change of the normal version of an object, then
                    // it might happen that some other theorems inferred in this loop no longer contain only correct objects,
                    // therefore we need to verify them. The reason why we don't have to worry about incorrect objects in other
                    // cases is that the normalization helper keeps everything normalized and the inference rule applier provides
                    // only normalized objects. However, if there is a change of normal versions and the applier is already called
                    // and the results are enumerated, then we have to check it manually
                    if (anyNormalVersionChange && normalizationHelper.DoesTheoremContainAnyIncorrectObject(theorem))
                    {
                        continue;
                    }

                    // We need to check negative assumptions. The inference should be accepted only if all of them are false
                    if (negativeAssumptions.Any(negativeAssumption => _verifier.IsTrueInAllPictures(clonedPictures, negativeAssumption)))
                    {
                        continue;
                    }

                    // Prepare the proof data in case we need to construct proofs
                    var proofData = shouldWeConstructProofs ? new ProofData(proofBuilder, new CustomInferenceData(data.InferenceRule), possitiveAssumptions) : null;

                    // Prepare the variable indicating whether the theorem is geometrically valid
                    bool isValid;

                    // If this is an equality
                    if (theorem.Type == EqualObjects)
                    {
                        // Call the appropriate method to handle it while finding out whether there has been any normal version change
                        HandleEquality(theorem, normalizationHelper, scheduler, proofData, out isValid, out var anyNormalVersionChangeInThisIteration);

                        // If yes, then we set the outer loop variable indicating the same thing for the whole loop
                        if (anyNormalVersionChangeInThisIteration)
                        {
                            anyNormalVersionChange = true;
                        }
                    }
                    // If this is a non-equality
                    else
                    {
                        // Call the appropriate method to handle it
                        HandleNonequality(theorem, normalizationHelper, scheduler, proofData, out isValid);
                    }

                    // If the theorem turns out not to be geometrically valid, trace it
                    if (!isValid)
                    {
                        _tracer.MarkInvalidInferrence(configuration, theorem, data.InferenceRule, negativeAssumptions, possitiveAssumptions);
                    }
                }

                #endregion
            }

            #endregion
        }
Пример #18
0
        /// <summary>
        ///     Program entry point.
        /// </summary>
        /// <param name="app">Holds arguments and other info.</param>
        public void Execute(IExampleInterface app)
        {
            ErrorCalculation.Mode = ErrorCalculationMode.RMS;
            // Download the data that we will attempt to model.
            string filename = DownloadData(app.Args);

            // Define the format of the data file.
            // This area will change, depending on the columns and
            // format of the file that you are trying to model.
            var format = new CSVFormat('.', ' '); // decimal point and
            // space separated
            IVersatileDataSource source = new CSVDataSource(filename, true,
                                                            format);

            var data = new VersatileMLDataSet(source);

            data.NormHelper.Format = format;

            ColumnDefinition columnSSN = data.DefineSourceColumn("SSN",
                                                                 ColumnType.Continuous);
            ColumnDefinition columnDEV = data.DefineSourceColumn("DEV",
                                                                 ColumnType.Continuous);

            // Analyze the data, determine the min/max/mean/sd of every column.
            data.Analyze();

            // Use SSN & DEV to predict SSN. For time-series it is okay to have
            // SSN both as
            // an input and an output.
            data.DefineInput(columnSSN);
            data.DefineInput(columnDEV);
            data.DefineOutput(columnSSN);

            // Create feedforward neural network as the model type.
            // MLMethodFactory.TYPE_FEEDFORWARD.
            // You could also other model types, such as:
            // MLMethodFactory.SVM: Support Vector Machine (SVM)
            // MLMethodFactory.TYPE_RBFNETWORK: RBF Neural Network
            // MLMethodFactor.TYPE_NEAT: NEAT Neural Network
            // MLMethodFactor.TYPE_PNN: Probabilistic Neural Network
            var model = new EncogModel(data);

            model.SelectMethod(data, MLMethodFactory.TypeFeedforward);

            // Send any output to the console.
            model.Report = new ConsoleStatusReportable();

            // Now normalize the data. Encog will automatically determine the
            // correct normalization
            // type based on the model you chose in the last step.
            data.Normalize();

            // Set time series.
            data.LeadWindowSize = 1;
            data.LagWindowSize  = WindowSize;

            // Hold back some data for a final validation.
            // Do not shuffle the data into a random ordering. (never shuffle
            // time series)
            // Use a seed of 1001 so that we always use the same holdback and
            // will get more consistent results.
            model.HoldBackValidation(0.3, false, 1001);

            // Choose whatever is the default training type for this model.
            model.SelectTrainingType(data);

            // Use a 5-fold cross-validated train. Return the best method found.
            // (never shuffle time series)
            var bestMethod = (IMLRegression)model.Crossvalidate(5,
                                                                false);

            // Display the training and validation errors.
            Console.WriteLine(@"Training error: "
                              + model.CalculateError(bestMethod,
                                                     model.TrainingDataset));
            Console.WriteLine(@"Validation error: "
                              + model.CalculateError(bestMethod,
                                                     model.ValidationDataset));

            // Display our normalization parameters.
            NormalizationHelper helper = data.NormHelper;

            Console.WriteLine(helper.ToString());

            // Display the final model.
            Console.WriteLine(@"Final model: " + bestMethod);

            // Loop over the entire, original, dataset and feed it through the
            // model. This also shows how you would process new data, that was
            // not part of your training set. You do not need to retrain, simply
            // use the NormalizationHelper class. After you train, you can save
            // the NormalizationHelper to later normalize and denormalize your
            // data.
            source.Close();
            var csv  = new ReadCSV(filename, true, format);
            var line = new String[2];

            // Create a vector to hold each time-slice, as we build them.
            // These will be grouped together into windows.
            var     slice  = new double[2];
            var     window = new VectorWindow(WindowSize + 1);
            IMLData input  = helper.AllocateInputVector(WindowSize + 1);

            // Only display the first 100
            int stopAfter = 100;

            while (csv.Next() && stopAfter > 0)
            {
                var result = new StringBuilder();

                line[0] = csv.Get(2); // ssn
                line[1] = csv.Get(3); // dev
                helper.NormalizeInputVector(line, slice, false);

                // enough data to build a full window?
                if (window.IsReady())
                {
                    window.CopyWindow(((BasicMLData)input).Data, 0);
                    String  correct   = csv.Get(2); // trying to predict SSN.
                    IMLData output    = bestMethod.Compute(input);
                    String  predicted = helper
                                        .DenormalizeOutputVectorToString(output)[0];

                    result.Append(line);
                    result.Append(" -> predicted: ");
                    result.Append(predicted);
                    result.Append("(correct: ");
                    result.Append(correct);
                    result.Append(")");

                    Console.WriteLine(result.ToString());
                }

                // Add the normalized slice to the window. We do this just after
                // the after checking to see if the window is ready so that the
                // window is always one behind the current row. This is because
                // we are trying to predict next row.
                window.Add(slice);

                stopAfter--;
            }
            csv.Close();

            // Delete data file and shut down.
            File.Delete(filename);
            EncogFramework.Instance.Shutdown();
        }
Пример #19
0
 public PredictionMachine(IMLRegression neuralNet, NormalizationHelper normalizationHelper, PredictionConfig config)
 {
     NeuralNet            = neuralNet;
     _normalizationHelper = normalizationHelper;
     Config = config;
 }
        public ActionResult Saaty99([FromBody] Alternative[] array)
        {
            var saaty = NormalizationHelper.Saaty99(array);

            return(Ok(saaty));
        }
Пример #21
0
        /// <summary>
        ///     Program entry point.
        /// </summary>
        /// <param name="app">Holds arguments and other info.</param>
        public void Execute(IExampleInterface app)
        {
            // Download the data that we will attempt to model.
            string irisFile = DownloadData(app.Args);

            // Define the format of the data file.
            // This area will change, depending on the columns and
            // format of the file that you are trying to model.
            IVersatileDataSource source = new CSVDataSource(irisFile, false,
                                                            CSVFormat.DecimalPoint);
            var data = new VersatileMLDataSet(source);

            data.DefineSourceColumn("sepal-length", 0, ColumnType.Continuous);
            data.DefineSourceColumn("sepal-width", 1, ColumnType.Continuous);
            data.DefineSourceColumn("petal-length", 2, ColumnType.Continuous);
            data.DefineSourceColumn("petal-width", 3, ColumnType.Continuous);

            // Define the column that we are trying to predict.
            ColumnDefinition outputColumn = data.DefineSourceColumn("species", 4,
                                                                    ColumnType.Nominal);

            // Analyze the data, determine the min/max/mean/sd of every column.
            data.Analyze();

            // Map the prediction column to the output of the model, and all
            // other columns to the input.
            data.DefineSingleOutputOthersInput(outputColumn);

            // Create feedforward neural network as the model type. MLMethodFactory.TYPE_FEEDFORWARD.
            // You could also other model types, such as:
            // MLMethodFactory.SVM:  Support Vector Machine (SVM)
            // MLMethodFactory.TYPE_RBFNETWORK: RBF Neural Network
            // MLMethodFactor.TYPE_NEAT: NEAT Neural Network
            // MLMethodFactor.TYPE_PNN: Probabilistic Neural Network
            var model = new EncogModel(data);

            model.SelectMethod(data, MLMethodFactory.TypeFeedforward);

            // Send any output to the console.
            model.Report = new ConsoleStatusReportable();

            // Now normalize the data.  Encog will automatically determine the correct normalization
            // type based on the model you chose in the last step.
            data.Normalize();

            // Hold back some data for a final validation.
            // Shuffle the data into a random ordering.
            // Use a seed of 1001 so that we always use the same holdback and will get more consistent results.
            model.HoldBackValidation(0.3, true, 1001);

            // Choose whatever is the default training type for this model.
            model.SelectTrainingType(data);

            // Use a 5-fold cross-validated train.  Return the best method found.
            var bestMethod = (IMLRegression)model.Crossvalidate(5, true);

            // Display the training and validation errors.
            Console.WriteLine(@"Training error: " + model.CalculateError(bestMethod, model.TrainingDataset));
            Console.WriteLine(@"Validation error: " + model.CalculateError(bestMethod, model.ValidationDataset));

            // Display our normalization parameters.
            NormalizationHelper helper = data.NormHelper;

            Console.WriteLine(helper.ToString());

            // Display the final model.
            Console.WriteLine(@"Final model: " + bestMethod);

            // Loop over the entire, original, dataset and feed it through the model.
            // This also shows how you would process new data, that was not part of your
            // training set.  You do not need to retrain, simply use the NormalizationHelper
            // class.  After you train, you can save the NormalizationHelper to later
            // normalize and denormalize your data.
            source.Close();
            var     csv   = new ReadCSV(irisFile, false, CSVFormat.DecimalPoint);
            var     line  = new String[4];
            IMLData input = helper.AllocateInputVector();

            while (csv.Next())
            {
                var result = new StringBuilder();
                line[0] = csv.Get(0);
                line[1] = csv.Get(1);
                line[2] = csv.Get(2);
                line[3] = csv.Get(3);
                String correct = csv.Get(4);
                helper.NormalizeInputVector(line, ((BasicMLData)input).Data, false);
                IMLData output     = bestMethod.Compute(input);
                String  irisChosen = helper.DenormalizeOutputVectorToString(output)[0];

                result.Append(line);
                result.Append(" -> predicted: ");
                result.Append(irisChosen);
                result.Append("(correct: ");
                result.Append(correct);
                result.Append(")");

                Console.WriteLine(result.ToString());
            }
            csv.Close();

            // Delete data file ande shut down.
            File.Delete(irisFile);
            EncogFramework.Instance.Shutdown();
        }
        /// <inheritdoc/>
        public void Init(NormalizationHelper normalizationHelper)
        {

        }
Пример #23
0
 /// <inheritdoc/>
 public void Init(NormalizationHelper normalizationHelper)
 {
 }
        public ActionResult Geometry([FromBody] Alternative[] array)
        {
            var geom = NormalizationHelper.GeometryMethod(array);

            return(Ok(geom));
        }
        public IntegralCriterionMethodResult FindDecision(Model model)
        {
            var result =
                new IntegralCriterionMethodResult("Аддитивный критерий", "Значение аддитивного критерия");

            // Нормализуем критерии
            foreach (Criterion crit in model.Criteria.Values)
            {
                Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(model.Experiments, crit);
                //Normalization.NormalizeCriterion(model.Experiments, crit);
                result.AddNormalizedCriterion(normalizedCrit, crit.Id);
            }

            // Вычислим значения аддитивного критерия для каждого из
            // экспериментов
            var additiveCriterion = new Dictionary <TId, double>();

            foreach (Experiment exp in model.Experiments.Values)
            {
                if (exp.IsActive)
                {
                    double additiveCriterionValue = 0;
                    foreach (Criterion crit in model.Criteria.Values)
                    {
                        double normalizedCriterionValue =
                            result.GetNormalizedCriterion(crit.Id)[exp.Id];
                        normalizedCriterionValue *= crit.Weight;
                        //switch (crit.Type)
                        //{
                        //    case CriterionType.Maximizing:
                        //        additiveCriterionValue -= normalizedCriterionValue;
                        //        break;
                        //    case CriterionType.Minimizing:
                        additiveCriterionValue += normalizedCriterionValue;
                        //        break;
                        //}
                    }

                    additiveCriterion.Add(exp.Id, additiveCriterionValue);
                }
            }

            // Отсортируем результаты по возрастанию по значению
            // аддитивного критерия (меньше - лучше)
            List <SortableDouble> sortedAdditiveCriterionValues = additiveCriterion.Select <KeyValuePair <TId, double>, SortableDouble>(
                kvp => new SortableDouble()
            {
                Direction = SortDirection.Ascending, Id = kvp.Key, Value = kvp.Value
            }
                ).ToList();

            sortedAdditiveCriterionValues.Sort();

            // Заполним результаты
            foreach (SortableDouble sortedAdditiveCriterionValue in sortedAdditiveCriterionValues)
            {
                result.SortedPoints.Add(sortedAdditiveCriterionValue.Id);
                result.AdditionalData.Add(sortedAdditiveCriterionValue.Id, sortedAdditiveCriterionValue.Value);
            }

            return(result);
        }