// ListにClassifier追加
public override void Add( Classifier C )
{
// 最大サイズになったとき
if( this.Number == this.CList.Count )
{
return; // 削除実装予定
}
this.CList.Add( C );
}
// ListにClassifier追加
public override void Add( Classifier C )
{
// 最大サイズになったとき
if( this.Number == this.CList.Count )
{
//Console.WriteLine("hogehoge");
//System.Threading.Thread.Sleep( 1000 );
return; // 削除実装予定
}
this.CList.Add( C );
}
// 包摂条件判定用
public override bool IsMoreGeneral(Classifier Spec)
{
if (this.C.NumberOfSharp <= Spec.C.NumberOfSharp)
{
return(false);
}
int i = 0;
do
{
if (this.C.state[i] != '#' && this.C.state[i] != Spec.C.state[i])
{
return(false);
}
i++;
} while(i < this.C.state.Length);
return(true);
}
// 包摂条件判定
public override bool DoesSubsume(Classifier C)
{
/*if( this.A == C.A )
* {*/
if (this.CouldSubsume())
{
if (this.IsMoreGeneral(C))
{
if (this.Epsilon_0 <= C.Epsilon_0) //chou 10-5 GA subsumption
{
if (C.C.state[4] == '0' & C.C.state[7] == '1') //"bath0 rehabi1"
{
Configuration.Problem.WriteLine(C.C.state + "," + Configuration.T + "," + C.P + "," + C.M + "," + C.Epsilon + "," + C.F + "," + C.N + "," + C.Exp + "," + C.Ts + "," + C.As + "," + C.Kappa + "," + C.Epsilon_0 + "," + C.St + "," + C.GenerateTime + ", in GA");
Configuration.Problem.WriteLine(this.C.state + "," + Configuration.T + "," + this.P + "," + this.M + "," + this.Epsilon + "," + this.F + "," + this.N + "," + this.Exp + "," + this.Ts + "," + this.As + "," + this.Kappa + "," + this.Epsilon_0 + "," + this.St + "," + this.GenerateTime + ", in GA");
}
return(true);
}
}
}
//}
return(false);
}
//二点交差
public override void Crossover(Classifier C)
{
double x = Configuration.MT.NextDouble() * (this.C.Length + 1);
double y = Configuration.MT.NextDouble() * (this.C.Length + 1);
if (x > y)
{
double tmp = x;
x = y;
y = tmp;
}
int i = 0;
do
{
if (x <= i && i < y)
{
this.C.Switch(C.C, i);
}
i++;
} while(i < y);
}
protected override double DeletionVote(Classifier C, double AvFitness)
{
// SigmaNormalClassifier前提
SigmaNormalClassifier SNC = ( SigmaNormalClassifier )C;
double Vote = SNC.As * SNC.N;
//Console.WriteLine("AS: " + SNC.As + " N: " + SNC.N);
if ((SNC.Exp > Configuration.Theta_del) && (SNC.WinningRate.Average() / SNC.N < Configuration.Delta * AvFitness))
{
if (SNC.WinningRate.Average() == 0)
{
//Console.WriteLine("0 : " + Vote);
return(Vote);
}
Vote *= AvFitness / (SNC.WinningRate.Average() / SNC.N);
//Console.WriteLine("hoge");
}
//Console.WriteLine(SNC.WinningRate.Average() + " : " + Vote);
return(Vote);
}
protected override void Subsumption(Population Pop)
{
Classifier Cl = null;
foreach (Classifier C in this.CList)
{
if (C.CouldSubsume())
{
if ((Cl == null) || (C.C.NumberOfSharp > Cl.C.NumberOfSharp) || ((C.C.NumberOfSharp == Cl.C.NumberOfSharp) && (Configuration.MT.NextDouble() < 0.5)))
{
Cl = C;
}
}
}
if (Cl != null)
{
// 削除中にforeachできない
List <Classifier> CL = new List <Classifier>();
foreach (Classifier C in this.CList)
{
if (Cl.IsMoreGeneral(C))
{
Cl.N += C.N;
// 削除Classifier登録
CL.Add(C);
}
}
foreach (Classifier C in CL)
{
this.Remove(C);
Pop.Remove(C);
}
}
}
/// <summary> /// 分類子追加 かぶらないと分かっているのでInsertと統合可能 /// </summary> /// <param name="C">生成された分類子を追加</param> public abstract void Add( Classifier C );
/// <summary> /// 一般的か /// </summary> /// <param name="Spec">比較対象</param> /// <returns>比較対象が含まれる(true)</returns> public abstract bool IsMoreGeneral( Classifier Spec );
// 包摂条件判定
public override bool DoesSubsume( Classifier C )
{
if( this.A == C.A )
{
if( this.CouldSubsume() )
{
if( this.IsMoreGeneral( C ) )
{
if (this.Epsilon_0 < C.Epsilon_0)//chou 10-5 GA subsumption
{ return true; }
}
}
}
return false;
}
/// <summary> /// 削除条件計算 /// </summary> /// <param name="C">Classifier</param> /// <param name="AvFitness">AvFitness</param> /// <returns>計算結果</returns> abstract protected double DeletionVote(Classifier C, double AvFitness);
/// <summary> /// 一致検査をして追加 /// </summary> /// <param name="C">追加されるClassifier</param> abstract public void Insert(Classifier C);
public override void Crossover( Classifier C )
{
double x = Configuration.MT.NextDouble() * ( this.C.Length + 1 );
double y = Configuration.MT.NextDouble() * ( this.C.Length + 1 );
if( x > y )
{
double tmp = x;
x = y;
y = tmp;
}
int i = 0;
do
{
if( x <= i && i < y )
{
this.C.Switch( C.C, i );
}
i++;
} while( i < y );
}
public override void RunGA(State Situation, Population P)
{
double NumerositySum = 0.0;
double TimeStampSum = 0.0;
foreach (Classifier C in this.CList)
{
NumerositySum += C.N;
TimeStampSum += C.Ts * C.N;
}
if (Configuration.T - TimeStampSum / NumerositySum > Configuration.Theta_GA)
{
foreach (Classifier C in this.CList)
{
C.Ts = Configuration.T;
}
Classifier Parent_1 = this.SelectOffspring();
Classifier Parent_2 = this.SelectOffspring();
Classifier Child_1 = new NormalClassifier(( NormalClassifier )Parent_1);
Classifier Child_2 = new NormalClassifier(( NormalClassifier )Parent_2);
Child_1.N = Child_2.N = 1;
Child_1.Exp = Child_2.Exp = 0;
Child_1.St = Child_2.St = 0;
Child_1.M = Child_2.M = 0;
Child_1.S = Child_2.S = 0;
if (Configuration.MT.NextDouble() < Configuration.Chai)
{
Child_1.Crossover(Child_2);
Child_1.P = (Parent_1.P + Parent_2.P) / 2;
Child_1.Epsilon = (Parent_1.Epsilon + Parent_2.Epsilon) / 2;
Child_1.F = (Parent_1.F + Parent_2.F) / 2;
//Child_1.M = ( Parent_1.M + Parent_2.M ) / 2;
//Child_1.S = ( Parent_1.S + Parent_2.S ) / 2;
Child_2.P = Child_1.P;
Child_2.Epsilon = Child_1.Epsilon;
Child_2.F = Child_1.F;
//Child_2.M = Child_1.M;
//Child_2.S = Child_1.S;
}
Child_1.F *= 0.1;
Child_2.F *= 0.1;
// bothChild
Child_1.Mutation(Situation);
Child_2.Mutation(Situation);
if (Configuration.DoGASubsumption)
{
if (Parent_1.DoesSubsume(Child_1))
{
Parent_1.N++;
}
else if (Parent_2.DoesSubsume(Child_1))
{
Parent_2.N++;
}
else
{
P.Insert(Child_1);
}
P.Delete();
if (Parent_1.DoesSubsume(Child_2))
{
Parent_1.N++;
}
else if (Parent_2.DoesSubsume(Child_2))
{
Parent_2.N++;
}
else
{
P.Insert(Child_2);
}
P.Delete();
}
else
{
P.Insert(Child_1);
P.Delete();
P.Insert(Child_2);
P.Delete();
}
}
}
/// <summary> /// 一致検査をして追加 /// </summary> /// <param name="C">追加されるClassifier</param> public abstract void Insert( Classifier C );
// 包摂条件判定
public override bool DoesSubsume( Classifier C )
{
if( this.A == C.A )
{
if( this.CouldSubsume() )
{
if( this.IsMoreGeneral( C ) )
{
return true;
}
}
}
return false;
}
// ListからClassifier削除
public override void Remove( Classifier C )
{
//Console.WriteLine( Configuration.T + " del " + C.C.state + " : " + C.A + " : " + C.Epsilon + " : " + C.Epsilon_0 );
//if( Configuration.T > 41000 )
// System.Threading.Thread.Sleep( 500 );
this.CList.Remove( C );
}
public override void Insert( Classifier Cl )
{
foreach( Classifier C in this.CList )
{
if( C.Equals( Cl ) )
{
C.N++;
return;
}
}
this.CList.Add( Cl );
}
/// <summary> /// 包摂できるか /// </summary> /// <param name="C">包摂相手</param> /// <returns>包摂できる(true)</returns> public abstract bool DoesSubsume(Classifier C);
/// <summary> /// 交差 /// </summary> /// <param name="C">交差相手</param> public abstract void Crossover(Classifier C);
/// <summary> /// 一般的か /// </summary> /// <param name="Spec">比較対象</param> /// <returns>比較対象が含まれる(true)</returns> public abstract bool IsMoreGeneral(Classifier Spec);
/// <summary> /// 削除条件計算 /// </summary> /// <param name="C">Classifier</param> /// <param name="AvFitness">AvFitness</param> /// <returns>計算結果</returns> protected abstract double DeletionVote( Classifier C, double AvFitness );
protected override double DeletionVote( Classifier C, double AvFitness )
{
// SigmaNormalClassifier前提
SigmaNormalClassifier SNC = ( SigmaNormalClassifier )C;
double Vote = SNC.As * SNC.N;
//Console.WriteLine("AS: " + SNC.As + " N: " + SNC.N);
if( ( SNC.Exp > Configuration.Theta_del ) && ( SNC.WinningRate.Average() / SNC.N < Configuration.Delta * AvFitness ) )
{
if(SNC.WinningRate.Average() == 0)
{
//Console.WriteLine("0 : " + Vote);
return Vote;
}
Vote *= AvFitness / ( SNC.WinningRate.Average() / SNC.N );
//Console.WriteLine("hoge");
}
//Console.WriteLine(SNC.WinningRate.Average() + " : " + Vote);
return Vote;
}
// 包摂条件判定用
public override bool IsMoreGeneral( Classifier Spec )
{
if( this.C.NumberOfSharp <= Spec.C.NumberOfSharp )
{
return false;
}
int i = 0;
do
{
if( this.C.state[i] != '#' && this.C.state[i] != Spec.C.state[i] )
{
return false;
}
i++;
} while( i < this.C.state.Length );
return true;
}
public override void RunGA(State Situation, Population P)
{
double NumerositySum = 0.0;
double TimeStampSum = 0.0;
foreach (Classifier C in this.CList)
{
NumerositySum += C.N;
TimeStampSum += C.Ts * C.N;
}
if (Configuration.T - TimeStampSum / NumerositySum > Configuration.Theta_GA)
{
foreach (Classifier C in this.CList)
{
C.Ts = Configuration.T;
}
Classifier Parent_1 = this.SelectOffspring();
Classifier Parent_2 = this.SelectOffspring();
Classifier Child_1 = new SigmaNormalClassifier(( SigmaNormalClassifier )Parent_1);
Classifier Child_2 = new SigmaNormalClassifier(( SigmaNormalClassifier )Parent_2);
///nakata added
Child_1.F /= Child_1.N;
Child_2.F /= Child_2.N;
//////////////
Child_1.N = Child_2.N = 1;
Child_1.Exp = Child_2.Exp = 0;
Child_1.St = Child_2.St = 0;
Child_1.M = Child_2.M = 0;
Child_1.S = Child_2.S = 0;
//Child_1.Epsilon_0 = Child_2.Epsilon_0 = Configuration.Epsilon_0;
SigmaNormalClassifier SNP1 = ( SigmaNormalClassifier )Parent_1;
SigmaNormalClassifier SNP2 = ( SigmaNormalClassifier )Parent_2;
SigmaNormalClassifier SNC1 = ( SigmaNormalClassifier )Child_1;
SigmaNormalClassifier SNC2 = ( SigmaNormalClassifier )Child_2;
// 交叉
if (Configuration.MT.NextDouble() < Configuration.Chai)
{
Child_1.Crossover(Child_2);
Child_1.P = (Parent_1.P + Parent_2.P) / 2;
//Child_1.Epsilon = Parent_1.Epsilon + Parent_2.Epsilon;
Child_1.Epsilon = (Parent_1.Epsilon + Parent_2.Epsilon) / 2;
Child_1.F = (Parent_1.F + Parent_2.F) / 2;
Child_1.Epsilon_0 = (Parent_1.Epsilon_0 + Parent_2.Epsilon_0) / 2;
//Child_1.Epsilon_0 = Math.Min(Parent_1.Epsilon_0, Parent_2.Epsilon_0);
Child_2.P = Child_1.P;
Child_2.Epsilon = Child_1.Epsilon;
Child_2.F = Child_1.F;
Child_2.Epsilon_0 = Child_1.Epsilon_0;
for (int i = 0; i < SNC1.WinningRate.Count(); i++)
{
SNC1.WinningRate[i] = SNC2.WinningRate[i] = (SNP1.WinningRate[i] + SNP2.WinningRate[i]) / 2;
}
}
Child_1.F *= 0.1;
Child_2.F *= 0.1;
for (int i = 0; i < SNC1.WinningRate.Count(); i++)
{
SNC1.WinningRate[i] *= 0.1;
SNC2.WinningRate[i] *= 0.1;
}
// bothChild
Child_1.Mutation(Situation);
Child_2.Mutation(Situation);
if (Child_1.C.state[4] == '0' & Child_1.C.state[7] == '1')//"bath0 rehabi1"
{
Configuration.Problem.WriteLine(Child_1.C.state + "," + Configuration.T + "," + Child_1.P + "," + Child_1.M + "," + Child_1.Epsilon + "," + Child_1.F + ","
+ Child_1.N + "," + Child_1.Exp + "," + Child_1.Ts + "," + Child_1.As + "," + Child_1.Kappa + "," + Child_1.Epsilon_0 + "," + Child_1.St + "," + Child_1.GenerateTime + ", child 2 ");
Configuration.Problem.WriteLine(Parent_1.C.state + "," + Configuration.T + "," + Parent_1.P + "," + Parent_1.M + "," + Parent_1.Epsilon + "," + Parent_1.F + ","
+ Parent_1.N + "," + Parent_1.Exp + "," + Parent_1.Ts + "," + Parent_1.As + "," + Parent_1.Kappa + "," + Parent_1.Epsilon_0 + "," + Parent_1.St + "," + Parent_1.GenerateTime + ",Parent1");
Configuration.Problem.WriteLine(Parent_2.C.state + "," + Configuration.T + "," + Parent_2.P + "," + Parent_2.M + "," + Parent_2.Epsilon + "," + Parent_2.F + ","
+ Parent_2.N + "," + Parent_2.Exp + "," + Parent_2.Ts + "," + Parent_2.As + "," + Parent_2.Kappa + "," + Parent_2.Epsilon_0 + "," + Parent_2.St + "," + Parent_2.GenerateTime + ",Parent2");
}
if (Child_2.C.state[4] == '0' & Child_2.C.state[7] == '1')//"bath0 rehabi1"
{
Configuration.Problem.WriteLine(Child_2.C.state + "," + Configuration.T + "," + Child_2.P + "," + Child_2.M + "," + Child_2.Epsilon + "," + Child_2.F + ","
+ Child_2.N + "," + Child_2.Exp + "," + Child_2.Ts + "," + Child_2.As + "," + Child_2.Kappa + "," + Child_2.Epsilon_0 + "," + Child_2.St + "," + Child_2.GenerateTime + ",child 2");
Configuration.Problem.WriteLine(Parent_1.C.state + "," + Configuration.T + "," + Parent_1.P + "," + Parent_1.M + "," + Parent_1.Epsilon + "," + Parent_1.F + ","
+ Parent_1.N + "," + Parent_1.Exp + "," + Parent_1.Ts + "," + Parent_1.As + "," + Parent_1.Kappa + "," + Parent_1.Epsilon_0 + "," + Parent_1.St + "," + Parent_1.GenerateTime + ",Parent1");
Configuration.Problem.WriteLine(Parent_2.C.state + "," + Configuration.T + "," + Parent_2.P + "," + Parent_2.M + "," + Parent_2.Epsilon + "," + Parent_2.F + ","
+ Parent_2.N + "," + Parent_2.Exp + "," + Parent_2.Ts + "," + Parent_2.As + "," + Parent_2.Kappa + "," + Parent_2.Epsilon_0 + "," + Parent_2.St + "," + Parent_2.GenerateTime + ",Parent2");
}
if (Configuration.DoGASubsumption)
{
if (Parent_1.DoesSubsume(Child_1))
{
Parent_1.N++;
}
else if (Parent_2.DoesSubsume(Child_1))
{
Parent_2.N++;
}
else
{
P.Insert(Child_1);
}
P.Delete();
if (Parent_1.DoesSubsume(Child_2))
{
Parent_1.N++;
}
else if (Parent_2.DoesSubsume(Child_2))
{
Parent_2.N++;
}
else
{
P.Insert(Child_2);
}
P.Delete();
}
else
{
P.Insert(Child_1);
P.Delete();
P.Insert(Child_2);
P.Delete();
}
}
}
/// <summary> /// Classifier消去 /// </summary> /// <param name="C"></param> public abstract void Remove( Classifier C );
// ListからClassifier削除
public override void Remove(Classifier C)
{
this.CList.Remove(C);
}
// 包摂
protected override void Subsumption(Population Pop)
{
List <Classifier> copyActionSet = new List <Classifier>();
foreach (Classifier classifier in CList)
{
copyActionSet.Add(classifier);
}
int N = copyActionSet.Count;
//最大N回実行する
//for (int i = 0; i < N; i++)
//{
#region subsume
Classifier Cl = null;
//actionsetなかに最も一般的な分類子をClにする
foreach (Classifier C in copyActionSet)
{
if (C.CouldSubsume())
{
if ((Cl == null) || (C.C.NumberOfSharp > Cl.C.NumberOfSharp) || ((C.C.NumberOfSharp == Cl.C.NumberOfSharp) && (Configuration.MT.NextDouble() < 0.5)))
{
Cl = C;
}
}
}
if (Cl != null)
{
// 削除中にforeachできない
List <Classifier> CL = new List <Classifier>();
// 包摂された、削除したいClassifier C をCLに登録
foreach (Classifier C in copyActionSet)
{
if (Cl.IsMoreGeneral(C))
{
SigmaNormalClassifier Snc_ko = (SigmaNormalClassifier)C;
SigmaNormalClassifier Snc_oya = (SigmaNormalClassifier)Cl;
// e0 の値を３位まで見る、近いものは差がないとみなす
var subsumer = Math.Round(Cl.Epsilon_0, 3);
var subsumed = Math.Round(C.Epsilon_0, 3);
if ((subsumer <= (subsumed + subsumer / 10)) &&
Snc_ko.IsConvergenceEpsilon() &&
Snc_oya.IsConvergenceEpsilon()
)
{
Cl.N += C.N;
CL.Add(C);
}
}
}
foreach (Classifier C in CL)
{
SigmaNormalClassifier SNC = (SigmaNormalClassifier)Cl;
if (C.C.state[4] == '0' & C.C.state[7] == '1') //"bath0 rehabi1"
{
Configuration.Problem.WriteLine(C.C.state + "," + Configuration.T + "," + C.P + "," + C.M + "," + C.Epsilon + "," + C.F + "," + C.N + "," + C.Exp + "," + C.Ts + "," + C.As + "," + C.Kappa + "," + C.Epsilon_0 + "," + C.St + "," + C.GenerateTime + ", in AS");
}
this.Remove(C); //as から削除
Pop.Remove(C); //pop から削除
}
//いまの最も一般化されたものを削除する
//copyActionSet.Remove(Cl);
}
#endregion
//}
}
/// <summary> /// 分類子追加 かぶらないと分かっているのでInsertと統合可能 /// </summary> /// <param name="C">生成された分類子を追加</param> abstract public void Add(Classifier C);
/// <summary> /// Classifier消去 /// </summary> /// <param name="C"></param> public abstract void Remove( Classifier C );
/// <summary> /// 交差 /// </summary> /// <param name="C">交差相手</param> public abstract void Crossover( Classifier C );
//学習終了後に圧縮にする
public override void Compact()
{
List <Classifier> copyActionSet = new List <Classifier>();
foreach (Classifier classifier in CList)
{
copyActionSet.Add(classifier);
}
int N = copyActionSet.Count;
for (int i = 0; i < N; i++)
{
#region subsume
Classifier Cl = null;
//なかに最も一般的な分類子をClにする
foreach (Classifier C in copyActionSet)
{
if (C.CouldSubsume())
{
if ((Cl == null) || (C.C.NumberOfSharp > Cl.C.NumberOfSharp) || ((C.C.NumberOfSharp == Cl.C.NumberOfSharp) && (Configuration.MT.NextDouble() < 0.5)))
{
Cl = C;
}
}
}
//Cl が包摂できる分類子を吸収する
if (Cl != null)
{
// 削除中にforeachできない
List <Classifier> CL = new List <Classifier>();
foreach (Classifier C in copyActionSet)
{
if (Cl.IsMoreGeneral(C))
{
SigmaNormalClassifier Snc_ko = (SigmaNormalClassifier)C;
SigmaNormalClassifier Snc_oya = (SigmaNormalClassifier)Cl;
//10の数字は適当 可変にするか？ 1/10にする 10－7 あんまり変わらない
//分散が同じの判断基準 他に？？t test を使う 予定 特殊化がでない
//
//double t = (Snc_oya.M - Snc_ko.M)/Math.Sqrt(Snc_oya.S/30 + Snc_ko.S/30);
//double studentT = StudentT.InvCDF(0, 1, 60, 0.005);
//if (t < studentT || t > Math.Abs(studentT))//t test で有意差がある 包摂しない
//{
//}
// else//有意差がない 統合しでもよい ただ 特殊化ルールどう識別するか
//{
if (/*Math.Abs(Cl.M - C.M) < 10 &&*/
// Math.Abs(Cl.Epsilon_0 - C.Epsilon_0)< 10&&
// Cl.Kappa == 1
//&& Snc_oya.Epsilon < Snc_ko.Epsilon
(Cl.Epsilon_0 < C.Epsilon_0 || Math.Abs(Cl.Epsilon_0 - C.Epsilon_0) < Cl.Epsilon_0 / 10)
//&& Math.Abs(Cl.Epsilon_0 - C.Epsilon_0) < 10//case 1 +- 10
// Cl.Epsilon < C.Epsilon
&& Snc_ko.IsConvergenceEpsilon() &&
Snc_oya.IsConvergenceEpsilon()
) //
{
Cl.N += C.N;
// 包摂された、削除したいClassifier C をCLに登録
CL.Add(C);
}
// }
}
}
foreach (Classifier C in CL)
{
this.Remove(C);//包摂された分類子 C を pop からCを削除
}
}
//最も一般化されるもの copyActionSetからを削除
copyActionSet.Remove(Cl);
#endregion
}
}
/// <summary> /// 包摂できるか /// </summary> /// <param name="C">包摂相手</param> /// <returns>包摂できる(true)</returns> public abstract bool DoesSubsume( Classifier C );
// Actionsetから削除
public override void Remove( Classifier C )
{
this.CList.Remove( C );
}
protected override double DeletionVote( Classifier C, double AvFitness )
{
double Vote = C.As * C.N;
if( ( C.Exp > Configuration.Theta_del ) && ( C.F / C.N < Configuration.Delta * AvFitness ) )
{
//Vote *= AvFitness / ( C.F / C.N )* (C.Epsilon_0/SumEpsilon_0()); //2015/10/8 cho ε小さいのも残す
//Vote *= AvFitness / (C.F / C.N) * (C.Epsilon_0 / MaxEpsilon_0());//10-14 chou failled
Vote *= AvFitness / (C.F / C.N);
}
return Vote;
}
