# Evaluate a class expression

When using a concept learner, the generated concepts (class expressions) for a certain learning problem
can be evaluated using different approaches. One of them is to use the static functions `evaluate_concept`.
It requires the following arguments:

1. a knowledge base: [AbstractKnowledgeBase](ontolearn.abstracts.AbstractKnowledgeBase)
2. a concept to evaluate: [OWLClassExpression](https://dice-group.github.io/owlapy/autoapi/owlapy/class_expression/class_expression/index.html#owlapy.class_expression.class_expression.OWLClassExpression)
3. a quality function: [AbstractScorer](ontolearn.abstracts.AbstractScorer)
4. the encoded learning problem: [EncodedLearningProblem](ontolearn.learning_problem.EncodedPosNegLPStandard)

When you use a concept learner to generate a class expression (CE) you usually evaluate the performance of the CE 
in the learning problem examples that you used to generate the CE in the first place.
The function `evaluate_concept` returns an object of [EvaluatedConcept](ontolearn.search.EvaluatedConcept).

In this guide we will not use a concept learner to generate a CE but will construct a learning problem and a 
CE manually. Furthermore, we will consider you already have created an object of
[AbstractKnowledgeBase](ontolearn.knowledge_base.AbstractKnowledgeBase) (either KnowlegeBase or TripleStore).
If that's not the case, check [Knowledge Bases](04_knowledge_base.md).

## Construct a learning problem

Let's define a learning problem for the _Father_ ontology. Firstly, we create two simple sets containing 
the positive and negative examples for the concept of 'Father'. Our positive examples 
(individuals to describe) are stefan, markus, and martin. And our negative examples
(individuals to not describe) are heinz, anna, and michelle.

<!--pytest-codeblocks:cont-->
```python
from owlapy.owl_individual import OWLNamedIndividual, IRI

positive_examples = {OWLNamedIndividual(IRI.create(NS, 'stefan')),
                     OWLNamedIndividual(IRI.create(NS, 'markus')),
                     OWLNamedIndividual(IRI.create(NS, 'martin'))}

negative_examples = {OWLNamedIndividual(IRI.create(NS, 'heinz')),
                     OWLNamedIndividual(IRI.create(NS, 'anna')),
                     OWLNamedIndividual(IRI.create(NS, 'michelle'))}
```

Now the learning problem can be represented by using the
[positive-negative standard learning problem](ontolearn.learning_problem.PosNegLPStandard).

<!--pytest-codeblocks:cont-->
```python
from ontolearn.learning_problem import PosNegLPStandard

lp = PosNegLPStandard(pos=positive_examples, neg=negative_examples)
```

We then encod it to the knowledge base:

```python
encoded_lp = lp.encode_kb(kb)
```
where `kb` is an instance of `KnowledgeBase` or `TripleStore`, instantiated in our previous guide.

Now that we have an encoded learning problem, we need a concept to evaluate.

## Construct a concept

Suppose that the class expression `(¬female) ⊓ (∃ hasChild.⊤)` 
was generated by [CELOE](ontolearn.concept_learner.CELOE)
for the target concept of 'Father'. We will see how that can happen later
but for now we let's construct this class expression manually using owlapy:

<!--pytest-codeblocks:cont-->
```python
from owlapy.owl_property import OWLObjectProperty
from owlapy.class_expression import OWLClass, OWLObjectSomeValuesFrom , OWLObjectIntersectionOf
from ontolearn.concept_generator import ConceptGenerator

generator = ConceptGenerator()

female = OWLClass(IRI(NS,'female'))
not_female = generator.negation(female)
has_child_property = OWLObjectProperty(IRI(NS, "hasChild"))
thing = OWLClass(IRI('http://www.w3.org/2002/07/owl#', 'Thing'))
exist_has_child_T = OWLObjectSomeValuesFrom(property=has_child_property, filler=thing)

concept_to_test = OWLObjectIntersectionOf([not_female, exist_has_child_T])
```

We use an instance of [ConceptGenerator](ontolearn.concept_generator.ConceptGenerator) to create the negated concept `¬female`. 
[OWLClass](https://dice-group.github.io/owlapy/autoapi/owlapy/class_expression/owl_class/index.html#owlapy.class_expression.owl_class.OWLClass) 
represent a named class in OWL, [OWLObjectProperty](https://dice-group.github.io/owlapy/autoapi/owlapy/owl_property/index.html#owlapy.owl_property.OWLObjectProperty),
represents an object property in OWL and [OWLObjectSomeValuesFrom](https://dice-group.github.io/owlapy/autoapi/owlapy/class_expression/index.html#owlapy.class_expression.OWLObjectSomeValuesFrom), [OWLObjectIntersectionOf](https://dice-group.github.io/owlapy/autoapi/owlapy/class_expression/nary_boolean_expression/index.html#owlapy.class_expression.nary_boolean_expression.OWLObjectIntersectionOf) represent
class expression constructs.

## Evaluation and results

You can now evaluate the class expression you just created:

<!--pytest-codeblocks:cont-->
```python
from ontolearn.quality_funcs import evaluate_concept

evaluated_concept = evaluate_concept(concept_to_test, F1(), encoded_lp)
```
In this example we use F1-score to evaluate the concept, but there are more [metrics](ontolearn.metrics) 
which you can use including Accuracy, Precision and Recall. 

You can now:

- Print the quality:
    <!--pytest-codeblocks:cont-->
    ```python
    print(evaluated_concept.q) # 1.0
    ```

- Print the set of individuals covered by the class expression:
    <!--pytest-codeblocks:cont-->
    ```python
    for ind in evaluated_concept.inds:
        print(ind) 
  
    # OWLNamedIndividual(http://example.com/father#markus)
    # OWLNamedIndividual(http://example.com/father#martin)
    # OWLNamedIndividual(http://example.com/father#stefan)
    ```
- Print the amount of them:
    <!--pytest-codeblocks:cont-->
    ```python
    print(evaluated_concept.ic) # 3
    ```
  
-----------------------------------------------------------------------------

In the next guide we will walk through the steps of using a concept learning model.