Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.spark.examples;
 
 
Logistic regression based classification.
 
 public final class JavaHdfsLR {
 
   private static final int D = 10;   // Number of dimensions
   private static final Random rand = new Random(42);
 
   static class DataPoint implements Serializable {
     DataPoint(double[] xdouble y) {
       this. = x;
       this. = y;
     }
 
     double[] x;
     double y;
   }
 
   static class ParsePoint extends Function<StringDataPoint> {
     private static final Pattern SPACE = Pattern.compile(" ");
 
     @Override
     public DataPoint call(String line) {
       String[] tok = .split(line);
       double y = Double.parseDouble(tok[0]);
       double[] x = new double[];
       for (int i = 0; i < i++) {
         x[i] = Double.parseDouble(tok[i + 1]);
       }
       return new DataPoint(xy);
     }
   }
 
   static class VectorSum extends Function2<double[], double[], double[]> {
     @Override
     public double[] call(double[] adouble[] b) {
       double[] result = new double[];
       for (int j = 0; j < j++) {
         result[j] = a[j] + b[j];
       }
       return result;
     }
   }
 
   static class ComputeGradient extends Function<DataPointdouble[]> {
     private final double[] weights;
 
     ComputeGradient(double[] weights) {
       this. = weights;
     }
 
     @Override
     public double[] call(DataPoint p) {
       double[] gradient = new double[];
       for (int i = 0; i < i++) {
         double dot = dot(p.x);
         gradient[i] = (1 / (1 + Math.exp(-p.y * dot)) - 1) * p.y * p.x[i];
       }
       return gradient;
     }
   }
 
   public static double dot(double[] adouble[] b) {
     double x = 0;
     for (int i = 0; i < i++) {
       x += a[i] * b[i];
     }
     return x;
   }
 
  public static void printWeights(double[] a) {
    ..println(Arrays.toString(a));
  }
  public static void main(String[] args) {
    if (args.length < 3) {
      ..println("Usage: JavaHdfsLR <master> <file> <iters>");
      System.exit(1);
    }
    JavaSparkContext sc = new JavaSparkContext(args[0], "JavaHdfsLR",
        System.getenv("SPARK_HOME"), JavaSparkContext.jarOfClass(JavaHdfsLR.class));
    JavaRDD<Stringlines = sc.textFile(args[1]);
    JavaRDD<DataPointpoints = lines.map(new ParsePoint()).cache();
    int ITERATIONS = Integer.parseInt(args[2]);
    // Initialize w to a random value
    double[] w = new double[];
    for (int i = 0; i < i++) {
      w[i] = 2 * .nextDouble() - 1;
    }
    ..print("Initial w: ");
    printWeights(w);
    for (int i = 1; i <= ITERATIONSi++) {
      ..println("On iteration " + i);
      double[] gradient = points.map(
        new ComputeGradient(w)
      ).reduce(new VectorSum());
      for (int j = 0; j < j++) {
        w[j] -= gradient[j];
      }
    }
    ..print("Final w: ");
    printWeights(w);
    System.exit(0);
  }
New to GrepCode? Check out our FAQ X