Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2013, Cloudera, Inc. All Rights Reserved.
   *
   * Cloudera, Inc. 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
   *
  * This software 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 com.cloudera.oryx.kmeans.serving.generation;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 public final class VectorFactory {
 
   private static final Logger log = LoggerFactory.getLogger(VectorFactory.class);
 
   private final boolean sparse;
   private final int fieldCount;
   private final List<Set<Update>> updates;
 
   public static VectorFactory create(
       MiningSchema schema,
       LocalTransformations transforms,
       List<ClusteringFieldfields) {
     Map<FieldNameDerivedFieldderived = Maps.newHashMapWithExpectedSize(transforms.getDerivedFields().size());
     for (DerivedField df : transforms.getDerivedFields()) {
       derived.put(df.getName(), df);
     }
 
     Multimap<FieldNameNumericUpdatenumeric = HashMultimap.create();
     Map<FieldNameMap<StringUpdate>> categorical = Maps.newHashMap();
     for (int j = 0; j < fields.size(); j++) {
       ClusteringField cf = fields.get(j);
       FieldName fn = cf.getField();
       if (derived.containsKey(fn)) {
         DerivedField df = derived.get(fn);
         Expression e = df.getExpression();
         if (e instanceof NormDiscrete) {
           NormDiscrete nd = (NormDiscretee;
           Map<StringUpdatem = categorical.get(nd.getField());
           if (m == null) {
             m = Maps.newHashMap();
             categorical.put(nd.getField(), m);
           }
           m.put(nd.getValue(), new NumericUpdate(jcf.getFieldWeight()));
         } else if (e instanceof Apply) {
           Apply apply = (Applye;
           if (!"ln".equals(apply.getFunction())) {
             throw new UnsupportedOperationException("Unsupported function type: " + apply.getFunction());
           }
           FieldName f = ((FieldRefapply.getExpressions().get(0)).getField();
           numeric.put(fnew NumericUpdate(jcf.getFieldWeight()));
         } else if (e instanceof NormContinuous) {
           NormContinuous nc = (NormContinuouse;
           FieldName f = nc.getField();
           LinearNorm l1 = nc.getLinearNorms().get(0);
           LinearNorm l2 = nc.getLinearNorms().get(1);
           InterpolateFunction ifunc = new InterpolateFunction(
               l1.getOrig(), l1.getNorm(),
               l2.getOrig(), l2.getNorm());
           numeric.put(fnew NumericUpdate(ifuncjcf.getFieldWeight()));
         } else {
           throw new UnsupportedOperationException("Unsupported expression type: " + e);
         }
       } else {
         numeric.put(fnnew NumericUpdate(jcf.getFieldWeight()));
       }
    }
    boolean sparse = 2 * schema.getMiningFields().size() <= fields.size();
    List<Set<Update>> updates = Lists.newArrayListWithExpectedSize(schema.getMiningFields().size());
    for (MiningField mf : schema.getMiningFields()) {
      FieldName fn = mf.getName();
      if (numeric.containsKey(fn)) {
        updates.add(ImmutableSet.<Update>copyOf(numeric.get(fn)));
      } else if (categorical.containsKey(fn)) {
        CategoricalUpdate u = new CategoricalUpdate(fn.getValue(), categorical.get(fn));
        updates.add(ImmutableSet.<Update>of(u));
      }
    }
    return new VectorFactory(sparsefields.size(), updates);
  }
  private VectorFactory(boolean sparseint fieldCountList<Set<Update>> updates) {
    this. = sparse;
    this. = fieldCount;
    this. = updates;
  }
  public RealVector createVector(String[] tokens) {
    if (tokens.length != .size()) {
      return null;
    }
    RealVector v =  ? Vectors.sparse() : Vectors.dense();
    for (int i = 0; i < tokens.lengthi++) {
      for (Update update : .get(i)) {
        update.update(vtokens[i]);
      }
    }
    return v;
  }
  private interface Update {
    void update(RealVector vString value);
  }
  private static final class CategoricalUpdate implements Update {
    private final String name;
    private final Map<StringUpdateupdates;
    CategoricalUpdate(String nameMap<StringUpdateupdates) {
      this. = name;
      this. = updates;
    }
    @Override
    public void update(RealVector vString value) {
      Update u = .get(value);
      if (u != null) {
        u.update(vvalue);
      } else {
        .warn("Unknown value '{}' for categorical variable {}"value);
      }
    }
  }
  private static final class NumericUpdate implements Update {
    private final ConvertFunction c;
    private final int offset;
    private final double scale;
    NumericUpdate(ConvertFunction cint offsetdouble scale) {
      this. = c;
      this. = offset;
      this. = scale;
    }
    @Override
    public void update(RealVector vString value) {
      v.setEntry(.apply(value) * );
    }
  }
  private interface ConvertFunction extends Function<StringDouble> {}
  private static final ConvertFunction ONE = new ConvertFunction() {
    @Override
    public Double apply(String input) {
      return 1.0;
    }
  };
  private static final ConvertFunction VALUE = new ConvertFunction() {
    @Override
    public Double apply(String input) {
      try {
        return Double.valueOf(input);
      } catch (NumberFormatException e) {
        return .;
      }
    }
  };
  private static final ConvertFunction LOG_VALUE = new ConvertFunction() {
    @Override
    public Double apply(String input) {
      try {
        return Math.log(Double.valueOf(input));
      } catch (NumberFormatException e) {
        return .;
      }
    }
  };
  private static final class InterpolateFunction implements ConvertFunction {
    private final double a1;
    private final double b1;
    private final double a2;
    private final double b2;
    private InterpolateFunction(double a1double b1double a2double b2) {
      this. = a1;
      this. = b1;
      this. = a2;
      this. = b2;
    }
    @Override
    public Double apply(String input) {
      try {
        double x = Double.valueOf(input);
        return  + ((x - ) / ( - )) * ( - );
      } catch (NumberFormatException e) {
        return .;
      }
    }
  }
New to GrepCode? Check out our FAQ X