/// <summary>
/// Convert a file format to a string.
/// </summary>
///
/// <param name="af">The file format.</param>
/// <returns>A string.</returns>
public static String AnalystFileFormat2String(AnalystFileFormat af)
{
if (af == AnalystFileFormat.DecpntComma)
{
return "decpnt|comma";
}
if (af == AnalystFileFormat.DecpntSpace)
{
return "decpnt|space";
}
if (af == AnalystFileFormat.DecpntSemi)
{
return "decpnt|semi";
}
if (af == AnalystFileFormat.DeccommaSpace)
{
return "deccomma|space";
}
if (af == AnalystFileFormat.DeccommaSemi)
{
return "deccomma|semi";
}
return null;
}
/// <summary>
/// Convert a file format to a string.
/// </summary>
///
/// <param name="af">The file format.</param>
/// <returns>A string.</returns>
public static String AnalystFileFormat2String(AnalystFileFormat af)
{
if (af == AnalystFileFormat.DecpntComma)
{
return("decpnt|comma");
}
if (af == AnalystFileFormat.DecpntSpace)
{
return("decpnt|space");
}
if (af == AnalystFileFormat.DecpntSemi)
{
return("decpnt|semi");
}
if (af == AnalystFileFormat.DeccommaSpace)
{
return("deccomma|space");
}
if (af == AnalystFileFormat.DeccommaSemi)
{
return("deccomma|semi");
}
return(null);
}
private void ConvertEGB2CSV()
{
if (_cmd.Args.Count != 2)
{
Console.WriteLine(@"Must specify a source and target.");
return;
}
String sourceFile = _cmd.Args[0];
String targetFile = _cmd.Args[1];
AnalystFileFormat format1 =
ConvertStringConst.String2AnalystFileFormat(_cmd.PromptString("format", "decpnt|comma"));
CSVFormat format = ConvertStringConst.ConvertToCSVFormat(format1);
new FileInfo(targetFile).Delete();
IDataSetCODEC codec = new CSVDataCODEC(targetFile, format, false);
var loader = new BinaryDataLoader(codec)
{
Status = new ConsoleStatusReportable()
};
_sw.Start();
loader.Binary2External(sourceFile);
}
/// <summary>
/// Analyze a file.
/// </summary>
///
/// <param name="analyzeFile">The file to analyze.</param>
/// <param name="b">True if there are headers.</param>
/// <param name="format">The file format.</param>
public void Wizard(FileInfo analyzeFile, bool b,
AnalystFileFormat format)
{
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceFormat, format);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceHeaders, b);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile, analyzeFile);
_timeSeries = ((_lagWindowSize > 0) || (_leadWindowSize > 0));
DetermineClassification();
GenerateFilenames(analyzeFile);
GenerateSettings();
_analyst.Analyze(analyzeFile, b, format);
GenerateNormalizedFields();
GenerateSegregate();
GenerateGenerate();
GenerateTasks();
if (_timeSeries && (_lagWindowSize > 0) &&
(_leadWindowSize > 0))
{
ExpandTimeSlices();
}
}
/// <summary>
/// Convert an analyst format to a csv format.
/// </summary>
///
/// <param name="af">The analyst format.</param>
/// <returns>The CSV format.</returns>
public static CSVFormat ConvertToCSVFormat(AnalystFileFormat af)
{
if (af == AnalystFileFormat.DecpntComma)
{
return(new CSVFormat('.', ','));
}
else if (af == AnalystFileFormat.DecpntSpace)
{
return(new CSVFormat('.', ' '));
}
else if (af == AnalystFileFormat.DecpntSemi)
{
return(new CSVFormat('.', ';'));
}
else if (af == AnalystFileFormat.DeccommaSpace)
{
return(new CSVFormat(',', ' '));
}
else if (af == AnalystFileFormat.DeccommaSemi)
{
return(new CSVFormat(',', ';'));
}
else
{
return(null);
}
}
public static CSVFormat ConvertToCSVFormat(AnalystFileFormat af)
{
if (af != AnalystFileFormat.DecpntComma)
{
if (af == AnalystFileFormat.DecpntSpace)
{
return new CSVFormat('.', ' ');
}
if (af != AnalystFileFormat.DecpntSemi)
{
if (af != AnalystFileFormat.DeccommaSpace)
{
if (af == AnalystFileFormat.DeccommaSemi)
{
return new CSVFormat(',', ';');
}
if (0 == 0)
{
}
return null;
}
}
else if (0 == 0)
{
return new CSVFormat('.', ';');
}
}
else
{
return new CSVFormat('.', ',');
}
return new CSVFormat(',', ' ');
}
public PerformAnalysis(AnalystScript theScript, string theFilename, bool theHeaders, AnalystFileFormat theFormat)
{
this._xb41a802ca5fde63b = theFilename;
this._x94e6ca5ac178dbd0 = theHeaders;
this._x5786461d089b10a0 = theFormat;
this._x594135906c55045c = theScript;
}
private void ConvertCSV2EGB()
{
if (_cmd.Args.Count != 2)
{
Console.WriteLine(@"Must specify a source and target.");
return;
}
String sourceFile = _cmd.Args[0];
String targetFile = _cmd.Args[1];
bool headers = _cmd.PromptBoolean("headers", true);
int inputCount = _cmd.PromptInteger("inputCount", 0);
int outputCount = _cmd.PromptInteger("outputCount", 0);
if (inputCount == 0)
{
Console.WriteLine(@"Must specify an input count.");
return;
}
AnalystFileFormat format1 =
ConvertStringConst.String2AnalystFileFormat(_cmd.PromptString("format", "decpnt|comma"));
CSVFormat format = ConvertStringConst.ConvertToCSVFormat(format1);
new FileInfo(targetFile).Delete();
IDataSetCODEC codec = new CSVDataCODEC(sourceFile, format, headers,
inputCount, outputCount, false);
var loader = new BinaryDataLoader(codec)
{
Status = new ConsoleStatusReportable()
};
_sw.Start();
loader.External2Binary(targetFile);
}
/// <summary>
/// Get a property as a format.
/// </summary>
/// <param name="name">The property name.</param>
/// <returns>A format value.</returns>
public CSVFormat GetPropertyCSVFormat(String name)
{
String v = _data[name];
AnalystFileFormat code = ConvertStringConst
.String2AnalystFileFormat(v);
return(ConvertStringConst.ConvertToCSVFormat(code));
}
/// <summary>
/// Construct the analysis object.
/// </summary>
/// <param name="theScript">The script to use.</param>
/// <param name="theFilename">The name of the file to analyze.</param>
/// <param name="theHeaders">True if headers are present.</param>
/// <param name="theFormat">The format of the file being analyzed.</param>
public PerformAnalysis(AnalystScript theScript,
String theFilename, bool theHeaders,
AnalystFileFormat theFormat)
{
_filename = theFilename;
_headers = theHeaders;
_format = theFormat;
_script = theScript;
}
/// <summary>
/// Construct the analysis object.
/// </summary>
/// <param name="theScript">The script to use.</param>
/// <param name="theFilename">The name of the file to analyze.</param>
/// <param name="theHeaders">True if headers are present.</param>
/// <param name="theFormat">The format of the file being analyzed.</param>
public PerformAnalysis(AnalystScript theScript,
String theFilename, bool theHeaders,
AnalystFileFormat theFormat)
{
_filename = theFilename;
_headers = theHeaders;
_format = theFormat;
_script = theScript;
}
/// <summary>
/// Analyze the specified file. Used by the wizard.
/// </summary>
/// <param name="file">The file to analyze.</param>
/// <param name="headers">True if headers are present.</param>
/// <param name="format">The format of the file.</param>
public void Analyze(FileInfo file, bool headers,
AnalystFileFormat format)
{
_script.Properties.SetFilename(AnalystWizard.FileRaw,
file.ToString());
_script.Properties.SetProperty(
ScriptProperties.SetupConfigInputHeaders, headers);
var a = new PerformAnalysis(_script,
file.ToString(), headers, format);
a.Process(this);
}
public static string AnalystFileFormat2String(AnalystFileFormat af)
{
if (af != AnalystFileFormat.DecpntComma)
{
if (af == AnalystFileFormat.DecpntSpace)
{
return "decpnt|space";
}
if (af == AnalystFileFormat.DecpntSemi)
{
return "decpnt|semi";
}
goto Label_001B;
}
if (8 != 0)
{
goto Label_003E;
}
Label_000A:
if (af != AnalystFileFormat.DeccommaSemi)
{
return null;
}
Label_000E:
if (4 != 0)
{
return "deccomma|semi";
}
Label_001B:
if (af == AnalystFileFormat.DeccommaSpace)
{
return "deccomma|space";
}
if (0 == 0)
{
goto Label_000A;
}
Label_003E:
if (3 == 0)
{
goto Label_000E;
}
return "decpnt|comma";
}
private void EvaluateCommand()
{
String methodFile = _cmd.Args[0];
String trainingFile = _cmd.Args[1];
String outputFile = _cmd.Args[2];
var method = (IMLRegression)EncogDirectoryPersistence.LoadObject(new FileInfo(methodFile));
bool headers = _cmd.PromptBoolean("headers", true);
AnalystFileFormat format1 =
ConvertStringConst.String2AnalystFileFormat(_cmd.PromptString("format", "decpnt|comma"));
CSVFormat format = ConvertStringConst.ConvertToCSVFormat(format1);
var e = new EvaluateRawCSV {
Report = new ConsoleStatusReportable()
};
e.Analyze(method, new FileInfo(trainingFile), headers, format);
e.Process(new FileInfo(outputFile), method);
Console.WriteLine(@"Done evaluating file.");
}
/// <summary>
/// Analyze a file at the specified URL.
/// </summary>
///
/// <param name="url">The URL to analyze.</param>
/// <param name="saveFile">The save file.</param>
/// <param name="analyzeFile">The Encog analyst file.</param>
/// <param name="b">True if there are headers.</param>
/// <param name="format">The file format.</param>
public void Wizard(Uri url, FileInfo saveFile,
FileInfo analyzeFile, bool b,
AnalystFileFormat format)
{
_script.BasePath = saveFile.DirectoryName;
_format = format;
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceFile, url);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceHeaders, b);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile, analyzeFile);
GenerateFilenames(analyzeFile);
GenerateSettings();
_analyst.Download();
Wizard(analyzeFile, b, format);
}
public void SetProperty(string name, AnalystFileFormat format)
{
this._x4a3f0a05c02f235f[name] = ConvertStringConst.AnalystFileFormat2String(format);
}
/// <summary>
/// Analyze a file.
/// </summary>
/// <param name="analyzeFile">The file to analyze.</param>
/// <param name="b">True if there are headers.</param>
/// <param name="format">The file format.</param>
public void Wizard(FileInfo analyzeFile, bool b,
AnalystFileFormat format)
{
_script.BasePath = analyzeFile.DirectoryName;
_format = format;
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceHeaders, b);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile, analyzeFile);
_timeSeries = ((_lagWindowSize > 0) || (_leadWindowSize > 0));
DetermineClassification();
GenerateFilenames(analyzeFile);
GenerateSettings();
_analyst.Analyze(analyzeFile, b, format);
GenerateNormalizedFields();
GenerateSegregate();
GenerateGenerate();
GenerateTasks();
if (_timeSeries && (_lagWindowSize > 0)
&& (_leadWindowSize > 0))
{
ExpandTimeSlices();
}
}
/// <summary>
/// Analyze the specified file. Used by the wizard.
/// </summary>
///
/// <param name="file">The file to analyze.</param>
/// <param name="headers">True if headers are present.</param>
/// <param name="format">The format of the file.</param>
public void Analyze(FileInfo file, bool headers,
AnalystFileFormat format)
{
_script.Properties.SetFilename(AnalystWizard.FileRaw,
file.ToString());
_script.Properties.SetProperty(
ScriptProperties.SetupConfigInputHeaders, headers);
var a = new PerformAnalysis(_script,
file.ToString(), headers, format);
a.Process(this);
}
private void WizardCommand()
{
String targetCSVFile = _cmd.Args[0];
String egaFile = FileUtil.ForceExtension(targetCSVFile, "ega");
var analyst = new EncogAnalyst();
var wizard = new AnalystWizard(analyst);
bool headers = _cmd.PromptBoolean("headers", true);
AnalystFileFormat format =
ConvertStringConst.String2AnalystFileFormat(_cmd.PromptString("format", "decpnt|comma"));
String goal = _cmd.PromptString("goal", "c").ToLower().Trim();
if (goal.Equals("c"))
{
wizard.Goal = AnalystGoal.Classification;
}
else if (goal.Equals("r"))
{
wizard.Goal = AnalystGoal.Regression;
}
else
{
Console.WriteLine(@"Invalid goal: " + goal);
return;
}
wizard.TargetFieldName = _cmd.PromptString("targetField", "");
String m = _cmd.PromptString("method", "ff").ToLower();
if (m.Equals("ff"))
{
wizard.MethodType = WizardMethodType.FeedForward;
}
else if (m.Equals("neat"))
{
wizard.MethodType = WizardMethodType.NEAT;
}
else if (m.Equals("pnn"))
{
wizard.MethodType = WizardMethodType.PNN;
}
else if (m.Equals("rbf"))
{
wizard.MethodType = WizardMethodType.RBF;
}
else if (m.Equals("som"))
{
wizard.MethodType = WizardMethodType.SOM;
}
else if (m.Equals("svm"))
{
wizard.MethodType = WizardMethodType.SVM;
}
else
{
Console.WriteLine(@"Invalid method: " + m);
return;
}
String r = _cmd.PromptString("range", "-1t1").Trim().ToLower();
if (r.Equals("-1t1"))
{
wizard.Range = NormalizeRange.NegOne2One;
}
else if (r.Equals("0t1"))
{
wizard.Range = NormalizeRange.Zero2One;
}
wizard.Missing = TranslateMissing(_cmd.PromptString("missing", "DiscardMissing"));
wizard.LagWindowSize = _cmd.PromptInteger("lagWindow", 0);
wizard.LeadWindowSize = _cmd.PromptInteger("leadWindow", 0);
wizard.IncludeTargetField = _cmd.PromptBoolean("includeTarget", false);
wizard.TaskNormalize = _cmd.PromptBoolean("normalize", true);
wizard.TaskRandomize = _cmd.PromptBoolean("randomize", true);
wizard.TaskSegregate = _cmd.PromptBoolean("segregate", true);
wizard.TaskBalance = _cmd.PromptBoolean("balance", false);
wizard.TaskCluster = _cmd.PromptBoolean("cluster", false);
_sw.Start();
Console.WriteLine(@"Analyzing data");
wizard.Wizard(new FileInfo(targetCSVFile), headers, format);
Console.WriteLine(@"Saving analyst file");
analyst.Save(egaFile);
}
/// <summary>
/// Analyze a file at the specified URL.
/// </summary>
/// <param name="url">The URL to analyze.</param>
/// <param name="saveFile">The save file.</param>
/// <param name="analyzeFile">The Encog analyst file.</param>
/// <param name="b">True if there are headers.</param>
/// <param name="format">The file format.</param>
public void Wizard(Uri url, FileInfo saveFile,
FileInfo analyzeFile, bool b,
AnalystFileFormat format)
{
_script.BasePath = saveFile.DirectoryName;
_format = format;
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceFile, url);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceHeaders, b);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile, analyzeFile);
GenerateFilenames(analyzeFile);
GenerateSettings();
_analyst.Download();
Wizard(analyzeFile, b, format);
}
public void WizardRealTime(IList<SourceElement> sourceData, FileInfo csvFile,
int backwardWindow, int forwardWindow, PredictionType prediction,
String predictField)
{
Preprocess = true;
_script.BasePath = csvFile.DirectoryName;
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceHeaders, true);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile, csvFile);
_script.Properties.SetProperty(
ScriptProperties.SetupConfigInputHeaders, true);
LagWindowSize = backwardWindow;
LeadWindowSize = 1;
_timeSeries = true;
_format = AnalystFileFormat.DecpntComma;
MethodType = WizardMethodType.FeedForward;
_includeTargetField = false;
TargetFieldName = "prediction";
Missing = new DiscardMissing();
Goal = AnalystGoal.Regression;
Range = NormalizeRange.NegOne2One;
TaskNormalize = true;
TaskRandomize = false;
TaskSegregate = true;
TaskBalance = false;
TaskCluster = false;
MaxError = 0.05;
CodeEmbedData = true;
DetermineClassification();
GenerateFilenames(csvFile);
GenerateSettings();
GenerateSourceData(sourceData);
GenerateNormalizedFields();
// if there is a time field, then ignore it
AnalystField timeField = _script.FindAnalystField("time");
if (timeField != null)
{
timeField.Action = NormalizationAction.Ignore;
}
GenerateSegregate();
GenerateGenerate();
GenerateProcess(backwardWindow, forwardWindow, prediction, predictField);
GenerateCode();
// override raw_file to be the processed file
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile,
FilePre);
GenerateTasks();
if (_timeSeries && (_lagWindowSize > 0)
&& (_leadWindowSize > 0))
{
ExpandTimeSlices();
}
}
public void Analyze(FileInfo file, bool headers, AnalystFileFormat format)
{
this._x594135906c55045c.Properties.SetFilename("FILE_RAW", file.ToString());
this._x594135906c55045c.Properties.SetProperty("SETUP:CONFIG_inputHeaders", headers);
new PerformAnalysis(this._x594135906c55045c, file.ToString(), headers, format).Process(this);
}
/// <summary>
/// Set the property to a format.
/// </summary>
/// <param name="name">The name of the property.</param>
/// <param name="format">The value of the property.</param>
public void SetProperty(String name,
AnalystFileFormat format)
{
_data[name] = ConvertStringConst.AnalystFileFormat2String(format);
}
public void Wizard(Uri url, FileInfo saveFile, FileInfo analyzeFile, bool b, AnalystFileFormat format)
{
this._x594135906c55045c.BasePath = saveFile.DirectoryName;
while (true)
{
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_sourceFile", url);
if (((uint) b) >= 0)
{
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_sourceFormat", format);
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_sourceHeaders", b);
}
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_rawFile", analyzeFile);
this.xf6e1c35864db42aa(analyzeFile);
this.xdd8dc65aef162a86();
this._x554f16462d8d4675.Download();
this.Wizard(analyzeFile, b, format);
if (0 == 0)
{
return;
}
}
}
public void Wizard(FileInfo analyzeFile, bool b, AnalystFileFormat format)
{
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_sourceFormat", format);
if (0 == 0)
{
goto Label_00E4;
}
Label_0039:
if (this._x654428e3563552e3 <= 0)
{
return;
}
if (this._xb6540cd895237850 <= 0)
{
if (0 == 0)
{
return;
}
}
else
{
this.xfd33c8a1cd5c5a19();
if ((((uint) b) | 8) != 0)
{
return;
}
}
goto Label_0039;
Label_00E4:
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_sourceHeaders", b);
this._x594135906c55045c.Properties.SetProperty("HEADER:DATASOURCE_rawFile", analyzeFile);
if (0 == 0)
{
this._x02283b983d652139 = (this._x654428e3563552e3 > 0) || (this._xb6540cd895237850 > 0);
this.xf1bed93d6f997005();
if ((((uint) b) - ((uint) b)) > uint.MaxValue)
{
goto Label_0039;
}
if ((((uint) b) + ((uint) b)) <= uint.MaxValue)
{
this.xf6e1c35864db42aa(analyzeFile);
}
this.xdd8dc65aef162a86();
this._x554f16462d8d4675.Analyze(analyzeFile, b, format);
}
Label_008D:
this.xa39295d07e81cd8c();
this.x457a4b5397851b17();
this.x0b3092feb6dc609a();
this.x8623f9a426a3d24c();
if (!this._x02283b983d652139)
{
return;
}
if ((((uint) b) + ((uint) b)) >= 0)
{
if ((15 != 0) && ((((uint) b) + ((uint) b)) < 0))
{
goto Label_008D;
}
goto Label_0039;
}
goto Label_00E4;
}
/// <summary>
/// Set the property to a format.
/// </summary>
/// <param name="name">The name of the property.</param>
/// <param name="format">The value of the property.</param>
public void SetProperty(String name,
AnalystFileFormat format)
{
_data[name] = ConvertStringConst.AnalystFileFormat2String(format);
}
/// <summary>
/// Analyze a file.
/// </summary>
///
/// <param name="analyzeFile">The file to analyze.</param>
/// <param name="useheader">True if there are headers.</param>
/// <param name="format">The file format.</param>
public void Wizard(FileInfo analyzeFile, bool useheader,
AnalystFileFormat format)
{
Encog.EncogFramework.Instance.LoggingPlugin.Log(
EncogLogging.LogLevel.Info,
string.Format(
"Starting analyst Wizard with analyst file:{0} Headers :{1} Analyst format : {2}",
analyzeFile.Name,
useheader,
format));
_script.BasePath = analyzeFile.DirectoryName;
_format = format;
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceSourceHeaders, useheader);
_script.Properties.SetProperty(
ScriptProperties.HeaderDatasourceRawFile, analyzeFile);
_timeSeries = ((_lagWindowSize > 0) || (_leadWindowSize > 0));
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Determining Classification");
DetermineClassification();
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating filenames");
GenerateFilenames(analyzeFile);
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating settings");
GenerateSettings();
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Starting analysis");
_analyst.Analyze(analyzeFile, useheader, format);
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating normalized fields");
GenerateNormalizedFields();
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating Segregate");
GenerateSegregate();
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating finalization.");
GenerateGenerate();
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating all tasks");
GenerateTasks();
if (_timeSeries && (_lagWindowSize > 0) && (_leadWindowSize > 0))
{
Encog.EncogFramework.Instance.LoggingPlugin.Log(EncogLogging.LogLevel.Debug, "Next:Generating Timeslices");
ExpandTimeSlices();
}
}
