← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/facet/src/test/org/apache/lucene/facet/search/sampling/BaseSampleTestTopK.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/facet/src/test/org/apache/lucene/facet/search/sampling/BaseSampleTestTopK.java
1
 
package org.apache.lucene.facet.search.sampling;
2
 
 
3
 
import java.io.IOException;
4
 
import java.util.List;
5
 
import java.util.Random;
6
 
 
7
 
import org.apache.lucene.index.IndexReader;
8
 
import org.apache.lucene.index.Term;
9
 
import org.apache.lucene.search.Query;
10
 
import org.apache.lucene.search.TermQuery;
11
 
 
12
 
import org.apache.lucene.search.MultiCollector;
13
 
import org.apache.lucene.facet.search.BaseTestTopK;
14
 
import org.apache.lucene.facet.search.FacetsAccumulator;
15
 
import org.apache.lucene.facet.search.FacetsCollector;
16
 
import org.apache.lucene.facet.search.ScoredDocIDs;
17
 
import org.apache.lucene.facet.search.ScoredDocIdCollector;
18
 
import org.apache.lucene.facet.search.params.FacetSearchParams;
19
 
import org.apache.lucene.facet.search.results.FacetResult;
20
 
import org.apache.lucene.facet.taxonomy.TaxonomyReader;
21
 
 
22
 
/**
23
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
24
 
 * contributor license agreements.  See the NOTICE file distributed with
25
 
 * this work for additional information regarding copyright ownership.
26
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
27
 
 * (the "License"); you may not use this file except in compliance with
28
 
 * the License.  You may obtain a copy of the License at
29
 
 *
30
 
 *     http://www.apache.org/licenses/LICENSE-2.0
31
 
 *
32
 
 * Unless required by applicable law or agreed to in writing, software
33
 
 * distributed under the License is distributed on an "AS IS" BASIS,
34
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
35
 
 * See the License for the specific language governing permissions and
36
 
 * limitations under the License.
37
 
 */
38
 
 
39
 
public abstract class BaseSampleTestTopK extends BaseTestTopK {
40
 
  
41
 
  /** Number of top results */
42
 
  protected static final int K = 2; 
43
 
  
44
 
  /** since there is a chance that this test would fail even if the code is correct, retry the sampling */
45
 
  protected static final int RETRIES = 10;
46
 
  
47
 
  protected abstract FacetsAccumulator getSamplingAccumulator(Sampler sampler,
48
 
      TaxonomyReader taxoReader, IndexReader indexReader,
49
 
      FacetSearchParams searchParams);
50
 
  
51
 
  /**
52
 
   * Try out faceted search with sampling enabled and complements either disabled or enforced
53
 
   * Lots of randomly generated data is being indexed, and later on a "90% docs" faceted search
54
 
   * is performed. The results are compared to non-sampled ones.
55
 
   */
56
 
  public void testCountUsingSamping() throws Exception, IOException {
57
 
    boolean useRandomSampler = random.nextBoolean();
58
 
    for (int partitionSize : partitionSizes) {
59
 
      try {
60
 
        initIndex(partitionSize);
61
 
        // Get all of the documents and run the query, then do different
62
 
        // facet counts and compare to control
63
 
        Query q = new TermQuery(new Term(CONTENT_FIELD, BETA)); // 90% of the docs
64
 
        ScoredDocIdCollector docCollector = ScoredDocIdCollector.create(searcher.maxDoc(), false);
65
 
        
66
 
        FacetSearchParams expectedSearchParams = searchParamsWithRequests(K, partitionSize); 
67
 
        FacetsCollector fc = new FacetsCollector(expectedSearchParams, indexReader, taxoReader);
68
 
        
69
 
        searcher.search(q, MultiCollector.wrap(docCollector, fc));
70
 
        
71
 
        List<FacetResult> expectedResults = fc.getFacetResults();
72
 
        
73
 
        FacetSearchParams samplingSearchParams = searchParamsWithRequests(K, partitionSize); 
74
 
        
75
 
        // try several times in case of failure, because the test has a chance to fail 
76
 
        // if the top K facets are not sufficiently common with the sample set
77
 
        for (int nTrial=0; nTrial<RETRIES; nTrial++) {
78
 
          try {
79
 
            // complement with sampling!
80
 
            final Sampler sampler = createSampler(nTrial, docCollector.getScoredDocIDs(), useRandomSampler);
81
 
            
82
 
            assertSampling(expectedResults, q, sampler, samplingSearchParams, false);
83
 
            assertSampling(expectedResults, q, sampler, samplingSearchParams, true);
84
 
            
85
 
            break; // succeeded
86
 
          } catch (NotSameResultError e) {
87
 
            if (nTrial>=RETRIES-1) {
88
 
              throw e; // no more retries allowed, must fail
89
 
            }
90
 
          }
91
 
        }
92
 
      } finally { 
93
 
        closeAll();
94
 
      }
95
 
    }
96
 
  }
97
 
  
98
 
  private void assertSampling(List<FacetResult> expected, Query q, Sampler sampler, FacetSearchParams params, boolean complement) throws Exception {
99
 
    FacetsCollector samplingFC = samplingCollector(complement, sampler, params);
100
 
    
101
 
    searcher.search(q, samplingFC);
102
 
    List<FacetResult> sampledResults = samplingFC.getFacetResults();
103
 
    
104
 
    assertSameResults(expected, sampledResults);
105
 
  }
106
 
  
107
 
  private FacetsCollector samplingCollector(
108
 
      final boolean complement,
109
 
      final Sampler sampler,
110
 
      FacetSearchParams samplingSearchParams) {
111
 
    FacetsCollector samplingFC = new FacetsCollector(samplingSearchParams, indexReader, taxoReader) {
112
 
      @Override
113
 
      protected FacetsAccumulator initFacetsAccumulator(
114
 
          FacetSearchParams facetSearchParams, IndexReader indexReader,
115
 
          TaxonomyReader taxonomyReader) {
116
 
        FacetsAccumulator acc = getSamplingAccumulator(sampler, taxonomyReader, indexReader, facetSearchParams);
117
 
        acc.setComplementThreshold(complement ? FacetsAccumulator.FORCE_COMPLEMENT : FacetsAccumulator.DISABLE_COMPLEMENT);
118
 
        return acc;
119
 
      }
120
 
    };
121
 
    return samplingFC;
122
 
  }
123
 
  
124
 
  private Sampler createSampler(int nTrial, ScoredDocIDs scoredDocIDs, boolean useRandomSampler) {
125
 
    SamplingParams samplingParams = new SamplingParams();
126
 
    
127
 
    final double retryFactor = Math.pow(1.01, nTrial);
128
 
    samplingParams.setSampleRatio(0.8 * retryFactor);
129
 
    samplingParams.setMinSampleSize((int) (100 * retryFactor));
130
 
    samplingParams.setMaxSampleSize((int) (10000 * retryFactor));
131
 
    samplingParams.setOversampleFactor(5.0 * retryFactor);
132
 
 
133
 
    samplingParams.setSampingThreshold(11000); //force sampling 
134
 
    Sampler sampler = useRandomSampler ? 
135
 
        new RandomSampler(samplingParams, new Random(random.nextLong())) :
136
 
          new RepeatableSampler(samplingParams);
137
 
    assertTrue("must enable sampling for this test!",sampler.shouldSample(scoredDocIDs));
138
 
    return sampler;
139
 
  }
140
 
}