Ejemplo n.º 1
0
        /**
         * {@inheritDoc}
         */

        public Object Read(Stream istream)
        {
            var result = new SOMNetwork();
            var reader = new EncogReadHelper(istream);
            EncogFileSection section;

            while ((section = reader.ReadNextSection()) != null)
            {
                if (section.SectionName.Equals("SOM") &&
                    section.SubSectionName.Equals("PARAMS"))
                {
                    IDictionary <String, String> p = section.ParseParams();
                    EngineArray.PutAll(p, result.Properties);
                }
                if (section.SectionName.Equals("SOM") &&
                    section.SubSectionName.Equals("NETWORK"))
                {
                    IDictionary <String, String> p = section.ParseParams();
                    result.Weights = EncogFileSection.ParseMatrix(p,
                                                                  PersistConst.Weights)
                    ;
                }
            }

            return(result);
        }
Ejemplo n.º 2
0
        /// <inheritdoc/>
        public Object Read(Stream mask0)
        {
            var result = new BAMNetwork();
            var ins0   = new EncogReadHelper(mask0);
            EncogFileSection section;

            while ((section = ins0.ReadNextSection()) != null)
            {
                if (section.SectionName.Equals("BAM") &&
                    section.SubSectionName.Equals("PARAMS"))
                {
                    IDictionary <String, String> paras = section.ParseParams();
                    EngineArray.PutAll(paras, result.Properties);
                }
                if (section.SectionName.Equals("BAM") &&
                    section.SubSectionName.Equals("NETWORK"))
                {
                    IDictionary <String, String> p = section.ParseParams();

                    result.F1Count = EncogFileSection.ParseInt(p,
                                                               PersistConst.PropertyF1Count);
                    result.F2Count = EncogFileSection.ParseInt(p,
                                                               PersistConst.PropertyF2Count);
                    result.WeightsF1ToF2 = EncogFileSection.ParseMatrix(p, PersistConst.PropertyWeightsF1F2);
                    result.WeightsF2ToF1 = EncogFileSection.ParseMatrix(p, PersistConst.PropertyWeightsF2F1);
                }
            }

            return(result);
        }
Ejemplo n.º 3
0
        /// <inheritdoc/>
        public Object Read(Stream mask0)
        {
            IDictionary <String, String> networkParams = null;
            var ins0 = new EncogReadHelper(mask0);
            EncogFileSection section;
            int    inputCount  = 0;
            int    instarCount = 0;
            int    outputCount = 0;
            int    winnerCount = 0;
            Matrix m1          = null;
            Matrix m2          = null;

            while ((section = ins0.ReadNextSection()) != null)
            {
                if (section.SectionName.Equals("CPN") &&
                    section.SubSectionName.Equals("PARAMS"))
                {
                    networkParams = section.ParseParams();
                }
                if (section.SectionName.Equals("CPN") &&
                    section.SubSectionName.Equals("NETWORK"))
                {
                    IDictionary <String, String> paras = section.ParseParams();

                    inputCount = EncogFileSection.ParseInt(paras,
                                                           PersistConst.InputCount);
                    instarCount = EncogFileSection.ParseInt(paras,
                                                            PersistConst.Instar);
                    outputCount = EncogFileSection.ParseInt(paras,
                                                            PersistConst.OutputCount);
                    winnerCount = EncogFileSection.ParseInt(paras,
                                                            PropertyWinnerCount);
                    m1 = EncogFileSection.ParseMatrix(paras,
                                                      PropertyInputToInstar);
                    m2 = EncogFileSection.ParseMatrix(paras,
                                                      PropertyInstarToInput);
                }
            }

            var result = new CPNNetwork(inputCount, instarCount, outputCount,
                                        winnerCount);

            EngineArray.PutAll(networkParams, result.Properties);
            result.WeightsInputToInstar.Set(m1);
            result.WeightsInstarToOutstar.Set(m2);
            return(result);
        }
