Package org.apache.commons.math3.stat.descriptive.moment

Examples of org.apache.commons.math3.stat.descriptive.moment.Mean


            sumSqImpl[i]   = new SumOfSquares();
            minImpl[i]     = new Min();
            maxImpl[i]     = new Max();
            sumLogImpl[i= new SumOfLogs();
            geoMeanImpl[i] = new GeometricMean();
            meanImpl[i]    = new Mean();
        }

        covarianceImpl =
            new VectorialCovariance(k, isCovarianceBiasCorrected);
View Full Code Here


            dest.varianceImpl = new Variance(dest.secondMoment);
        } else {
            dest.varianceImpl = source.varianceImpl.copy();
        }
        if (source.meanImpl instanceof Mean) {
            dest.meanImpl = new Mean(dest.secondMoment);
        } else {
            dest.meanImpl = source.meanImpl.copy();
        }
        if (source.getGeoMeanImpl() instanceof GeometricMean) {
            dest.geoMeanImpl = new GeometricMean((SumOfLogs) dest.sumLogImpl);
View Full Code Here

     * @throws  IllegalArgumentException if the arrays lengths do not match or
     * there is insufficient data
     */
    public double covariance(final double[] xArray, final double[] yArray, boolean biasCorrected)
        throws IllegalArgumentException {
        Mean mean = new Mean();
        double result = 0d;
        int length = xArray.length;
        if (length != yArray.length) {
            throw new MathIllegalArgumentException(
                  LocalizedFormats.DIMENSIONS_MISMATCH_SIMPLE, length, yArray.length);
        } else if (length < 2) {
            throw new MathIllegalArgumentException(
                  LocalizedFormats.INSUFFICIENT_OBSERVED_POINTS_IN_SAMPLE, length, 2);
        } else {
            double xMean = mean.evaluate(xArray);
            double yMean = mean.evaluate(yArray);
            for (int i = 0; i < length; i++) {
                double xDev = xArray[i] - xMean;
                double yDev = yArray[i] - yMean;
                result += (xDev * yDev - result) / (i + 1);
            }
View Full Code Here

            dest.varianceImpl = new Variance(dest.secondMoment);
        } else {
            dest.varianceImpl = source.varianceImpl.copy();
        }
        if (source.meanImpl instanceof Mean) {
            dest.meanImpl = new Mean(dest.secondMoment);
        } else {
            dest.meanImpl = source.meanImpl.copy();
        }
        if (source.getGeoMeanImpl() instanceof GeometricMean) {
            dest.geoMeanImpl = new GeometricMean((SumOfLogs) dest.sumLogImpl);
View Full Code Here

    public void displayStatistics(Sample[] samples, int threadNo) {
        long start = Long.MAX_VALUE;
        long finish = 0;
       
        Mean mean = new Mean();
        StandardDeviation stdDev = new StandardDeviation();
        Skewness skewness = new Skewness();
       
        int n = 0;
        for(Sample sample: samples) {
            if (threadNo == -1 || threadNo == sample.threadId) {
                n++;
                if (sample.timestamp < start) {
                    start = sample.timestamp;
                }
                if (sample.timestamp + sample.duration > finish) {
                    finish = sample.timestamp + sample.duration;
                }
                mean.increment(sample.duration);
                stdDev.increment(sample.duration);
                skewness.increment(sample.duration);
            }
        }
       
        double throughPut = (double)n * (double)TimeUnit.SECONDS.toNanos(1) / (double)(finish - start);
       
        System.out.println(String.format("Mean(NS)    %.1f", mean.getResult()));
        System.out.println(String.format("StdDev(NS)  %.1f", stdDev.getResult()));
        System.out.println(String.format("Skew(NS)    %.1f", skewness.getResult()));
        System.out.println(String.format("Throughput  %.1f", throughPut));
        System.out.println(String.format("Total time  %.3f", (finish - start) / (double)TimeUnit.SECONDS.toNanos(1)));
       
View Full Code Here

     * @throws  MathIllegalArgumentException if the arrays lengths do not match or
     * there is insufficient data
     */
    public double covariance(final double[] xArray, final double[] yArray, boolean biasCorrected)
        throws MathIllegalArgumentException {
        Mean mean = new Mean();
        double result = 0d;
        int length = xArray.length;
        if (length != yArray.length) {
            throw new MathIllegalArgumentException(
                  LocalizedFormats.DIMENSIONS_MISMATCH_SIMPLE, length, yArray.length);
        } else if (length < 2) {
            throw new MathIllegalArgumentException(
                  LocalizedFormats.INSUFFICIENT_OBSERVED_POINTS_IN_SAMPLE, length, 2);
        } else {
            double xMean = mean.evaluate(xArray);
            double yMean = mean.evaluate(yArray);
            for (int i = 0; i < length; i++) {
                double xDev = xArray[i] - xMean;
                double yDev = yArray[i] - yMean;
                result += (xDev * yDev - result) / (i + 1);
            }
View Full Code Here

  private final Mean mean;
  private final Min min;
  private final Max max;

  public RunningStatistics() {
    this.mean = new Mean();
    this.min = new Min();
    this.max = new Max();
  }
View Full Code Here

    return null;
  }
 
  public void runLoad() throws ExecutionException, InterruptedException {

    final Mean recommendedBecause = new Mean();
    final Mean setPreference = new Mean();
    final Mean removePreference = new Mean();
    final Mean setTag = new Mean();
    final Mean ingest = new Mean();
    final Mean refresh = new Mean();
    final Mean estimatePreference = new Mean();
    final Mean mostSimilarItems = new Mean();
    final Mean similarityToItem = new Mean();
    final Mean mostPopularItems = new Mean();
    final Mean recommendToMany = new Mean();
    final Mean recommend = new Mean();

    Processor<Integer> processor = new Processor<Integer>() {
      private final RandomGenerator random = RandomManager.getRandom();     
      @Override
      public void process(Integer step, long count) {
        double r;
        long userID;
        long itemID;
        long itemID2;
        float value;
        synchronized (random) {
          r = random.nextDouble();           
          userID = uniqueUserIDs[random.nextInt(uniqueUserIDs.length)];
          itemID = uniqueItemIDs[random.nextInt(uniqueItemIDs.length)];
          itemID2 = uniqueItemIDs[random.nextInt(uniqueItemIDs.length)];
          value = random.nextInt(10);
        }
        long stepStart = System.currentTimeMillis();
        try {
          if (r < 0.05) {
            client.recommendedBecause(userID, itemID, 10);
            recommendedBecause.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.07) {
            client.setPreference(userID, itemID);
            setPreference.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.08) {
            client.setPreference(userID, itemID, value);
            setPreference.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.09) {
            client.setUserTag(userID, Long.toString(itemID));
            setTag.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.10) {
            client.setItemTag(Long.toString(userID), itemID);
            setTag.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.11) {
            client.removePreference(userID, itemID);
            removePreference.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.12) {
            StringReader reader = new StringReader(userID + "," + itemID + ',' + value + '\n');
            client.ingest(reader);
            ingest.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.13) {
            client.refresh();
            refresh.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.14) {
            client.similarityToItem(itemID, itemID2);
            similarityToItem.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.15) {
            client.mostPopularItems(10);
            mostPopularItems.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.19) {
            client.estimatePreference(userID, itemID);
            estimatePreference.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.20) {
            client.estimateForAnonymous(itemID, new long[] {itemID2});
            estimatePreference.increment(System.currentTimeMillis() - stepStart);         
          } else if (r < 0.25) {
            client.mostSimilarItems(new long[]{itemID}, 10);
            mostSimilarItems.increment(System.currentTimeMillis() - stepStart);
          } else if (r < 0.30) {
            client.recommendToMany(new long[] { userID, userID }, 10, true, null);
            recommendToMany.increment(System.currentTimeMillis() - stepStart);
          } else {
            client.recommend(userID, 10);
            recommend.increment(System.currentTimeMillis() - stepStart);
          }
        } catch (TasteException te) {
          log.warn("Error during request", te);
        }
        if (count % 1000 == 0) {
          log.info("Finished {} load steps", count);
        }
      }
    };

    log.info("Starting load test...");
    long start = System.currentTimeMillis();
    new Paralleler<Integer>(new CountingIterator(steps), processor, "Load").runInParallel();
    long end = System.currentTimeMillis();

    log.info("Finished {} steps in {}ms", steps, end - start);

    log.info("recommendedBecause: {}", recommendedBecause.getResult());
    log.info("setPreference: {}", setPreference.getResult());
    log.info("removePreference: {}", removePreference.getResult());
    log.info("setTag: {}", setTag.getResult());
    log.info("ingest: {}", ingest.getResult());
    log.info("refresh: {}", refresh.getResult());
    log.info("estimatePreference: {}", estimatePreference.getResult());
    log.info("mostSimilarItems: {}", mostSimilarItems.getResult());
    log.info("similarityToItem: {}", similarityToItem.getResult());
    log.info("mostPopularItems: {}", mostPopularItems.getResult());       
    log.info("recommendToMany: {}", recommendToMany.getResult());
    log.info("recommend: {}", recommend.getResult());   
  }
View Full Code Here

      Generation generation = recommender.getGenerationManager().getCurrentGeneration();
      FastByIDMap<float[]> X = generation.getX();
      FastByIDMap<float[]> Y = generation.getY();

      Mean averageError = new Mean();
      // Only compute average over existing entries...
      for (Map.Entry<Long,RecommendedItem> entry : data.entries()) {
        long userID = entry.getKey();
        long itemID = entry.getValue().getItemID();
        // Each of which was a "1" in the factor P matrix
        double value = SimpleVectorMath.dot(X.get(userID), Y.get(itemID));
        // So store abs(1-value), except, don't penalize for reconstructing > 1. Error is 0 in this case.
        averageError.increment(FastMath.max(0.0, 1.0 - value));
      }

      return new EvaluationResultImpl(averageError.getResult());
    } finally {
      recommender.close();
      IOUtils.deleteRecursively(tempDir);
    }
  }
View Full Code Here

  @Override
  public EvaluationResult evaluate(final MyrrixRecommender recommender,
                                   final RescorerProvider provider,
                                   final Multimap<Long,RecommendedItem> testData) throws TasteException {

    final Mean precision = new Mean();
    final Mean recall = new Mean();
    final Mean ndcg = new Mean();
    final Mean meanAveragePrecision = new Mean();
   
    Processor<Long> processor = new Processor<Long>() {
      @Override
      public void process(Long userID, long count) {
       
        Collection<RecommendedItem> values = testData.get(userID);
        int numValues = values.size();
        if (numValues == 0) {
          return;
        }
       
        IDRescorer rescorer =
            provider == null ? null : provider.getRecommendRescorer(new long[]{userID}, recommender);
 
        List<RecommendedItem> recs;
        try {
          recs = recommender.recommend(userID, numValues, rescorer);
        } catch (NoSuchUserException nsue) {
          // Probably OK, just removed all data for this user from training
          log.warn("User only in test data: {}", userID);
          return;
        } catch (TasteException te) {
          log.warn("Unexpected exception", te);
          return;         
        }
        int numRecs = recs.size();
 
        Collection<Long> valueIDs = Sets.newHashSet();
        for (RecommendedItem rec : values) {
          valueIDs.add(rec.getItemID());
        }
 
        int intersectionSize = 0;
        double score = 0.0;
        double maxScore = 0.0;
        Mean precisionAtI = new Mean();
        double averagePrecision = 0.0;
 
        for (int i = 0; i < numRecs; i++) {
          RecommendedItem rec = recs.get(i);
          double value = LN2 / Math.log(2.0 + i); // 1 / log_2(1 + (i+1))
          if (valueIDs.contains(rec.getItemID())) {
            intersectionSize++;
            score += value;
            precisionAtI.increment(1.0);
            averagePrecision += precisionAtI.getResult();           
          } else {
            precisionAtI.increment(0.0);
          }
          maxScore += value;
        }
        averagePrecision /= numValues;
 
View Full Code Here

TOP

Related Classes of org.apache.commons.math3.stat.descriptive.moment.Mean

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.