test_text_classifier.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests del modulo text_classifier."""

from __future__ import unicode_literals
from __future__ import print_function
from __future__ import with_statement

import unittest
import sys
import os
import codecs
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import fetch_20newsgroups
sys.path.insert(0, os.path.abspath('..'))
from textar import TextClassifier


# @unittest.skip("skip")
class TextClassifierTestCase(unittest.TestCase):
    """Tests unitarios del objeto TextClassifier."""

    def test_get_similar(self):
        """Testea la búsqueda de textos similares."""

        tc = TextClassifier(
            texts=[
                "El árbol del edificio moderno tiene manzanas",
                "El árbol más chico tiene muchas mandarinas naranjas, y está cerca del monumento antiguo",
                "El edificio más antiguo tiene muchas cuadros caros porque era de un multimillonario",
                "El edificio más moderno tiene muchas programadoras que comen manzanas durante el almuerzo grupal"
            ],
            ids=list(map(str, range(4)))
        )

        ids, distancias, palabras_comunes = tc.get_similar(
            example="Me encontré muchas manzanas en el edificio",
            max_similars=4
        )

        self.assertEqual(ids, ['0', '3', '2', '1'])
        self.assertEqual(
            [
                sorted(palabras)
                for palabras in palabras_comunes
            ]
            ,
            [
                [u'edificio', u'manzanas'],
                [u'edificio', u'manzanas', u'muchas'],
                [u'edificio', u'muchas'], [u'muchas']
            ]
        )

    def test_classify(self):
        tc = TextClassifier(
            texts=[
                "Para hacer una pizza hace falta harina, tomate, queso y jamón",
                "Para hacer unas empanadas necesitamos tapas de empanadas, tomate, jamón y queso",
                "Para hacer un daiquiri necesitamos ron, una fruta y un poco de limón",
                "Para hacer un cuba libre necesitamos coca, ron y un poco de limón",
                "Para hacer una torta de naranja se necesita harina, huevos, leche, ralladura de naranja y polvo de hornear",
                "Para hacer un lemon pie se necesita crema, ralladura de limón, huevos, leche y harina"
            ],
            ids=list(map(str, range(6)))
        )

        # entrena un clasificador
        tc.make_classifier(
            name="recetas_classifier",
            ids=list(map(str, range(6))),
            labels=["Comida", "Comida", "Trago", "Trago", "Postre", "Postre"]
        )

        labels_considerados, puntajes = tc.classify(
            classifier_name="recetas_classifier",
            examples=[
                "Para hacer un bizcochuelo de chocolate se necesita harina, huevos, leche y chocolate negro",
                "Para hacer un sanguche de miga necesitamos pan, jamón y queso"
            ]
        )

        sorted_tuples = sorted(zip(puntajes[0], labels_considerados),
                               reverse=True)
        self.assertEqual(sorted_tuples[0][1], "Postre")

        sorted_tuples = sorted(zip(puntajes[1], labels_considerados),
                               reverse=True)
        self.assertEqual(sorted_tuples[0][1], "Comida")


# @unittest.skip("skip")
class TextClassifierPerformanceTestCase(unittest.TestCase):

    """Clase de tests del objeto TextClassifier."""

    def setUp(self):
        """Carga de los datos de prueba (20 Newsgroups corpus)."""
        newsdata = fetch_20newsgroups(data_home="./data/")
        self.ids = [str(i) for i in range(len(newsdata.target))]
        self.texts = newsdata.data
        self.labels = [newsdata.target_names[idx] for idx in newsdata.target]
        self.tc = TextClassifier(self.texts, self.ids)

    def test_reload_texts(self):
        # TODO aca van los tests!
        pass

    def test_classifier_performance(self):
        X_train, X_test, y_train, y_test = train_test_split(
            self.ids, self.labels, test_size=0.33, random_state=42)
        self.tc.make_classifier("prueba", X_train, y_train)
        clasificador = getattr(self.tc, "prueba")
        indices = np.searchsorted(self.tc.ids, X_test)
        my_score = clasificador.score(self.tc.tfidf_mat[indices, :], y_test)
        self.assertGreater(my_score, 0.8)


if __name__ == '__main__':
    unittest.main()