4.2.1. Chargement des fonctionnalités depuis les dictionnaires

La classe DictVectorizer est une quantité de caractéristiques représentée comme une liste d'objets dict Python standard. Il peut être utilisé pour convertir un tableau en représentation NumPy / SciPy utilisée par l'estimateur scikit-learn. Bien que pas particulièrement rapide, le dict de Python a les avantages d'être facile à utiliser, clairsemé (pas besoin de stocker des fonctionnalités inexistantes) et de pouvoir stocker des noms de fonctionnalités en plus des valeurs. DictVectorizer implémente un codage un-à-un ou un codage "one-hot" pour les catégories (ou les valeurs nominales discrètes). Les attributs de catégorie sont des paires «attribut-valeur» qui sont limitées à une liste non ordonnée de valeurs discrètes (identificateurs de rubrique, types d'objets, balises, noms, etc.). Dans ce qui suit, «ville» est un attribut de catégorie et «température» est une quantité caractéristique numérique conventionnelle.

>>> measurements = [
...     {'city': 'Dubai', 'temperature': 33.},
...     {'city': 'London', 'temperature': 12.},
...     {'city': 'San Fransisco', 'temperature': 18.},
... ]

>>> from sklearn.feature_extraction import DictVectorizer
>>> vec = DictVectorizer()

>>> vec.fit_transform(measurements).toarray()
array([[  1.,   0.,   0.,  33.],
       [  0.,   1.,   0.,  12.],
       [  0.,   0.,   1.,  18.]])

>>> vec.get_feature_names()
['city=Dubai', 'city=London', 'city=San Fransisco', 'temperature']

DictVectorizer est une transformation d'expression utile pour la formation des classificateurs de phrases dans les modèles de traitement du langage naturel (généralement en extrayant des caractéristiques autour d'un mot d'intérêt particulier). Par exemple, supposons que vous ayez un premier algorithme qui extrait les balises de mot partiel (PoS) d'une phrase. Le dict suivant est une telle caractéristique extraite du mot «assis» dans la phrase «Le chat était assis sur le tapis».

>>> pos_window = [
...     {
...         'word-2': 'the',
...         'pos-2': 'DT',
...         'word-1': 'cat',
...         'pos-1': 'NN',
...         'word+1': 'on',
...         'pos+1': 'PP',
...     },
...     #Dans une application réelle, vous extrairez de nombreux dicts de ce type
... ]

