import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public T trainWithSGD(int numIterations){    
    //Train the model
    if(modelName.equals("SVMModel")){
      SVMModel svmmodel = SVMWithSGD.train(trainingData.rdd(), numIterations);
      this.model = (T)(Object) svmmodel;
    } 
    else if(modelName.equals("LogisticRegressionModel")){
      LogisticRegressionModel lrmodel = LogisticRegressionWithSGD.train(trainingData.rdd(), numIterations);
      this.model = (T)(Object) lrmodel;
    } 

    //Evalute the trained model      
    EvaluateProcess<T> evalProcess = new EvaluateProcess<T>(model, modelName, validData, numClasses);
    evalProcess.evalute(numClasses);
  return model;
}
 

import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
public SVMModel generateKMeansModel(JavaRDD<LabeledPoint> parsedData,
                                    SVMDetectionAlgorithm svmDetectionAlgorithm,
                                    SVMModelSummary SVMModelSummary) {
    SVMModel svmModel;



    if (svmDetectionAlgorithm.getMiniBatchFraction() != -1) {
        svmModel = SVMWithSGD.train(parsedData.rdd(),
                svmDetectionAlgorithm.getNumIterations(),
                svmDetectionAlgorithm.getStepSize(),
                svmDetectionAlgorithm.getRegParam(),
                svmDetectionAlgorithm.getMiniBatchFraction());
    }else if (svmDetectionAlgorithm.getRegParam() != -1) {
        svmModel = SVMWithSGD.train(parsedData.rdd(),
                svmDetectionAlgorithm.getNumIterations(),
                svmDetectionAlgorithm.getStepSize(),
                svmDetectionAlgorithm.getRegParam());
    }else {
        svmModel = SVMWithSGD.train(parsedData.rdd(),
                svmDetectionAlgorithm.getNumIterations());
    }

    SVMModelSummary.setSVMDetectionAlgorithm(svmDetectionAlgorithm);
    return svmModel;
}
 

import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
public ModelSVM(JavaRDD<LabeledPoint> training) {
		super();

		SVMWithSGD svmAlg = new SVMWithSGD();
		svmAlg.optimizer().setNumIterations(100).setRegParam(0.1).setUpdater(new L1Updater());
		model = svmAlg.run(training.rdd());

		// Clear the default threshold.
//		model.clearThreshold();
//		model.setThreshold(0.001338428);
	}
 

import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
/**
 * This method uses stochastic gradient descent (SGD) algorithm to train a support vector machine (SVM) model.
 *
 * @param trainingDataset         Training dataset as a JavaRDD of LabeledPoints
 * @param noOfIterations          Number of iterarations
 * @param regularizationType      Regularization type: L1 or L2
 * @param regularizationParameter Regularization parameter
 * @param initialLearningRate     Initial learning rate (SGD step size)
 * @param miniBatchFraction       SGD minibatch fraction
 * @return                        SVM model
 */
public SVMModel train(JavaRDD<LabeledPoint> trainingDataset, int noOfIterations, String regularizationType,
        double regularizationParameter, double initialLearningRate, double miniBatchFraction) {
    SVMWithSGD svmWithSGD = new SVMWithSGD();
    if (regularizationType.equals(MLConstants.L1)) {
        svmWithSGD.optimizer().setUpdater(new L1Updater()).setRegParam(regularizationParameter);
    } else if (regularizationType.equals((MLConstants.L2))) {
        svmWithSGD.optimizer().setUpdater(new SquaredL2Updater()).setRegParam(regularizationParameter);
    }
    svmWithSGD.optimizer().setNumIterations(noOfIterations).setStepSize(initialLearningRate)
            .setMiniBatchFraction(miniBatchFraction);
    return svmWithSGD.run(trainingDataset.rdd());
}
 

import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
public static void main(String[] args) {
  MudrodEngine me = new MudrodEngine();

  JavaSparkContext jsc = me.startSparkDriver().sc;

  String path = SparkSVM.class.getClassLoader().getResource("inputDataForSVM_spark.txt").toString();
  JavaRDD<LabeledPoint> data = MLUtils.loadLibSVMFile(jsc.sc(), path).toJavaRDD();

  // Run training algorithm to build the model.
  int numIterations = 100;
  final SVMModel model = SVMWithSGD.train(data.rdd(), numIterations);

  // Save and load model
  model.save(jsc.sc(), SparkSVM.class.getClassLoader().getResource("javaSVMWithSGDModel").toString());

  jsc.sc().stop();

}
 

import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
public static void main(String[] args) throws IOException {

    JavaSparkContext sc = new JavaSparkContext("local", "WikipediaKMeans");

    JavaRDD<String> lines = sc.textFile("data/" + input_file);

    JavaRDD<LabeledPoint> points = lines.map(new ParsePoint());

    // Split initial RDD into two with 70% training data and 30% testing data (13L is a random seed):
    JavaRDD<LabeledPoint>[] splits = points.randomSplit(new double[]{0.7, 0.3}, 13L);
    JavaRDD<LabeledPoint> training = splits[0].cache();
    JavaRDD<LabeledPoint> testing = splits[1];
    training.cache();

    // Building the model
    int numIterations = 500;
    final SVMModel model =
        SVMWithSGD.train(JavaRDD.toRDD(training), numIterations);
    model.clearThreshold();
    // Evaluate model on testing examples and compute training error
    JavaRDD<Tuple2<Double, Double>> valuesAndPreds = testing.map(
        new Function<LabeledPoint, Tuple2<Double, Double>>() {
          public Tuple2<Double, Double> call(LabeledPoint point) {
            double prediction = model.predict(point.features());
            System.out.println(" ++ prediction: " + prediction + " original: " + map_to_print_original_text.get(point.features().compressed().toString()));
            return new Tuple2<Double, Double>(prediction, point.label());
          }
        }
    );

    double MSE = new JavaDoubleRDD(valuesAndPreds.map(
        new Function<Tuple2<Double, Double>, Object>() {
          public Object call(Tuple2<Double, Double> pair) {
            return Math.pow(pair._1() - pair._2(), 2.0);
          }
        }
    ).rdd()).mean();
    System.out.println("Test Data Mean Squared Error = " + MSE);

    sc.stop();
  }
 

import org.apache.spark.mllib.classification.SVMWithSGD; //导入依赖的package包/类
@Override
protected BaseSparkClassificationModel trainInternal(String modelId, RDD<LabeledPoint> trainingRDD)
  throws LensException {
  SVMModel svmModel = SVMWithSGD.train(trainingRDD, iterations, stepSize, regParam, minBatchFraction);
  return new SVMClassificationModel(modelId, svmModel);
}