/// <summary> /// Create an annealing trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is BasicNetwork)) { throw new TrainingError( "Invalid method type, requires BasicNetwork"); } ICalculateScore score = new TrainingSetScore(training); IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); double startTemp = holder.GetDouble( MLTrainFactory.PropertyTemperatureStart, false, 10); double stopTemp = holder.GetDouble( MLTrainFactory.PropertyTemperatureStop, false, 2); int cycles = holder.GetInt(MLTrainFactory.Cycles, false, 100); IMLTrain train = new NeuralSimulatedAnnealing( (BasicNetwork)method, score, startTemp, stopTemp, cycles); return(train); }
/// <summary> /// Create an annealing trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is BasicNetwork)) { throw new TrainingError( "Invalid method type, requires BasicNetwork"); } ICalculateScore score = new TrainingSetScore(training); IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); int populationSize = holder.GetInt( MLTrainFactory.PropertyPopulationSize, false, 5000); double mutation = holder.GetDouble( MLTrainFactory.PropertyMutation, false, 0.1d); double mate = holder.GetDouble(MLTrainFactory.PropertyMate, false, 0.25d); IMLTrain train = new NeuralGeneticAlgorithm((BasicNetwork)method, new RangeRandomizer(-1, 1), score, populationSize, mutation, mate); return(train); }
/// <summary> /// Create a SVM trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is SupportVectorMachine)) { throw new EncogError( "SVM Train training cannot be used on a method of type: " + method.GetType().FullName); } double defaultGamma = 1.0d / ((SupportVectorMachine)method).InputCount; double defaultC = 1.0d; IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); double gamma = holder.GetDouble(MLTrainFactory.PropertyGamma, false, defaultGamma); double c = holder.GetDouble(MLTrainFactory.PropertyC, false, defaultC); var result = new SVMTrain((SupportVectorMachine)method, training); result.Gamma = gamma; result.C = c; return(result); }
/// <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 NEAT population. /// </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 population.</returns> public IMLMethod Create(String architecture, int input, int output) { if (input <= 0) { throw new EncogError("Must have at least one input for NEAT."); } if (output <= 0) { throw new EncogError("Must have at least one output for NEAT."); } IDictionary <String, String> args = ArchitectureParse.ParseParams(architecture); ParamsHolder holder = new ParamsHolder(args); int populationSize = holder.GetInt( MLMethodFactory.PropertyPopulationSize, false, 1000); int cycles = holder.GetInt( MLMethodFactory.PropertyCycles, false, NEATPopulation.DefaultCycles); IActivationFunction af = this.factory.Create( holder.GetString(MLMethodFactory.PropertyAF, false, MLActivationFactory.AF_SSIGMOID)); NEATPopulation pop = new NEATPopulation(input, output, populationSize); pop.Reset(); pop.ActivationCycles = cycles; pop.NEATActivationFunction = af; return(pop); }
/// <summary> /// Create an annealing trainer. /// </summary> /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is BasicNetwork)) { throw new TrainingError( "Invalid method type, requires BasicNetwork"); } ICalculateScore score = new TrainingSetScore(training); IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); int populationSize = holder.GetInt( MLTrainFactory.PropertyPopulationSize, false, 5000); IMLTrain train = new MLMethodGeneticAlgorithm(() => { IMLMethod result = (IMLMethod)ObjectCloner.DeepCopy(method); ((IMLResettable)result).Reset(); return(result); }, score, populationSize); return(train); }
/// <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 quick propagation trainer. /// </summary> /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); double learningRate = holder.GetDouble( MLTrainFactory.PropertyLearningRate, false, 2.0); return(new QuickPropagation((BasicNetwork)method, training, learningRate)); }
/// <summary> /// Create a Nelder Mead trainer. /// </summary> /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); //final double learningRate = holder.getDouble( // MLTrainFactory.PROPERTY_LEARNING_RATE, false, 0.1); return(new NelderMeadTraining((BasicNetwork)method, training)); }
/// <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 PSO trainer. /// </summary> /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); ParamsHolder holder = new ParamsHolder(args); int particles = holder.GetInt( MLTrainFactory.PropertyParticles, false, 20); ICalculateScore score = new TrainingSetScore(training); IRandomizer randomizer = new NguyenWidrowRandomizer(); IMLTrain train = new NeuralPSO((BasicNetwork)method, randomizer, score, particles); return(train); }
/// <summary> /// Create a LMA trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is BasicNetwork)) { throw new EncogError( "LMA training cannot be used on a method of type: " + method.GetType().FullName); } IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); var result = new LevenbergMarquardtTraining( (BasicNetwork) method, training); 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) { if (input <= 0) { throw new EncogError("Must have at least one input for EPL."); } if (output <= 0) { throw new EncogError("Must have at least one output for EPL."); } IDictionary <String, String> args = ArchitectureParse.ParseParams(architecture); var holder = new ParamsHolder(args); int populationSize = holder.GetInt( MLMethodFactory.PropertyPopulationSize, false, 1000); String variables = holder.GetString("vars", false, "x"); String funct = holder.GetString("funct", false, null); var context = new EncogProgramContext(); string[] tok = variables.Split(','); foreach (string v in tok) { context.DefineVariable(v); } if (String.Compare("numeric", funct, StringComparison.OrdinalIgnoreCase) == 0) { StandardExtensions.CreateNumericOperators(context); } var pop = new PrgPopulation(context, populationSize); if (context.Functions.Count > 0) { (new RampedHalfAndHalf(context, 2, 6)).Generate(new EncogRandom(), pop); } return(pop); }
/// <summary> /// Create a SVM trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is SupportVectorMachine)) { throw new EncogError( "SVM Train training cannot be used on a method of type: " + method.GetType().FullName); } IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); new ParamsHolder(args); var holder = new ParamsHolder(args); double gammaStart = holder.GetDouble( PropertyGamma1, false, SVMSearchTrain.DefaultGammaBegin); double cStart = holder.GetDouble(PropertyC1, false, SVMSearchTrain.DefaultConstBegin); double gammaStop = holder.GetDouble( PropertyGamma2, false, SVMSearchTrain.DefaultGammaEnd); double cStop = holder.GetDouble(PropertyC2, false, SVMSearchTrain.DefaultConstEnd); double gammaStep = holder.GetDouble( PropertyGammaStep, false, SVMSearchTrain.DefaultGammaStep); double cStep = holder.GetDouble(PropertyCStep, false, SVMSearchTrain.DefaultConstStep); var result = new SVMSearchTrain((SupportVectorMachine)method, training) { GammaBegin = gammaStart, GammaEnd = gammaStop, GammaStep = gammaStep, ConstBegin = cStart, ConstEnd = cStop, ConstStep = cStep }; return(result); }
/// <summary> /// Create a RPROP trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is IContainsFlat)) { throw new EncogError( "RPROP training cannot be used on a method of type: " + method.GetType().FullName); } IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); double initialUpdate = holder.GetDouble( MLTrainFactory.PropertyInitialUpdate, false, RPROPConst.DefaultInitialUpdate); double maxStep = holder.GetDouble( MLTrainFactory.PropertyMaxStep, false, RPROPConst.DefaultMaxStep); return(new ResilientPropagation((IContainsFlat)method, training, initialUpdate, maxStep)); }
/// <summary> /// Create a LMA trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is BasicNetwork)) { throw new EncogError( "LMA training cannot be used on a method of type: " + method.GetType().FullName); } IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); bool useReg = holder.GetBoolean( MLTrainFactory.PropertyBayesianRegularization, false, false); var result = new LevenbergMarquardtTraining( (BasicNetwork)method, training) { UseBayesianRegularization = useReg }; return(result); }
/** * Create a K2 trainer. * * @param method * The method to use. * @param training * The training data to use. * @param argsStr * The arguments to use. * @return The newly created trainer. */ public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); ParamsHolder holder = new ParamsHolder(args); int maxParents = holder.GetInt( MLTrainFactory.PropertyMaxParents, false, 1); String searchStr = holder.GetString("SEARCH", false, "k2"); String estimatorStr = holder.GetString("ESTIMATOR", false, "simple"); String initStr = holder.GetString("INIT", false, "naive"); IBayesSearch search; IBayesEstimator estimator; BayesianInit init; if (string.Compare(searchStr, "k2", true) == 0) { search = new SearchK2(); } else if (string.Compare(searchStr, "none", true) == 0) { search = new SearchNone(); } else { throw new BayesianError("Invalid search type: " + searchStr); } if (string.Compare(estimatorStr, "simple", true) == 0) { estimator = new SimpleEstimator(); } else if (string.Compare(estimatorStr, "none", true) == 0) { estimator = new EstimatorNone(); } else { throw new BayesianError("Invalid estimator type: " + estimatorStr); } if (string.Compare(initStr, "simple") == 0) { init = BayesianInit.InitEmpty; } else if (string.Compare(initStr, "naive") == 0) { init = BayesianInit.InitNaiveBayes; } else if (string.Compare(initStr, "none") == 0) { init = BayesianInit.InitNoChange; } else { throw new BayesianError("Invalid init type: " + initStr); } return(new TrainBayesian((BayesianNetwork)method, training, maxParents, init, search, estimator)); }
/// <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 a LMA trainer. /// </summary> /// /// <param name="method">The method to use.</param> /// <param name="training">The training data to use.</param> /// <param name="argsStr">The arguments to use.</param> /// <returns>The newly created trainer.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String argsStr) { if (!(method is SupportVectorMachine)) { throw new EncogError( "Neighborhood training cannot be used on a method of type: " + method.GetType().FullName); } IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr); var holder = new ParamsHolder(args); double learningRate = holder.GetDouble( MLTrainFactory.PropertyLearningRate, false, 0.7d); String neighborhoodStr = holder.GetString( MLTrainFactory.PropertyNeighborhood, false, "rbf"); String rbfTypeStr = holder.GetString( MLTrainFactory.PropertyRBFType, false, "gaussian"); RBFEnum t; if (rbfTypeStr.Equals("Gaussian", StringComparison.InvariantCultureIgnoreCase)) { t = RBFEnum.Gaussian; } else if (rbfTypeStr.Equals("Multiquadric", StringComparison.InvariantCultureIgnoreCase)) { t = RBFEnum.Multiquadric; } else if (rbfTypeStr.Equals("InverseMultiquadric", StringComparison.InvariantCultureIgnoreCase)) { t = RBFEnum.InverseMultiquadric; } else if (rbfTypeStr.Equals("MexicanHat", StringComparison.InvariantCultureIgnoreCase)) { t = RBFEnum.MexicanHat; } else { t = RBFEnum.Gaussian; } INeighborhoodFunction nf = null; if (neighborhoodStr.Equals("bubble", StringComparison.InvariantCultureIgnoreCase)) { nf = new NeighborhoodBubble(1); } else if (neighborhoodStr.Equals("rbf", StringComparison.InvariantCultureIgnoreCase)) { String str = holder.GetString( MLTrainFactory.PropertyDimensions, true, null); int[] size = NumberList.FromListInt(CSVFormat.EgFormat, str); nf = new NeighborhoodRBF(size, t); } else if (neighborhoodStr.Equals("rbf1d", StringComparison.InvariantCultureIgnoreCase)) { nf = new NeighborhoodRBF1D(t); } if (neighborhoodStr.Equals("single", StringComparison.InvariantCultureIgnoreCase)) { nf = new NeighborhoodSingle(); } var result = new BasicTrainSOM((SOMNetwork)method, learningRate, training, nf); if (args.ContainsKey(MLTrainFactory.PropertyIterations)) { int plannedIterations = holder.GetInt( MLTrainFactory.PropertyIterations, false, 1000); double startRate = holder.GetDouble( MLTrainFactory.PropertyStartLearningRate, false, 0.05d); double endRate = holder.GetDouble( MLTrainFactory.PropertyEndLearningRate, false, 0.05d); double startRadius = holder.GetDouble( MLTrainFactory.PropertyStartRadius, false, 10); double endRadius = holder.GetDouble( MLTrainFactory.PropertyEndRadius, false, 1); result.SetAutoDecay(plannedIterations, startRate, endRate, startRadius, endRadius); } 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); }