private void RefreshButton_Click(object sender, EventArgs e)
{
ParameterSetting dlg = new ParameterSetting(_db);
if (dlg.ShowDialog(this) == DialogResult.Cancel)
{
return;
}
this.dateTimePicker_Start.Value = dlg.wpf.StartTime;
this.dateTimePicker_End.Value = dlg.wpf.EndTime;
DlgWaiting wait = new DlgWaiting();
wait.OnAction += dlg_OnAction;
wait.ShowDialog();
//this.textBox_LSL.Text = this._lsl;
//this.textBox_USL.Text = this._usl;
//this.textBox_Target.Text = this._target;
//this.tb_Sigma.Text = this._sigma;
//this.tb_M3Sigma.Text = this._m3Sigma;
//this.tb_P3Sigma.Text = this._p3Sigma;
//this.tb_Average.Text = this._average;
}
private static ParameterSetting[] LoadBaseParameters(ParameterSetting[] parameters, CsvReader reader, int[] columnMap)
{
var baseParameters = new ParameterSetting[parameters.Length];
// we only read the first line
int columns;
if (reader.LoadLine(out columns))
{
var job = new Job()
{
ProcessedBy = null,
Processing = false,
Processed = false,
Value = float.NaN,
Parameters = baseParameters
};
for (int i = 0; i < parameters.Length; i++)
{
baseParameters[i] = new ParameterSetting()
{
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum
};
}
for (int i = 0; i < columnMap.Length; i++)
{
reader.Get(out baseParameters[columnMap[i]].Current, i + 2);
}
}
return(baseParameters);
}
private void LoadParameterFile()
{
XmlDocument doc = new XmlDocument();
doc.Load(this.ParameterFile.GetFilePath());
List <ParameterSetting> parameters = new List <ParameterSetting>();
foreach (XmlNode child in doc["Root"].ChildNodes)
{
if (child.Name == "Parameter")
{
ParameterSetting current = new ParameterSetting();
if (child.HasChildNodes)
{
var nodes = child.ChildNodes;
current.Names = new string[nodes.Count];
for (int i = 0; i < nodes.Count; i++)
{
XmlNode name = nodes[i];
var parameterPath = name.Attributes["ParameterPath"].InnerText;
current.Names[i] = parameterPath;
}
}
else
{
var parameterPath = child.Attributes["ParameterPath"].InnerText;
current.Names = new string[] { parameterPath };
}
parameters.Add(current);
}
}
this.Parameters = parameters.ToArray();
}
private void button3_Click(object sender, EventArgs e)
{
string path = @"D:\桌面\程式\玻璃";
setting = new ParameterSetting(path, "玻璃");
setting.ShowDialog();
}
private void SaveShaField()
{
string text = cboSha.Text;
if (text.Trim().Length == 0)
{
Administrator.ProfileManager.ShaSettings.Delete(Administrator.ProfileManager.ShaSettings.SelectedKey);
InitialiseShaField();
return;
}
if (!Administrator.ProfileManager.ShaSettings.Keys.Contains(text))
{
ParameterSetting setting = new ParameterSetting
{
Key = text,
Value = text,
};
Administrator.ProfileManager.ShaSettings.Persist(setting);
InitialiseShaField();
}
else
{
Administrator.ProfileManager.ShaSettings.Select(text);
}
}
private ParameterSetting[] GeneratePairwiseAminoAcidParameters()
{
var parameterSettings = new List <ParameterSetting>
{
new ParameterSetting("DirectNeighborWeight", -1e3, 1e3, 0.01, 0.1),
new ParameterSetting("4thNeighborWeight", -1e3, 1e3, 0.01, 1.0)
};
var aminoAcids = (AminoAcidName[])Enum.GetValues(typeof(AminoAcidName));
var singleLetterCodes = aminoAcids
.Select(aa => aa.ToOneLetterCode())
.OrderBy(x => x)
.ToList();
AminoAcidCodePairs = new List <string>();
for (int idx1 = 0; idx1 < singleLetterCodes.Count; idx1++)
{
var code1 = singleLetterCodes[idx1];
for (int idx2 = idx1; idx2 < singleLetterCodes.Count; idx2++)
{
var code2 = singleLetterCodes[idx2];
var codePair = string.Empty + code1 + code2;
AminoAcidCodePairs.Add(codePair);
var parameterSetting = new ParameterSetting(
codePair,
-1,
1,
0.1,
1.0);
parameterSettings.Add(parameterSetting);
}
}
return(parameterSettings.ToArray());
}
internal Job UpdatePosition(HybridPSOGD us)
{
var temp = Job.Parameters;
Job job = new Job();
job.Processed = false;
job.ProcessedBy = null;
job.Processing = false;
job.Value = float.NaN;
var parameters = job.Parameters = new ParameterSetting[temp.Length];
for (int i = 0; i < temp.Length; i++)
{
parameters[i] = new ParameterSetting();
// we need to move in real parameter space instead of relative parameter space
parameters[i].Current = temp[i].Current + Velocity[i] * (temp[i].Size);
// clamp the value inside of parameter space
if (parameters[i].Current < (parameters[i].Minimum = temp[i].Minimum))
{
parameters[i].Current = temp[i].Minimum;
Velocity[i] = -Velocity[i];
}
if (parameters[i].Current > (parameters[i].Maximum = temp[i].Maximum))
{
parameters[i].Current = temp[i].Maximum;
Velocity[i] = -Velocity[i];
}
}
return(Job = job);
}
private void LoadInstructions()
{
XmlDocument doc = new XmlDocument();
doc.Load(GetFileLocation(ParameterInstructions));
List <ParameterSetting> parameters = new List <ParameterSetting>();
var childNodes = doc["Root"]?.ChildNodes;
if (childNodes == null)
{
return;
}
foreach (XmlNode child in childNodes)
{
if (child.Name == "Parameter")
{
ParameterSetting current = new ParameterSetting();
var childAttributes = child.Attributes;
if (childAttributes != null)
{
current.Start = float.Parse(childAttributes["Start"].InnerText);
current.Stop = float.Parse(childAttributes["Stop"].InnerText);
current.Current = current.Start;
if (child.HasChildNodes)
{
var nodes = child.ChildNodes;
current.Names = new string[nodes.Count];
for (int i = 0; i < nodes.Count; i++)
{
var grandChildAttributes = nodes[i].Attributes;
if (grandChildAttributes != null)
{
var modeName = grandChildAttributes["Mode"].InnerText;
var parameterName = grandChildAttributes["Name"].InnerText;
current.Names[i] = String.Concat(modeName, '.', parameterName);
}
}
}
else
{
var modeName = childAttributes["Mode"].InnerText;
var parameterName = String.Concat(modeName, '.', childAttributes["Name"].InnerText);
current.Names = new[] { parameterName };
}
if (!ValidateParameterNames || ValidateParameterName(current))
{
parameters.Add(current);
}
else
{
throw new XTMFRuntimeException(this,
"This parameter is invalid. Please make sure the mode exists and that it has a parameter with the given name!\r\n" +
child.OuterXml);
}
}
}
}
Parameters = parameters.ToArray();
}
public void ParamSetExecuteChanged()
{
if (UserInfoHelper.IsHaveLogin)
{
ParameterSetting setWin = new ParameterSetting();
setWin.ShowDialog();
}
}
void _parameters_Click(object sender, RoutedEventArgs e)
{
ParameterSetting paramSetting = new ParameterSetting(this._host, false);
paramSetting.Owner = this._host;
paramSetting.ShowDialog();
paramSetting = null;
}
public ActionResult Edit(ParameterSetting parametersetting)
{
if (ModelState.IsValid)
{
db.Entry(parametersetting).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(parametersetting));
}
protected override bool Setting()
{
ParameterSetting dlg = new ParameterSetting(_db);
if (dlg.ShowDialog(this) == DialogResult.Cancel)
{
return(false);
}
_bkSeries.Clear();
return(true);
}
private int IndexOf(ParameterSetting[] parameters, ParameterSetting selectedParameter)
{
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] == selectedParameter)
{
return(i);
}
}
return(-1);
}
static void Main(string[] args)
{
if (args.Length <= 0)
{
Console.WriteLine("Please specify config file:");
return;
}
ParameterSetting.LoadArgs(args[0]);
RunPipeline();
}
private void SaveCheckoutBranchField()
{
string text = cboCheckoutBranch.Text;
if (text.Trim().Length == 0)
{
Administrator.ProfileManager.BranchCheckoutSettings.Delete(Administrator.ProfileManager.BranchCheckoutSettings.SelectedKey);
InitialiseCheckoutBranchField();
return;
}
if (!Administrator.ProfileManager.BranchCheckoutSettings.Keys.Contains(text))
{
ParameterSetting setting = new ParameterSetting
{
Key = text,
Value = text,
};
Administrator.ProfileManager.BranchCheckoutSettings.Persist(setting);
InitialiseCheckoutBranchField();
}
else
{
Administrator.ProfileManager.BranchCheckoutSettings.Select(text);
}
// Change related fields.
if (text.Trim().Length > 0)
{
cboRemoteBranch.Text = text;
cboLocalBranch.Text = text;
string currentCommentIssueIdentifier = GetIssueIdentifier(cboComment.Text);
string newBranchIssueIdentifier = GetIssueIdentifier(text);
if (newBranchIssueIdentifier.Length > 0)
{
if (newBranchIssueIdentifier != currentCommentIssueIdentifier)
{
List <string> sortedComments = Administrator.ProfileManager.CommentSettings.Keys.ToList();
sortedComments.Sort();
string comment = string.Empty;
foreach (string c in sortedComments)
{
if (c.StartsWith(newBranchIssueIdentifier))
{
comment = c;
break;
}
}
if (comment.Length > 0)
{
cboComment.Text = comment;
}
}
}
}
}
private void SaveOneFileSpecField(string fileSpec)
{
if (!Administrator.ProfileManager.FileSpecSettings.Keys.Contains(fileSpec))
{
ParameterSetting setting = new ParameterSetting
{
Key = fileSpec,
Value = fileSpec,
};
Administrator.ProfileManager.FileSpecSettings.Persist(setting);
}
}
private void SaveCommentField()
{
string text = cboComment.Text;
if (text.Trim().Length == 0)
{
Administrator.ProfileManager.CommentSettings.Delete(Administrator.ProfileManager.CommentSettings.SelectedKey);
InitialiseCommentField();
return;
}
if (!Administrator.ProfileManager.CommentSettings.Keys.Contains(text))
{
ParameterSetting setting = new ParameterSetting
{
Key = text,
Value = text,
};
Administrator.ProfileManager.CommentSettings.Persist(setting);
InitialiseCommentField();
}
else
{
Administrator.ProfileManager.CommentSettings.Select(text);
}
// Change related fields.
if (text.Trim().Length > 0)
{
string currentBranchIssueIdentifier = GetIssueIdentifier(cboCheckoutBranch.Text);
string newCommentIssueIdentifier = GetIssueIdentifier(text);
if (newCommentIssueIdentifier.Length > 0)
{
if (newCommentIssueIdentifier != currentBranchIssueIdentifier)
{
List <string> sortedBranches = Administrator.ProfileManager.BranchCheckoutSettings.Keys.ToList();
sortedBranches.Sort();
string branch = string.Empty;
foreach (string b in sortedBranches)
{
if (b.Contains(newCommentIssueIdentifier))
{
branch = b;
break;
}
}
if (branch.Length > 0)
{
cboCheckoutBranch.Text = branch;
}
}
}
}
}
private void SetupParameters(List <ParameterSetting> list)
{
var param = new ParameterSetting[list.Count];
for (int i = 0; i < param.Length; i++)
{
var other = list[i];
param[i] = new ParameterSetting();
param[i].Minimum = other.Minimum;
param[i].Maximum = other.Maximum;
param[i].Current = (other.Maximum + other.Minimum) / 2;
}
LocalSpaces = param;
}
private ParameterSetting[] Clone(ParameterSetting[] parameters)
{
ParameterSetting[] ret = new ParameterSetting[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
ret[i] = new ParameterSetting()
{
Current = parameters[i].Current,
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum,
NullHypothesis = parameters[i].NullHypothesis
};
}
return(ret);
}
private bool ValidateParameterName(ParameterSetting current)
{
for (int i = 0; i < current.Names.Length; i++)
{
var parts = current.Names[i].Split('.');
if (parts.Length != 2)
{
throw new XTMFRuntimeException(this, "We were unable to validate the parameter name '" + current.Names[i] + "'!");
}
if (GetVariableName(parts[0], parts[1]) == null)
{
return(false);
}
}
return(true);
}
public List <Job> CreateJobsForIteration()
{
var ret = new List <Job>();
var parameters = this.Root.Parameters.ToArray();
int totalParameters = parameters.Sum(p => p.Names.Length);
using (CsvReader reader = new CsvReader(this.ResultFile.GetFilePath()))
{
reader.LoadLine();
int columns;
while (reader.LoadLine(out columns))
{
//+2 for generation and value
if (columns >= totalParameters + 2)
{
var jobParameters = new ParameterSetting[parameters.Length];
var job = new Job()
{
ProcessedBy = null,
Processing = false,
Processed = false,
Value = float.NaN,
Parameters = jobParameters
};
var columnIndex = 2;
for (int i = 0; i < parameters.Length; i++)
{
jobParameters[i] = new ParameterSetting()
{
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum
};
reader.Get(out jobParameters[i].Current, columnIndex);
columnIndex += parameters[i].Names.Length;
}
ret.Add(job);
if (NumberOfRows > 0 & ret.Count >= NumberOfRows)
{
break;
}
}
}
}
return(ret);
}
protected override bool Setting()
{
base.Setting();
ParameterSetting dlg = new ParameterSetting(_db);
if (dlg.ShowDialog(this) == DialogResult.Cancel)
{
return(false);
}
if (this._db != null)
{
_db.time_start = Properties.Settings.Default.DefaultDateTimeStart;
_db.time_end = Properties.Settings.Default.DefaultDateTimeEnd;
_db.TestBench = Properties.Settings.Default.DefaultTestBench;
_db.ProductType = Properties.Settings.Default.ProductType;
}
return(true);
}
void _insetParameter_Click(object sender, RoutedEventArgs e)
{
ParameterSetting parameterSetting = new ParameterSetting(this._host, true);
parameterSetting.Owner = this._host;
parameterSetting.ShowDialog();
if (string.IsNullOrEmpty(parameterSetting.ParameterName))
{
return;
}
if (this.main.SelectedText == null)
{
this.main.Text = this.main.Text.Insert(this.main.CaretIndex, parameterSetting.ParameterName);
}
else
{
this.main.SelectedText = parameterSetting.ParameterName;
this.main.CaretIndex += this.main.SelectedText.Length;
this.main.SelectionLength = 0;
}
}
private static ParameterSetting[] LoadBaseParameters(ParameterSetting[] parameters, CsvReader reader, int[] columnMap)
{
var baseParameters = new ParameterSetting[parameters.Length];
// we only read the first line
if (reader.LoadLine(out int columns))
{
for (int i = 0; i < parameters.Length; i++)
{
baseParameters[i] = new ParameterSetting()
{
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum
};
}
for (int i = 0; i < columnMap.Length; i++)
{
reader.Get(out baseParameters[columnMap[i]].Current, i + 2);
}
}
return(baseParameters);
}
private void SetupParameters(List<ParameterSetting> list)
{
var param = new ParameterSetting[list.Count];
for ( int i = 0; i < param.Length; i++ )
{
var other = list[i];
param[i] = new ParameterSetting();
param[i].Minimum = other.Minimum;
param[i].Maximum = other.Maximum;
param[i].Current = ( other.Maximum + other.Minimum ) / 2;
}
this.LocalSpaces = param;
}
private void LoadParameterInstructions()
{
XmlDocument doc = new XmlDocument();
doc.Load( this.ParameterInstructions );
List<ParameterSetting> parameters = new List<ParameterSetting>();
foreach ( XmlNode child in doc["Root"].ChildNodes )
{
if ( child.Name == "Parameter" )
{
ParameterSetting current = new ParameterSetting();
current.ParameterName = child.Attributes["Name"].InnerText;
current.MSNumber = int.Parse( child.Attributes["MS"].InnerText );
current.Start = float.Parse( child.Attributes["Start"].InnerText );
current.Stop = float.Parse( child.Attributes["Stop"].InnerText );
current.Current = current.Start;
parameters.Add( current );
}
}
this.Parameters = parameters.ToArray();
}
public void Explore(ParameterSetting[] parameters, Action UpdateProgress, Func<ParameterSetting[], float> evaluationfunction)
{
this.Progress = 0;
Random rand = new Random( ( ++this.NumberOfExplorations ) * ( this.RandomSeed ) );
var numberOfParameters = parameters.Length;
this.Kernel = parameters.Clone() as ParameterSetting[];
this.GenerateRandomSeed( rand );
float[,] explorationErrors = new float[numberOfParameters, 2];
float[,] explorationGradients = new float[numberOfParameters, 2];
ParameterSetting[,][] explorationPoints = new ParameterSetting[numberOfParameters, 2][];
for ( int i = 0; i < numberOfParameters; i++ )
{
for ( int j = 0; j < 2; j++ )
{
explorationPoints[i, j] = parameters.Clone() as ParameterSetting[];
}
}
// Explore it for all of the pre-defined iterations
for ( int iteration = 0; iteration < this.TotalIterations; iteration++ )
{
this.CurrentIteration = iteration;
this.Progress = (float)iteration / this.TotalIterations;
UpdateProgress();
// figure out how good our point is
if ( this.Exit )
{
break;
}
var kernelError = evaluationfunction( this.Kernel );
// Calculate all of the errors
GenerateExplorationPoints( numberOfParameters, this.Kernel, explorationPoints, explorationErrors, evaluationfunction, UpdateProgress );
// Calculate the gradients from the errors
ComputeGradients( numberOfParameters, explorationErrors, explorationGradients, kernelError );
MoveKernel( explorationGradients, rand );
}
this.Progress = 1;
}
public float ComplexErrorFunction(ParameterSetting[] parameters, TransitLine[] transitLine, TransitLine[] predicted, float[] aggToTruth)
{
float sum = 0;
//var regionError = this.ComputeRegionError( transitLine, predicted );
//var lineByLine = this.ComputeLineError( transitLine, aggToTruth );
foreach ( var tally in this.ErrorTallies )
{
sum += tally.ComputeError( parameters, transitLine, predicted );
}
return sum;
}
private int IndexOf(ParameterSetting[] parameters, ParameterSetting selectedParameter)
{
for(int i = 0; i < parameters.Length; i++)
{
if(parameters[i] == selectedParameter) return i;
}
return -1;
}
internal Job UpdatePosition(ParticleSwarmOptimization us)
{
var temp = Job.Parameters;
Job job = new Job();
job.Processed = false;
job.ProcessedBy = null;
job.Processing = false;
job.Value = float.NaN;
var parameters = job.Parameters = new ParameterSetting[temp.Length];
for(int i = 0; i < temp.Length; i++)
{
parameters[i] = new ParameterSetting();
// we need to move in real parameter space instead of relative parameter space
parameters[i].Current = temp[i].Current + Velocity[i] * (temp[i].Size);
// clamp the value inside of parameter space
if(parameters[i].Current < (parameters[i].Minimum = temp[i].Minimum))
{
parameters[i].Current = temp[i].Minimum;
Velocity[i] = -Velocity[i];
}
if(parameters[i].Current > (parameters[i].Maximum = temp[i].Maximum))
{
parameters[i].Current = temp[i].Maximum;
Velocity[i] = -Velocity[i];
}
}
return (Job = job);
}
private GenerationJob[] GetLowestBest(CsvReader reader, ParameterSetting[] parameters)
{
List<GenerationJob> best = new List<GenerationJob>( this.ResultsToSave + 2 );
GenerationJob currentJob;
var maxResults = this.ResultsToSave;
while ( ( currentJob = ReadJob( reader, parameters ) ) != null )
{
int index = -1;
// Always accept the first one
if ( best.Count > 0 )
{
//check the last one first since they are in order to see if we need to check each one
if ( currentJob.Job.Value < best[best.Count - 1].Job.Value )
{
for ( int i = 0; i < best.Count; i++ )
{
if ( currentJob.Job.Value < best[i].Job.Value )
{
index = i;
break;
}
}
}
}
if ( index >= 0 )
{
best.Insert( index, currentJob );
if ( best.Count > maxResults )
{
best.RemoveAt( best.Count - 1 );
}
}
// if we don't have enough just add
else if ( index == -1 & best.Count < maxResults )
{
best.Add( currentJob );
}
}
return best.ToArray();
}
private Job CreateWithout(ParameterSetting[] baseParameters, int index)
{
var parameters = Clone(baseParameters);
parameters[index].Current = 0.0f;
return CreateJob(parameters);
}
public void Explore(ParameterSetting[] parameters, Action UpdateProgress, Func<ParameterSetting[], float> evaluationfunction)
{
this.Exit = false;
this.Progress = 0;
this.Explore( parameters, UpdateProgress, evaluationfunction, 0 );
this.Progress = 1;
UpdateProgress();
}
public float ComplexErrorFunction(ParameterSetting[] parameters, TransitLine[] transitLine, TransitLine[] predicted, float[] aggToTruth)
{
return this.ErrorTally.ComputeError( parameters, transitLine, predicted );
}
private Job CreateWithOffset(ParameterSetting[] baseParameters, int index, float delta)
{
var parameters = Clone(baseParameters);
parameters[index].Current += delta * (parameters[index].Maximum - parameters[index].Minimum);
return CreateJob(parameters);
}
private void GenerateExplorationPoints(int numberOfParameters, ParameterSetting[] kernel, ParameterSetting[,][] explorationPoints
, float[,] explorationErrors, Func<ParameterSetting[], float> evaluationfunction, Action UpdateProgress)
{
for ( int i = 0; i < numberOfParameters; i++ )
{
for ( int j = 0; j < numberOfParameters; j++ )
{
if ( i != j )
{
explorationPoints[i, 0][j].Current = kernel[j].Current;
explorationPoints[i, 1][j].Current = kernel[j].Current;
explorationPoints[i, 2][j].Current = kernel[j].Current;
explorationPoints[i, 3][j].Current = kernel[j].Current;
}
else
{
for ( int k = 0; k < 4; k++ )
{
float currentWhisker;
switch ( k )
{
case 0:
currentWhisker = this.WhiskerLength * -2;
break;
case 1:
currentWhisker = -this.WhiskerLength;
break;
case 2:
currentWhisker = this.WhiskerLength;
break;
default:
currentWhisker = this.WhiskerLength * 2;
break;
}
explorationPoints[i, k][j].Current = kernel[j].Current + ( kernel[j].Stop - kernel[j].Start ) * currentWhisker;
if ( explorationPoints[i, k][j].Current < explorationPoints[i, k][j].Start )
{
explorationPoints[i, k][j].Current = explorationPoints[i, k][j].Start;
}
else if ( explorationPoints[i, k][j].Current > explorationPoints[i, k][j].Stop )
{
explorationPoints[i, k][j].Current = explorationPoints[i, k][j].Stop;
}
}
}
}
for ( int k = 0; k < 4; k++ )
{
if ( this.Exit )
{
break;
}
explorationErrors[i, k] = evaluationfunction( explorationPoints[i, k] );
this.Progress = (float)( (float)this.CurrentIteration / this.TotalIterations )
+ ( 1.0f / this.TotalIterations ) * ( ( i * 4 + k ) / (float)( numberOfParameters * 4 ) );
UpdateProgress();
}
}
}
public void Explore(ParameterSetting[] parameters, Action UpdateProgress, Func<ParameterSetting[], float> evaluationfunction)
{
this.Progress = 0;
Random rand = new Random( ( ++this.NumberOfExplorations ) * ( this.RandomSeed ) );
var numberOfParameters = parameters.Length;
this.Kernel = parameters.Clone() as ParameterSetting[];
this.ParameterVolatility = new float[numberOfParameters];
this.PreviousVolatility = new float[numberOfParameters];
this.Momentum = new float[numberOfParameters];
this.MoveChoice = new float[numberOfParameters];
this.PreviousMoveChoice = new float[numberOfParameters];
this.GenerateRandomSeed( rand );
float[,] explorationErrors = new float[numberOfParameters, 4];
float[,] explorationGradients = new float[numberOfParameters, 4];
ParameterSetting[,][] explorationPoints = new ParameterSetting[numberOfParameters, 4][];
float bestSoFar = float.MaxValue;
int numberOfIterationSinceBest = 0;
for ( int i = 0; i < numberOfParameters; i++ )
{
for ( int j = 0; j < 4; j++ )
{
explorationPoints[i, j] = parameters.Clone() as ParameterSetting[];
}
}
// Explore it for all of the pre-defined iterations
for ( int iteration = 0; iteration < this.TotalIterations; iteration++ )
{
this.CurrentIteration = iteration;
this.Progress = (float)iteration / this.TotalIterations;
UpdateProgress();
// figure out how good our point is
if ( this.Exit )
{
break;
}
var kernelError = evaluationfunction( this.Kernel );
if ( kernelError < bestSoFar )
{
bestSoFar = kernelError;
numberOfIterationSinceBest = 0;
}
else if ( ( ++numberOfIterationSinceBest ) > this.IterationsFromBest )
{
break;
}
// Calculate all of the errors
GenerateExplorationPoints( numberOfParameters, this.Kernel, explorationPoints, explorationErrors, evaluationfunction, UpdateProgress );
// Calculate the gradients from the errors
ComputeGradients( numberOfParameters, explorationErrors, explorationGradients, kernelError );
ComputeVolatility( explorationGradients, kernelError );
if ( EarlyTermination() )
{
break;
}
MoveKernel( explorationGradients, rand );
var moveChoiceTemp = PreviousMoveChoice;
PreviousMoveChoice = MoveChoice;
MoveChoice = moveChoiceTemp;
}
this.Progress = 1;
}
private static float RelativeDistance(ParameterSetting parameter, float ourValue, float otherValue)
{
return((otherValue - ourValue) / parameter.Size);
}
private void Explore(ParameterSetting[] parameters, Action UpdateProgress, Func<ParameterSetting[], float> evaluationfunction, int parameterIndex)
{
float point = parameters[parameterIndex].Start;
for ( ; point < parameters[parameterIndex].Stop; point += ( parameters[parameterIndex].Stop - parameters[parameterIndex].Start ) * this.Interval )
{
parameters[parameterIndex].Current = point;
if ( parameterIndex >= parameters.Length - 1 )
{
var result = evaluationfunction( parameters );
this.Progress = this.Progress + ( 1f / (float)Math.Pow( 1f / this.Interval, parameters.Length ) );
UpdateProgress();
}
else
{
this.Explore( parameters, UpdateProgress, evaluationfunction, parameterIndex + 1 );
}
if ( this.Exit )
{
break;
}
}
}
public float ComputeError(ParameterSetting[] parameters, TransitLine[] transitLine, TransitLine[] predicted)
{
List<Pair<char, char>> foundModes = new List<Pair<char, char>>();
var ttsLines = transitLine.Length;
var predictedLines = predicted.Length;
var compairePair = new Pair<char, char>();
for ( int i = 0; i < ttsLines; i++ )
{
if ( i > transitLine.Length )
{
throw new XTMFRuntimeException( String.Format( "i = {0}, ttsLines = {1}, transitLine.Length = {2}",
i, ttsLines, transitLine.Length ) );
}
var mode = transitLine[i].Mode;
if ( transitLine[i].ID == null )
{
throw new XTMFRuntimeException( "There is a TTS line without an ID!" );
}
else if ( transitLine[i].ID.Length < 1 )
{
throw new XTMFRuntimeException( "There is a TTS line without an ID!" );
}
else if ( transitLine[i].ID[0].Length < 1 )
{
throw new XTMFRuntimeException( "There is an invalid ID for the TTS line #" + i + "!" );
}
var firstLetter = transitLine[i].ID[0][0];
compairePair.First = mode;
compairePair.Second = firstLetter;
if ( !foundModes.Contains( compairePair ) )
{
foundModes.Add( new Pair<char, char>( mode, firstLetter ) );
}
}
var numberOfModesFirstLetters = foundModes.Count;
float[] aggTTSToMode = new float[numberOfModesFirstLetters];
float[] aggPredToMode = new float[numberOfModesFirstLetters];
// first pass agg all of the tts numbers
var testPair = new Pair<char, char>();
for ( int i = 0; i < ttsLines; i++ )
{
testPair.First = transitLine[i].Mode;
testPair.Second = transitLine[i].ID[0][0];
var indexOfTransitLine = foundModes.IndexOf( testPair );
if ( indexOfTransitLine == -1 )
{
continue;
}
aggTTSToMode[indexOfTransitLine] += transitLine[i].Bordings;
}
// second pass agg all of the predicted numbers
for ( int i = 0; i < predictedLines; i++ )
{
testPair.First = predicted[i].Mode;
testPair.Second = predicted[i].ID[0][0];
var indexOfPredictedMode = foundModes.IndexOf( testPair );
if ( indexOfPredictedMode == -1 )
{
continue;
}
aggPredToMode[indexOfPredictedMode] += predicted[i].Bordings;
}
double rmse = 0;
double mabs = 0;
double terror = 0;
for ( int i = 0; i < numberOfModesFirstLetters; i++ )
{
float error = this.RegionPercentError ? (float)( Math.Abs( aggPredToMode[i] - aggTTSToMode[i] ) / aggTTSToMode[i] ) : aggTTSToMode[i] - aggPredToMode[i];
rmse += error * error;
mabs += Math.Abs( error );
terror += error;
}
var finalError = (float)( ( rmse * this.RMSEWeight ) + ( mabs * this.MABSWeight ) + ( terror * this.TERRORWeight ) );
if ( !String.IsNullOrWhiteSpace( this.RegionErrorFile ) )
{
bool exists = File.Exists( this.RegionErrorFile );
using ( var writer = new StreamWriter( this.RegionErrorFile, true ) )
{
if ( !exists )
{
for ( int i = 0; i < numberOfModesFirstLetters; i++ )
{
writer.Write( foundModes[i].Second );
writer.Write( ':' );
writer.Write( foundModes[i].First );
if ( i == numberOfModesFirstLetters - 1 )
{
if ( this.RegionPercentError )
{
writer.WriteLine( ",%Error" );
}
else
{
writer.WriteLine( ",Error" );
}
}
else
{
writer.Write( ',' );
}
}
}
for ( int i = 0; i < numberOfModesFirstLetters; i++ )
{
if ( this.RegionPercentError )
{
writer.Write( (float)( Math.Abs( aggPredToMode[i] - aggTTSToMode[i] ) / aggTTSToMode[i] ) );
}
else
{
writer.Write( aggPredToMode[i] - aggTTSToMode[i] );
}
writer.Write( ',' );
}
writer.WriteLine( finalError );
}
}
return finalError;
}
private void GenerateExplorationPoints(int numberOfParameters, ParameterSetting[] kernel, ParameterSetting[,][] explorationPoints
, float[,] explorationErrors, Func<ParameterSetting[], float> evaluationfunction, Action UpdateProgress)
{
for ( int i = 0; i < numberOfParameters; i++ )
{
for ( int j = 0; j < numberOfParameters; j++ )
{
if ( i != j )
{
explorationPoints[i, 0][j].Current = kernel[j].Current;
explorationPoints[i, 1][j].Current = kernel[j].Current;
}
else
{
for ( int k = 0; k < 2; k++ )
{
explorationPoints[i, k][j].Current = kernel[j].Current + ( kernel[j].Stop - kernel[j].Start ) * ( k == 0 ? -this.WhiskerLength : this.WhiskerLength );
if ( explorationPoints[i, k][j].Current < explorationPoints[i, k][j].Start )
{
explorationPoints[i, k][j].Current = explorationPoints[i, k][j].Start;
}
else if ( explorationPoints[i, k][j].Current > explorationPoints[i, k][j].Stop )
{
explorationPoints[i, k][j].Current = explorationPoints[i, k][j].Stop;
}
}
}
}
for ( int k = 0; k < 2; k++ )
{
if ( this.Exit )
{
break;
}
explorationErrors[i, k] = evaluationfunction( explorationPoints[i, k] );
this.Progress = (float)( (float)this.CurrentIteration / this.TotalIterations )
+ ( 1.0f / this.TotalIterations ) * ( ( i * 2 + k ) / (float)( numberOfParameters * 2 ) );
UpdateProgress();
}
}
}
private Job CreateZero(ParameterSetting[] baseParameters)
{
var parameters = Clone(baseParameters);
for(int i = 0; i < parameters.Length; i++)
{
parameters[i].Current = parameters[i].NullHypothesis;
}
return CreateJob(parameters);
}
private float EvaluteParameters(ParameterSetting[] parameters)
{
SetupInputFiles( parameters );
this.NetworkAssignment.RunNetworkAssignment();
return ProcessResults( parameters );
}
internal Job UpdatePosition(ParticleSwarmOptimization us, Random rand)
{
var temp = Job.Parameters;
var job = new Job
{
Processed = false,
ProcessedBy = null,
Processing = false,
Value = float.NaN
};
var parameters = job.Parameters = new ParameterSetting[temp.Length];
for (int i = 0; i < temp.Length; i++)
{
parameters[i] = new ParameterSetting
{
// we need to move in real parameter space instead of relative parameter space
Current = temp[i].Current + Velocity[i] * (temp[i].Size)
};
// clamp the value inside of parameter space
if (parameters[i].Current < (parameters[i].Minimum = temp[i].Minimum))
{
// reflect off the boundary instead of being absorbed
switch (us.Bounce)
{
case BounceStrategy.Reflect:
parameters[i].Current = Math.Min(temp[i].Minimum + (temp[i].Minimum - parameters[i].Current), temp[i].Maximum);
break;
case BounceStrategy.RandomReallocation:
parameters[i].Current = (float)(rand.NextDouble() * (temp[i].Maximum - temp[i].Minimum) + temp[i].Minimum);
break;
case BounceStrategy.Absorb:
parameters[i].Current = parameters[i].Minimum;
break;
}
if (us.Momentum > 0)
{
Velocity[i] = -Velocity[i];
}
}
if (parameters[i].Current > (parameters[i].Maximum = temp[i].Maximum))
{
// reflect off the boundary instead of being absorbed
switch (us.Bounce)
{
case BounceStrategy.Reflect:
parameters[i].Current = Math.Max(temp[i].Maximum - (parameters[i].Current - temp[i].Maximum), temp[i].Minimum);
break;
case BounceStrategy.RandomReallocation:
parameters[i].Current = (float)(rand.NextDouble() * (temp[i].Maximum - temp[i].Minimum) + temp[i].Minimum);
break;
case BounceStrategy.Absorb:
parameters[i].Current = parameters[i].Maximum;
break;
}
if (us.Momentum > 0)
{
Velocity[i] = -Velocity[i];
}
}
}
return(Job = job);
}
public ActionResult Edit(int id)
{
ParameterSetting parametersetting = db.ParameterSettings.Find(id);
return(View(parametersetting));
}
private static float RelativeDistance(ParameterSetting parameter, float ourValue, float otherValue)
{
return (otherValue - ourValue) / parameter.Size;
}
private void SaveEvaluation(ParameterSetting[] param, float value, double rmse, double mabs, double terror)
{
if ( this.Client != null )
{
var paramLength = param.Length;
float[] results = new float[paramLength + 4];
for ( int i = 0; i < paramLength; i++ )
{
results[i] = param[i].Current;
}
results[paramLength] = value;
results[paramLength + 1] = (float)rmse;
results[paramLength + 2] = (float)mabs;
results[paramLength + 3] = (float)terror;
this.Client.SendCustomMessage( results, this.ResultPort );
results = null;
}
bool exists = File.Exists( this.EvaluationFile );
using ( StreamWriter writer = new StreamWriter( this.EvaluationFile, true ) )
{
if ( !exists )
{
writer.Write( param[0].ParameterName );
for ( int i = 1; i < param.Length; i++ )
{
writer.Write( ',' );
writer.Write( param[i].ParameterName );
}
writer.Write( ',' );
writer.Write( "Value" );
writer.Write( ',' );
writer.Write( "rmse" );
writer.Write( ',' );
writer.Write( "mabs" );
writer.Write( ',' );
writer.WriteLine( "terror" );
}
if ( this.FirstRun && exists )
{
writer.WriteLine();
}
this.FirstRun = false;
writer.Write( param[0].Current );
for ( int i = 1; i < param.Length; i++ )
{
writer.Write( ',' );
writer.Write( param[i].Current );
}
writer.Write( ',' );
writer.Write( value );
writer.Write( ',' );
writer.Write( rmse );
writer.Write( ',' );
writer.Write( mabs );
writer.Write( ',' );
writer.WriteLine( terror );
}
}
public float ComplexErrorFunction(ParameterSetting[] parameters, Emme.TransitLine[] transitLine, Emme.TransitLine[] predicted, float[] aggToTruth)
{
throw new NotImplementedException();
}
private GenerationJob ReadJob(CsvReader reader, ParameterSetting[] parameters)
{
int columns;
while ( reader.LoadLine( out columns ) )
{
if ( columns >= parameters.Length + 2 )
{
var localParameters = CloneParameters( parameters );
var job = new Job()
{
ProcessedBy = null,
Processed = false,
Processing = false,
Parameters = localParameters
};
int generation;
reader.Get( out generation, 0 );
GenerationJob genJob = new GenerationJob( job, generation );
// we don't load the generation
reader.Get( out job.Value, 1 );
for ( int i = 0; i < localParameters.Length; i++ )
{
reader.Get( out localParameters[i].Current, i + 2 );
}
return genJob;
}
}
return null;
}
private void SetupInputFiles(ParameterSetting[] param)
{
/*
* t matrices
* m ms[MS:##] [NAME]
* all all: [VALUE]
*/
using ( StreamWriter writer = new StreamWriter( this.MacroInputFile ) )
{
writer.WriteLine( "t matrices" );
foreach ( var p in param )
{
writer.WriteLine( String.Format( "m ms{0} {1}", p.MSNumber, p.ParameterName ) );
writer.WriteLine( String.Format( " all all: {0}", p.Current ) );
}
}
}
public float ComputeError(ParameterSetting[] parameters, TransitLine[] truth, TransitLine[] predicted)
{
var first = this.FirstTally.ComputeError( parameters, truth, predicted );
var second = this.SecondTally.ComputeError( parameters, truth, predicted );
return ( first * FirstWeight ) + ( second * SecondWeight );
}
private void buttonConditions_Click(object sender, EventArgs e)
{
settings = new ParameterSetting(_db);
settings.ShowDialog();
}
private static ParameterSetting[] LoadBaseParameters(ParameterSetting[] parameters, CsvReader reader, int[] columnMap)
{
var baseParameters = new ParameterSetting[parameters.Length];
// we only read the first line
int columns;
if(reader.LoadLine(out columns))
{
var job = new Job()
{
ProcessedBy = null,
Processing = false,
Processed = false,
Value = float.NaN,
Parameters = baseParameters
};
for(int i = 0; i < parameters.Length; i++)
{
baseParameters[i] = new ParameterSetting()
{
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum
};
}
for(int i = 0; i < columnMap.Length; i++)
{
reader.Get(out baseParameters[columnMap[i]].Current, i + 2);
}
}
return baseParameters;
}
private float ProcessResults(ParameterSetting[] param)
{
TransitLines currentLines = new TransitLines( this.MacroOutputFile );
var predicted = currentLines.Lines;
var numberOfLines = predicted.Length;
double rmse = 0;
double mabs = 0;
double terror = 0;
float[] aggToTruth = new float[this.Truth.Length];
List<KeyValuePair<string, float>> Orphans = new List<KeyValuePair<string, float>>();
for ( int i = 0; i < numberOfLines; i++ )
{
int index = -1;
bool orphan = true;
for ( int j = 0; j < this.Truth.Length; j++ )
{
bool found = false;
foreach ( var line in predicted[i].ID )
{
if ( this.Truth[j].ID.Contains( line ) )
{
index = j;
found = true;
break;
}
}
if ( found )
{
orphan = false;
aggToTruth[j] += predicted[i].Bordings;
break;
}
}
if ( orphan )
{
Orphans.Add( new KeyValuePair<string, float>( predicted[i].ID[0], predicted[i].Bordings ) );
}
}
for ( int i = 0; i < this.Truth.Length; i++ )
{
var error = aggToTruth[i] - this.Truth[i].Bordings;
rmse += error * error;
mabs += Math.Abs( error );
terror += error;
}
var value = this.EstimationAI.UseComplexErrorFunction ? this.EstimationAI.ComplexErrorFunction( this.Parameters, this.Truth, predicted, aggToTruth ) : this.EstimationAI.ErrorCombinationFunction( rmse, mabs, terror );
if ( value < this.BestRunError )
{
SaveBordingData( aggToTruth, Orphans );
this.BestRunError = value;
}
SaveEvaluation( param, value, rmse, mabs, terror );
return value;
}
private ParameterSetting[] Clone(ParameterSetting[] parameters)
{
ParameterSetting[] ret = new ParameterSetting[parameters.Length];
for(int i = 0; i < parameters.Length; i++)
{
ret[i] = new ParameterSetting()
{
Current = parameters[i].Current,
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum,
NullHypothesis = parameters[i].NullHypothesis
};
}
return ret;
}
/// <summary>
/// 일자별 객실유금 폼 생성자 입니다.<see cref="DAHAH08"/> class.
/// </summary>
/// <param name="pSetting">The p setting.</param>
/// <remarks>
/// 리턴 값은 다음과 같습니다. [string 총요금] [string 금일요금] [bool 변경여부] [DataTable 일자별객실요금]
/// </remarks>
public DAHAH08(string ReturnFunctionName, ParameterSetting pSetting)
{
InitializeComponent();
pSettings = pSetting;
fnReturnFunctionName = ReturnFunctionName;
}
private Job CreateJob(ParameterSetting[] parameters)
{
return new Job()
{
Parameters = parameters,
Processed = false,
ProcessedBy = null,
Processing = false,
Value = float.NaN
};
}
private void LoadParameterFile()
{
XmlDocument doc = new XmlDocument();
doc.Load( this.ParameterFile.GetFilePath() );
List<ParameterSetting> parameters = new List<ParameterSetting>();
foreach ( XmlNode child in doc["Root"].ChildNodes )
{
if ( child.Name == "Parameter" )
{
ParameterSetting current = new ParameterSetting();
if ( child.HasChildNodes )
{
var nodes = child.ChildNodes;
current.Names = new string[nodes.Count];
for ( int i = 0; i < nodes.Count; i++ )
{
XmlNode name = nodes[i];
var parameterPath = name.Attributes["ParameterPath"].InnerText;
current.Names[i] = parameterPath;
}
}
else
{
var parameterPath = child.Attributes["ParameterPath"].InnerText;
current.Names = new string[] { parameterPath };
}
parameters.Add( current );
}
}
this.Parameters = parameters.ToArray();
}
public List<Job> CreateJobsForIteration()
{
var ret = new List<Job>();
var parameters = this.Root.Parameters.ToArray();
int totalParameters = parameters.Sum(p => p.Names.Length);
using ( CsvReader reader = new CsvReader( this.ResultFile.GetFilePath() ) )
{
reader.LoadLine();
int columns;
while ( reader.LoadLine( out columns ) )
{
//+2 for generation and value
if ( columns >= totalParameters + 2 )
{
var jobParameters = new ParameterSetting[parameters.Length];
var job = new Job()
{
ProcessedBy = null,
Processing = false,
Processed = false,
Value = float.NaN,
Parameters = jobParameters
};
var columnIndex = 2;
for ( int i = 0; i < parameters.Length; i++ )
{
jobParameters[i] = new ParameterSetting()
{
Names = parameters[i].Names,
Minimum = parameters[i].Minimum,
Maximum = parameters[i].Maximum
};
reader.Get( out jobParameters[i].Current, columnIndex );
columnIndex += parameters[i].Names.Length;
}
ret.Add( job );
if (NumberOfRows > 0 & ret.Count >= NumberOfRows)
{
break;
}
}
}
}
return ret;
}
