import unittest
import re
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer


# Helper functions
def _require_success(test_case, condition, failure_message):
    if not condition:
        test_case._testMethodName = failure_message
        test_case.fail()

def _check_success(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
    else:
        test_case._testMethodName = failure_message
        test_case.fail()


class TestUserCode(unittest.TestCase):
    # Test that everything is imported correctly
    def test_imports(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "word_tokenize"), 
            "`word_tokenize` is not declared"
        )
        _require_success(
            self,
            user_code.word_tokenize == word_tokenize,
            "`word_tokenize` is declared, but it's not `nltk.tokenize.word_tokenize`"
        )
        _require_success(
            self, 
            hasattr(user_code, "stopwords"), 
            "`stopwords` is not declared"
        )
        _require_success(
            self,
            user_code.stopwords == stopwords,
            "`stopwords` is declared, but it's not `nltk.corpus.stopwords`"
        )
        _require_success(
            self, 
            hasattr(user_code, "PorterStemmer"), 
            "`PorterStemmer` is not declared"
        )
        _require_success(
            self,
            user_code.PorterStemmer == PorterStemmer,
            "`PorterStemmer` is declared, but it's not `nltk.stem.PorterStemmer`"
        )
        _require_success(
            self,
            hasattr(user_code, "nltk"),
            "`nltk` is not declared"
        )
        _require_success(
            self,
            user_code.nltk == nltk,
            "`nltk` is declared, but it's not `nltk` library"
        )
        self._testMethodName = "imports are correct"

    # Test that required NLTK resources are downloaded
    def test_nltk_downloads(self):
        import user_code
        _require_success(
            self,
            hasattr(user_code, "nltk"),
            "`nltk` is not declared"
        )
        _require_success(
            self,
            user_code.nltk == nltk,
            "`nltk` is declared, but it's not `nltk` library"
        )
        with open("user_code.py", "r") as f:
            user_code_text = f.read()
            _require_success(
                self,
                re.search(r"nltk *\. *download *\( *'punkt_tab' *\)", user_code_text),
                "Code for downloading `'punkt_tab'` tokenizer shouldn't be modified"
            )
            _require_success(
                self,
                re.search(r"nltk *\. *download *\( *'stopwords' *\)", user_code_text),
                "Code for downloading `'stopwords'` shouldn't be modified"
            )
        self._testMethodName = "NLTK resources are downloaded"

    # Test original text
    def test_text(self):
        import user_code
        expected = "Despite the pouring rain, the overwhelming sense of joy and accomplishment made the day unforgettable!"
        _require_success(
            self, 
            hasattr(user_code, "text"), 
            "`text` is not declared"
        )
        _check_success(
            self,
            user_code.text == expected,
            "`text` contains correct value",
            "`text` shouldn't be modified"
        )

    # Test lowercase conversion
    def test_text_lower(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "text"), 
            "`text` is not declared"
        )
        _require_success(
            self, 
            isinstance(user_code.text, str), 
            "`text` is not a string"
        )
        _require_success(
            self, 
            hasattr(user_code, "text_lower"), 
            "`text_lower` is not declared"
        )
        _check_success(
            self,
            user_code.text_lower == user_code.text.lower(),
            "`text_lower` is computed correctly",
            "`text_lower` is not the lowercase of `text`"
        )

    # Test tokenization of text_lower
    def test_tokens(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "text_lower"), 
            "`text_lower` is not declared"
        )
        _require_success(
            self, 
            isinstance(user_code.text_lower, str), 
            "`text_lower` is not a string"
        )
        _require_success(
            self, 
            hasattr(user_code, "tokens"), 
            "`tokens` is not declared"
        )
        _check_success(
            self,
            user_code.tokens == word_tokenize(user_code.text_lower),
            "`tokens` is computed correctly",
            "`text_lower` is not correctly tokenized into words"
        )

    # Test stop_words set
    def test_stop_words(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "stop_words"), 
            "`stop_words` is not declared"
        )
        _require_success(
            self, 
            isinstance(user_code.stop_words, set), 
            "`stop_words` is not a set"
        )
        _check_success(
            self,
            user_code.stop_words == set(stopwords.words('english')),
            "`stop_words` contains correct English stopwords set",
            "`stop_words` doesn't contain English stopwords"
        )

    # Test filtered_tokens filtering
    def test_filtered_tokens(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "tokens"), 
            "`tokens` is not declared"
        )
        _require_success(
            self, 
            isinstance(user_code.tokens, list), 
            "`tokens` is not a list"
        )
        _require_success(
            self, 
            hasattr(user_code, "stop_words"), 
            "`stop_words` is not declared"
        )
        _require_success(
            self, 
            isinstance(user_code.stop_words, set), 
            "`stop_words` is not a set"
        )
        _require_success(
            self, 
            hasattr(user_code, "filtered_tokens"), 
            "`filtered_tokens` is not declared"
        )
        expected = [tok for tok in user_code.tokens if tok not in user_code.stop_words]
        _check_success(
            self,
            user_code.filtered_tokens == expected,
            "`filtered_tokens` is computed correctly",
            "stop words in `tokens` are not correctly filtered out"
        )

    # Test stemmer instance
    def test_stemmer(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "stemmer"), 
            "`stemmer` is not declared"
        )
        _check_success(
            self,
            isinstance(user_code.stemmer, PorterStemmer),
            "`stemmer` is defined correctly",
            "`stemmer` is not an instance of `PorterStemmer`"
        )

    # Test stemming results
    def test_stemmed_tokens(self):
        import user_code
        _require_success(
            self, 
            hasattr(user_code, "stemmer"), 
            "`stemmer` is not declared"
        )
        _require_success(
            self,
            isinstance(user_code.stemmer, PorterStemmer),
            "`stemmer` is not an instance of `PorterStemmer`"
        )
        _require_success(
            self, 
            hasattr(user_code, "filtered_tokens"), 
            "`filtered_tokens` is not declared"
        )
        _require_success(
            self, 
            isinstance(user_code.filtered_tokens, list), 
            "`filtered_tokens` is not a list"
        )
        _require_success(
            self, 
            hasattr(user_code, "stemmed_tokens"), 
            "`stemmed_tokens` is not declared"
        )
        expected = [user_code.stemmer.stem(tok) for tok in user_code.filtered_tokens]
        _check_success(
            self,
            user_code.stemmed_tokens == expected,
            "`stemmed_tokens` is computed correctly",
            "`filtered_tokens` are not correctly stemmed"
        )

    # Test print statement
    def test_print(self):
        with open("user_code.py", "r") as f:
            user_code_text = f.read()
        _check_success(
            self,
            re.search(r"print *\( *\\"Stemmed tokens:\\" *, *stemmed_tokens *\)", user_code_text),
            "print statement is correct",
            "print statement shouldn't be modified"
        )


