MiningAssistant

java.lang.Object
- amie.mining.assistant.MiningAssistant

Direct Known Subclasses:

DefaultMiningAssistant
```
public class MiningAssistant
extends java.lang.Object
```
Simpler miner assistant which implements all the logic required to mine conjunctive rules from a RDF datastore. Subclasses are encouraged to override the following methods:
- getInitialAtomsFromSeeds
- getInitialAtoms
- getDanglingAtoms
- getClosingAtoms
- getInstantiatedAtoms
Author:

lgalarra

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`allowConstants` Allow constants for refinements
`protected boolean`	`avoidUnboundTypeAtoms` If true, the assistant will never add atoms of the form type(x, y), i.e., it will always bind the second argument to a type.
`protected java.util.Collection<javatools.datatypes.ByteString>`	`bodyExcludedRelations` List of excluded relations for the body of rules;
`protected java.util.Collection<javatools.datatypes.ByteString>`	`bodyTargetRelations` List of target relations for the body of rules;
`protected ConfidenceMetric`	`confidenceMetric` Confidence metric used to assess the quality of rules.
`protected boolean`	`countAlwaysOnSubject` Count directly on subject or use functional information
`protected boolean`	`enabledConfidenceUpperBounds` Enable confidence and PCA confidence upper bounds for pruning when given a confidence threshold
`protected boolean`	`enabledFunctionalityHeuristic` Use a functionality vs suggested functionality heuristic to prune low confident rule upfront.
`protected boolean`	`enablePerfectRules` Enable perfect rule pruning, i.e., do not further specialize rules with PCA confidence 1.0.
`protected boolean`	`enableQueryRewriting` Enable query rewriting to optimize runtime.
`protected boolean`	`enforceConstants` Enforce constants in all atoms of rules
`protected boolean`	`exploitMaxLengthOption` If false, the assistant will not exploit the maximum length restriction to improve runtime.
`protected java.util.HashMap<java.lang.String,java.lang.Double>`	`headCardinalities` Contains the number of triples per relation in the database
`protected java.util.Collection<javatools.datatypes.ByteString>`	`headExcludedRelations` List of excluded relations for the head of rules;
`protected KB`	`kb` Factory object to instantiate query components
`protected KB`	`kbSchema` Exclusively used for schema information, such as subclass and sub-property relations or relation signatures.
`protected int`	`maxDepth` Maximum number of atoms in a query
`protected double`	`minPcaConfidence` Minimum confidence
`protected double`	`minStdConfidence` Minimum confidence
`protected int`	`recursivityLimit` Maximum number of times a relation can appear in a rule.
`protected javatools.datatypes.ByteString`	`subPropertyString` Subproperty keyword
`protected long`	`totalObjectCount` Number of different objects in the underlying dataset
`protected long`	`totalSubjectCount` Number of different subjects in the underlying dataset
`protected javatools.datatypes.ByteString`	`typeString` Type keyword
`protected boolean`	`verbose` If true, the assistant will output minimal debug information

Constructor Summary

Constructors
Constructor and Description

MiningAssistant(KB dataSource)

