Java NoSuchUserException类代码示例

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public PreferenceArray get(Long userID) throws TasteException {
    try {
        List<Entity> results = getItemsForUser(userID);
        if(results == null || results.isEmpty()) {
            throw new NoSuchUserException(userID);
        }
        int i = 0;
        PreferenceArray prefs = new GenericUserPreferenceArray(results.size());
        prefs.setUserID(0, userID);
        for (Entity entity : results) {
            prefs.setItemID(
                    i,
                    DatastoreHelper.getLong(
                            DatastoreHelper.getPropertyMap(entity).get(ITEM_ID_COLUMN)
                    )
            );
            prefs.setValue(i, 1f);
            i++;
        }
        return prefs;
    } catch (DatastoreException e) {
        throw new TasteException(e);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
/**
 * Give the recommendations based on the supplied User instance.
 * This will make the calls to Mahout and ask it to give recommendations
 * for the given User instance that this user is likely interested in.
 * Although we speak about Users here, this can be any object type.
 * Note: The recommendations that are returned are the result of the
 * algorithm you use, if the results do not match your expectations, please
 * try using another algorithm. See the documentation for more information.
 * @param x The user object to give recommendations of.
 * @param howMany The number of recommendations you would like to get.
 * @param aType The type of the recommendation, either USER (in case of User
 * to Item recommendations) or ITEM (in case of Item to Item recommendations)
 * @return A list with recommended items that are recommended by Mahout
 * for this user.
 */
public List<?> getRecommendations(Object x, int howMany, RecFieldType aType) {
    if(checkAvailabilityOfRecommendations(aType) == false){
        org.webdsl.logging.Logger.warn("Warning, you request to get recommendations while the recommendations taste table has not yet been filled by Mahout.\nEither wait for it to finish its background task, or call the reconstructRecommendCache function (last option should be used with care, on non-production systems only.)");
        return new ArrayList<Object>();
    }
    long startTime = System.currentTimeMillis();

    try {
        long id = getIDOfObject(x, aType);

        List<RecommendedItem> recommendations = aType == RecFieldType.USER ? this.userRecommenderCache.recommend(id, howMany) : this.itemRecommenderCache.recommend(id, howMany);

        this.lastExecutionTime = System.currentTimeMillis() - startTime;
        //org.webdsl.logging.Logger.info("Obtaining the list of recommendations took: " + this.lastExecutionTime);
        return getObjectsOfIDList(recommendations, RecFieldType.ITEM);
    } catch(NoSuchUserException nse){
        /* Recommendations cannot be given because the user is unknown */
        return new ArrayList<Object>();
    } catch (Exception e){
        org.webdsl.logging.Logger.error("Error, catched an exception while obtaining the recommendations! " + e);
        org.webdsl.logging.Logger.error("EXCEPTION",e);
        return new ArrayList<Object>();
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public EvaluationResult evaluate(MyrrixRecommender recommender,
                                 RescorerProvider provider, // ignored
                                 Multimap<Long,RecommendedItem> testData) throws TasteException {
  DoubleWeightedMean score = new DoubleWeightedMean();
  int count = 0;
  for (Map.Entry<Long,RecommendedItem> entry : testData.entries()) {
    long userID = entry.getKey();
    RecommendedItem itemPref = entry.getValue();
    try {
      float estimate = recommender.estimatePreference(userID, itemPref.getItemID());
      Preconditions.checkState(LangUtils.isFinite(estimate));
      score.increment(1.0 - estimate, itemPref.getValue());
    } catch (NoSuchItemException nsie) {
      // continue
    } catch (NoSuchUserException nsue) {
      // continue
    }
    if (++count % 100000 == 0) {
      log.info("Score: {}", score);
    }
  }
  log.info("Score: {}", score);
  return new EvaluationResultImpl(score.getResult());
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Test
public void testSetRemove() throws Exception {
  ClientRecommender client = getClient();

  client.setPreference(0L, 1L);
  List<RecommendedItem> recs = client.recommend(0L, 1);
  assertEquals(50L, recs.get(0).getItemID());

  client.setPreference(0L, 2L, 1.0f);
  recs = client.recommend(0L, 1);
  assertEquals(50L, recs.get(0).getItemID());

  client.removePreference(0L, 2L);
  recs = client.recommend(0L, 1);
  assertEquals(50L, recs.get(0).getItemID());

  client.removePreference(0L, 1L);
  try {
    client.recommend(0L, 1);
    fail();
  } catch (NoSuchUserException nsue) {
    // good
  }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public PreferenceArray getPreferencesFromUser(int tenantId, Date cutoffDate, long userID, int actionTypeId) throws TasteException {
    Object[] args = new Object[]{tenantId, cutoffDate, userID, actionTypeId};
    int[] argTypes = new int[]{Types.INTEGER, Types.TIMESTAMP, Types.INTEGER, Types.INTEGER};
    try {
        return new GenericUserPreferenceArray(getJdbcTemplate().query(getPreferencesFromUserQuery, args, argTypes, genericPreferenceRowMapper));
    } catch (EmptyResultDataAccessException e) {
        logger.warn("An error occurred!", e);
        throw new NoSuchUserException(userID);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public PreferenceArray getBooleanPreferencesFromUser(int tenantId, Date cutoffDate, long userID, int actionTypeId) throws TasteException {
    Object[] args = new Object[]{tenantId, cutoffDate, userID, actionTypeId};
    int[] argTypes = new int[]{Types.INTEGER, Types.TIMESTAMP, Types.INTEGER, Types.INTEGER};
    try {
        return new GenericUserPreferenceArray(getJdbcTemplate().query(getPreferencesFromUserQuery, args, argTypes, genericBooleanPreferenceRowMapper));
    } catch (EmptyResultDataAccessException e) {
        logger.warn("An error occurred!", e);
        throw new NoSuchUserException(userID);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public FastIDSet getItemIDsFromUser(int tenantId, Date cutoffDate, long userID, int actionTypeId) throws TasteException {
    Object[] args = new Object[]{tenantId, cutoffDate, userID, actionTypeId};
    int[] argTypes = new int[]{Types.INTEGER, Types.TIMESTAMP, Types.INTEGER, Types.INTEGER};

    try {
        return getJdbcTemplate().query(getItemIDsFromUserQuery, args, argTypes, fastIDSetExtractor);
    } catch (EmptyResultDataAccessException e) {
        logger.warn("An error occurred!", e);
        throw new NoSuchUserException(userID);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public PreferenceArray getPreferencesFromUser(int tenantId, Date cutoffDate, long userID, int actionTypeId) throws TasteException {
    Object[] args = new Object[]{tenantId, cutoffDate, userID, actionTypeId};
    int[] argTypes = new int[]{Types.INTEGER, Types.TIMESTAMP, Types.INTEGER, Types.INTEGER};
    try {
        return new GenericUserPreferenceArray(getJdbcTemplate().query(getPreferencesFromUserQuery, args, argTypes, genericPreferenceRowMapper));
    } catch (EmptyResultDataAccessException e) {
        throw new NoSuchUserException(userID);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public PreferenceArray getBooleanPreferencesFromUser(int tenantId, Date cutoffDate, long userID, int actionTypeId) throws TasteException {
    Object[] args = new Object[]{tenantId, cutoffDate, userID, actionTypeId};
    int[] argTypes = new int[]{Types.INTEGER, Types.TIMESTAMP, Types.INTEGER, Types.INTEGER};
    try {
        return new GenericUserPreferenceArray(getJdbcTemplate().query(getPreferencesFromUserQuery, args, argTypes, genericBooleanPreferenceRowMapper));
    } catch (EmptyResultDataAccessException e) {
        throw new NoSuchUserException(userID);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Override
public FastIDSet getItemIDsFromUser(int tenantId, Date cutoffDate, long userID, int actionTypeId) throws TasteException {
    Object[] args = new Object[]{tenantId, cutoffDate, userID, actionTypeId};
    int[] argTypes = new int[]{Types.INTEGER, Types.TIMESTAMP, Types.INTEGER, Types.INTEGER};

    try {
        return getJdbcTemplate().query(getItemIDsFromUserQuery, args, argTypes, fastIDSetExtractor);
    } catch (EmptyResultDataAccessException e) {
        throw new NoSuchUserException(userID);
    }
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
/**
 * @param userID user for which recommendations are to be computed
 * @param howMany desired number of recommendations
 * @param considerKnownItems if true, items that the user is already associated to are candidates
 *  for recommendation. Normally this is {@code false}.
 * @param rescorerParams optional parameters to send to the server's {@code RescorerProvider}
 * @return {@link List} of recommended {@link RecommendedItem}s, ordered from most strongly recommend to least
 * @throws NoSuchUserException if the user is not known in the model
 * @throws NotReadyException if the recommender has no model available yet
 * @throws TasteException if another error occurs
 * @throws UnsupportedOperationException if rescorer is not null
 */
public List<RecommendedItem> recommend(long userID,
                                       int howMany,
                                       boolean considerKnownItems,
                                       String[] rescorerParams) throws TasteException {

  StringBuilder urlPath = new StringBuilder();
  urlPath.append("/recommend/");
  urlPath.append(userID);
  appendCommonQueryParams(howMany, considerKnownItems, rescorerParams, urlPath);

  TasteException savedException = null;
  for (HostAndPort replica : choosePartitionAndReplicas(userID)) {
    HttpURLConnection connection = null;
    try {
      connection = buildConnectionToReplica(replica, urlPath.toString(), "GET");
      switch (connection.getResponseCode()) {
        case HttpURLConnection.HTTP_OK:
          return consumeItems(connection);
        case HttpURLConnection.HTTP_NOT_FOUND:
          throw new NoSuchUserException(userID);
        case HttpURLConnection.HTTP_UNAVAILABLE:
          throw new NotReadyException();
        default:
          throw new TasteException(connection.getResponseCode() + " " + connection.getResponseMessage());
      }
    } catch (TasteException te) {
      log.info("Can't access {} at {}: ({})", urlPath, replica, te.toString());
      savedException = te;
    } catch (IOException ioe) {
      log.info("Can't access {} at {}: ({})", urlPath, replica, ioe.toString());
      savedException = new TasteException(ioe);
    } finally {
      if (connection != null) {
        connection.disconnect();
      }
    }
  }
  throw savedException;
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
/**
 * <p>Lists the items that were most influential in recommending a given item to a given user. Exactly how this
 * is determined is left to the implementation, but, generally this will return items that the user prefers
 * and that are similar to the given item.</p>
 *
 * <p>These values by which the results are ordered are opaque values and have no interpretation
 * other than that larger means stronger.</p>
 *
 * @param userID ID of user who was recommended the item
 * @param itemID ID of item that was recommended
 * @param howMany maximum number of items to return
 * @return {@link List} of {@link RecommendedItem}, ordered from most influential in recommended the given
 *  item to least
 * @throws NoSuchUserException if the user is not known in the model
 * @throws NoSuchItemException if the item is not known in the model
 * @throws NotReadyException if the recommender has no model available yet
 * @throws TasteException if another error occurs
 */
@Override
public List<RecommendedItem> recommendedBecause(long userID, long itemID, int howMany) throws TasteException {
  String urlPath = "/because/" + userID + '/' + itemID + "?howMany=" + howMany;

  TasteException savedException = null;
  for (HostAndPort replica : choosePartitionAndReplicas(userID)) {
    HttpURLConnection connection = null;
    try {
      connection = buildConnectionToReplica(replica, urlPath, "GET");
      switch (connection.getResponseCode()) {
        case HttpURLConnection.HTTP_OK:
          return consumeItems(connection);
        case HttpURLConnection.HTTP_NOT_FOUND:
          String connectionMessage = connection.getResponseMessage();
          if (connectionMessage != null &&
              connectionMessage.contains(NoSuchUserException.class.getSimpleName())) {
            throw new NoSuchUserException(userID);
          } else {
            throw new NoSuchItemException(itemID);
          }
        case HttpURLConnection.HTTP_UNAVAILABLE:
          throw new NotReadyException();
        default:
          throw new TasteException(connection.getResponseCode() + " " + connection.getResponseMessage());
      }
    } catch (TasteException te) {
      log.info("Can't access {} at {}: ({})", urlPath, replica, te.toString());
      savedException = te;
    } catch (IOException ioe) {
      log.info("Can't access {} at {}: ({})", urlPath, replica, ioe.toString());
      savedException = new TasteException(ioe);
    } finally {
      if (connection != null) {
        connection.disconnect();
      }
    }
  }
  throw savedException;
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
@Test
public void testRecommend() throws Exception {

  ClientRecommender client = getClient();
  List<RecommendedItem> recs = client.recommend(1L, 3);

  assertNotNull(recs);
  assertEquals(3, recs.size());

  log.info("{}", recs);

  assertEquals(475L, recs.get(0).getItemID());
  assertEquals(582L, recs.get(1).getItemID());
  assertEquals(403L, recs.get(2).getItemID());

  try {
    client.recommend(0L, 3);
    fail();
  } catch (NoSuchUserException nsue) {
    // good
  }

  recs = client.recommend(1L, 3, true, (String[]) null);

  assertNotNull(recs);
  assertEquals(3, recs.size());

  log.info("{}", recs);

  assertEquals(179L, recs.get(0).getItemID());
  assertEquals(475L, recs.get(1).getItemID());
  assertEquals(135L, recs.get(2).getItemID());
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
/**
 * Like {@link #recommend(long, int, IDRescorer)} but supplies no rescorer.
 */
@Override
public List<RecommendedItem> recommend(long userID, int howMany) throws NoSuchUserException, NotReadyException {
  return recommend(userID, howMany, null);
}
 

import org.apache.mahout.cf.taste.common.NoSuchUserException; //导入依赖的package包/类
/**
 * <p>Lists the items that were most influential in recommending a given item to a given user. Exactly how this
 * is determined is left to the implementation, but, generally this will return items that the user prefers
 * and that are similar to the given item.</p>
 *
 * <p>These values by which the results are ordered are opaque values and have no interpretation
 * other than that larger means stronger.</p>
 *
 * @param userID ID of user who was recommended the item
 * @param itemID ID of item that was recommended
 * @param howMany maximum number of items to return
 * @return {@link List} of {@link RecommendedItem}, ordered from most influential in recommended the given
 *  item to least
 * @throws NoSuchUserException if the user is not known in the model
 * @throws NoSuchItemException if the item is not known in the model
 * @throws NotReadyException if the recommender has no model available yet
 */
@Override
public List<RecommendedItem> recommendedBecause(long userID, long itemID, int howMany)
    throws NoSuchUserException, NoSuchItemException, NotReadyException {

  Preconditions.checkArgument(howMany > 0, "howMany must be positive");

  Generation generation = getCurrentGeneration();
  FastByIDMap<FastIDSet> knownItemIDs = generation.getKnownItemIDs();
  if (knownItemIDs == null) {
    throw new UnsupportedOperationException("No known item IDs available");
  }

  Lock knownItemLock = generation.getKnownItemLock().readLock();
  FastIDSet userKnownItemIDs;
  knownItemLock.lock();
  try {
    userKnownItemIDs = knownItemIDs.get(userID);
  } finally {
    knownItemLock.unlock();
  }
  if (userKnownItemIDs == null) {
    throw new NoSuchUserException(userID);
  }

  FastByIDMap<float[]> Y = generation.getY();

  Lock yLock = generation.getYLock().readLock();
  yLock.lock();
  try {

    float[] features = Y.get(itemID);
    if (features == null) {
      throw new NoSuchItemException(itemID);
    }
    FastByIDMap<float[]> toFeatures;
    synchronized (userKnownItemIDs) {
      toFeatures = new FastByIDMap<float[]>(userKnownItemIDs.size());
      LongPrimitiveIterator it = userKnownItemIDs.iterator();
      while (it.hasNext()) {
        long fromItemID = it.nextLong();
        float[] fromFeatures = Y.get(fromItemID);
        toFeatures.put(fromItemID, fromFeatures);
      }
    }

    return TopN.selectTopN(new RecommendedBecauseIterator(toFeatures.entrySet().iterator(), 
                                                          generation.getUserTagIDs(), 
                                                          features), 
                           howMany);
  } finally {
    yLock.unlock();
  }
}