public static void writeAboutTable(XmlWriter writer, SampleSet samplesSet, IFuzzySystem Classifier) { writer.WriteStartElement("Table"); writer.WriteAttributeString("Name", samplesSet.FileName); if (samplesSet == Classifier.LearnSamplesSet) { writer.WriteAttributeString("Type", "Training"); } else { writer.WriteAttributeString("Type", "Testing"); } writer.WriteAttributeString("Output", samplesSet.OutputAttribute.Name); writer.WriteStartElement("Attributes"); writer.WriteAttributeString("Count", XmlConvert.ToString(samplesSet.CountVars + 1)); for (int i = 0; i < samplesSet.CountVars; i++) { writeAboutAttribute(writer, samplesSet.InputAttributes[i]); } writeAboutAttribute(writer, samplesSet.OutputAttribute); writer.WriteEndElement(); writeAboutRows(writer, samplesSet); writer.WriteEndElement(); }
public IFuzzySystem UniversalMethod(IFuzzySystem FSystem, ILearnAlgorithmConf conf) { init(FSystem, conf); for (int m = 0; m < max_Features; m++) { for (int i = 0; i < FSystem.CountFeatures; i++) { if (BestSolute[i] == true) { continue; } test.Add(BestSolute.Clone() as bool[]); test[test.Count - 1][i] = true; FSystem.AcceptedFeatures = test[test.Count - 1]; Errors.Add(FSystem.ErrorLearnSamples(FSystem.AbstractRulesBase()[0])); } int best = Errors.IndexOf(Errors.Min()); BestSolute = test[best].Clone() as bool[]; FSystem.AcceptedFeatures = BestSolute; Storage.Add(new FeatureSelectionModel(FSystem, BestSolute)); test.Clear(); Errors.Clear(); } Storage = FeatureSelectionModel.Distinct(Storage); FeatureSelectionModel.Sort(Storage, SortWay); return(FSystem); }
private void save_FS(IFuzzySystem FS, string Name_alg) { if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } string file_name = DateTime.Now.ToLongDateString() + " " + DateTime.Now.TimeOfDay.ToString("hh','mm','ss") + " (" + Thread.CurrentThread.ManagedThreadId.ToString() + ") {" + Name_alg + "}.ufs"; writeIFuzzySystemUFS(FS, path + file_name); }
private void BrowseB_Click(object sender, EventArgs e) { if (openFSDialog.ShowDialog() == DialogResult.OK) { string fileName = openFSDialog.FileName; if (File.Exists(fileName)) { tempTable = BaseUFSLoader.LoadLearnFromUFS(fileName); temptestTable = BaseUFSLoader.LoadTestFromUFS(fileName); FSystem = BaseUFSLoader.LoadUFS(fileName, out TSystem); switch (TSystem) { case FuzzySystemRelisedList.TypeSystem.PittsburghClassifier: { PCFS = FSystem as PCFuzzySystem; break; } case FuzzySystemRelisedList.TypeSystem.Singletone: { SAFS = FSystem as SAFuzzySystem; break; } case FuzzySystemRelisedList.TypeSystem.TakagiSugenoApproximate: { TSAFS = FSystem as TSAFuzzySystem; break; } } NamesOfTerms = new String[getCountVars()][]; indexofTerm = new int[getCountVars()][]; makeNamesforAll(); FeatureCB.Items.Clear(); for (int i = 0; i < getCountVars(); i++) { FeatureCB.Items.Add(getNameAttribute(i)); } FeatureCB.SelectedIndex = 0; MakeRulesB.Enabled = true; RulesRTB.Text = ""; } } }
public IFuzzySystem UniversalMethod(IFuzzySystem FSystem, ILearnAlgorithmConf config) { init(FSystem, config); ////////////////////////////////////////////////////////////////////////////////////Первоначальная генерация for (int u = 0; u < MCount; u++) { ///Создаем частицу for (int i = 0; i < max_Features; i++) { if (rand.NextDouble() > 0.5) { Solute[i] = true; } else { Solute[i] = false; } } ///Проверяем, есть ли признаки. Если частица пуста, рандомный признак становится единицей if (Solute.Count(x => x == true) == 0) { BestSolute[rand.Next(BestSolute.Count())] = true; } ; //Заносим частицу в популяцию test.Add(Solute.Clone() as bool[]); //Заносим признаки в классификатор FSystem.AcceptedFeatures = test[test.Count - 1]; Errors.Add(FSystem.ErrorLearnSamples(FSystem.AbstractRulesBase()[0])); if (Errors[u] < Ebest) { Ebest = Errors[u]; BestSolute = test[u].Clone() as bool[]; Console.WriteLine("Найдена частица с ошибкой E=" + Errors[u]); Storage.Add(new FeatureSelectionModel(FSystem, BestSolute)); } Console.WriteLine(Errors[u]); } /////////////////////////////////////////// Сгенерировали первоначальные частицы, ура! algoritm(); Storage = FeatureSelectionModel.Distinct(Storage); FeatureSelectionModel.Sort(Storage, SortWay); FSystem.AcceptedFeatures = BestSolute; return(FSystem); }
public void init(IFuzzySystem FSystem, ILearnAlgorithmConf conf) { GreedyChoiceConfigMinus Config = conf as GreedyChoiceConfigMinus; SortWay = Config.GCCSortWay; Storage = new List <FeatureSelectionModel>(FSystem.CountFeatures); test = new List <bool[]>(); Errors = new List <double>(); BestSolute = new bool[FSystem.AcceptedFeatures.Count()]; for (int i = 0; i < FSystem.CountFeatures; i++) { BestSolute[i] = true; } }
public IFuzzySystem Universal(IFuzzySystem FS, IGeneratorConf config) { ShrinkFeatures = ((SimpleShrinkFeatureConf)config).ShrinkFeature; string[] shouldShrink = ShrinkFeatures.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < shouldShrink.Length; i++) { int a; int.TryParse(shouldShrink[i], out a); FS.AcceptedFeatures[a - 1] = false; } return(FS); }
public void init(IFuzzySystem FSystem, ILearnAlgorithmConf conf) { GreedyChoiceConfigPlus Config = conf as GreedyChoiceConfigPlus; max_Features = Config.GCCMaxVars > FSystem.AcceptedFeatures.Length? FSystem.AcceptedFeatures.Length: Config.GCCMaxVars; SortWay = Config.GCCSortWay; test = new List <bool[]>(); Errors = new List <double>(); Storage = new List <FeatureSelectionModel>(); BestSolute = new bool[FSystem.AcceptedFeatures.Count()]; for (int i = 0; i < FSystem.CountFeatures; i++) { BestSolute[i] = false; } }
string makeNameFeatures(IFuzzySystem FSystem, bool[] Source) { string temp = String.Empty; string temp2 = String.Empty; for (int i = 0; i < Source.Count(); i++) { if (Source[i]) { temp += FSystem.LearnSamplesSet.InputAttributes[i].Name + ", "; temp2 += $"{i + 1}, "; } } return(temp + Environment.NewLine + temp2); }
private string ErrorInfoPC(IFuzzySystem FS) { PCFuzzySystem IFS = FS as PCFuzzySystem; if (IFS.RulesDatabaseSet.Count < 1) { return("Точность нечеткой системы недоступна"); } classLearnResult.Add(IFS.ClassifyLearnSamples(IFS.RulesDatabaseSet[0])); classTestResult.Add(IFS.ClassifyTestSamples(IFS.RulesDatabaseSet[0])); classErLearn.Add(IFS.ErrorLearnSamples(IFS.RulesDatabaseSet[0])); classErTest.Add(IFS.ErrorTestSamples(IFS.RulesDatabaseSet[0])); return("Точностью на обучающей выборке " + classLearnResult[classLearnResult.Count - 1].ToString() + " , Точность на тестовой выборке " + classTestResult[classTestResult.Count - 1].ToString() + " " + Environment.NewLine + "Ошибкой на обучающей выборке " + classErLearn[classErLearn.Count - 1].ToString() + " , Ошибкой на тестовой выборке " + classErTest[classErTest.Count - 1].ToString() + " " + Environment.NewLine); }
public static void writeAboutObservation(XmlWriter writer, IFuzzySystem Classifier) { writer.WriteStartElement("Observations"); if (Classifier.TestSamplesSet != null) { writer.WriteAttributeString("CountTable", XmlConvert.ToString(2)); writeAboutTable(writer, Classifier.LearnSamplesSet, Classifier); writeAboutTable(writer, Classifier.TestSamplesSet, Classifier); } else { writer.WriteAttributeString("CountTable", XmlConvert.ToString(1)); writeAboutTable(writer, Classifier.LearnSamplesSet, Classifier); } writer.WriteEndElement(); }
public static IFuzzySystem LoadUFS(string FileName, out FuzzySystemRelisedList.TypeSystem TypeFS) { IFuzzySystem result = null; TypeFS = FuzzySystemRelisedList.TypeSystem.PittsburghClassifier; XmlDocument Source = new XmlDocument(); Source.Load(FileName); XmlNode temp = Source.SelectSingleNode("FuzzySystem"); string typestring = temp.Attributes.GetNamedItem("Type").Value.ToLowerInvariant(); switch (typestring) { case "approximatortakagisugeno": { TSAFuzzySystem TSAFS = new TSAFuzzySystem(LoadLearnFromUFS(Source), LoadTestFromUFS(Source)); TSAFS.loadUFS(Source); result = TSAFS; TypeFS = FuzzySystemRelisedList.TypeSystem.TakagiSugenoApproximate; break; } case "approximatorsingleton": { SAFuzzySystem SAFS = new SAFuzzySystem(LoadLearnFromUFS(Source), LoadTestFromUFS(Source)); SAFS.loadUFS(Source); result = SAFS; TypeFS = FuzzySystemRelisedList.TypeSystem.Singletone; break; } case "classifierpittsburgh": { PCFuzzySystem PCFS = new PCFuzzySystem(LoadLearnFromUFS(Source), LoadTestFromUFS(Source)); PCFS.loadUFS(Source); result = PCFS; TypeFS = FuzzySystemRelisedList.TypeSystem.PittsburghClassifier; break; } } return(result); }
public FeatureSelectionModel(IFuzzySystem Fsystem, bool[] FeaturesSource) { bool[] temp = Fsystem.AcceptedFeatures; Features = FeaturesSource; Fsystem.AcceptedFeatures = Features; Error = Fsystem.ErrorLearnSamples(Fsystem.AbstractRulesBase()[0]); ErrorTest = Fsystem.ErrorTestSamples(Fsystem.AbstractRulesBase()[0]); Fsystem.AcceptedFeatures = temp; if (Fsystem is PCFuzzySystem) { Accuracy = 100.0 - Error; AccuracyTest = 100.0 - ErrorTest; } else { Error = Fsystem.RMSEtoMSEforLearn(Error); ErrorTest = Fsystem.RMSEtoMSEforTest(ErrorTest); } Info = makeNameFeatures(Fsystem, Features); }
public void init(IFuzzySystem FSystem, ILearnAlgorithmConf conf) { theFuzzySystem = FSystem; grbin_conf Config = conf as grbin_conf; Ebest = Config.GSAErrorBest; Ebest1 = Ebest; iterMax = Config.GSAMInter; MCount = Config.GSAMCount; G0 = Config.GSAG0; alpha = Config.GSAAlpha; epsilon = Config.GSAEpsilon; open_Features = Config.GSAMaxVars; max_Features = FSystem.CountFeatures; test = new List <bool[]>(); Errors = new List <double>(); BestSolute = new bool[FSystem.AcceptedFeatures.Count()]; GoodSolute = new bool[FSystem.AcceptedFeatures.Count()]; Solute = new bool[FSystem.AcceptedFeatures.Count()]; Storage = new List <FeatureSelectionModel>(); SortWay = Config.GSASortWay; }
private string ErrorInfoTSA(IFuzzySystem FS) { TSAFuzzySystem IFS = FS as TSAFuzzySystem; if (IFS.RulesDatabaseSet.Count < 1) { return("Точность нечеткой системы недоступна"); } approxLearnResult.Add(IFS.approxLearnSamples(IFS.RulesDatabaseSet[0])); approxTestResult.Add(IFS.approxTestSamples(IFS.RulesDatabaseSet[0])); approxLearnResultMSE.Add(IFS.RMSEtoMSEforLearn(approxLearnResult[approxLearnResult.Count - 1])); approxTestResultMSE.Add(IFS.RMSEtoMSEforTest(approxTestResult[approxTestResult.Count - 1])); approxLearnResultMSEdiv2.Add(IFS.RMSEtoMSEdiv2forLearn(approxLearnResult[approxLearnResult.Count - 1])); approxTestResultMSEdiv2.Add(IFS.RMSEtoMSEdiv2forTest(approxTestResult[approxTestResult.Count - 1])); // Console.WriteLine($"Time\t{IFS.sw.ElapsedMilliseconds} {Environment.NewLine }Ticks\t{IFS.sw.ElapsedTicks}"); return("Точностью на обучающей выборке(RSME) " + approxLearnResult[approxLearnResult.Count - 1].ToString() + " , Точность на тестовой выборке(RMSE) " + approxTestResult[approxTestResult.Count - 1].ToString() + " " + Environment.NewLine + "Точностью на обучающей выборке(MSE) " + approxLearnResultMSE[approxLearnResultMSE.Count - 1].ToString() + " , Точность на тестовой выборке(MSE) " + approxTestResultMSE[approxTestResultMSE.Count - 1].ToString() + " " + Environment.NewLine + "Точностью на обучающей выборке(MSE/2) " + approxLearnResultMSEdiv2[approxLearnResultMSEdiv2.Count - 1].ToString() + " , Точность на тестовой выборке(MSE/2) " + approxTestResultMSEdiv2[approxTestResultMSEdiv2.Count - 1].ToString() + " " + Environment.NewLine); }
private string ErrorInfoSA(IFuzzySystem FS) { SAFuzzySystem IFS = FS as SAFuzzySystem; if (IFS.RulesDatabaseSet.Count < 1) { return("Точность нечеткой системы недоступна"); } approxLearnResult.Add(IFS.approxLearnSamples(IFS.RulesDatabaseSet[0])); approxTestResult.Add(IFS.approxTestSamples(IFS.RulesDatabaseSet[0])); approxLearnResultMSE.Add(IFS.RMSEtoMSEforLearn(approxLearnResult[approxLearnResult.Count - 1])); approxTestResultMSE.Add(IFS.RMSEtoMSEforTest(approxTestResult[approxTestResult.Count - 1])); approxLearnResultMSEdiv2.Add(IFS.RMSEtoMSEdiv2forLearn(approxLearnResult[approxLearnResult.Count - 1])); approxTestResultMSEdiv2.Add(IFS.RMSEtoMSEdiv2forTest(approxTestResult[approxTestResult.Count - 1])); return("Точностью на обучающей выборке(RSME) " + approxLearnResult [approxLearnResult.Count - 1].ToString() + " , Точность на тестовой выборке(RMSE) " + approxTestResult[approxTestResult.Count - 1].ToString() + " " + Environment.NewLine + "Точностью на обучающей выборке(MSE) " + approxLearnResultMSE[approxLearnResultMSE.Count - 1].ToString() + " , Точность на тестовой выборке(MSE) " + approxTestResultMSE[approxTestResultMSE.Count - 1].ToString() + " " + Environment.NewLine + "Точностью на обучающей выборке(MSE/2) " + approxLearnResultMSEdiv2[approxLearnResultMSEdiv2.Count - 1].ToString() + " , Точность на тестовой выборке(MSE/2) " + approxTestResultMSEdiv2[approxTestResultMSEdiv2.Count - 1].ToString() + " " + Environment.NewLine); }
private void make_Log(Log_line EventCall, IFuzzySystem FS = null, string name_Alg = "", DateTime TimerValue = new DateTime(), TimeSpan TimerSpan = new TimeSpan()) { switch (EventCall) { case Log_line.Start: { LOG += Environment.NewLine + "(" + TimerValue.ToString() + ")" + " Начало построения системы" + Environment.NewLine; break; } case Log_line.StartGenerate: { LOG += "(" + TimerValue.ToString() + ")" + " Начата генерация системы { " + FS.LearnSamplesSet.FileName + " ; " + FS.TestSamplesSet.FileName + " }" + Environment.NewLine; break; } case Log_line.StartOptimaze: { LOG += "(" + DateTime.Now.ToString() + ")" + " Начата оптимизация системы" + Environment.NewLine; break; } case Log_line.PreGenerate_log: { LOG += "(" + DateTime.Now.ToString() + ")" + " Генерация алгоритмом " + name_Alg.ToString() + Environment.NewLine; break; } case Log_line.PostGenerate_log: { LOG += "(" + DateTime.Now.ToString() + ")" + " Сгенерирована система сложностью " + FS.ValueComplexity(FS.AbstractRulesBase()[0]).ToString() + Environment.NewLine + " Количество правил " + FS.ValueRuleCount(FS.AbstractRulesBase()[0]).ToString() + Environment.NewLine + showErrorInfo(FS) + ""; LOG += "Использован " + name_Alg.ToString() + Environment.NewLine; break; } case Log_line.PreOptimaze_log: { LOG += "(" + DateTime.Now.ToString() + ")" + " Оптимизация алгоритмом " + name_Alg.ToString() + Environment.NewLine; break; } case Log_line.PostOptimaze_log: { LOG += "(" + DateTime.Now.ToString() + ")" + " оптимизированная система сложностью " + FS.ValueComplexity(FS.AbstractRulesBase()[0]).ToString() + Environment.NewLine + " Количество правил " + FS.ValueRuleCount(FS.AbstractRulesBase()[0]).ToString() + Environment.NewLine + showErrorInfo(FS) + ""; LOG += "Использован " + name_Alg.ToString() + Environment.NewLine; break; } case Log_line.EndCircle: { LOG += "(" + DateTime.Now.ToString() + ")" + " Время построения системы" + TimerSpan.TotalSeconds.ToString() + Environment.NewLine; break; } case Log_line.End: { LOG += "(" + DateTime.Now.ToString() + ")" + " Время построения всех систем" + TimerSpan.TotalSeconds.ToString() + Environment.NewLine; break; } default: { LOG += "Не верный вызов" + Environment.NewLine; break; } } }
public IFuzzySystem TuneUpFuzzySystem(IFuzzySystem Approximate, ILearnAlgorithmConf conf) { SAFuzzySystem toRunSystem = Approximate as SAFuzzySystem; return(TuneUpFuzzySystem(toRunSystem, conf)); }
private void writeSAtoUFS(IFuzzySystem FS, string fileName) { SAFSUFSWriter.saveToUFS(FS as SAFuzzySystem, fileName); }
public IFuzzySystem Generate(IFuzzySystem Classifier, IGeneratorConf config) { PCFuzzySystem toRunFuzzySystem = Classifier as PCFuzzySystem; return(Generate(toRunFuzzySystem, config)); }
public IFuzzySystem Generate(IFuzzySystem Approximate, IGeneratorConf config) { SAFuzzySystem toRunFuzzySystem = Approximate as SAFuzzySystem; return(Generate(toRunFuzzySystem, config)); }
private void writePCtoUFS(IFuzzySystem FS, string fileName) { PCFSUFSWriter.saveToUFS(FS as PCFuzzySystem, fileName); }