if __name__ == '__main__':
    nltk.download('punkt_tab')
    nltk.download('stopwords')
    unittest.main()

test_main.py

Udforsk grundlæggende principper inden for Natural Language Processing (NLP) ved at lære essentielle teknikker til tekstforbehandling og metoder til repræsentation af tekstdata. Opnå praktisk erfaring med værktøjer til at rense, analysere og fortolke tekstuel information. Udvikl færdigheder til at omdanne råt sprog til strukturerede indsigter og skab et solidt fundament for avancerede anvendelser inden for kunstig intelligens og maskinlæring.

Dyk ned i de grundlæggende principper for tekstforbehandling for at klargøre rå tekst til analyse. Lær hvordan man opdeler tekst i tokens, filtrerer stopord fra og tilpasser tokenisering med regulære udtryk.

Opdag, hvordan ord kan reduceres til deres grundformer ved hjælp af stamme- og lemmatisering. Behersk ordklassemærkning for at berige tekst med grammatisk kontekst og anvend ordklassebevidst lemmatisering.

Lær, hvordan tekst kan repræsenteres med tal ved hjælp af vektorrumsmodeller. Få praktisk erfaring med at implementere og tilpasse to populære vektorrumsmodeller: bag of words og TF-IDF.

Opnå en solid forståelse af ordindlejringer og hvordan de indfanger semantisk betydning. Udforsk CBoW- og Skip-gram-arkitekturer anvendt i Word2Vec, og implementer dem selv.

Udfordring: Stemming

Løsning

Awesome!

Udfordring: Stemming

Løsning