You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@solr.apache.org by kr...@apache.org on 2022/02/21 16:35:40 UTC
[solr] branch branch_9_0 updated: SOLR-14920, SOLR-16029: contrib/ltr/src/java: apply & enforce 'spotless' code formatting (#189)
This is an automated email from the ASF dual-hosted git repository.
krisden pushed a commit to branch branch_9_0
in repository https://gitbox.apache.org/repos/asf/solr.git
The following commit(s) were added to refs/heads/branch_9_0 by this push:
new 1c81159 SOLR-14920, SOLR-16029: contrib/ltr/src/java: apply & enforce 'spotless' code formatting (#189)
1c81159 is described below
commit 1c8115905de6e200c6fcaee93df41aa193a596f0
Author: Christine Poerschke <cp...@apache.org>
AuthorDate: Mon Feb 21 16:29:16 2022 +0000
SOLR-14920, SOLR-16029: contrib/ltr/src/java: apply & enforce 'spotless' code formatting (#189)
---
gradle/validation/spotless.gradle | 4 +-
.../java/org/apache/solr/ltr/CSVFeatureLogger.java | 26 +-
.../ltr/src/java/org/apache/solr/ltr/DocInfo.java | 5 +-
.../java/org/apache/solr/ltr/FeatureLogger.java | 52 ++--
.../src/java/org/apache/solr/ltr/LTRRescorer.java | 144 ++++++-----
.../java/org/apache/solr/ltr/LTRScoringQuery.java | 237 +++++++++--------
.../java/org/apache/solr/ltr/LTRThreadModule.java | 69 ++---
.../solr/ltr/SolrQueryRequestContextUtils.java | 24 +-
.../java/org/apache/solr/ltr/feature/Feature.java | 207 +++++++--------
.../apache/solr/ltr/feature/FeatureException.java | 1 -
.../solr/ltr/feature/FieldLengthFeature.java | 80 +++---
.../apache/solr/ltr/feature/FieldValueFeature.java | 135 +++++-----
.../solr/ltr/feature/OriginalScoreFeature.java | 55 ++--
.../org/apache/solr/ltr/feature/SolrFeature.java | 102 ++++----
.../org/apache/solr/ltr/feature/ValueFeature.java | 74 +++---
.../org/apache/solr/ltr/feature/package-info.java | 4 +-
.../apache/solr/ltr/interleaving/Interleaving.java | 34 +--
.../solr/ltr/interleaving/InterleavingResult.java | 9 +-
.../ltr/interleaving/LTRInterleavingQuery.java | 29 ++-
.../ltr/interleaving/LTRInterleavingRescorer.java | 87 ++++---
.../interleaving/LTRInterleavingScoringQuery.java | 8 +-
.../OriginalRankingLTRScoringQuery.java | 1 -
.../algorithms/TeamDraftInterleaving.java | 74 +++---
.../ltr/interleaving/algorithms/package-info.java | 4 +-
.../apache/solr/ltr/interleaving/package-info.java | 4 +-
.../org/apache/solr/ltr/model/AdapterModel.java | 15 +-
.../apache/solr/ltr/model/DefaultWrapperModel.java | 42 +--
.../org/apache/solr/ltr/model/LTRScoringModel.java | 213 ++++++++--------
.../org/apache/solr/ltr/model/LinearModel.java | 116 +++++----
.../org/apache/solr/ltr/model/ModelException.java | 1 -
.../solr/ltr/model/MultipleAdditiveTreesModel.java | 214 +++++++++-------
.../apache/solr/ltr/model/NeuralNetworkModel.java | 282 ++++++++++++---------
.../org/apache/solr/ltr/model/WrapperModel.java | 63 +++--
.../org/apache/solr/ltr/model/package-info.java | 4 +-
.../apache/solr/ltr/norm/IdentityNormalizer.java | 15 +-
.../org/apache/solr/ltr/norm/MinMaxNormalizer.java | 41 +--
.../java/org/apache/solr/ltr/norm/Normalizer.java | 22 +-
.../apache/solr/ltr/norm/NormalizerException.java | 1 -
.../apache/solr/ltr/norm/StandardNormalizer.java | 42 +--
.../org/apache/solr/ltr/norm/package-info.java | 5 +-
.../src/java/org/apache/solr/ltr/package-info.java | 44 ++--
.../LTRFeatureLoggerTransformerFactory.java | 259 +++++++++++--------
.../LTRInterleavingTransformerFactory.java | 38 ++-
.../solr/ltr/response/transform/package-info.java | 5 +-
.../apache/solr/ltr/search/LTRQParserPlugin.java | 135 +++++-----
.../java/org/apache/solr/ltr/search/LTRQuery.java | 19 +-
.../org/apache/solr/ltr/search/package-info.java | 5 +-
.../org/apache/solr/ltr/store/FeatureStore.java | 11 +-
.../java/org/apache/solr/ltr/store/ModelStore.java | 14 +-
.../org/apache/solr/ltr/store/package-info.java | 4 +-
.../solr/ltr/store/rest/ManagedFeatureStore.java | 94 ++++---
.../solr/ltr/store/rest/ManagedModelStore.java | 180 +++++++------
.../apache/solr/ltr/store/rest/package-info.java | 4 +-
53 files changed, 1778 insertions(+), 1579 deletions(-)
diff --git a/gradle/validation/spotless.gradle b/gradle/validation/spotless.gradle
index bfb00bc..a6c1472 100644
--- a/gradle/validation/spotless.gradle
+++ b/gradle/validation/spotless.gradle
@@ -52,7 +52,6 @@ configure(project(":solr").subprojects) { prj ->
case ":solr:modules:hadoop-auth":
case ":solr:modules:hdfs":
case ":solr:modules:langid":
- case ":solr:modules:ltr":
case ":solr:modules:scripting":
case ":solr:core":
case ":solr:solrj":
@@ -60,6 +59,9 @@ configure(project(":solr").subprojects) { prj ->
case ":solr:test-framework":
targetExclude "src/**/*.java"
break
+ case ":solr:modules:ltr":
+ targetExclude "src/test/**/*.java"
+ break
}
}
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/CSVFeatureLogger.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/CSVFeatureLogger.java
index 2da754e..244b1b7 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/CSVFeatureLogger.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/CSVFeatureLogger.java
@@ -16,9 +16,7 @@
*/
package org.apache.solr.ltr;
-/**
- * A feature logger that logs in csv format.
- */
+/** A feature logger that logs in csv format. */
public class CSVFeatureLogger extends FeatureLogger {
public static final char DEFAULT_KEY_VALUE_SEPARATOR = '=';
public static final char DEFAULT_FEATURE_SEPARATOR = ',';
@@ -39,24 +37,22 @@ public class CSVFeatureLogger extends FeatureLogger {
@Override
public String makeFeatureVector(LTRScoringQuery.FeatureInfo[] featuresInfo) {
- // Allocate the buffer to a size based on the number of features instead of the
- // default 16. You need space for the name, value, and two separators per feature,
- // but not all the features are expected to fire, so this is just a naive estimate.
+ // Allocate the buffer to a size based on the number of features instead of the
+ // default 16. You need space for the name, value, and two separators per feature,
+ // but not all the features are expected to fire, so this is just a naive estimate.
StringBuilder sb = new StringBuilder(featuresInfo.length * 3);
boolean isDense = featureFormat.equals(FeatureFormat.DENSE);
- for (LTRScoringQuery.FeatureInfo featInfo:featuresInfo) {
- if (featInfo.isUsed() || isDense){
+ for (LTRScoringQuery.FeatureInfo featInfo : featuresInfo) {
+ if (featInfo.isUsed() || isDense) {
sb.append(featInfo.getName())
- .append(keyValueSep)
- .append(featInfo.getValue())
- .append(featureSep);
+ .append(keyValueSep)
+ .append(featInfo.getValue())
+ .append(featureSep);
}
}
- final String features = (sb.length() > 0 ?
- sb.substring(0, sb.length() - 1) : "");
+ final String features = (sb.length() > 0 ? sb.substring(0, sb.length() - 1) : "");
return features;
}
-
-}
\ No newline at end of file
+}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/DocInfo.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/DocInfo.java
index b3dfb9e..e454d90 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/DocInfo.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/DocInfo.java
@@ -18,7 +18,7 @@ package org.apache.solr.ltr;
import java.util.HashMap;
-public class DocInfo extends HashMap<String,Object> {
+public class DocInfo extends HashMap<String, Object> {
// Name of key used to store the original score of a doc
private static final String ORIGINAL_DOC_SCORE = "ORIGINAL_DOC_SCORE";
@@ -32,11 +32,10 @@ public class DocInfo extends HashMap<String,Object> {
}
public Float getOriginalDocScore() {
- return (Float)get(ORIGINAL_DOC_SCORE);
+ return (Float) get(ORIGINAL_DOC_SCORE);
}
public boolean hasOriginalDocScore() {
return containsKey(ORIGINAL_DOC_SCORE);
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/FeatureLogger.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/FeatureLogger.java
index ec14ab9..1b43511 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/FeatureLogger.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/FeatureLogger.java
@@ -19,15 +19,18 @@ package org.apache.solr.ltr;
import org.apache.solr.search.SolrIndexSearcher;
/**
- * FeatureLogger can be registered in a model and provide a strategy for logging
- * the feature values.
+ * FeatureLogger can be registered in a model and provide a strategy for logging the feature values.
*/
public abstract class FeatureLogger {
- /** the name of the cache using for storing the feature value **/
+ /** the name of the cache using for storing the feature value */
private final String fvCacheName;
- public enum FeatureFormat {DENSE, SPARSE};
+ public enum FeatureFormat {
+ DENSE,
+ SPARSE
+ };
+
protected final FeatureFormat featureFormat;
protected FeatureLogger(String fvCacheName, FeatureFormat f) {
@@ -36,46 +39,45 @@ public abstract class FeatureLogger {
}
/**
- * Log will be called every time that the model generates the feature values
- * for a document and a query.
+ * Log will be called every time that the model generates the feature values for a document and a
+ * query.
*
- * @param docid
- * Solr document id whose features we are saving
- * @param featuresInfo
- * List of all the {@link LTRScoringQuery.FeatureInfo} objects which contain name and value
- * for all the features triggered by the result set
- * @return true if the logger successfully logged the features, false
- * otherwise.
+ * @param docid Solr document id whose features we are saving
+ * @param featuresInfo List of all the {@link LTRScoringQuery.FeatureInfo} objects which contain
+ * name and value for all the features triggered by the result set
+ * @return true if the logger successfully logged the features, false otherwise.
*/
-
- public boolean log(int docid, LTRScoringQuery scoringQuery,
- SolrIndexSearcher searcher, LTRScoringQuery.FeatureInfo[] featuresInfo) {
+ public boolean log(
+ int docid,
+ LTRScoringQuery scoringQuery,
+ SolrIndexSearcher searcher,
+ LTRScoringQuery.FeatureInfo[] featuresInfo) {
final String featureVector = makeFeatureVector(featuresInfo);
if (featureVector == null) {
return false;
}
- return searcher.cacheInsert(fvCacheName,
- fvCacheKey(scoringQuery, docid), featureVector) != null;
+ if (null == searcher.cacheInsert(fvCacheName, fvCacheKey(scoringQuery, docid), featureVector)) {
+ return false;
+ }
+
+ return true;
}
public abstract String makeFeatureVector(LTRScoringQuery.FeatureInfo[] featuresInfo);
private static int fvCacheKey(LTRScoringQuery scoringQuery, int docid) {
- return scoringQuery.hashCode() + (31 * docid);
+ return scoringQuery.hashCode() + (31 * docid);
}
/**
* populate the document with its feature vector
*
- * @param docid
- * Solr document id
+ * @param docid Solr document id
* @return String representation of the list of features calculated for docid
*/
-
- public String getFeatureVector(int docid, LTRScoringQuery scoringQuery,
- SolrIndexSearcher searcher) {
+ public String getFeatureVector(
+ int docid, LTRScoringQuery scoringQuery, SolrIndexSearcher searcher) {
return (String) searcher.cacheLookup(fvCacheName, fvCacheKey(scoringQuery, docid));
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRRescorer.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRRescorer.java
index 4909a6f..6407034 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRRescorer.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRRescorer.java
@@ -20,7 +20,6 @@ import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.ReaderUtil;
import org.apache.lucene.search.Explanation;
@@ -34,16 +33,14 @@ import org.apache.lucene.search.Weight;
import org.apache.solr.ltr.interleaving.OriginalRankingLTRScoringQuery;
import org.apache.solr.search.SolrIndexSearcher;
-
/**
- * Implements the rescoring logic. The top documents returned by solr with their
- * original scores, will be processed by a {@link LTRScoringQuery} that will assign a
- * new score to each document. The top documents will be resorted based on the
- * new score.
- * */
+ * Implements the rescoring logic. The top documents returned by solr with their original scores,
+ * will be processed by a {@link LTRScoringQuery} that will assign a new score to each document. The
+ * top documents will be resorted based on the new score.
+ */
public class LTRRescorer extends Rescorer {
- final private LTRScoringQuery scoringQuery;
+ private final LTRScoringQuery scoringQuery;
public LTRRescorer() {
this.scoringQuery = null;
@@ -53,20 +50,21 @@ public class LTRRescorer extends Rescorer {
this.scoringQuery = scoringQuery;
}
- final private static Comparator<ScoreDoc> docComparator = Comparator.comparingInt(a -> a.doc);
+ private static final Comparator<ScoreDoc> docComparator = Comparator.comparingInt(a -> a.doc);
- final protected static Comparator<ScoreDoc> scoreComparator = (a, b) -> {
- // Sort by score descending, then docID ascending:
- if (a.score > b.score) {
- return -1;
- } else if (a.score < b.score) {
- return 1;
- } else {
- // This subtraction can't overflow int
- // because docIDs are >= 0:
- return a.doc - b.doc;
- }
- };
+ protected static final Comparator<ScoreDoc> scoreComparator =
+ (a, b) -> {
+ // Sort by score descending, then docID ascending:
+ if (a.score > b.score) {
+ return -1;
+ } else if (a.score < b.score) {
+ return 1;
+ } else {
+ // This subtraction can't overflow int
+ // because docIDs are >= 0:
+ return a.doc - b.doc;
+ }
+ };
protected static void heapAdjust(ScoreDoc[] hits, int size, int root) {
final ScoreDoc doc = hits[root];
@@ -112,16 +110,13 @@ public class LTRRescorer extends Rescorer {
/**
* rescores the documents:
*
- * @param searcher
- * current IndexSearcher
- * @param firstPassTopDocs
- * documents to rerank;
- * @param topN
- * documents to return;
+ * @param searcher current IndexSearcher
+ * @param firstPassTopDocs documents to rerank;
+ * @param topN documents to return;
*/
@Override
- public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs,
- int topN) throws IOException {
+ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int topN)
+ throws IOException {
if ((topN == 0) || (firstPassTopDocs.scoreDocs.length == 0)) {
return firstPassTopDocs;
}
@@ -133,13 +128,15 @@ public class LTRRescorer extends Rescorer {
return new TopDocs(firstPassTopDocs.totalHits, reranked);
}
- private ScoreDoc[] rerank(IndexSearcher searcher, int topN, ScoreDoc[] firstPassResults) throws IOException {
+ private ScoreDoc[] rerank(IndexSearcher searcher, int topN, ScoreDoc[] firstPassResults)
+ throws IOException {
final ScoreDoc[] reranked = new ScoreDoc[topN];
final List<LeafReaderContext> leaves = searcher.getIndexReader().leaves();
- final LTRScoringQuery.ModelWeight modelWeight = (LTRScoringQuery.ModelWeight) searcher
- .createWeight(searcher.rewrite(scoringQuery), ScoreMode.COMPLETE, 1);
+ final LTRScoringQuery.ModelWeight modelWeight =
+ (LTRScoringQuery.ModelWeight)
+ searcher.createWeight(searcher.rewrite(scoringQuery), ScoreMode.COMPLETE, 1);
- scoreFeatures(searcher,topN, modelWeight, firstPassResults, leaves, reranked);
+ scoreFeatures(searcher, topN, modelWeight, firstPassResults, leaves, reranked);
// Must sort all documents that we reranked, and then select the top
Arrays.sort(reranked, scoreComparator);
return reranked;
@@ -153,9 +150,14 @@ public class LTRRescorer extends Rescorer {
return hits;
}
- public void scoreFeatures(IndexSearcher indexSearcher,
- int topN, LTRScoringQuery.ModelWeight modelWeight, ScoreDoc[] hits, List<LeafReaderContext> leaves,
- ScoreDoc[] reranked) throws IOException {
+ public void scoreFeatures(
+ IndexSearcher indexSearcher,
+ int topN,
+ LTRScoringQuery.ModelWeight modelWeight,
+ ScoreDoc[] hits,
+ List<LeafReaderContext> leaves,
+ ScoreDoc[] reranked)
+ throws IOException {
int readerUpto = -1;
int endDoc = 0;
@@ -186,30 +188,43 @@ public class LTRRescorer extends Rescorer {
}
/**
- * Call this method if the {@link #scoreSingleHit(int, int, int, ScoreDoc, int, org.apache.solr.ltr.LTRScoringQuery.ModelWeight.ModelScorer, ScoreDoc[])}
- * method indicated that the document's feature info should be logged.
+ * Call this method if the {@link #scoreSingleHit(int, int, int, ScoreDoc, int,
+ * org.apache.solr.ltr.LTRScoringQuery.ModelWeight.ModelScorer, ScoreDoc[])} method indicated that
+ * the document's feature info should be logged.
*/
- protected static void logSingleHit(IndexSearcher indexSearcher, LTRScoringQuery.ModelWeight modelWeight, int docid, LTRScoringQuery scoringQuery) {
+ protected static void logSingleHit(
+ IndexSearcher indexSearcher,
+ LTRScoringQuery.ModelWeight modelWeight,
+ int docid,
+ LTRScoringQuery scoringQuery) {
final FeatureLogger featureLogger = scoringQuery.getFeatureLogger();
if (featureLogger != null && indexSearcher instanceof SolrIndexSearcher) {
- featureLogger.log(docid, scoringQuery, (SolrIndexSearcher)indexSearcher, modelWeight.getFeaturesInfo());
+ featureLogger.log(
+ docid, scoringQuery, (SolrIndexSearcher) indexSearcher, modelWeight.getFeaturesInfo());
}
}
/**
- * Scores a single document and returns true if the document's feature info should be logged via the
- * {@link #logSingleHit(IndexSearcher, org.apache.solr.ltr.LTRScoringQuery.ModelWeight, int, LTRScoringQuery)}
- * method. Feature info logging is only necessary for the topN documents.
+ * Scores a single document and returns true if the document's feature info should be logged via
+ * the {@link #logSingleHit(IndexSearcher, org.apache.solr.ltr.LTRScoringQuery.ModelWeight, int,
+ * LTRScoringQuery)} method. Feature info logging is only necessary for the topN documents.
*/
- protected static boolean scoreSingleHit(int topN, int docBase, int hitUpto, ScoreDoc hit, int docID, LTRScoringQuery.ModelWeight.ModelScorer scorer, ScoreDoc[] reranked) throws IOException {
- // Scorer for a LTRScoringQuery.ModelWeight should never be null since we always have to
- // call score
- // even if no feature scorers match, since a model might use that info to
- // return a
- // non-zero score. Same applies for the case of advancing a LTRScoringQuery.ModelWeight.ModelScorer
- // past the target
- // doc since the model algorithm still needs to compute a potentially
- // non-zero score from blank features.
+ protected static boolean scoreSingleHit(
+ int topN,
+ int docBase,
+ int hitUpto,
+ ScoreDoc hit,
+ int docID,
+ LTRScoringQuery.ModelWeight.ModelScorer scorer,
+ ScoreDoc[] reranked)
+ throws IOException {
+ /**
+ * Scorer for a LTRScoringQuery.ModelWeight should never be null since we always have to call
+ * score even if no feature scorers match, since a model might use that info to return a
+ * non-zero score. Same applies for the case of advancing a
+ * LTRScoringQuery.ModelWeight.ModelScorer past the target doc since the model algorithm still
+ * needs to compute a potentially non-zero score from blank features.
+ */
assert (scorer != null);
final int targetDoc = docID - docBase;
scorer.docID();
@@ -244,37 +259,39 @@ public class LTRRescorer extends Rescorer {
}
@Override
- public Explanation explain(IndexSearcher searcher,
- Explanation firstPassExplanation, int docID) throws IOException {
+ public Explanation explain(IndexSearcher searcher, Explanation firstPassExplanation, int docID)
+ throws IOException {
return getExplanation(searcher, docID, scoringQuery);
}
- protected static Explanation getExplanation(IndexSearcher searcher, int docID, LTRScoringQuery rerankingQuery) throws IOException {
- final List<LeafReaderContext> leafContexts = searcher.getTopReaderContext()
- .leaves();
+ protected static Explanation getExplanation(
+ IndexSearcher searcher, int docID, LTRScoringQuery rerankingQuery) throws IOException {
+ final List<LeafReaderContext> leafContexts = searcher.getTopReaderContext().leaves();
final int n = ReaderUtil.subIndex(docID, leafContexts);
final LeafReaderContext context = leafContexts.get(n);
final int deBasedDoc = docID - context.docBase;
final Weight rankingWeight;
if (rerankingQuery instanceof OriginalRankingLTRScoringQuery) {
- rankingWeight = rerankingQuery.getOriginalQuery().createWeight(searcher, ScoreMode.COMPLETE, 1);
+ rankingWeight =
+ rerankingQuery.getOriginalQuery().createWeight(searcher, ScoreMode.COMPLETE, 1);
} else {
- rankingWeight = searcher.createWeight(searcher.rewrite(rerankingQuery),
- ScoreMode.COMPLETE, 1);
+ rankingWeight =
+ searcher.createWeight(searcher.rewrite(rerankingQuery), ScoreMode.COMPLETE, 1);
}
return rankingWeight.explain(context, deBasedDoc);
}
- public static LTRScoringQuery.FeatureInfo[] extractFeaturesInfo(LTRScoringQuery.ModelWeight modelWeight,
+ public static LTRScoringQuery.FeatureInfo[] extractFeaturesInfo(
+ LTRScoringQuery.ModelWeight modelWeight,
int docid,
Float originalDocScore,
List<LeafReaderContext> leafContexts)
- throws IOException {
+ throws IOException {
final int n = ReaderUtil.subIndex(docid, leafContexts);
final LeafReaderContext atomicContext = leafContexts.get(n);
final int deBasedDoc = docid - atomicContext.docBase;
final LTRScoringQuery.ModelWeight.ModelScorer r = modelWeight.scorer(atomicContext);
- if ( (r == null) || (r.iterator().advance(deBasedDoc) != deBasedDoc) ) {
+ if ((r == null) || (r.iterator().advance(deBasedDoc) != deBasedDoc)) {
return new LTRScoringQuery.FeatureInfo[0];
} else {
if (originalDocScore != null) {
@@ -286,5 +303,4 @@ public class LTRRescorer extends Rescorer {
return modelWeight.getFeaturesInfo();
}
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java
index dcffbd6..a7b3d7b 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRScoringQuery.java
@@ -29,7 +29,6 @@ import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.Semaphore;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.DisiPriorityQueue;
import org.apache.lucene.search.DisiWrapper;
@@ -50,50 +49,53 @@ import org.apache.solr.request.SolrQueryRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-/**
- * The ranking query that is run, reranking results using the
- * LTRScoringModel algorithm
- */
+/** The ranking query that is run, reranking results using the LTRScoringModel algorithm */
public class LTRScoringQuery extends Query implements Accountable {
private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
- private static final long BASE_RAM_BYTES = RamUsageEstimator.shallowSizeOfInstance(LTRScoringQuery.class);
+ private static final long BASE_RAM_BYTES =
+ RamUsageEstimator.shallowSizeOfInstance(LTRScoringQuery.class);
// contains a description of the model
- final private LTRScoringModel ltrScoringModel;
- final private boolean extractAllFeatures;
- final private LTRThreadModule ltrThreadMgr;
- final private Semaphore querySemaphore; // limits the number of threads per query, so that multiple requests can be serviced simultaneously
+ private final LTRScoringModel ltrScoringModel;
+ private final boolean extractAllFeatures;
+ private final LTRThreadModule ltrThreadMgr;
+
+ // limits the number of threads per query, so that multiple requests can be serviced
+ // simultaneously
+ private final Semaphore querySemaphore;
// feature logger to output the features.
private FeatureLogger fl;
// Map of external parameters, such as query intent, that can be used by
// features
- final private Map<String,String[]> efi;
+ private final Map<String, String[]> efi;
// Original solr query used to fetch matching documents
private Query originalQuery;
// Original solr request
private SolrQueryRequest request;
public LTRScoringQuery(LTRScoringModel ltrScoringModel) {
- this(ltrScoringModel, Collections.<String,String[]>emptyMap(), false, null);
+ this(ltrScoringModel, Collections.<String, String[]>emptyMap(), false, null);
}
public LTRScoringQuery(LTRScoringModel ltrScoringModel, boolean extractAllFeatures) {
this(ltrScoringModel, Collections.<String, String[]>emptyMap(), extractAllFeatures, null);
}
- public LTRScoringQuery(LTRScoringModel ltrScoringModel,
+ public LTRScoringQuery(
+ LTRScoringModel ltrScoringModel,
Map<String, String[]> externalFeatureInfo,
- boolean extractAllFeatures, LTRThreadModule ltrThreadMgr) {
+ boolean extractAllFeatures,
+ LTRThreadModule ltrThreadMgr) {
this.ltrScoringModel = ltrScoringModel;
this.efi = externalFeatureInfo;
this.extractAllFeatures = extractAllFeatures;
this.ltrThreadMgr = ltrThreadMgr;
if (this.ltrThreadMgr != null) {
this.querySemaphore = this.ltrThreadMgr.createQuerySemaphore();
- } else{
+ } else {
this.querySemaphore = null;
}
}
@@ -122,7 +124,7 @@ public class LTRScoringQuery extends Query implements Accountable {
return originalQuery;
}
- public Map<String,String[]> getExternalFeatureInfo() {
+ public Map<String, String[]> getExternalFeatureInfo() {
return efi;
}
@@ -139,13 +141,11 @@ public class LTRScoringQuery extends Query implements Accountable {
final int prime = 31;
int result = classHash();
result = (prime * result) + ((ltrScoringModel == null) ? 0 : ltrScoringModel.hashCode());
- result = (prime * result)
- + ((originalQuery == null) ? 0 : originalQuery.hashCode());
+ result = (prime * result) + ((originalQuery == null) ? 0 : originalQuery.hashCode());
if (efi == null) {
result = (prime * result) + 0;
- }
- else {
- for (final Map.Entry<String,String[]> entry : efi.entrySet()) {
+ } else {
+ for (final Map.Entry<String, String[]> entry : efi.entrySet()) {
final String key = entry.getKey();
final String[] values = entry.getValue();
result = (prime * result) + key.hashCode();
@@ -155,9 +155,10 @@ public class LTRScoringQuery extends Query implements Accountable {
result = (prime * result) + this.toString().hashCode();
return result;
}
+
@Override
public boolean equals(Object o) {
- return sameClassAs(o) && equalsTo(getClass().cast(o));
+ return sameClassAs(o) && equalsTo(getClass().cast(o));
}
@Override
@@ -188,10 +189,10 @@ public class LTRScoringQuery extends Query implements Accountable {
if (other.efi == null || efi.size() != other.efi.size()) {
return false;
}
- for(final Map.Entry<String,String[]> entry : efi.entrySet()) {
+ for (final Map.Entry<String, String[]> entry : efi.entrySet()) {
final String key = entry.getKey();
final String[] otherValues = other.efi.get(key);
- if (otherValues == null || !Arrays.equals(otherValues,entry.getValue())) {
+ if (otherValues == null || !Arrays.equals(otherValues, entry.getValue())) {
return false;
}
}
@@ -209,31 +210,31 @@ public class LTRScoringQuery extends Query implements Accountable {
Collection<Feature> features = null;
if (this.extractAllFeatures) {
features = allFeatures;
+ } else {
+ features = modelFeatures;
}
- else{
- features = modelFeatures;
- }
- final Feature.FeatureWeight[] extractedFeatureWeights = new Feature.FeatureWeight[features.size()];
+ final Feature.FeatureWeight[] extractedFeatureWeights =
+ new Feature.FeatureWeight[features.size()];
final Feature.FeatureWeight[] modelFeaturesWeights = new Feature.FeatureWeight[modelFeatSize];
- List<Feature.FeatureWeight > featureWeights = new ArrayList<>(features.size());
+ List<Feature.FeatureWeight> featureWeights = new ArrayList<>(features.size());
if (querySemaphore == null) {
createWeights(searcher, scoreMode.needsScores(), featureWeights, features);
- }
- else{
+ } else {
createWeightsParallel(searcher, scoreMode.needsScores(), featureWeights, features);
}
- int i=0, j = 0;
+ int i = 0, j = 0;
if (this.extractAllFeatures) {
for (final Feature.FeatureWeight fw : featureWeights) {
extractedFeatureWeights[i++] = fw;
}
- for (final Feature f : modelFeatures){
- modelFeaturesWeights[j++] = extractedFeatureWeights[f.getIndex()]; // we can lookup by featureid because all features will be extracted when this.extractAllFeatures is set
+ for (final Feature f : modelFeatures) {
+ // we can lookup by featureid because all features will be
+ // extracted when this.extractAllFeatures is set
+ modelFeaturesWeights[j++] = extractedFeatureWeights[f.getIndex()];
}
- }
- else{
- for (final Feature.FeatureWeight fw: featureWeights){
+ } else {
+ for (final Feature.FeatureWeight fw : featureWeights) {
extractedFeatureWeights[i++] = fw;
modelFeaturesWeights[j++] = fw;
}
@@ -241,28 +242,33 @@ public class LTRScoringQuery extends Query implements Accountable {
return new ModelWeight(modelFeaturesWeights, extractedFeatureWeights, allFeatures.size());
}
- private void createWeights(IndexSearcher searcher, boolean needsScores,
- List<Feature.FeatureWeight > featureWeights, Collection<Feature> features) throws IOException {
+ private void createWeights(
+ IndexSearcher searcher,
+ boolean needsScores,
+ List<Feature.FeatureWeight> featureWeights,
+ Collection<Feature> features)
+ throws IOException {
final SolrQueryRequest req = getRequest();
// since the feature store is a linkedhashmap order is preserved
for (final Feature f : features) {
- try{
+ try {
Feature.FeatureWeight fw = f.createWeight(searcher, needsScores, req, originalQuery, efi);
featureWeights.add(fw);
} catch (final Exception e) {
- throw new RuntimeException("Exception from createWeight for " + f.toString() + " "
- + e.getMessage(), e);
+ throw new RuntimeException(
+ "Exception from createWeight for " + f.toString() + " " + e.getMessage(), e);
}
}
}
- private class CreateWeightCallable implements Callable<Feature.FeatureWeight>{
- final private Feature f;
- final private IndexSearcher searcher;
- final private boolean needsScores;
- final private SolrQueryRequest req;
+ private class CreateWeightCallable implements Callable<Feature.FeatureWeight> {
+ private final Feature f;
+ private final IndexSearcher searcher;
+ private final boolean needsScores;
+ private final SolrQueryRequest req;
- public CreateWeightCallable(Feature f, IndexSearcher searcher, boolean needsScores, SolrQueryRequest req){
+ public CreateWeightCallable(
+ Feature f, IndexSearcher searcher, boolean needsScores, SolrQueryRequest req) {
this.f = f;
this.searcher = searcher;
this.needsScores = needsScores;
@@ -270,13 +276,13 @@ public class LTRScoringQuery extends Query implements Accountable {
}
@Override
- public Feature.FeatureWeight call() throws Exception{
+ public Feature.FeatureWeight call() throws Exception {
try {
- Feature.FeatureWeight fw = f.createWeight(searcher, needsScores, req, originalQuery, efi);
+ Feature.FeatureWeight fw = f.createWeight(searcher, needsScores, req, originalQuery, efi);
return fw;
} catch (final Exception e) {
- throw new RuntimeException("Exception from createWeight for " + f.toString() + " "
- + e.getMessage(), e);
+ throw new RuntimeException(
+ "Exception from createWeight for " + f.toString() + " " + e.getMessage(), e);
} finally {
querySemaphore.release();
ltrThreadMgr.releaseLTRSemaphore();
@@ -284,21 +290,29 @@ public class LTRScoringQuery extends Query implements Accountable {
}
} // end of call CreateWeightCallable
- private void createWeightsParallel(IndexSearcher searcher, boolean needsScores,
- List<Feature.FeatureWeight > featureWeights, Collection<Feature> features) throws RuntimeException {
+ private void createWeightsParallel(
+ IndexSearcher searcher,
+ boolean needsScores,
+ List<Feature.FeatureWeight> featureWeights,
+ Collection<Feature> features)
+ throws RuntimeException {
final SolrQueryRequest req = getRequest();
- List<Future<Feature.FeatureWeight> > futures = new ArrayList<>(features.size());
- try{
+ List<Future<Feature.FeatureWeight>> futures = new ArrayList<>(features.size());
+ try {
for (final Feature f : features) {
CreateWeightCallable callable = new CreateWeightCallable(f, searcher, needsScores, req);
RunnableFuture<Feature.FeatureWeight> runnableFuture = new FutureTask<>(callable);
- querySemaphore.acquire(); // always acquire before the ltrSemaphore is acquired, to guarantee a that the current query is within the limit for max. threads
- ltrThreadMgr.acquireLTRSemaphore();//may block and/or interrupt
- ltrThreadMgr.execute(runnableFuture);//releases semaphore when done
+
+ // always acquire before the ltrSemaphore is acquired, to guarantee a that
+ // the current query is within the limit for max. threads
+ querySemaphore.acquire();
+
+ ltrThreadMgr.acquireLTRSemaphore(); // may block and/or interrupt
+ ltrThreadMgr.execute(runnableFuture); // releases semaphore when done
futures.add(runnableFuture);
}
- //Loop over futures to get the feature weight objects
+ // Loop over futures to get the feature weight objects
for (final Future<Feature.FeatureWeight> future : futures) {
featureWeights.add(future.get()); // future.get() will block if the job is still running
}
@@ -315,38 +329,41 @@ public class LTRScoringQuery extends Query implements Accountable {
@Override
public long ramBytesUsed() {
- return BASE_RAM_BYTES +
- RamUsageEstimator.sizeOfObject(efi) +
- RamUsageEstimator.sizeOfObject(ltrScoringModel) +
- RamUsageEstimator.sizeOfObject(originalQuery, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED);
+ return BASE_RAM_BYTES
+ + RamUsageEstimator.sizeOfObject(efi)
+ + RamUsageEstimator.sizeOfObject(ltrScoringModel)
+ + RamUsageEstimator.sizeOfObject(
+ originalQuery, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED);
}
public static class FeatureInfo {
- final private String name;
+ private final String name;
private float value;
private boolean used;
- FeatureInfo(String n, float v, boolean u){
- name = n; value = v; used = u;
+ FeatureInfo(String n, float v, boolean u) {
+ name = n;
+ value = v;
+ used = u;
}
- public void setValue(float value){
+ public void setValue(float value) {
this.value = value;
}
- public String getName(){
+ public String getName() {
return name;
}
- public float getValue(){
+ public float getValue() {
return value;
}
- public boolean isUsed(){
+ public boolean isUsed() {
return used;
}
- public void setUsed(boolean used){
+ public void setUsed(boolean used) {
this.used = used;
}
}
@@ -355,9 +372,9 @@ public class LTRScoringQuery extends Query implements Accountable {
// List of the model's features used for scoring. This is a subset of the
// features used for logging.
- final private Feature.FeatureWeight[] modelFeatureWeights;
- final private float[] modelFeatureValuesNormalized;
- final private Feature.FeatureWeight[] extractedFeatureWeights;
+ private final Feature.FeatureWeight[] modelFeatureWeights;
+ private final float[] modelFeatureValuesNormalized;
+ private final Feature.FeatureWeight[] extractedFeatureWeights;
// List of all the feature names, values - used for both scoring and logging
/*
@@ -370,7 +387,7 @@ public class LTRScoringQuery extends Query implements Accountable {
* we need a map which holds just the features that were triggered by the documents in the result set.
*
*/
- final private FeatureInfo[] featuresInfo;
+ private final FeatureInfo[] featuresInfo;
/*
* @param modelFeatureWeights
* - should be the same size as the number of features used by the model
@@ -381,8 +398,10 @@ public class LTRScoringQuery extends Query implements Accountable {
* @param allFeaturesSize
* - total number of feature in the feature store used by this model
*/
- public ModelWeight(Feature.FeatureWeight[] modelFeatureWeights,
- Feature.FeatureWeight[] extractedFeatureWeights, int allFeaturesSize) {
+ public ModelWeight(
+ Feature.FeatureWeight[] modelFeatureWeights,
+ Feature.FeatureWeight[] extractedFeatureWeights,
+ int allFeaturesSize) {
super(LTRScoringQuery.this);
this.extractedFeatureWeights = extractedFeatureWeights;
this.modelFeatureWeights = modelFeatureWeights;
@@ -391,16 +410,16 @@ public class LTRScoringQuery extends Query implements Accountable {
setFeaturesInfo();
}
- private void setFeaturesInfo(){
- for (int i = 0; i < extractedFeatureWeights.length;++i){
+ private void setFeaturesInfo() {
+ for (int i = 0; i < extractedFeatureWeights.length; ++i) {
String featName = extractedFeatureWeights[i].getName();
int featId = extractedFeatureWeights[i].getIndex();
float value = extractedFeatureWeights[i].getDefaultValue();
- featuresInfo[featId] = new FeatureInfo(featName,value,false);
+ featuresInfo[featId] = new FeatureInfo(featName, value, false);
}
}
- public FeatureInfo[] getFeaturesInfo(){
+ public FeatureInfo[] getFeaturesInfo() {
return featuresInfo;
}
@@ -420,16 +439,16 @@ public class LTRScoringQuery extends Query implements Accountable {
}
/**
- * Goes through all the stored feature values, and calculates the normalized
- * values for all the features that will be used for scoring.
- * Then calculate and return the model's score.
+ * Goes through all the stored feature values, and calculates the normalized values for all the
+ * features that will be used for scoring. Then calculate and return the model's score.
*/
private float makeNormalizedFeaturesAndScore() {
int pos = 0;
for (final Feature.FeatureWeight feature : modelFeatureWeights) {
final int featureId = feature.getIndex();
FeatureInfo fInfo = featuresInfo[featureId];
- if (fInfo.isUsed()) { // not checking for finfo == null as that would be a bug we should catch
+ // not checking for finfo == null as that would be a bug we should catch
+ if (fInfo.isUsed()) {
modelFeatureValuesNormalized[pos] = fInfo.getValue();
} else {
modelFeatureValuesNormalized[pos] = feature.getDefaultValue();
@@ -441,15 +460,14 @@ public class LTRScoringQuery extends Query implements Accountable {
}
@Override
- public Explanation explain(LeafReaderContext context, int doc)
- throws IOException {
+ public Explanation explain(LeafReaderContext context, int doc) throws IOException {
final Explanation[] explanations = new Explanation[this.featuresInfo.length];
for (final Feature.FeatureWeight feature : extractedFeatureWeights) {
explanations[feature.getIndex()] = feature.explain(context, doc);
}
final List<Explanation> featureExplanations = new ArrayList<>();
- for (int idx = 0 ;idx < modelFeatureWeights.length; ++idx) {
+ for (int idx = 0; idx < modelFeatureWeights.length; ++idx) {
final Feature.FeatureWeight f = modelFeatureWeights[idx];
Explanation e = ltrScoringModel.getNormalizerExplanation(explanations[f.getIndex()], idx);
featureExplanations.add(e);
@@ -460,14 +478,15 @@ public class LTRScoringQuery extends Query implements Accountable {
final float finalScore = bs.score();
return ltrScoringModel.explain(context, doc, finalScore, featureExplanations);
-
}
protected void reset() {
- for (int i = 0; i < extractedFeatureWeights.length;++i){
+ for (int i = 0; i < extractedFeatureWeights.length; ++i) {
int featId = extractedFeatureWeights[i].getIndex();
float value = extractedFeatureWeights[i].getDefaultValue();
- featuresInfo[featId].setValue(value); // need to set default value everytime as the default value is used in 'dense' mode even if used=false
+ // need to set default value everytime as the default value is used in 'dense'
+ // mode even if used=false
+ featuresInfo[featId].setValue(value);
featuresInfo[featId].setUsed(false);
}
}
@@ -475,8 +494,8 @@ public class LTRScoringQuery extends Query implements Accountable {
@Override
public ModelScorer scorer(LeafReaderContext context) throws IOException {
- final List<Feature.FeatureWeight.FeatureScorer> featureScorers = new ArrayList<Feature.FeatureWeight.FeatureScorer>(
- extractedFeatureWeights.length);
+ final List<Feature.FeatureWeight.FeatureScorer> featureScorers =
+ new ArrayList<Feature.FeatureWeight.FeatureScorer>(extractedFeatureWeights.length);
for (final Feature.FeatureWeight featureWeight : extractedFeatureWeights) {
final Feature.FeatureWeight.FeatureScorer scorer = featureWeight.scorer(context);
if (scorer != null) {
@@ -490,7 +509,6 @@ public class LTRScoringQuery extends Query implements Accountable {
// non 0 score for a given model.
ModelScorer mscorer = new ModelScorer(this, featureScorers);
return mscorer;
-
}
@Override
@@ -499,8 +517,8 @@ public class LTRScoringQuery extends Query implements Accountable {
}
public class ModelScorer extends Scorer {
- final private DocInfo docInfo;
- final private Scorer featureTraversalScorer;
+ private final DocInfo docInfo;
+ private final Scorer featureTraversalScorer;
public DocInfo getDocInfo() {
return docInfo;
@@ -546,18 +564,17 @@ public class LTRScoringQuery extends Query implements Accountable {
}
private class SparseModelScorer extends Scorer {
- final private DisiPriorityQueue subScorers;
- final private ScoringQuerySparseIterator itr;
+ private final DisiPriorityQueue subScorers;
+ private final ScoringQuerySparseIterator itr;
private int targetDoc = -1;
private int activeDoc = -1;
- private SparseModelScorer(Weight weight,
- List<Feature.FeatureWeight.FeatureScorer> featureScorers) {
+ private SparseModelScorer(
+ Weight weight, List<Feature.FeatureWeight.FeatureScorer> featureScorers) {
super(weight);
if (featureScorers.size() <= 1) {
- throw new IllegalArgumentException(
- "There must be at least 2 subScorers");
+ throw new IllegalArgumentException("There must be at least 2 subScorers");
}
subScorers = new DisiPriorityQueue(featureScorers.size());
for (final Scorer scorer : featureScorers) {
@@ -643,17 +660,16 @@ public class LTRScoringQuery extends Query implements Accountable {
return targetDoc;
}
}
-
}
private class DenseModelScorer extends Scorer {
private int activeDoc = -1; // The doc that our scorer's are actually at
private int targetDoc = -1; // The doc we were most recently told to go to
private int freq = -1;
- final private List<Feature.FeatureWeight.FeatureScorer> featureScorers;
+ private final List<Feature.FeatureWeight.FeatureScorer> featureScorers;
- private DenseModelScorer(Weight weight,
- List<Feature.FeatureWeight.FeatureScorer> featureScorers) {
+ private DenseModelScorer(
+ Weight weight, List<Feature.FeatureWeight.FeatureScorer> featureScorers) {
super(weight);
this.featureScorers = featureScorers;
}
@@ -685,7 +701,7 @@ public class LTRScoringQuery extends Query implements Accountable {
public float getMaxScore(int upTo) throws IOException {
return Float.POSITIVE_INFINITY;
}
-
+
@Override
public final Collection<ChildScorable> getChildren() {
final ArrayList<ChildScorable> children = new ArrayList<>();
@@ -726,8 +742,7 @@ public class LTRScoringQuery extends Query implements Accountable {
activeDoc = NO_MORE_DOCS;
for (final Scorer scorer : featureScorers) {
if (scorer.docID() != NO_MORE_DOCS) {
- activeDoc = Math.min(activeDoc,
- scorer.iterator().advance(target));
+ activeDoc = Math.min(activeDoc, scorer.iterator().advance(target));
}
}
}
@@ -743,10 +758,8 @@ public class LTRScoringQuery extends Query implements Accountable {
}
return sum;
}
-
}
}
}
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRThreadModule.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRThreadModule.java
index 2f5c337..dccae8b 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRThreadModule.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/LTRThreadModule.java
@@ -19,41 +19,43 @@ package org.apache.solr.ltr;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Semaphore;
-
import org.apache.solr.common.util.NamedList;
import org.apache.solr.util.SolrPluginUtils;
import org.apache.solr.util.plugin.NamedListInitializedPlugin;
/**
- * The LTRThreadModule is optionally used by the {@link org.apache.solr.ltr.search.LTRQParserPlugin} and
- * {@link org.apache.solr.ltr.response.transform.LTRFeatureLoggerTransformerFactory LTRFeatureLoggerTransformerFactory}
- * classes to parallelize the creation of {@link org.apache.solr.ltr.feature.Feature.FeatureWeight Feature.FeatureWeight}
- * objects.
- * <p>
- * Example configuration:
+ * The LTRThreadModule is optionally used by the {@link org.apache.solr.ltr.search.LTRQParserPlugin}
+ * and {@link org.apache.solr.ltr.response.transform.LTRFeatureLoggerTransformerFactory
+ * LTRFeatureLoggerTransformerFactory} classes to parallelize the creation of {@link
+ * org.apache.solr.ltr.feature.Feature.FeatureWeight Feature.FeatureWeight} objects.
+ *
+ * <p>Example configuration:
+ *
* <pre>
- <queryParser name="ltr" class="org.apache.solr.ltr.search.LTRQParserPlugin">
- <int name="threadModule.totalPoolThreads">10</int>
- <int name="threadModule.numThreadsPerRequest">5</int>
- </queryParser>
-
- <transformer name="features" class="org.apache.solr.ltr.response.transform.LTRFeatureLoggerTransformerFactory">
- <int name="threadModule.totalPoolThreads">10</int>
- <int name="threadModule.numThreadsPerRequest">5</int>
- </transformer>
-</pre>
- * If an individual solr instance is expected to receive no more than one query at a time, it is best
- * to set <code>totalPoolThreads</code> and <code>numThreadsPerRequest</code> to the same value.
+ * <queryParser name="ltr" class="org.apache.solr.ltr.search.LTRQParserPlugin">
+ * <int name="threadModule.totalPoolThreads">10</int>
+ * <int name="threadModule.numThreadsPerRequest">5</int>
+ * </queryParser>
+ *
+ * <transformer name="features" class="org.apache.solr.ltr.response.transform.LTRFeatureLoggerTransformerFactory">
+ * <int name="threadModule.totalPoolThreads">10</int>
+ * <int name="threadModule.numThreadsPerRequest">5</int>
+ * </transformer>
+ * </pre>
*
- * If multiple queries need to be serviced simultaneously then <code>totalPoolThreads</code> and
+ * If an individual solr instance is expected to receive no more than one query at a time, it is
+ * best to set <code>totalPoolThreads</code> and <code>numThreadsPerRequest</code> to the same
+ * value.
+ *
+ * <p>If multiple queries need to be serviced simultaneously then <code>totalPoolThreads</code> and
* <code>numThreadsPerRequest</code> can be adjusted based on the expected response times.
*
- * If the value of <code>numThreadsPerRequest</code> is higher, the response time for a single query
- * will be improved up to a point. If multiple queries are serviced simultaneously, the value of
- * <code>totalPoolThreads</code> imposes a contention between the queries if
- * <code>(totalPoolThreads < numThreadsPerRequest * total parallel queries)</code>.
+ * <p>If the value of <code>numThreadsPerRequest</code> is higher, the response time for a single
+ * query will be improved up to a point. If multiple queries are serviced simultaneously, the value
+ * of <code>totalPoolThreads</code> imposes a contention between the queries if <code>
+ * (totalPoolThreads < numThreadsPerRequest * total parallel queries)</code>.
*/
-public final class LTRThreadModule implements NamedListInitializedPlugin {
+public final class LTRThreadModule implements NamedListInitializedPlugin {
public static LTRThreadModule getInstance(NamedList<?> args) {
@@ -87,7 +89,7 @@ public final class LTRThreadModule implements NamedListInitializedPlugin {
// remove consumed keys only once iteration is complete
// since NamedList iterator does not support 'remove'
for (Object key : extractedArgs.asShallowMap().keySet()) {
- args.remove(CONFIG_PREFIX+key);
+ args.remove(CONFIG_PREFIX + key);
}
return extractedArgs;
@@ -101,8 +103,7 @@ public final class LTRThreadModule implements NamedListInitializedPlugin {
private Semaphore ltrSemaphore;
private volatile ExecutorService createWeightScoreExecutor;
- public LTRThreadModule() {
- }
+ public LTRThreadModule() {}
// For test use only.
LTRThreadModule(int totalPoolThreads, int numThreadsPerRequest) {
@@ -117,7 +118,7 @@ public final class LTRThreadModule implements NamedListInitializedPlugin {
SolrPluginUtils.invokeSetters(this, args);
}
validate();
- if (this.totalPoolThreads > 1 ){
+ if (this.totalPoolThreads > 1) {
ltrSemaphore = new Semaphore(totalPoolThreads);
} else {
ltrSemaphore = null;
@@ -125,14 +126,15 @@ public final class LTRThreadModule implements NamedListInitializedPlugin {
}
private void validate() {
- if (totalPoolThreads <= 0){
+ if (totalPoolThreads <= 0) {
throw new IllegalArgumentException("totalPoolThreads cannot be less than 1");
}
- if (numThreadsPerRequest <= 0){
+ if (numThreadsPerRequest <= 0) {
throw new IllegalArgumentException("numThreadsPerRequest cannot be less than 1");
}
- if (totalPoolThreads < numThreadsPerRequest){
- throw new IllegalArgumentException("numThreadsPerRequest cannot be greater than totalPoolThreads");
+ if (totalPoolThreads < numThreadsPerRequest) {
+ throw new IllegalArgumentException(
+ "numThreadsPerRequest cannot be greater than totalPoolThreads");
}
}
@@ -163,5 +165,4 @@ public final class LTRThreadModule implements NamedListInitializedPlugin {
public void setExecutor(ExecutorService sharedExecutor) {
this.createWeightScoreExecutor = sharedExecutor;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/SolrQueryRequestContextUtils.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/SolrQueryRequestContextUtils.java
index 295597b..57e790b 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/SolrQueryRequestContextUtils.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/SolrQueryRequestContextUtils.java
@@ -20,23 +20,22 @@ import org.apache.solr.request.SolrQueryRequest;
public class SolrQueryRequestContextUtils {
- /** key prefix to reduce possibility of clash with other code's key choices **/
+ /** key prefix to reduce possibility of clash with other code's key choices */
private static final String LTR_PREFIX = "ltr.";
- /** key of the feature logger in the request context **/
+ /** key of the feature logger in the request context */
private static final String FEATURE_LOGGER = LTR_PREFIX + "feature_logger";
- /** key of the scoring queries in the request context **/
+ /** key of the scoring queries in the request context */
private static final String SCORING_QUERIES = LTR_PREFIX + "scoring_queries";
- /** key of the isExtractingFeatures flag in the request context **/
+ /** key of the isExtractingFeatures flag in the request context */
private static final String IS_EXTRACTING_FEATURES = LTR_PREFIX + "isExtractingFeatures";
- /** key of the feature vector store name in the request context **/
+ /** key of the feature vector store name in the request context */
private static final String STORE = LTR_PREFIX + "store";
- /** feature logger accessors **/
-
+ /** feature logger accessors */
public static void setFeatureLogger(SolrQueryRequest req, FeatureLogger featureLogger) {
req.getContext().put(FEATURE_LOGGER, featureLogger);
}
@@ -45,8 +44,7 @@ public class SolrQueryRequestContextUtils {
return (FeatureLogger) req.getContext().get(FEATURE_LOGGER);
}
- /** scoring query accessors **/
-
+ /** scoring query accessors */
public static void setScoringQueries(SolrQueryRequest req, LTRScoringQuery[] scoringQueries) {
req.getContext().put(SCORING_QUERIES, scoringQueries);
}
@@ -55,8 +53,7 @@ public class SolrQueryRequestContextUtils {
return (LTRScoringQuery[]) req.getContext().get(SCORING_QUERIES);
}
- /** isExtractingFeatures flag accessors **/
-
+ /** isExtractingFeatures flag accessors */
public static void setIsExtractingFeatures(SolrQueryRequest req) {
req.getContext().put(IS_EXTRACTING_FEATURES, Boolean.TRUE);
}
@@ -69,8 +66,7 @@ public class SolrQueryRequestContextUtils {
return Boolean.TRUE.equals(req.getContext().get(IS_EXTRACTING_FEATURES));
}
- /** feature vector store name accessors **/
-
+ /** feature vector store name accessors */
public static void setFvStoreName(SolrQueryRequest req, String fvStoreName) {
req.getContext().put(STORE, fvStoreName);
}
@@ -78,6 +74,4 @@ public class SolrQueryRequestContextUtils {
public static String getFvStoreName(SolrQueryRequest req) {
return (String) req.getContext().get(STORE);
}
-
}
-
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java
index df6b60c..da6b1ad 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/Feature.java
@@ -19,7 +19,6 @@ package org.apache.solr.ltr.feature;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.DocIdSetIterator;
import org.apache.lucene.search.Explanation;
@@ -37,45 +36,52 @@ import org.apache.solr.request.macro.MacroExpander;
import org.apache.solr.util.SolrPluginUtils;
/**
- * A recipe for computing a feature. Subclass this for specialized feature calculations.
- * <p>
- * A feature consists of
+ * A recipe for computing a feature. Subclass this for specialized feature calculations.
+ *
+ * <p>A feature consists of
+ *
* <ul>
- * <li> a name as the identifier
- * <li> parameters to represent the specific feature
+ * <li>a name as the identifier
+ * <li>parameters to represent the specific feature
* </ul>
- * <p>
- * Example configuration (snippet):
- * <pre>{
- "class" : "...",
- "name" : "myFeature",
- "params" : {
- ...
- }
-}</pre>
- * <p>
- * {@link Feature} is an abstract class and concrete classes should implement
- * the {@link #validate()} function, and must implement the {@link #paramsToMap()}
- * and createWeight() methods.
+ *
+ * <p>Example configuration (snippet):
+ *
+ * <pre>
+ * {
+ * "class" : "...",
+ * "name" : "myFeature",
+ * "params" : {
+ * ...
+ * }
+ * }
+ * </pre>
+ *
+ * <p>{@link Feature} is an abstract class and concrete classes should implement the {@link
+ * #validate()} function, and must implement the {@link #paramsToMap()} and createWeight() methods.
*/
public abstract class Feature extends Query implements Accountable {
private static final long BASE_RAM_BYTES = RamUsageEstimator.shallowSizeOfInstance(Feature.class);
- final protected String name;
+ protected final String name;
private int index = -1;
private float defaultValue = 0.0f;
private Object defaultValueObject = null;
- final private Map<String,Object> params;
-
- public static Feature getInstance(SolrResourceLoader solrResourceLoader,
- String className, String name, Map<String,Object> params) {
- final Feature f = solrResourceLoader.newInstance(
- className,
- Feature.class,
- new String[0], // no sub packages
- new Class<?>[] { String.class, Map.class },
- new Object[] { name, params });
+ private final Map<String, Object> params;
+
+ public static Feature getInstance(
+ SolrResourceLoader solrResourceLoader,
+ String className,
+ String name,
+ Map<String, Object> params) {
+ final Feature f =
+ solrResourceLoader.newInstance(
+ className,
+ Feature.class,
+ new String[0], // no sub packages
+ new Class<?>[] {String.class, Map.class},
+ new Object[] {name, params});
if (params != null) {
SolrPluginUtils.invokeSetters(f, params.entrySet());
}
@@ -83,17 +89,16 @@ public abstract class Feature extends Query implements Accountable {
return f;
}
- public Feature(String name, Map<String,Object> params) {
+ public Feature(String name, Map<String, Object> params) {
this.name = name;
this.params = params;
}
/**
- * As part of creation of a feature instance, this function confirms
- * that the feature parameters are valid.
+ * As part of creation of a feature instance, this function confirms that the feature parameters
+ * are valid.
*
- * @throws FeatureException
- * Feature Exception
+ * @throws FeatureException Feature Exception
*/
protected abstract void validate() throws FeatureException;
@@ -102,7 +107,7 @@ public abstract class Feature extends Query implements Accountable {
final StringBuilder sb = new StringBuilder(64); // default initialCapacity of 16 won't be enough
sb.append(getClass().getSimpleName());
sb.append(" [name=").append(name);
- final LinkedHashMap<String,Object> params = paramsToMap();
+ final LinkedHashMap<String, Object> params = paramsToMap();
if (params != null) {
sb.append(", params=").append(params);
}
@@ -110,17 +115,22 @@ public abstract class Feature extends Query implements Accountable {
return sb.toString();
}
- public abstract FeatureWeight createWeight(IndexSearcher searcher,
- boolean needsScores, SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) throws IOException;
+ public abstract FeatureWeight createWeight(
+ IndexSearcher searcher,
+ boolean needsScores,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException;
public float getDefaultValue() {
return defaultValue;
}
- public void setDefaultValue(Object obj){
+ public void setDefaultValue(Object obj) {
this.defaultValueObject = obj;
if (obj instanceof String) {
- defaultValue = Float.parseFloat((String)obj);
+ defaultValue = Float.parseFloat((String) obj);
} else if (obj instanceof Double) {
defaultValue = ((Double) obj).floatValue();
} else if (obj instanceof Float) {
@@ -134,7 +144,6 @@ public abstract class Feature extends Query implements Accountable {
}
}
-
@Override
public int hashCode() {
final int prime = 31;
@@ -147,14 +156,14 @@ public abstract class Feature extends Query implements Accountable {
@Override
public boolean equals(Object o) {
- return sameClassAs(o) && equalsTo(getClass().cast(o));
+ return sameClassAs(o) && equalsTo(getClass().cast(o));
}
@Override
public long ramBytesUsed() {
- return BASE_RAM_BYTES +
- RamUsageEstimator.sizeOfObject(name) +
- RamUsageEstimator.sizeOfObject(params);
+ return BASE_RAM_BYTES
+ + RamUsageEstimator.sizeOfObject(name)
+ + RamUsageEstimator.sizeOfObject(params);
}
@Override
@@ -183,70 +192,63 @@ public abstract class Feature extends Query implements Accountable {
return true;
}
- /**
- * @return the name
- */
+ /** @return the name */
public String getName() {
return name;
}
- /**
- * @return the id
- */
+ /** @return the id */
public int getIndex() {
return index;
}
/**
- * @param index
- * Unique ID for this feature. Similar to feature name, except it can
- * be used to directly access the feature in the global list of
- * features.
+ * @param index Unique ID for this feature. Similar to feature name, except it can be used to
+ * directly access the feature in the global list of features.
*/
public void setIndex(int index) {
this.index = index;
}
- public abstract LinkedHashMap<String,Object> paramsToMap();
+ public abstract LinkedHashMap<String, Object> paramsToMap();
- protected LinkedHashMap<String,Object> defaultParamsToMap() {
- final LinkedHashMap<String,Object> params = new LinkedHashMap<>();
+ protected LinkedHashMap<String, Object> defaultParamsToMap() {
+ final LinkedHashMap<String, Object> params = new LinkedHashMap<>();
if (defaultValueObject != null) {
params.put("defaultValue", defaultValueObject);
}
return params;
}
- /**
- * Weight for a feature
- **/
+ /** Weight for a feature */
public abstract class FeatureWeight extends Weight {
- final protected IndexSearcher searcher;
- final protected SolrQueryRequest request;
- final protected Map<String,String[]> efi;
- final protected MacroExpander macroExpander;
- final protected Query originalQuery;
+ protected final IndexSearcher searcher;
+ protected final SolrQueryRequest request;
+ protected final Map<String, String[]> efi;
+ protected final MacroExpander macroExpander;
+ protected final Query originalQuery;
/**
- * Initialize a feature without the normalizer from the feature file. This is
- * called on initial construction since multiple models share the same
- * features, but have different normalizers. A concrete model's feature is
- * copied through featForNewModel().
+ * Initialize a feature without the normalizer from the feature file. This is called on initial
+ * construction since multiple models share the same features, but have different normalizers. A
+ * concrete model's feature is copied through featForNewModel().
*
- * @param q
- * Solr query associated with this FeatureWeight
- * @param searcher
- * Solr searcher available for features if they need them
+ * @param q Solr query associated with this FeatureWeight
+ * @param searcher Solr searcher available for features if they need them
*/
- public FeatureWeight(Query q, IndexSearcher searcher,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) {
+ public FeatureWeight(
+ Query q,
+ IndexSearcher searcher,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi) {
super(q);
this.searcher = searcher;
this.request = request;
this.originalQuery = originalQuery;
this.efi = efi;
- macroExpander = new MacroExpander(efi,true);
+ macroExpander = new MacroExpander(efi, true);
}
public String getName() {
@@ -262,8 +264,7 @@ public abstract class Feature extends Query implements Accountable {
}
@Override
- public abstract FeatureScorer scorer(LeafReaderContext context)
- throws IOException;
+ public abstract FeatureScorer scorer(LeafReaderContext context) throws IOException;
@Override
public boolean isCacheable(LeafReaderContext ctx) {
@@ -271,8 +272,7 @@ public abstract class Feature extends Query implements Accountable {
}
@Override
- public Explanation explain(LeafReaderContext context, int doc)
- throws IOException {
+ public Explanation explain(LeafReaderContext context, int doc) throws IOException {
final FeatureScorer r = scorer(context);
float score = getDefaultValue();
if (r != null) {
@@ -281,34 +281,30 @@ public abstract class Feature extends Query implements Accountable {
score = r.score();
}
return Explanation.match(score, toString());
- }else{
+ } else {
return Explanation.match(score, "The feature has no value");
}
}
/**
- * Used in the FeatureWeight's explain. Each feature should implement this
- * returning properties of the specific scorer useful for an explain. For
- * example "MyCustomClassFeature [name=" + name + "myVariable:" + myVariable +
- * "]"; If not provided, a default implementation will return basic feature
- * properties, which might not include query time specific values.
+ * Used in the FeatureWeight's explain. Each feature should implement this returning properties
+ * of the specific scorer useful for an explain. For example "MyCustomClassFeature [name=" +
+ * name + "myVariable:" + myVariable + "]"; If not provided, a default implementation will
+ * return basic feature properties, which might not include query time specific values.
*/
@Override
public String toString() {
return Feature.this.toString();
}
- /**
- * A 'recipe' for computing a feature
- */
+ /** A 'recipe' for computing a feature */
public abstract class FeatureScorer extends Scorer {
- final protected String name;
+ protected final String name;
private DocInfo docInfo;
- final protected DocIdSetIterator itr;
+ protected final DocIdSetIterator itr;
- public FeatureScorer(Feature.FeatureWeight weight,
- DocIdSetIterator itr) {
+ public FeatureScorer(Feature.FeatureWeight weight, DocIdSetIterator itr) {
super(weight);
this.itr = itr;
name = weight.getName();
@@ -318,9 +314,7 @@ public abstract class Feature extends Query implements Accountable {
@Override
public abstract float score() throws IOException;
- /**
- * Used to provide context from initial score steps to later reranking steps.
- */
+ /** Used to provide context from initial score steps to later reranking steps. */
public void setDocInfo(DocInfo docInfo) {
this.docInfo = docInfo;
}
@@ -341,12 +335,12 @@ public abstract class Feature extends Query implements Accountable {
}
/**
- * A <code>FeatureScorer</code> that contains a <code>Scorer</code>,
- * which it delegates to where appropriate.
+ * A <code>FeatureScorer</code> that contains a <code>Scorer</code>, which it delegates to where
+ * appropriate.
*/
public abstract class FilterFeatureScorer extends FeatureScorer {
- final protected Scorer in;
+ protected final Scorer in;
public FilterFeatureScorer(Feature.FeatureWeight weight, Scorer scorer) {
super(weight, null);
@@ -376,20 +370,17 @@ public abstract class Feature extends Query implements Accountable {
public float getMaxScore(int upTo) throws IOException {
return in.getMaxScore(upTo);
}
-
}
/**
- * Default FeatureScorer class that returns the score passed in. Can be used
- * as a simple ValueFeature, or to return a default scorer in case an
- * underlying feature's scorer is null.
+ * Default FeatureScorer class that returns the score passed in. Can be used as a simple
+ * ValueFeature, or to return a default scorer in case an underlying feature's scorer is null.
*/
public class ValueFeatureScorer extends FeatureScorer {
float constScore;
- public ValueFeatureScorer(FeatureWeight weight, float constScore,
- DocIdSetIterator itr) {
- super(weight,itr);
+ public ValueFeatureScorer(FeatureWeight weight, float constScore, DocIdSetIterator itr) {
+ super(weight, itr);
this.constScore = constScore;
}
@@ -403,7 +394,5 @@ public abstract class Feature extends Query implements Accountable {
return constScore;
}
}
-
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FeatureException.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FeatureException.java
index 6c8f827..86c3192 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FeatureException.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FeatureException.java
@@ -27,5 +27,4 @@ public class FeatureException extends RuntimeException {
public FeatureException(String message, Exception cause) {
super(message, cause);
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldLengthFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldLengthFeature.java
index 7bbfdb8..f4a454f 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldLengthFeature.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldLengthFeature.java
@@ -19,7 +19,6 @@ package org.apache.solr.ltr.feature;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
-
import org.apache.lucene.index.IndexableField;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.NumericDocValues;
@@ -28,20 +27,25 @@ import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.util.SmallFloat;
import org.apache.solr.request.SolrQueryRequest;
+
/**
- * This feature returns the length of a field (in terms) for the current document.
- * Example configuration:
- * <pre>{
- "name": "titleLength",
- "class": "org.apache.solr.ltr.feature.FieldLengthFeature",
- "params": {
- "field": "title"
- }
-}</pre>
- * Note: since this feature relies on norms values that are stored in a single byte
- * the value of the feature could have a lightly different value.
- * (see also {@link org.apache.lucene.search.similarities.ClassicSimilarity})
- **/
+ * This feature returns the length of a field (in terms) for the current document. Example
+ * configuration:
+ *
+ * <pre>
+ * {
+ * "name": "titleLength",
+ * "class": "org.apache.solr.ltr.feature.FieldLengthFeature",
+ * "params": {
+ * "field": "title"
+ * }
+ * }
+ * </pre>
+ *
+ * Note: since this feature relies on norms values that are stored in a single byte the value of the
+ * feature could have a lightly different value. (see also {@link
+ * org.apache.lucene.search.similarities.ClassicSimilarity})
+ */
public class FieldLengthFeature extends Feature {
private String field;
@@ -55,8 +59,8 @@ public class FieldLengthFeature extends Feature {
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
- final LinkedHashMap<String,Object> params = defaultParamsToMap();
+ public LinkedHashMap<String, Object> paramsToMap() {
+ final LinkedHashMap<String, Object> params = defaultParamsToMap();
params.put("field", field);
return params;
}
@@ -64,13 +68,11 @@ public class FieldLengthFeature extends Feature {
@Override
protected void validate() throws FeatureException {
if (field == null || field.isEmpty()) {
- throw new FeatureException(getClass().getSimpleName()+
- ": field must be provided");
+ throw new FeatureException(getClass().getSimpleName() + ": field must be provided");
}
}
/** Cache of decoded bytes. */
-
private static final float[] NORM_TABLE = new float[256];
static {
@@ -80,42 +82,44 @@ public class FieldLengthFeature extends Feature {
}
}
- /**
- * Decodes the norm value, assuming it is a single byte.
- *
- */
-
+ /** Decodes the norm value, assuming it is a single byte. */
private final float decodeNorm(long norm) {
return NORM_TABLE[(int) (norm & 0xFF)]; // & 0xFF maps negative bytes to
// positive above 127
}
- public FieldLengthFeature(String name, Map<String,Object> params) {
+ public FieldLengthFeature(String name, Map<String, Object> params) {
super(name, params);
}
@Override
- public FeatureWeight createWeight(IndexSearcher searcher, boolean needsScores,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi)
- throws IOException {
+ public FeatureWeight createWeight(
+ IndexSearcher searcher,
+ boolean needsScores,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
return new FieldLengthFeatureWeight(searcher, request, originalQuery, efi);
}
-
public class FieldLengthFeatureWeight extends FeatureWeight {
- public FieldLengthFeatureWeight(IndexSearcher searcher,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) {
+ public FieldLengthFeatureWeight(
+ IndexSearcher searcher,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi) {
super(FieldLengthFeature.this, searcher, request, originalQuery, efi);
}
@Override
public FeatureScorer scorer(LeafReaderContext context) throws IOException {
NumericDocValues norms = context.reader().getNormValues(field);
- if (norms == null){
- return new ValueFeatureScorer(this, 0f,
- DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
+ if (norms == null) {
+ return new ValueFeatureScorer(
+ this, 0f, DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
}
return new FieldLengthFeatureScorer(this, norms);
}
@@ -124,8 +128,8 @@ public class FieldLengthFeature extends Feature {
NumericDocValues norms = null;
- public FieldLengthFeatureScorer(FeatureWeight weight,
- NumericDocValues norms) throws IOException {
+ public FieldLengthFeatureScorer(FeatureWeight weight, NumericDocValues norms)
+ throws IOException {
super(weight, norms);
this.norms = norms;
@@ -133,8 +137,7 @@ public class FieldLengthFeature extends Feature {
final IndexableField idxF = searcher.doc(0).getField(field);
if (idxF.fieldType().omitNorms()) {
throw new IOException(
- "FieldLengthFeatures can't be used if omitNorms is enabled (field="
- + field + ")");
+ "FieldLengthFeatures can't be used if omitNorms is enabled (field=" + field + ")");
}
}
@@ -152,5 +155,4 @@ public class FieldLengthFeature extends Feature {
}
}
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldValueFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldValueFeature.java
index 563a01d..87c47be 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldValueFeature.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/FieldValueFeature.java
@@ -21,7 +21,6 @@ import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
-
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.DocValuesType;
@@ -41,27 +40,31 @@ import org.apache.solr.schema.SchemaField;
import org.apache.solr.search.SolrIndexSearcher;
/**
- * This feature returns the value of a field in the current document.
- * The field must have stored="true" or docValues="true" properties.
- * Example configuration:
- * <pre>{
- "name": "rawHits",
- "class": "org.apache.solr.ltr.feature.FieldValueFeature",
- "params": {
- "field": "hits"
- }
-}</pre>
+ * This feature returns the value of a field in the current document. The field must have
+ * stored="true" or docValues="true" properties. Example configuration:
+ *
+ * <pre>
+ * {
+ * "name": "rawHits",
+ * "class": "org.apache.solr.ltr.feature.FieldValueFeature",
+ * "params": {
+ * "field": "hits"
+ * }
+ * }
+ * </pre>
*
- * <p>There are 4 different types of FeatureScorers that a FieldValueFeatureWeight may use.
- * The chosen scorer depends on the field attributes.</p>
+ * <p>There are 4 different types of FeatureScorers that a FieldValueFeatureWeight may use. The
+ * chosen scorer depends on the field attributes.
*
- * <p>FieldValueFeatureScorer (FVFS): used for stored=true, no matter if docValues=true or docValues=false</p>
+ * <p>FieldValueFeatureScorer (FVFS): used for stored=true, no matter if docValues=true or
+ * docValues=false
+ *
+ * <p>NumericDocValuesFVFS: used for stored=false and docValues=true, if docValueType == NUMERIC
*
- * <p>NumericDocValuesFVFS: used for stored=false and docValues=true, if docValueType == NUMERIC</p>
* <p>SortedDocValuesFVFS: used for stored=false and docValues=true, if docValueType == SORTED
*
- * <p>DefaultValueFVFS: used for stored=false and docValues=true, a fallback scorer that is used on segments
- * where no document has a value set in the field of this feature</p>
+ * <p>DefaultValueFVFS: used for stored=false and docValues=true, a fallback scorer that is used on
+ * segments where no document has a value set in the field of this feature
*/
public class FieldValueFeature extends Feature {
@@ -78,8 +81,8 @@ public class FieldValueFeature extends Feature {
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
- final LinkedHashMap<String,Object> params = defaultParamsToMap();
+ public LinkedHashMap<String, Object> paramsToMap() {
+ final LinkedHashMap<String, Object> params = defaultParamsToMap();
params.put("field", field);
return params;
}
@@ -87,27 +90,33 @@ public class FieldValueFeature extends Feature {
@Override
protected void validate() throws FeatureException {
if (field == null || field.isEmpty()) {
- throw new FeatureException(getClass().getSimpleName()+
- ": field must be provided");
+ throw new FeatureException(getClass().getSimpleName() + ": field must be provided");
}
}
- public FieldValueFeature(String name, Map<String,Object> params) {
+ public FieldValueFeature(String name, Map<String, Object> params) {
super(name, params);
}
@Override
- public FeatureWeight createWeight(IndexSearcher searcher, boolean needsScores,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi)
- throws IOException {
+ public FeatureWeight createWeight(
+ IndexSearcher searcher,
+ boolean needsScores,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
return new FieldValueFeatureWeight(searcher, request, originalQuery, efi);
}
public class FieldValueFeatureWeight extends FeatureWeight {
private final SchemaField schemaField;
- public FieldValueFeatureWeight(IndexSearcher searcher,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) {
+ public FieldValueFeatureWeight(
+ IndexSearcher searcher,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi) {
super(FieldValueFeature.this, searcher, request, originalQuery, efi);
if (searcher instanceof SolrIndexSearcher) {
schemaField = ((SolrIndexSearcher) searcher).getSchema().getFieldOrNull(field);
@@ -128,34 +137,38 @@ public class FieldValueFeature extends Feature {
if (schemaField != null && !schemaField.stored() && schemaField.hasDocValues()) {
final FieldInfo fieldInfo = context.reader().getFieldInfos().fieldInfo(field);
- final DocValuesType docValuesType = fieldInfo != null ? fieldInfo.getDocValuesType() : DocValuesType.NONE;
+ final DocValuesType docValuesType =
+ fieldInfo != null ? fieldInfo.getDocValuesType() : DocValuesType.NONE;
if (DocValuesType.NUMERIC.equals(docValuesType)) {
- return new NumericDocValuesFieldValueFeatureScorer(this, context,
- DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS), schemaField.getType().getNumberType());
+ return new NumericDocValuesFieldValueFeatureScorer(
+ this,
+ context,
+ DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS),
+ schemaField.getType().getNumberType());
} else if (DocValuesType.SORTED.equals(docValuesType)) {
- return new SortedDocValuesFieldValueFeatureScorer(this, context,
- DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
+ return new SortedDocValuesFieldValueFeatureScorer(
+ this, context, DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
} else if (DocValuesType.NONE.equals(docValuesType)) {
- // Using a fallback feature scorer because this segment has no documents with a doc value for the current field
- return new DefaultValueFieldValueFeatureScorer(this, DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
+ // Using a fallback feature scorer because this segment has no documents with a doc value
+ // for the current field
+ return new DefaultValueFieldValueFeatureScorer(
+ this, DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
}
- throw new IllegalArgumentException("Doc values type " + docValuesType.name() + " of field " + field
- + " is not supported");
+ throw new IllegalArgumentException(
+ "Doc values type " + docValuesType.name() + " of field " + field + " is not supported");
}
- return new FieldValueFeatureScorer(this, context,
- DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
+ return new FieldValueFeatureScorer(
+ this, context, DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
}
- /**
- * A FeatureScorer that reads the stored value for a field
- */
+ /** A FeatureScorer that reads the stored value for a field */
public class FieldValueFeatureScorer extends FeatureScorer {
LeafReaderContext context = null;
- public FieldValueFeatureScorer(FeatureWeight weight,
- LeafReaderContext context, DocIdSetIterator itr) {
+ public FieldValueFeatureScorer(
+ FeatureWeight weight, LeafReaderContext context, DocIdSetIterator itr) {
super(weight, itr);
this.context = context;
}
@@ -164,8 +177,7 @@ public class FieldValueFeature extends Feature {
public float score() throws IOException {
try {
- final Document document = context.reader().document(itr.docID(),
- fieldAsSet);
+ final Document document = context.reader().document(itr.docID(), fieldAsSet);
final IndexableField indexableField = document.getField(field);
if (indexableField == null) {
return getDefaultValue();
@@ -189,9 +201,7 @@ public class FieldValueFeature extends Feature {
}
} catch (final IOException e) {
throw new FeatureException(
- e.toString() + ": " +
- "Unable to extract feature for "
- + name, e);
+ e.toString() + ": " + "Unable to extract feature for " + name, e);
}
return getDefaultValue();
}
@@ -202,15 +212,16 @@ public class FieldValueFeature extends Feature {
}
}
- /**
- * A FeatureScorer that reads the numeric docValues for a field
- */
+ /** A FeatureScorer that reads the numeric docValues for a field */
public final class NumericDocValuesFieldValueFeatureScorer extends FeatureScorer {
private final NumericDocValues docValues;
private final NumberType numberType;
- public NumericDocValuesFieldValueFeatureScorer(final FeatureWeight weight, final LeafReaderContext context,
- final DocIdSetIterator itr, final NumberType numberType) {
+ public NumericDocValuesFieldValueFeatureScorer(
+ final FeatureWeight weight,
+ final LeafReaderContext context,
+ final DocIdSetIterator itr,
+ final NumberType numberType) {
super(weight, itr);
this.numberType = numberType;
@@ -255,14 +266,12 @@ public class FieldValueFeature extends Feature {
}
}
- /**
- * A FeatureScorer that reads the sorted docValues for a field
- */
+ /** A FeatureScorer that reads the sorted docValues for a field */
public final class SortedDocValuesFieldValueFeatureScorer extends FeatureScorer {
private final SortedDocValues docValues;
- public SortedDocValuesFieldValueFeatureScorer(final FeatureWeight weight, final LeafReaderContext context,
- final DocIdSetIterator itr) {
+ public SortedDocValuesFieldValueFeatureScorer(
+ final FeatureWeight weight, final LeafReaderContext context, final DocIdSetIterator itr) {
super(weight, itr);
SortedDocValues docValues;
@@ -314,12 +323,14 @@ public class FieldValueFeature extends Feature {
/**
* A FeatureScorer that always returns the default value.
*
- * It is used as a fallback for cases when a segment does not have any documents that contain doc values for a field.
- * By doing so, we prevent a fallback to the FieldValueFeatureScorer, which would also return the default value but
- * in a less performant way because it would first try to read the stored fields for the doc (which aren't present).
+ * <p>It is used as a fallback for cases when a segment does not have any documents that contain
+ * doc values for a field. By doing so, we prevent a fallback to the FieldValueFeatureScorer,
+ * which would also return the default value but in a less performant way because it would first
+ * try to read the stored fields for the doc (which aren't present).
*/
public final class DefaultValueFieldValueFeatureScorer extends FeatureScorer {
- public DefaultValueFieldValueFeatureScorer(final FeatureWeight weight, final DocIdSetIterator itr) {
+ public DefaultValueFieldValueFeatureScorer(
+ final FeatureWeight weight, final DocIdSetIterator itr) {
super(weight, itr);
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java
index 68ceca7..a74e930 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/OriginalScoreFeature.java
@@ -19,7 +19,6 @@ package org.apache.solr.ltr.feature;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
@@ -28,48 +27,57 @@ import org.apache.lucene.search.Scorer;
import org.apache.lucene.search.Weight;
import org.apache.solr.ltr.DocInfo;
import org.apache.solr.request.SolrQueryRequest;
+
/**
- * This feature returns the original score that the document had before performing
- * the reranking.
+ * This feature returns the original score that the document had before performing the reranking.
* Example configuration:
- * <pre>{
- "name": "originalScore",
- "class": "org.apache.solr.ltr.feature.OriginalScoreFeature",
- "params": { }
-}</pre>
- **/
+ *
+ * <pre>
+ * {
+ * "name": "originalScore",
+ * "class": "org.apache.solr.ltr.feature.OriginalScoreFeature",
+ * "params": { }
+ * }
+ * </pre>
+ */
public class OriginalScoreFeature extends Feature {
- public OriginalScoreFeature(String name, Map<String,Object> params) {
+ public OriginalScoreFeature(String name, Map<String, Object> params) {
super(name, params);
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
+ public LinkedHashMap<String, Object> paramsToMap() {
return defaultParamsToMap();
}
@Override
- protected void validate() throws FeatureException {
- }
+ protected void validate() throws FeatureException {}
@Override
- public OriginalScoreWeight createWeight(IndexSearcher searcher,
- boolean needsScores, SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) throws IOException {
+ public OriginalScoreWeight createWeight(
+ IndexSearcher searcher,
+ boolean needsScores,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
return new OriginalScoreWeight(searcher, request, originalQuery, efi);
-
}
public class OriginalScoreWeight extends FeatureWeight {
final Weight w;
- public OriginalScoreWeight(IndexSearcher searcher,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) throws IOException {
+ public OriginalScoreWeight(
+ IndexSearcher searcher,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
super(OriginalScoreFeature.this, searcher, request, originalQuery, efi);
w = searcher.createWeight(searcher.rewrite(originalQuery), ScoreMode.COMPLETE, 1);
- };
-
+ }
@Override
public String toString() {
@@ -95,11 +103,10 @@ public class OriginalScoreFeature extends Feature {
// was already scored in step 1
// we shouldn't need to calc original score again.
final DocInfo docInfo = getDocInfo();
- return (docInfo != null && docInfo.hasOriginalDocScore() ? docInfo.getOriginalDocScore() : in.score());
+ return (docInfo != null && docInfo.hasOriginalDocScore()
+ ? docInfo.getOriginalDocScore()
+ : in.score());
}
-
}
-
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java
index 83b8b11..145e757 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/SolrFeature.java
@@ -21,7 +21,6 @@ import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MatchNoDocsQuery;
@@ -41,22 +40,28 @@ import org.apache.solr.search.SolrIndexSearcher;
import org.apache.solr.search.SyntaxError;
/**
- * This feature allows you to reuse any Solr query as a feature. The value
- * of the feature will be the score of the given query for the current document.
- * See <a href="https://solr.apache.org/guide/other-parsers.html">Solr documentation of other parsers</a> you can use as a feature.
- * Example configurations:
- * <pre>[{ "name": "isBook",
- "class": "org.apache.solr.ltr.feature.SolrFeature",
- "params":{ "fq": ["{!terms f=category}book"] }
-},
-{
- "name": "documentRecency",
- "class": "org.apache.solr.ltr.feature.SolrFeature",
- "params": {
- "q": "{!func}recip( ms(NOW,publish_date), 3.16e-11, 1, 1)"
- }
-}]</pre>
- **/
+ * This feature allows you to reuse any Solr query as a feature. The value of the feature will be
+ * the score of the given query for the current document. See <a
+ * href="https://solr.apache.org/solr/guide/other-parsers.html">Solr documentation of other
+ * parsers</a> you can use as a feature. Example configurations:
+ *
+ * <pre>
+ * [
+ * {
+ * "name": "isBook",
+ * "class": "org.apache.solr.ltr.feature.SolrFeature",
+ * "params":{ "fq": ["{!terms f=category}book"] }
+ * },
+ * {
+ * "name": "documentRecency",
+ * "class": "org.apache.solr.ltr.feature.SolrFeature",
+ * "params": {
+ * "q": "{!func}recip( ms(NOW,publish_date), 3.16e-11, 1, 1)"
+ * }
+ * }
+ * ]
+ * </pre>
+ */
public class SolrFeature extends Feature {
private String df;
@@ -89,13 +94,13 @@ public class SolrFeature extends Feature {
this.fq = fq;
}
- public SolrFeature(String name, Map<String,Object> params) {
+ public SolrFeature(String name, Map<String, Object> params) {
super(name, params);
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
- final LinkedHashMap<String,Object> params = defaultParamsToMap();
+ public LinkedHashMap<String, Object> paramsToMap() {
+ final LinkedHashMap<String, Object> params = defaultParamsToMap();
if (df != null) {
params.put("df", df);
}
@@ -109,29 +114,33 @@ public class SolrFeature extends Feature {
}
@Override
- public FeatureWeight createWeight(IndexSearcher searcher, boolean needsScores,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi)
- throws IOException {
+ public FeatureWeight createWeight(
+ IndexSearcher searcher,
+ boolean needsScores,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
return new SolrFeatureWeight((SolrIndexSearcher) searcher, request, originalQuery, efi);
}
@Override
protected void validate() throws FeatureException {
- if ((q == null || q.isEmpty()) &&
- ((fq == null) || fq.isEmpty())) {
- throw new FeatureException(getClass().getSimpleName()+
- ": Q or FQ must be provided");
+ if ((q == null || q.isEmpty()) && ((fq == null) || fq.isEmpty())) {
+ throw new FeatureException(getClass().getSimpleName() + ": Q or FQ must be provided");
}
}
- /**
- * Weight for a SolrFeature
- **/
+ /** Weight for a SolrFeature */
public class SolrFeatureWeight extends FeatureWeight {
private final Weight solrQueryWeight;
- public SolrFeatureWeight(SolrIndexSearcher searcher,
- SolrQueryRequest request, Query originalQuery, Map<String, String[]> efi) throws IOException {
+ public SolrFeatureWeight(
+ SolrIndexSearcher searcher,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
super(SolrFeature.this, searcher, request, originalQuery, efi);
try {
final SolrQueryRequest req = makeRequest(request.getCore(), q, fq, df);
@@ -147,10 +156,13 @@ public class SolrFeature extends Feature {
} else {
qStr = macroExpander.expand(qStr);
if (qStr == null) {
- throw new FeatureException(this.getClass().getSimpleName() + " requires efi parameter that was not passed in request.");
+ throw new FeatureException(
+ this.getClass().getSimpleName()
+ + " requires efi parameter that was not passed in request.");
}
scoreQuery = QParser.getParser(qStr, req).getQuery();
- // note: QParser can return a null Query sometimes, such as if the query is a stopword or just symbols
+ // note: QParser can return a null Query sometimes, such as if the query is a stopword or
+ // just symbols
if (scoreQuery == null) {
scoreQuery = new MatchNoDocsQuery(); // debatable; all or none?
}
@@ -159,12 +171,15 @@ public class SolrFeature extends Feature {
// Build the filter queries
Query filterDocSetQuery = null;
if (fq != null) {
- List<Query> filterQueries = new ArrayList<>(); // If there are no fqs we just want an empty list
+ List<Query> filterQueries =
+ new ArrayList<>(); // If there are no fqs we just want an empty list
for (String fqStr : fq) {
if (fqStr != null) {
fqStr = macroExpander.expand(fqStr);
if (fqStr == null) {
- throw new FeatureException(this.getClass().getSimpleName() + " requires efi parameter that was not passed in request.");
+ throw new FeatureException(
+ this.getClass().getSimpleName()
+ + " requires efi parameter that was not passed in request.");
}
final Query filterQuery = QParser.getParser(fqStr, req).getQuery();
if (filterQuery != null) {
@@ -188,8 +203,8 @@ public class SolrFeature extends Feature {
}
}
- private LocalSolrQueryRequest makeRequest(SolrCore core, String solrQuery,
- List<String> fqs, String df) {
+ private LocalSolrQueryRequest makeRequest(
+ SolrCore core, String solrQuery, List<String> fqs, String df) {
final NamedList<String> returnList = new NamedList<String>();
if ((solrQuery != null) && !solrQuery.isEmpty()) {
returnList.add(CommonParams.Q, solrQuery);
@@ -218,9 +233,7 @@ public class SolrFeature extends Feature {
return new SolrFeatureScorer(this, solrScorer);
}
- /**
- * Scorer for a SolrFeature
- */
+ /** Scorer for a SolrFeature */
public class SolrFeatureScorer extends FilterFeatureScorer {
public SolrFeatureScorer(FeatureWeight weight, Scorer solrScorer) {
@@ -233,12 +246,9 @@ public class SolrFeature extends Feature {
return in.score();
} catch (UnsupportedOperationException e) {
throw new FeatureException(
- e.toString() + ": " +
- "Unable to extract feature for "
- + name, e);
+ e.toString() + ": " + "Unable to extract feature for " + name, e);
}
}
-
}
}
-}
\ No newline at end of file
+}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/ValueFeature.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/ValueFeature.java
index 80e7d8c..2c13262 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/ValueFeature.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/ValueFeature.java
@@ -19,31 +19,33 @@ package org.apache.solr.ltr.feature;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.DocIdSetIterator;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.solr.request.SolrQueryRequest;
+
/**
* This feature allows to return a constant given value for the current document.
*
- * Example configuration:
- * <pre>{
- "name" : "userFromMobile",
- "class" : "org.apache.solr.ltr.feature.ValueFeature",
- "params" : { "value" : "${userFromMobile}", "required":true }
- }</pre>
+ * <p>Example configuration:
*
- *You can place a constant value like "1.3f" in the value params, but many times you
- *would want to pass in external information to use per request. For instance, maybe
- *you want to rank things differently if the search came from a mobile device, or maybe
- *you want to use your external query intent system as a feature.
- *In the rerank request you can pass in rq={... efi.userFromMobile=1}, and the above
- *feature will return 1 for all the docs for that request. If required is set to true,
- *the request will return an error since you failed to pass in the efi, otherwise if will
- *just skip the feature and use a default value of 0 instead.
- **/
+ * <pre>
+ * {
+ * "name" : "userFromMobile",
+ * "class" : "org.apache.solr.ltr.feature.ValueFeature",
+ * "params" : { "value" : "${userFromMobile}", "required":true }
+ * }
+ * </pre>
+ *
+ * You can place a constant value like "1.3f" in the value params, but many times you would want to
+ * pass in external information to use per request. For instance, maybe you want to rank things
+ * differently if the search came from a mobile device, or maybe you want to use your external query
+ * intent system as a feature. In the rerank request you can pass in rq={... efi.userFromMobile=1},
+ * and the above feature will return 1 for all the docs for that request. If required is set to
+ * true, the request will return an error since you failed to pass in the efi, otherwise if will
+ * just skip the feature and use a default value of 0 instead.
+ */
public class ValueFeature extends Feature {
private float configValue = -1f;
private String configValueStr = null;
@@ -81,8 +83,8 @@ public class ValueFeature extends Feature {
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
- final LinkedHashMap<String,Object> params = defaultParamsToMap();
+ public LinkedHashMap<String, Object> paramsToMap() {
+ final LinkedHashMap<String, Object> params = defaultParamsToMap();
params.put("value", value);
if (required != null) {
params.put("required", required);
@@ -97,32 +99,41 @@ public class ValueFeature extends Feature {
}
}
- public ValueFeature(String name, Map<String,Object> params) {
+ public ValueFeature(String name, Map<String, Object> params) {
super(name, params);
}
@Override
- public FeatureWeight createWeight(IndexSearcher searcher, boolean needsScores,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi)
- throws IOException {
+ public FeatureWeight createWeight(
+ IndexSearcher searcher,
+ boolean needsScores,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi)
+ throws IOException {
return new ValueFeatureWeight(searcher, request, originalQuery, efi);
}
public class ValueFeatureWeight extends FeatureWeight {
- final protected Float featureValue;
+ protected final Float featureValue;
- public ValueFeatureWeight(IndexSearcher searcher,
- SolrQueryRequest request, Query originalQuery, Map<String,String[]> efi) {
+ public ValueFeatureWeight(
+ IndexSearcher searcher,
+ SolrQueryRequest request,
+ Query originalQuery,
+ Map<String, String[]> efi) {
super(ValueFeature.this, searcher, request, originalQuery, efi);
if (configValueStr != null) {
final String expandedValue = macroExpander.expand(configValueStr);
if (expandedValue != null) {
featureValue = Float.parseFloat(expandedValue);
} else if (isRequired()) {
- throw new FeatureException(this.getClass().getSimpleName() + " requires efi parameter that was not passed in request.");
+ throw new FeatureException(
+ this.getClass().getSimpleName()
+ + " requires efi parameter that was not passed in request.");
} else {
- featureValue=null;
+ featureValue = null;
}
} else {
featureValue = configValue;
@@ -131,15 +142,12 @@ public class ValueFeature extends Feature {
@Override
public FeatureScorer scorer(LeafReaderContext context) throws IOException {
- if(featureValue!=null) {
- return new ValueFeatureScorer(this, featureValue,
- DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
+ if (featureValue != null) {
+ return new ValueFeatureScorer(
+ this, featureValue, DocIdSetIterator.all(DocIdSetIterator.NO_MORE_DOCS));
} else {
return null;
}
}
-
-
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/package-info.java
index 456fffc..052eae3 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/feature/package-info.java
@@ -15,7 +15,5 @@
* limitations under the License.
*/
-/**
- * Contains Feature related classes
- */
+/** Contains Feature related classes */
package org.apache.solr.ltr.feature;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/Interleaving.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/Interleaving.java
index db04443..bb5992c 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/Interleaving.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/Interleaving.java
@@ -22,25 +22,27 @@ import org.apache.solr.common.SolrException;
import org.apache.solr.ltr.interleaving.algorithms.TeamDraftInterleaving;
/**
- * Interleaving considers two ranking models: modelA and modelB.
- * For a given query, each model returns its ranked list of documents La = (a1,a2,...) and Lb = (b1, b2, ...).
- * An Interleaving algorithm creates a unique ranked list I = (i1, i2, ...).
- * This list is created by interleaving elements from the two lists la and lb as described by the implementation algorithm.
+ * Interleaving considers two ranking models: modelA and modelB.<br>
+ * For a given query, each model returns its ranked list of documents La = (a1,a2,...) and Lb = (b1,
+ * b2, ...).<br>
+ * An Interleaving algorithm creates a unique ranked list I = (i1, i2, ...).<br>
+ * This list is created by interleaving elements from the two lists la and lb as described by the
+ * implementation algorithm.<br>
* Each element Ij is labelled TeamA if it is selected from La and TeamB if it is selected from Lb.
*/
public interface Interleaving {
- String TEAM_DRAFT = "TeamDraft";
+ String TEAM_DRAFT = "TeamDraft";
- InterleavingResult interleave(ScoreDoc[] rerankedA, ScoreDoc[] rerankedB);
+ InterleavingResult interleave(ScoreDoc[] rerankedA, ScoreDoc[] rerankedB);
- static Interleaving getImplementation(String algorithm) {
- switch(algorithm) {
- case TEAM_DRAFT:
- return new TeamDraftInterleaving();
- default:
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
- "Unknown Interleaving algorithm: " + algorithm);
- }
- }
-}
\ No newline at end of file
+ static Interleaving getImplementation(String algorithm) {
+ switch (algorithm) {
+ case TEAM_DRAFT:
+ return new TeamDraftInterleaving();
+ default:
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST, "Unknown Interleaving algorithm: " + algorithm);
+ }
+ }
+}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/InterleavingResult.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/InterleavingResult.java
index aeaac29..7cc45b0 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/InterleavingResult.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/InterleavingResult.java
@@ -19,14 +19,14 @@ package org.apache.solr.ltr.interleaving;
import java.util.ArrayList;
import java.util.Set;
-
import org.apache.lucene.search.ScoreDoc;
public class InterleavingResult {
- final private ScoreDoc[] interleavedResults;
- final private ArrayList<Set<Integer>> interleavingPicks;
+ private final ScoreDoc[] interleavedResults;
+ private final ArrayList<Set<Integer>> interleavingPicks;
- public InterleavingResult(ScoreDoc[] interleavedResults, ArrayList<Set<Integer>> interleavingPicks) {
+ public InterleavingResult(
+ ScoreDoc[] interleavedResults, ArrayList<Set<Integer>> interleavingPicks) {
this.interleavedResults = interleavedResults;
this.interleavingPicks = interleavingPicks;
}
@@ -38,5 +38,4 @@ public class InterleavingResult {
public ArrayList<Set<Integer>> getInterleavingPicks() {
return interleavingPicks;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingQuery.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingQuery.java
index 7c00195..f34ee16 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingQuery.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingQuery.java
@@ -19,20 +19,22 @@ package org.apache.solr.ltr.interleaving;
import java.io.IOException;
import java.util.Arrays;
-
import org.apache.lucene.search.Query;
import org.apache.solr.ltr.search.LTRQuery;
import org.apache.solr.search.RankQuery;
/**
- * A learning to rank Query with Interleaving, will incapsulate two models, and delegate to it the rescoring
- * of the documents.
- **/
+ * A learning to rank Query with Interleaving, will incapsulate two models, and delegate to it the
+ * rescoring of the documents.
+ */
public class LTRInterleavingQuery extends LTRQuery {
private final LTRInterleavingScoringQuery[] rerankingQueries;
private final Interleaving interlavingAlgorithm;
- public LTRInterleavingQuery(Interleaving interleavingAlgorithm, LTRInterleavingScoringQuery[] rerankingQueries, int rerankDocs) {
+ public LTRInterleavingQuery(
+ Interleaving interleavingAlgorithm,
+ LTRInterleavingScoringQuery[] rerankingQueries,
+ int rerankDocs) {
super(null, rerankDocs, new LTRInterleavingRescorer(interleavingAlgorithm, rerankingQueries));
this.rerankingQueries = rerankingQueries;
this.interlavingAlgorithm = interleavingAlgorithm;
@@ -50,13 +52,14 @@ public class LTRInterleavingQuery extends LTRQuery {
private boolean equalsTo(LTRInterleavingQuery other) {
return (mainQuery.equals(other.mainQuery)
- && rerankingQueries.equals(other.rerankingQueries) && (reRankDocs == other.reRankDocs));
+ && rerankingQueries.equals(other.rerankingQueries)
+ && (reRankDocs == other.reRankDocs));
}
@Override
public RankQuery wrap(Query _mainQuery) {
super.wrap(_mainQuery);
- for(LTRInterleavingScoringQuery rerankingQuery: rerankingQueries){
+ for (LTRInterleavingScoringQuery rerankingQuery : rerankingQueries) {
rerankingQuery.setOriginalQuery(_mainQuery);
}
return this;
@@ -64,12 +67,18 @@ public class LTRInterleavingQuery extends LTRQuery {
@Override
public String toString(String field) {
- return "{!ltr mainQuery='" + mainQuery.toString() + "' rerankingQueries='"
- + Arrays.toString(rerankingQueries) + "' reRankDocs=" + reRankDocs + "}";
+ return "{!ltr mainQuery='"
+ + mainQuery.toString()
+ + "' rerankingQueries='"
+ + Arrays.toString(rerankingQueries)
+ + "' reRankDocs="
+ + reRankDocs
+ + "}";
}
@Override
protected Query rewrite(Query rewrittenMainQuery) throws IOException {
- return new LTRInterleavingQuery(interlavingAlgorithm, rerankingQueries, reRankDocs).wrap(rewrittenMainQuery);
+ return new LTRInterleavingQuery(interlavingAlgorithm, rerankingQueries, reRankDocs)
+ .wrap(rewrittenMainQuery);
}
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingRescorer.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingRescorer.java
index 799f4d9..f0c9055 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingRescorer.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingRescorer.java
@@ -21,7 +21,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.lucene.search.IndexSearcher;
@@ -32,22 +31,22 @@ import org.apache.solr.ltr.LTRRescorer;
import org.apache.solr.ltr.LTRScoringQuery;
/**
- * Implements the rescoring logic. The top documents returned by solr with their
- * original scores, will be processed by a {@link LTRScoringQuery} that will assign a
- * new score to each document. The top documents will be resorted based on the
- * new score.
- * */
+ * Implements the rescoring logic. The top documents returned by solr with their original scores,
+ * will be processed by a {@link LTRScoringQuery} that will assign a new score to each document. The
+ * top documents will be resorted based on the new score.
+ */
public class LTRInterleavingRescorer extends LTRRescorer {
-
- final private LTRInterleavingScoringQuery[] rerankingQueries;
+
+ private final LTRInterleavingScoringQuery[] rerankingQueries;
private Integer originalRankingIndex = null;
- final private Interleaving interleavingAlgorithm;
-
- public LTRInterleavingRescorer( Interleaving interleavingAlgorithm, LTRInterleavingScoringQuery[] rerankingQueries) {
+ private final Interleaving interleavingAlgorithm;
+
+ public LTRInterleavingRescorer(
+ Interleaving interleavingAlgorithm, LTRInterleavingScoringQuery[] rerankingQueries) {
this.rerankingQueries = rerankingQueries;
this.interleavingAlgorithm = interleavingAlgorithm;
- for(int i=0;i<this.rerankingQueries.length;i++){
- if(this.rerankingQueries[i] instanceof OriginalRankingLTRScoringQuery){
+ for (int i = 0; i < this.rerankingQueries.length; i++) {
+ if (this.rerankingQueries[i] instanceof OriginalRankingLTRScoringQuery) {
this.originalRankingIndex = i;
}
}
@@ -56,34 +55,34 @@ public class LTRInterleavingRescorer extends LTRRescorer {
/**
* rescores the documents:
*
- * @param searcher
- * current IndexSearcher
- * @param firstPassTopDocs
- * documents to rerank;
- * @param topN
- * documents to return;
+ * @param searcher current IndexSearcher
+ * @param firstPassTopDocs documents to rerank;
+ * @param topN documents to return;
*/
@Override
- public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs,
- int topN) throws IOException {
+ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int topN)
+ throws IOException {
if ((topN == 0) || (firstPassTopDocs.scoreDocs.length == 0)) {
return firstPassTopDocs;
}
ScoreDoc[] firstPassResults = null;
- if(originalRankingIndex != null) {
+ if (originalRankingIndex != null) {
firstPassResults = new ScoreDoc[firstPassTopDocs.scoreDocs.length];
- System.arraycopy(firstPassTopDocs.scoreDocs, 0, firstPassResults, 0, firstPassTopDocs.scoreDocs.length);
+ System.arraycopy(
+ firstPassTopDocs.scoreDocs, 0, firstPassResults, 0, firstPassTopDocs.scoreDocs.length);
}
topN = Math.toIntExact(Math.min(topN, firstPassTopDocs.totalHits.value));
- ScoreDoc[][] reRankedPerModel = rerank(searcher,topN,getFirstPassDocsRanked(firstPassTopDocs));
+ ScoreDoc[][] reRankedPerModel =
+ rerank(searcher, topN, getFirstPassDocsRanked(firstPassTopDocs));
if (originalRankingIndex != null) {
reRankedPerModel[originalRankingIndex] = firstPassResults;
}
- InterleavingResult interleaved = interleavingAlgorithm.interleave(reRankedPerModel[0], reRankedPerModel[1]);
+ InterleavingResult interleaved =
+ interleavingAlgorithm.interleave(reRankedPerModel[0], reRankedPerModel[1]);
ScoreDoc[] interleavedResults = interleaved.getInterleavedResults();
-
+
ArrayList<Set<Integer>> interleavingPicks = interleaved.getInterleavingPicks();
rerankingQueries[0].setPickedInterleavingDocIds(interleavingPicks.get(0));
rerankingQueries[1].setPickedInterleavingDocIds(interleavingPicks.get(1));
@@ -91,14 +90,17 @@ public class LTRInterleavingRescorer extends LTRRescorer {
return new TopDocs(firstPassTopDocs.totalHits, interleavedResults);
}
- private ScoreDoc[][] rerank(IndexSearcher searcher, int topN, ScoreDoc[] firstPassResults) throws IOException {
+ private ScoreDoc[][] rerank(IndexSearcher searcher, int topN, ScoreDoc[] firstPassResults)
+ throws IOException {
ScoreDoc[][] reRankedPerModel = new ScoreDoc[rerankingQueries.length][topN];
final List<LeafReaderContext> leaves = searcher.getIndexReader().leaves();
- LTRScoringQuery.ModelWeight[] modelWeights = new LTRScoringQuery.ModelWeight[rerankingQueries.length];
+ LTRScoringQuery.ModelWeight[] modelWeights =
+ new LTRScoringQuery.ModelWeight[rerankingQueries.length];
for (int i = 0; i < rerankingQueries.length; i++) {
if (originalRankingIndex == null || originalRankingIndex != i) {
- modelWeights[i] = (LTRScoringQuery.ModelWeight) searcher
- .createWeight(searcher.rewrite(rerankingQueries[i]), ScoreMode.COMPLETE, 1);
+ modelWeights[i] =
+ (LTRScoringQuery.ModelWeight)
+ searcher.createWeight(searcher.rewrite(rerankingQueries[i]), ScoreMode.COMPLETE, 1);
}
}
scoreFeatures(searcher, topN, modelWeights, firstPassResults, leaves, reRankedPerModel);
@@ -112,15 +114,21 @@ public class LTRInterleavingRescorer extends LTRRescorer {
return reRankedPerModel;
}
- public void scoreFeatures(IndexSearcher indexSearcher,
- int topN, LTRScoringQuery.ModelWeight[] modelWeights, ScoreDoc[] hits, List<LeafReaderContext> leaves,
- ScoreDoc[][] rerankedPerModel) throws IOException {
+ public void scoreFeatures(
+ IndexSearcher indexSearcher,
+ int topN,
+ LTRScoringQuery.ModelWeight[] modelWeights,
+ ScoreDoc[] hits,
+ List<LeafReaderContext> leaves,
+ ScoreDoc[][] rerankedPerModel)
+ throws IOException {
int readerUpto = -1;
int endDoc = 0;
int docBase = 0;
int hitUpto = 0;
- LTRScoringQuery.ModelWeight.ModelScorer[] scorers = new LTRScoringQuery.ModelWeight.ModelScorer[rerankingQueries.length];
+ LTRScoringQuery.ModelWeight.ModelScorer[] scorers =
+ new LTRScoringQuery.ModelWeight.ModelScorer[rerankingQueries.length];
while (hitUpto < hits.length) {
final ScoreDoc hit = hits[hitUpto];
final int docID = hit.doc;
@@ -143,24 +151,23 @@ public class LTRInterleavingRescorer extends LTRRescorer {
for (int i = 0; i < rerankingQueries.length; i++) {
if (modelWeights[i] != null) {
final ScoreDoc hit_i = new ScoreDoc(hit.doc, hit.score, hit.shardIndex);
- if (scoreSingleHit(topN, docBase, hitUpto, hit_i, docID, scorers[i], rerankedPerModel[i])) {
+ if (scoreSingleHit(
+ topN, docBase, hitUpto, hit_i, docID, scorers[i], rerankedPerModel[i])) {
logSingleHit(indexSearcher, modelWeights[i], hit_i.doc, rerankingQueries[i]);
}
}
}
hitUpto++;
}
-
}
-
+
@Override
- public Explanation explain(IndexSearcher searcher,
- Explanation firstPassExplanation, int docID) throws IOException {
+ public Explanation explain(IndexSearcher searcher, Explanation firstPassExplanation, int docID)
+ throws IOException {
LTRScoringQuery pickedRerankModel = rerankingQueries[0];
if (rerankingQueries[1].getPickedInterleavingDocIds().contains(docID)) {
pickedRerankModel = rerankingQueries[1];
}
return getExplanation(searcher, docID, pickedRerankModel);
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingScoringQuery.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingScoringQuery.java
index cb2da2c..be15592 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingScoringQuery.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/LTRInterleavingScoringQuery.java
@@ -18,7 +18,6 @@ package org.apache.solr.ltr.interleaving;
import java.util.Map;
import java.util.Set;
-
import org.apache.solr.ltr.LTRScoringQuery;
import org.apache.solr.ltr.LTRThreadModule;
import org.apache.solr.ltr.model.LTRScoringModel;
@@ -36,9 +35,11 @@ public class LTRInterleavingScoringQuery extends LTRScoringQuery {
super(ltrScoringModel, extractAllFeatures);
}
- public LTRInterleavingScoringQuery(LTRScoringModel ltrScoringModel,
+ public LTRInterleavingScoringQuery(
+ LTRScoringModel ltrScoringModel,
Map<String, String[]> externalFeatureInfo,
- boolean extractAllFeatures, LTRThreadModule ltrThreadMgr) {
+ boolean extractAllFeatures,
+ LTRThreadModule ltrThreadMgr) {
super(ltrScoringModel, externalFeatureInfo, extractAllFeatures, ltrThreadMgr);
}
@@ -49,5 +50,4 @@ public class LTRInterleavingScoringQuery extends LTRScoringQuery {
public void setPickedInterleavingDocIds(Set<Integer> pickedInterleavingDocIds) {
this.pickedInterleavingDocIds = pickedInterleavingDocIds;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/OriginalRankingLTRScoringQuery.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/OriginalRankingLTRScoringQuery.java
index 9c4db05..aa7f8d5 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/OriginalRankingLTRScoringQuery.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/OriginalRankingLTRScoringQuery.java
@@ -29,5 +29,4 @@ public final class OriginalRankingLTRScoringQuery extends LTRInterleavingScoring
public String getScoringModelName() {
return this.originalRankingModelName;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/TeamDraftInterleaving.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/TeamDraftInterleaving.java
index a9cd38a..eab4160 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/TeamDraftInterleaving.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/TeamDraftInterleaving.java
@@ -22,32 +22,34 @@ import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;
import java.util.Set;
-
import org.apache.lucene.search.ScoreDoc;
import org.apache.solr.ltr.interleaving.Interleaving;
import org.apache.solr.ltr.interleaving.InterleavingResult;
/**
- * Interleaving was introduced the first time by Joachims in [1, 2].
- * Team Draft Interleaving is among the most successful and used interleaving approaches[3].
- * Team Draft Interleaving implements a method similar to the way in which captains select their players in team-matches.
- * Team Draft Interleaving produces a fair distribution of ranking models’ elements in the final interleaved list.
- * "Team draft interleaving" has also proved to overcome an issue of the "Balanced interleaving" approach, in determining the winning model[4].
- * <p>
- * [1] T. Joachims. Optimizing search engines using clickthrough data. KDD (2002)
- * [2] T.Joachims.Evaluatingretrievalperformanceusingclickthroughdata.InJ.Franke, G. Nakhaeizadeh, and I. Renz, editors,
- * Text Mining, pages 79–96. Physica/Springer (2003)
- * [3] F. Radlinski, M. Kurup, and T. Joachims. How does clickthrough data reflect re-
- * trieval quality? In CIKM, pages 43–52. ACM Press (2008)
- * [4] O. Chapelle, T. Joachims, F. Radlinski, and Y. Yue.
- * Large-scale validation and analysis of interleaved search evaluation. ACM TOIS, 30(1):1–41, Feb. (2012)
+ * Interleaving was introduced the first time by Joachims in [1, 2].<br>
+ * Team Draft Interleaving is among the most successful and used interleaving approaches[3].<br>
+ * Team Draft Interleaving implements a method similar to the way in which captains select their
+ * players in team-matches.<br>
+ * Team Draft Interleaving produces a fair distribution of ranking models’ elements in the final
+ * interleaved list.<br>
+ * "Team draft interleaving" has also proved to overcome an issue of the "Balanced interleaving"
+ * approach, in determining the winning model[4].
+ *
+ * <p>[1] T. Joachims. Optimizing search engines using clickthrough data. KDD (2002) <br>
+ * [2] T.Joachims.Evaluatingretrievalperformanceusingclickthroughdata.InJ.Franke, G. Nakhaeizadeh,
+ * and I. Renz, editors, Text Mining, pages 79–96. Physica/Springer (2003) <br>
+ * [3] F. Radlinski, M. Kurup, and T. Joachims. How does clickthrough data reflect re- trieval
+ * quality? In CIKM, pages 43–52. ACM Press (2008) <br>
+ * [4] O. Chapelle, T. Joachims, F. Radlinski, and Y. Yue. Large-scale validation and analysis of
+ * interleaved search evaluation. ACM TOIS, 30(1):1–41, Feb. (2012)
*/
public class TeamDraftInterleaving implements Interleaving {
public static Random RANDOM;
static {
- // We try to make things reproducible in the context of our tests by initializing the random instance
- // based on the current seed
+ // We try to make things reproducible in the context of our tests by initializing the random
+ // instance based on the current seed
String seed = System.getProperty("tests.seed");
if (seed == null) {
RANDOM = new Random();
@@ -57,20 +59,20 @@ public class TeamDraftInterleaving implements Interleaving {
}
/**
- * Team Draft Interleaving considers two ranking models: modelA and modelB.
- * For a given query, each model returns its ranked list of documents La = (a1,a2,...) and Lb = (b1, b2, ...).
- * The algorithm creates a unique ranked list I = (i1, i2, ...).
- * This list is created by interleaving elements from the two lists la and lb as described by Chapelle et al.[1].
- * Each element Ij is labelled TeamA if it is selected from La and TeamB if it is selected from Lb.
- * <p>
- * [1] O. Chapelle, T. Joachims, F. Radlinski, and Y. Yue.
- * Large-scale validation and analysis of interleaved search evaluation. ACM TOIS, 30(1):1–41, Feb. (2012)
- * <p>
- * Assumptions:
- * - rerankedA and rerankedB has the same length.
- * They contains the same search results, ranked differently by two ranking models
- * - each reranked list can not contain the same search result more than once.
- * - results are all from the same shard
+ * Team Draft Interleaving considers two ranking models: modelA and modelB. For a given query,
+ * each model returns its ranked list of documents La = (a1,a2,...) and Lb = (b1, b2, ...). The
+ * algorithm creates a unique ranked list I = (i1, i2, ...). This list is created by interleaving
+ * elements from the two lists la and lb as described by Chapelle et al.[1]. Each element Ij is
+ * labelled TeamA if it is selected from La and TeamB if it is selected from Lb.
+ *
+ * <p>[1] O. Chapelle, T. Joachims, F. Radlinski, and Y. Yue. Large-scale validation and analysis
+ * of interleaved search evaluation. ACM TOIS, 30(1):1–41, Feb. (2012)
+ *
+ * <p>Assumptions:<br>
+ * - rerankedA and rerankedB has the same length. They contains the same search results, ranked
+ * differently by two ranking models<br>
+ * - each reranked list can not contain the same search result more than once.<br>
+ * - results are all from the same shard<br>
*
* @param rerankedA a ranked list of search results produced by a ranking model A
* @param rerankedB a ranked list of search results produced by a ranking model B
@@ -86,15 +88,17 @@ public class TeamDraftInterleaving implements Interleaving {
int topN = rerankedA.length;
int indexA = 0, indexB = 0;
- while (interleavedResults.size() < topN && indexA < rerankedA.length && indexB < rerankedB.length) {
- if(teamA.size()<teamB.size() || (teamA.size()==teamB.size() && !RANDOM.nextBoolean())){
+ while (interleavedResults.size() < topN
+ && indexA < rerankedA.length
+ && indexB < rerankedB.length) {
+ if (teamA.size() < teamB.size() || (teamA.size() == teamB.size() && !RANDOM.nextBoolean())) {
indexA = updateIndex(alreadyAdded, indexA, rerankedA);
interleavedResults.add(rerankedA[indexA]);
alreadyAdded.add(rerankedA[indexA].doc);
teamA.add(rerankedA[indexA].doc);
indexA++;
- } else{
- indexB = updateIndex(alreadyAdded,indexB,rerankedB);
+ } else {
+ indexB = updateIndex(alreadyAdded, indexB, rerankedB);
interleavedResults.add(rerankedB[indexB]);
alreadyAdded.add(rerankedB[indexB].doc);
teamB.add(rerankedB[indexB].doc);
@@ -105,7 +109,7 @@ public class TeamDraftInterleaving implements Interleaving {
interleavingPicks.add(teamB);
interleavedResultArray = interleavedResults.toArray(interleavedResultArray);
- return new InterleavingResult(interleavedResultArray,interleavingPicks);
+ return new InterleavingResult(interleavedResultArray, interleavingPicks);
}
private int updateIndex(HashSet<Integer> alreadyAdded, int index, ScoreDoc[] reranked) {
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/package-info.java
index d66eedf..32c417e 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/algorithms/package-info.java
@@ -15,7 +15,5 @@
* limitations under the License.
*/
-/**
- * Contains Various Interleaving Algorithms
- */
+/** Contains Various Interleaving Algorithms */
package org.apache.solr.ltr.interleaving.algorithms;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/package-info.java
index 82f5975..301ca05 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/interleaving/package-info.java
@@ -15,7 +15,5 @@
* limitations under the License.
*/
-/**
- * Contains Various Interleaving auxiliary classes
- */
+/** Contains Various Interleaving auxiliary classes */
package org.apache.solr.ltr.interleaving;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/AdapterModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/AdapterModel.java
index 262a47f..61e0d4c 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/AdapterModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/AdapterModel.java
@@ -18,14 +18,13 @@ package org.apache.solr.ltr.model;
import java.util.List;
import java.util.Map;
-
import org.apache.solr.core.SolrResourceLoader;
import org.apache.solr.ltr.feature.Feature;
import org.apache.solr.ltr.norm.Normalizer;
/**
- * A scoring model whose initialization is completed via its
- * {@link #init(SolrResourceLoader)} method.
+ * A scoring model whose initialization is completed via its {@link #init(SolrResourceLoader)}
+ * method.
*
* @since 7.3
*/
@@ -33,13 +32,17 @@ public abstract class AdapterModel extends LTRScoringModel {
protected SolrResourceLoader solrResourceLoader;
- public AdapterModel(String name, List<Feature> features, List<Normalizer> norms, String featureStoreName,
- List<Feature> allFeatures, Map<String,Object> params) {
+ public AdapterModel(
+ String name,
+ List<Feature> features,
+ List<Normalizer> norms,
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
}
public void init(SolrResourceLoader solrResourceLoader) throws ModelException {
this.solrResourceLoader = solrResourceLoader;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/DefaultWrapperModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/DefaultWrapperModel.java
index a56fe82..b18251e 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/DefaultWrapperModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/DefaultWrapperModel.java
@@ -25,7 +25,6 @@ import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
-
import org.apache.solr.core.SolrResourceLoader;
import org.apache.solr.ltr.feature.Feature;
import org.apache.solr.ltr.norm.Normalizer;
@@ -35,32 +34,40 @@ import org.noggit.ObjectBuilder;
/**
* A scoring model that fetches the wrapped model from {@link SolrResourceLoader}.
*
- * <p>This model uses {@link SolrResourceLoader#openResource(String)} for fetching the wrapped model.
- * If you give a relative path for {@code params/resource}, this model will try to load the wrapped model from
- * the instance directory (i.e. ${solr.solr.home}). Otherwise, seek through classpaths.
+ * <p>This model uses {@link SolrResourceLoader#openResource(String)} for fetching the wrapped
+ * model. If you give a relative path for {@code params/resource}, this model will try to load the
+ * wrapped model from the instance directory (i.e. ${solr.solr.home}). Otherwise, seek through
+ * classpaths.
*
* <p>Example configuration:
- * <pre>{
- "class": "org.apache.solr.ltr.model.DefaultWrapperModel",
- "name": "myWrapperModelName",
- "params": {
- "resource": "models/myModel.json"
- }
-}</pre>
+ *
+ * <pre>
+ * {
+ * "class": "org.apache.solr.ltr.model.DefaultWrapperModel",
+ * "name": "myWrapperModelName",
+ * "params": {
+ * "resource": "models/myModel.json"
+ * }
+ * }
+ * </pre>
*
* @see SolrResourceLoader#openResource(String)
*/
public class DefaultWrapperModel extends WrapperModel {
/**
- * resource is part of the LTRScoringModel params map
- * and therefore here it does not individually
+ * resource is part of the LTRScoringModel params map and therefore here it does not individually
* influence the class hashCode, equals, etc.
*/
private String resource;
- public DefaultWrapperModel(String name, List<Feature> features, List<Normalizer> norms, String featureStoreName,
- List<Feature> allFeatures, Map<String, Object> params) {
+ public DefaultWrapperModel(
+ String name,
+ List<Feature> features,
+ List<Normalizer> norms,
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
}
@@ -72,7 +79,7 @@ public class DefaultWrapperModel extends WrapperModel {
protected void validate() throws ModelException {
super.validate();
if (resource == null) {
- throw new ModelException("no resource configured for model "+name);
+ throw new ModelException("no resource configured for model " + name);
}
}
@@ -82,7 +89,8 @@ public class DefaultWrapperModel extends WrapperModel {
try (InputStream in = openInputStream()) {
modelMapObj = parseInputStream(in);
} catch (IOException e) {
- throw new ModelException("Failed to fetch the wrapper model from given resource (" + resource + ")", e);
+ throw new ModelException(
+ "Failed to fetch the wrapper model from given resource (" + resource + ")", e);
}
return modelMapObj;
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java
index b1fb21f..2f57bf5 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LTRScoringModel.java
@@ -24,7 +24,6 @@ import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.lucene.util.Accountable;
@@ -38,71 +37,83 @@ import org.apache.solr.util.SolrPluginUtils;
/**
* A scoring model computes scores that can be used to rerank documents.
- * <p>
- * A scoring model consists of
+ *
+ * <p>A scoring model consists of
+ *
* <ul>
- * <li> a list of features ({@link Feature}) and
- * <li> a list of normalizers ({@link Normalizer}) plus
- * <li> parameters or configuration to represent the scoring algorithm.
+ * <li>a list of features ({@link Feature}) and
+ * <li>a list of normalizers ({@link Normalizer}) plus
+ * <li>parameters or configuration to represent the scoring algorithm.
* </ul>
- * <p>
- * Example configuration (snippet):
- * <pre>{
- "class" : "...",
- "name" : "myModelName",
- "features" : [
- {
- "name" : "isBook"
- },
- {
- "name" : "originalScore",
- "norm": {
- "class" : "org.apache.solr.ltr.norm.StandardNormalizer",
- "params" : { "avg":"100", "std":"10" }
- }
- },
- {
- "name" : "price",
- "norm": {
- "class" : "org.apache.solr.ltr.norm.MinMaxNormalizer",
- "params" : { "min":"0", "max":"1000" }
- }
- }
- ],
- "params" : {
- ...
- }
-}</pre>
- * <p>
- * {@link LTRScoringModel} is an abstract class and concrete classes must
- * implement the {@link #score(float[])} and
- * {@link #explain(LeafReaderContext, int, float, List)} methods.
+ *
+ * <p>Example configuration (snippet):
+ *
+ * <pre>
+ * {
+ * "class" : "...",
+ * "name" : "myModelName",
+ * "features" : [
+ * {
+ * "name" : "isBook"
+ * },
+ * {
+ * "name" : "originalScore",
+ * "norm": {
+ * "class" : "org.apache.solr.ltr.norm.StandardNormalizer",
+ * "params" : { "avg":"100", "std":"10" }
+ * }
+ * },
+ * {
+ * "name" : "price",
+ * "norm": {
+ * "class" : "org.apache.solr.ltr.norm.MinMaxNormalizer",
+ * "params" : { "min":"0", "max":"1000" }
+ * }
+ * }
+ * ],
+ * "params" : {
+ * ...
+ * }
+ * }
+ * </pre>
+ *
+ * <p>{@link LTRScoringModel} is an abstract class and concrete classes must implement the {@link
+ * #score(float[])} and {@link #explain(LeafReaderContext, int, float, List)} methods.
*/
public abstract class LTRScoringModel implements Accountable {
- private static final long BASE_RAM_BYTES = RamUsageEstimator.shallowSizeOfInstance(LTRScoringModel.class);
+ private static final long BASE_RAM_BYTES =
+ RamUsageEstimator.shallowSizeOfInstance(LTRScoringModel.class);
protected final String name;
private final String featureStoreName;
protected final List<Feature> features;
private final List<Feature> allFeatures;
- private final Map<String,Object> params;
+ private final Map<String, Object> params;
protected final List<Normalizer> norms;
private Integer hashCode; // cached since it shouldn't actually change after construction
- public static LTRScoringModel getInstance(SolrResourceLoader solrResourceLoader,
- String className, String name, List<Feature> features,
+ public static LTRScoringModel getInstance(
+ SolrResourceLoader solrResourceLoader,
+ String className,
+ String name,
+ List<Feature> features,
List<Normalizer> norms,
- String featureStoreName, List<Feature> allFeatures,
- Map<String,Object> params) throws ModelException {
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params)
+ throws ModelException {
final LTRScoringModel model;
try {
// create an instance of the model
- model = solrResourceLoader.newInstance(
- className,
- LTRScoringModel.class,
- new String[0], // no sub packages
- new Class<?>[] { String.class, List.class, List.class, String.class, List.class, Map.class },
- new Object[] { name, features, norms, featureStoreName, allFeatures, params });
+ model =
+ solrResourceLoader.newInstance(
+ className,
+ LTRScoringModel.class,
+ new String[0], // no sub packages
+ new Class<?>[] {
+ String.class, List.class, List.class, String.class, List.class, Map.class
+ },
+ new Object[] {name, features, norms, featureStoreName, allFeatures, params});
if (params != null) {
SolrPluginUtils.invokeSetters(model, params.entrySet());
}
@@ -113,74 +124,78 @@ public abstract class LTRScoringModel implements Accountable {
return model;
}
- public LTRScoringModel(String name, List<Feature> features,
+ public LTRScoringModel(
+ String name,
+ List<Feature> features,
List<Normalizer> norms,
- String featureStoreName, List<Feature> allFeatures,
- Map<String,Object> params) {
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
this.name = name;
- this.features = features != null ? Collections.unmodifiableList(new ArrayList<>(features)) : null;
+ this.features =
+ features != null ? Collections.unmodifiableList(new ArrayList<>(features)) : null;
this.featureStoreName = featureStoreName;
- this.allFeatures = allFeatures != null ? Collections.unmodifiableList(new ArrayList<>(allFeatures)) : null;
+ this.allFeatures =
+ allFeatures != null ? Collections.unmodifiableList(new ArrayList<>(allFeatures)) : null;
this.params = params != null ? Collections.unmodifiableMap(new LinkedHashMap<>(params)) : null;
this.norms = norms != null ? Collections.unmodifiableList(new ArrayList<>(norms)) : null;
}
/**
- * Validate that settings make sense and throws
- * {@link ModelException} if they do not make sense.
+ * Validate that settings make sense and throws {@link ModelException} if they do not make sense.
*/
protected void validate() throws ModelException {
final List<Feature> features = getFeatures();
final List<Normalizer> norms = getNorms();
if (features.isEmpty()) {
- throw new ModelException("no features declared for model "+name);
+ throw new ModelException("no features declared for model " + name);
}
final HashSet<String> featureNames = new HashSet<>();
for (final Feature feature : features) {
final String featureName = feature.getName();
if (!featureNames.add(featureName)) {
- throw new ModelException("duplicated feature "+featureName+" in model "+name);
+ throw new ModelException("duplicated feature " + featureName + " in model " + name);
}
}
if (features.size() != norms.size()) {
- throw new ModelException("counted "+features.size()+" features and "+norms.size()+" norms in model "+name);
+ throw new ModelException(
+ "counted "
+ + features.size()
+ + " features and "
+ + norms.size()
+ + " norms in model "
+ + name);
}
}
- /**
- * @return the norms
- */
+ /** @return the norms */
public List<Normalizer> getNorms() {
return norms;
}
- /**
- * @return the name
- */
+ /** @return the name */
public String getName() {
return name;
}
- /**
- * @return the features
- */
+ /** @return the features */
public List<Feature> getFeatures() {
return features;
}
- public Map<String,Object> getParams() {
+ public Map<String, Object> getParams() {
return params;
}
@Override
public int hashCode() {
- if(hashCode == null) {
+ if (hashCode == null) {
hashCode = calculateHashCode();
}
return hashCode;
}
- final private int calculateHashCode() {
+ private final int calculateHashCode() {
final int prime = 31;
int result = 1;
result = (prime * result) + Objects.hashCode(features);
@@ -239,19 +254,19 @@ public abstract class LTRScoringModel implements Accountable {
return false;
}
-
return true;
}
@Override
public long ramBytesUsed() {
- return BASE_RAM_BYTES +
- RamUsageEstimator.sizeOfObject(allFeatures, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED) +
- RamUsageEstimator.sizeOfObject(features, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED) +
- RamUsageEstimator.sizeOfObject(featureStoreName) +
- RamUsageEstimator.sizeOfObject(name) +
- RamUsageEstimator.sizeOfObject(norms) +
- RamUsageEstimator.sizeOfObject(params);
+ return BASE_RAM_BYTES
+ + RamUsageEstimator.sizeOfObject(
+ allFeatures, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED)
+ + RamUsageEstimator.sizeOfObject(features, RamUsageEstimator.QUERY_DEFAULT_RAM_BYTES_USED)
+ + RamUsageEstimator.sizeOfObject(featureStoreName)
+ + RamUsageEstimator.sizeOfObject(name)
+ + RamUsageEstimator.sizeOfObject(norms)
+ + RamUsageEstimator.sizeOfObject(params);
}
public Collection<Feature> getAllFeatures() {
@@ -263,48 +278,43 @@ public abstract class LTRScoringModel implements Accountable {
}
/**
- * Given a list of normalized values for all features a scoring algorithm
- * cares about, calculate and return a score.
+ * Given a list of normalized values for all features a scoring algorithm cares about, calculate
+ * and return a score.
*
- * @param modelFeatureValuesNormalized
- * List of normalized feature values. Each feature is identified by
- * its id, which is the index in the array
+ * @param modelFeatureValuesNormalized List of normalized feature values. Each feature is
+ * identified by its id, which is the index in the array
* @return The final score for a document
*/
public abstract float score(float[] modelFeatureValuesNormalized);
/**
- * Similar to the score() function, except it returns an explanation of how
- * the features were used to calculate the score.
+ * Similar to the score() function, except it returns an explanation of how the features were used
+ * to calculate the score.
*
- * @param context
- * Context the document is in
- * @param doc
- * Document to explain
- * @param finalScore
- * Original score
- * @param featureExplanations
- * Explanations for each feature calculation
+ * @param context Context the document is in
+ * @param doc Document to explain
+ * @param finalScore Original score
+ * @param featureExplanations Explanations for each feature calculation
* @return Explanation for the scoring of a document
*/
- public abstract Explanation explain(LeafReaderContext context, int doc,
- float finalScore, List<Explanation> featureExplanations);
+ public abstract Explanation explain(
+ LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations);
@Override
public String toString() {
- return getClass().getSimpleName() + "(name="+getName()+")";
+ return getClass().getSimpleName() + "(name=" + getName() + ")";
}
/**
- * Goes through all the stored feature values, and calculates the normalized
- * values for all the features that will be used for scoring.
+ * Goes through all the stored feature values, and calculates the normalized values for all the
+ * features that will be used for scoring.
*/
public void normalizeFeaturesInPlace(float[] modelFeatureValues) {
float[] modelFeatureValuesNormalized = modelFeatureValues;
if (modelFeatureValues.length != norms.size()) {
throw new FeatureException("Must have normalizer for every feature");
}
- for(int idx = 0; idx < modelFeatureValuesNormalized.length; ++idx) {
+ for (int idx = 0; idx < modelFeatureValuesNormalized.length; ++idx) {
modelFeatureValuesNormalized[idx] =
norms.get(idx).normalize(modelFeatureValuesNormalized[idx]);
}
@@ -317,5 +327,4 @@ public abstract class LTRScoringModel implements Accountable {
}
return e;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LinearModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LinearModel.java
index 965c0cb..6b030f2 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LinearModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/LinearModel.java
@@ -19,68 +19,73 @@ package org.apache.solr.ltr.model;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.solr.ltr.feature.Feature;
import org.apache.solr.ltr.norm.Normalizer;
/**
- * A scoring model that computes scores using a dot product.
- * Example models are RankSVM and Pranking.
- * <p>
- * Example configuration:
- * <pre>{
- "class" : "org.apache.solr.ltr.model.LinearModel",
- "name" : "myModelName",
- "features" : [
- { "name" : "userTextTitleMatch" },
- { "name" : "originalScore" },
- { "name" : "isBook" }
- ],
- "params" : {
- "weights" : {
- "userTextTitleMatch" : 1.0,
- "originalScore" : 0.5,
- "isBook" : 0.1
- }
- }
-}</pre>
- * <p>
- * Training libraries:
+ * A scoring model that computes scores using a dot product. Example models are RankSVM and
+ * Pranking.
+ *
+ * <p>Example configuration:
+ *
+ * <pre>
+ * {
+ * "class" : "org.apache.solr.ltr.model.LinearModel",
+ * "name" : "myModelName",
+ * "features" : [
+ * { "name" : "userTextTitleMatch" },
+ * { "name" : "originalScore" },
+ * { "name" : "isBook" }
+ * ],
+ * "params" : {
+ * "weights" : {
+ * "userTextTitleMatch" : 1.0,
+ * "originalScore" : 0.5,
+ * "isBook" : 0.1
+ * }
+ * }
+ * }
+ * </pre>
+ *
+ * <p>Training libraries:
+ *
* <ul>
- * <li> <a href="https://www.csie.ntu.edu.tw/~cjlin/liblinear/">
- * LIBLINEAR -- A Library for Large Linear Classification</a>
+ * <li><a href="https://www.csie.ntu.edu.tw/~cjlin/liblinear/">LIBLINEAR -- A Library for Large
+ * Linear Classification</a>
* </ul>
+ *
* <ul>
- * <li> <a href="https://www.csie.ntu.edu.tw/~cjlin/libsvm/">
- * LIBSVM -- A Library for Support Vector Machines</a>
+ * <li><a href="https://www.csie.ntu.edu.tw/~cjlin/libsvm/">LIBSVM -- A Library for Support Vector
+ * Machines</a>
* </ul>
- * <p>
- * Background reading:
+ *
+ * <p>Background reading:
+ *
* <ul>
- * <li> <a href="http://www.cs.cornell.edu/people/tj/publications/joachims_02c.pdf">
- * Thorsten Joachims. Optimizing Search Engines Using Clickthrough Data.
- * Proceedings of the ACM Conference on Knowledge Discovery and Data Mining (KDD), ACM, 2002.</a>
+ * <li><a href="http://www.cs.cornell.edu/people/tj/publications/joachims_02c.pdf">Thorsten
+ * Joachims. Optimizing Search Engines Using Clickthrough Data. Proceedings of the ACM
+ * Conference on Knowledge Discovery and Data Mining (KDD), ACM, 2002.</a>
* </ul>
+ *
* <ul>
- * <li> <a href="https://papers.nips.cc/paper/2023-pranking-with-ranking.pdf">
- * Koby Crammer and Yoram Singer. Pranking with Ranking.
- * Advances in Neural Information Processing Systems (NIPS), 2001.</a>
+ * <li><a href="https://papers.nips.cc/paper/2023-pranking-with-ranking.pdf">Koby Crammer and
+ * Yoram Singer. Pranking with Ranking. Advances in Neural Information Processing Systems
+ * (NIPS), 2001.</a>
* </ul>
*/
public class LinearModel extends LTRScoringModel {
/**
- * featureToWeight is part of the LTRScoringModel params map
- * and therefore here it does not individually
- * influence the class hashCode, equals, etc.
+ * featureToWeight is part of the LTRScoringModel params map and therefore here it does not
+ * individually influence the class hashCode, equals, etc.
*/
protected Float[] featureToWeight;
public void setWeights(Object weights) {
@SuppressWarnings({"unchecked"})
- final Map<String,Number> modelWeights = (Map<String, Number>) weights;
+ final Map<String, Number> modelWeights = (Map<String, Number>) weights;
for (int ii = 0; ii < features.size(); ++ii) {
final String key = features.get(ii).getName();
final Number val = modelWeights.get(key);
@@ -88,10 +93,13 @@ public class LinearModel extends LTRScoringModel {
}
}
- public LinearModel(String name, List<Feature> features,
+ public LinearModel(
+ String name,
+ List<Feature> features,
List<Normalizer> norms,
- String featureStoreName, List<Feature> allFeatures,
- Map<String,Object> params) {
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
featureToWeight = new Float[features.size()];
}
@@ -110,7 +118,8 @@ public class LinearModel extends LTRScoringModel {
throw new ModelException("Model " + name + " doesn't contain any weights");
}
if (!missingWeightFeatureNames.isEmpty()) {
- throw new ModelException("Model " + name + " lacks weight(s) for "+missingWeightFeatureNames);
+ throw new ModelException(
+ "Model " + name + " lacks weight(s) for " + missingWeightFeatureNames);
}
}
@@ -124,24 +133,26 @@ public class LinearModel extends LTRScoringModel {
}
@Override
- public Explanation explain(LeafReaderContext context, int doc,
- float finalScore, List<Explanation> featureExplanations) {
+ public Explanation explain(
+ LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations) {
final List<Explanation> details = new ArrayList<>();
int index = 0;
for (final Explanation featureExplain : featureExplanations) {
final List<Explanation> featureDetails = new ArrayList<>();
- featureDetails.add(Explanation.match(featureToWeight[index],
- "weight on feature"));
+ featureDetails.add(Explanation.match(featureToWeight[index], "weight on feature"));
featureDetails.add(featureExplain);
- details.add(Explanation.match(featureExplain.getValue().floatValue()
- * featureToWeight[index], "prod of:", featureDetails));
+ details.add(
+ Explanation.match(
+ featureExplain.getValue().floatValue() * featureToWeight[index],
+ "prod of:",
+ featureDetails));
index++;
}
- return Explanation.match(finalScore, toString()
- + " model applied to features, sum of:", details);
+ return Explanation.match(
+ finalScore, toString() + " model applied to features, sum of:", details);
}
@Override
@@ -150,7 +161,7 @@ public class LinearModel extends LTRScoringModel {
sb.append("(name=").append(getName());
sb.append(",featureWeights=[");
for (int ii = 0; ii < features.size(); ++ii) {
- if (ii>0) {
+ if (ii > 0) {
sb.append(',');
}
final String key = features.get(ii).getName();
@@ -159,5 +170,4 @@ public class LinearModel extends LTRScoringModel {
sb.append("])");
return sb.toString();
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/ModelException.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/ModelException.java
index de8786d..a4e57af 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/ModelException.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/ModelException.java
@@ -27,5 +27,4 @@ public class ModelException extends RuntimeException {
public ModelException(String message, Exception cause) {
super(message, cause);
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/MultipleAdditiveTreesModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/MultipleAdditiveTreesModel.java
index d79db83..b66e2ff 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/MultipleAdditiveTreesModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/MultipleAdditiveTreesModel.java
@@ -21,7 +21,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.solr.ltr.feature.Feature;
@@ -29,83 +28,89 @@ import org.apache.solr.ltr.norm.Normalizer;
import org.apache.solr.util.SolrPluginUtils;
/**
- * A scoring model that computes scores based on the summation of multiple weighted trees.
- * Example models are LambdaMART and Gradient Boosted Regression Trees (GBRT) .
- * <p>
- * Example configuration:
-<pre>{
- "class" : "org.apache.solr.ltr.model.MultipleAdditiveTreesModel",
- "name" : "multipleadditivetreesmodel",
- "features":[
- { "name" : "userTextTitleMatch"},
- { "name" : "originalScore"}
- ],
- "params" : {
- "trees" : [
- {
- "weight" : "1",
- "root": {
- "feature" : "userTextTitleMatch",
- "threshold" : "0.5",
- "left" : {
- "value" : "-100"
- },
- "right" : {
- "feature" : "originalScore",
- "threshold" : "10.0",
- "left" : {
- "value" : "50"
- },
- "right" : {
- "value" : "75"
- }
- }
- }
- },
- {
- "weight" : "2",
- "root" : {
- "value" : "-10"
- }
- }
- ]
- }
-}</pre>
- * <p>
- * Training libraries:
+ * A scoring model that computes scores based on the summation of multiple weighted trees. Example
+ * models are LambdaMART and Gradient Boosted Regression Trees (GBRT) .
+ *
+ * <p>Example configuration:
+ *
+ * <pre>
+ * {
+ * "class" : "org.apache.solr.ltr.model.MultipleAdditiveTreesModel",
+ * "name" : "multipleadditivetreesmodel",
+ * "features":[
+ * { "name" : "userTextTitleMatch"},
+ * { "name" : "originalScore"}
+ * ],
+ * "params" : {
+ * "trees" : [
+ * {
+ * "weight" : "1",
+ * "root": {
+ * "feature" : "userTextTitleMatch",
+ * "threshold" : "0.5",
+ * "left" : {
+ * "value" : "-100"
+ * },
+ * "right" : {
+ * "feature" : "originalScore",
+ * "threshold" : "10.0",
+ * "left" : {
+ * "value" : "50"
+ * },
+ * "right" : {
+ * "value" : "75"
+ * }
+ * }
+ * }
+ * },
+ * {
+ * "weight" : "2",
+ * "root" : {
+ * "value" : "-10"
+ * }
+ * }
+ * ]
+ * }
+ * }
+ * </pre>
+ *
+ * <p>Training libraries:
+ *
* <ul>
- * <li> <a href="http://sourceforge.net/p/lemur/wiki/RankLib/">RankLib</a>
+ * <li><a href="http://sourceforge.net/p/lemur/wiki/RankLib/">RankLib</a>
* </ul>
- * <p>
- * Background reading:
+ *
+ * <p>Background reading:
+ *
* <ul>
- * <li> <a href="http://research.microsoft.com/pubs/132652/MSR-TR-2010-82.pdf">
- * Christopher J.C. Burges. From RankNet to LambdaRank to LambdaMART: An Overview.
- * Microsoft Research Technical Report MSR-TR-2010-82.</a>
+ * <li><a href="http://research.microsoft.com/pubs/132652/MSR-TR-2010-82.pdf">Christopher J.C.
+ * Burges. From RankNet to LambdaRank to LambdaMART: An Overview. Microsoft Research Technical
+ * Report MSR-TR-2010-82.</a>
* </ul>
+ *
* <ul>
- * <li> <a href="https://papers.nips.cc/paper/3305-a-general-boosting-method-and-its-application-to-learning-ranking-functions-for-web-search.pdf">
- * Z. Zheng, H. Zha, T. Zhang, O. Chapelle, K. Chen, and G. Sun. A General Boosting Method and its Application to Learning Ranking Functions for Web Search.
- * Advances in Neural Information Processing Systems (NIPS), 2007.</a>
+ * <li><a
+ * href="https://papers.nips.cc/paper/3305-a-general-boosting-method-and-its-application-to-learning-ranking-functions-for-web-search.pdf">
+ * Z. Zheng, H. Zha, T. Zhang, O. Chapelle, K. Chen, and G. Sun. A General Boosting Method and
+ * its Application to Learning Ranking Functions for Web Search. Advances in Neural
+ * Information Processing Systems (NIPS), 2007.</a>
* </ul>
*/
public class MultipleAdditiveTreesModel extends LTRScoringModel {
/**
- * fname2index is filled from constructor arguments
- * (that are already part of the base class hashCode)
- * and therefore here it does not individually
- * influence the class hashCode, equals, etc.
+ * fname2index is filled from constructor arguments (that are already part of the base class
+ * hashCode) and therefore here it does not individually influence the class hashCode, equals,
+ * etc.
*/
- private final HashMap<String,Integer> fname2index;
+ private final HashMap<String, Integer> fname2index;
/**
- * trees is part of the LTRScoringModel params map
- * and therefore here it does not individually
+ * trees is part of the LTRScoringModel params map and therefore here it does not individually
* influence the class hashCode, equals, etc.
*/
private List<RegressionTree> trees;
- private RegressionTree createRegressionTree(Map<String,Object> map) {
+ private RegressionTree createRegressionTree(Map<String, Object> map) {
final RegressionTree rt = new RegressionTree();
if (map != null) {
SolrPluginUtils.invokeSetters(rt, map.entrySet());
@@ -113,7 +118,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
return rt;
}
- private RegressionTreeNode createRegressionTreeNode(Map<String,Object> map) {
+ private RegressionTreeNode createRegressionTreeNode(Map<String, Object> map) {
final RegressionTreeNode rtn = new RegressionTreeNode();
if (map != null) {
SolrPluginUtils.invokeSetters(rtn, map.entrySet());
@@ -158,12 +163,12 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
@SuppressWarnings({"unchecked"})
public void setLeft(Object left) {
- this.left = createRegressionTreeNode((Map<String,Object>) left);
+ this.left = createRegressionTreeNode((Map<String, Object>) left);
}
@SuppressWarnings({"unchecked"})
public void setRight(Object right) {
- this.right = createRegressionTreeNode((Map<String,Object>) right);
+ this.right = createRegressionTreeNode((Map<String, Object>) right);
}
public boolean isLeaf() {
@@ -177,7 +182,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
sb.append(value);
} else {
sb.append("(feature=").append(feature);
- sb.append(",threshold=").append(threshold.floatValue()-NODE_SPLIT_SLACK);
+ sb.append(",threshold=").append(threshold.floatValue() - NODE_SPLIT_SLACK);
sb.append(",left=").append(left);
sb.append(",right=").append(right);
sb.append(')');
@@ -185,9 +190,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
return sb.toString();
}
- public RegressionTreeNode() {
- }
-
+ public RegressionTreeNode() {}
}
public class RegressionTree {
@@ -205,7 +208,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
@SuppressWarnings({"unchecked"})
public void setRoot(Object root) {
- this.root = createRegressionTreeNode((Map<String,Object>)root);
+ this.root = createRegressionTreeNode((Map<String, Object>) root);
}
public float score(float[] featureVector) {
@@ -225,8 +228,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
return sb.toString();
}
- public RegressionTree() {
- }
+ public RegressionTree() {}
public void validate() throws ModelException {
if (weight == null) {
@@ -244,18 +246,21 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
public void setTrees(Object trees) {
this.trees = new ArrayList<RegressionTree>();
for (final Object o : (List<Object>) trees) {
- final RegressionTree rt = createRegressionTree((Map<String,Object>) o);
+ final RegressionTree rt = createRegressionTree((Map<String, Object>) o);
this.trees.add(rt);
}
}
- public MultipleAdditiveTreesModel(String name, List<Feature> features,
+ public MultipleAdditiveTreesModel(
+ String name,
+ List<Feature> features,
List<Normalizer> norms,
- String featureStoreName, List<Feature> allFeatures,
- Map<String,Object> params) {
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
- fname2index = new HashMap<String,Integer>();
+ fname2index = new HashMap<String, Integer>();
for (int i = 0; i < features.size(); ++i) {
final String key = features.get(i).getName();
fname2index.put(key, i);
@@ -266,7 +271,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
protected void validate() throws ModelException {
super.validate();
if (trees == null) {
- throw new ModelException("no trees declared for model "+name);
+ throw new ModelException("no trees declared for model " + name);
}
for (RegressionTree tree : trees) {
tree.validate();
@@ -288,7 +293,8 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
return regressionTreeNode.value;
}
// unsupported feature (tree is looking for a feature that does not exist)
- if ((regressionTreeNode.featureIndex < 0) || (regressionTreeNode.featureIndex >= featureVector.length)) {
+ if ((regressionTreeNode.featureIndex < 0)
+ || (regressionTreeNode.featureIndex >= featureVector.length)) {
return 0f;
}
@@ -301,7 +307,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
}
private static void validateNode(RegressionTreeNode regressionTreeNode) throws ModelException {
-
+
// Create an empty stack and push root to it
Stack<RegressionTreeNode> stack = new Stack<RegressionTreeNode>();
stack.push(regressionTreeNode);
@@ -311,7 +317,11 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
if (topStackNode.isLeaf()) {
if (topStackNode.left != null || topStackNode.right != null) {
- throw new ModelException("MultipleAdditiveTreesModel tree node is leaf with left=" + topStackNode.left + " and right=" + topStackNode.right);
+ throw new ModelException(
+ "MultipleAdditiveTreesModel tree node is leaf with left="
+ + topStackNode.left
+ + " and right="
+ + topStackNode.right);
}
continue;
}
@@ -340,8 +350,10 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
}
// unsupported feature (tree is looking for a feature that does not exist)
- if ((regressionTreeNode.featureIndex < 0) || (regressionTreeNode.featureIndex >= featureVector.length)) {
- returnValueBuilder.append("'" + regressionTreeNode.feature + "' does not exist in FV, Return Zero");
+ if ((regressionTreeNode.featureIndex < 0)
+ || (regressionTreeNode.featureIndex >= featureVector.length)) {
+ returnValueBuilder.append(
+ "'" + regressionTreeNode.feature + "' does not exist in FV, Return Zero");
return returnValueBuilder.toString();
}
@@ -350,19 +362,29 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
// that here
if (featureVector[regressionTreeNode.featureIndex] <= regressionTreeNode.threshold) {
- returnValueBuilder.append("'" + regressionTreeNode.feature + "':" + featureVector[regressionTreeNode.featureIndex] + " <= "
- + regressionTreeNode.threshold + ", Go Left | ");
+ returnValueBuilder.append(
+ "'"
+ + regressionTreeNode.feature
+ + "':"
+ + featureVector[regressionTreeNode.featureIndex]
+ + " <= "
+ + regressionTreeNode.threshold
+ + ", Go Left | ");
regressionTreeNode = regressionTreeNode.left;
} else {
- returnValueBuilder.append("'" + regressionTreeNode.feature + "':" + featureVector[regressionTreeNode.featureIndex] + " > "
- + regressionTreeNode.threshold + ", Go Right | ");
+ returnValueBuilder.append(
+ "'"
+ + regressionTreeNode.feature
+ + "':"
+ + featureVector[regressionTreeNode.featureIndex]
+ + " > "
+ + regressionTreeNode.threshold
+ + ", Go Right | ");
regressionTreeNode = regressionTreeNode.right;
}
}
-
}
-
// /////////////////////////////////////////
// produces a string that looks like:
// 40.0 = multipleadditivetreesmodel [ org.apache.solr.ltr.model.MultipleAdditiveTreesModel ]
@@ -373,8 +395,8 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
// exist in FV, Go Left | val: 50.0
// -10.0 = tree 1 | val: -10.0
@Override
- public Explanation explain(LeafReaderContext context, int doc,
- float finalScore, List<Explanation> featureExplanations) {
+ public Explanation explain(
+ LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations) {
final float[] fv = new float[featureExplanations.size()];
int index = 0;
for (final Explanation featureExplain : featureExplanations) {
@@ -387,14 +409,13 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
for (final RegressionTree t : trees) {
final float score = t.score(fv);
- final Explanation p = Explanation.match(score, "tree " + index + " | "
- + t.explain(fv));
+ final Explanation p = Explanation.match(score, "tree " + index + " | " + t.explain(fv));
details.add(p);
index++;
}
- return Explanation.match(finalScore, toString()
- + " model applied to features, sum of:", details);
+ return Explanation.match(
+ finalScore, toString() + " model applied to features, sum of:", details);
}
@Override
@@ -403,7 +424,7 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
sb.append("(name=").append(getName());
sb.append(",trees=[");
for (int ii = 0; ii < trees.size(); ++ii) {
- if (ii>0) {
+ if (ii > 0) {
sb.append(',');
}
sb.append(trees.get(ii));
@@ -411,5 +432,4 @@ public class MultipleAdditiveTreesModel extends LTRScoringModel {
sb.append("])");
return sb.toString();
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/NeuralNetworkModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/NeuralNetworkModel.java
index d136eea..de76958 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/NeuralNetworkModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/NeuralNetworkModel.java
@@ -19,7 +19,6 @@ package org.apache.solr.ltr.model;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.solr.ltr.feature.Feature;
@@ -28,75 +27,81 @@ import org.apache.solr.util.SolrPluginUtils;
/**
* A scoring model that computes document scores using a neural network.
- * <p>
- * Supported <a href="https://en.wikipedia.org/wiki/Activation_function">activation functions</a> are:
- * <code>identity</code>, <code>relu</code>, <code>sigmoid</code>, <code>tanh</code>, <code>leakyrelu</code> and
- * contributions to support additional activation functions are welcome.
- * <p>
- * Example configuration:
-<pre>{
- "class" : "org.apache.solr.ltr.model.NeuralNetworkModel",
- "name" : "rankNetModel",
- "features" : [
- { "name" : "documentRecency" },
- { "name" : "isBook" },
- { "name" : "originalScore" }
- ],
- "params" : {
- "layers" : [
- {
- "matrix" : [ [ 1.0, 2.0, 3.0 ],
- [ 4.0, 5.0, 6.0 ],
- [ 7.0, 8.0, 9.0 ],
- [ 10.0, 11.0, 12.0 ] ],
- "bias" : [ 13.0, 14.0, 15.0, 16.0 ],
- "activation" : "sigmoid"
- },
- {
- "matrix" : [ [ 17.0, 18.0, 19.0, 20.0 ],
- [ 21.0, 22.0, 23.0, 24.0 ] ],
- "bias" : [ 25.0, 26.0 ],
- "activation" : "relu"
- },
- {
- "matrix" : [ [ 27.0, 28.0 ],
- [ 29.0, 30.0 ] ],
- "bias" : [ 31.0, 32.0 ],
- "activation" : "leakyrelu"
- },
- {
- "matrix" : [ [ 33.0, 34.0 ],
- [ 35.0, 36.0 ] ],
- "bias" : [ 37.0, 38.0 ],
- "activation" : "tanh"
- },
- {
- "matrix" : [ [ 39.0, 40.0 ] ],
- "bias" : [ 41.0 ],
- "activation" : "identity"
- }
- ]
- }
-}</pre>
- * <p>
- * Training libraries:
+ *
+ * <p>Supported <a href="https://en.wikipedia.org/wiki/Activation_function">activation functions</a>
+ * are: <code>identity</code>, <code>relu</code>, <code>sigmoid</code>, <code>tanh</code>, <code>
+ * leakyrelu</code> and contributions to support additional activation functions are welcome.
+ *
+ * <p>Example configuration:
+ *
+ * <pre>
+ * {
+ * "class" : "org.apache.solr.ltr.model.NeuralNetworkModel",
+ * "name" : "rankNetModel",
+ * "features" : [
+ * { "name" : "documentRecency" },
+ * { "name" : "isBook" },
+ * { "name" : "originalScore" }
+ * ],
+ * "params" : {
+ * "layers" : [
+ * {
+ * "matrix" : [ [ 1.0, 2.0, 3.0 ],
+ * [ 4.0, 5.0, 6.0 ],
+ * [ 7.0, 8.0, 9.0 ],
+ * [ 10.0, 11.0, 12.0 ] ],
+ * "bias" : [ 13.0, 14.0, 15.0, 16.0 ],
+ * "activation" : "sigmoid"
+ * },
+ * {
+ * "matrix" : [ [ 17.0, 18.0, 19.0, 20.0 ],
+ * [ 21.0, 22.0, 23.0, 24.0 ] ],
+ * "bias" : [ 25.0, 26.0 ],
+ * "activation" : "relu"
+ * },
+ * {
+ * "matrix" : [ [ 27.0, 28.0 ],
+ * [ 29.0, 30.0 ] ],
+ * "bias" : [ 31.0, 32.0 ],
+ * "activation" : "leakyrelu"
+ * },
+ * {
+ * "matrix" : [ [ 33.0, 34.0 ],
+ * [ 35.0, 36.0 ] ],
+ * "bias" : [ 37.0, 38.0 ],
+ * "activation" : "tanh"
+ * },
+ * {
+ * "matrix" : [ [ 39.0, 40.0 ] ],
+ * "bias" : [ 41.0 ],
+ * "activation" : "identity"
+ * }
+ * ]
+ * }
+ * }
+ * </pre>
+ *
+ * <p>Training libraries:
+ *
* <ul>
- * <li> <a href="https://keras.io">Keras</a> is a high-level neural networks API, written in Python.
- * A Keras and Solr implementation of RankNet can be found at <a href="https://github.com/airalcorn2/RankNet">https://github.com/airalcorn2/RankNet</a>.
+ * <li><a href="https://keras.io">Keras</a> is a high-level neural networks API, written in
+ * Python. A Keras and Solr implementation of RankNet can be found at <a
+ * href="https://github.com/airalcorn2/RankNet">https://github.com/airalcorn2/RankNet</a>.
* </ul>
- * <p>
- * Background reading:
+ *
+ * <p>Background reading:
+ *
* <ul>
- * <li> <a href="http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf">
- * C. Burges, T. Shaked, E. Renshaw, A. Lazier, M. Deeds, N. Hamilton, and G. Hullender. Learning to Rank Using Gradient Descent.
- * Proceedings of the 22nd International Conference on Machine Learning (ICML), ACM, 2005.</a>
+ * <li><a href="http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf">C. Burges, T.
+ * Shaked, E. Renshaw, A. Lazier, M. Deeds, N. Hamilton, and G. Hullender. Learning to Rank
+ * Using Gradient Descent. Proceedings of the 22nd International Conference on Machine
+ * Learning (ICML), ACM, 2005.</a>
* </ul>
*/
public class NeuralNetworkModel extends LTRScoringModel {
/**
- * layers is part of the LTRScoringModel params map
- * and therefore here it does not individually
+ * layers is part of the LTRScoringModel params map and therefore here it does not individually
* influence the class hashCode, equals, etc.
*/
private List<Layer> layers;
@@ -108,7 +113,9 @@ public class NeuralNetworkModel extends LTRScoringModel {
public interface Layer {
public float[] calculateOutput(float[] inputVec);
+
public int validate(int inputDim) throws ModelException;
+
public String describe();
}
@@ -155,44 +162,49 @@ public class NeuralNetworkModel extends LTRScoringModel {
this.activationStr = (String) activationStr;
switch (this.activationStr) {
case "relu":
- this.activation = new Activation() {
- @Override
- public float apply(float in) {
- return in < 0 ? 0 : in;
- }
- };
+ this.activation =
+ new Activation() {
+ @Override
+ public float apply(float in) {
+ return in < 0 ? 0 : in;
+ }
+ };
break;
case "leakyrelu":
- this.activation = new Activation() {
- @Override
- public float apply(float in) {
- return in < 0 ? 0.01f * in : in;
- }
- };
+ this.activation =
+ new Activation() {
+ @Override
+ public float apply(float in) {
+ return in < 0 ? 0.01f * in : in;
+ }
+ };
break;
case "tanh":
- this.activation = new Activation() {
- @Override
- public float apply(float in) {
- return (float)Math.tanh(in);
- }
- };
+ this.activation =
+ new Activation() {
+ @Override
+ public float apply(float in) {
+ return (float) Math.tanh(in);
+ }
+ };
break;
case "sigmoid":
- this.activation = new Activation() {
- @Override
- public float apply(float in) {
- return (float) (1 / (1 + Math.exp(-in)));
- }
- };
+ this.activation =
+ new Activation() {
+ @Override
+ public float apply(float in) {
+ return (float) (1 / (1 + Math.exp(-in)));
+ }
+ };
break;
case "identity":
- this.activation = new Activation() {
- @Override
- public float apply(float in) {
- return in;
- }
- };
+ this.activation =
+ new Activation() {
+ @Override
+ public float apply(float in) {
+ return in;
+ }
+ };
break;
default:
this.activation = null;
@@ -217,23 +229,51 @@ public class NeuralNetworkModel extends LTRScoringModel {
public int validate(int inputDim) throws ModelException {
if (this.numUnits != this.matrixRows) {
- throw new ModelException("Dimension mismatch in model \"" + name + "\". Layer " +
- Integer.toString(this.layerID) + " has " + Integer.toString(this.numUnits) +
- " bias weights but " + Integer.toString(this.matrixRows) + " weight matrix rows.");
+ throw new ModelException(
+ "Dimension mismatch in model \""
+ + name
+ + "\". Layer "
+ + Integer.toString(this.layerID)
+ + " has "
+ + Integer.toString(this.numUnits)
+ + " bias weights but "
+ + Integer.toString(this.matrixRows)
+ + " weight matrix rows.");
}
if (this.activation == null) {
- throw new ModelException("Invalid activation function (\""+this.activationStr+"\") in layer "+Integer.toString(this.layerID)+" of model \"" + name + "\".");
+ throw new ModelException(
+ "Invalid activation function (\""
+ + this.activationStr
+ + "\") in layer "
+ + Integer.toString(this.layerID)
+ + " of model \""
+ + name
+ + "\".");
}
if (inputDim != this.matrixCols) {
if (this.layerID == 0) {
- throw new ModelException("Dimension mismatch in model \"" + name + "\". The input has " +
- Integer.toString(inputDim) + " features, but the weight matrix for layer 0 has " +
- Integer.toString(this.matrixCols) + " columns.");
+ throw new ModelException(
+ "Dimension mismatch in model \""
+ + name
+ + "\". The input has "
+ + Integer.toString(inputDim)
+ + " features, but the weight matrix for layer 0 has "
+ + Integer.toString(this.matrixCols)
+ + " columns.");
} else {
- throw new ModelException("Dimension mismatch in model \"" + name + "\". The weight matrix for layer " +
- Integer.toString(this.layerID - 1) + " has " + Integer.toString(inputDim) + " rows, but the " +
- "weight matrix for layer " + Integer.toString(this.layerID) + " has " +
- Integer.toString(this.matrixCols) + " columns.");
+ throw new ModelException(
+ "Dimension mismatch in model \""
+ + name
+ + "\". The weight matrix for layer "
+ + Integer.toString(this.layerID - 1)
+ + " has "
+ + Integer.toString(inputDim)
+ + " rows, but the "
+ + "weight matrix for layer "
+ + Integer.toString(this.layerID)
+ + " has "
+ + Integer.toString(this.matrixCols)
+ + " columns.");
}
}
return this.matrixRows;
@@ -241,9 +281,13 @@ public class NeuralNetworkModel extends LTRScoringModel {
public String describe() {
final StringBuilder sb = new StringBuilder();
- sb
- .append("(matrix=").append(Integer.toString(this.matrixRows)).append('x').append(Integer.toString(this.matrixCols))
- .append(",activation=").append(this.activationStr).append(")");
+ sb.append("(matrix=")
+ .append(Integer.toString(this.matrixRows))
+ .append('x')
+ .append(Integer.toString(this.matrixCols))
+ .append(",activation=")
+ .append(this.activationStr)
+ .append(")");
return sb.toString();
}
}
@@ -252,7 +296,7 @@ public class NeuralNetworkModel extends LTRScoringModel {
protected Layer createLayer(Object o) {
final DefaultLayer layer = new DefaultLayer();
if (o != null) {
- SolrPluginUtils.invokeSetters(layer, ((Map<String,Object>) o).entrySet());
+ SolrPluginUtils.invokeSetters(layer, ((Map<String, Object>) o).entrySet());
}
return layer;
}
@@ -266,10 +310,13 @@ public class NeuralNetworkModel extends LTRScoringModel {
}
}
- public NeuralNetworkModel(String name, List<Feature> features,
- List<Normalizer> norms,
- String featureStoreName, List<Feature> allFeatures,
- Map<String,Object> params) {
+ public NeuralNetworkModel(
+ String name,
+ List<Feature> features,
+ List<Normalizer> norms,
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
}
@@ -284,8 +331,12 @@ public class NeuralNetworkModel extends LTRScoringModel {
}
if (inputDim != 1) {
- throw new ModelException("The output matrix for model \"" + name + "\" has " + Integer.toString(inputDim) +
- " rows, but should only have one.");
+ throw new ModelException(
+ "The output matrix for model \""
+ + name
+ + "\" has "
+ + Integer.toString(inputDim)
+ + " rows, but should only have one.");
}
}
@@ -302,8 +353,8 @@ public class NeuralNetworkModel extends LTRScoringModel {
}
@Override
- public Explanation explain(LeafReaderContext context, int doc,
- float finalScore, List<Explanation> featureExplanations) {
+ public Explanation explain(
+ LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations) {
final StringBuilder modelDescription = new StringBuilder();
@@ -329,5 +380,4 @@ public class NeuralNetworkModel extends LTRScoringModel {
return Explanation.match(finalScore, modelDescription.toString());
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java
index e143d3b..19ff7c9 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/WrapperModel.java
@@ -20,7 +20,6 @@ package org.apache.solr.ltr.model;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.solr.ltr.feature.Feature;
@@ -29,26 +28,28 @@ import org.apache.solr.ltr.norm.Normalizer;
/**
* A scoring model that wraps the other model.
*
- * <p>This model loads a model from an external resource during the initialization.
- * The way of fetching the wrapped model is depended on
- * the implementation of {@link WrapperModel#fetchModelMap()}.
+ * <p>This model loads a model from an external resource during the initialization. The way of
+ * fetching the wrapped model is depended on the implementation of {@link
+ * WrapperModel#fetchModelMap()}.
*
- * <p>This model doesn't hold the actual parameters of the wrapped model,
- * thus it can manage large models which are difficult to upload to ZooKeeper.
+ * <p>This model doesn't hold the actual parameters of the wrapped model, thus it can manage large
+ * models which are difficult to upload to ZooKeeper.
*
* <p>Example configuration:
- * <pre>{
- "class": "...",
- "name": "myModelName",
- "params": {
- ...
- }
- }</pre>
*
- * <p>NOTE: no "features" are configured in the wrapper model
- * because the wrapped model's features will be used instead.
- * Also note that if a "store" is configured for the wrapper
- * model then it must match the "store" of the wrapped model.
+ * <pre>
+ * {
+ * "class": "...",
+ * "name": "myModelName",
+ * "params": {
+ * ...
+ * }
+ * }
+ * </pre>
+ *
+ * <p>NOTE: no "features" are configured in the wrapper model because the wrapped model's features
+ * will be used instead. Also note that if a "store" is configured for the wrapper model then it
+ * must match the "store" of the wrapped model.
*/
public abstract class WrapperModel extends AdapterModel {
@@ -78,8 +79,13 @@ public abstract class WrapperModel extends AdapterModel {
return true;
}
- public WrapperModel(String name, List<Feature> features, List<Normalizer> norms, String featureStoreName,
- List<Feature> allFeatures, Map<String, Object> params) {
+ public WrapperModel(
+ String name,
+ List<Feature> features,
+ List<Normalizer> norms,
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
}
@@ -97,10 +103,16 @@ public abstract class WrapperModel extends AdapterModel {
model.validate();
// check feature store names match
final String wrappedFeatureStoreName = model.getFeatureStoreName();
- if (wrappedFeatureStoreName == null || !wrappedFeatureStoreName.equals(this.getFeatureStoreName())) {
- throw new ModelException("wrapper feature store name ("+this.getFeatureStoreName() +")"
- + " must match the "
- + "wrapped feature store name ("+wrappedFeatureStoreName+")");
+ if (wrappedFeatureStoreName == null
+ || !wrappedFeatureStoreName.equals(this.getFeatureStoreName())) {
+ throw new ModelException(
+ "wrapper feature store name ("
+ + this.getFeatureStoreName()
+ + ")"
+ + " must match the "
+ + "wrapped feature store name ("
+ + wrappedFeatureStoreName
+ + ")");
}
}
}
@@ -141,8 +153,8 @@ public abstract class WrapperModel extends AdapterModel {
}
@Override
- public Explanation explain(LeafReaderContext context, int doc, float finalScore,
- List<Explanation> featureExplanations) {
+ public Explanation explain(
+ LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations) {
return model.explain(context, doc, finalScore, featureExplanations);
}
@@ -164,5 +176,4 @@ public abstract class WrapperModel extends AdapterModel {
return sb.toString();
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/package-info.java
index 32bd626..4e8f26c 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/model/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/model/package-info.java
@@ -15,7 +15,5 @@
* limitations under the License.
*/
-/**
- * Contains Model related classes
- */
+/** Contains Model related classes */
package org.apache.solr.ltr.model;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/IdentityNormalizer.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/IdentityNormalizer.java
index a3d1026..a5c9b4b 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/IdentityNormalizer.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/IdentityNormalizer.java
@@ -19,17 +19,14 @@ package org.apache.solr.ltr.norm;
import java.util.LinkedHashMap;
/**
- * A Normalizer that normalizes a feature value to itself. This is the
- * default normalizer class, if no normalizer is configured then the
- * IdentityNormalizer will be used.
+ * A Normalizer that normalizes a feature value to itself. This is the default normalizer class, if
+ * no normalizer is configured then the IdentityNormalizer will be used.
*/
public class IdentityNormalizer extends Normalizer {
public static final IdentityNormalizer INSTANCE = new IdentityNormalizer();
- public IdentityNormalizer() {
-
- }
+ public IdentityNormalizer() {}
@Override
public float normalize(float value) {
@@ -37,17 +34,15 @@ public class IdentityNormalizer extends Normalizer {
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
+ public LinkedHashMap<String, Object> paramsToMap() {
return null;
}
@Override
- protected void validate() throws NormalizerException {
- }
+ protected void validate() throws NormalizerException {}
@Override
public String toString() {
return getClass().getSimpleName();
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/MinMaxNormalizer.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/MinMaxNormalizer.java
index f6322fe..4754d3d 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/MinMaxNormalizer.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/MinMaxNormalizer.java
@@ -20,19 +20,22 @@ import java.util.LinkedHashMap;
/**
* A Normalizer to scale a feature value using a (min,max) range.
- * <p>
- * Example configuration:
-<pre>
-"norm" : {
- "class" : "org.apache.solr.ltr.norm.MinMaxNormalizer",
- "params" : { "min":"0", "max":"50" }
-}
-</pre>
+ *
+ * <p>Example configuration:
+ *
+ * <pre>
+ * "norm" : {
+ * "class" : "org.apache.solr.ltr.norm.MinMaxNormalizer",
+ * "params" : { "min":"0", "max":"50" }
+ * }
+ * </pre>
+ *
* Example normalizations:
+ *
* <ul>
- * <li>-5 will be normalized to -0.1
- * <li>55 will be normalized to 1.1
- * <li>+5 will be normalized to +0.1
+ * <li>-5 will be normalized to -0.1
+ * <li>55 will be normalized to 1.1
+ * <li>+5 will be normalized to +0.1
* </ul>
*/
public class MinMaxNormalizer extends Normalizer {
@@ -76,9 +79,14 @@ public class MinMaxNormalizer extends Normalizer {
@Override
protected void validate() throws NormalizerException {
if (delta == 0f) {
- throw
- new NormalizerException("MinMax Normalizer delta must not be zero " +
- "| min = " + min + ",max = " + max + ",delta = " + delta);
+ throw new NormalizerException(
+ "MinMax Normalizer delta must not be zero "
+ + "| min = "
+ + min
+ + ",max = "
+ + max
+ + ",delta = "
+ + delta);
}
}
@@ -88,8 +96,8 @@ public class MinMaxNormalizer extends Normalizer {
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
- final LinkedHashMap<String,Object> params = new LinkedHashMap<>(2, 1.0f);
+ public LinkedHashMap<String, Object> paramsToMap() {
+ final LinkedHashMap<String, Object> params = new LinkedHashMap<>(2, 1.0f);
params.put("min", Float.toString(min));
params.put("max", Float.toString(max));
return params;
@@ -103,5 +111,4 @@ public class MinMaxNormalizer extends Normalizer {
sb.append(",max=").append(max).append(')');
return sb.toString();
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/Normalizer.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/Normalizer.java
index b475173..6e96675 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/Normalizer.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/Normalizer.java
@@ -18,22 +18,20 @@ package org.apache.solr.ltr.norm;
import java.util.LinkedHashMap;
import java.util.Map;
-
import org.apache.lucene.search.Explanation;
import org.apache.solr.core.SolrResourceLoader;
import org.apache.solr.util.SolrPluginUtils;
/**
- * A normalizer normalizes the value of a feature. After the feature values
- * have been computed, the {@link Normalizer#normalize(float)} methods will
- * be called and the resulting values will be used by the model.
+ * A normalizer normalizes the value of a feature. After the feature values have been computed, the
+ * {@link Normalizer#normalize(float)} methods will be called and the resulting values will be used
+ * by the model.
*/
public abstract class Normalizer {
-
public abstract float normalize(float value);
- public abstract LinkedHashMap<String,Object> paramsToMap();
+ public abstract LinkedHashMap<String, Object> paramsToMap();
public Explanation explain(Explanation explain) {
final float normalized = normalize(explain.getValue().floatValue());
@@ -42,8 +40,8 @@ public abstract class Normalizer {
return Explanation.match(normalized, explainDesc, explain);
}
- public static Normalizer getInstance(SolrResourceLoader solrResourceLoader,
- String className, Map<String,Object> params) {
+ public static Normalizer getInstance(
+ SolrResourceLoader solrResourceLoader, String className, Map<String, Object> params) {
final Normalizer f = solrResourceLoader.newInstance(className, Normalizer.class);
if (params != null) {
SolrPluginUtils.invokeSetters(f, params.entrySet());
@@ -53,12 +51,10 @@ public abstract class Normalizer {
}
/**
- * As part of creation of a normalizer instance, this function confirms
- * that the normalizer parameters are valid.
+ * As part of creation of a normalizer instance, this function confirms that the normalizer
+ * parameters are valid.
*
- * @throws NormalizerException
- * Normalizer Exception
+ * @throws NormalizerException Normalizer Exception
*/
protected abstract void validate() throws NormalizerException;
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/NormalizerException.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/NormalizerException.java
index 5b33f05..091b428 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/NormalizerException.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/NormalizerException.java
@@ -27,5 +27,4 @@ public class NormalizerException extends RuntimeException {
public NormalizerException(String message, Exception cause) {
super(message, cause);
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/StandardNormalizer.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/StandardNormalizer.java
index d908ea94..2c17822 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/StandardNormalizer.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/StandardNormalizer.java
@@ -20,20 +20,22 @@ import java.util.LinkedHashMap;
/**
* A Normalizer to scale a feature value around an average-and-standard-deviation distribution.
- * <p>
- * Example configuration:
-<pre>
-"norm" : {
- "class" : "org.apache.solr.ltr.norm.StandardNormalizer",
- "params" : { "avg":"42", "std":"6" }
-}
-</pre>
- * <p>
- * Example normalizations:
+ *
+ * <p>Example configuration:
+ *
+ * <pre>
+ * "norm" : {
+ * "class" : "org.apache.solr.ltr.norm.StandardNormalizer",
+ * "params" : { "avg":"42", "std":"6" }
+ * }
+ * </pre>
+ *
+ * <p>Example normalizations:
+ *
* <ul>
- * <li>39 will be normalized to -0.5
- * <li>42 will be normalized to 0
- * <li>45 will be normalized to +0.5
+ * <li>39 will be normalized to -0.5
+ * <li>42 will be normalized to 0
+ * <li>45 will be normalized to +0.5
* </ul>
*/
public class StandardNormalizer extends Normalizer {
@@ -73,15 +75,18 @@ public class StandardNormalizer extends Normalizer {
@Override
protected void validate() throws NormalizerException {
if (std <= 0f) {
- throw
- new NormalizerException("Standard Normalizer standard deviation must "
- + "be positive | avg = " + avg + ",std = " + std);
+ throw new NormalizerException(
+ "Standard Normalizer standard deviation must "
+ + "be positive | avg = "
+ + avg
+ + ",std = "
+ + std);
}
}
@Override
- public LinkedHashMap<String,Object> paramsToMap() {
- final LinkedHashMap<String,Object> params = new LinkedHashMap<>(2, 1.0f);
+ public LinkedHashMap<String, Object> paramsToMap() {
+ final LinkedHashMap<String, Object> params = new LinkedHashMap<>(2, 1.0f);
params.put("avg", Float.toString(avg));
params.put("std", Float.toString(std));
return params;
@@ -95,5 +100,4 @@ public class StandardNormalizer extends Normalizer {
sb.append(",std=").append(avg).append(')');
return sb.toString();
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/package-info.java
index 164b425..dfdd0f5 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/norm/package-info.java
@@ -16,8 +16,7 @@
*/
/**
- * A normalizer normalizes the value of a feature. Once that the feature values
- * will be computed, the normalizer will be applied and the resulting values
- * will be received by the model.
+ * A normalizer normalizes the value of a feature. Once that the feature values will be computed,
+ * the normalizer will be applied and the resulting values will be received by the model.
*/
package org.apache.solr.ltr.norm;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/package-info.java
index 59aebe8..7266339 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/package-info.java
@@ -16,30 +16,24 @@
*/
/**
- * <p>
- * This package contains the main logic for performing the reranking using
- * a Learning to Rank model.
- * </p>
- * <p>
- * A model will be applied on each document through a {@link org.apache.solr.ltr.LTRScoringQuery}, a
- * subclass of {@link org.apache.lucene.search.Query}. As a normal query,
- * the learned model will produce a new score
- * for each document reranked.
- * </p>
- * <p>
- * A {@link org.apache.solr.ltr.LTRScoringQuery} is created by providing an instance of
- * {@link org.apache.solr.ltr.model.LTRScoringModel}. An instance of
- * {@link org.apache.solr.ltr.model.LTRScoringModel}
- * defines how to combine the features in order to create a new
- * score for a document. A new Learning to Rank model is plugged
- * into the framework by extending {@link org.apache.solr.ltr.model.LTRScoringModel},
- * (see for example {@link org.apache.solr.ltr.model.MultipleAdditiveTreesModel} and {@link org.apache.solr.ltr.model.LinearModel}).
- * </p>
- * <p>
- * The {@link org.apache.solr.ltr.LTRScoringQuery} will take care of computing the values of
- * all the features (see {@link org.apache.solr.ltr.feature.Feature}) and then will delegate the final score
- * generation to the {@link org.apache.solr.ltr.model.LTRScoringModel}, by calling the method
- * {@link org.apache.solr.ltr.model.LTRScoringModel#score(float[] modelFeatureValuesNormalized) score(float[] modelFeatureValuesNormalized)}.
- * </p>
+ * This package contains the main logic for performing the reranking using a Learning to Rank model.
+ *
+ * <p>A model will be applied on each document through a {@link
+ * org.apache.solr.ltr.LTRScoringQuery}, a subclass of {@link org.apache.lucene.search.Query}. As a
+ * normal query, the learned model will produce a new score for each document reranked.
+ *
+ * <p>A {@link org.apache.solr.ltr.LTRScoringQuery} is created by providing an instance of {@link
+ * org.apache.solr.ltr.model.LTRScoringModel}. An instance of {@link
+ * org.apache.solr.ltr.model.LTRScoringModel} defines how to combine the features in order to create
+ * a new score for a document. A new Learning to Rank model is plugged into the framework by
+ * extending {@link org.apache.solr.ltr.model.LTRScoringModel}, (see for example {@link
+ * org.apache.solr.ltr.model.MultipleAdditiveTreesModel} and {@link
+ * org.apache.solr.ltr.model.LinearModel}).
+ *
+ * <p>The {@link org.apache.solr.ltr.LTRScoringQuery} will take care of computing the values of all
+ * the features (see {@link org.apache.solr.ltr.feature.Feature}) and then will delegate the final
+ * score generation to the {@link org.apache.solr.ltr.model.LTRScoringModel}, by calling the method
+ * {@link org.apache.solr.ltr.model.LTRScoringModel#score(float[] modelFeatureValuesNormalized)
+ * score(float[] modelFeatureValuesNormalized)}.
*/
package org.apache.solr.ltr;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRFeatureLoggerTransformerFactory.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRFeatureLoggerTransformerFactory.java
index 310efb6..eb10aae 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRFeatureLoggerTransformerFactory.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRFeatureLoggerTransformerFactory.java
@@ -21,7 +21,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Map;
-
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.search.Explanation;
import org.apache.lucene.search.ScoreMode;
@@ -51,18 +50,19 @@ import org.apache.solr.search.SolrIndexSearcher;
import org.apache.solr.util.SolrPluginUtils;
/**
- * This transformer will take care to generate and append in the response the
- * features declared in the feature store of the current reranking model,
- * or a specified feature store. Ex. <code>fl=id,[features store=myStore efi.user_text="ibm"]</code>
- *
+ * This transformer will take care to generate and append in the response the features declared in
+ * the feature store of the current reranking model, or a specified feature store. Ex. <code>
+ * fl=id,[features store=myStore efi.user_text="ibm"]</code>
+ *
* <h2>Parameters</h2>
- * <code>store</code> - The feature store to extract features from. If not provided it
- * will default to the features used by your reranking model.<br>
- * <code>efi.*</code> - External feature information variables required by the features
- * you are extracting.<br>
- * <code>format</code> - The format you want the features to be returned in. Supports (dense|sparse). Defaults to dense.<br>
-*/
-
+ *
+ * <code>store</code> - The feature store to extract features from. If not provided it will default
+ * to the features used by your reranking model.<br>
+ * <code>efi.*</code> - External feature information variables required by the features you are
+ * extracting.<br>
+ * <code>format</code> - The format you want the features to be returned in. Supports
+ * (dense|sparse). Defaults to dense.<br>
+ */
public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
// used inside fl to specify the format (dense|sparse) of the extracted features
@@ -95,7 +95,8 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
}
public void setDefaultFormat(String defaultFormat) {
- this.defaultFormat = FeatureLogger.FeatureFormat.valueOf(defaultFormat.toUpperCase(Locale.ROOT));
+ this.defaultFormat =
+ FeatureLogger.FeatureFormat.valueOf(defaultFormat.toUpperCase(Locale.ROOT));
}
public void setCsvKeyValueDelimiter(String csvKeyValueDelimiter) {
@@ -120,31 +121,29 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
}
@Override
- public DocTransformer create(String name, SolrParams localparams,
- SolrQueryRequest req) {
+ public DocTransformer create(String name, SolrParams localparams, SolrQueryRequest req) {
// Hint to enable feature vector cache since we are requesting features
SolrQueryRequestContextUtils.setIsExtractingFeatures(req);
// Communicate which feature store we are requesting features for
final String fvStoreName = localparams.get(FV_STORE);
- SolrQueryRequestContextUtils.setFvStoreName(req, (fvStoreName == null ? defaultStore : fvStoreName));
+ SolrQueryRequestContextUtils.setFvStoreName(
+ req, (fvStoreName == null ? defaultStore : fvStoreName));
// Create and supply the feature logger to be used
- SolrQueryRequestContextUtils.setFeatureLogger(req,
- createFeatureLogger(
- localparams.get(FV_FORMAT)));
+ SolrQueryRequestContextUtils.setFeatureLogger(
+ req, createFeatureLogger(localparams.get(FV_FORMAT)));
- return new FeatureTransformer(name, localparams, req, (fvStoreName != null) /* hasExplicitFeatureStore */);
+ return new FeatureTransformer(
+ name, localparams, req, (fvStoreName != null) /* hasExplicitFeatureStore */);
}
/**
- * returns a FeatureLogger that logs the features
- * 'featureFormat' param: 'dense' will write features in dense format,
- * 'sparse' will write the features in sparse format, null or empty will
+ * returns a FeatureLogger that logs the features 'featureFormat' param: 'dense' will write
+ * features in dense format, 'sparse' will write the features in sparse format, null or empty will
* default to 'sparse'
*
- *
* @return a feature logger for the format specified.
*/
private FeatureLogger createFeatureLogger(String formatStr) {
@@ -162,31 +161,35 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
class FeatureTransformer extends DocTransformer {
- final private String name;
- final private SolrParams localparams;
- final private SolrQueryRequest req;
- final private boolean hasExplicitFeatureStore;
+ private final String name;
+ private final SolrParams localparams;
+ private final SolrQueryRequest req;
+ private final boolean hasExplicitFeatureStore;
private List<LeafReaderContext> leafContexts;
private SolrIndexSearcher searcher;
+
/**
* rerankingQueries, modelWeights have:
- * length=1 - [Classic LTR] When reranking with a single model
- * length=2 - [Interleaving] When reranking with interleaving (two ranking models are involved)
+ *
+ * <p>length=1 - [Classic LTR] When reranking with a single model
+ *
+ * <p>length=2 - [Interleaving] When reranking with interleaving (two ranking models are
+ * involved)
*/
private LTRScoringQuery[] rerankingQueriesFromContext;
+
private LTRScoringQuery[] rerankingQueries;
private LTRScoringQuery.ModelWeight[] modelWeights;
private FeatureLogger featureLogger;
private boolean docsWereNotReranked;
- /**
- * @param name
- * Name of the field to be added in a document representing the
- * feature vectors
- */
- public FeatureTransformer(String name, SolrParams localparams,
- SolrQueryRequest req, boolean hasExplicitFeatureStore) {
+ /** @param name Name of the field to be added in a document representing the feature vectors */
+ public FeatureTransformer(
+ String name,
+ SolrParams localparams,
+ SolrQueryRequest req,
+ boolean hasExplicitFeatureStore) {
this.name = name;
this.localparams = localparams;
this.req = req;
@@ -210,89 +213,116 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
searcher = context.getSearcher();
if (searcher == null) {
- throw new SolrException(
- SolrException.ErrorCode.BAD_REQUEST,
- "searcher is null");
+ throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "searcher is null");
}
leafContexts = searcher.getTopReaderContext().leaves();
if (threadManager != null) {
- threadManager.setExecutor(context.getRequest().getCore().getCoreContainer().getUpdateShardHandler().getUpdateExecutor());
+ threadManager.setExecutor(
+ context
+ .getRequest()
+ .getCore()
+ .getCoreContainer()
+ .getUpdateShardHandler()
+ .getUpdateExecutor());
}
rerankingQueriesFromContext = SolrQueryRequestContextUtils.getScoringQueries(req);
- docsWereNotReranked = (rerankingQueriesFromContext == null || rerankingQueriesFromContext.length == 0);
+ docsWereNotReranked =
+ (rerankingQueriesFromContext == null || rerankingQueriesFromContext.length == 0);
String transformerFeatureStore = SolrQueryRequestContextUtils.getFvStoreName(req);
- Map<String, String[]> transformerExternalFeatureInfo = LTRQParserPlugin.extractEFIParams(localparams);
+ Map<String, String[]> transformerExternalFeatureInfo =
+ LTRQParserPlugin.extractEFIParams(localparams);
final LoggingModel loggingModel = createLoggingModel(transformerFeatureStore);
- setupRerankingQueriesForLogging(transformerFeatureStore, transformerExternalFeatureInfo, loggingModel);
+ setupRerankingQueriesForLogging(
+ transformerFeatureStore, transformerExternalFeatureInfo, loggingModel);
setupRerankingWeightsForLogging(context);
}
/**
- * The loggingModel is an empty model that is just used to extract the features
- * and log them
+ * The loggingModel is an empty model that is just used to extract the features and log them
+ *
* @param transformerFeatureStore the explicit transformer feature store
*/
private LoggingModel createLoggingModel(String transformerFeatureStore) {
final ManagedFeatureStore fr = ManagedFeatureStore.getManagedFeatureStore(req.getCore());
final FeatureStore store = fr.getFeatureStore(transformerFeatureStore);
- transformerFeatureStore = store.getName(); // if transformerFeatureStore was null before this gets actual name
- return new LoggingModel(loggingModelName,
- transformerFeatureStore, store.getFeatures());
+ // if transformerFeatureStore was null before this gets actual name
+ transformerFeatureStore = store.getName();
+
+ return new LoggingModel(loggingModelName, transformerFeatureStore, store.getFeatures());
}
/**
* When preparing the reranking queries for logging features various scenarios apply:
- *
- * No Reranking
- * There is the need of a logger model from the default feature store or the explicit feature store passed
- * to extract the feature vector
- *
- * Re Ranking
- * 1) If no explicit feature store is passed, the models for each reranking query can be safely re-used
- * the feature vector can be fetched from the feature vector cache.
- * 2) If an explicit feature store is passed, and no reranking query uses a model with that feature store,
- * There is the need of a logger model to extract the feature vector
- * 3) If an explicit feature store is passed, and there is a reranking query that uses a model with that feature store,
- * the model can be re-used and there is no need for a logging model
+ *
+ * <p>No Reranking
+ *
+ * <p>There is the need of a logger model from the default feature store or the explicit feature
+ * store passed to extract the feature vector
+ *
+ * <p>Re Ranking
+ *
+ * <p>1) If no explicit feature store is passed, the models for each reranking query can be
+ * safely re-used the feature vector can be fetched from the feature vector cache.
+ *
+ * <p>2) If an explicit feature store is passed, and no reranking query uses a model with that
+ * feature store, There is the need of a logger model to extract the feature vector
+ *
+ * <p>3) If an explicit feature store is passed, and there is a reranking query that uses a
+ * model with that feature store, the model can be re-used and there is no need for a logging
+ * model
*
* @param transformerFeatureStore explicit feature store for the transformer
* @param transformerExternalFeatureInfo explicit efi for the transformer
*/
- private void setupRerankingQueriesForLogging(String transformerFeatureStore, Map<String, String[]> transformerExternalFeatureInfo, LoggingModel loggingModel) {
- if (docsWereNotReranked) { //no reranking query
- LTRScoringQuery loggingQuery = new LTRScoringQuery(loggingModel,
- transformerExternalFeatureInfo,
- true /* extractAllFeatures */,
- threadManager);
- rerankingQueries = new LTRScoringQuery[]{loggingQuery};
+ private void setupRerankingQueriesForLogging(
+ String transformerFeatureStore,
+ Map<String, String[]> transformerExternalFeatureInfo,
+ LoggingModel loggingModel) {
+ if (docsWereNotReranked) { // no reranking query
+ LTRScoringQuery loggingQuery =
+ new LTRScoringQuery(
+ loggingModel,
+ transformerExternalFeatureInfo,
+ true /* extractAllFeatures */,
+ threadManager);
+ rerankingQueries = new LTRScoringQuery[] {loggingQuery};
} else {
rerankingQueries = new LTRScoringQuery[rerankingQueriesFromContext.length];
- System.arraycopy(rerankingQueriesFromContext, 0, rerankingQueries, 0, rerankingQueriesFromContext.length);
-
- if (transformerFeatureStore != null) {// explicit feature store for the transformer
+ System.arraycopy(
+ rerankingQueriesFromContext,
+ 0,
+ rerankingQueries,
+ 0,
+ rerankingQueriesFromContext.length);
+
+ if (transformerFeatureStore != null) { // explicit feature store for the transformer
LTRScoringModel matchingRerankingModel = loggingModel;
for (LTRScoringQuery rerankingQuery : rerankingQueries) {
- if (!(rerankingQuery instanceof OriginalRankingLTRScoringQuery) &&
- transformerFeatureStore.equals(rerankingQuery.getScoringModel().getFeatureStoreName())) {
+ if (!(rerankingQuery instanceof OriginalRankingLTRScoringQuery)
+ && transformerFeatureStore.equals(
+ rerankingQuery.getScoringModel().getFeatureStoreName())) {
matchingRerankingModel = rerankingQuery.getScoringModel();
}
}
for (int i = 0; i < rerankingQueries.length; i++) {
- rerankingQueries[i] = new LTRScoringQuery(
- matchingRerankingModel,
- (!transformerExternalFeatureInfo.isEmpty() ? transformerExternalFeatureInfo : rerankingQueries[i].getExternalFeatureInfo()),
- true /* extractAllFeatures */,
- threadManager);
+ rerankingQueries[i] =
+ new LTRScoringQuery(
+ matchingRerankingModel,
+ (!transformerExternalFeatureInfo.isEmpty()
+ ? transformerExternalFeatureInfo
+ : rerankingQueries[i].getExternalFeatureInfo()),
+ true /* extractAllFeatures */,
+ threadManager);
}
}
}
}
-
+
private void setupRerankingWeightsForLogging(ResultContext context) {
modelWeights = new LTRScoringQuery.ModelWeight[rerankingQueries.length];
for (int i = 0; i < rerankingQueries.length; i++) {
@@ -300,9 +330,11 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
rerankingQueries[i].setOriginalQuery(context.getQuery());
}
rerankingQueries[i].setRequest(req);
- if (!(rerankingQueries[i] instanceof OriginalRankingLTRScoringQuery) || hasExplicitFeatureStore) {
+ if (!(rerankingQueries[i] instanceof OriginalRankingLTRScoringQuery)
+ || hasExplicitFeatureStore) {
if (rerankingQueries[i].getFeatureLogger() == null) {
- rerankingQueries[i].setFeatureLogger(SolrQueryRequestContextUtils.getFeatureLogger(req));
+ rerankingQueries[i].setFeatureLogger(
+ SolrQueryRequestContextUtils.getFeatureLogger(req));
}
featureLogger = rerankingQueries[i].getFeatureLogger();
try {
@@ -311,31 +343,31 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e.getMessage(), e);
}
if (modelWeights[i] == null) {
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST,
"error logging the features, model weight is null");
}
}
}
}
-
+
@Override
- public void transform(SolrDocument doc, int docid, float score)
- throws IOException {
+ public void transform(SolrDocument doc, int docid, float score) throws IOException {
implTransform(doc, docid, score);
}
@Override
- public void transform(SolrDocument doc, int docid)
- throws IOException {
+ public void transform(SolrDocument doc, int docid) throws IOException {
implTransform(doc, docid, null);
}
- private void implTransform(SolrDocument doc, int docid, Float score)
- throws IOException {
+ private void implTransform(SolrDocument doc, int docid, Float score) throws IOException {
LTRScoringQuery rerankingQuery = rerankingQueries[0];
LTRScoringQuery.ModelWeight rerankingModelWeight = modelWeights[0];
for (int i = 1; i < rerankingQueries.length; i++) {
- if (((LTRInterleavingScoringQuery)rerankingQueriesFromContext[i]).getPickedInterleavingDocIds().contains(docid)) {
+ if (((LTRInterleavingScoringQuery) rerankingQueriesFromContext[i])
+ .getPickedInterleavingDocIds()
+ .contains(docid)) {
rerankingQuery = rerankingQueries[i];
rerankingModelWeight = modelWeights[i];
}
@@ -343,29 +375,38 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
if (!(rerankingQuery instanceof OriginalRankingLTRScoringQuery) || hasExplicitFeatureStore) {
Object featureVector = featureLogger.getFeatureVector(docid, rerankingQuery, searcher);
if (featureVector == null) { // FV for this document was not in the cache
- featureVector = featureLogger.makeFeatureVector(
- LTRRescorer.extractFeaturesInfo(
- rerankingModelWeight,
- docid,
- (docsWereNotReranked ? score : null),
- leafContexts));
+ featureVector =
+ featureLogger.makeFeatureVector(
+ LTRRescorer.extractFeaturesInfo(
+ rerankingModelWeight,
+ docid,
+ (docsWereNotReranked ? score : null),
+ leafContexts));
}
doc.addField(name, featureVector);
}
}
-
}
private static class LoggingModel extends LTRScoringModel {
- public LoggingModel(String name, String featureStoreName, List<Feature> allFeatures){
- this(name, Collections.emptyList(), Collections.emptyList(),
- featureStoreName, allFeatures, Collections.emptyMap());
+ public LoggingModel(String name, String featureStoreName, List<Feature> allFeatures) {
+ this(
+ name,
+ Collections.emptyList(),
+ Collections.emptyList(),
+ featureStoreName,
+ allFeatures,
+ Collections.emptyMap());
}
- protected LoggingModel(String name, List<Feature> features,
- List<Normalizer> norms, String featureStoreName,
- List<Feature> allFeatures, Map<String,Object> params) {
+ protected LoggingModel(
+ String name,
+ List<Feature> features,
+ List<Normalizer> norms,
+ String featureStoreName,
+ List<Feature> allFeatures,
+ Map<String, Object> params) {
super(name, features, norms, featureStoreName, allFeatures, params);
}
@@ -375,11 +416,13 @@ public class LTRFeatureLoggerTransformerFactory extends TransformerFactory {
}
@Override
- public Explanation explain(LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations) {
- return Explanation.match(finalScore, toString()
- + " logging model, used only for logging the features");
+ public Explanation explain(
+ LeafReaderContext context,
+ int doc,
+ float finalScore,
+ List<Explanation> featureExplanations) {
+ return Explanation.match(
+ finalScore, toString() + " logging model, used only for logging the features");
}
-
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRInterleavingTransformerFactory.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRInterleavingTransformerFactory.java
index bffa0b3..91a59e6 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRInterleavingTransformerFactory.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/LTRInterleavingTransformerFactory.java
@@ -20,9 +20,9 @@ import java.io.IOException;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.common.util.NamedList;
-import org.apache.solr.ltr.interleaving.LTRInterleavingScoringQuery;
import org.apache.solr.ltr.LTRScoringQuery;
import org.apache.solr.ltr.SolrQueryRequestContextUtils;
+import org.apache.solr.ltr.interleaving.LTRInterleavingScoringQuery;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.response.ResultContext;
import org.apache.solr.response.transform.DocTransformer;
@@ -30,7 +30,7 @@ import org.apache.solr.response.transform.TransformerFactory;
import org.apache.solr.util.SolrPluginUtils;
public class LTRInterleavingTransformerFactory extends TransformerFactory {
-
+
@Override
public void init(NamedList<?> args) {
super.init(args);
@@ -38,25 +38,22 @@ public class LTRInterleavingTransformerFactory extends TransformerFactory {
}
@Override
- public DocTransformer create(String name, SolrParams localparams,
- SolrQueryRequest req) {
+ public DocTransformer create(String name, SolrParams localparams, SolrQueryRequest req) {
return new InterleavingTransformer(name, req);
}
-
+
class InterleavingTransformer extends DocTransformer {
- final private String name;
- final private SolrQueryRequest req;
-
+ private final String name;
+ private final SolrQueryRequest req;
+
private LTRInterleavingScoringQuery[] rerankingQueries;
/**
- * @param name
- * Name of the field to be added in a document representing the
- * model picked by the interleaving process
+ * @param name Name of the field to be added in a document representing the model picked by the
+ * interleaving process
*/
- public InterleavingTransformer(String name,
- SolrQueryRequest req) {
+ public InterleavingTransformer(String name, SolrQueryRequest req) {
this.name = name;
this.req = req;
}
@@ -75,7 +72,8 @@ public class LTRInterleavingTransformerFactory extends TransformerFactory {
if (context.getRequest() == null) {
return;
}
- rerankingQueries = (LTRInterleavingScoringQuery[])SolrQueryRequestContextUtils.getScoringQueries(req);
+ rerankingQueries =
+ (LTRInterleavingScoringQuery[]) SolrQueryRequestContextUtils.getScoringQueries(req);
for (int i = 0; i < rerankingQueries.length; i++) {
LTRScoringQuery scoringQuery = rerankingQueries[i];
@@ -83,31 +81,29 @@ public class LTRInterleavingTransformerFactory extends TransformerFactory {
scoringQuery.setOriginalQuery(context.getQuery());
}
if (scoringQuery.getFeatureLogger() == null) {
- scoringQuery.setFeatureLogger( SolrQueryRequestContextUtils.getFeatureLogger(req) );
+ scoringQuery.setFeatureLogger(SolrQueryRequestContextUtils.getFeatureLogger(req));
}
scoringQuery.setRequest(req);
}
}
@Override
- public void transform(SolrDocument doc, int docid, float score)
- throws IOException {
+ public void transform(SolrDocument doc, int docid, float score) throws IOException {
implTransform(doc, docid);
}
@Override
- public void transform(SolrDocument doc, int docid)
- throws IOException {
+ public void transform(SolrDocument doc, int docid) throws IOException {
implTransform(doc, docid);
}
private void implTransform(SolrDocument doc, int docid) {
LTRScoringQuery rerankingQuery = rerankingQueries[0];
- if (rerankingQueries.length > 1 && rerankingQueries[1].getPickedInterleavingDocIds().contains(docid)) {
+ if (rerankingQueries.length > 1
+ && rerankingQueries[1].getPickedInterleavingDocIds().contains(docid)) {
rerankingQuery = rerankingQueries[1];
}
doc.addField(name, rerankingQuery.getScoringModelName());
}
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/package-info.java
index a946135..0834f0f 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/response/transform/package-info.java
@@ -16,8 +16,7 @@
*/
/**
- * APIs and implementations of {@link org.apache.solr.response.transform.DocTransformer} for modifying documents in Solr request responses
+ * APIs and implementations of {@link org.apache.solr.response.transform.DocTransformer} for
+ * modifying documents in Solr request responses
*/
package org.apache.solr.ltr.response.transform;
-
-
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQParserPlugin.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQParserPlugin.java
index f29e7f3..eafc5a7 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQParserPlugin.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQParserPlugin.java
@@ -20,21 +20,20 @@ import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
-
+import org.apache.lucene.search.Query;
import org.apache.lucene.util.ResourceLoader;
import org.apache.lucene.util.ResourceLoaderAware;
-import org.apache.lucene.search.Query;
import org.apache.solr.common.SolrException;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.core.SolrResourceLoader;
-import org.apache.solr.ltr.interleaving.LTRInterleavingScoringQuery;
-import org.apache.solr.ltr.interleaving.OriginalRankingLTRScoringQuery;
import org.apache.solr.ltr.LTRScoringQuery;
import org.apache.solr.ltr.LTRThreadModule;
import org.apache.solr.ltr.SolrQueryRequestContextUtils;
import org.apache.solr.ltr.interleaving.Interleaving;
import org.apache.solr.ltr.interleaving.LTRInterleavingQuery;
+import org.apache.solr.ltr.interleaving.LTRInterleavingScoringQuery;
+import org.apache.solr.ltr.interleaving.OriginalRankingLTRScoringQuery;
import org.apache.solr.ltr.model.LTRScoringModel;
import org.apache.solr.ltr.store.rest.ManagedFeatureStore;
import org.apache.solr.ltr.store.rest.ManagedModelStore;
@@ -49,11 +48,11 @@ import org.apache.solr.util.SolrPluginUtils;
/**
* Plug into solr a rerank model.
*
- * Learning to Rank Query Parser Syntax: rq={!ltr model=6029760550880411648 reRankDocs=300
+ * <p>Learning to Rank Query Parser Syntax: rq={!ltr model=6029760550880411648 reRankDocs=300
* efi.myCompanyQueryIntent=0.98}
- *
*/
-public class LTRQParserPlugin extends QParserPlugin implements ResourceLoaderAware, ManagedResourceObserver {
+public class LTRQParserPlugin extends QParserPlugin
+ implements ResourceLoaderAware, ManagedResourceObserver {
public static final String NAME = "ltr";
private static final String ORIGINAL_RANKING = "_OriginalRanking_";
@@ -66,25 +65,21 @@ public class LTRQParserPlugin extends QParserPlugin implements ResourceLoaderAwa
private LTRThreadModule threadManager = null;
- /** query parser plugin: the name of the attribute for setting the model **/
+ /** query parser plugin: the name of the attribute for setting the model */
public static final String MODEL = "model";
- /** query parser plugin: default number of documents to rerank **/
+ /** query parser plugin: default number of documents to rerank */
public static final int DEFAULT_RERANK_DOCS = 200;
- /**
- * query parser plugin:the param that will select how the number of document
- * to rerank
- **/
+ /** query parser plugin:the param that will select how the number of document to rerank */
public static final String RERANK_DOCS = "reRankDocs";
- /** query parser plugin: default interleaving algorithm **/
+ /** query parser plugin: default interleaving algorithm */
public static final String DEFAULT_INTERLEAVING_ALGORITHM = Interleaving.TEAM_DRAFT;
- /** query parser plugin:the param that selects the interleaving algorithm to use **/
+ /** query parser plugin:the param that selects the interleaving algorithm to use */
public static final String INTERLEAVING_ALGORITHM = "interleavingAlgorithm";
-
@Override
public void init(NamedList<?> args) {
super.init(args);
@@ -93,32 +88,30 @@ public class LTRQParserPlugin extends QParserPlugin implements ResourceLoaderAwa
}
@Override
- public QParser createParser(String qstr, SolrParams localParams,
- SolrParams params, SolrQueryRequest req) {
+ public QParser createParser(
+ String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) {
return new LTRQParser(qstr, localParams, params, req);
}
/**
* Given a set of local SolrParams, extract all of the efi.key=value params into a map
+ *
* @param localParams Local request parameters that might conatin efi params
- * @return Map of efi params, where the key is the name of the efi param, and the
- * value is the value of the efi param
+ * @return Map of efi params, where the key is the name of the efi param, and the value is the
+ * value of the efi param
*/
- public static Map<String,String[]> extractEFIParams(SolrParams localParams) {
- final Map<String,String[]> externalFeatureInfo = new HashMap<>();
- for (final Iterator<String> it = localParams.getParameterNamesIterator(); it
- .hasNext();) {
+ public static Map<String, String[]> extractEFIParams(SolrParams localParams) {
+ final Map<String, String[]> externalFeatureInfo = new HashMap<>();
+ for (final Iterator<String> it = localParams.getParameterNamesIterator(); it.hasNext(); ) {
final String name = it.next();
if (name.startsWith(EXTERNAL_FEATURE_INFO)) {
externalFeatureInfo.put(
- name.substring(EXTERNAL_FEATURE_INFO.length()),
- new String[] {localParams.get(name)});
+ name.substring(EXTERNAL_FEATURE_INFO.length()), new String[] {localParams.get(name)});
}
}
return externalFeatureInfo;
}
-
@Override
public void inform(ResourceLoader loader) throws IOException {
final SolrResourceLoader solrResourceLoader = (SolrResourceLoader) loader;
@@ -127,79 +120,96 @@ public class LTRQParserPlugin extends QParserPlugin implements ResourceLoaderAwa
}
@Override
- public void onManagedResourceInitialized(NamedList<?> args, ManagedResource res) throws SolrException {
+ public void onManagedResourceInitialized(NamedList<?> args, ManagedResource res)
+ throws SolrException {
if (res instanceof ManagedFeatureStore) {
- fr = (ManagedFeatureStore)res;
+ fr = (ManagedFeatureStore) res;
}
- if (res instanceof ManagedModelStore){
- mr = (ManagedModelStore)res;
+ if (res instanceof ManagedModelStore) {
+ mr = (ManagedModelStore) res;
}
- if (mr != null && fr != null){
+ if (mr != null && fr != null) {
mr.setManagedFeatureStore(fr);
// now we can safely load the models
mr.loadStoredModels();
-
}
}
public class LTRQParser extends QParser {
- public LTRQParser(String qstr, SolrParams localParams, SolrParams params,
- SolrQueryRequest req) {
+ public LTRQParser(
+ String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) {
super(qstr, localParams, params, req);
}
@Override
public Query parse() throws SyntaxError {
if (threadManager != null) {
- threadManager.setExecutor(req.getCore().getCoreContainer().getUpdateShardHandler().getUpdateExecutor());
+ threadManager.setExecutor(
+ req.getCore().getCoreContainer().getUpdateShardHandler().getUpdateExecutor());
}
// ReRanking Model
final String[] modelNames = localParams.getParams(LTRQParserPlugin.MODEL);
- if ((modelNames == null) || (modelNames.length!=1 && modelNames.length!=2)) {
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
- "Must provide one or two models in the request");
+ if ((modelNames == null) || (modelNames.length != 1 && modelNames.length != 2)) {
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST, "Must provide one or two models in the request");
}
final boolean isInterleaving = (modelNames.length > 1);
final boolean extractFeatures = SolrQueryRequestContextUtils.isExtractingFeatures(req);
final String tranformerFeatureStoreName = SolrQueryRequestContextUtils.getFvStoreName(req);
- final Map<String,String[]> externalFeatureInfo = extractEFIParams(localParams);
+ final Map<String, String[]> externalFeatureInfo = extractEFIParams(localParams);
LTRScoringQuery rerankingQuery = null;
- LTRInterleavingScoringQuery[] rerankingQueries = new LTRInterleavingScoringQuery[modelNames.length];
+ LTRInterleavingScoringQuery[] rerankingQueries =
+ new LTRInterleavingScoringQuery[modelNames.length];
for (int i = 0; i < modelNames.length; i++) {
if (modelNames[i].isEmpty()) {
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
- "the " + LTRQParserPlugin.MODEL + " "+ i +" is empty");
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST,
+ "the " + LTRQParserPlugin.MODEL + " " + i + " is empty");
}
if (!ORIGINAL_RANKING.equals(modelNames[i])) {
final LTRScoringModel ltrScoringModel = mr.getModel(modelNames[i]);
if (ltrScoringModel == null) {
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST,
"cannot find " + LTRQParserPlugin.MODEL + " " + modelNames[i]);
}
final String modelFeatureStoreName = ltrScoringModel.getFeatureStoreName();
- // Check if features are requested and if the model feature store and feature-transform feature store are the same
- final boolean featuresRequestedFromSameStore = (modelFeatureStoreName.equals(tranformerFeatureStoreName) || tranformerFeatureStoreName == null) ? extractFeatures : false;
-
+ // Check if features are requested and if the model feature store and feature-transform
+ // feature store are the same
+ final boolean featuresRequestedFromSameStore =
+ (modelFeatureStoreName.equals(tranformerFeatureStoreName)
+ || tranformerFeatureStoreName == null)
+ ? extractFeatures
+ : false;
+
if (isInterleaving) {
- rerankingQuery = rerankingQueries[i] = new LTRInterleavingScoringQuery(ltrScoringModel,
- externalFeatureInfo,
- featuresRequestedFromSameStore, threadManager);
+ rerankingQuery =
+ rerankingQueries[i] =
+ new LTRInterleavingScoringQuery(
+ ltrScoringModel,
+ externalFeatureInfo,
+ featuresRequestedFromSameStore,
+ threadManager);
} else {
- rerankingQuery = new LTRScoringQuery(ltrScoringModel,
- externalFeatureInfo,
- featuresRequestedFromSameStore, threadManager);
+ rerankingQuery =
+ new LTRScoringQuery(
+ ltrScoringModel,
+ externalFeatureInfo,
+ featuresRequestedFromSameStore,
+ threadManager);
rerankingQueries[i] = null;
}
// Enable the feature vector caching if we are extracting features, and the features
// we requested are the same ones we are reranking with
if (featuresRequestedFromSameStore) {
- rerankingQuery.setFeatureLogger( SolrQueryRequestContextUtils.getFeatureLogger(req) );
+ rerankingQuery.setFeatureLogger(SolrQueryRequestContextUtils.getFeatureLogger(req));
}
- }else{
- rerankingQuery = rerankingQueries[i] = new OriginalRankingLTRScoringQuery(ORIGINAL_RANKING);
+ } else {
+ rerankingQuery =
+ rerankingQueries[i] = new OriginalRankingLTRScoringQuery(ORIGINAL_RANKING);
}
// External features
@@ -208,18 +218,19 @@ public class LTRQParserPlugin extends QParserPlugin implements ResourceLoaderAwa
int reRankDocs = localParams.getInt(RERANK_DOCS, DEFAULT_RERANK_DOCS);
if (reRankDocs <= 0) {
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
- "Must rerank at least 1 document");
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST, "Must rerank at least 1 document");
}
if (!isInterleaving) {
- SolrQueryRequestContextUtils.setScoringQueries(req, new LTRScoringQuery[] { rerankingQuery });
+ SolrQueryRequestContextUtils.setScoringQueries(req, new LTRScoringQuery[] {rerankingQuery});
return new LTRQuery(rerankingQuery, reRankDocs);
} else {
- String interleavingAlgorithm = localParams.get(INTERLEAVING_ALGORITHM, DEFAULT_INTERLEAVING_ALGORITHM);
+ String interleavingAlgorithm =
+ localParams.get(INTERLEAVING_ALGORITHM, DEFAULT_INTERLEAVING_ALGORITHM);
SolrQueryRequestContextUtils.setScoringQueries(req, rerankingQueries);
- return new LTRInterleavingQuery(Interleaving.getImplementation(interleavingAlgorithm), rerankingQueries, reRankDocs);
+ return new LTRInterleavingQuery(
+ Interleaving.getImplementation(interleavingAlgorithm), rerankingQueries, reRankDocs);
}
}
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQuery.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQuery.java
index e86fb7e..1e8edd4 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQuery.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/search/LTRQuery.java
@@ -18,7 +18,6 @@
package org.apache.solr.ltr.search;
import java.io.IOException;
-
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.Query;
import org.apache.solr.ltr.LTRRescorer;
@@ -27,9 +26,9 @@ import org.apache.solr.search.AbstractReRankQuery;
import org.apache.solr.search.RankQuery;
/**
- * A learning to rank Query, will incapsulate a learning to rank model, and delegate to it the rescoring
- * of the documents.
- **/
+ * A learning to rank Query, will incapsulate a learning to rank model, and delegate to it the
+ * rescoring of the documents.
+ */
public class LTRQuery extends AbstractReRankQuery {
private static final Query defaultQuery = new MatchAllDocsQuery();
private final LTRScoringQuery scoringQuery;
@@ -55,7 +54,8 @@ public class LTRQuery extends AbstractReRankQuery {
private boolean equalsTo(LTRQuery other) {
return (mainQuery.equals(other.mainQuery)
- && scoringQuery.equals(other.scoringQuery) && (reRankDocs == other.reRankDocs));
+ && scoringQuery.equals(other.scoringQuery)
+ && (reRankDocs == other.reRankDocs));
}
@Override
@@ -69,8 +69,13 @@ public class LTRQuery extends AbstractReRankQuery {
@Override
public String toString(String field) {
- return "{!ltr mainQuery='" + mainQuery.toString() + "' scoringQuery='"
- + scoringQuery.toString() + "' reRankDocs=" + reRankDocs + "}";
+ return "{!ltr mainQuery='"
+ + mainQuery.toString()
+ + "' scoringQuery='"
+ + scoringQuery.toString()
+ + "' reRankDocs="
+ + reRankDocs
+ + "}";
}
@Override
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/search/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/search/package-info.java
index 95b645b..5461e25 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/search/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/search/package-info.java
@@ -16,8 +16,7 @@
*/
/**
- * APIs and classes for {@linkplain org.apache.solr.search.QParserPlugin parsing} and {@linkplain org.apache.solr.search.SolrIndexSearcher processing} search requests
+ * APIs and classes for {@linkplain org.apache.solr.search.QParserPlugin parsing} and {@linkplain
+ * org.apache.solr.search.SolrIndexSearcher processing} search requests
*/
package org.apache.solr.ltr.search;
-
-
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/FeatureStore.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/FeatureStore.java
index ab2595f..f554d63 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/FeatureStore.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/FeatureStore.java
@@ -20,16 +20,16 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
-
import org.apache.solr.ltr.feature.Feature;
import org.apache.solr.ltr.feature.FeatureException;
public class FeatureStore {
- /** the name of the default feature store **/
+ /** the name of the default feature store */
public static final String DEFAULT_FEATURE_STORE_NAME = "_DEFAULT_";
- private final LinkedHashMap<String,Feature> store = new LinkedHashMap<>(); // LinkedHashMap because we need predictable iteration order
+ // LinkedHashMap because we need predictable iteration order
+ private final LinkedHashMap<String, Feature> store = new LinkedHashMap<>();
private final String name;
public FeatureStore(String name) {
@@ -47,8 +47,8 @@ public class FeatureStore {
public void add(Feature feature) {
final String name = feature.getName();
if (store.containsKey(name)) {
- throw new FeatureException(name
- + " already contained in the store, please use a different name");
+ throw new FeatureException(
+ name + " already contained in the store, please use a different name");
}
feature.setIndex(store.size());
store.put(name, feature);
@@ -63,5 +63,4 @@ public class FeatureStore {
public String toString() {
return "FeatureStore [features=" + store.keySet() + "]";
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/ModelStore.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/ModelStore.java
index dbb065f..619d778 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/ModelStore.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/ModelStore.java
@@ -21,16 +21,13 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import org.apache.solr.ltr.model.LTRScoringModel;
import org.apache.solr.ltr.model.ModelException;
-/**
- * Contains the model and features declared.
- */
+/** Contains the model and features declared. */
public class ModelStore {
- private final Map<String,LTRScoringModel> availableModels;
+ private final Map<String, LTRScoringModel> availableModels;
public ModelStore() {
availableModels = new HashMap<>();
@@ -59,16 +56,13 @@ public class ModelStore {
return availableModels.remove(modelName);
}
- public synchronized void addModel(LTRScoringModel modeldata)
- throws ModelException {
+ public synchronized void addModel(LTRScoringModel modeldata) throws ModelException {
final String name = modeldata.getName();
if (availableModels.containsKey(name)) {
- throw new ModelException("model '" + name
- + "' already exists. Please use a different name");
+ throw new ModelException("model '" + name + "' already exists. Please use a different name");
}
availableModels.put(modeldata.getName(), modeldata);
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/package-info.java
index 1ed9bff..bbefbbc 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/package-info.java
@@ -15,7 +15,5 @@
* limitations under the License.
*/
-/**
- * Contains feature and model store related classes.
- */
+/** Contains feature and model store related classes. */
package org.apache.solr.ltr.store;
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedFeatureStore.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedFeatureStore.java
index 9ef36b8..6242f93 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedFeatureStore.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedFeatureStore.java
@@ -22,7 +22,6 @@ import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-
import org.apache.solr.common.SolrException;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.core.SolrCore;
@@ -37,56 +36,50 @@ import org.apache.solr.rest.ManagedResourceStorage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-/**
- * Managed resource for a storing a feature.
- */
-public class ManagedFeatureStore extends ManagedResource implements ManagedResource.ChildResourceSupport {
-
- public static void registerManagedFeatureStore(SolrResourceLoader solrResourceLoader,
- ManagedResourceObserver managedResourceObserver) {
- solrResourceLoader.getManagedResourceRegistry().registerManagedResource(
- REST_END_POINT,
- ManagedFeatureStore.class,
- managedResourceObserver);
+/** Managed resource for a storing a feature. */
+public class ManagedFeatureStore extends ManagedResource
+ implements ManagedResource.ChildResourceSupport {
+
+ public static void registerManagedFeatureStore(
+ SolrResourceLoader solrResourceLoader, ManagedResourceObserver managedResourceObserver) {
+ solrResourceLoader
+ .getManagedResourceRegistry()
+ .registerManagedResource(
+ REST_END_POINT, ManagedFeatureStore.class, managedResourceObserver);
}
public static ManagedFeatureStore getManagedFeatureStore(SolrCore core) {
- return (ManagedFeatureStore) core.getRestManager()
- .getManagedResource(REST_END_POINT);
+ return (ManagedFeatureStore) core.getRestManager().getManagedResource(REST_END_POINT);
}
- /** the feature store rest endpoint **/
+ /** the feature store rest endpoint */
public static final String REST_END_POINT = "/schema/feature-store";
- /** name of the attribute containing the feature class **/
+ /** name of the attribute containing the feature class */
static final String CLASS_KEY = "class";
- /** name of the attribute containing the feature name **/
+ /** name of the attribute containing the feature name */
static final String NAME_KEY = "name";
- /** name of the attribute containing the feature params **/
+ /** name of the attribute containing the feature params */
static final String PARAMS_KEY = "params";
- /** name of the attribute containing the feature store used **/
+ /** name of the attribute containing the feature store used */
static final String FEATURE_STORE_NAME_KEY = "store";
- private final Map<String,FeatureStore> stores = new HashMap<>();
+ private final Map<String, FeatureStore> stores = new HashMap<>();
- /**
- * Managed feature store: the name of the attribute containing all the feature
- * stores
- **/
+ /** Managed feature store: the name of the attribute containing all the feature stores */
private static final String FEATURE_STORE_JSON_FIELD = "featureStores";
/**
- * Managed feature store: the name of the attribute containing all the
- * features of a feature store
- **/
+ * Managed feature store: the name of the attribute containing all the features of a feature store
+ */
private static final String FEATURES_JSON_FIELD = "features";
private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
- public ManagedFeatureStore(String resourceId, SolrResourceLoader loader,
- ManagedResourceStorage.StorageIO storageIO) throws SolrException {
+ public ManagedFeatureStore(
+ String resourceId, SolrResourceLoader loader, ManagedResourceStorage.StorageIO storageIO)
+ throws SolrException {
super(resourceId, loader, storageIO);
-
}
public synchronized FeatureStore getFeatureStore(String name) {
@@ -100,22 +93,22 @@ public class ManagedFeatureStore extends ManagedResource implements ManagedResou
}
@Override
- protected void onManagedDataLoadedFromStorage(NamedList<?> managedInitArgs,
- Object managedData) throws SolrException {
+ protected void onManagedDataLoadedFromStorage(NamedList<?> managedInitArgs, Object managedData)
+ throws SolrException {
stores.clear();
log.info("------ managed feature ~ loading ------");
if (managedData instanceof List) {
@SuppressWarnings("unchecked")
- final List<Map<String,Object>> up = (List<Map<String,Object>>) managedData;
- for (final Map<String,Object> u : up) {
+ final List<Map<String, Object>> up = (List<Map<String, Object>>) managedData;
+ for (final Map<String, Object> u : up) {
final String featureStore = (String) u.get(FEATURE_STORE_NAME_KEY);
addFeature(u, featureStore);
}
}
}
- public synchronized void addFeature(Map<String,Object> map, String featureStore) {
+ public synchronized void addFeature(Map<String, Object> map, String featureStore) {
log.info("register feature based on {}", map);
final FeatureStore fstore = getFeatureStore(featureStore);
final Feature feature = fromFeatureMap(solrResourceLoader, map);
@@ -126,8 +119,8 @@ public class ManagedFeatureStore extends ManagedResource implements ManagedResou
@Override
public Object applyUpdatesToManagedData(Object updates) {
if (updates instanceof List) {
- final List<Map<String,Object>> up = (List<Map<String,Object>>) updates;
- for (final Map<String,Object> u : up) {
+ final List<Map<String, Object>> up = (List<Map<String, Object>>) updates;
+ for (final Map<String, Object> u : up) {
final String featureStore = (String) u.get(FEATURE_STORE_NAME_KEY);
addFeature(u, featureStore);
}
@@ -135,7 +128,7 @@ public class ManagedFeatureStore extends ManagedResource implements ManagedResou
if (updates instanceof Map) {
// a unique feature
- Map<String,Object> updatesMap = (Map<String,Object>) updates;
+ Map<String, Object> updatesMap = (Map<String, Object>) updates;
final String featureStore = (String) updatesMap.get(FEATURE_STORE_NAME_KEY);
addFeature(updatesMap, featureStore);
}
@@ -156,9 +149,8 @@ public class ManagedFeatureStore extends ManagedResource implements ManagedResou
}
/**
- * Called to retrieve a named part (the given childId) of the resource at the
- * given endpoint. Note: since we have a unique child feature store we ignore
- * the childId.
+ * Called to retrieve a named part (the given childId) of the resource at the given endpoint.
+ * Note: since we have a unique child feature store we ignore the childId.
*/
@Override
public void doGet(BaseSolrResource endpoint, String childId) {
@@ -170,11 +162,10 @@ public class ManagedFeatureStore extends ManagedResource implements ManagedResou
} else {
final FeatureStore store = getFeatureStore(childId);
if (store == null) {
- throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
- "missing feature store [" + childId + "]");
+ throw new SolrException(
+ SolrException.ErrorCode.BAD_REQUEST, "missing feature store [" + childId + "]");
}
- response.add(FEATURES_JSON_FIELD,
- featuresAsManagedResources(store));
+ response.add(FEATURES_JSON_FIELD, featuresAsManagedResources(store));
}
}
@@ -182,29 +173,30 @@ public class ManagedFeatureStore extends ManagedResource implements ManagedResou
final List<Feature> storedFeatures = store.getFeatures();
final List<Object> features = new ArrayList<Object>(storedFeatures.size());
for (final Feature f : storedFeatures) {
- final LinkedHashMap<String,Object> m = toFeatureMap(f);
+ final LinkedHashMap<String, Object> m = toFeatureMap(f);
m.put(FEATURE_STORE_NAME_KEY, store.getName());
features.add(m);
}
return features;
}
- private static LinkedHashMap<String,Object> toFeatureMap(Feature feat) {
- final LinkedHashMap<String,Object> o = new LinkedHashMap<>(4, 1.0f); // 1 extra for caller to add store
+ private static LinkedHashMap<String, Object> toFeatureMap(Feature feat) {
+ final LinkedHashMap<String, Object> o = new LinkedHashMap<>(4, 1.0f);
+ // 4 = 3 + 1 i.e. 1 extra for caller to add store
o.put(NAME_KEY, feat.getName());
o.put(CLASS_KEY, feat.getClass().getName());
o.put(PARAMS_KEY, feat.paramsToMap());
return o;
}
- private static Feature fromFeatureMap(SolrResourceLoader solrResourceLoader,
- Map<String,Object> featureMap) {
+ private static Feature fromFeatureMap(
+ SolrResourceLoader solrResourceLoader, Map<String, Object> featureMap) {
final String className = (String) featureMap.get(CLASS_KEY);
final String name = (String) featureMap.get(NAME_KEY);
@SuppressWarnings("unchecked")
- final Map<String,Object> params = (Map<String,Object>) featureMap.get(PARAMS_KEY);
+ final Map<String, Object> params = (Map<String, Object>) featureMap.get(PARAMS_KEY);
return Feature.getInstance(solrResourceLoader, className, name, params);
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedModelStore.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedModelStore.java
index b4f3c42..a0f0b98 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedModelStore.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/ManagedModelStore.java
@@ -21,16 +21,15 @@ import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-
import org.apache.solr.common.SolrException;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.core.SolrCore;
import org.apache.solr.core.SolrResourceLoader;
import org.apache.solr.ltr.feature.Feature;
import org.apache.solr.ltr.model.AdapterModel;
-import org.apache.solr.ltr.model.WrapperModel;
import org.apache.solr.ltr.model.LTRScoringModel;
import org.apache.solr.ltr.model.ModelException;
+import org.apache.solr.ltr.model.WrapperModel;
import org.apache.solr.ltr.norm.IdentityNormalizer;
import org.apache.solr.ltr.norm.Normalizer;
import org.apache.solr.ltr.store.FeatureStore;
@@ -43,44 +42,38 @@ import org.apache.solr.rest.ManagedResourceStorage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-/**
- * Menaged resource for storing a model
- */
-public class ManagedModelStore extends ManagedResource implements ManagedResource.ChildResourceSupport {
-
- public static void registerManagedModelStore(SolrResourceLoader solrResourceLoader,
- ManagedResourceObserver managedResourceObserver) {
- solrResourceLoader.getManagedResourceRegistry().registerManagedResource(
- REST_END_POINT,
- ManagedModelStore.class,
- managedResourceObserver);
+/** Menaged resource for storing a model */
+public class ManagedModelStore extends ManagedResource
+ implements ManagedResource.ChildResourceSupport {
+
+ public static void registerManagedModelStore(
+ SolrResourceLoader solrResourceLoader, ManagedResourceObserver managedResourceObserver) {
+ solrResourceLoader
+ .getManagedResourceRegistry()
+ .registerManagedResource(REST_END_POINT, ManagedModelStore.class, managedResourceObserver);
}
public static ManagedModelStore getManagedModelStore(SolrCore core) {
- return (ManagedModelStore) core.getRestManager()
- .getManagedResource(REST_END_POINT);
+ return (ManagedModelStore) core.getRestManager().getManagedResource(REST_END_POINT);
}
- /** the model store rest endpoint **/
+ /** the model store rest endpoint */
public static final String REST_END_POINT = "/schema/model-store";
- /**
- * Managed model store: the name of the attribute containing all the models of
- * a model store
- **/
+ /** Managed model store: the name of the attribute containing all the models of a model store */
private static final String MODELS_JSON_FIELD = "models";
- /** name of the attribute containing a class **/
+ /** name of the attribute containing a class */
static final String CLASS_KEY = "class";
- /** name of the attribute containing the features **/
+ /** name of the attribute containing the features */
static final String FEATURES_KEY = "features";
- /** name of the attribute containing a name **/
+ /** name of the attribute containing a name */
static final String NAME_KEY = "name";
- /** name of the attribute containing a normalizer **/
+ /** name of the attribute containing a normalizer */
static final String NORM_KEY = "norm";
- /** name of the attribute containing parameters **/
+ /** name of the attribute containing parameters */
static final String PARAMS_KEY = "params";
- /** name of the attribute containing a store **/
+ /** name of the attribute containing a store */
static final String STORE_KEY = "store";
private final ModelStore store;
@@ -88,8 +81,9 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
- public ManagedModelStore(String resourceId, SolrResourceLoader loader,
- ManagedResourceStorage.StorageIO storageIO) throws SolrException {
+ public ManagedModelStore(
+ String resourceId, SolrResourceLoader loader, ManagedResourceStorage.StorageIO storageIO)
+ throws SolrException {
super(resourceId, loader, storageIO);
store = new ModelStore();
}
@@ -106,8 +100,8 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
private Object managedData;
@Override
- protected void onManagedDataLoadedFromStorage(NamedList<?> managedInitArgs,
- Object managedData) throws SolrException {
+ protected void onManagedDataLoadedFromStorage(NamedList<?> managedInitArgs, Object managedData)
+ throws SolrException {
store.clear();
// the managed models on the disk or on zookeeper will be loaded in a lazy
// way, since we need to set the managed features first (unfortunately
@@ -115,7 +109,6 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
// decouple the creation of a managed resource with the reading of the data
// from the storage)
this.managedData = managedData;
-
}
public void loadStoredModels() {
@@ -123,16 +116,17 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
if ((managedData != null) && (managedData instanceof List)) {
@SuppressWarnings({"unchecked"})
- final List<Map<String,Object>> up = (List<Map<String,Object>>) managedData;
- for (final Map<String,Object> u : up) {
+ final List<Map<String, Object>> up = (List<Map<String, Object>>) managedData;
+ for (final Map<String, Object> u : up) {
addModelFromMap(u);
}
}
}
- private void addModelFromMap(Map<String,Object> modelMap) {
+ private void addModelFromMap(Map<String, Object> modelMap) {
try {
- final LTRScoringModel algo = fromLTRScoringModelMap(solrResourceLoader, modelMap, managedFeatureStore);
+ final LTRScoringModel algo =
+ fromLTRScoringModelMap(solrResourceLoader, modelMap, managedFeatureStore);
addModel(algo);
} catch (final ModelException e) {
throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e);
@@ -155,14 +149,14 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
protected Object applyUpdatesToManagedData(Object updates) {
if (updates instanceof List) {
- final List<Map<String,Object>> up = (List<Map<String,Object>>) updates;
- for (final Map<String,Object> u : up) {
+ final List<Map<String, Object>> up = (List<Map<String, Object>>) updates;
+ for (final Map<String, Object> u : up) {
addModelFromMap(u);
}
}
if (updates instanceof Map) {
- final Map<String,Object> map = (Map<String,Object>) updates;
+ final Map<String, Object> map = (Map<String, Object>) updates;
addModelFromMap(map);
}
@@ -176,16 +170,14 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
}
/**
- * Called to retrieve a named part (the given childId) of the resource at the
- * given endpoint. Note: since we have a unique child managed store we ignore
- * the childId.
+ * Called to retrieve a named part (the given childId) of the resource at the given endpoint.
+ * Note: since we have a unique child managed store we ignore the childId.
*/
@Override
public void doGet(BaseSolrResource endpoint, String childId) {
final SolrQueryResponse response = endpoint.getSolrResponse();
- response.add(MODELS_JSON_FIELD,
- modelsAsManagedResources(store.getModels()));
+ response.add(MODELS_JSON_FIELD, modelsAsManagedResources(store.getModels()));
}
public LTRScoringModel getModel(String modelName) {
@@ -196,15 +188,13 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
@Override
public String toString() {
- return "ManagedModelStore [store=" + store + ", featureStores="
- + managedFeatureStore + "]";
+ return "ManagedModelStore [store=" + store + ", featureStores=" + managedFeatureStore + "]";
}
/**
- * Returns the available models as a list of Maps objects. After an update the
- * managed resources needs to return the resources in this format in order to
- * store in json somewhere (zookeeper, disk...)
- *
+ * Returns the available models as a list of Maps objects. After an update the managed resources
+ * needs to return the resources in this format in order to store in json somewhere (zookeeper,
+ * disk...)
*
* @return the available models as a list of Maps objects
*/
@@ -217,8 +207,10 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
}
@SuppressWarnings("unchecked")
- public static LTRScoringModel fromLTRScoringModelMap(SolrResourceLoader solrResourceLoader,
- Map<String,Object> modelMap, ManagedFeatureStore managedFeatureStore) {
+ public static LTRScoringModel fromLTRScoringModelMap(
+ SolrResourceLoader solrResourceLoader,
+ Map<String, Object> modelMap,
+ ManagedFeatureStore managedFeatureStore) {
final FeatureStore featureStore =
managedFeatureStore.getFeatureStore((String) modelMap.get(STORE_KEY));
@@ -229,56 +221,61 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
final List<Object> featureList = (List<Object>) modelMap.get(FEATURES_KEY);
if (featureList != null) {
for (final Object feature : featureList) {
- final Map<String,Object> featureMap = (Map<String,Object>) feature;
+ final Map<String, Object> featureMap = (Map<String, Object>) feature;
features.add(lookupFeatureFromFeatureMap(featureMap, featureStore));
norms.add(createNormalizerFromFeatureMap(solrResourceLoader, featureMap));
}
}
- final LTRScoringModel ltrScoringModel = LTRScoringModel.getInstance(solrResourceLoader,
- (String) modelMap.get(CLASS_KEY), // modelClassName
- (String) modelMap.get(NAME_KEY), // modelName
- features,
- norms,
- featureStore.getName(),
- featureStore.getFeatures(),
- (Map<String,Object>) modelMap.get(PARAMS_KEY));
+ final LTRScoringModel ltrScoringModel =
+ LTRScoringModel.getInstance(
+ solrResourceLoader,
+ (String) modelMap.get(CLASS_KEY), // modelClassName
+ (String) modelMap.get(NAME_KEY), // modelName
+ features,
+ norms,
+ featureStore.getName(),
+ featureStore.getFeatures(),
+ (Map<String, Object>) modelMap.get(PARAMS_KEY));
if (ltrScoringModel instanceof AdapterModel) {
- initAdapterModel(solrResourceLoader, (AdapterModel)ltrScoringModel, managedFeatureStore);
+ initAdapterModel(solrResourceLoader, (AdapterModel) ltrScoringModel, managedFeatureStore);
}
return ltrScoringModel;
}
- private static void initAdapterModel(SolrResourceLoader solrResourceLoader,
- AdapterModel adapterModel, ManagedFeatureStore managedFeatureStore) {
+ private static void initAdapterModel(
+ SolrResourceLoader solrResourceLoader,
+ AdapterModel adapterModel,
+ ManagedFeatureStore managedFeatureStore) {
adapterModel.init(solrResourceLoader);
if (adapterModel instanceof WrapperModel) {
- initWrapperModel(solrResourceLoader, (WrapperModel)adapterModel, managedFeatureStore);
+ initWrapperModel(solrResourceLoader, (WrapperModel) adapterModel, managedFeatureStore);
}
}
- private static void initWrapperModel(SolrResourceLoader solrResourceLoader,
- WrapperModel wrapperModel, ManagedFeatureStore managedFeatureStore) {
- final LTRScoringModel model = fromLTRScoringModelMap(
- solrResourceLoader,
- wrapperModel.fetchModelMap(),
- managedFeatureStore);
+ private static void initWrapperModel(
+ SolrResourceLoader solrResourceLoader,
+ WrapperModel wrapperModel,
+ ManagedFeatureStore managedFeatureStore) {
+ final LTRScoringModel model =
+ fromLTRScoringModelMap(
+ solrResourceLoader, wrapperModel.fetchModelMap(), managedFeatureStore);
if (model instanceof AdapterModel) {
- initAdapterModel(solrResourceLoader, (AdapterModel)model, managedFeatureStore);
+ initAdapterModel(solrResourceLoader, (AdapterModel) model, managedFeatureStore);
}
wrapperModel.updateModel(model);
}
- private static LinkedHashMap<String,Object> toLTRScoringModelMap(LTRScoringModel model) {
- final LinkedHashMap<String,Object> modelMap = new LinkedHashMap<>(5, 1.0f);
+ private static LinkedHashMap<String, Object> toLTRScoringModelMap(LTRScoringModel model) {
+ final LinkedHashMap<String, Object> modelMap = new LinkedHashMap<>(5, 1.0f);
modelMap.put(NAME_KEY, model.getName());
modelMap.put(CLASS_KEY, model.getClass().getName());
modelMap.put(STORE_KEY, model.getFeatureStoreName());
- final List<Map<String,Object>> features = new ArrayList<>();
+ final List<Map<String, Object>> features = new ArrayList<>();
if (!(model instanceof WrapperModel)) {
final List<Feature> featuresList = model.getFeatures();
final List<Normalizer> normsList = model.getNorms();
@@ -293,56 +290,57 @@ public class ManagedModelStore extends ManagedResource implements ManagedResourc
return modelMap;
}
- private static Feature lookupFeatureFromFeatureMap(Map<String, Object> featureMap, FeatureStore featureStore)
- {
+ private static Feature lookupFeatureFromFeatureMap(
+ Map<String, Object> featureMap, FeatureStore featureStore) {
final String featureName = (String) featureMap.get(NAME_KEY);
Feature extractedFromStore = featureName == null ? null : featureStore.get(featureName);
if (extractedFromStore == null) {
if (featureStore.getFeatures().isEmpty()) {
throw new ModelException("Missing or empty feature store: " + featureStore.getName());
} else {
- throw new ModelException("Feature: " + featureName + " not found in store: " + featureStore.getName());
+ throw new ModelException(
+ "Feature: " + featureName + " not found in store: " + featureStore.getName());
}
}
return extractedFromStore;
}
@SuppressWarnings("unchecked")
- private static Normalizer createNormalizerFromFeatureMap(SolrResourceLoader solrResourceLoader,
- Map<String,Object> featureMap) {
- final Map<String,Object> normMap = (Map<String,Object>)featureMap.get(NORM_KEY);
- return (normMap == null ? IdentityNormalizer.INSTANCE
+ private static Normalizer createNormalizerFromFeatureMap(
+ SolrResourceLoader solrResourceLoader, Map<String, Object> featureMap) {
+ final Map<String, Object> normMap = (Map<String, Object>) featureMap.get(NORM_KEY);
+ return (normMap == null
+ ? IdentityNormalizer.INSTANCE
: fromNormalizerMap(solrResourceLoader, normMap));
}
- private static LinkedHashMap<String,Object> toFeatureMap(Feature feature, Normalizer norm) {
- final LinkedHashMap<String,Object> map = new LinkedHashMap<String,Object>(2, 1.0f);
- map.put(NAME_KEY, feature.getName());
+ private static LinkedHashMap<String, Object> toFeatureMap(Feature feature, Normalizer norm) {
+ final LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>(2, 1.0f);
+ map.put(NAME_KEY, feature.getName());
map.put(NORM_KEY, toNormalizerMap(norm));
return map;
}
- private static Normalizer fromNormalizerMap(SolrResourceLoader solrResourceLoader,
- Map<String,Object> normMap) {
+ private static Normalizer fromNormalizerMap(
+ SolrResourceLoader solrResourceLoader, Map<String, Object> normMap) {
final String className = (String) normMap.get(CLASS_KEY);
@SuppressWarnings("unchecked")
- final Map<String,Object> params = (Map<String,Object>) normMap.get(PARAMS_KEY);
+ final Map<String, Object> params = (Map<String, Object>) normMap.get(PARAMS_KEY);
return Normalizer.getInstance(solrResourceLoader, className, params);
}
- private static LinkedHashMap<String,Object> toNormalizerMap(Normalizer norm) {
- final LinkedHashMap<String,Object> normalizer = new LinkedHashMap<>(2, 1.0f);
+ private static LinkedHashMap<String, Object> toNormalizerMap(Normalizer norm) {
+ final LinkedHashMap<String, Object> normalizer = new LinkedHashMap<>(2, 1.0f);
normalizer.put(CLASS_KEY, norm.getClass().getName());
- final LinkedHashMap<String,Object> params = norm.paramsToMap();
+ final LinkedHashMap<String, Object> params = norm.paramsToMap();
if (params != null) {
normalizer.put(PARAMS_KEY, params);
}
return normalizer;
}
-
}
diff --git a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/package-info.java b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/package-info.java
index fbf7029..0ec9b5f 100644
--- a/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/package-info.java
+++ b/solr/modules/ltr/src/java/org/apache/solr/ltr/store/rest/package-info.java
@@ -16,7 +16,7 @@
*/
/**
- * Contains the {@link org.apache.solr.rest.ManagedResource} that encapsulate
- * the feature and the model stores.
+ * Contains the {@link org.apache.solr.rest.ManagedResource} that encapsulate the feature and the
+ * model stores.
*/
package org.apache.solr.ltr.store.rest;