Constructors
Constructor and Description
`MiningAssistant(KB dataSource)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`buildInitialQueries(javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> relations, double minSupportThreshold, java.util.Collection<Rule> output)` Given a list of relations with their corresponding support (one assistant could count based on the number of pairs, another could use the number of subjects), it adds one rule per relation to the output.
`protected boolean`	`calculateConfidenceApproximationFor3Atoms(Rule candidate)` Calculate the confidence approximation of the query for the case when the rule has exactly 3 atoms.
`protected boolean`	`calculateConfidenceApproximationForGeneralCase(Rule candidate)` Given a rule with more than 3 atoms and a single path connecting the head variables, it computes a confidence approximation.
`boolean`	`calculateConfidenceBoundsAndApproximations(Rule candidate)` It computes the confidence upper bounds and approximations for the rule sent as argument.
`void`	`calculateConfidenceMetrics(Rule candidate)` It computes the standard and the PCA confidence of a given rule.
`protected boolean`	`canAddInstantiatedAtoms()` Returns true if the assistant configuration allows the addition of instantiated atom, i.e., atoms where one of the arguments has a constant.
`double`	`computeCardinality(Rule rule)` It computes the number of positive examples (cardinality) of the given rule based on the evidence in the database.
`double`	`computePCAConfidence(Rule rule)` It computes the PCA confidence of the given rule based on the evidence in database.
`double`	`computeStandardConfidence(Rule candidate)` It computes the standard confidence of the given rule based on the evidence in database.
`protected int`	`findCountingVariable(javatools.datatypes.ByteString[] headAtom)` It determines the counting variable of an atom with constant relation based on the functionality of the relation
`java.util.Collection<javatools.datatypes.ByteString>`	`getBodyExcludedRelations()`
`java.util.Collection<javatools.datatypes.ByteString>`	`getBodyTargetRelations()`
`void`	`getClosingAtoms(Rule rule, double minSupportThreshold, java.util.Collection<Rule> output)` Returns all rule candidates obtained by adding a new atom that does not contain fresh variables.
`ConfidenceMetric`	`getConfidenceMetric()`
`void`	`getDanglingAtoms(Rule rule, double minSupportThreshold, java.util.Collection<Rule> output)` Returns all candidates obtained by adding a new dangling atom to the query.
`java.lang.String`	`getDescription()` Brief description of the MiningAssistant capabilities.
`long`	`getFactsCount()`
`long`	`getHeadCardinality(Rule query)`
`java.util.Collection<javatools.datatypes.ByteString>`	`getHeadExcludedRelations()`
`void`	`getInitialAtoms(double minSupportThreshold, java.util.Collection<Rule> output)` Returns a list of one-atom queries using the relations from the KB
`void`	`getInitialAtomsFromSeeds(java.util.Collection<javatools.datatypes.ByteString> relations, double minSupportThreshold, java.util.Collection<Rule> output)` Returns a list of one-atom queries using the head relations provided in the collection relations.
`void`	`getInstantiatedAtoms(Rule rule, double minSupportThreshold, java.util.Collection<Rule> danglingEdges, java.util.Collection<Rule> output)` Returns all candidates obtained by instantiating the dangling variable of the last added triple pattern in the rule
`protected void`	`getInstantiatedAtoms(Rule queryWithDanglingEdge, Rule parentQuery, int danglingAtomPosition, int danglingPositionInEdge, double minSupportThreshold, java.util.Collection<Rule> output)` It returns all the refinements of queryWithDanglingEdge where the fresh variable in the dangling atom has been bound to all the constants that keep the query above the support threshold.
`KB`	`getKb()` It returns the training dataset from which rules atoms are added
`KB`	`getKbSchema()` It returns the KB containing the schema information (subclass and subproperty relationships, domains and ranges for relation, etc.) about the training dataset.
`int`	`getMaxDepth()`
`double`	`getMinConfidence()`
`double`	`getPcaConfidenceThreshold()`
`int`	`getRecursivityLimit()`
`double`	`getRelationCardinality(javatools.datatypes.ByteString relation)`
`double`	`getRelationCardinality(java.lang.String relation)`
`protected java.util.Set<javatools.datatypes.ByteString>`	`getSubClasses(javatools.datatypes.ByteString className)`
`long`	`getTotalCount(int projVarPosition)`
`long`	`getTotalCount(Rule candidate)`
`long`	`getTotalObjectCount()`
`long`	`getTotalSubjectCount()` Returns the total number of subjects in the database.
`boolean`	`isAvoidUnboundTypeAtoms()`
`boolean`	`isEnabledConfidenceUpperBounds()`
`boolean`	`isEnabledFunctionalityHeuristic()`
`boolean`	`isEnablePerfectRules()`
`boolean`	`isEnableQueryRewriting()`
`boolean`	`isEnforceConstants()`
`boolean`	`isExploitMaxLengthOption()`
`boolean`	`isVerbose()`
`boolean`	`registerHeadRelation(Rule query)`
`void`	`setAllowConstants(boolean allowConstants)`
`void`	`setAvoidUnboundTypeAtoms(boolean avoidUnboundTypeAtoms)`
`void`	`setBodyExcludedRelations(java.util.Collection<javatools.datatypes.ByteString> excludedRelations)`
`void`	`setConfidenceMetric(ConfidenceMetric confidenceMetric)`
`void`	`setCountAlwaysOnSubject(boolean countAlwaysOnSubject)`
`void`	`setEnabledConfidenceUpperBounds(boolean enabledConfidenceUpperBounds)`
`void`	`setEnabledFunctionalityHeuristic(boolean enableOptimizations)`
`void`	`setEnablePerfectRules(boolean enablePerfectRules)`
`void`	`setEnableQueryRewriting(boolean enableQueryRewriting)`
`void`	`setEnforceConstants(boolean enforceConstants)`
`void`	`setExploitMaxLengthOption(boolean exploitMaxLengthOption)`
`void`	`setHeadExcludedRelations(java.util.Collection<javatools.datatypes.ByteString> headExcludedRelations)`
`void`	`setKbSchema(KB schemaSource)`
`void`	`setMaxDepth(int maxAntecedentDepth)`
`void`	`setPcaConfidenceThreshold(double minConfidence)`
`void`	`setRecursivityLimit(int recursivityLimit)`
`void`	`setStdConfidenceThreshold(double minConfidence)`
`void`	`setTargetBodyRelations(java.util.Collection<javatools.datatypes.ByteString> bodyTargetRelations)`
`void`	`setVerbose(boolean silent)`
`boolean`	`testConfidenceThresholds(Rule candidate)` It checks whether a rule satisfies the confidence thresholds and the sky-line heuristic: the strategy that avoids outputting rules that do not improve the confidence w.r.t their parents.
`protected boolean`	`testLength(Rule candidate)` Check whether the rule meets the length criteria configured in the object.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - recursivityLimit
```
protected int recursivityLimit
```
    Maximum number of times a relation can appear in a rule.
  - kb
```
protected KB kb
```
    Factory object to instantiate query components
  - kbSchema
```
protected KB kbSchema
```
    Exclusively used for schema information, such as subclass and sub-property relations or relation signatures.
  - totalObjectCount
```
protected long totalObjectCount
```
    Number of different objects in the underlying dataset
  - totalSubjectCount
```
protected long totalSubjectCount
```
    Number of different subjects in the underlying dataset
  - typeString
```
protected javatools.datatypes.ByteString typeString
```
    Type keyword
  - subPropertyString
```
protected javatools.datatypes.ByteString subPropertyString
```
    Subproperty keyword
  - minStdConfidence
```
protected double minStdConfidence
```
    Minimum confidence
  - minPcaConfidence
```
protected double minPcaConfidence
```
    Minimum confidence
  - maxDepth
```
protected int maxDepth
```
    Maximum number of atoms in a query
  - headCardinalities
```
protected java.util.HashMap<java.lang.String,java.lang.Double> headCardinalities
```
    Contains the number of triples per relation in the database
  - allowConstants
```
protected boolean allowConstants
```
    Allow constants for refinements
  - enforceConstants
```
protected boolean enforceConstants
```
    Enforce constants in all atoms of rules
  - bodyExcludedRelations
```
protected java.util.Collection<javatools.datatypes.ByteString> bodyExcludedRelations
```
    List of excluded relations for the body of rules;
  - headExcludedRelations
```
protected java.util.Collection<javatools.datatypes.ByteString> headExcludedRelations
```
    List of excluded relations for the head of rules;
  - bodyTargetRelations
```
protected java.util.Collection<javatools.datatypes.ByteString> bodyTargetRelations
```
    List of target relations for the body of rules;
  - countAlwaysOnSubject
```
protected boolean countAlwaysOnSubject
```
    Count directly on subject or use functional information
  - enabledFunctionalityHeuristic
```
protected boolean enabledFunctionalityHeuristic
```
    Use a functionality vs suggested functionality heuristic to prune low confident rule upfront.
  - enabledConfidenceUpperBounds
```
protected boolean enabledConfidenceUpperBounds
```
    Enable confidence and PCA confidence upper bounds for pruning when given a confidence threshold
  - verbose
```
protected boolean verbose
```
    If true, the assistant will output minimal debug information
  - avoidUnboundTypeAtoms
```
protected boolean avoidUnboundTypeAtoms
```
    If true, the assistant will never add atoms of the form type(x, y), i.e., it will always bind the second argument to a type.
  - exploitMaxLengthOption
```
protected boolean exploitMaxLengthOption
```
    If false, the assistant will not exploit the maximum length restriction to improve runtime.
  - enableQueryRewriting
```
protected boolean enableQueryRewriting
```
    Enable query rewriting to optimize runtime.
  - enablePerfectRules
```
protected boolean enablePerfectRules
```
    Enable perfect rule pruning, i.e., do not further specialize rules with PCA confidence 1.0.
  - confidenceMetric
```
protected ConfidenceMetric confidenceMetric
```
    Confidence metric used to assess the quality of rules.
- Constructor Detail
  - MiningAssistant
```
public MiningAssistant(KB dataSource)
```
    Parameters:
    
    dataSource -
- Method Detail
  - getRecursivityLimit
```
public int getRecursivityLimit()
```
  - setRecursivityLimit
```
public void setRecursivityLimit(int recursivityLimit)
```
  - getTotalCount
```
public long getTotalCount(Rule candidate)
```
  - getTotalSubjectCount
```
public long getTotalSubjectCount()
```
    Returns the total number of subjects in the database.
    
    Returns:
  - getTotalObjectCount
```
public long getTotalObjectCount()
```
  - getMaxDepth
```
public int getMaxDepth()
```
    Returns:
    
    the maxDepth
  - setMaxDepth
```
public void setMaxDepth(int maxAntecedentDepth)
```
    Parameters:
    
    maxAntecedentDepth -
  - getMinConfidence
```
public double getMinConfidence()
```
    Returns:
    
    the minStdConfidence
  - getPcaConfidenceThreshold
```
public double getPcaConfidenceThreshold()
```
    Returns:
    
    the minPcaConfidence
  - setPcaConfidenceThreshold
```
public void setPcaConfidenceThreshold(double minConfidence)
```
    Parameters:
    
    minConfidence - the minPcaConfidence to set
  - setStdConfidenceThreshold
```
public void setStdConfidenceThreshold(double minConfidence)
```
    Parameters:
    
    minConfidence - the minConfidence to set
  - getKb
```
public KB getKb()
```
    It returns the training dataset from which rules atoms are added
    
    Returns:
  - getKbSchema
```
public KB getKbSchema()
```
    It returns the KB containing the schema information (subclass and subproperty relationships, domains and ranges for relation, etc.) about the training dataset.
    
    Returns:
  - getDescription
```
public java.lang.String getDescription()
```
    Brief description of the MiningAssistant capabilities.
  - setKbSchema
```
public void setKbSchema(KB schemaSource)
```
  - registerHeadRelation
```
public boolean registerHeadRelation(Rule query)
```
  - getHeadCardinality
```
public long getHeadCardinality(Rule query)
```
  - getRelationCardinality
```
public double getRelationCardinality(java.lang.String relation)
```
  - getRelationCardinality
```
public double getRelationCardinality(javatools.datatypes.ByteString relation)
```
  - getSubClasses
```
protected java.util.Set<javatools.datatypes.ByteString> getSubClasses(javatools.datatypes.ByteString className)
```
  - canAddInstantiatedAtoms
```
protected boolean canAddInstantiatedAtoms()
```
    Returns true if the assistant configuration allows the addition of instantiated atom, i.e., atoms where one of the arguments has a constant.
    
    Returns:
  - getInitialAtomsFromSeeds
```
public void getInitialAtomsFromSeeds(java.util.Collection<javatools.datatypes.ByteString> relations,
                                     double minSupportThreshold,
                                     java.util.Collection<Rule> output)
