public void LoadDictionary(string filepath) { gren = new SolarixGrammarEngineNET.GrammarEngine2(); gren.Load(filepath, false); Init(); return; }
public int DumpRule(System.IO.TextWriter dest, int LanguageID, SolarixGrammarEngineNET.GrammarEngine2 gren) { dest.WriteLine("\n\n#region\n// This rules has {0} successful checks:", success_count); // Выведем список эталонов, которые подтверждают правило: foreach (MatchedContextInfo sample in success_samples) { dest.WriteLine("// {0}", sample.ToString()); } dest.WriteLine("#endregion"); // теперь само правило string lang = string.Empty;; switch (LanguageID) { case SolarixGrammarEngineNET.GrammarEngineAPI.RUSSIAN_LANGUAGE: lang = "Russian"; break; case SolarixGrammarEngineNET.GrammarEngineAPI.ENGLISH_LANGUAGE: lang = "English"; break; } dest.WriteLine("colloc_filter auto_rule_{1} language={0}", lang, id); dest.WriteLine("{"); dest.WriteLine(" if context {{{0} }} then accept", rule_context_str); dest.WriteLine("}\n"); return(1); }
static bool IsPronoun_1s_nom(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode node) { return(GetPOS(gren, node) == SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN_ru && node.GetCoordState(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_ru) == SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_1_ru && node.GetCoordState(SolarixGrammarEngineNET.GrammarEngineAPI.CASE_ru) == SolarixGrammarEngineNET.GrammarEngineAPI.NOMINATIVE_CASE_ru && node.GetCoordState(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru) == SolarixGrammarEngineNET.GrammarEngineAPI.SINGULAR_NUMBER_ru); }
static int GetPOS(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode node) { int id_entry = node.GetEntryID(); int pos_id = gren.GetEntryClass(id_entry); return(pos_id); }
static string GetFeatures(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.AnalysisResults words, int focus_index) { List <string> features = new List <string>(); for (int offset = -window; offset <= window; ++offset) { int word_index = focus_index + offset; if (word_index >= 1 && word_index < words.Count - 1) { features.AddRange(GetWordFeatures(gren, words[word_index], offset.ToString())); if (word_index == 1) { features.Add($"start[{offset}]"); } if (word_index == words.Count - 2) { features.Add($"end[{offset}]"); } } } return(string.Join("\t", features)); }
static List <string> GetWordFeatures(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode word, string feature_prefix) { List <string> features = new List <string>(); if (emit_shingles) { // шинглы features.AddRange(GetShingles(word.GetWord()).Select(z => $"shingle[{feature_prefix}]={z}")); } if (emit_morphtags) { // морфологические фичи int id_class = gren.GetEntryClass(word.GetEntryID()); features.Add(string.Format("class[{0}]={1}", feature_prefix, id_class)); int nfeat = SolarixGrammarEngineNET.GrammarEngine.sol_GetNodePairsCount(word.hNode); for (int i = 0; i < nfeat; ++i) { int id_coord = SolarixGrammarEngineNET.GrammarEngine.sol_GetNodePairCoord(word.hNode, i); int id_state = SolarixGrammarEngineNET.GrammarEngine.sol_GetNodePairState(word.hNode, i); features.Add(string.Format("{0}[{2}]={1}", id_coord, id_state, feature_prefix)); } } return(features); }
public int Match(SolarixGrammarEngineNET.AnalysisResults tokens, int left_i, SolarixGrammarEngineNET.GrammarEngine2 gren) { // Проверяем, что не-омонимичные термы сопоставляются. bool m = true; for (int iterm = 0; iterm < points.Count; ++iterm) { if (points[iterm] != null) { SolarixGrammarEngineNET.SyntaxTreeNode token = tokens[left_i + iterm]; if (!points[iterm].Match(token, gren)) { m = false; break; } } } if (m) { // Осталось проверить, правильно ли снята омонимия. SolarixGrammarEngineNET.SyntaxTreeNode omonym_token = tokens[left_i + omonym_point.GetPosition()]; return(omonym_point.Match(omonym_token) ? 1 : 0); } return(-1); }
public FootPrint(SolarixGrammarEngineNET.GrammarEngine2 gren, List <SolarixGrammarEngineNET.SyntaxTreeNode> terms) { tokens = new List <FootPrintToken>(); foreach (var term in terms) { tokens.Add(new FootPrintToken(gren, term)); } }
public bool Match(SolarixGrammarEngineNET.SyntaxTreeNode proj, int iver, SolarixGrammarEngineNET.GrammarEngine2 gren) { if (lexeme != null) { return(proj.GetWord().Equals(lexeme, StringComparison.InvariantCultureIgnoreCase)); } if (id_lemma != null) { int ekey = proj.GetVersionEntryID(iver); if (id_lemma.Contains(ekey)) { return(true); } return(false); } if (pos != null) { bool pos_matched = false; int ekey = proj.GetVersionEntryID(iver); if (ekey != -1) { int id_class = gren.GetEntryClass(ekey); pos_matched = pos.Contains(id_class); } if (!pos_matched) { return(false); } } if (pairs != null) { bool contains_all_required_pairs = true; foreach (SolarixGrammarEngineNET.CoordPair p in pairs) { if (!proj.VersionContains(iver, p)) { contains_all_required_pairs = false; break; } } if (!contains_all_required_pairs) { return(false); } } return(true); }
public int DumpRules(System.IO.TextWriter dest, int LanguageID, SolarixGrammarEngineNET.GrammarEngine2 gren) { int counter = 0; foreach (var r in rules) { counter += r.Value.DumpRules(dest, LanguageID, gren); } return(counter); }
public SyntaxTreeNode( GrammarEngine2 _gren, IntPtr _hNode ) { gren = _gren; hNode = _hNode; int nleaf = GrammarEngine.sol_CountLeafs( hNode ); leafs = new List<SyntaxTreeNode>(); for( int i = 0; i < nleaf; ++i ) leafs.Add( new SyntaxTreeNode( gren, GrammarEngine.sol_GetLeaf( hNode, i ) ) ); return; }
public AnalysisResults( GrammarEngine2 gren, IntPtr _hPack, bool release_handle ) { hPack = new AnalysisResultsSafeHandle( _hPack, release_handle ); nodes = new List<SyntaxTreeNode>(); int n = SolarixGrammarEngineNET.GrammarEngine.sol_CountRoots( hPack.DangerousGetHandle(), 0 ); for( int i = 0; i < n; ++i ) { SyntaxTreeNode node = new SyntaxTreeNode( gren, SolarixGrammarEngineNET.GrammarEngine.sol_GetRoot( hPack.DangerousGetHandle(), 0, i ) ); nodes.Add( node ); } }
static string ChangePronounTo(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode node, string to_person) { List <int> coords = new List <int>(); List <int> states = new List <int>(); if (to_person == "1s") { coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.SINGULAR_NUMBER_ru); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_1_ru); } else if (to_person == "2s") { coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.SINGULAR_NUMBER_ru); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_2_ru); } else if (to_person == "3s") { coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.SINGULAR_NUMBER_ru); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_2_ru); } else { throw new ArgumentException("to_person"); } coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.CASE_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.NOMINATIVE_CASE_ru); string new_word = ""; List <string> fx = SolarixGrammarEngineNET.GrammarEngine.sol_GenerateWordformsFX(gren.GetEngineHandle(), node.GetEntryID(), coords, states); if (fx != null && fx.Count > 0) { new_word = fx[0].ToLower(); } else { new_word = null; } return(new_word); }
public AnalysisResults(GrammarEngine2 gren, IntPtr _hPack, bool release_handle) { hPack = new AnalysisResultsSafeHandle(_hPack, release_handle); nodes = new List <SyntaxTreeNode>(); int n = SolarixGrammarEngineNET.GrammarEngine.sol_CountRoots(hPack.DangerousGetHandle(), 0); for (int i = 0; i < n; ++i) { SyntaxTreeNode node = new SyntaxTreeNode(gren, SolarixGrammarEngineNET.GrammarEngine.sol_GetRoot(hPack.DangerousGetHandle(), 0, i)); nodes.Add(node); } }
private static string TermToString(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode term) { int id_entry = term.GetEntryID(); if (gren.GetEntryName(id_entry) == "???") { return(term.GetWord()); } string res_word = gren.RestoreCasing(id_entry, term.GetWord()); return(res_word); }
public string Preprocess(string phrase0, SolarixGrammarEngineNET.GrammarEngine2 gren) { string phrase = phrase0; if (phrase.EndsWith("..")) { phrase = phrase.Substring(0, phrase.Length - 2); } if (phrase.EndsWith("!")) { phrase = phrase.Substring(0, phrase.Length - 1); } string[] tokens = gren.Tokenize(phrase, SolarixGrammarEngineNET.GrammarEngineAPI.RUSSIAN_LANGUAGE); List <string> res_tokens = tokens.ToList(); bool changed = false; string s = string.Join("|", tokens).ToLower(); foreach (string prefix in prefixes) { if (s.StartsWith(prefix)) { // Ну и жара нынче стоит! res_tokens = res_tokens.Skip(prefix.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Length).ToList(); changed = true; break; } } foreach (string infix in infixes) { if (res_tokens.Contains(infix)) { res_tokens.Remove(infix); changed = true; } } if (changed) { return(string.Join(" ", res_tokens)); } else { return(phrase); } }
static bool IsVerb_1s(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode node) { if (GetPOS(gren, node) == SolarixGrammarEngineNET.GrammarEngineAPI.VERB_ru) { if (node.GetCoordState(SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_ru) == SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_1_ru && node.GetCoordState(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru) == SolarixGrammarEngineNET.GrammarEngineAPI.SINGULAR_NUMBER_ru && node.GetCoordState(SolarixGrammarEngineNET.GrammarEngineAPI.VERB_FORM_ru) == SolarixGrammarEngineNET.GrammarEngineAPI.VB_INF_ru) { return(true); } } return(false); }
public string GetContextPoint(SolarixGrammarEngineNET.GrammarEngine2 gren) { System.Text.StringBuilder b = new StringBuilder(); if (!string.IsNullOrEmpty(lexem)) { b.AppendFormat("\"{0}\"", lexem); } else { if (id_class != -1) { b.AppendFormat("{0}:*", gren.GetClassName(id_class)); } else { int pos = gren.GetEntryClass(id_entry); b.AppendFormat("{0}:{1}", gren.GetClassName(pos), gren.GetEntryName(id_entry)); } b.Append("{"); // выводим список координатных пар foreach (SolarixGrammarEngineNET.CoordPair p in pairs) { string CoordName = gren.GetCoordName(p.CoordID); if (gren.CountCoordStates(p.CoordID) == 0) { if (p.StateID == 1) { b.AppendFormat(" {0}", CoordName); } else { b.AppendFormat(" ~{0}", CoordName); } } else { string StateName = gren.GetCoordStateName(p.CoordID, p.StateID); b.AppendFormat(" {0}:{1}", CoordName, StateName); } } b.Append(" }"); } return(b.ToString()); }
public SyntaxTreeNode(GrammarEngine2 _gren, IntPtr _hNode) { gren = _gren; hNode = _hNode; int nleaf = GrammarEngine.sol_CountLeafs(hNode); leafs = new List <SyntaxTreeNode>(); for (int i = 0; i < nleaf; ++i) { leafs.Add(new SyntaxTreeNode(gren, GrammarEngine.sol_GetLeaf(hNode, i))); } return; }
static void Build_Morphology_CRF(SolarixGrammarEngineNET.GrammarEngine2 gren, List <string> model_params) { Builder_CRF builder = new Builder_CRF(SUFFIX_LEN, CONTEXT_SPAN); builder.SetModelParams(model_params); builder.SetDictionary(gren); builder.SetTmpFolder(tmp_folder); if (!string.IsNullOrEmpty(sematags_path)) { builder.LoadSemanticTags(sematags_path); } int counter = 0; int MAX_COUNT = NSAMPLE; int TEST_SHARE = 10; // каждый такой пример идет на валидацию foreach (var corpus in corpora) { foreach (SentenceData sample in corpus.Read(gren)) { counter++; if (counter >= MAX_COUNT) { break; } Console.WriteLine("{0}: {1}", counter, sample.GetSentenceStr()); if ((counter % TEST_SHARE) == 0) { builder.ProcessValidationSample(sample); } else { builder.ProcessTrainingSample(sample); } } } builder.FinishLearning(); Console.WriteLine("Storing the model files..."); builder.FinishTesting(); return; }
public OmonymContextEnumerator(SolarixGrammarEngineNET.AnalysisResults tokens, int _omonym_position, int _left_i, int _len, SolarixGrammarEngineNET.GrammarEngine2 _gren) { gren = _gren; left_i = _left_i; len = _len; omonym_position = _omonym_position; recognizers = new List <ContextRecognizer>(); // Для каждого токена, кроме омонимичной формы, генерируем список вариантов. // ... пока только код для контекстов длины=2 if (len == 2) { SolarixGrammarEngineNET.SyntaxTreeNode omonym_token = tokens[left_i + omonym_position]; OmonymTokenRecognizer omonym_point = new OmonymTokenRecognizer(omonym_position, omonym_token); if (omonym_position == 0) { TokenTagsEnumerator tte = new TokenTagsEnumerator(IsBoundaryToken(tokens, left_i + 1), tokens[left_i + 1], gren); int n = tte.Count; for (int i = 0; i < n; ++i) { List <TokenRecognizer> points = new List <TokenRecognizer>(); points.Add(null); // это омонимичная форма points.Add(tte[i]); ContextRecognizer ctx_recognizer = new ContextRecognizer(points, omonym_point, gren); recognizers.Add(ctx_recognizer); } } else { TokenTagsEnumerator tte = new TokenTagsEnumerator(IsBoundaryToken(tokens, left_i), tokens[left_i], gren); int n = tte.Count; for (int i = 0; i < n; ++i) { List <TokenRecognizer> points = new List <TokenRecognizer>(); points.Add(tte[i]); points.Add(null); // это омонимичная форма ContextRecognizer ctx_recognizer = new ContextRecognizer(points, omonym_point, gren); recognizers.Add(ctx_recognizer); } } } }
private string PrintContext(SolarixGrammarEngineNET.GrammarEngine2 gren) { System.Text.StringBuilder ctx_str = new StringBuilder(); foreach (var point in points) { if (point == null) { ctx_str.AppendFormat(" {0}", omonym_point.GetContextPoint(gren)); } else { ctx_str.AppendFormat(" {0}", point.GetContextPoint(gren)); } } return(ctx_str.ToString()); }
public int DumpRules(System.IO.TextWriter dest, int LanguageID, SolarixGrammarEngineNET.GrammarEngine2 gren) { int counter = 0; // Выводим все правила (todo - надо только самые общие из возможных), которые ни разу не ошиблись. List <ContextRecognizer> good = new List <ContextRecognizer>(); foreach (ContextRecognizer r in recognizers) { if (!r.HasEverFailed()) { good.Add(r); } } // теперь оставим в этом списке только ортогональные правила. List <ContextRecognizer> orthogonal = new List <ContextRecognizer>(); for (int i = 0; i < good.Count; ++i) { ContextRecognizer x = good[i]; bool is_orthogonal = true; for (int j = 0; j < good.Count; ++j) { if (i != j && good[j].IncludesY(x)) { is_orthogonal = false; break; } } if (is_orthogonal) { orthogonal.Add(x); } } foreach (ContextRecognizer r in orthogonal) { counter += r.DumpRule(dest, LanguageID, gren); } return(counter); }
public int MatchTags(SolarixGrammarEngineNET.SyntaxTreeNode token, SolarixGrammarEngineNET.GrammarEngine2 gren) { foreach (TagMatcher m in matchers) { if (m.Match(token, gren)) { return(m.GetId()); } } int entry_id = token.GetEntryID(); int pos_id = gren.GetEntryClass(entry_id); string part_of_speech = gren.GetClassName(pos_id); string tags = string.Join(" ", token.GetPairs().Select(z => string.Format("{0}={1}", gren.GetCoordName(z.CoordID), gren.GetCoordStateName(z.CoordID, z.StateID))).ToArray()); string msg = string.Format("Can not find tag for {0} {{ {1} {2} }}", token.GetWord(), part_of_speech, tags); throw new ApplicationException(msg); }
public bool Match(SolarixGrammarEngineNET.SyntaxTreeNode token, SolarixGrammarEngineNET.GrammarEngine2 gren) { if (!string.IsNullOrEmpty(lexem)) { return(lexem.Equals(token.GetWord(), StringComparison.CurrentCultureIgnoreCase)); } // Признаём сопоставимость с любой версией токена. int nver = token.VersionCount(); for (int iver = 0; iver < nver; ++iver) { int version_ekey = token.GetVersionEntryID(iver); if (id_entry != -1 && version_ekey == id_entry) { return(true); } if (id_class != -1 && gren.GetEntryClass(version_ekey) == id_class) { return(true); } bool pairs_matched = true; foreach (SolarixGrammarEngineNET.CoordPair p in pairs) { if (!token.VersionContains(iver, p)) { pairs_matched = false; break; } } if (pairs_matched) { return(true); } } return(true); }
private static void Build_LemmByPostags(SolarixGrammarEngineNET.GrammarEngine2 gren, List <string> model_params) { Builder_LEMM_ByPOSTag builder = new Builder_LEMM_ByPOSTag(); builder.ChangeModelParams(model_params); builder.SetDictionary(gren); builder.SetTmpFolder(tmp_folder); builder.Init(); int counter = 0; int MAX_COUNT = NSAMPLE == 0 ? int.MaxValue : NSAMPLE; int TEST_SHARE = 10; // каждый такой пример идет на валидацию foreach (var corpus in corpora) { foreach (SentenceData sample in corpus.Read(gren)) { counter++; if (counter >= MAX_COUNT) { break; } Console.WriteLine("{0}: {1}", counter, sample.GetSentenceStr()); if ((counter % TEST_SHARE) == 0) { builder.ProcessValidationSample(sample); } else { builder.ProcessTrainingSample(sample); } } } builder.FinishLearning(); builder.StartTesting(); builder.PrintTestResults(); return; }
public int MatchTags(SolarixGrammarEngineNET.SyntaxTreeNode proj, int iproj, SolarixGrammarEngineNET.GrammarEngine2 gren) { foreach (TagMatcher m in matchers) { if (m.Match(proj, iproj, gren)) { // ---~~~~~ DEBUG ~~~--- #if DEBUG string matcher = m.ToString(); string form = ""; int npair = SolarixGrammarEngineNET.GrammarEngine.sol_GetNodeVerPairsCount(proj.hNode, iproj); for (int j = 0; j < npair; ++j) { int id_coord = SolarixGrammarEngineNET.GrammarEngine.sol_GetNodeVerPairCoord(proj.hNode, iproj, j); int id_state = SolarixGrammarEngineNET.GrammarEngine.sol_GetNodeVerPairState(proj.hNode, iproj, j); string coord_name = gren.GetCoordName(id_coord); string state_name = null; if (gren.CountCoordStates(id_coord) == 0) { state_name = id_state.ToString(); } else { state_name = gren.GetCoordStateName(id_coord, id_state); } form += string.Format(" {0}:{1}", coord_name, state_name); } #endif // ---~~~~~ ..... ~~~--- return(m.GetId()); } } return(-1); }
public void Load(string lines, SolarixGrammarEngineNET.GrammarEngine2 gren) { matchers = new List <TagMatcher>(); id2matcher = new Dictionary <int, TagMatcher>(); id2index = new Dictionary <int, int>(); index2id = new Dictionary <int, int>(); foreach (string line in lines.Split('\n')) { string l = line.Trim(); if (!string.IsNullOrEmpty(l)) { TagMatcher m = new TagMatcher(line, gren); matchers.Add(m); id2matcher.Add(m.GetId(), m); id2index.Add(m.GetId(), matchers.Count - 1); index2id.Add(matchers.Count - 1, m.GetId()); } } return; }
private void ProcessTree(SolarixGrammarEngineNET.SyntaxTreeNode node, SolarixGrammarEngineNET.GrammarEngine2 gren) { int p_ekey = node.GetEntryID(); int id_class = gren.GetEntryClass(p_ekey); if ( id_class == SolarixGrammarEngineNET.GrammarEngineAPI.NOUN_ru || id_class == SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN2_ru || id_class == SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN_ru ) { SetLabel(node, string.Format("NP:{0}", chunk_num++), true); for (int ileaf = 0; ileaf < node.leafs.Count; ++ileaf) { SolarixGrammarEngineNET.SyntaxTreeNode leaf = node.leafs[ileaf]; if ( node.GetLinkType(ileaf) == SolarixGrammarEngineNET.GrammarEngineAPI.RIGHT_GENITIVE_OBJECT_link || node.GetLinkType(ileaf) == SolarixGrammarEngineNET.GrammarEngineAPI.OBJECT_link ) { SetLabel(leaf, string.Format("NP:{0}", chunk_num++), true); } } } else if (id_class == SolarixGrammarEngineNET.GrammarEngineAPI.PREPOS_ru) { SetLabel(node, string.Format("PN:{0}", chunk_num++), true); for (int ileaf = 0; ileaf < node.leafs.Count; ++ileaf) { SolarixGrammarEngineNET.SyntaxTreeNode leaf = node.leafs[ileaf]; int p_ekey2 = leaf.GetEntryID(); int id_class2 = gren.GetEntryClass(p_ekey2); if ( id_class2 == SolarixGrammarEngineNET.GrammarEngineAPI.NOUN_ru || id_class2 == SolarixGrammarEngineNET.GrammarEngineAPI.ADJ_ru || id_class2 == SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN_ru || id_class2 == SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN2_ru || id_class2 == SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru ) { SetLabel(leaf, string.Format("NP:{0}", chunk_num++), true); } } } else if ( id_class == SolarixGrammarEngineNET.GrammarEngineAPI.IMPERSONAL_VERB_ru || id_class == SolarixGrammarEngineNET.GrammarEngineAPI.VERB_ru || id_class == SolarixGrammarEngineNET.GrammarEngineAPI.INFINITIVE_ru ) { SetLabel(node, string.Format("VP:{0}", chunk_num++), true); SetLabel(node, string.Format("VX:{0}", chunk_num++), false); // корневой глагол отмечаем как VX for (int ileaf = 0; ileaf < node.leafs.Count; ++ileaf) { SolarixGrammarEngineNET.SyntaxTreeNode leaf = node.leafs[ileaf]; if (node.GetLinkType(ileaf) == SolarixGrammarEngineNET.GrammarEngineAPI.SUBJECT_link) { SetLabel(leaf, string.Format("NP:{0}", chunk_num++), true); } else if (node.GetLinkType(ileaf) == SolarixGrammarEngineNET.GrammarEngineAPI.OBJECT_link) { SetLabel(leaf, string.Format("NP:{0}", chunk_num++), true); } } } for (int ileaf = 0; ileaf < node.leafs.Count; ++ileaf) { SolarixGrammarEngineNET.SyntaxTreeNode leaf = node.leafs[ileaf]; ProcessTree(leaf, gren); } return; }
public void Collect(SolarixGrammarEngineNET.AnalysisResults tokens, SolarixGrammarEngineNET.AnalysisResults trees, SolarixGrammarEngineNET.GrammarEngine2 gren) { if (trees.Count == 3) { SolarixGrammarEngineNET.SyntaxTreeNode root = trees[1]; int p_ekey = root.GetEntryID(); int id_class = gren.GetEntryClass(p_ekey); if ( id_class == SolarixGrammarEngineNET.GrammarEngineAPI.IMPERSONAL_VERB_ru || id_class == SolarixGrammarEngineNET.GrammarEngineAPI.VERB_ru || id_class == SolarixGrammarEngineNET.GrammarEngineAPI.INFINITIVE_ru ) { ok = true; } } if (ok) { int N = tokens.Count; labels = new List <List <string> >(); for (int iroot = 0; iroot < N; ++iroot) { List <string> x = new List <string>(); x.Add("O"); labels.Add(x); } for (int iroot = 1; iroot < trees.Count - 1; ++iroot) { ProcessTree(trees[iroot], gren); } // ----------------------------------------------- // Уточняем разметку для групп существительных // ----------------------------------------------- for (int i = 1; i < N - 1; ++i) { List <string> l = labels[i]; if (l[0].StartsWith("NP")) { string NP = l[0]; // меняем метку у первого токена на B-NP l.RemoveAt(0); l.Insert(0, "B-NP"); // идем вправо до появления другой NP-метки. for (int k = i + 1; k < N; ++k) { if (labels[k][0] == NP) { labels[k].RemoveAt(0); labels[k].Insert(0, "I-NP"); } else { // Удалим все появления NP-метки далее вправо. for (int q = k; q < N; ++q) { labels[q].Remove(NP); } break; } } } } // Уточняем разметку для глагольных групп. for (int i = 1; i < N - 1; ++i) { List <string> l = labels[i]; if (l[0].StartsWith("VX")) { // Корневой глагол в сказуемом. // Цепочка токенов в группе может быть разорвана из-за того, что наречный оборот, привязанный к сказуемому, // стоит справа от глагольного дополнения. Поэтому проверим наличие таких разрывов. l.RemoveAt(0); // под VX лежит VP, который мы сейчас поднимем string VP = l[0]; int vp_begin = i; // ищем разрыв слева for (int k = i - 1; k >= 0; --k) { if (labels[k][0] != VP) { // слева - конец цепочки токенов для этого сказуемого. Удалим все более левые упоминания этого VP. for ( ; k >= 0; --k) { labels[k].Remove(VP); } break; } else { vp_begin = k; } } int vp_end = i; // ищем разрыв справа for (int k = i + 1; k < N; ++k) { if (labels[k][0] != VP) { // справа - конец цепочки токенов для этого сказуемого. Удалим все более правые упоминания этого VP. for ( ; k < N; ++k) { labels[k].Remove(VP); } break; } else { vp_end = k; } } // поставим отметку на первый VP-токен labels[vp_begin].RemoveAt(0); labels[vp_begin].Insert(0, "B-VP"); // а остальные пометим как I-VP for (int j = vp_begin + 1; j <= vp_end; ++j) { labels[j].Remove(VP); labels[j].Insert(0, "I-VP"); } } } for (int i = 0; i < labels.Count; ++i) { string l = labels[i][0]; string[] t = l.Split(':'); labels[i].Clear(); labels[i].Add(t[0]); } } return; }
public FootPrintToken(SolarixGrammarEngineNET.GrammarEngine2 gren, SolarixGrammarEngineNET.SyntaxTreeNode root) { Contract.Ensures(!string.IsNullOrEmpty(this.word)); Contract.Ensures(this.node != null); Contract.Ensures(this.tags != null); this.word = root.GetWord(); this.tags = new List <string>(); this.node = root; this.tags.Add(root.GetWord().ToLower()); if (root.GetWord().Equals("не", StringComparison.OrdinalIgnoreCase)) { this.tags.Add("neg"); } int part_of_speech = gren.GetEntryClass(root.GetEntryID()); switch (part_of_speech) { case SolarixGrammarEngineNET.GrammarEngineAPI.CONJ_ru: this.tags.Add("conj"); break; // союз case SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN_ru: this.tags.Add("pr"); break; // местоимение Я case SolarixGrammarEngineNET.GrammarEngineAPI.NOUN_ru: this.tags.Add("n"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.ADJ_ru: this.tags.Add("adj"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.VERB_ru: this.tags.Add("v"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.INFINITIVE_ru: this.tags.Add("v"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.GERUND_2_ru: this.tags.AddRange("adv adv_v".Split(' ')); break; case SolarixGrammarEngineNET.GrammarEngineAPI.ADVERB_ru: { this.tags.Add("adv"); if (StringExtender.InCI(word, "очень крайне наиболее наименее чрезвычайно почти".Split())) // модификаторы наречий и прилагательных { this.tags.Add("a_modif"); } string adv_cat = AdverbCategory.GetQuestionWordForAdverb(word); if (!string.IsNullOrEmpty(adv_cat)) { this.tags.Add("adv_" + adv_cat); } break; } case SolarixGrammarEngineNET.GrammarEngineAPI.PREPOS_ru: this.tags.Add("p"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PRONOUN2_ru: this.tags.Add("pr"); break; default: this.tags.Add("x"); break; } foreach (var p in root.GetPairs()) { if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.CASE_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.NOMINATIVE_CASE_ru: this.tags.Add("nom"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.GENITIVE_CASE_ru: this.tags.Add("gen"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.ACCUSATIVE_CASE_ru: this.tags.Add("acc"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.DATIVE_CASE_ru: this.tags.Add("dat"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PREPOSITIVE_CASE_ru: this.tags.Add("prep"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PARTITIVE_CASE_ru: this.tags.Add("part"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.LOCATIVE_CASE_ru: this.tags.Add("loc"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.INSTRUMENTAL_CASE_ru: this.tags.Add("instr"); break; } } if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.SINGULAR_NUMBER_ru: this.tags.Add("sing"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PLURAL_NUMBER_ru: this.tags.Add("pl"); break; } } if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.TENSE_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.PAST_ru: this.tags.Add("past"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PRESENT_ru: this.tags.Add("pres"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.FUTURE_ru: this.tags.Add("future"); break; } } if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.FORM_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.ANIMATIVE_FORM_ru: this.tags.Add("anim"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.INANIMATIVE_FORM_ru: this.tags.Add("inanim"); break; } } if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.GENDER_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.MASCULINE_GENDER_ru: this.tags.Add("masc"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.FEMININE_GENDER_ru: this.tags.Add("fem"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.NEUTRAL_GENDER_ru: this.tags.Add("neut"); break; } } if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_1_ru: this.tags.Add("1"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_2_ru: this.tags.Add("2"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.PERSON_3_ru: this.tags.Add("3"); break; } } if (p.CoordID == SolarixGrammarEngineNET.GrammarEngineAPI.VERB_FORM_ru) { switch (p.StateID) { case SolarixGrammarEngineNET.GrammarEngineAPI.VB_INF_ru: this.tags.Add("vf1"); break; case SolarixGrammarEngineNET.GrammarEngineAPI.VB_ORDER_ru: this.tags.Add("imper"); break; } } } }
static void Main(string[] args) { string parsed_sentences = @"F:\Corpus\parsing\ru\SENT4.parsing.txt"; string result_path = @"f:\tmp\negative3.dat"; string dict_path = @"e:\MVoice\lem\bin-windows64\dictionary.xml"; // Загрузим морфологический словарь, он нам понадобится для смены падежей слов. SolarixGrammarEngineNET.GrammarEngine2 gren = new SolarixGrammarEngineNET.GrammarEngine2(); gren.Load(dict_path, true); string[] files = null; if (System.IO.Directory.Exists(parsed_sentences)) files = System.IO.Directory.GetFiles(parsed_sentences, "*.parsing.txt"); else files = new string[1] { parsed_sentences }; List<TreeTemplate> templates = new List<TreeTemplate>(); templates.Add(new TreeTemplate("[class:ГЛАГОЛ]( <PREPOS_ADJUNCT>[class:ПРЕДЛОГ].<OBJECT>[class:МЕСТОИМЕНИЕ,СУЩЕСТВИТЕЛЬНОЕ,ПРИЛАГАТЕЛЬНОЕ] )")); sample_count = 0; using (wrt = new System.IO.StreamWriter(result_path)) { foreach (string file in files) { Console.WriteLine("Processing {0}...", file); using (Sentences src = new Sentences(file)) { while (src.Next()) { Sentence sent = src.GetFetched(); if (sent.root != null) { #region AdjNounAdjNoun for (int i1 = 0; i1 < sent.Tokens.Count; ++i1) { if (sent.Tokens[i1].part_of_speech == "СУЩЕСТВИТЕЛЬНОЕ") { SNode node1 = sent.Nodes.Where(z => z.index == i1).First(); if (node1.edge_types.Count > 0) { int edge1 = -1; for (int j1 = 0; j1 < node1.edge_types.Count; ++j1) { if (node1.edge_types[j1] == "ATTRIBUTE") { if (sent.Tokens[node1.children[j1].index].part_of_speech == "ПРИЛАГАТЕЛЬНОЕ") { edge1 = j1; break; } } } if (edge1 != -1) { // Нашли первое существительное с атрибутирующим прилагательным. int noun_ie1 = gren.FindEntry(sent.Tokens[i1].word, gren.FindPartOfSpeech(sent.Tokens[i1].part_of_speech)); SToken adj1 = sent.Tokens[node1.children[edge1].index]; adj1.word = adj1.word.ToLower(); for (int i2 = i1 + 2; i2 < sent.Tokens.Count; ++i2) { if (sent.Tokens[i2].part_of_speech == "СУЩЕСТВИТЕЛЬНОЕ") { int noun_ie2 = gren.FindEntry(sent.Tokens[i2].word, gren.FindPartOfSpeech(sent.Tokens[i2].part_of_speech)); if (noun_ie1 != noun_ie2) { int gender1 = gren.GetEntryAttrState(noun_ie1, SolarixGrammarEngineNET.GrammarEngineAPI.GENDER_ru); int gender2 = gren.GetEntryAttrState(noun_ie2, SolarixGrammarEngineNET.GrammarEngineAPI.GENDER_ru); if (gender1 == gender2) { string number1 = sent.Tokens[i1].tags.Where(z => z.StartsWith("ЧИСЛО:")).First().Split(':')[1]; string number2 = sent.Tokens[i2].tags.Where(z => z.StartsWith("ЧИСЛО:")).First().Split(':')[1]; if (number1 == number2) { SNode node2 = sent.Nodes.Where(z => z.index == i2).First(); if (node2.edge_types.Count > 0) { int edge2 = -1; for (int j2 = 0; j2 < node2.edge_types.Count; ++j2) { if (node2.edge_types[j2] == "ATTRIBUTE") { if (sent.Tokens[node2.children[j2].index].part_of_speech == "ПРИЛАГАТЕЛЬНОЕ") { edge2 = j2; break; } } } if (edge2 != -1) { // Нашли второе существительное с атрибутирующим прилагательным. SToken adj2 = sent.Tokens[node2.children[edge2].index]; adj2.word = adj2.word.ToLower(); // Сгенерируем предложение, в котором эти прилагательные поменяны местами. List<SToken> tokens2 = new List<SToken>(); foreach (SToken t in sent.Tokens) { if (t.index == adj1.index) { tokens2.Add(adj2); } else if (t.index == adj2.index) { tokens2.Add(adj1); } else { tokens2.Add(t); } } StoreSample(sent, tokens2); } else { // у второго существительного нет атрибутирующего прилагательного. // перенесем прилагательное от первого ко второму существительному. List<SToken> tokens2 = new List<SToken>(); foreach (SToken t in sent.Tokens) { if (t.index == adj1.index) { continue; } else if (t.index == i2) { tokens2.Add(adj1); tokens2.Add(sent.Tokens[i2]); } else { tokens2.Add(t); } } StoreSample(sent, tokens2); } } } } } } } } } } } #endregion AdjNounAdjNoun #region NounNoun // Ищем два существительных, связанных в конструкцию родительного дополнения: // "восход солнца" // Генерируем предложение с перестановкой слов и сменой падежей: // "солнце восхода" foreach (SNode n1 in sent.Nodes) { SToken t1 = sent.Tokens[n1.index]; // восход if (t1.part_of_speech == "СУЩЕСТВИТЕЛЬНОЕ") { if (n1.children.Count > 0) { int gen_edge_index = n1.edge_types.IndexOf("RIGHT_GENITIVE_OBJECT"); if (gen_edge_index != -1) { SToken t2 = sent.Tokens[n1.children[gen_edge_index].index]; // солнца if (gen_edge_index != -1 && t2.part_of_speech == "СУЩЕСТВИТЕЛЬНОЕ") { List<SToken> tokens2 = new List<SToken>(); bool t12_ok = true; foreach (SToken t in sent.Tokens) { if (t.index == t1.index) { // сюда вставляем слово "солнца" и меняем его падеж на падеж слова t string t_case = t.tags.Where(z => z.StartsWith("ПАДЕЖ:")).First().Split(':')[1]; string t_number = t2.tags.Where(z => z.StartsWith("ЧИСЛО:")).First().Split(':')[1]; int ie_t2 = gren.FindEntry(t2.lemma, gren.FindPartOfSpeech(t2.part_of_speech)); if (ie_t2 != -1) { List<int> coords = new List<int>(); List<int> states = new List<int>(); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.CASE_ru); states.Add(gren.FindState(SolarixGrammarEngineNET.GrammarEngineAPI.CASE_ru, t_case)); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru); states.Add(gren.FindState(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru, t_number)); List<string> forms = gren.GenerateWordforms(ie_t2, coords, states); if (forms.Count > 0) { string new_word = gren.RestoreCasing(ie_t2, forms[0]); SToken new_t = new SToken(); new_t.index = t.index; new_t.word = new_word; new_t.lemma = t.lemma; new_t.part_of_speech = t1.part_of_speech; tokens2.Add(new_t); } else { t12_ok = false; } } else { t12_ok = false; } } else if (t.index == t2.index) { // сюда вставляем слово "восход" и меняем его падеж на родительный string t_number = t1.tags.Where(z => z.StartsWith("ЧИСЛО:")).First().Split(':')[1]; int ie_t1 = gren.FindEntry(t1.lemma, gren.FindPartOfSpeech(t1.part_of_speech)); if (ie_t1 != -1) { List<int> coords = new List<int>(); List<int> states = new List<int>(); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.CASE_ru); states.Add(SolarixGrammarEngineNET.GrammarEngineAPI.GENITIVE_CASE_ru); coords.Add(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru); states.Add(gren.FindState(SolarixGrammarEngineNET.GrammarEngineAPI.NUMBER_ru, t_number)); List<string> forms = gren.GenerateWordforms(ie_t1, coords, states); if (forms.Count > 0) { string new_word = gren.RestoreCasing(ie_t1, forms[0]); SToken new_t = new SToken(); new_t.index = t.index; new_t.word = new_word; new_t.lemma = t.lemma; new_t.part_of_speech = t.part_of_speech; tokens2.Add(new_t); } else { t12_ok = false; } } else { t12_ok = false; } } else { tokens2.Add(t); } } if (t12_ok) { StoreSample(sent, tokens2); } } } } } } #endregion NounNoun #region PrepObject // Ищем предлог. foreach (SToken token_prepos in sent.Tokens) { if (token_prepos.part_of_speech == "ПРЕДЛОГ") { // Нашли предлог. Теперь перенесем его в другую позицию. List<Tuple<SToken, float>> tokens2 = sent.Tokens.Where(z => z.index != token_prepos.index).Select(z => new Tuple<SToken, float>(z, z.index)).ToList(); foreach (var t2 in tokens2.Where(z => z.Item1.index != token_prepos.index + 1)) { // Ставим предлог в позицию ПЕРЕД токеном t2 и генерируем предложение. List<Tuple<SToken, float>> tokens3 = new List<Tuple<SToken, float>>(); tokens3.AddRange(tokens2); tokens3.Add(new Tuple<SToken, float>(token_prepos, t2.Item2 - 0.5f)); StoreSample(sent, tokens3.OrderBy(z => z.Item2).Select(z => z.Item1).ToList()); } } } #endregion PrepObject /* foreach (TreeTemplate t in templates) { if (t.Match(sent)) { } } */ } } } } } Console.WriteLine("\nsample_count={0}", sample_count); return; }
public TextSegmenter( GrammarEngine2 _gren, IntPtr _hObject ) { gren = _gren; hObject = _hObject; }
public static string tmp_folder = "."; // папка для генерируемых временных файлов - логи, датасеты. static void Main(string[] args) { List <string> model_params = new List <string>(); if (args.Length > 0) { for (int i = 0; i < args.Length; ++i) { if (args[i] == "-dict") { // Путь к файлу с конфигурацией словарной базы. dictionary_path = args[i + 1]; ++i; } else if (args[i] == "-tmp") { // Временный каталог для сохранения датасетов. tmp_folder = args[i + 1]; ++i; } else if (args[i] == "-corpus") { // Путь к бинарному корпусу в формате Solarix. string corpus_path = args[i + 1]; corpora.Add(new SolarixBinaryCorpusReader(corpus_path)); ++i; } else if (args[i] == "-conllu_corpus") { // Путь к корпусу в формате ConllU string corpus_path = args[i + 1]; corpora.Add(new ConlluCorpusReader(corpus_path)); ++i; } else if (args[i] == "-nsample") { NSAMPLE = int.Parse(args[i + 1]); ++i; } else if (args[i] == "-minsentlen") { MIN_SENT_LEN = int.Parse(args[i + 1]); ++i; } else if (args[i] == "-suffix_len") { SUFFIX_LEN = int.Parse(args[i + 1]); ++i; } else if (args[i] == "-context_span") { // полуразмер контекста - число слов вправо или влево от текущего слова. CONTEXT_SPAN = int.Parse(args[i + 1]); ++i; } else if (args[i] == "-params") { string[] px = args[i + 1].Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); model_params.AddRange(px); ++i; } else { throw new ApplicationException(string.Format("Unknown option [{0}] in command line", args[i])); } } } Console.WriteLine("Loading dictionary from {0}...", dictionary_path); SolarixGrammarEngineNET.GrammarEngine2 gren; gren = new SolarixGrammarEngineNET.GrammarEngine2(); gren.Load(dictionary_path, true); Build_LemmByPostags(gren, model_params); return; }
static void Execute( string[] args ) { string dictionary_path = @"e:\MVoice\lem\bin-windows\dictionary.xml"; // путь к словарной базе string samples_path = @"E:\MVoice\lem\Слова\rus\SENT5.plain.txt"; // путь к файлу со списком предложений (одно предложение на одной строке) int NSAMPLE = 20000; // сколько предложений максимум обработать int START_INDEX = 0; // порядковый номер первого обрабатываемого предложений в исходном файле int MAXARGS = 20; // beam size bool append_result = false; // если леммы надо добавлять к существующему файлу, а не формировать файл с нуля string save_path = null; // путь к файлу, куда будут записаны леммы int source_format = 0; // 0 - token per line, 1 - sentence per line bool output_lemmas = true; // в результат записывать леммы с приведением к нижнему регистру bool output_suffix = false; bool output_words = false; // в результат записывать исходные слова с приведением к нижнему регистру int suffix_len = 0; int min_sentence_length = 0; // фильтр по минимальной длине предложений int max_sentence_length = int.MaxValue; // фильтр по максимальной длине предложений bool reject_unknown = false; // отбрасывать предложения с несловарными токенами bool emit_eol = false; // добавлять в выходной файл токены <EOL> для маркировки конца предложения int eol_count = 0; // кол-во вставляемых <EOL>, гарантированно перекрывающее размер окна в word2vec List<System.Text.RegularExpressions.Regex> rx_stop = new List<System.Text.RegularExpressions.Regex>(); for( int i = 0; i < args.Length; ++i ) { if( args[i] == "-dict" ) { ++i; dictionary_path = args[i]; } else if( args[i] == "-samples" ) { ++i; samples_path = args[i]; } else if( args[i] == "-source_format" ) { ++i; source_format = int.Parse( args[i] ); } else if( args[i] == "-append" ) { // Добавлять в конец существующего файла append_result = true; } else if( args[i] == "-emit_eol" ) { ++i; eol_count = int.Parse( args[i] ); if( eol_count > 0 ) emit_eol = true; } else if( args[i] == "-result" ) { // Способ обработки токенов: // lemma => лемматизация // suffix => усечение до псевдосуффикса длиной -suffix_len // raw => исходные слова ++i; output_lemmas = false; output_suffix = false; output_words = false; if( args[i] == "suffix" ) { output_suffix = true; } else if( args[i] == "lemma" ) { output_lemmas = true; } else if( args[i] == "raw" ) { output_words = true; } else throw new ApplicationException( string.Format( "Unknown result format: {0}", args[i] ) ); } else if( args[i] == "-save" ) { // Путь к файлу, куда будут записываться результаты обработки ++i; save_path = args[i]; } else if( args[i] == "-nsample" ) { // кол-во обрабатываемых предложений, начиная с -start_index ++i; NSAMPLE = int.Parse( args[i] ); } else if( args[i] == "-min_sent_len" ) { // Обрабатывать только предложения, содержащие не менее NNN токенов ++i; min_sentence_length = int.Parse( args[i] ); } else if( args[i] == "-max_sent_len" ) { // Обрабатывать только предложения, содержащие не более NNN токенов ++i; max_sentence_length = int.Parse( args[i] ); } else if( args[i] == "-suffix_len" ) { ++i; suffix_len = int.Parse( args[i] ); } else if( args[i] == "-start_index" ) { // Начинать обработку с предложения с указанным индексом ++i; START_INDEX = int.Parse( args[i] ); } else if( args[i] == "-reject_unknown" ) { reject_unknown = true; } else if( args[i] == "-rx_stop" ) { ++i; using( System.IO.StreamReader rdr = new System.IO.StreamReader( args[i] ) ) { while( !rdr.EndOfStream ) { string line = rdr.ReadLine(); if( line == null ) break; line = line.Trim(); if( line.Length > 0 ) { rx_stop.Add( new System.Text.RegularExpressions.Regex( line ) ); } } } } else throw new ApplicationException( string.Format( "Unknown option {0}", args[i] ) ); } Samples sources = null; if( source_format == 1 ) sources = new Samples1( samples_path ); else sources = new Samples2( samples_path ); sources.SetMinSentenceLen( min_sentence_length ); sources.SetMaxSentenceLen( max_sentence_length ); if( output_suffix || output_words ) sources.SetTokenDelimiter( '|' ); SolarixGrammarEngineNET.GrammarEngine2 gren = null; gren = new SolarixGrammarEngineNET.GrammarEngine2(); if( output_lemmas ) { gren.Load( dictionary_path, true ); } int counter = -1; int n_processed = 1; int MAX_COUNT = NSAMPLE; int LanguageID = SolarixGrammarEngineNET.GrammarEngineAPI.RUSSIAN_LANGUAGE; int Constraints = 120000 | ( MAXARGS << 22 ); // 2 мин и 20 альтернатив SolarixGrammarEngineNET.GrammarEngine.MorphologyFlags Flags = SolarixGrammarEngineNET.GrammarEngine.MorphologyFlags.SOL_GREN_MODEL_ONLY | SolarixGrammarEngineNET.GrammarEngine.MorphologyFlags.SOL_GREN_MODEL; // сколько всего предложений Console.WriteLine( "Counting lines in source file {0}...", samples_path ); int n_total_lines = sources.TotalCount(); Console.WriteLine( "Total number of lines={0}", n_total_lines.ToString( "N0", new System.Globalization.CultureInfo( "en-US" ) ) ); System.IO.StreamWriter wrt = new System.IO.StreamWriter( save_path, append_result, new UTF8Encoding( false ) ); sources.Start(); while( true ) { string sample = sources.Next(); if( sample == null ) break; sample = sample.Trim(); counter++; if( counter < START_INDEX ) continue; if( n_processed >= MAX_COUNT ) break; bool contains_insane_chars = false; foreach( char c in sample ) if( c < 32 ) { contains_insane_chars = true; break; } if( contains_insane_chars ) { System.Text.StringBuilder b = new StringBuilder( sample.Length ); foreach( char c in sample ) if( c >= 32 ) b.Append( c ); sample = b.ToString(); } n_processed++; if( sample.Length == 0 ) continue; if( rx_stop.Count > 0 ) { bool reject_this_sample = false; foreach( var rx in rx_stop ) if( rx.Match( sample ).Success ) { reject_this_sample = true; break; } if( reject_this_sample ) continue; } if( output_lemmas ) { using( SolarixGrammarEngineNET.AnalysisResults tokens = gren.AnalyzeMorphology( sample, LanguageID, Flags, Constraints ) ) { for( int i = 1; i < tokens.Count - 1; ++i ) { if( char.IsPunctuation( tokens[i].GetWord()[0] ) ) continue; int id_entry = tokens[i].GetEntryID(); string lemma = gren.GetEntryName( id_entry ); if( lemma == "???" || lemma.Equals( "UNKNOWNENTRY", StringComparison.InvariantCultureIgnoreCase ) || lemma.Equals( "number_", StringComparison.InvariantCultureIgnoreCase ) ) lemma = tokens[i].GetWord(); lemma = lemma.ToLower(); wrt.Write( " {0}", lemma ); } } } else if( output_words ) { string[] tokens = sample.Split( "|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries ); foreach( string token in tokens ) { if( token.Length >= 1 && char.IsPunctuation( token[0] ) ) continue; string norma = token.ToLower(); wrt.Write( " {0}", norma ); } } else if( output_suffix ) { string[] tokens = sample.Split( "|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries ); foreach( string token in tokens ) { if( token.Length == 0 || ( token.Length == 1 && char.IsPunctuation( token[0] ) ) ) continue; string suffix = token; int num; if( int.TryParse( token, out num ) ) suffix = token.Substring( token.Length - 1 ); else if( token.Length > suffix_len + 1 ) suffix = "~" + token.Substring( token.Length - suffix_len ); wrt.Write( " {0}", suffix.ToLower() ); } } if( emit_eol ) for( int k = 0; k < eol_count; ++k ) wrt.Write( " <EOL>" ); Console.WriteLine( "[{1}/{2}] {0}", sample, counter, n_total_lines ); wrt.Flush(); } wrt.Close(); return; }