/// <summary>
/// Create a SOM.
/// </summary>
///
/// <param name="architecture">The architecture string.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The newly created SOM.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
IList <String> layers = ArchitectureParse.ParseLayers(architecture);
if (layers.Count != 2)
{
throw new EncogError(
"SOM's must have exactly two elements, separated by ->.");
}
ArchitectureLayer inputLayer = ArchitectureParse.ParseLayer(
layers[0], input);
ArchitectureLayer outputLayer = ArchitectureParse.ParseLayer(
layers[1], output);
int inputCount = inputLayer.Count;
int outputCount = outputLayer.Count;
var pattern = new SOMPattern {
InputNeurons = inputCount, OutputNeurons = outputCount
};
return(pattern.Generate());
}
/// <summary>
/// Create a RBF network.
/// </summary>
///
/// <param name="architecture">THe architecture string to use.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The RBF network.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
IList <String> layers = ArchitectureParse.ParseLayers(architecture);
if (layers.Count != MaxLayers)
{
throw new EncogError(
"RBF Networks must have exactly three elements, "
+ "separated by ->.");
}
ArchitectureLayer inputLayer = ArchitectureParse.ParseLayer(
layers[0], input);
ArchitectureLayer rbfLayer = ArchitectureParse.ParseLayer(
layers[1], -1);
ArchitectureLayer outputLayer = ArchitectureParse.ParseLayer(
layers[2], output);
int inputCount = inputLayer.Count;
int outputCount = outputLayer.Count;
RBFEnum t;
if (rbfLayer.Name.Equals("Gaussian", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.Gaussian;
}
else if (rbfLayer.Name.Equals("Multiquadric", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.Multiquadric;
}
else if (rbfLayer.Name.Equals("InverseMultiquadric", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.InverseMultiquadric;
}
else if (rbfLayer.Name.Equals("MexicanHat", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.MexicanHat;
}
else
{
throw new NeuralNetworkError("Unknown RBF: " + rbfLayer.Name);
}
var holder = new ParamsHolder(rbfLayer.Params);
int rbfCount = holder.GetInt("C", true, 0);
var result = new RBFNetwork(inputCount, rbfCount,
outputCount, t);
return(result);
}
/// <summary>
/// Create a feed forward network.
/// </summary>
///
/// <param name="architecture">The architecture string to use.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The feedforward network.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
var result = new BasicNetwork();
IList <String> layers = ArchitectureParse.ParseLayers(architecture);
IActivationFunction af = new ActivationLinear();
int questionPhase = 0;
foreach (String layerStr in layers)
{
// determine default
int defaultCount = questionPhase == 0 ? input : output;
ArchitectureLayer layer = ArchitectureParse.ParseLayer(
layerStr, defaultCount);
bool bias = layer.Bias;
String part = layer.Name;
part = part != null?part.Trim() : "";
IActivationFunction lookup = _factory.Create(part);
if (lookup != null)
{
af = lookup;
}
else
{
if (layer.UsedDefault)
{
questionPhase++;
if (questionPhase > 2)
{
throw new EncogError("Only two ?'s may be used.");
}
}
if (layer.Count == 0)
{
throw new EncogError("Unknown architecture element: "
+ architecture + ", can't parse: " + part);
}
result.AddLayer(new BasicLayer(af, bias, layer.Count));
}
}
result.Structure.FinalizeStructure();
result.Reset();
return(result);
}
/// <summary>
/// Create a PNN network.
/// </summary>
///
/// <param name="architecture">THe architecture string to use.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The RBF network.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
IList <String> layers = ArchitectureParse.ParseLayers(architecture);
if (layers.Count != MaxLayers)
{
throw new EncogError(
"PNN Networks must have exactly three elements, "
+ "separated by ->.");
}
ArchitectureLayer inputLayer = ArchitectureParse.ParseLayer(
layers[0], input);
ArchitectureLayer pnnLayer = ArchitectureParse.ParseLayer(
layers[1], -1);
ArchitectureLayer outputLayer = ArchitectureParse.ParseLayer(
layers[2], output);
int inputCount = inputLayer.Count;
int outputCount = outputLayer.Count;
PNNKernelType kernel;
PNNOutputMode outmodel;
if (pnnLayer.Name.Equals("c", StringComparison.InvariantCultureIgnoreCase))
{
outmodel = PNNOutputMode.Classification;
}
else if (pnnLayer.Name.Equals("r", StringComparison.InvariantCultureIgnoreCase))
{
outmodel = PNNOutputMode.Regression;
}
else if (pnnLayer.Name.Equals("u", StringComparison.InvariantCultureIgnoreCase))
{
outmodel = PNNOutputMode.Unsupervised;
}
else
{
throw new NeuralNetworkError("Unknown model: " + pnnLayer.Name);
}
var holder = new ParamsHolder(pnnLayer.Params);
String kernelStr = holder.GetString("KERNEL", false, "gaussian");
if (kernelStr.Equals("gaussian", StringComparison.InvariantCultureIgnoreCase))
{
kernel = PNNKernelType.Gaussian;
}
else if (kernelStr.Equals("reciprocal", StringComparison.InvariantCultureIgnoreCase))
{
kernel = PNNKernelType.Reciprocal;
}
else
{
throw new NeuralNetworkError("Unknown kernel: " + kernelStr);
}
var result = new BasicPNN(kernel, outmodel, inputCount,
outputCount);
return(result);
}
/// <summary>
/// Create the SVM.
/// </summary>
///
/// <param name="architecture">The architecture string.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The newly created SVM.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
IList <String> layers = ArchitectureParse.ParseLayers(architecture);
if (layers.Count != MAX_LAYERS)
{
throw new EncogError(
"SVM's must have exactly three elements, separated by ->.");
}
ArchitectureLayer inputLayer = ArchitectureParse.ParseLayer(
layers[0], input);
ArchitectureLayer paramsLayer = ArchitectureParse.ParseLayer(
layers[1], input);
ArchitectureLayer outputLayer = ArchitectureParse.ParseLayer(
layers[2], output);
String name = paramsLayer.Name;
String kernelStr = paramsLayer.Params.ContainsKey("KERNEL") ? paramsLayer.Params["KERNEL"] : null;
String svmTypeStr = paramsLayer.Params.ContainsKey("TYPE") ? paramsLayer.Params["TYPE"] : null;
SVMType svmType = SVMType.NewSupportVectorClassification;
KernelType kernelType = KernelType.RadialBasisFunction;
bool useNew = true;
if (svmTypeStr == null)
{
useNew = true;
}
else if (svmTypeStr.Equals("NEW", StringComparison.InvariantCultureIgnoreCase))
{
useNew = true;
}
else if (svmTypeStr.Equals("OLD", StringComparison.InvariantCultureIgnoreCase))
{
useNew = false;
}
else
{
throw new EncogError("Unsupported type: " + svmTypeStr
+ ", must be NEW or OLD.");
}
if (name.Equals("C", StringComparison.InvariantCultureIgnoreCase))
{
if (useNew)
{
svmType = SVMType.NewSupportVectorClassification;
}
else
{
svmType = SVMType.SupportVectorClassification;
}
}
else if (name.Equals("R", StringComparison.InvariantCultureIgnoreCase))
{
if (useNew)
{
svmType = SVMType.NewSupportVectorRegression;
}
else
{
svmType = SVMType.EpsilonSupportVectorRegression;
}
}
else
{
throw new EncogError("Unsupported mode: " + name
+ ", must be C for classify or R for regression.");
}
if (kernelStr == null)
{
kernelType = KernelType.RadialBasisFunction;
}
else if ("linear".Equals(kernelStr, StringComparison.InvariantCultureIgnoreCase))
{
kernelType = KernelType.Linear;
}
else if ("poly".Equals(kernelStr, StringComparison.InvariantCultureIgnoreCase))
{
kernelType = KernelType.Poly;
}
else if ("precomputed".Equals(kernelStr, StringComparison.InvariantCultureIgnoreCase))
{
kernelType = KernelType.Precomputed;
}
else if ("rbf".Equals(kernelStr, StringComparison.InvariantCultureIgnoreCase))
{
kernelType = KernelType.RadialBasisFunction;
}
else if ("sigmoid".Equals(kernelStr, StringComparison.InvariantCultureIgnoreCase))
{
kernelType = KernelType.Sigmoid;
}
else
{
throw new EncogError("Unsupported kernel: " + kernelStr
+ ", must be linear,poly,precomputed,rbf or sigmoid.");
}
int inputCount = inputLayer.Count;
int outputCount = outputLayer.Count;
if (outputCount != 1)
{
throw new EncogError("SVM can only have an output size of 1.");
}
var result = new SupportVectorMachine(inputCount, svmType, kernelType);
return(result);
}
