Java Code Examples for com.esotericsoftware.minlog.Log#info()

@Override
protected final void buildModels() {
    if (profilesD1 == null) {
        Log.error("First list of entity profiles is null! "
                + "The first argument should always contain entities.");
        System.exit(-1);
    }

    if (entityModelsD1 == null) {
        Log.info("Applying " + getMethodName() + " with the following configuration : " + getMethodConfiguration());

        isCleanCleanER = false;
        entityModelsD1 = getModels(DATASET_1, profilesD1);
        if (profilesD2 != null) {
            isCleanCleanER = true;
            entityModelsD2 = getModels(DATASET_2, profilesD2);
        }
    }
}
 

protected void initializeData(SimilarityPairs simPairs) {
        Log.info("Applying " + getMethodName() + " with the following configuration : " + getMethodConfiguration());
        
//        simPairs.normalizeSimilarities();
        isCleanCleanER = simPairs.isCleanCleanER();
        
        int maxEntity1 = getMaxEntityId(simPairs.getEntityIds1());
        int maxEntity2 = getMaxEntityId(simPairs.getEntityIds2());
        if (simPairs.isCleanCleanER()) {
            datasetLimit = maxEntity1 + 1;
            noOfEntities = maxEntity1 + maxEntity2 + 2;
        } else {
            datasetLimit = 0;
            noOfEntities = Math.max(maxEntity1, maxEntity2) + 1;
        }

        similarityGraph = new UndirectedGraph(noOfEntities);
    }
 

@Override
protected void setThreshold() {
    noOfEdges = 0;
    threshold = 0;

    int limit = cleanCleanER ? datasetLimit : noOfEntities;
    if (weightingScheme.equals(WeightingScheme.ARCS)) {
        for (int i = 0; i < limit; i++) {
            processArcsEntity(i);
            updateThreshold(i);
        }
    } else {
        for (int i = 0; i < limit; i++) {
            processEntity(i);
            updateThreshold(i);
        }
    }

    threshold /= noOfEdges;

    Log.info("Edge Pruning Weight Threshold\t:\t" + threshold);
}
 

/**
 * Initializes an empty graph with {@code V} vertices and 0 edges. param V
 * the number of vertices
 *
 * @param V number of vertices
 * @throws IllegalArgumentException if {@code V < 0}
 */
public UndirectedGraph(int V) {
    if (V < 0) {
        throw new IllegalArgumentException("Number of vertices must be nonnegative");
    }
    this.V = V;
    this.E = 0;
    adj = new TIntSet[V];
    for (int v = 0; v < V; v++) {
        adj[v] = new TIntHashSet();
    }

    Log.info("Created graph with " + V + " nodes");
}
 

protected void initializeGraph() {
    weightedGraph = new SimpleWeightedGraph<>(DefaultWeightedEdge.class);

    String sinkLabel = "" + noOfEntities;
    weightedGraph.addVertex(sinkLabel); //add the artificial sink
    for (int i = 0; i < noOfEntities; i++) {
        String edgeLabel = i + "";
        weightedGraph.addVertex(edgeLabel);
        DefaultWeightedEdge e = (DefaultWeightedEdge) weightedGraph.addEdge(sinkLabel, edgeLabel); // add the capacity edges "a"
        weightedGraph.setEdgeWeight(e, Acap); //connecting the artificial sink with all vertices
    }

    Log.info("Added " + noOfEntities + " nodes in the graph");
}
 

public static void runWithConfig(ServerConfiguration config) throws Exception {
  URI baseUri = UriBuilder.fromUri("http://0.0.0.0/").port(config.port).build();
  // ResourceConfig rConfig = new
  // ResourceConfig(QueryResource.class).register;

  MultiCube cube = new MultiCubeImpl(new File(config.path).getAbsolutePath());
  cube.load(cube.getPath());
  CubeApplication rConfig = new CubeApplication(config, cube);
  registerStuff(rConfig);
  HttpServer server = GrizzlyHttpServerFactory.createHttpServer(baseUri, rConfig);
  Log.info("Starting server");
  server.start();
  Thread.currentThread().join();
  Log.info("Shutting down");
}
 

