Esempio n. 1
0
        /**
         * /// Deserializes an Fst from an ObjectInputStream
         * ///
         * /// @param in
         * ///            the ObjectInputStream. It should be already be initialized by
         * ///            the caller.
         * /// @return
         * /// @throws IOException
         * /// @throws ClassNotFoundException
         */
        private static Fst ReadFst(Stream inStream)
        {
            var _is        = ReadStringMap(inStream);
            var os         = ReadStringMap(inStream);
            var serializer = new BinaryFormatter();

            var startid   = (int)serializer.Deserialize(inStream);
            var semiring  = (Semiring)serializer.Deserialize(inStream);
            var numStates = (int)serializer.Deserialize(inStream);
            var res       = new Fst(numStates);

            res.Isyms    = _is;
            res.Osyms    = os;
            res.Semiring = semiring;
            for (var i = 0; i < numStates; i++)
            {
                var numArcs = (int)serializer.Deserialize(inStream);
                var s       = new State(numArcs + 1);
                var f       = (float)serializer.Deserialize(inStream);
                if (f == res.Semiring.Zero)
                {
                    f = res.Semiring.Zero;
                }
                else if (f == res.Semiring.One)
                {
                    f = res.Semiring.One;
                }
                s.FinalWeight = f;
                s.Id          = (int)serializer.Deserialize(inStream);
                res._states.Add(s);
            }
            res.SetStart(res._states[startid]);

            numStates = res.GetNumStates();
            for (var i = 0; i < numStates; i++)
            {
                var s1 = res.GetState(i);
                for (var j = 0; j < s1.InitialNumArcs - 1; j++)
                {
                    var a = new Arc();
                    a.Ilabel    = (int)serializer.Deserialize(inStream);
                    a.Olabel    = (int)serializer.Deserialize(inStream);
                    a.Weight    = (float)serializer.Deserialize(inStream);
                    a.NextState = res._states[(int)serializer.Deserialize(inStream)];
                    s1.AddArc(a);
                }
            }

            return(res);
        }
Esempio n. 2
0
        public static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Input and output files are not provided");
                Console.WriteLine("You need to provide both the input serialized java fst model");
                Console.WriteLine("and the output binary openfst model.");
                Environment.Exit(1);
            }

            Fst fst = Fst.LoadModel(args[0]);

            Console.WriteLine("Saving as openfst text model...");
            Convert.Export(fst, args[1]);
        }
Esempio n. 3
0
        private static void ExportFst(Fst fst, string filename)
        {
            StreamWriter streamWriter = new StreamWriter(filename);

            // print start first
            State start = fst.Start;

            streamWriter.WriteLine(start.GetId() + "\t" + start.FinalWeight);

            // print all states
            int numStates = fst.GetNumStates();

            for (int i = 0; i < numStates; i++)
            {
                State s = fst.GetState(i);
                if (s.GetId() != fst.Start.GetId())
                {
                    streamWriter.WriteLine(s.GetId() + "\t" + s.FinalWeight);
                }
            }


            string[] isyms = fst.Isyms;
            string[] osyms = fst.Osyms;
            numStates = fst.GetNumStates();
            for (int i = 0; i < numStates; i++)
            {
                State s       = fst.GetState(i);
                int   numArcs = s.GetNumArcs();
                for (int j = 0; j < numArcs; j++)
                {
                    Arc    arc  = s.GetArc(j);
                    string isym = (isyms != null) ? isyms[arc.Ilabel] : Integer.ToString(arc.Ilabel);
                    string osym = (osyms != null) ? osyms[arc.Olabel] : Integer.ToString(arc.Olabel);

                    streamWriter.WriteLine(s.GetId() + "\t" + arc.NextState.GetId()
                                           + "\t" + isym + "\t" + osym + "\t" + arc.Weight);
                }
            }

            streamWriter.Close();
        }
