/// <inheritdoc/>
public Object Read(Stream mask0)
{
var result = new TrainingContinuation();
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("CONT") &&
section.SubSectionName.Equals("PARAMS"))
{
IDictionary <String, String> paras = section.ParseParams();
foreach (String key in paras.Keys)
{
if (key.Equals("type", StringComparison.InvariantCultureIgnoreCase))
{
result.TrainingType = paras[key];
}
else
{
double[] list = EncogFileSection
.ParseDoubleArray(paras, key);
result.Put(key, list);
}
}
}
}
return(result);
}
/// <inheritdoc/>
public Object Read(Stream mask0)
{
var result = new SupportVectorMachine();
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("SVM") &&
section.SubSectionName.Equals("PARAMS"))
{
IDictionary <String, String> paras = section.ParseParams();
EngineArray.PutAll(paras, result.Properties);
}
if (section.SectionName.Equals("SVM") &&
section.SubSectionName.Equals("SVM-PARAM"))
{
IDictionary <String, String> p = section.ParseParams();
result.InputCount = EncogFileSection.ParseInt(p,
PersistConst.InputCount);
result.Params.C = EncogFileSection.ParseDouble(p,
ParamC);
result.Params.cache_size = EncogFileSection.ParseDouble(
p, ParamCacheSize);
result.Params.coef0 = EncogFileSection.ParseDouble(p,
ParamCoef0);
result.Params.degree = EncogFileSection.ParseDouble(p,
ParamDegree);
result.Params.eps = EncogFileSection.ParseDouble(p,
ParamEps);
result.Params.gamma = EncogFileSection.ParseDouble(p,
ParamGamma);
result.Params.kernel_type = EncogFileSection.ParseInt(
p, ParamKernelType);
result.Params.nr_weight = EncogFileSection.ParseInt(
p, ParamNumWeight);
result.Params.nu = EncogFileSection.ParseDouble(p,
ParamNu);
result.Params.p = EncogFileSection.ParseDouble(p,
ParamP);
result.Params.probability = EncogFileSection.ParseInt(
p, ParamProbability);
result.Params.shrinking = EncogFileSection.ParseInt(
p, ParamShrinking);
/*result.Params.statIterations = Encog.Persist.EncogFileSection.ParseInt(
* params_0, PersistSVM.PARAM_START_ITERATIONS);*/
result.Params.svm_type = EncogFileSection.ParseInt(p,
ParamSVMType);
result.Params.weight = EncogFileSection.ParseDoubleArray(
p, ParamWeight);
result.Params.weight_label = EncogFileSection
.ParseIntArray(p, ParamWeightLabel);
}
else if (section.SectionName.Equals("SVM") &&
section.SubSectionName.Equals("SVM-MODEL"))
{
try
{
#if !SILVERLIGHT
var rdr = new StringReader(
section.LinesAsString);
TextReader br = rdr;
svm_model model = svm.svm_load_model(rdr);
result.Model = model;
br.Close();
rdr.Close();
#endif
}
catch (IOException ex)
{
throw new PersistError(ex);
}
}
}
return(result);
}
/// <summary>
/// Read an object.
/// </summary>
///
public Object Read(Stream mask0)
{
var result = new BasicNetwork();
var flat = new FlatNetwork();
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("BASIC") &&
section.SubSectionName.Equals("PARAMS"))
{
IDictionary <String, String> paras = section.ParseParams();
EngineArray.PutAll(paras, result.Properties);
}
if (section.SectionName.Equals("BASIC") &&
section.SubSectionName.Equals("NETWORK"))
{
IDictionary <String, String> p = section.ParseParams();
flat.BeginTraining = EncogFileSection.ParseInt(p,
BasicNetwork.TagBeginTraining);
flat.ConnectionLimit = EncogFileSection.ParseDouble(p,
BasicNetwork.TagConnectionLimit);
flat.ContextTargetOffset = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagContextTargetOffset);
flat.ContextTargetSize = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagContextTargetSize);
flat.EndTraining = EncogFileSection.ParseInt(p,
BasicNetwork.TagEndTraining);
flat.HasContext = EncogFileSection.ParseBoolean(p,
BasicNetwork.TagHasContext);
flat.InputCount = EncogFileSection.ParseInt(p,
PersistConst.InputCount);
flat.LayerCounts = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerCounts);
flat.LayerFeedCounts = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerFeedCounts);
flat.LayerContextCount = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagLayerContextCount);
flat.LayerIndex = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerIndex);
flat.LayerOutput = EncogFileSection.ParseDoubleArray(p,
PersistConst.Output);
flat.LayerSums = new double[flat.LayerOutput.Length];
flat.OutputCount = EncogFileSection.ParseInt(p,
PersistConst.OutputCount);
flat.WeightIndex = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagWeightIndex);
flat.Weights = EncogFileSection.ParseDoubleArray(p,
PersistConst.Weights);
flat.BiasActivation = EncogFileSection.ParseDoubleArray(
p, BasicNetwork.TagBiasActivation);
}
else if (section.SectionName.Equals("BASIC") &&
section.SubSectionName.Equals("ACTIVATION"))
{
int index = 0;
flat.ActivationFunctions = new IActivationFunction[flat.LayerCounts.Length];
foreach (String line in section.Lines)
{
IActivationFunction af;
IList <String> cols = EncogFileSection
.SplitColumns(line);
String name = ReflectionUtil.AfPath
+ cols[0];
try
{
af = (IActivationFunction)ReflectionUtil.LoadObject(name);
}
catch (TypeLoadException e)
{
throw new PersistError(e);
}
catch (TargetException e)
{
throw new PersistError(e);
}
catch (MemberAccessException e)
{
throw new PersistError(e);
}
for (int i = 0; i < af.ParamNames.Length; i++)
{
af.Params[i] =
CSVFormat.EgFormat.Parse(cols[i + 1]);
}
flat.ActivationFunctions[index++] = af;
}
}
}
result.Structure.Flat = flat;
return(result);
}
/// <summary>
/// Read an object.
/// </summary>
public Object Read(Stream mask0)
{
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
var samples = new BasicMLDataSet();
IDictionary <String, String> networkParams = null;
PNNKernelType kernel = default(PNNKernelType) /* was: null */;
PNNOutputMode outmodel = default(PNNOutputMode) /* was: null */;
int inputCount = 0;
int outputCount = 0;
double error = 0;
double[] sigma = null;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("PNN") &&
section.SubSectionName.Equals("PARAMS"))
{
networkParams = section.ParseParams();
}
if (section.SectionName.Equals("PNN") &&
section.SubSectionName.Equals("NETWORK"))
{
IDictionary <String, String> paras = section.ParseParams();
inputCount = EncogFileSection.ParseInt(paras,
PersistConst.InputCount);
outputCount = EncogFileSection.ParseInt(paras,
PersistConst.OutputCount);
kernel = StringToKernel(paras[PersistConst.Kernel]);
outmodel = StringToOutputMode(paras[PropertyOutputMode]);
error = EncogFileSection
.ParseDouble(paras, PersistConst.Error);
sigma = EncogFileSection.ParseDoubleArray(paras,
PersistConst.Sigma);
}
if (section.SectionName.Equals("PNN") &&
section.SubSectionName.Equals("SAMPLES"))
{
foreach (String line in section.Lines)
{
IList <String> cols = EncogFileSection
.SplitColumns(line);
int index = 0;
IMLData inputData = new BasicMLData(inputCount);
for (int i = 0; i < inputCount; i++)
{
inputData[i] =
CSVFormat.EgFormat.Parse(cols[index++]);
}
IMLData idealData = new BasicMLData(inputCount);
for (int i = 0; i < outputCount; i++)
{
idealData[i] =
CSVFormat.EgFormat.Parse(cols[index++]);
}
IMLDataPair pair = new BasicMLDataPair(inputData,
idealData);
samples.Add(pair);
}
}
}
var result = new BasicPNN(kernel, outmodel, inputCount,
outputCount);
if (networkParams != null)
{
EngineArray.PutAll(networkParams, result.Properties);
}
result.Samples = samples;
result.Error = error;
if (sigma != null)
{
EngineArray.ArrayCopy(sigma, result.Sigma);
}
return(result);
}