@Override
public Set<IdDuplicates> getDuplicatePairs(List<EntityProfile> profilesD1,
        List<EntityProfile> profilesD2) {
    if (!idDuplicates.isEmpty()) {
        return idDuplicates;
    }

    if (profilesD1 == null) {
        Log.error("First list of entity profiles is null! "
                + "The first argument should always contain entities.");
        return null;
    }

    initializeDataStructures(profilesD1, profilesD2);
    try {
        performReading();
    } catch (NoSuchElementException ex) {
        Log.error("Error in duplicates reading!", ex);
        return null;
    }
    Log.info("Total edges in duplicates graph\t:\t" + duplicatesGraph.edgeSet().size());

    // get connected components
    final ConnectivityInspector ci = new ConnectivityInspector(duplicatesGraph);
    final List<Set<Integer>> connectedComponents = ci.connectedSets();
    Log.info("Total connected components in duplicate graph\t:\t" + connectedComponents.size());

    // transform connected components into pairs of duplicates
    if (profilesD2 != null) { // Clean-Clean ER
        getBilateralConnectedComponents(connectedComponents);
    } else { // Dirty ER
        getUnilateralConnectedComponents(connectedComponents);
    }
    Log.info("Total pair of duplicats\t:\t" + idDuplicates.size());

    return idDuplicates;
}
 

protected void printOriginalStatistics(List<AbstractBlock> inputBlocks) {
    float comparisons = 0;
    comparisons = inputBlocks.stream().map((block) -> block.getNoOfComparisons()).reduce(comparisons, (accumulator, _item) -> accumulator + _item);
    
    Log.info("Original blocks\t:\t" + inputBlocks.size());
    Log.info("Original comparisons\t:\t" + comparisons);
}
 

@Override
public List<AbstractBlock> refineBlocks(List<AbstractBlock> blocks) {
    Log.info("Applying " + getMethodName() + " with the following configuration : " + getMethodConfiguration());
    
    entityIndex = new EntityIndex(blocks);
    
    cleanCleanER = entityIndex.isCleanCleanER();
    datasetLimit = entityIndex.getDatasetLimit();
    noOfBlocks = blocks.size();
    noOfEntities = entityIndex.getNoOfEntities();
    bBlocks = entityIndex.getBilateralBlocks();
    uBlocks = entityIndex.getUnilateralBlocks();

    return applyMainProcessing();
}
 

@Override
public List<AbstractBlock> refineBlocks(List<AbstractBlock> blocks) {
    Log.info("Applying " + getMethodName() + " with the following configuration : " + getMethodConfiguration());
    
    List<AbstractBlock> newBlocks = new ArrayList<>(blocks);
    printOriginalStatistics(newBlocks);
    setThreshold(newBlocks);

    int noOfPurgedBlocks = 0;
    float totalComparisons = 0;
    final Iterator<AbstractBlock> blocksIterator = newBlocks.iterator();
    while (blocksIterator.hasNext()) {
        AbstractBlock aBlock = blocksIterator.next();
        if (!satisfiesThreshold(aBlock)) {
            noOfPurgedBlocks++;
            blocksIterator.remove();
        } else {
            totalComparisons += aBlock.getNoOfComparisons();
        }
    }
    
    Log.info("Purged blocks\t:\t" + noOfPurgedBlocks);
    Log.info("Retained blocks\t:\t" + blocks.size());
    Log.info("Retained comparisons\t:\t" + totalComparisons);

    return newBlocks;
}
 

@Override
protected void setThreshold() {
    threshold = Math.max(1, blockAssingments / noOfEntities);
    Log.info(getMethodName() + " Threshold \t:\t" + threshold);
}
 

@Override
protected void setThreshold() {
    threshold = maxComparisons;

    Log.info(getMethodName() + " Threshold \t:\t" + threshold);
}
 

@Override
protected void setThreshold() {
    threshold = Math.max(1, 2 * comparisonsBudget / noOfEntities);
    Log.info(getMethodName() + " Threshold \t:\t" + threshold);
}
 

protected void initializeLshFunctions() {
    Log.info("Dimensionality\t:\t" + SuperBitUnigrams.getCorpusDimensionality());
    superbit = new SuperBit(SuperBitUnigrams.getCorpusDimensionality(), bandsNumber, bandSize);
}
 