```
    Returns a list of one-atom queries using the head relations provided in the collection relations.
    
    Parameters:
    
    relations -
    
    minSupportThreshold - Only relations of size bigger or equal than this value will be considered.
    
    output - The results of the method are added directly to this collection.
  - getInitialAtoms
```
public void getInitialAtoms(double minSupportThreshold,
                            java.util.Collection<Rule> output)
```
    Returns a list of one-atom queries using the relations from the KB
    
    Parameters:
    
    minSupportThreshold - Only relations of size bigger or equal than this value will be considered.
    
    output -
  - buildInitialQueries
```
protected void buildInitialQueries(javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> relations,
                                   double minSupportThreshold,
                                   java.util.Collection<Rule> output)
```
    Given a list of relations with their corresponding support (one assistant could count based on the number of pairs, another could use the number of subjects), it adds one rule per relation to the output. The relation appears as the head and unique atom of the rule.
    
    Parameters:
    
    relations -
    
    minSupportThreshold - Only relations with support equal or above this value are considered.
    
    output -
  - getDanglingAtoms
```
public void getDanglingAtoms(Rule rule,
                             double minSupportThreshold,
                             java.util.Collection<Rule> output)
```
    Returns all candidates obtained by adding a new dangling atom to the query. A dangling atom joins with the rule on one variable and introduces a fresh variable not seen in the rule.
    
    Parameters:
    
    rule -
    
    minSupportThreshold -
    
    output -
  - findCountingVariable
```
protected int findCountingVariable(javatools.datatypes.ByteString[] headAtom)
```
    It determines the counting variable of an atom with constant relation based on the functionality of the relation
    
    Parameters:
    
    headAtom -
  - calculateConfidenceMetrics
```
public void calculateConfidenceMetrics(Rule candidate)
```
    It computes the standard and the PCA confidence of a given rule. It assumes the rule's cardinality (absolute support) is known.
    
    Parameters:
    
    candidate -
  - getClosingAtoms
```
public void getClosingAtoms(Rule rule,
                            double minSupportThreshold,
                            java.util.Collection<Rule> output)
