<jupyter_start><jupyter_text>Classes Word et nltk Jouons un peu avec un fichier taggé et nltkUn peu de POO avec nos propres classes puis celles de nltk  Classes Word pour lecture de fichiers taggés en pos<jupyter_code>import re

class Word:
    """ Classe Word : définit un mot simple de la langue """

    type = "simple"

    def __init__(self, *args):
            self.form, self.lemma, self.pos = args

    def is_inflected(self):
        if self.form != self.lemma:
            return True
        else:
            return False

    def magic_compare(self, other_word):
        diff = []
        for key in self.__dict__.keys():
            if self.__dict__[key] != other_word.__dict__[key]:
                diff.append(key)
        return diff

    def __str__(self):
        return " ".join((self.form, self.lemma, self.pos))<jupyter_output><empty_output><jupyter_text>`__str__` est une méthode que partagent tous les objets, elle est appellée par la fonction `print`.Ici nous 'surchargeons' la méthode pour spécifier la sortie désirée. On peut aussi implémenter une ou plus méthodes d'output (text, xml, json, ...)<jupyter_code>obj = Word("été", "été", "NOM")
print(obj)<jupyter_output><empty_output><jupyter_text>Pour les imports de données aux formats TreeTagger, Brow et Sem nous allons utiliser des classes qui héritent de Word.Les classes se contentent d'avoir un constructeur différent.<jupyter_code>class WordTreeTagger(Word):
    def __init__(self, formatted_str):
        """
        import a formatted_str in treetagger format
        """
        self.form, self.lemma, self.pos = formatted_str.split("\t")

class WordBrown(Word):
    def __init__(self, formatted_str):
        """
        import a formatted_str in brown format
        """
        self.form, self.lemma, self.pos = formatted_str.split("/")

class WordSem(Word):
    def __init__(self, formatted_str):
        """
        import a formatted_str in sem format (brown with no lemmas
        """
        self.form, self.pos = formatted_str.split("/")
        self.lemma = ""<jupyter_output><empty_output><jupyter_text>Un objet WordBrown est aussi un objet Word<jupyter_code>obj_brown = WordBrown("été/être/V")
if isinstance(obj_brown, WordBrown):
    print("Évidemment obj_brown est une instance de WordBrown")
if isinstance(obj_brown, Word):
    print("C'est aussi une instance de la classe Word, je peux lui appliquer les méthodes de Word")
obj_brown.magic_compare(obj)<jupyter_output><empty_output><jupyter_text>Lecture et chargement du fichier `lecun-pos.txt`, transcription tagguée avec Sem (http://apps.lattice.cnrs.fr/sem) d'une présentation de l'intelligence artificielle de <NAME> au collège de France (https://www.college-de-france.fr/site/yann-lecun/Recherches-sur-l-intelligence-artificielle.htm).<jupyter_code>words = []
with open('lecun-pos.txt') as file:
    for line in file:
        if '/' in line:
            line = line.rstrip()
            words.extend([WordSem(item) for item in line.split(" ")])
for word in words[:10]:
    print(word)<jupyter_output><empty_output><jupyter_text>Le fichier est chargé en mémoire dans une liste d'objets Word.Je voudrais maintenant faire des calculs simples sur les fréquences de mots, trouver les hapax, les mots d'une certaine catégorie, etc...Je peux faire ça à la main sans trop de difficultés, je peux aussi utiliser le package `nltk` et plus particulièrement le module `nltk.probablity`  Utilisation du module `nltk.probability`<jupyter_code>from nltk.probability import FreqDist, ConditionalFreqDist<jupyter_output><empty_output><jupyter_text>Si vous avez un message d'erreur c'est que le package `nltk` n'est pas installé sur votre machine : `sudo pip3 install nltk`Nous aurons aussi besoin de matplotlib. Si vous êtes sur une debian-based utilisez apt-get pour l'installer (`python3-matplotlib`), sinon pip. Il faut commencer par lire ou au moins parcourir la [doc de `nltk.probability`](http://www.nltk.org/api/nltk.html?highlight=nltk.probabilitymodule-nltk.probability)Nous allons utiliser les classes `FreqDist` et `ConditionalFreqDist`<jupyter_code>fdist = FreqDist(word.form.lower() for word in words)
fdist.hapaxes()<jupyter_output><empty_output><jupyter_text>Et voilà. C'est aussi simple que ça de trouver les hapax.À vous de jouer, trouvez le mot le plus fréquent, puis les 20 mots les plus fréquents, trouvez les fréquences de 'le', 'artificielle' et 'réseaux'.Enfin affichez un graphe des fréquences des 20 mots les plus fréquents.<jupyter_code>#fdist.max()
#for form, occ in fdist.most_common(20):
#    print(form)
#fdist['le']
%matplotlib inline
fdist.plot(10)<jupyter_output><empty_output><jupyter_text>`ConditionalFreqDist` permet de faire des calculs de fréquences selon une certaine condition. Ici nous allons utiliser le pos comme condition.  cfdist = ConditionalFreqDist((word.pos, word.form) for word in words)<jupyter_code>cfdist['V']<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09833738848337388, 'fraction_numerical': 0.0024330900243309003, 'mean_word_length': 4.247872340425532, 'pattern_counts': {'":': 0, '<': 38, '<?xml version=': 0, '>': 38, 'https://': 1, 'lorem ipsum': 0, 'www.': 2, 'xml': 1}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '424186', 'license': 'MIT', 'n_tokens_mistral': 1669, 'n_tokens_neox': 1615, 'n_words': 489, 'path': 'classes-word.ipynb', 'repo_name': 'afafe78/python-im', 'size': '4936'}