/// <summary>
/// Load the specified Encog object from an XML reader.
/// </summary>
/// <param name="xmlin">The XML reader to use.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlin)
{
String name = xmlin.LastTag.GetAttributeValue("name");
String description = xmlin.LastTag.GetAttributeValue("description");
TextData result = new TextData();
xmlin.ReadToTag();
String text = xmlin.LastTag.Name;
result.Name = name;
result.Description = description;
result.Text = text;
xmlin.ReadToTag();
return result;
}
/// <summary>
/// Load the specified Encog object from an XML reader.
/// </summary>
/// <param name="xmlIn">The XML reader to use.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlIn)
{
WeightedSynapse synapse = new WeightedSynapse();
String end = xmlIn.LastTag.Name;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(WeightedSynapsePersistor.TAG_WEIGHTS, true))
{
xmlIn.ReadToTag();
synapse.WeightMatrix = PersistorUtil.LoadMatrix(xmlIn);
}
if (xmlIn.IsIt(end, false))
{
break;
}
}
return synapse;
}
/// <summary>
/// Handle loading the items.
/// </summary>
/// <param name="xmlin">The XML input object.</param>
public void HandleItems(ReadXML xmlin)
{
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(TrainingContinuationPersistor.TAG_ITEM, true))
{
HandleItem(xmlin);
}
else if (xmlin.IsIt(TrainingContinuationPersistor.TAG_ITEM, false))
{
break;
}
}
}
/// <summary>
/// Handle the properties tag.
/// </summary>
/// <param name="xmlin">The XML reader.</param>
private void HandleProperties(ReadXML xmlin)
{
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(PropertyDataPersistor.TAG_PROPERTY, true))
{
HandleProperty(xmlin);
}
else if (xmlin.IsIt(PropertyDataPersistor.TAG_PROPERTIES, false))
{
break;
}
}
}
private void HandleTags(ReadXML inXML)
{
String end = inXML.LastTag.Name;
while (inXML.ReadToTag())
{
if (inXML.IsIt(BasicNetworkPersistor.TAG_TAG, true))
{
String name = inXML.LastTag.GetAttributeValue(
BasicNetworkPersistor.ATTRIBUTE_NAME);
String layerStr = inXML.LastTag.GetAttributeValue(
BasicNetworkPersistor.ATTRIBUTE_LAYER);
int layerInt = int.Parse(layerStr);
ILayer layer = this.index2layer[layerInt];
this.currentNetwork.TagLayer(name, layer);
inXML.ReadToTag();
}
if (inXML.IsIt(end, false))
{
break;
}
}
}
/// <summary>
/// Load the properties.
/// </summary>
/// <param name="xmlIn">The XML object.</param>
private void HandleProperties(ReadXML xmlIn)
{
String end = xmlIn.LastTag.Name;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(BasicNetworkPersistor.TAG_PROPERTY, true))
{
String name = xmlIn.LastTag.GetAttributeValue(
BasicNetworkPersistor.ATTRIBUTE_NAME);
String value = xmlIn.ReadTextToTag();
this.currentNetwork.SetProperty(name, value);
}
if (xmlIn.IsIt(end, false))
{
break;
}
}
}
/// <summary>
/// Load the specified Encog object from an XML reader.
/// </summary>
/// <param name="xmlIn">The XML reader to use.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlIn)
{
String name = xmlIn.LastTag.Attributes[EncogPersistedCollection.ATTRIBUTE_NAME];
String description = xmlIn.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_DESCRIPTION];
this.currentNetwork = new BasicNetwork();
this.currentNetwork.Name = name;
this.currentNetwork.Description = description;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(BasicNetworkPersistor.TAG_LAYERS, true))
{
HandleLayers(xmlIn);
}
else if (xmlIn.IsIt(BasicNetworkPersistor.TAG_SYNAPSES, true))
{
HandleSynapses(xmlIn);
}
else if (xmlIn.IsIt(BasicNetworkPersistor.TAG_PROPERTIES, true))
{
HandleProperties(xmlIn);
}
else if (xmlIn.IsIt(BasicNetworkPersistor.TAG_LOGIC, true))
{
HandleLogic(xmlIn);
}
else if (xmlIn.IsIt(BasicNetworkPersistor.TAG_TAGS, true))
{
HandleTags(xmlIn);
}
else if (xmlIn.IsIt(EncogPersistedCollection.TYPE_BASIC_NET, false))
{
break;
}
}
this.currentNetwork.Structure.FinalizeStructure();
return this.currentNetwork;
}
/// <summary>
/// Process any synapses that should be loaded.
/// </summary>
/// <param name="xmlIn">The XML reader.</param>
private void HandleSynapses(ReadXML xmlIn)
{
String end = xmlIn.LastTag.Name;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(BasicNetworkPersistor.TAG_SYNAPSE, true))
{
int from = xmlIn.LastTag.GetAttributeInt(
BasicNetworkPersistor.ATTRIBUTE_FROM);
int to = xmlIn.LastTag.GetAttributeInt(
BasicNetworkPersistor.ATTRIBUTE_TO);
xmlIn.ReadToTag();
IPersistor persistor = PersistorUtil.CreatePersistor(xmlIn
.LastTag.Name);
ISynapse synapse = (ISynapse)persistor.Load(xmlIn);
synapse.FromLayer = this.index2layer[from];
synapse.ToLayer = this.index2layer[to];
synapse.FromLayer.AddSynapse(synapse);
}
if (xmlIn.IsIt(end, false))
{
break;
}
}
}
/// <summary>
/// Handle any layers that should be loaded.
/// </summary>
/// <param name="xmlIn">The XML reader.</param>
private void HandleLayers(ReadXML xmlIn)
{
String end = xmlIn.LastTag.Name;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(BasicNetworkPersistor.TAG_LAYER, true))
{
int num = xmlIn.LastTag.GetAttributeInt(
BasicNetworkPersistor.ATTRIBUTE_ID);
String type = xmlIn.LastTag.GetAttributeValue(
BasicNetworkPersistor.ATTRIBUTE_TYPE);
xmlIn.ReadToTag();
IPersistor persistor = PersistorUtil.CreatePersistor(xmlIn
.LastTag.Name);
ILayer layer = (ILayer)persistor.Load(xmlIn);
this.index2layer[num] = layer;
// the type attribute is actually "legacy", but if its there
// then use it!
if (type != null)
{
if (type.Equals(BasicNetworkPersistor.ATTRIBUTE_TYPE_INPUT))
{
this.currentNetwork.TagLayer(BasicNetwork.TAG_INPUT,
layer);
}
else if (type
.Equals(BasicNetworkPersistor.ATTRIBUTE_TYPE_OUTPUT))
{
this.currentNetwork.TagLayer(BasicNetwork.TAG_OUTPUT,
layer);
}
else if (type
.Equals(BasicNetworkPersistor.ATTRIBUTE_TYPE_BOTH))
{
this.currentNetwork.TagLayer(BasicNetwork.TAG_INPUT,
layer);
this.currentNetwork.TagLayer(BasicNetwork.TAG_OUTPUT,
layer);
}
}
// end of legacy processing
}
if (xmlIn.IsIt(end, false))
{
break;
}
}
}
private IRadialBasisFunction[] LoadAllRBF(ReadXML xmlin)
{
IList<IRadialBasisFunction> rbfs = new List<IRadialBasisFunction>();
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(PROPERTY_RBF, false))
{
break;
}
else
{
String name = xmlin.LastTag.Name;
IRadialBasisFunction rbf = LoadRBF(name, xmlin);
rbfs.Add(rbf);
}
}
IRadialBasisFunction[] result = new IRadialBasisFunction[rbfs.Count];
for (int i = 0; i < rbfs.Count; i++)
result[i] = rbfs[i];
return result;
}
/// <summary>
/// Load the object.
/// </summary>
/// <param name="xmlin">The XML object to load from.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlin)
{
this.current = new TrainingContinuation();
String name = xmlin.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_NAME];
String description = xmlin.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_DESCRIPTION];
this.current.Name = name;
this.current.Description = description;
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(TrainingContinuationPersistor.TAG_ITEMS, true))
{
HandleItems(xmlin);
}
else if (xmlin.IsIt(
EncogPersistedCollection.TYPE_TRAINING_CONTINUATION, false))
{
break;
}
}
return this.current;
}
/// <summary>
/// Load the models.
/// </summary>
/// <param name="xmlin">Where to read the models from.</param>
/// <param name="network">Where the models are read into.</param>
private void HandleModels(ReadXML xmlin, SVMNetwork network)
{
int index = 0;
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODEL, true))
{
svm_parameter param = new svm_parameter();
svm_model model = new svm_model();
model.param = param;
network.Models[index] = model;
HandleModel(xmlin, network.Models[index]);
index++;
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODELS, false))
{
break;
}
}
}
/// <summary>
/// Load the SVM network.
/// </summary>
/// <param name="xmlin">Where to read it from.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlin)
{
SVMNetwork result = null;
int input = -1, output = -1;
String name = xmlin.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_NAME];
String description = xmlin.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_DESCRIPTION];
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(SVMNetworkPersistor.TAG_INPUT, true))
{
input = int.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_OUTPUT, true))
{
output = int.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODELS, true))
{
result = new SVMNetwork(input, output, false);
HandleModels(xmlin, result);
}
else if (xmlin.IsIt(EncogPersistedCollection.TYPE_SVM, false))
{
break;
}
}
result.Name = name;
result.Description = description;
return result;
}
/// <summary>
/// Load the specified Encog object from an XML reader.
/// </summary>
/// <param name="xmlIn">The XML reader to use.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlIn)
{
String name = xmlIn.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_NAME];
String description = xmlIn.LastTag.GetAttributeValue(
EncogPersistedCollection.ATTRIBUTE_DESCRIPTION);
this.currentDataSet = new BasicNeuralDataSet();
this.currentDataSet.Name = name;
this.currentDataSet.Description = description;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(BasicNeuralDataSetPersistor.TAG_ITEM, true))
{
HandleItem(xmlIn);
}
else if (xmlIn.IsIt(EncogPersistedCollection.TYPE_TRAINING, false))
{
break;
}
}
return this.currentDataSet;
}
/// <summary>
/// Perform a deep copy.
/// Silverlight version.
/// </summary>
/// <param name="oldObj">The old object.</param>
/// <returns>The new object.</returns>
static public IEncogPersistedObject DeepCopy(IEncogPersistedObject oldObj)
{
bool replacedName = false;
// encog objects won't save without a name
if (oldObj.Name == null)
{
replacedName = true;
oldObj.Name = "temp";
}
// now make the copy
MemoryStream mstream = new MemoryStream();
WriteXML xmlOut = new WriteXML(mstream);
IPersistor persistor = oldObj.CreatePersistor();
xmlOut.BeginDocument();
persistor.Save(oldObj, xmlOut);
xmlOut.EndDocument();
// now read it back
mstream.Position = 0;
ReadXML xmlIn = new ReadXML(mstream);
xmlIn.ReadToTag();
IEncogPersistedObject result = persistor.Load(xmlIn);
mstream.Close();
// put the name back to null if we changed it
if (replacedName)
{
oldObj.Name = null;
result.Name = null;
}
return result; }
/// <summary>
/// Load a RBF layer.
/// </summary>
/// <param name="xmlin">The XML to read from.</param>
/// <returns>The object that was loaded.</returns>
public IEncogPersistedObject Load(ReadXML xmlin)
{
int neuronCount = 0;
int x = 0;
int y = 0;
int dimensions = 1;
IRadialBasisFunction[] rbfs = new IRadialBasisFunction[0];
String end = xmlin.LastTag.Name;
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(BasicLayerPersistor.PROPERTY_NEURONS, true))
{
neuronCount = xmlin.ReadIntToTag();
}
else if (xmlin.IsIt(BasicLayerPersistor.PROPERTY_X, true))
{
x = xmlin.ReadIntToTag();
}
else if (xmlin.IsIt(BasicLayerPersistor.PROPERTY_Y, true))
{
y = xmlin.ReadIntToTag();
}
else if (xmlin.IsIt(RadialBasisFunctionLayerPersistor.PROPERTY_RBF,
true))
{
rbfs = LoadAllRBF(xmlin);
}
else if (xmlin.IsIt(end, false))
{
break;
}
}
RadialBasisFunctionLayer layer = new RadialBasisFunctionLayer(neuronCount);
layer.RadialBasisFunction = rbfs;
layer.X = x;
layer.Y = y;
return layer;
}
private IRadialBasisFunction LoadRBF(String name, ReadXML xmlin)
{
String clazz = ReflectionUtil.ResolveEncogClass(name);
if (clazz == null)
{
throw new NeuralNetworkError("Unknown RBF function type: " + name);
}
IRadialBasisFunction result = (IRadialBasisFunction)ReflectionUtil.LoadObject(clazz);
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(name, false))
{
break;
}
else if (xmlin.IsIt(PROPERTY_CENTERS, true))
{
String str = xmlin.ReadTextToTag();
double[] centers = NumberList.FromList(CSVFormat.EG_FORMAT, str);
result.Centers = centers;
}
else if (xmlin.IsIt(PROPERTY_PEAK, true))
{
String str = xmlin.ReadTextToTag();
double d = Double.Parse(str);
result.Peak = d;
}
else if (xmlin.IsIt(PROPERTY_WIDTH, true))
{
String str = xmlin.ReadTextToTag();
double d = Double.Parse(str);
result.Width = d;
}
}
return result;
}
/// <summary>
/// Load a matrix from the reader.
/// </summary>
/// <param name="xmlIn">The XML reader.</param>
/// <returns>The loaded matrix.</returns>
public static Matrix LoadMatrix(ReadXML xmlIn)
{
int rows = xmlIn.LastTag.GetAttributeInt(
PersistorUtil.ATTRIBUTE_MATRIX_ROWS);
int cols = xmlIn.LastTag.GetAttributeInt(
PersistorUtil.ATTRIBUTE_MATRIX_COLS);
Matrix matrix = new Matrix(rows, cols);
int row = 0;
String end = xmlIn.LastTag.Name;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(end, false))
{
break;
}
if (xmlIn.IsIt(PersistorUtil.ROW, true))
{
String str = xmlIn.ReadTextToTag();
double[] d = NumberList.FromList(CSVFormat.EG_FORMAT, str);
for (int col = 0; col < d.Length; col++)
{
matrix[row, col] = d[col];
}
row++;
}
}
return matrix;
}
/// <summary>
/// Load the specified Encog object from an XML reader.
/// </summary>
/// <param name="xmlIn">The XML reader to use.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlIn)
{
int neuronCount = 0;
int x = 0;
int y = 0;
double biasActivation = 1;
String threshold = null;
IActivationFunction activation = null;
String end = xmlIn.LastTag.Name;
String context = null;
while (xmlIn.ReadToTag())
{
if (xmlIn.IsIt(BasicLayerPersistor.TAG_ACTIVATION, true))
{
xmlIn.ReadToTag();
String type = xmlIn.LastTag.Name;
activation = BasicLayerPersistor.LoadActivation(type, xmlIn);
}
else if (xmlIn.IsIt(BasicLayerPersistor.PROPERTY_NEURONS, true))
{
neuronCount = xmlIn.ReadIntToTag();
}
else if (xmlIn.IsIt(BasicLayerPersistor.PROPERTY_X, true))
{
x = xmlIn.ReadIntToTag();
}
else if (xmlIn.IsIt(BasicLayerPersistor.PROPERTY_Y, true))
{
y = xmlIn.ReadIntToTag();
}
else if (xmlIn.IsIt(BasicLayerPersistor.PROPERTY_THRESHOLD, true))
{
threshold = xmlIn.ReadTextToTag();
}
else if (xmlIn.IsIt(PROPERTY_CONTEXT, true))
{
context = xmlIn.ReadTextToTag();
}
else if (xmlIn.IsIt(BasicLayerPersistor.PROPERTY_BIAS_ACTIVATION, true))
{
biasActivation = double.Parse(xmlIn.ReadTextToTag());
}
else if (xmlIn.IsIt(end, false))
{
break;
}
}
if (neuronCount > 0)
{
ContextLayer layer;
if (threshold == null)
{
layer = new ContextLayer(activation, false, neuronCount);
}
else
{
double[] t = NumberList.FromList(CSVFormat.EG_FORMAT, threshold);
layer = new ContextLayer(activation, true, neuronCount);
for (int i = 0; i < t.Length; i++)
{
layer.BiasWeights[i] = t[i];
}
}
if (context != null)
{
double[] c = NumberList.FromList(CSVFormat.EG_FORMAT, context);
for (int i = 0; i < c.Length; i++)
{
layer.Context[i] = c[i];
}
}
layer.X = x;
layer.Y = y;
layer.BiasActivation = biasActivation;
return layer;
}
return null;
}
/// <summary>
/// Load the specified Encog object from an XML reader.
/// </summary>
/// <param name="xmlin">The XML reader to use.</param>
/// <returns>The loaded object.</returns>
public IEncogPersistedObject Load(ReadXML xmlin)
{
String name = xmlin.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_NAME];
String description = xmlin.LastTag.Attributes[
EncogPersistedCollection.ATTRIBUTE_DESCRIPTION];
this.propertyData = new PropertyData();
this.propertyData.Name = name;
this.propertyData.Description = description;
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(PropertyDataPersistor.TAG_PROPERTIES, true))
{
HandleProperties(xmlin);
}
else if (xmlin.IsIt(EncogPersistedCollection.TYPE_PROPERTY, false))
{
break;
}
}
return this.propertyData;
}
/// <summary>
/// Handle a model.
/// </summary>
/// <param name="xmlin">Where to read the model from.</param>
/// <param name="model">Where to load the model into.</param>
private void HandleModel(ReadXML xmlin, svm_model model)
{
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(SVMNetworkPersistor.TAG_TYPE_SVM, true))
{
int i = EngineArray.FindStringInArray(
SVMNetworkPersistor.svm_type_table, xmlin.ReadTextToTag());
model.param.svm_type = i;
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_DEGREE, true))
{
model.param.degree = int.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_GAMMA, true))
{
model.param.gamma = double.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_COEF0, true))
{
model.param.coef0 = double.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_NUMCLASS, true))
{
model.nr_class = int.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_TOTALSV, true))
{
model.l = int.Parse(xmlin.ReadTextToTag());
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_RHO, true))
{
int n = model.nr_class * (model.nr_class - 1) / 2;
model.rho = new double[n];
String[] st = xmlin.ReadTextToTag().Split(',');
for (int i = 0; i < n; i++)
model.rho[i] = double.Parse(st[i]);
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_LABEL, true))
{
int n = model.nr_class;
model.label = new int[n];
String[] st = xmlin.ReadTextToTag().Split(',');
for (int i = 0; i < n; i++)
model.label[i] = int.Parse(st[i]);
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_PROB_A, true))
{
int n = model.nr_class * (model.nr_class - 1) / 2;
model.probA = new double[n];
String[] st = xmlin.ReadTextToTag().Split(',');
for (int i = 0; i < n; i++)
model.probA[i] = Double.Parse(st[i]);
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_PROB_B, true))
{
int n = model.nr_class * (model.nr_class - 1) / 2;
model.probB = new double[n];
String[] st = xmlin.ReadTextToTag().Split(',');
for (int i = 0; i < n; i++)
model.probB[i] = Double.Parse(st[i]);
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_NSV, true))
{
int n = model.nr_class;
model.nSV = new int[n];
String[] st = xmlin.ReadTextToTag().Split(',');
for (int i = 0; i < n; i++)
model.nSV[i] = int.Parse(st[i]);
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_TYPE_KERNEL, true))
{
int i = EngineArray.FindStringInArray(
SVMNetworkPersistor.kernel_type_table, xmlin
.ReadTextToTag());
model.param.kernel_type = i;
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_DATA, true))
{
HandleData(xmlin, model);
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODEL, false))
{
break;
}
}
}
/// <summary>
/// Load the data from a model.
/// </summary>
/// <param name="xmlin">Where to read the data from.</param>
/// <param name="model">The model to load data into.</param>
private void HandleData(ReadXML xmlin, svm_model model)
{
int i = 0;
int m = model.nr_class - 1;
int l = model.l;
model.sv_coef = EngineArray.AllocateDouble2D(m, l);
model.SV = new svm_node[l][];
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(SVMNetworkPersistor.TAG_ROW, true))
{
String line = xmlin.ReadTextToTag();
String[] st = xmlin.ReadTextToTag().Split(',');
for (int k = 0; k < m; k++)
model.sv_coef[k][i] = Double.Parse(st[i]);
int n = st.Length / 2;
model.SV[i] = new svm_node[n];
int idx = 0;
for (int j = 0; j < n; j++)
{
model.SV[i][j] = new svm_node();
model.SV[i][j].index = int.Parse(st[idx++]);
model.SV[i][j].value_Renamed = Double.Parse(st[idx++]);
}
i++;
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_DATA, false))
{
break;
}
}
}