private void ChangeExplorerPositions(int i)
{
KnowlegeBasePCRules temp = new KnowlegeBasePCRules();
temp = ExplorerParticles[i];
for (int k = 0; k < temp.TermsSet.Count; k++)
{
for (int j = 0; j < temp.TermsSet[k].Parametrs.Length; j++)
{
temp.TermsSet[k].Parametrs[j] += VelocityVector.TermsSet[k].Parametrs[j];
}
}
if (result.ClassifyLearnSamples(ExplorerParticles[i]) < result.ClassifyLearnSamples(ParticlesBest[ExplorerParticles[i]]))
{
ParticlesBest.Remove(ExplorerParticles[i]);
ParticlesBest.Add(temp, ExplorerParticles[i]);
}
else
{
KnowlegeBasePCRules tmp = new KnowlegeBasePCRules();
tmp = ParticlesBest[ExplorerParticles[i]];
ParticlesBest.Remove(ExplorerParticles[i]);
ParticlesBest.Add(temp, tmp);
}
ExplorerParticles[i] = temp;
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
preIterate(Classify, conf);
//Оптимизируем параметры
iter = 1;
while (iter <= MaxIter)
{
if (iter % changeParts == 0)
{
swapParticles();
}
oneIterate();
}
//Выводим точность классификации для лучшей частицы из каждой популяции
for (int j = 0; j < Populations.Count; j++)
{
Populations[j] = ListPittsburgClassifierTool.SortRules(Populations[j], result);
Console.WriteLine("Популяция №" + j + ":");
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(Populations[j][0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(Populations[j][0]), 2));
}
//Находим самое лучшее решение из всех популяций
List <KnowlegeBasePCRules> BestPopulation = new List <KnowlegeBasePCRules>();
for (int i = 0; i < numberOfPopulations; i++)
{
BestPopulation.Add(Populations[i][0]);
}
BestPopulation = ListPittsburgClassifierTool.SortRules(BestPopulation, result);
result.RulesDatabaseSet[0] = BestPopulation[0];
//Возвращаем результат
return(result);
}
/// <summary>
/// Last step
/// </summary>
protected virtual void prepareFinalFuzzySystem()
{
double startPrecission = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
double afterPrecission = result.ClassifyLearnSamples(newSolution);
if (startPrecission < afterPrecission)
{
result.RulesDatabaseSet[0] = newSolution;
}
}
private void SortPopulation()
{
Dictionary <int[], double> PopulationWithAccuracy = new Dictionary <int[], double>();
double accuracy = 0;
for (int i = 0; i < Population.Count; i++)
{
for (int j = 0; j < Population[i].Length; j++)
{
if (Population[i][j] == 0)
{
result.AcceptedFeatures[j] = false;
}
else
{
result.AcceptedFeatures[j] = true;
}
}
accuracy = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
PopulationWithAccuracy.Add(Population[i], accuracy);
}
Population.Clear();
foreach (var pair in PopulationWithAccuracy.OrderByDescending(pair => pair.Value))
{
Population.Add(pair.Key);
}
PopulationWithAccuracy.Clear();
}
public double getGoodsImproove(PCFuzzySystem FS, double baseValue)
{
thePositionOfBee = checkAndCorrect(thePositionOfBee);
FS.AcceptedFeatures = thePositionOfBee;
accuracy = FS.ClassifyLearnSamples(FS.RulesDatabaseSet[0]);
goods = accuracy - baseValue;
return(goods);
}
public virtual void oneIterate(PCFuzzySystem result)
{
for (int j = 0; j < count_particle; j++)
{
w = 1 / (1 + Math.Exp(-(Errors[j] - OldErrors[j]) / 0.01));
for (int k = 0; k < X[j].TermsSet.Count; k++)
{
for (int q = 0; q < X[j].TermsSet[k].CountParams; q++)
{
double bp = Pi[j].TermsSet[k].Parametrs[q];
V[j].TermsSet[k].Parametrs[q] = V[j].TermsSet[k].Parametrs[q] * w + c1 * rnd.NextDouble() * (bp - X[j].TermsSet[k].Parametrs[q]) +
c2 * rnd.NextDouble() * (Pg.TermsSet[k].Parametrs[q] - X[j].TermsSet[k].Parametrs[q]);
X[j].TermsSet[k].Parametrs[q] += V[j].TermsSet[k].Parametrs[q];
}
}
double[] bf = new double[V[j].Weigths.Length];
double[] bfw = new double[V[j].Weigths.Length];
for (int k = 0; k < V[j].Weigths.Length; k++)
{
bfw[k] = V[j].Weigths[k] * w + c1 * rnd.NextDouble() * (Pi[j].Weigths[k] - X[j].Weigths[k]) +
c2 * rnd.NextDouble() * (Pg.Weigths[k] - X[j].Weigths[k]);
double sw = X[j].Weigths[k] + bfw[k];
if (sw > 0 && sw <= 2)
{
bf[k] = sw;
}
else
{
bf[k] = X[j].Weigths[k];
bfw[k] = V[j].Weigths[k];
}
}
X[j].Weigths = bf;
V[j].Weigths = bfw;
double newError = 0;
bool success = true;
try
{
newError = result.ClassifyLearnSamples(X[j]);
}
catch (Exception)
{
success = false;
}
if (success && (newError > Errors[j]))
{
OldErrors[j] = Errors[j];
Errors[j] = newError;
Pi[j] = new KnowlegeBasePCRules(X[j]);
}
if (minError < newError)
{
minError = newError;
Pg = new KnowlegeBasePCRules(X[j]);
}
}
}
private void Chiu(PCFuzzySystem result)
{
double best_res = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
double res = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
for (int j = 0; j < result.AcceptedFeatures.Length; j++)
{
int n = 0;
for (int i = 0; i < result.AcceptedFeatures.Length; i++)
{
if (result.AcceptedFeatures[i] == true)
{
result.AcceptedFeatures[i] = false;
if (result.ClassifyLearnSamples(result.RulesDatabaseSet[0]) >= res)
{
res = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
n = i;
}
else
{
result.AcceptedFeatures[i] = true;
}
}
}
if (res >= best_res)
{
best_res = res;
}
else
{
break;
}
}
//for (int i = 0; i < result.AcceptedFeatures.Length; i++)
//{
// if (result.AcceptedFeatures[i] == true)
// Console.Write(Convert.ToString(i) + ' ');
//}
//Console.WriteLine();
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classif, ILearnAlgorithmConf conf)
{
result = Classif;
numberOfFeatures = result.CountFeatures;
Init(conf);
HeadLeader = new int[numberOfFeatures];
BestParticles = new List <int[]>();
for (int i = 0; i < numberOfFeatures; i++)
{
BestParticles.Add(new int[2]);
BestParticles[i][0] = 0;
BestParticles[i][1] = 0;
}
SetPopulation();
iter = 0;
while (iter < MaxIter)
{
SortPopulation();
for (int i = 0; i < Population[0].Length; i++)
{
BestParticles[i][Population[0][i]] += 1;
}
HeadLeader = Population[0];
ChangeParticles();
iter++;
}
SortPopulation();
for (int j = 0; j < Population[0].Length; j++)
{
Console.Write(Convert.ToString(Population[0][j]) + ' ');
if (Population[0][j] == 0)
{
result.AcceptedFeatures[j] = false;
}
else
{
result.AcceptedFeatures[j] = true;
}
}
Console.WriteLine();
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2));
return(result);
}
/// <summary>
/// Step 1
/// </summary>
/// <param name="Classifier"></param>
/// <param name="config"></param>
protected virtual void init(PCFuzzySystem Classifier, ACOSearchConf config)
{
ACO_iterationCount = config.ACOCountIteration;
ACO_antCount = config.ACOCountAnt;
ACO_decisionArchiveCount = 2;
ACO_q = config.ACOQ;
ACO_xi = config.ACOXi;
result = Classifier;
colonyCount = result.CountFeatures;
colonyList = new List <Colony>();
basePrecission = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
}
public void rouletteSelection()
{
double[] currentError = new double[childrenMassive.Count()];
double efficient = 0;
for (int i = 0; i < childrenMassive.Count(); i++)
//Parallel.For(0, childrenMassive.Count(), i =>
{
fullFuzzySystem.RulesDatabaseSet.Add(childrenMassive[i]);
fullFuzzySystem.UnlaidProtectionFix(childrenMassive[i]);
currentError[i] = fullFuzzySystem.ClassifyLearnSamples(fullFuzzySystem.RulesDatabaseSet[i + 1]);
efficient += currentError[i];
//});
}
for (int i = 0; i < currentError.Count(); i++)
//Parallel.For(0, currentError.Count(), i =>
{
currentError[i] = ((currentError[i] / efficient));
//});
}
Array.Sort(currentError, childrenMassive);
for (int i = 0; i < populationMassive.Count(); i++)
//Parallel.For(0, current.Count(), i =>
{
double a = allRandom.NextDouble();
double summ = 0;
for (int j = 0; j < currentError.Count(); j++)
{
if ((a >= summ) && (a <= (summ + currentError[j])))
{
populationMassive[i] = childrenMassive[j];
break;
}
summ += currentError[j];
}
}
//});
fullFuzzySystem.RulesDatabaseSet.RemoveRange(1, childrenMassive.Count());
}
public override string ToString(bool with_param = false)
{
if (with_param)
{
string result = "Алгоритм пчелинной колонии дискретный {";
result += "Количество разведчиков= " + countScouts.ToString() + " ;" + Environment.NewLine;
result += "Количество рабочих пчел= " + countWorkers.ToString() + " ;" + Environment.NewLine;
for (int z = solutionInfo.Count - countBestBase; z < solutionInfo.Count; z++)
{
int saved = solutionInfo[z].PositionOfBee.Where(x => x == true).Count();
int lost = solutionInfo[z].PositionOfBee.Length - saved;
theFuzzySystem.AcceptedFeatures = solutionInfo[z].PositionOfBee;
double accuracyLearn = theFuzzySystem.ClassifyLearnSamples(theFuzzySystem.RulesDatabaseSet[0]);
double accuracyTest = theFuzzySystem.ClassifyTestSamples(theFuzzySystem.RulesDatabaseSet[0]);
result += $"Оставшиеся признаки {saved}:{accuracyLearn}||{accuracyTest} [ ";
for (int i = 0; i < solutionInfo[z].PositionOfBee.Length; i++)
{
if (solutionInfo[z].PositionOfBee[i] == true)
{
result += (i + 1).ToString() + ", ";
}
}
result += "]" + Environment.NewLine;
result += $"Усеченные признаки {saved}:{accuracyLearn}||{accuracyTest} [ ";
for (int i = 0; i < solutionInfo[z].PositionOfBee.Length; i++)
{
if (solutionInfo[z].PositionOfBee[i] == false)
{
result += (i + 1).ToString() + ", ";
}
}
result += "]" + Environment.NewLine;
}
result += "}";
return(result);
}
return("Алгоритм пчелинной колонии дискретный");
}
public void updateFS(PCFuzzySystem FS)
{
backup = FS.AcceptedFeatures[Position];
FS.AcceptedFeatures[Position] = Value;
try
{
Precision = FS.ClassifyLearnSamples(FS.RulesDatabaseSet[0]);
}
catch (Exception)
{
FS.AcceptedFeatures[Position] = backup;
}
}
/// <summary>
/// Step 1
/// </summary>
/// <param name="Classifier"></param>
/// <param name="config"></param>
protected virtual void init(PCFuzzySystem Classifier, ACOSearchConf config)
{
ACO_iterationCount = config.ACOCountIteration;
ACO_antCount = config.ACOCountAnt;
ACO_decisionArchiveCount = config.ACODescisionArchiveSize;
ACO_q = config.ACOQ;
ACO_xi = config.ACOXi;
result = Classifier;
colonyCount = result.RulesDatabaseSet[0].TermsSet.Count;
colonyList = new List <Colony>();
newSolution = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
basePrecission = result.ClassifyLearnSamples(newSolution);
}
public virtual void CalcPecission(PCFuzzySystem FS)
{
backup = FS.AcceptedFeatures[Position];
FS.AcceptedFeatures[Position] = Value;
try
{
Precision = FS.ClassifyLearnSamples(FS.RulesDatabaseSet[0]);
}
catch (Exception)
{
Precision = double.PositiveInfinity;
}
FS.AcceptedFeatures[Position] = backup;
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
count_iteration = ((WeigthsRandomSearchConfig)conf).WRSCCountIteration;
count_generation_by_iteration =
((WeigthsRandomSearchConfig)conf).WRSCCountRules;
PCFuzzySystem result = Classifier;
for (int i = 0; i < count_iteration; i++)
{
double [][] Weigths = new double[count_generation_by_iteration + 1][];
Weigths[0] = Classifier.RulesDatabaseSet[0].Weigths;
double best_result = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
int best_index = 0;
for (int j = 1; j < count_generation_by_iteration + 1; j++)
{
Weigths[j] = new double[Weigths[0].Count()];
for (int k = 0; k < Weigths[0].Count(); k++)
{
Weigths[j][k] = rand.NextDouble();
}
result.RulesDatabaseSet[0].Weigths = Weigths[j];
double current_result = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
if (current_result > best_result)
{
best_result = current_result;
best_index = j;
}
result.RulesDatabaseSet[0].Weigths = Weigths[best_index];
}
}
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
result = Classifier;
numberOfFeatures = result.CountFeatures;
groups = new List <int[][]>();
Init(conf);
SetPopulation();
NS = new int[m];
for (int i = 0; i < m; i++)
{
NS[i] = (N - 1) / m;
}
cur_iter = 0;
double featurecount = 0;
while (cur_iter < iter)
{
//Console.WriteLine("\nИТЕРАЦИЯ " + cur_iter);
SortPopulation();
groups = GroupStream();
if (p_one > rand.NextDouble())
{
ChooseOneCluster();
}
else
{
ChooseTwoClusters();
}
SortPopulation();
cur_iter++;
}
for (int j = 0; j < Population[0].Length; j++)
{
if (Population[0][j] == true)
{
featurecount += 1;
}
}
result.AcceptedFeatures = Population[0];
Console.WriteLine();
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Признаки:" + featurecount);
featurecount = 0;
return(result);
}
public double DB(double[] shrapnel, int count_terms, int type, PCFuzzySystem Classifier)
{
int k = 1;
for (int l = 0; l < count_terms; l++)
{
for (int p = 0; p < type; p++)
{
Classifier.RulesDatabaseSet[0].TermsSet[l].Parametrs[p] = shrapnel[k];
k++;
}
}
double MSE = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
return(MSE);
}
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);
}
private void SortPopulation()
{
Dictionary <bool[], double> PopulationWithAccuracy = new Dictionary <bool[], double>();
double accuracy = 0;
for (int i = 0; i < Population.Count; i++)
{
result.AcceptedFeatures = Population[i];
accuracy = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
PopulationWithAccuracy.Add(Population[i], accuracy);
}
Population.Clear();
foreach (var pair in PopulationWithAccuracy.OrderByDescending(pair => pair.Value))
{
Population.Add(pair.Key);
}
PopulationWithAccuracy.Clear();
}
protected void preIterate(PCFuzzySystem Classifier)
{
for (int i = 0; i < count_particle; i++)
{
KnowlegeBasePCRules temp_c_Rule = new KnowlegeBasePCRules(Classifier.RulesDatabaseSet[0]);
X[i] = temp_c_Rule;
Errors[i] = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
OldErrors[i] = Errors[i];
Pi[i] = new KnowlegeBasePCRules(X[i]);
V[i] = new KnowlegeBasePCRules(X[i]);
//
for (int j = 0; j < V[i].TermsSet.Count; j++)
{
for (int k = 0; k < Term.CountParamsinSelectedTermType(V[i].TermsSet[j].TermFuncType); k++)
{
if (i == 0)
{
V[i].TermsSet[j].Parametrs[k] = 0;
}
else
{
V[i].TermsSet[j].Parametrs[k] = rnd.NextDouble() - 0.5;
}
}
}
double[] bf = new double[V[i].Weigths.Length];
for (int k = 0; k < V[i].Weigths.Length; k++)
{
if (i == 0)
{
bf[k] = 1;
}
else
{
//System.Windows.Forms.MessageBox.Show(rnd.NextDouble().ToString());
bf[k] = rnd.NextDouble() / 200;
}
}
V[i].Weigths = bf;
}
Pg = new KnowlegeBasePCRules(Classifier.RulesDatabaseSet[0]);
minError = Errors[0];
}
private void addClassifierValue(PCFuzzySystem Classifier)
{
double Value = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
ValueLGoodsPercent.Add(Value);
ValueLGoodsError.Add(100 - Value);
Value = Classifier.ClassifyTestSamples(Classifier.RulesDatabaseSet[0]);
ValueTGoodsPercent.Add(Value);
ValueTGoodsError.Add(100 - Value);
Value = Classifier.getComplexit();
ValueComplexityFull.Add(Value);
Value = Classifier.getRulesCount();
ValueComplexityRules.Add(Value);
Value = Classifier.getNormalIndex();
ValueInterpretyNominal.Add(Value);
Value = Classifier.getIndexReal();
ValueInterpretyReal.Add(Value);
}
public override void oneIterate(PCFuzzySystem result)
{
base.oneIterate(result);
counterIter++;
if (counterIter == interPSOtoSend)
{
Pi = sortSolution(Pi);
savetoUFS(Pi.ToList(), 0, sendPSO, trySend);
BacteryRunner();
trySend++;
List <KnowlegeBasePCRules> tempRes = loadDatabase().ToList();
int size = tempRes.Count;
for (int p = tempRes.Count - 1; p >= 0; p--)
{
X[p] = tempRes[0];
double newError = result.ClassifyLearnSamples(X[p]);
if (newError > Errors[p])
{
Pi[p] = new KnowlegeBasePCRules(X[p]);
OldErrors[p] = Errors[p];
Errors[p] = newError;
if (minError < newError)
{
minError = newError;
Pg = new KnowlegeBasePCRules(X[p]);
}
}
tempRes.RemoveAt(0);
}
counterIter = 0;
}
}
private void SortPopulation()
{
Dictionary <int, Tuple <bool[], double> > PopulationWithAccuracy = new Dictionary <int, Tuple <bool[], double> >();
double accuracy = 0;
for (int i = 0; i < Population.Count; i++)
{
result.AcceptedFeatures = Population[i];
accuracy = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
Tuple <bool[], double> tuple = new Tuple <bool[], double>(Population[i], accuracy);
try
{
PopulationWithAccuracy.Add(i, tuple);
}
catch (ArgumentException)
{
//Console.WriteLine(i);
}
}
double[] accuracylist = new double[Population.Count];
Population.Clear();
foreach (var pair in PopulationWithAccuracy.OrderByDescending(pair => pair.Value.Item2))
{
accuracylist[pair.Key] = pair.Value.Item2;
Population.Add(pair.Value.Item1);
}
PopulationWithAccuracy.Clear();
}
public override FuzzySystem.PittsburghClassifier.PCFuzzySystem TuneUpFuzzySystem(FuzzySystem.PittsburghClassifier.PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
PCFuzzySystem result = Classifier;
count_iteration = ((CuckooConf)conf).CuckooCountIterate;
count_particle = ((CuckooConf)conf).CuckooPopulationSize;
m = ((CuckooConf)conf).CuckooWorse;
p = ((CuckooConf)conf).CuckooLifeChance;
beta = ((CuckooConf)conf).CuckooBeta;
KnowlegeBasePCRules[] X = new KnowlegeBasePCRules[count_particle + 1];
double[] Errors = new double[count_particle + 1];
double[] Er = new double[count_particle + 1];
Random rnd = new Random();
int best = 0;
for (int i = 0; i < count_particle + 1; i++)
{
KnowlegeBasePCRules temp_c_Rule = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
X[i] = temp_c_Rule;
Errors[i] = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
}
///////////
for (int i = 0; i < count_iteration; i++)
{
X[0] = new KnowlegeBasePCRules(X[0]);
for (int k = 0; k < X[0].TermsSet.Count; k++)
{
for (int q = 0; q < X[0].TermsSet[k].CountParams; q++)
{
double b = (rnd.Next(1000, 2000) / Convert.ToDouble(1000));
X[0].TermsSet[k].Parametrs[q] = X[0].TermsSet[k].Parametrs[q] + Levi(BM(sigu(beta)), BM(1.0), beta);
}
}
for (int k = 0; k < X[0].Weigths.Length; k++)
{
X[0].Weigths[k] = rnd.NextDouble() / 200;
}
result.RulesDatabaseSet.Add(X[0]);
int temp_index = result.RulesDatabaseSet.Count - 1;
Errors[0] = result.ClassifyLearnSamples(result.RulesDatabaseSet[temp_index]);
result.RulesDatabaseSet.RemoveAt(temp_index);
int s = rnd.Next(1, count_particle + 1);
if (Errors[0] > Errors[s])
{
X[s] = X[0];
Errors[s] = Errors[0];
}
else
{
X[0] = X[s];
Errors[0] = Errors[s];
}
for (int v = 0; v < m; v++)
{
double max = Errors[1];
int ind = 1;
for (int r = 2; r < count_particle + 1; r++)
{
if (Errors[r] < max)
{
max = Errors[r];
ind = r;
}
else
{
};
}
double h = (rnd.Next(1, 1000) / Convert.ToDouble(1000));
if (h > p)
{
X[ind] = new KnowlegeBasePCRules(X[ind]);
for (int j = 0; j < X[ind].TermsSet.Count; j++)
{
for (int k = 0; k < X[ind].TermsSet[j].CountParams; k++)
{
X[ind].TermsSet[j].Parametrs[k] = X[0].TermsSet[j].Parametrs[k] + (rnd.Next(-1000, 1000) / Convert.ToDouble(1000));
}
for (int k = 0; k < X[ind].Weigths.Length; k++)
{
X[ind].Weigths[k] = X[0].Weigths[k] + (rnd.Next(1, 1000) / Convert.ToDouble(10000));
}
}
result.RulesDatabaseSet.Add(X[ind]);
temp_index = result.RulesDatabaseSet.Count - 1;
Errors[ind] = result.ClassifyLearnSamples(result.RulesDatabaseSet[temp_index]);
result.RulesDatabaseSet.RemoveAt(temp_index);
}
}
}
double min = Errors[0];
best = 0;
for (int g = 1; g < count_particle + 1; g++)
{
if (Errors[g] > min)
{
min = Errors[g];
best = g;
}
}
X[0] = X[best];
result.RulesDatabaseSet.Add(X[0]);
int t_index = result.RulesDatabaseSet.Count - 1;
Errors[0] = result.ClassifyLearnSamples(result.RulesDatabaseSet[t_index]);
result.RulesDatabaseSet.RemoveAt(t_index);
result.RulesDatabaseSet[0] = X[0];
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
result = Classify;
//Узнаем название папки с данными
string path_name = "../../OLD/Data/Keel/Classifier/KEEL-10/";
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
//Инициализируем параметры
Init(conf);
//Создаем новые обучающую и тестовую выбоки и удаляем из них некоторое количество случайных элементов
List <PCFuzzySystem> results = new List <PCFuzzySystem>();
for (int i = 0; i < numberOfPopulations; i++)
{
SampleSet new_learn = new SampleSet(path_name + folder_name + "/" + result.LearnSamplesSet.FileName);
SampleSet new_test = new SampleSet(path_name + folder_name + "/" + result.TestSamplesSet.FileName);
results.Add(new PCFuzzySystem(new_learn, new_test));
int ground = (int)Math.Round(results[i].LearnSamplesSet.DataRows.Count * 0.25);
for (int j = 0; j < ground; j++)
{
results[i].LearnSamplesSet.DataRows.RemoveAt(rand.Next(0, results[i].LearnSamplesSet.DataRows.Count));
}
}
//Инициализируем и зануляем вектора алгоритма
HeadLeader = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
VelocityVector = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
VelocityVectorLL = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
VelocityVectorHL = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
for (int i = 0; i < VelocityVector.TermsSet.Count; i++)
{
for (int j = 0; j < VelocityVector.TermsSet[i].Parametrs.Length; j++)
{
VelocityVector.TermsSet[i].Parametrs[j] = 0;
VelocityVectorLL.TermsSet[i].Parametrs[j] = 0;
VelocityVectorHL.TermsSet[i].Parametrs[j] = 0;
}
}
//Создаем популяции и архив лучших положений каждой частицы
Populations = new List <List <KnowlegeBasePCRules> >();
for (int i = 0; i < numberOfPopulations; i++)
{
Populations.Add(SetPopulation(new List <KnowlegeBasePCRules>()));
}
ParticlesBest = new Dictionary <KnowlegeBasePCRules, KnowlegeBasePCRules>();
foreach (var Population in Populations)
{
foreach (var Particle in Population)
{
ParticlesBest.Add(Particle, Universal);
}
}
//Инициализируем роли частиц
LocalLeaders = new KnowlegeBasePCRules[numberOfLocalLeaders];
ExplorerParticles = new KnowlegeBasePCRules[numberOfAllParts - numberOfAimlessParts - numberOfLocalLeaders - 1];
AimlessParticles = new KnowlegeBasePCRules[numberOfAimlessParts];
//Оптимизируем параметры
iter = 1;
while (iter < MaxIter)
{
for (int p_i = 0; p_i < Populations.Count; p_i++)
{
Populations[p_i] = ListPittsburgClassifierTool.SortRules(Populations[p_i], results[p_i]);
SetRoles(Populations[p_i]);
ChangeExplorersPositions();
ChangeAimlessPositions();
Populations[p_i] = DiscardRoles(Populations[p_i]);
}
iter++;
}
//Выводим точность классификации для лучшей частицы из каждой популяции
for (int j = 0; j < Populations.Count; j++)
{
Populations[j] = ListPittsburgClassifierTool.SortRules(Populations[j], results[j]);
Console.WriteLine("Популяция №" + j + ":");
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(Populations[j][0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(Populations[j][0]), 2));
}
//Допобавляем в базу правил лучшие решения
if (result.RulesDatabaseSet.Count == 1)
{
result.RulesDatabaseSet.Clear();
}
for (int i = 0; i < Populations.Count; i++)
{
result.RulesDatabaseSet.Add(Populations[i][0]);
}
//Возвращаем результат
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
result = Classify;
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
numberOfFeatures = result.CountFeatures;
Init(conf);
HeadLeader = new bool[numberOfFeatures];
VelocityVector = new bool[numberOfFeatures];
VelocityVectorLL = new bool[numberOfFeatures];
VelocityVectorHL = new bool[numberOfFeatures];
SetPopulation();
LocalLeaders = new List <bool[]>();
ExplorerParticles = new List <bool[]>();
AimlessParticles = new List <bool[]>();
iter = 0;
while (iter < MaxIter)
{
SortPopulation();
SetRoles();
ChangeExplorersPositions();
ChangeAimlessPositions();
DiscardRoles();
iter++;
}
SortPopulation();
result.AcceptedFeatures = Population[0];
for (int j = 0; j < Population[0].Length; j++)
{
if (Population[0][j])
{
Console.Write("1 ");
}
else
{
Console.Write("0 ");
}
}
Console.WriteLine();
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2));
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
iskl_prizn = "";
count_iteration = ((Param)conf).Количество_итераций;
count_populate = ((Param)conf).Число_осколков;
exploration = ((Param)conf).Фактор_исследования;
reduce_koef = ((Param)conf).Уменьшающий_коэффициент;
priznaki_usech = ((Param)conf).Усечённые_признаки;
iter_descrete = ((Param)conf).Итерации_дискр_алг;
int iter = 0, iter2, i, j, count_terms, count_iter = 0;
int count_cons, count_best2 = 0, best_pred = 0;
double RMSE_best, cosFi, RMSE_best2;
int Nd, variables, k = 1, best2 = 0;
PCFuzzySystem result = Classifier;
int type = Classifier.RulesDatabaseSet[0].TermsSet[0].CountParams;
Nd = Classifier.RulesDatabaseSet[0].TermsSet.Count * type;
double[] X_best = new double[Nd + 1];
double[,] X_pred = new double[2, Nd + 1];
double[,] direction = new double[count_populate, Nd + 1];
double[,] d = new double[count_populate, Nd + 1];
double[,] explosion = new double[count_populate, Nd + 1];
double[,] shrapnel = new double[count_populate, Nd + 1];
cosFi = Math.Cos(2 * Math.PI / count_populate);
RMSE_best = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
RMSE_best2 = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
count_cons = Classifier.RulesDatabaseSet[0].Weigths.Count();
double[] RMSE = new double[count_populate];
double[] RMSE_all = new double[iter];
double[] RMSE_tst = new double[count_populate];
double[] RMSE2 = new double[count_populate];
double[] RMSE_pred = new double[2];
double[] cons_best = new double[count_cons];
variables = Classifier.LearnSamplesSet.CountVars;
count_terms = Classifier.RulesDatabaseSet[0].TermsSet.Count;
int[] terms = new int[variables];
double[] X_best2 = new double[variables];
double[,] d3 = new double[count_populate, variables];
double[,] priznak = new double[count_populate, variables];
for (i = 0; i < variables; i++)
{
priznak[0, i] = 1;
X_best2[i] = 1;
}
KnowlegeBasePCRules[] X = new KnowlegeBasePCRules[count_populate];
for (int s = 0; s < count_populate - 1; s++)
{
X[s] = new KnowlegeBasePCRules(Classifier.RulesDatabaseSet[0]);
Classifier.RulesDatabaseSet.Add(X[s]);
}
for (iter2 = 0; iter2 < iter_descrete; iter2++)
{
best2 = 0;
//if (count_best2 < 10)
//{
if (iter == 0)
{
for (k = 0; k < variables; k++)
{
d3[0, k] = RandomNext(Classifier.LearnSamplesSet.InputAttributes[k].Min, Classifier.LearnSamplesSet.InputAttributes[k].Max);
}
}
for (i = 0; i < variables; i++)
{
for (j = 1; j < count_populate; j++)
{
generate:
d3[j, i] = d3[j - 1, i] * randn();
priznak[j, i] = d3[j, i] * cosFi;
if ((priznak[j, i] < Classifier.LearnSamplesSet.InputAttributes[i].Min) || (priznak[j, i] > Classifier.LearnSamplesSet.InputAttributes[i].Max))
{
goto generate;
}
Random random = new Random();
if (random.NextDouble() < descret(priznak[j, i]))
{
priznak[j, i] = 1;
}
else
{
priznak[j, i] = 0;
}
}
}
for (j = 1; j < count_populate; j++)
{
for (int h = 0; h < variables; h++)
{
if (priznak[j, h] == 1)
{
Classifier.AcceptedFeatures[h] = true;
}
else
{
Classifier.AcceptedFeatures[h] = false;
}
}
RMSE2[j] = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet [0]);
if (RMSE2[j] > RMSE_best2)
{
RMSE_best2 = RMSE2[j];
best2 = j;
}
for (int h = 0; h < variables; h++)
{
X_best2[h] = priznak[best2, h];
}
}
if (best_pred == best2)
{
count_best2++;
}
else
{
count_best2 = 0;
}
for (k = 0; k < variables; k++)
{
priznak[0, k] = priznak[best2, k];
}
count_iter++;
//}
}
for (k = 0; k < variables; k++)
{
if (priznak[best2, k] == 1)
{
Classifier.AcceptedFeatures[k] = true;
}
else
{
Classifier.AcceptedFeatures[k] = false;
iskl_prizn += (k + 1).ToString() + " ";
}
}
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
result = Classifier;
//Узнаем название папки с данными
string path_name = "../../OLD/Data/Keel/Classifier/KEEL-10/";
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
groups = new List <int[]>();
Init(conf);
//Создаем новые обучающую и тестовую выбоки и удаляем из них некоторое количество случайных элементов
List <PCFuzzySystem> results = new List <PCFuzzySystem>();
for (int i = 0; i < numberOfPopulations; i++)
{
SampleSet new_learn = new SampleSet(path_name + folder_name + "/" + result.LearnSamplesSet.FileName);
SampleSet new_test = new SampleSet(path_name + folder_name + "/" + result.TestSamplesSet.FileName);
results.Add(new PCFuzzySystem(new_learn, new_test));
int ground = (int)Math.Round(results[i].LearnSamplesSet.DataRows.Count * 0.25);
for (int j = 0; j < ground; j++)
{
results[i].LearnSamplesSet.DataRows.RemoveAt(rand.Next(0, results[i].LearnSamplesSet.DataRows.Count));
}
}
Populations = new List <List <KnowlegeBasePCRules> >();
for (int i = 0; i < numberOfPopulations; i++)
{
Populations.Add(SetPopulation(new List <KnowlegeBasePCRules>()));
Populations[i] = ListPittsburgClassifierTool.SortRules(Populations[i], result);
}
NS = new int[m];
for (int i = 0; i < m; i++)
{
NS[i] = (N - 1) / m;
}
cur_iter = 0;
while (cur_iter < iter)
{
for (int p_i = 0; p_i < Populations.Count; p_i++)
{
groups = GroupStream(Populations[p_i]);
if (p_one > rand.NextDouble())
{
ChooseOneCluster(Populations[p_i]);
}
else
{
ChooseTwoClusters(Populations[p_i]);
}
Populations[p_i] = ListPittsburgClassifierTool.SortRules(Populations[p_i], results[p_i]);
//Console.WriteLine(cur_iter + " - Итерация");
//Console.WriteLine("Обуч. выборка = " + result.ErrorLearnSamples(Populations[p_i][0]));
//Console.WriteLine("Тест. выборка = " + result.ErrorTestSamples(Populations[p_i][0]));
}
cur_iter++;
}
//Выводим точность классификации для лучшей частицы из каждой популяции
for (int j = 0; j < Populations.Count; j++)
{
Populations[j] = ListPittsburgClassifierTool.SortRules(Populations[j], results[j]);
Console.WriteLine("Популяция №" + j + ":");
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(Populations[j][0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(Populations[j][0]), 2));
}
//Допобавляем в базу правил лучшие решения
if (result.RulesDatabaseSet.Count == 1)
{
result.RulesDatabaseSet.Clear();
}
for (int i = 0; i < Populations.Count; i++)
{
result.RulesDatabaseSet.Add(Populations[i][0]);
}
//Возвращаем результат
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
result = Classify;
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
numberOfFeatures = result.CountFeatures;
Init(conf);
rand = new Random();
HeadLeader = new bool[numberOfFeatures];
SetPopulation();
Population[0].CopyTo(HeadLeader, 0);
result.AcceptedFeatures = HeadLeader;
double HLAcc = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
iter = 0;
while (iter < MaxIter)
{
ChangePositions();
SortPopulation();
result.AcceptedFeatures = Population[0];
if (result.ClassifyLearnSamples(result.RulesDatabaseSet[0]) > HLAcc)
{
HLAcc = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
Population[0].CopyTo(HeadLeader, 0);
}
iter++;
}
int count_ones = 0;
result.AcceptedFeatures = HeadLeader;
for (int j = 0; j < HeadLeader.Length; j++)
{
if (HeadLeader[j])
{
Console.Write("1 ");
count_ones++;
}
else
{
Console.Write("0 ");
}
}
Console.WriteLine();
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2));
File.AppendAllText("E:/TUSUR/GPO/Эксперименты/Behavior/RS" + folder_name + ".txt", "Признаки: " + count_ones + Environment.NewLine);
File.AppendAllText("E:/TUSUR/GPO/Эксперименты/Behavior/RS" + folder_name + ".txt", "Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2) + Environment.NewLine);
File.AppendAllText("E:/TUSUR/GPO/Эксперименты/Behavior/RS" + folder_name + ".txt", "Время: " + Environment.NewLine);
return(result);
}
private void make_Log(Log_line EventCall, PCFuzzySystem FS = null, string name_Alg = "", DateTime TimerValue = new DateTime(), TimeSpan TimerSpan = new TimeSpan())
{
switch (EventCall)
{
case Log_line.Start:
{
LOG += "(" + TimerValue.ToString() + ")" + " Начало построения системы" + Environment.NewLine;
break;
}
case Log_line.StartGenerate:
{
LOG += "(" + TimerValue.ToString() + ")" + " Начата генерация системы" + 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:
{
double LearnResult = FS.ClassifyLearnSamples();
double TestResult = FS.ClassifyTestSamples();
LOG += "(" + DateTime.Now.ToString() + ")" + " Сгенерирована система сложностью " + FS.ValueComplexity().ToString() + Environment.NewLine +
"Точностью на обучающей выборке " + LearnResult.ToString() + ", Точность на тестовой выборке " + TestResult.ToString() + Environment.NewLine;
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:
{
double LearnResult = FS.ClassifyLearnSamples();
double TestResult = FS.ClassifyTestSamples();
LOG += "(" + DateTime.Now.ToString() + ")" + " оптимизированная система сложностью " + FS.ValueComplexity().ToString() + Environment.NewLine +
"Точностью на обучающей выборке " + LearnResult.ToString() + ", Точность на тестовой выборке " + TestResult.ToString() + Environment.NewLine;
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; }
}
}