Ejemplo n.º 4
0
        /// <inheritdoc/>
        public Object Read(Stream mask0)
        {
            var result = new ART1();
            var ins0   = new EncogReadHelper(mask0);
            EncogFileSection section;

            while ((section = ins0.ReadNextSection()) != null)
            {
                if (section.SectionName.Equals("ART1") &&
                    section.SubSectionName.Equals("PARAMS"))
                {
                    IDictionary <String, String> paras = section.ParseParams();
                    EngineArray.PutAll(paras, result.Properties);
                }
                if (section.SectionName.Equals("ART1") &&
                    section.SubSectionName.Equals("NETWORK"))
                {
                    IDictionary <String, String> p = section.ParseParams();

                    result.A1 = EncogFileSection.ParseDouble(p,
                                                             BasicART.PropertyA1);
                    result.B1 = EncogFileSection.ParseDouble(p,
                                                             BasicART.PropertyB1);
                    result.C1 = EncogFileSection.ParseDouble(p,
                                                             BasicART.PropertyC1);
                    result.D1 = EncogFileSection.ParseDouble(p,
                                                             BasicART.PropertyD1);
                    result.F1Count = EncogFileSection.ParseInt(p,
                                                               PersistConst.PropertyF1Count);
                    result.F2Count = EncogFileSection.ParseInt(p,
                                                               PersistConst.PropertyF2Count);
                    result.NoWinner = EncogFileSection.ParseInt(p,
                                                                BasicART.PropertyNoWinner);
                    result.L = EncogFileSection
                               .ParseDouble(p, BasicART.PropertyL);
                    result.Vigilance = EncogFileSection.ParseDouble(p,
                                                                    BasicART.PropertyVigilance);
                    result.WeightsF1ToF2 = EncogFileSection.ParseMatrix(p,
                                                                        PersistConst.PropertyWeightsF1F2);
                    result.WeightsF2ToF1 = EncogFileSection.ParseMatrix(p,
                                                                        PersistConst.PropertyWeightsF2F1);
                }
            }

            return(result);
        }
Ejemplo n.º 5
0
        /// <inheritdoc/>
        public Object Read(Stream istream)
        {
            int states = 0;

            int[]    items;
            double[] pi = null;
            Matrix   transitionProbability             = null;
            IDictionary <String, String> properties    = null;
            IList <IStateDistribution>   distributions = new List <IStateDistribution>();

            EncogReadHelper  reader = new EncogReadHelper(istream);
            EncogFileSection section;

            while ((section = reader.ReadNextSection()) != null)
            {
                if (section.SectionName.Equals("HMM") &&
                    section.SubSectionName.Equals("PARAMS"))
                {
                    properties = section.ParseParams();
                }
                if (section.SectionName.Equals("HMM") &&
                    section.SubSectionName.Equals("CONFIG"))
                {
                    IDictionary <String, String> p = section.ParseParams();

                    states = EncogFileSection.ParseInt(p, HiddenMarkovModel.TAG_STATES);

                    if (p.ContainsKey(HiddenMarkovModel.TAG_ITEMS))
                    {
                        items = EncogFileSection.ParseIntArray(p, HiddenMarkovModel.TAG_ITEMS);
                    }
                    pi = section.ParseDoubleArray(p, HiddenMarkovModel.TAG_PI);
                    transitionProbability = EncogFileSection.ParseMatrix(p, HiddenMarkovModel.TAG_TRANSITION);
                }
                else if (section.SectionName.Equals("HMM") &&
                         section.SubSectionName.StartsWith("DISTRIBUTION-"))
                {
                    IDictionary <String, String> p = section.ParseParams();
                    String t = p[HiddenMarkovModel.TAG_DIST_TYPE];
                    if ("ContinousDistribution".Equals(t))
                    {
                        double[] mean = section.ParseDoubleArray(p, HiddenMarkovModel.TAG_MEAN);
                        Matrix   cova = EncogFileSection.ParseMatrix(p, HiddenMarkovModel.TAG_COVARIANCE);
                        ContinousDistribution dist = new ContinousDistribution(mean, cova.Data);
                        distributions.Add(dist);
                    }
                    else if ("DiscreteDistribution".Equals(t))
                    {
                        Matrix prob = EncogFileSection.ParseMatrix(p, HiddenMarkovModel.TAG_PROBABILITIES);
                        DiscreteDistribution dist = new DiscreteDistribution(prob.Data);
                        distributions.Add(dist);
                    }
                }
            }

            HiddenMarkovModel result = new HiddenMarkovModel(states);

            EngineArray.PutAll(properties, result.Properties);
            result.TransitionProbability = transitionProbability.Data;
            result.Pi = pi;
            int index = 0;

            foreach (IStateDistribution dist in distributions)
            {
                result.StateDistributions[index++] = dist;
            }


            return(result);
        }