Esempio n. 4
0
        public static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Input and output files not provided");
                Console.WriteLine("You need to provide both the input binary openfst model");
                Console.WriteLine("and the output serialized java fst model.");
                Environment.Exit(1);
            }

            //Serialize the java fst model to disk
            Fst fst = Convert.ImportFst(args[0], new TropicalSemiring());

            Console.WriteLine("Saving as binar java fst model...");
            try
            {
                fst.SaveModel(args[1]);
            }
            catch (IOException ex)
            {
                Console.WriteLine("Cannot write to file " + args[1]);
                Environment.Exit(1);
            }
        }
Esempio n. 5
0
 public static void Export(Fst fst, string basename)
 {
     ExportSymbols(fst.Isyms, basename + ".input.syms");
     ExportSymbols(fst.Osyms, basename + ".output.syms");
     ExportFst(fst, basename + ".fst.txt");
 }
Esempio n. 6
0
        public static Fst ImportFst(string basename, Semiring semiring)
        {
            Fst fst = new Fst(semiring);

            HashMap <string, Integer> isyms = ImportSymbols(basename + ".input.syms");

            if (isyms == null)
            {
                isyms = new HashMap <string, Integer>();
                isyms.Put("<eps>", 0);
            }

            HashMap <string, Integer> osyms = ImportSymbols(basename
                                                            + ".output.syms");

            if (osyms == null)
            {
                osyms = new HashMap <string, Integer>();
                osyms.Put("<eps>", 0);
            }

            HashMap <string, Integer> ssyms = ImportSymbols(basename + ".states.syms");

            // Parse input
            FileStream fis = new FileStream(basename + ".fst.txt", FileMode.Open);
            TextReader br  = new StreamReader(fis);

            bool   firstLine = true;
            string strLine;
            HashMap <Integer, State> stateMap = new HashMap <Integer, State>();

            while ((strLine = br.ReadLine()) != null)
            {
                string[] tokens = strLine.Split("\\t");
                Integer  inputStateId;
                if (ssyms == null)
                {
                    inputStateId = Integer.ParseInt(tokens[0]);
                }
                else
                {
                    inputStateId = ssyms.Get(tokens[0]);
                }
                State inputState = stateMap.Get(inputStateId);
                if (inputState == null)
                {
                    inputState = new State(semiring.Zero);
                    fst.AddState(inputState);
                    stateMap.Put(inputStateId, inputState);
                }

                if (firstLine)
                {
                    firstLine = false;
                    fst.SetStart(inputState);
                }

                if (tokens.Length > 2)
                {
                    Integer nextStateId;
                    if (ssyms == null)
                    {
                        nextStateId = Integer.ParseInt(tokens[1]);
                    }
                    else
                    {
                        nextStateId = ssyms.Get(tokens[1]);
                    }

                    State nextState = stateMap.Get(nextStateId);
                    if (nextState == null)
                    {
                        nextState = new State(semiring.Zero);
                        fst.AddState(nextState);
                        stateMap.Put(nextStateId, nextState);
                    }
                    // Adding arc
                    if (isyms.Get(tokens[2]) == null)
                    {
                        isyms.Put(tokens[2], isyms.Size());
                    }
                    int?iLabel = isyms.Get(tokens[2]);
                    if (osyms.Get(tokens[3]) == null)
                    {
                        osyms.Put(tokens[3], osyms.Size());
                    }
                    int?oLabel = osyms.Get(tokens[3]);

                    float arcWeight;
                    if (tokens.Length > 4)
                    {
                        arcWeight = Float.ParseFloat(tokens[4]);
                    }
                    else
                    {
                        arcWeight = 0;
                    }
                    Arc arc = new Arc(iLabel.Value, oLabel.Value, arcWeight, nextState);
                    inputState.AddArc(arc);
                }
                else
                {
                    if (tokens.Length > 1)
                    {
                        float finalWeight = Float.ParseFloat(tokens[1]);
                        inputState.FinalWeight = finalWeight;
                    }
                    else
                    {
                        inputState.FinalWeight = 0.0f;
                    }
                }
            }
            br.Close();

            fst.Isyms = Utils.Utils.ToStringArray(isyms);
            fst.Osyms = Utils.Utils.ToStringArray(osyms);

            return(fst);
        }