コード例 #1
0
        private static void RunCommand(string cmd)
        {
            cmd = cmd.ToLower();
            if (cmd.StartsWith("run! "))
            {
                cmd = cmd.Replace("run! ", "");
                if (TrainedNetwork != null)
                {
                    Console.WriteLine("\t" + TrainedNetwork.Compute(RootBreaker.BreakWord(cmd).SignificantRoots(2).GetVals())[0]);
                    Console.WriteLine("");
                }
            }
            else if (cmd.StartsWith("graph "))
            {
                cmd = cmd.Replace("graph ", "");
                var                        lineCount = File.ReadAllLines(cmd).Length;
                StreamReader               file      = new StreamReader(cmd);
                string                     line      = "";
                List <LogResult>           results   = new List <LogResult>();
                int                        maxLine   = 0;
                Dictionary <int, double[]> initial   = new Dictionary <int, double[]>();
                while ((line = file.ReadLine()) != null)
                {
                    if (line.Contains("type: new-word"))
                    {
                        NewWordResult res = new NewWordResult(line);
                        results.Add(res);
                    }
                    else if (line.Contains("type: abstraction"))
                    {
                        ClassResult res = new ClassResult(line);
                        if (initial.ContainsKey(res.Line))
                        {
                            initial[res.Line] = new double[] { initial[res.Line][0] + res.Value, initial[res.Line][1] + 1 };
                        }
                        else
                        {
                            initial.Add(res.Line, new double[] { res.Value, 1 });
                        }
                        results.Add(res);
                    }
                }
                double[] classResults = new double[20000];
                foreach (KeyValuePair <int, double[]> e in initial)
                {
                    classResults[e.Key] = (e.Value[0] / e.Value[1]);
                }
                for (int i = 0; i < classResults.Length; i++)
                {
                    Console.WriteLine(classResults[i]);
                }
            }
            else if (cmd.StartsWith("read "))
            {
                cmd = cmd.Replace("read ", "");
                StreamReader     file      = new StreamReader(cmd);
                string           line      = "";
                Queue <string>   readQueue = new Queue <string>();
                Queue <Sentence> sentences = new Queue <Sentence>();
                int lineNum = 0;
                while ((line = file.ReadLine()) != null)
                {
                    // remove not needed words
                    line = line.Replace(" the ", " ").Replace(" an ", " ").Replace(" a ", " ");
                    string[] words = line.Split(' ');

                    int i = 0;
                    for (i = 0; i < words.Length; i++)
                    {
                        Word w = new Word(words[i]);
                        // check abstraction only for nouns
                        if (w.WordType == WordType.Noun)
                        {
                            double             d  = GlobalNetworks.GetRootsNetwork().Compute(RootBreaker.BreakWord(w.Isolation).SignificantRoots(2).GetVals())[0];
                            WordClassification cl = d > 0.5 ? WordClassification.Abstract : WordClassification.Physical;
                            GlobalCache.LogAction("abstraction", $"class: {cl}, value: {d}, word: {w.Isolation}, line: {lineNum}");
                        }
                    }
                    i = 0;
                    while (i < words.Length)
                    {
                        string word = words[i];
                        readQueue.Enqueue(word);
                        if (word.Contains(".") || word.Contains("?") || word.Contains("!"))
                        {
                            // empty queue into sentance
                            string all = "";
                            while (readQueue.Count > 0)
                            {
                                all += " " + readQueue.Dequeue();
                            }
                            all = all.Trim();
                            Sentence s = new Sentence(all);
                            Console.WriteLine("\n\t > " + s.Raw);
                            sentences.Enqueue(s);
                            if (sentences.Count > 50)
                            {
                                Sentence        sen  = sentences.Dequeue();
                                List <Sentence> sens = SentenceBreaker.BreakSentence(sen);
                                // pass sentances into context analyzer
                            }
                        }
                        i++;
                    }
                    lineNum++;
                }

                file.Close();
            }
            else if (cmd.StartsWith("train "))
            {
                cmd = cmd.Replace("train ", "");
                if (cmd.StartsWith("root from "))
                {
                    cmd = cmd.Replace("root from ", "");
                    string[] args = cmd.Split(' ');
                    if (args.Length > 1)
                    {
                        string input  = args[0];
                        string output = args[1];
                        Console.WriteLine(">> training roots\n");
                        ActivationNetwork an = Analyzer.RunRoots(input, output);
                        Console.WriteLine(">> finished training roots\n");
                        TrainedNetwork = an;
                    }
                }
            }
            else if (cmd.StartsWith("test "))
            {
                cmd = cmd.Replace("test ", "");
                if (cmd.StartsWith("sen "))
                {
                    cmd = cmd.Replace("sen ", "");
                    List <List <Sentence> > s = SentenceBreaker.BreakString(cmd);
                    foreach (List <Sentence> list in s)
                    {
                        Console.WriteLine("\n\t> " + list);
                        foreach (Sentence sen in list)
                        {
                            Console.WriteLine($"\t - {sen.Raw}");
                        }
                    }
                }
                else if (cmd.StartsWith("syn "))
                {
                    cmd = cmd.Replace("syn ", "");
                    Word w = new Word(cmd);
                    w.LoadSynonyms();
                }
                else if (cmd == "backpropogation" || cmd == "bp")
                {
                    double[][] input = new double[4][] {
                        new double[] { 0, 0 }, new double[] { 0, 1 },
                        new double[] { 1, 0 }, new double[] { 1, 1 }
                    };
                    double[][] output = new double[4][] {
                        new double[] { 0 }, new double[] { 1 },
                        new double[] { 1 }, new double[] { 0 }
                    };

                    Console.WriteLine(">> testing back-propogation\n");
                    ActivationNetwork net = Neural.RunBackPropogation(input, output, 6);
                    Console.WriteLine($"\n>> test results:\n" +
                                      $"\n[0,0]\t{net.Compute(new double[] { 0, 0 })[0]}" +
                                      $"\n[0,1]\t{net.Compute(new double[] { 0, 1 })[0]}" +
                                      $"\n[1,0]\t{net.Compute(new double[] { 1, 0 })[0]}" +
                                      $"\n[1,1]\t{net.Compute(new double[] { 1, 1 })[0]}");
                }
            }
        }