Ces données peuvent être vectorisées dans une matrice bidimensionnelle clairsemée appropriée pour alimenter le classificateur (text.TfidfTransformer pour la normalisation. Après avoir été redirigé vers modules / generated / sklearn.feature_extraction.text.TfidfTransformer.html # sklearn.feature_extraction.text.TfidfTransformer).

>>> vec = DictVectorizer()
>>> pos_vectorized = vec.fit_transform(pos_window)
>>> pos_vectorized                
<1x6 sparse matrix of type '<... 'numpy.float64'>'
    with 6 stored elements in Compressed Sparse ... format>
>>> pos_vectorized.toarray()
array([[ 1.,  1.,  1.,  1.,  1.,  1.]])
>>> vec.get_feature_names()
['pos+1=PP', 'pos-1=NN', 'pos-2=DT', 'word+1=on', 'word-1=cat', 'word-2=the']

Comme vous pouvez l'imaginer, extraire un tel contexte autour de mots individuels dans le corpus de documents aboutit à une matrice très large (de nombreuses fonctionnalités one-hot), presque nulle. Sera. Pour stocker la structure de données résultante en mémoire, la classe DictVectorizer utilise la matrice scipy.sparse par défaut au lieu de numpy.ndarray.

4.2.2. Hachage des fonctionnalités

La classe FeatureHasher est un hachage de fonctionnalité ou "[astuce de hachage](https: //) en.wikipedia.org/wiki/Feature_hashing) est un vectoriseur rapide et à faible mémoire qui utilise une technologie connue sous le nom de. Au lieu de créer une table de conversion de valeur de fonctionnalité, FeatureHasher applique une fonction de hachage aux valeurs de fonctionnalité pour déterminer directement les numéros de colonne dans l'exemple de matrice. En conséquence, la vitesse est augmentée et l'utilisation de la mémoire est réduite au détriment de l'inspectabilité. Hasher ne se souvient pas de l'apparence des valeurs d'entités d'entrée et n'a pas la méthode ʻinverse_transform. Les fonctions de hachage peuvent provoquer des conflits entre des fonctionnalités (non pertinentes), de sorte que des fonctions de hachage signées sont utilisées et le signe de la valeur de hachage détermine le signe de la valeur stockée dans la matrice de sortie de la valeur de fonctionnalité. De cette manière, les collisions sont susceptibles d'être compensées plutôt que cumulatives, et la moyenne attendue des valeurs caractéristiques de sortie est nulle. Si non_negative = Trueest passé au constructeur, la valeur absolue sera récupérée. Cela annule une partie de la gestion des conflits, mais attend une entrée non négative [sklearn.naive_bayes.MultinomialNB](http://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.MultinomialNB. html # sklearn.naive_bayes.MultinomialNB) Estimator et [sklearn.feature_selection.chi2](http://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.chi2.html#sklearn.feature_selection.chi2) Fonctionnalités Vous pouvez transmettre la sortie à un sélecteur, etc. FeatureHasher accepte les mappages (tels que les dictées Python et leurs variantes dans le modulecollections), les paires (fonctionnalité, valeur) ou les listes de chaînes, selon le paramètre du constructeur ʻinput_type. Le mappage est traité comme une liste de (fonctionnalité, valeur), où['feat1', 'feat2', 'feat3']est[('feat1', 1), ('feat2', 1), ( Interprété comme «fonction3», 1)] ». Si une valeur de caractéristique apparaît plusieurs fois dans l'échantillon, les valeurs associées sont additionnées (ainsi('feat', 2)et('feat', 3.5)sont('feat', 5.5)). La sortie de FeatureHasher est toujours une matrice scipy.sparse de style CSR. Les hachages de fonctionnalités peuvent être utilisés pour la classification de documents, mais text.CountVectorizer, FeatureHasher n'effectue aucun fractionnement de mot ou autre prétraitement autre que l'encodage Unicode vers UTF-8. Pour la combinaison tokenization / hasher, voir [Vectoring a large text corpus using hash tricks](# 4238-% E3% 83% 8F% E3% 83% 83% E3% 82% B7% E3) % 83% A5% E3% 83% 88% E3% 83% AA% E3% 83% 83% E3% 82% AF% E3% 82% 92% E4% BD% BF% E7% 94% A8% E3% 81 % 97% E3% 81% A6% E5% A4% A7% E3% 81% 8D% E3% 81% AA% E3% 83% 86% E3% 82% AD% E3% 82% B9% E3% 83% 88 % E3% 82% B3% E3% 83% BC% E3% 83% 91% E3% 82% B9% E3% 82% 92% E3% 83% 99% E3% 82% AF% E3% 83% 88% E3 Voir% 83% AB% E5% 8C% 96% E3% 81% 99% E3% 82% 8B). À titre d'exemple, considérons une tâche de traitement du langage naturel au niveau du mot qui nécessite des fonctionnalités extraites d'une paire (token, part_of_speech). Vous pouvez utiliser les fonctions du générateur Python pour extraire des fonctionnalités:

def token_features(token, part_of_speech):
    if token.isdigit():
        yield "numeric"
    else:
        yield "token={}".format(token.lower())
        yield "token,pos={},{}".format(token, part_of_speech)
    if token[0].isupper():
        yield "uppercase_initial"
    if token.isupper():
        yield "all_uppercase"
    yield "pos={}".format(part_of_speech)

Ensuite, le raw_X fourni à FeatureHasher.transform peut être construit en utilisant:

 raw_X = (token_features(tok, pos_tagger(tok)) for tok in corpus)

Il est fourni à la laveuse comme suit.

hasher = FeatureHasher(input_type='string')
X = hasher.transform(raw_X)

Récupérez la matrice scipy.sparse X`. Notez le générateur qui facilite l'extraction des fonctionnalités. Les jetons ne sont traités que sur demande de Hasher.

4.2.2.1. Détails de mise en œuvre

FeatureHasher utilise une version 32 bits signée de MurmurHash3. En conséquence (et en raison des limitations de scipy.sparse), le nombre maximum de fonctionnalités actuellement prises en charge est de 2 $ ^ {31} -1 $. Dans la formulation originale de l'astuce de hachage de Weinberger et al., Deux fonctions de hachage distinctes $ h $ et $ \ xi $ ont été utilisées pour déterminer respectivement le numéro de colonne et le signe des valeurs des caractéristiques. L'implémentation actuelle fonctionne sur l'hypothèse que les bits de code MurmurHash3 sont indépendants des autres bits. Il est recommandé d'utiliser une puissance de 2 comme paramètre n_features, car il utilise simplement le reste de la division pour convertir la fonction de hachage en un numéro de colonne. Sinon, les valeurs des caractéristiques ne seront pas mappées uniformément.

--Référence: --Killian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, Josh Attenberg (2009) Functional Hashing for Large-Scale Multitasking Learning Proc. ICML. - MurmurHash3

4.2.3. Extraction d'entités de texte

4.2.3.1. Représentation par sac de mots

L'analyse de texte est une application majeure des algorithmes d'apprentissage automatique. Cependant, les données brutes ne peuvent pas fournir un ensemble de symboles directement à l'algorithme lui-même. Parce que la plupart d'entre eux attendent des vecteurs d'entités numériques de taille fixe plutôt que des documents texte brut de longueur variable. Pour résoudre ce problème, scicit-learn fournit un utilitaire de la manière la plus courante pour extraire des caractéristiques numériques d'un contenu textuel.

• Donnez un identifiant entier pour chaque jeton possible, comme la création de jetons d'une chaîne et l'utilisation d'espaces et de ponctuation comme séparateurs de jetons.
• Comptez l'apparence des jetons dans chaque document.
• Normaliser et pondérer en utilisant des jetons moins importants qui se produisent dans la majorité des échantillons / documents.

Dans ce schéma, les fonctionnalités et les exemples sont définis comme suit:

• La fréquence d'apparition des jetons individuels est traitée comme une quantité de caractéristiques (peut ou non être normalisée). --Un vecteur de toutes les fréquences de jeton dans un document donné est considéré comme un échantillon multivarié.

Ainsi, un corpus d'un document peut être représenté par une matrice avec une ligne par document et une colonne pour chaque jeton (par exemple, mot) qui apparaît dans le corpus. La vectorisation est le processus général de conversion d'un ensemble de documents texte en un vecteur de caractéristiques numériques. Cette stratégie particulière (tokenisation, comptage, normalisation) est appelée le Sac de Mots ou représentation «Sac de n-grammes». Le document est décrit par le nombre d'occurrences du mot, ignorant complètement les informations de position relative du mot dans le document.

4.2.3.2. Clairsemé

La plupart des documents n'utilisent que quelques-uns des mots couramment utilisés dans les corpus, de sorte que la matrice résultante contient de nombreuses valeurs de caractéristiques nulles (généralement 99% ou plus). Par exemple, un ensemble de 10 000 documents courts (comme le courrier électronique) utilise un total de 100 000 ordres de vocabulaire et chaque document utilise de 100 à 1 000 mots uniques. En plus de pouvoir stocker de telles matrices en mémoire, les implémentations utilisent généralement une représentation éparse du package scipy.sparse pour accélérer les matrices / vecteurs algébriques.

4.2.3.3. Comment utiliser le vectoriseur commun

CountVectorizer fournit à la fois la tokenisation et le décompte des occurrences. Il est implémenté dans une classe.

>>> from sklearn.feature_extraction.text import CountVectorizer

Il existe de nombreux paramètres dans ce modèle, mais les valeurs par défaut sont très raisonnables (voir la documentation de référence (http://scikit-learn.org/stable/modules/classes.html#text-feature-extraction- pour plus d'informations). ref)) ::

>>> vectorizer = CountVectorizer(min_df=1)
>>> vectorizer                     
CountVectorizer(analyzer=...'word', binary=False, decode_error=...'strict',
        dtype=<... 'numpy.int64'>, encoding=...'utf-8', input=...'content',
        lowercase=True, max_df=1.0, max_features=None, min_df=1,
        ngram_range=(1, 1), preprocessor=None, stop_words=None,
        strip_accents=None, token_pattern=...'(?u)\\b\\w\\w+\\b',
        tokenizer=None, vocabulary=None)

Utilisez-le pour tokeniser et compter l'occurrence de mots dans le corpus minimal de documents texte.

>>> corpus = [
...     'This is the first document.',
...     'This is the second second document.',
...     'And the third one.',
...     'Is this the first document?',
... ]
>>> X = vectorizer.fit_transform(corpus)
>>> X                              
<4x9 sparse matrix of type '<... 'numpy.int64'>'
    with 19 stored elements in Compressed Sparse ... format>

Le paramètre par défaut consiste à extraire les mots de deux caractères ou plus et à tokeniser la chaîne. La fonction spécifique qui effectue cette étape peut être explicitement demandée.

>>> analyze = vectorizer.build_analyzer()
>>> analyze("This is a text document to analyze.") == (
...     ['this', 'is', 'text', 'document', 'to', 'analyze'])
True

Chaque terme détecté par l'analyseur lors de l'ajustement se voit attribuer un index entier unique qui correspond à la colonne de la matrice résultante. Vous pouvez obtenir l'interprétation de cette colonne comme suit:

>>> vectorizer.get_feature_names() == (
...     ['and', 'document', 'first', 'is', 'one',
...      'second', 'the', 'third', 'this'])
True

>>> X.toarray()           
array([[0, 1, 1, 1, 0, 0, 1, 0, 1],
       [0, 1, 0, 1, 0, 2, 1, 0, 1],
       [1, 0, 0, 0, 1, 0, 1, 1, 0],
       [0, 1, 1, 1, 0, 0, 1, 0, 1]]...)

Le mappage inversé des valeurs de caractéristiques aux index de colonne est stocké dans l'attribut vocabulary_ du vectoriseur.

>>> vectorizer.vocabulary_.get('document')
1

Par conséquent, les mots non trouvés dans le corpus d'apprentissage seront complètement ignorés lors des futurs appels à la méthode de conversion.

>>> vectorizer.transform(['Something completely new.']).toarray()
...                           
array([[0, 0, 0, 0, 0, 0, 0, 0, 0]]...)

Notez que dans le corpus précédent, le premier et le dernier documents ont exactement les mêmes mots et sont codés avec un vecteur d'égalité. En particulier, vous perdez l'information selon laquelle le dernier document est au format question. Pour stocker les informations de commande, vous pouvez extraire 2 grammes de mots en plus de 1 gramme (mots individuels).

>>> bigram_vectorizer = CountVectorizer(ngram_range=(1, 2),
...                                     token_pattern=r'\b\w+\b', min_df=1)
>>> analyze = bigram_vectorizer.build_analyzer()
>>> analyze('Bi-grams are cool!') == (
...     ['bi', 'grams', 'are', 'cool', 'bi grams', 'grams are', 'are cool'])
True

Le vocabulaire extrait par ce vectoriseur est beaucoup plus large et peut résoudre l'ambiguïté des informations de position d'ordre des mots une fois codées.

>>>
>>> X_2 = bigram_vectorizer.fit_transform(corpus).toarray()
>>> X_2
...                           
array([[0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0],
       [0, 0, 1, 0, 0, 1, 1, 0, 0, 2, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0],
       [1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1]]...)

Plus précisément, la phrase de question "Est-ce que c'est" n'existe que dans le dernier document.

>>> feature_index = bigram_vectorizer.vocabulary_.get('is this')
>>> X_2[:, feature_index]     
array([0, 0, 0, 1]...)

4.2.3.4. Pondération Tf-idf

Dans un corpus de texte volumineux, il y a tellement de mots (par exemple, "the", "a", "is" en anglais) qu'ils ont peu d'informations significatives sur le contenu du document. Fournir des informations de fréquence directement au classifieur masque la fréquence des termes rares mais intéressants pour les termes très fréquemment utilisés. Il est très courant d'utiliser la transformation tf-idf pour rendre les informations de fréquence adaptées au classificateur. Tf-idf signifie le nombre de mots apparaissant (tf) et le nombre inverse de phrases apparaissant (idf), et $ \ text {tf-idf (t, d)} = \ text {tf (t, d)} \ fois \ texte {idf (t)} $. Le paramètre par défaut pour TfidfTransformer`` TfidfTransformer (norm = 'l2', use_idf = True, smooth_idf = True, sublinear_tf = False) La fréquence des mots, le nombre de fois qu'un mot apparaît dans un document donné, est multipliée par la composante IDF calculée comme suit:

\text{idf}(t) = log{\frac{1 + n_d}{1+\text{df}(d,t)}} + 1

Où $ n_d $ est le nombre total de documents et $ \ text {df} (d, t) $ est le nombre de documents contenant le mot $ t $. Le vecteur tf-idf résultant est normalisé par la norme euclidienne.

v_{norm} = \frac{v}{||v||_2} ＝ \frac{v}{\sqrt{v{\_1}^2 + v{\_2}^2 + \dots + v{\_n}^2}}

Il s'agissait à l'origine d'une méthode de pondération des mots (fonction de classement des résultats de recherche des moteurs de recherche) développée pour la recherche d'informations, qui est souvent utilisée dans la classification et le regroupement de documents. Dans la section ci-dessous, comment exactement tf-idfs est calculé, [TfidfTransformer] de scikit-learn (http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfTransformer.html Calculé avec # sklearn.feature_extraction.text.TfidfTransformer) et TfidfVectorizer Montre si le tf-idfs donné est un peu différent de la notation standard du manuel qui définit idf comme suit:

\text{idf}(t) = log{\frac{n_d}{1+\text{df}(d,t)}}

Dans TfidfTransformer et TfidfVectorizer, smooth_idf = False ajoute" 1 "à idf au lieu du dénominateur de idf.

\text{idf}(t) = log{\frac{n_d}{\text{df}(d,t)}} + 1

Cette normalisation est implémentée par la classe TfidfTransformer.

>>> from sklearn.feature_extraction.text import TfidfTransformer
>>> transformer = TfidfTransformer(smooth_idf=False)
>>> transformer   
TfidfTransformer(norm=...'l2', smooth_idf=False, sublinear_tf=False,
                 use_idf=True)

Encore une fois, consultez la documentation de référence (http://scikit-learn.org/stable/modules/classes.html#text-feature-extraction-ref) pour plus d'informations sur tous les paramètres. Prenons l'exemple suivant. Le taux d'apparition du premier mot est de 100%, ce qui n'est pas très intéressant. Le taux d'apparition des deux autres fonctionnalités est inférieur à 50%, ce qui représente probablement mieux le contenu du document.

>>> counts = [[3, 0, 1],
...           [2, 0, 0],
...           [3, 0, 0],
...           [4, 0, 0],
...           [3, 2, 0],
...           [3, 0, 2]]
...
>>> tfidf = transformer.fit_transform(counts)
>>> tfidf                         
<6x3 sparse matrix of type '<... 'numpy.float64'>'
    with 9 stored elements in Compressed Sparse ... format>

>>> tfidf.toarray()                        
array([[ 0.81940995,  0.        ,  0.57320793],
       [ 1.        ,  0.        ,  0.        ],
       [ 1.        ,  0.        ,  0.        ],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.47330339,  0.88089948,  0.        ],
       [ 0.58149261,  0.        ,  0.81355169]])

Chaque ligne est normalisée pour avoir une unité standard euclidienne:

v\_{norm} = \frac{v}{||v||\_2} = \frac{v}{\sqrt{v{\_1}^2 + v{\_2}^2 + \dots + v{_n}^2}}

Par exemple, vous pouvez calculer tf-idf dans le premier terme du premier document dans le tableau des nombres comme suit:

n_{d, {\text{term1}}} = 6  \\
\text{df}(d, t)_{\text{term1}} = 6  \\
\text{idf}(d, t)_{\text{term1}} = log \frac{n_d}{\text{df}(d, t)} + 1 = log(1)+1 = 1  \\
\text{tf-idf}_{\text{term1}} = \text{tf} \times \text{idf} = 3 \times 1 = 3

La répétition de ce calcul pour les deux autres termes du document donne:

\text{tf-idf}_{\text{term2}} = 0 \times log(6/1)+1 = 0 \\
\text{tf-idf}_{\text{term3}} = 1 \times log(6/2)+1 \approx 2.0986

Vecteur tf-idfs brut:

\text{tf-idf}_raw = [3, 0, 2.0986]

Ensuite, l'application de la norme euclidienne (L2) donne les tf-idfs suivants pour le document 1.

\frac{[3, 0, 2.0986]}{\sqrt{\big(3^2 + 0^2 + 2.0986^2\big)}}
= [ 0.819,  0,  0.573]

De plus, le paramètre par défaut smooth_idf = True ajoute un" 1 "à la molécule et au dénominateur. Il semble que le document supplémentaire contienne exactement une fois pour chaque terme de la collection. Empêche zéro pour cent.

\text{idf}(t) = log{\frac{1 + n_d}{1+\text{df}(d,t)}} + 1

En utilisant ce changement, le tf-idf dans la section 3 du document 1 est changé en 1.8473.

\text{tf-idf}_{\text{term3}} = 1 \times log(7/3)+1 \approx 1.8473

Et le tf-idf normalisé L2

\frac{[3, 0, 1.8473]}{\sqrt{\big(3^2 + 0^2 + 1.8473^2\big)}} = [0.8515, 0, 0.5243]

>>> transformer = TfidfTransformer()
>>> transformer.fit_transform(counts).toarray()
array([[ 0.85151335,  0.        ,  0.52433293],
       [ 1.        ,  0.        ,  0.        ],
       [ 1.        ,  0.        ,  0.        ],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.55422893,  0.83236428,  0.        ],
       [ 0.63035731,  0.        ,  0.77630514]])

Le poids de chaque entité calculé par l'appel de méthode «fit» est stocké dans l'attribut model.

>>> transformer.idf_                       
array([ 1. ...,  2.25...,  1.84...])

Puisque tf-idf est si populaire pour les fonctions de texte, il existe une autre classe appelée TfidfVectorizer qui combine toutes les options de CountVectorizer et TfidfTransformer dans un seul modèle:

>>> from sklearn.feature_extraction.text import TfidfVectorizer
>>> vectorizer = TfidfVectorizer(min_df=1)
>>> vectorizer.fit_transform(corpus)
...                                
<4x9 sparse matrix of type '<... 'numpy.float64'>'
    with 19 stored elements in Compressed Sparse ... format>

La normalisation TF-IDF est souvent très utile, mais il peut y avoir des exemples où les marqueurs de génération binaire fournissent de meilleures fonctionnalités. Ceci peut être réalisé en utilisant le paramètre binary de CountVectorizer. En particulier, des estimateurs tels que Bernoulli Naive Bayes modélisent explicitement des variables probabilistes booléennes discrètes. .. De plus, un texte très court peut être bruyant avec tf-idf, tandis que les informations de génération binaire sont plus stables. Comme toujours, la meilleure façon d'ajuster les paramètres d'extraction d'entités est d'utiliser une recherche de grille à validation croisée, par exemple, en pipelinant l'extracteur d'entités avec un classificateur.

• [Exemple de pipeline pour l'extraction et l'évaluation des fonctionnalités de texte](http://scikit-learn.org/stable/auto_examples/model_selection/grid_search_text_feature_extraction.html#sphx-glr-auto-examples-model-selection-grid- search-text-feature-extraction-py)

4.2.3.5. Décodage des fichiers texte

Le texte est composé de lettres, mais le fichier est composé d'octets. Ces octets représentent des caractères selon un certain codage. Pour travailler avec un fichier texte en Python, vous devez décoder cet octet en un jeu de caractères appelé Unicode. Les codages courants sont ASCII, Latin-1 (Europe occidentale), KOI8-R (russe), codages universels UTF-8 et UTF-16. Il y en a beaucoup d'autres.

>>> import chardet    
>>> text1 = b"Sei mir gegr\xc3\xbc\xc3\x9ft mein Sauerkraut"
>>> text2 = b"holdselig sind deine Ger\xfcche"
>>> text3 = b"\xff\xfeA\x00u\x00f\x00 \x00F\x00l\x00\xfc\x00g\x00e\x00l\x00n\x00 \x00d\x00e\x00s\x00 \x00G\x00e\x00s\x00a\x00n\x00g\x00e\x00s\x00,\x00 \x00H\x00e\x00r\x00z\x00l\x00i\x00e\x00b\x00c\x00h\x00e\x00n\x00,\x00 \x00t\x00r\x00a\x00g\x00 \x00i\x00c\x00h\x00 \x00d\x00i\x00c\x00h\x00 \x00f\x00o\x00r\x00t\x00"
>>> decoded = [x.decode(chardet.detect(x)['encoding'])
...            for x in (text1, text2, text3)]        
>>> v = CountVectorizer().fit(decoded).vocabulary_    
>>> for term in v: print(v)                           

>>> ngram_vectorizer = CountVectorizer(analyzer='char_wb', ngram_range=(2, 2), min_df=1)
>>> counts = ngram_vectorizer.fit_transform(['words', 'wprds'])
>>> ngram_vectorizer.get_feature_names() == (
...     [' w', 'ds', 'or', 'pr', 'rd', 's ', 'wo', 'wp'])
True
>>> counts.toarray().astype(int)
array([[1, 1, 1, 0, 1, 1, 1, 0],
       [1, 1, 0, 1, 1, 1, 0, 1]])

>>>
>>> ngram_vectorizer = CountVectorizer(analyzer='char_wb', ngram_range=(5, 5), min_df=1)
>>> ngram_vectorizer.fit_transform(['jumpy fox'])
...                                
<1x4 sparse matrix of type '<... 'numpy.int64'>'
   with 4 stored elements in Compressed Sparse ... format>
>>> ngram_vectorizer.get_feature_names() == (
...     [' fox ', ' jump', 'jumpy', 'umpy '])
True

>>> ngram_vectorizer = CountVectorizer(analyzer='char', ngram_range=(5, 5), min_df=1)
>>> ngram_vectorizer.fit_transform(['jumpy fox'])
...                                
<1x5 sparse matrix of type '<... 'numpy.int64'>'
    with 5 stored elements in Compressed Sparse ... format>
>>> ngram_vectorizer.get_feature_names() == (
...     ['jumpy', 'mpy f', 'py fo', 'umpy ', 'y fox'])
True

>>> from sklearn.feature_extraction.text import HashingVectorizer
>>> hv = HashingVectorizer(n_features=10)
>>> hv.transform(corpus)
...                                
<4x10 sparse matrix of type '<... 'numpy.float64'>'
    with 16 stored elements in Compressed Sparse ... format>

>>> hv = HashingVectorizer()
>>> hv.transform(corpus)
...                               
<4x1048576 sparse matrix of type '<... 'numpy.float64'>'
    with 19 stored elements in Compressed Sparse ... format>
>>>

>>> def my_tokenizer(s):
...     return s.split()
...
>>> vectorizer = CountVectorizer(tokenizer=my_tokenizer)
>>> vectorizer.build_analyzer()(u"Some... punctuation!") == (
...     ['some...', 'punctuation!'])
True

>>> from nltk import word_tokenize          
>>> from nltk.stem import WordNetLemmatizer 
>>> class LemmaTokenizer(object):
...     def __init__(self):
...         self.wnl = WordNetLemmatizer()
...     def __call__(self, doc):
...         return [self.wnl.lemmatize(t) for t in word_tokenize(doc)]
...
>>> vect = CountVectorizer(tokenizer=LemmaTokenizer()) 

>>> import numpy as np
>>> from sklearn.feature_extraction import image

>>> one_image = np.arange(4 * 4 * 3).reshape((4, 4, 3))
>>> one_image[:, :, 0]  # R channel of a fake RGB picture
array([[ 0,  3,  6,  9],
       [12, 15, 18, 21],
       [24, 27, 30, 33],
       [36, 39, 42, 45]])

>>> patches = image.extract_patches_2d(one_image, (2, 2), max_patches=2,
...     random_state=0)
>>> patches.shape
(2, 2, 2, 3)
>>> patches[:, :, :, 0]
array([[[ 0,  3],
        [12, 15]],

       [[15, 18],
        [27, 30]]])
>>> patches = image.extract_patches_2d(one_image, (2, 2))
>>> patches.shape
(9, 2, 2, 3)
>>> patches[4, :, :, 0]
array([[15, 18],
       [27, 30]])

>>> reconstructed = image.reconstruct_from_patches_2d(patches, (4, 4, 3))
>>> np.testing.assert_array_equal(one_image, reconstructed)

>>> five_images = np.arange(5 * 4 * 4 * 3).reshape(5, 4, 4, 3)
>>> patches = image.PatchExtractor((2, 2)).transform(five_images)
>>> patches.shape
(45, 2, 2, 3)