@Override
protected void initializeLshFunctions() {
    Log.info("Dimensionality\t:\t" + MinHashUnigrams.getCorpusDimensionality());
    minhash = new MinHash(bandSize * bandsNumber, MinHashUnigrams.getCorpusDimensionality());
}
 

@Override
protected void setThreshold() {
    threshold = blockAssingments / 2;
    
    Log.info(getMethodName() + " Threshold \t:\t" + threshold);
}
 

@Override
public BestMove init(Object batchId, TridentCollector collector) {
    Log.info("Batch Id = [" + batchId + "]");
    return new BestMove();
}
 

@Override
public EquivalenceCluster[] getDuplicates(SimilarityPairs simPairs) {
    Log.info("Input comparisons\t:\t" + simPairs.getNoOfComparisons());
    
    matchedIds.clear();
    if (simPairs.getNoOfComparisons() == 0) {
        return new EquivalenceCluster[0];
    }

    initializeData(simPairs);
    if (!isCleanCleanER) {
        return null; //the method is only applicable to Clean-Clean ER
    }

    final Queue<SimilarityEdge> SEqueue = new PriorityQueue<>(simPairs.getNoOfComparisons(), new DecSimilarityEdgeComparator());

    final Iterator<Comparison> iterator = simPairs.getPairIterator();
    while (iterator.hasNext()) { // add a similarity edge to the queue, for every pair of entities with a weight higher than the threshold
        Comparison comparison = iterator.next();
        if (threshold < comparison.getUtilityMeasure()) {
            SEqueue.add(new SimilarityEdge(comparison.getEntityId1(), comparison.getEntityId2() + datasetLimit, comparison.getUtilityMeasure()));
        }
    }

    Log.info("Retained comparisons\t:\t" + SEqueue.size());

    while (!SEqueue.isEmpty()) {
        final SimilarityEdge se = SEqueue.remove();
        int e1 = se.getModel1Pos();
        int e2 = se.getModel2Pos();

        //skip already matched entities (unique mapping contraint for clean-clean ER)
        if (matchedIds.contains(e1) || matchedIds.contains(e2)) {
            continue;
        }

        similarityGraph.addEdge(e1, e2);
        matchedIds.add(e1);
        matchedIds.add(e2);
    }

    return getConnectedComponents();
}
 

@Override
public EquivalenceCluster[] getDuplicates(SimilarityPairs simPairs) {
    Log.info("Input comparisons\t:\t" + simPairs.getNoOfComparisons());
    
    matchedIds.clear();
    if (simPairs.getNoOfComparisons() == 0) {
        return new EquivalenceCluster[0];
    }

    initializeData(simPairs);
    if (!isCleanCleanER) {
        return null; //the method is only applicable to Clean-Clean ER
    }

    final Iterator<Comparison> iterator = simPairs.getPairIterator();
    int matrixSize = Math.max(noOfEntities - datasetLimit, datasetLimit);
    float[][] simMatrix = new float[matrixSize][matrixSize];
    while (iterator.hasNext()) {
        final Comparison comparison = iterator.next();
        if (threshold < comparison.getUtilityMeasure()) {
            simMatrix[comparison.getEntityId1()][comparison.getEntityId2()] = comparison.getUtilityMeasure();
        }
    }
    init(getNegative(simMatrix));

    execute();

    int[] solutionHeuristic = getSolution();

    for (int i = 0; i < solutionHeuristic.length; i++) {
        int e1 = i;
        int e2 = solutionHeuristic[i];
        if (simMatrix[e1][e2] < threshold) {
            continue;
        }
        e2 += datasetLimit;

        //skip already matched entities (unique mapping contraint for clean-clean ER)
        if (matchedIds.contains(e1) || matchedIds.contains(e2)) {
            System.err.println("id already in the graph");
        }

        similarityGraph.addEdge(e1, e2);
        matchedIds.add(e1);
        matchedIds.add(e2);
    }

    return getConnectedComponents();
}
 

@Override
public void setSimilarityThreshold(float th) {
    threshold = th;
    Log.info("Similarity threshold : " + threshold);
}