```
    Returns all rule candidates obtained by adding a new atom that does not contain fresh variables.
    
    Parameters:
    
    rule -
    
    minSupportThreshold - Only candidates with support above or equal this value are returned.
    
    output -
  - getInstantiatedAtoms
```
public void getInstantiatedAtoms(Rule rule,
                                 double minSupportThreshold,
                                 java.util.Collection<Rule> danglingEdges,
                                 java.util.Collection<Rule> output)
```
    Returns all candidates obtained by instantiating the dangling variable of the last added triple pattern in the rule
    
    Parameters:
    
    rule -
    
    minSupportThreshold -
    
    danglingEdges -
    
    output -
  - testLength
```
protected boolean testLength(Rule candidate)
```
    Check whether the rule meets the length criteria configured in the object.
    
    Parameters:
    
    candidate -
    
    Returns:
  - calculateConfidenceBoundsAndApproximations
```
public boolean calculateConfidenceBoundsAndApproximations(Rule candidate)
```
    It computes the confidence upper bounds and approximations for the rule sent as argument.
    
    Parameters:
    
    candidate -
    
    Returns:
    
    True If neither the confidence bounds nor the approximations are aplicable or if they did not find enough evidence to discard the rule.
  - calculateConfidenceApproximationForGeneralCase
```
protected boolean calculateConfidenceApproximationForGeneralCase(Rule candidate)
```
    Given a rule with more than 3 atoms and a single path connecting the head variables, it computes a confidence approximation. It corresponds to the last formula of page 15 in http://luisgalarraga.de/docs/amie-plus.pdf
    
    Parameters:
    
    candidate -
    
    Returns:
    
    boolean True if the approximation is not applicable or produces a value above the confidence thresholds, i.e., there is not enough evidence to drop the rule.
  - calculateConfidenceApproximationFor3Atoms
```
protected boolean calculateConfidenceApproximationFor3Atoms(Rule candidate)
```
    Calculate the confidence approximation of the query for the case when the rule has exactly 3 atoms. It is the implementation of section 6.2.2 in http://luisgalarraga.de/docs/amie-plus.pdf
    
    Parameters:
    
    candidate -
    
    Returns:
    
    boolean True if the approximation is not applicable or produces a value above the confidence thresholds, i.e., there is not enough evidence to drop the rule.
  - testConfidenceThresholds
```
public boolean testConfidenceThresholds(Rule candidate)
```
    It checks whether a rule satisfies the confidence thresholds and the sky-line heuristic: the strategy that avoids outputting rules that do not improve the confidence w.r.t their parents.
    
    Parameters:
    
    candidate -
    
    Returns:
  - getInstantiatedAtoms
```
protected void getInstantiatedAtoms(Rule queryWithDanglingEdge,
                                    Rule parentQuery,
                                    int danglingAtomPosition,
                                    int danglingPositionInEdge,
                                    double minSupportThreshold,
                                    java.util.Collection<Rule> output)
