source: branches/3022-FastFunctionExtraction/FFX/FastFunctionExtraction.cs @ 17223

using System;
using System.Threading;
using System.Linq;
using HeuristicLab.Common; // required for parameters collection
using HeuristicLab.Core; // required for parameters collection
using HeuristicLab.Data; // IntValue, ...
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Optimization; // BasicAlgorithm
using HeuristicLab.Parameters;
using HeuristicLab.Problems.Binary;
using HeuristicLab.Random; // MersenneTwister
using HEAL.Attic;
using HeuristicLab.Algorithms.DataAnalysis.Glmnet;
using HeuristicLab.Problems.DataAnalysis;
using System.Collections.Generic;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;

namespace HeuristicLab.Algorithms.DataAnalysis.FastFunctionExtraction
{

    [Item(Name = "FastFunctionExtraction", Description = "An FFX algorithm.")]
    [Creatable(Category = CreatableAttribute.Categories.Algorithms, Priority = 999)]
    [StorableType("689280F7-E371-44A2-98A5-FCEDF22CA343")] // for persistence (storing your algorithm to a files or transfer to HeuristicLab.Hive
    public sealed class FastFunctionExtraction : FixedDataAnalysisAlgorithm<RegressionProblem>
    {
        private enum Operator { Abs, Log };
        private static readonly double[] exponents = { 0.5, 1, 2 };

        private const string PenaltyParameterName = "Penalty";
        private const string ConsiderInteractionsParameterName = "Consider Interactions";
        private const string ConsiderDenominationParameterName = "Consider Denomination";
        private const string ConsiderExponentiationParameterName = "Consider Exponentiation";
        private const string ConsiderNonlinearFuncsParameterName = "Consider Nonlinear functions";
        private const string ConsiderHingeFuncsParameterName = "Consider Hinge Functions";

        #region parameters
        public IValueParameter<BoolValue> ConsiderInteractionsParameter
        {
            get { return (IValueParameter<BoolValue>)Parameters[ConsiderInteractionsParameterName]; }
        }
        #endregion

        #region properties
        public bool ConsiderInteractions
        {
            get { return ConsiderInteractionsParameter.Value.Value; }
            set { ConsiderInteractionsParameter.Value.Value = value; }
        }
        #endregion

        [StorableConstructor]
        private FastFunctionExtraction(StorableConstructorFlag _) : base(_) { }
        public FastFunctionExtraction(FastFunctionExtraction original, Cloner cloner) : base(original, cloner)
        {
            // Don't forget to call the cloning ctor of the base class  
            // This class does not have fields, therefore we don't need to actually clone anything
        }
        public FastFunctionExtraction() : base()
        {
            // algorithm parameters are shown in the GUI
            Parameters.Add(new FixedValueParameter<DoubleValue>(PenaltyParameterName, "Penalty factor (alpha) for balancing between ridge (0.0) and lasso (1.0) regression", new DoubleValue(0.5)));
            Parameters.Add(new ValueParameter<BoolValue>(ConsiderInteractionsParameterName, "True if you want to consider interactions, otherwise false.", new BoolValue(true)));
            Parameters.Add(new ValueParameter<BoolValue>(ConsiderDenominationParameterName, "True if you want to consider denominations, otherwise false.", new BoolValue(true)));
            Parameters.Add(new ValueParameter<BoolValue>(ConsiderExponentiationParameterName, "True if you want to consider exponentiation, otherwise false.", new BoolValue(true)));
            Parameters.Add(new ValueParameter<BoolValue>(ConsiderNonlinearFuncsParameterName, "True if you want to consider nonlinear functions(abs, log,...), otherwise false.", new BoolValue(true)));
            Parameters.Add(new ValueParameter<BoolValue>(ConsiderHingeFuncsParameterName, "True if you want to consider Hinge Functions, otherwise false.", new BoolValue(true)));
        }

        [StorableHook(HookType.AfterDeserialization)]
        private void AfterDeserialization() { }

        public override IDeepCloneable Clone(Cloner cloner)
        {
            return new FastFunctionExtraction(this, cloner);
        }

        public override Type ProblemType { get { return typeof(RegressionProblem); } }
        public new RegressionProblem Problem { get { return (RegressionProblem)base.Problem; } }


        protected override void Run(CancellationToken cancellationToken)
        {
            var basisFunctions = generateBasisFunctions(Problem.ProblemData);
            var x = Problem.ProblemData.AllowedInputsTrainingValues;
            List<SymbolicExpressionTree> trees = new List<SymbolicExpressionTree>();


            foreach (var basisFunc in basisFunctions)
            {
                // add tree representation of basisFunc to trees
                trees.Add(generateSymbolicExpressionTree(basisFunc));
            }

            foreach (var tree in trees)
            {
                // create new data through the help of the Interpreter
                //IEnumerable<double> responses = 
            }

            var coefficientVectorSet = findCoefficientValues(basisFunctions);
            var paretoFront = nondominatedFilter(coefficientVectorSet);
        }

        private SymbolicExpressionTree generateSymbolicExpressionTree(KeyValuePair<string, double[]> basisFunc)
        {
            throw new NotImplementedException();
        }

        // generate all possible models
        private static Dictionary<string, double[]> generateBasisFunctions(IRegressionProblemData problemData)
        {
            var basisFunctions = generateUnivariateBases(problemData);
            return basisFunctions;
        }

        private static Dictionary<string, double[]> generateUnivariateBases(IRegressionProblemData problemData)
        {

            var dataset = problemData.Dataset;
            var rows = problemData.TrainingIndices;
            var B1 = new Dictionary<string, double[]>();

            foreach (var variableName in dataset.VariableNames)
            {
                foreach (var exp in new[] { 0.5, 1, 2 })
                {
                    var name = variableName + " ** " + exp;
                    var data = dataset.GetDoubleValues(variableName, rows).Select(x => Math.Pow(x, exp)).ToArray();
                    B1.Add(name, data);
                    foreach (Operator op in Enum.GetValues(typeof(Operator)))
                    {
                        var inner_name = op.ToString() + "(" + name + ")";
                        var inner_data = data.Select(x => executeOperator(x, op)).ToArray();
                        B1.Add(inner_name, inner_data);
                    }
                }
            }
            
            return B1;
        }

        private static double executeOperator(double x, Operator op)
        {
            switch (op)
            {
                case Operator.Abs:
                    return x > 0 ? x : -x;
                case Operator.Log:
                    return Math.Log10(x);
                default:
                    throw new NotImplementedException();
            }
        }

        private static Dictionary<string, double[]> generateMultiVariateBases(Dictionary<string, double[]> B1)
        {
            var B2 = new Dictionary<string, double[]>();
            for(int i = 1; i <= B1.Count(); i++ )
            {
                var b_i = B1.ElementAt(i);
                for (int j = 1; j < i; i++)
                {
                    var b_j = B1.ElementAt(j);
                }
            }

            // return union of B1 and B2
            return B2.Concat(B1).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
        }

        private static object findCoefficientValues(IEnumerable<KeyValuePair<string, double[]>> basisFunctions)
        {
            return new object();
        }

        private static object nondominatedFilter(object coefficientVectorSet)
        {
            return new object();
        }

        public override bool SupportsPause
        {
            get { return false; }
        }
    }
}