コード例 #2
0
        public Word(string word)
        {
            WordClassification = WordClassification.None;
            Literal            = word;
            word      = word.Replace(":", "").Replace("?", "").Replace("_", "").Replace("!", "").Replace(".", "").ToLower().Replace("\"", "").Replace("\\", "").Replace("/", "").Replace(",", "");
            Isolation = word;
            if (GlobalCache.WordCache.ContainsKey(Isolation))
            {
                Word w = GlobalCache.WordCache[Isolation];
                WordType = w.WordType;
            }
            else
            {
                try
                {
                    string   w  = WebInteractive.GetPageContents(@"https://www.dictionary.com/browse/" + word);
                    string[] bk = w.Split(new string[] { "<span class=\"luna-pos\">" }, StringSplitOptions.None);
                    if (bk.Length < 2)
                    {
                        WordType = WordType.None;
                        return;
                    }
                    string type = bk[1].Split(new string[] { "</span>" }, StringSplitOptions.None)[0].Replace(",", "").Replace(";", "").ToLower();
                    switch (type)
                    {
                    case "definite article":
                        WordType = WordType.DefiniteArticle;
                        break;

                    case "noun adjective":
                    case "noun":
                        WordType = WordType.Noun;
                        break;

                    case "verb (used without object)":
                    case "verb (used with object)":
                    case "auxiliary verb":
                    case "verb":
                        WordType = WordType.Verb;
                        break;

                    case "interjection":
                        WordType = WordType.Interjection;
                        break;

                    case "adjective":
                        WordType = WordType.Adjective;
                        break;

                    case "adverb":
                        WordType = WordType.Adverb;
                        break;

                    case "pronoun":
                        WordType = WordType.Pronoun;
                        break;

                    case "preposition":
                        WordType = WordType.Preposition;
                        break;

                    case "conjunction":
                    case "connective":
                        WordType = WordType.Adjective;
                        break;

                    default:
                        WordType = WordType.None;
                        break;
                    }
                    if (WordType == WordType.None)
                    {
                        Console.WriteLine(Isolation + " - " + type);
                    }
                    GlobalCache.WordCache.Add(Isolation, this);
                    GlobalCache.LogAction("new-word", $"word: {Isolation}, type: {WordType}");
                    //Console.WriteLine($"\tcached: [{Isolation}, {WordType}]");
                }
                catch
                {
                }
            }
        }