```
    It returns all the refinements of queryWithDanglingEdge where the fresh variable in the dangling atom has been bound to all the constants that keep the query above the support threshold.
    
    Parameters:
    
    queryWithDanglingEdge -
    
    parentQuery -
    
    danglingAtomPosition -
    
    danglingPositionInEdge -
    
    minSupportThreshold -
    
    output -
  - computeCardinality
```
public double computeCardinality(Rule rule)
```
    It computes the number of positive examples (cardinality) of the given rule based on the evidence in the database.
    
    Parameters:
    
    rule -
    
    Returns:
  - computePCAConfidence
```
public double computePCAConfidence(Rule rule)
```
    It computes the PCA confidence of the given rule based on the evidence in database. The value is both returned and set to the rule
    
    Parameters:
    
    rule -
    
    Returns:
  - computeStandardConfidence
```
public double computeStandardConfidence(Rule candidate)
```
    It computes the standard confidence of the given rule based on the evidence in database. The value is both returned and set to the rule
    
    Parameters:
    
    candidate -
    
    Returns:
  - setAllowConstants
```
public void setAllowConstants(boolean allowConstants)
```
  - isEnforceConstants
```
public boolean isEnforceConstants()
```
  - setEnforceConstants
```
public void setEnforceConstants(boolean enforceConstants)
```
  - getBodyExcludedRelations
```
public java.util.Collection<javatools.datatypes.ByteString> getBodyExcludedRelations()
```
  - setBodyExcludedRelations
```
public void setBodyExcludedRelations(java.util.Collection<javatools.datatypes.ByteString> excludedRelations)
```
  - getHeadExcludedRelations
```
public java.util.Collection<javatools.datatypes.ByteString> getHeadExcludedRelations()
```
  - setHeadExcludedRelations
```
public void setHeadExcludedRelations(java.util.Collection<javatools.datatypes.ByteString> headExcludedRelations)
```
  - getBodyTargetRelations
```
public java.util.Collection<javatools.datatypes.ByteString> getBodyTargetRelations()
```
  - isAvoidUnboundTypeAtoms
```
public boolean isAvoidUnboundTypeAtoms()
```
  - setAvoidUnboundTypeAtoms
```
public void setAvoidUnboundTypeAtoms(boolean avoidUnboundTypeAtoms)
```
  - setTargetBodyRelations
```
public void setTargetBodyRelations(java.util.Collection<javatools.datatypes.ByteString> bodyTargetRelations)
```
  - getTotalCount
```
public long getTotalCount(int projVarPosition)
```
  - setCountAlwaysOnSubject
```
public void setCountAlwaysOnSubject(boolean countAlwaysOnSubject)
```
  - getFactsCount
```
public long getFactsCount()
```
  - isEnabledFunctionalityHeuristic
```
public boolean isEnabledFunctionalityHeuristic()
```
  - setEnabledFunctionalityHeuristic
```
public void setEnabledFunctionalityHeuristic(boolean enableOptimizations)
```
  - isEnabledConfidenceUpperBounds
```
public boolean isEnabledConfidenceUpperBounds()
```
  - setEnabledConfidenceUpperBounds
```
public void setEnabledConfidenceUpperBounds(boolean enabledConfidenceUpperBounds)
```
  - isVerbose
```
public boolean isVerbose()
```
  - setVerbose
```
public void setVerbose(boolean silent)
```
  - isExploitMaxLengthOption
```
public boolean isExploitMaxLengthOption()
```
  - setExploitMaxLengthOption
```
public void setExploitMaxLengthOption(boolean exploitMaxLengthOption)
```
  - isEnableQueryRewriting
```
public boolean isEnableQueryRewriting()
```
  - setEnableQueryRewriting
```
public void setEnableQueryRewriting(boolean enableQueryRewriting)
```
  - isEnablePerfectRules
```
public boolean isEnablePerfectRules()
```
  - setEnablePerfectRules
```
public void setEnablePerfectRules(boolean enablePerfectRules)
```
  - getConfidenceMetric
```
public ConfidenceMetric getConfidenceMetric()
```
  - setConfidenceMetric
```
public void setConfidenceMetric(ConfidenceMetric confidenceMetric)
```

Class MiningAssistant

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

recursivityLimit

kb

kbSchema

totalObjectCount

totalSubjectCount

typeString

subPropertyString

minStdConfidence

minPcaConfidence

maxDepth

headCardinalities

allowConstants

enforceConstants

bodyExcludedRelations

headExcludedRelations

bodyTargetRelations

countAlwaysOnSubject

enabledFunctionalityHeuristic

enabledConfidenceUpperBounds

verbose

avoidUnboundTypeAtoms

exploitMaxLengthOption

enableQueryRewriting

enablePerfectRules

confidenceMetric

Constructor Detail

MiningAssistant

Method Detail

getRecursivityLimit

setRecursivityLimit

getTotalCount

getTotalSubjectCount

getTotalObjectCount

getMaxDepth

setMaxDepth

getMinConfidence

getPcaConfidenceThreshold

setPcaConfidenceThreshold

setStdConfidenceThreshold

getKb

getKbSchema

getDescription

setKbSchema

registerHeadRelation

getHeadCardinality

getRelationCardinality

getRelationCardinality

getSubClasses

canAddInstantiatedAtoms

getInitialAtomsFromSeeds

getInitialAtoms

buildInitialQueries

getDanglingAtoms

findCountingVariable

calculateConfidenceMetrics

getClosingAtoms

getInstantiatedAtoms

testLength

calculateConfidenceBoundsAndApproximations

calculateConfidenceApproximationForGeneralCase

calculateConfidenceApproximationFor3Atoms

testConfidenceThresholds

getInstantiatedAtoms

computeCardinality

computePCAConfidence

computeStandardConfidence

setAllowConstants

isEnforceConstants

setEnforceConstants

getBodyExcludedRelations

setBodyExcludedRelations

getHeadExcludedRelations

setHeadExcludedRelations

getBodyTargetRelations