4.2.1 Laden von Funktionen aus Diktaten

Die Klasse DictVectorizer ist eine Feature-Menge, die als Liste von Standard-Python-Dikt-Objekten dargestellt wird. Es kann verwendet werden, um ein Array in die NumPy / SciPy-Darstellung zu konvertieren, die vom Scikit-Learn-Schätzer verwendet wird. Obwohl Pythons Diktat nicht besonders schnell ist, bietet es den Vorteil, dass es einfach zu verwenden, spärlich ist (keine Notwendigkeit, nicht vorhandene Features zu speichern) und neben Werten auch Feature-Namen speichern kann. DictVectorizer implementiert eine Eins-zu-Eins-Codierung oder eine "One-Hot" -Codierung für Kategorien (oder diskrete Nennwerte). Kategorieattribute sind "Attribut-Wert" -Paare, die auf eine ungeordnete Liste diskreter Werte (Themenkennungen, Objekttypen, Tags, Namen usw.) beschränkt sind. Im Folgenden ist "Stadt" ein Kategorieattribut und "Temperatur" eine herkömmliche numerische Merkmalsgröße.

>>> 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 ist eine nützliche Ausdruckstransformation zum Trainieren von Satzklassifizierern in Modellen zur Verarbeitung natürlicher Sprache (normalerweise Extrahieren von Merkmalen um ein bestimmtes interessierendes Wort). Angenommen, Sie haben einen ersten Algorithmus, der Teilwort-Tags (PoS) aus einem Satz extrahiert. Das folgende Diktat ist ein solches Merkmal, das aus dem Wort "saß" im Satz "Die Katze saß auf der Matte" extrahiert wurde.

>>> pos_window = [
...     {
...         'word-2': 'the',
...         'pos-2': 'DT',
...         'word-1': 'cat',
...         'pos-1': 'NN',
...         'word+1': 'on',
...         'pos+1': 'PP',
...     },
...     #In einer realen Anwendung werden Sie viele solcher Diktate extrahieren
... ]

Diese Daten können in eine spärliche zweidimensionale Matrix vektorisiert werden, die zum Zuführen des Klassifikators (text.TfidfTransformer zur Normalisierung geeignet ist. Nach dem Weiterleiten an modules / generate / 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']

Wie Sie sich vorstellen können, führt das Extrahieren eines solchen Kontexts um einzelne Wörter im Dokumentenkorpus zu einer sehr breiten Matrix (viele One-Hot-Features), fast Null. Wird sein. Um die resultierende Datenstruktur im Speicher zu speichern, verwendet die Klasse "DictVectorizer" standardmäßig die Matrix "scipy.sparse" anstelle von "numpy.ndarray".

4.2.2. Feature-Hash

Die Klasse FeatureHasher ist ein Feature-Hash oder "[Hashing-Trick](https: //) en.wikipedia.org/wiki/Feature_hashing) ist ein schneller Vektorisierer mit wenig Speicher, der eine Technologie verwendet, die als bekannt ist. Anstatt eine Feature-Value-Konvertierungstabelle zu erstellen, wendet FeatureHasher eine Hash-Funktion auf die Feature-Werte an, um die Spaltennummern in der Beispielmatrix direkt zu bestimmen. Infolgedessen wird die Geschwindigkeit erhöht und die Speichernutzung auf Kosten der Überprüfbarkeit verringert. Hasher erinnert sich nicht an das Auftreten von Eingabemerkmalwerten und verfügt nicht über eine "inverse_transform" -Methode. Hash-Funktionen können Konflikte zwischen (irrelevanten) Features verursachen. Daher werden signierte Hash-Funktionen verwendet, und das Vorzeichen des Hash-Werts bestimmt das Vorzeichen des in der Feature-Wert-Ausgabematrix gespeicherten Werts. Auf diese Weise werden Kollisionen wahrscheinlich eher ausgeglichen als kumuliert, und der erwartete Durchschnitt der Ausgangscharakteristikwerte ist Null. Wenn "non_negative = True" an den Konstruktor übergeben wird, wird der absolute Wert abgerufen. Dies macht einen Teil der Konfliktbehandlung rückgängig, erwartet jedoch nicht negative Eingaben sklearn.naive_bayes.MultinomialNB. html # sklearn.naive_bayes.MultinomialNB) Estimator und sklearn.feature_selection.chi2 Features Sie können die Ausgabe an einen Selektor usw. übergeben. FeatureHasher akzeptiert Zuordnungen (wie Pythons Diktat und seine Varianten im Modul "Sammlungen"), "(Feature, Wert)" Paare oder Listen von Zeichenfolgen, abhängig vom Konstruktorparameter "input_type". Die Zuordnung wird als Liste von "(Merkmal, Wert)" behandelt, wobei "[" feat1 "," feat2 "," feat3 "]" [("feat1", 1), ("feat2", 1), ( Interpretiert als "feat3", 1)] ". Wenn ein Merkmalswert im Beispiel mehrmals vorkommt, werden die zugehörigen Werte summiert (also sind "(" feat ", 2)" und "(" feat ", 3.5)" "(" feat ", 5.5)" ) . Die Ausgabe von FeatureHasher ist immer eine scipy.sparse Matrix im CSR-Stil. Feature-Hashes können für die Dokumentklassifizierung verwendet werden, aber text.CountVectorizer, FeatureHasher führt keine andere Wortaufteilung oder andere Vorverarbeitung als die Unicode-zu-UTF-8-Codierung durch. Informationen zur Tokenisierung / Hasher-Kombination finden Sie unter [Vektorisieren eines großen Textkorpus mithilfe von 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 Siehe% 83% AB% E5% 8C% 96% E3% 81% 99% E3% 82% 8B). Stellen Sie sich als Beispiel eine Aufgabe zur Verarbeitung natürlicher Sprache auf Wortebene vor, für die Features erforderlich sind, die aus einem Paar (Token, part_of_speech) extrahiert wurden. Sie können Python-Generatorfunktionen verwenden, um Funktionen zu extrahieren:

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)

Dann kann das an FeatureHasher.transform gelieferte "raw_X" erstellt werden mit:

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

Es wird der Waschmaschine wie folgt zugeführt.

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

Holen Sie sich die scipy.sparse Matrix X. Beachten Sie den Generator, der das Extrahieren von Features erleichtert. Token werden nur auf Anfrage von Hasher verarbeitet.

4.2.2.1. Implementierungsdetails

FeatureHasher verwendet eine signierte 32-Bit-Version von MurmurHash3. Infolgedessen (und aufgrund der Einschränkungen von scipy.sparse) wird derzeit maximal $ 2 ^ {31} -1 $ unterstützt. In der ursprünglichen Hashing-Trick-Formulierung von Weinberger et al. Wurden zwei separate Hash-Funktionen $ h $ und $ \ xi $ verwendet, um die Spaltennummer bzw. das Vorzeichen der Merkmalswerte zu bestimmen. Die aktuelle Implementierung geht davon aus, dass die MurmurHash3-Codebits unabhängig von den anderen Bits sind. Es wird empfohlen, eine Potenz von 2 als Parameter "n_features" zu verwenden, da einfach der Rest der Division verwendet wird, um die Hash-Funktion in eine Spaltennummer zu konvertieren. Andernfalls werden die Feature-Werte nicht gleichmäßig zugeordnet.

--Referenz:

• Killian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, Josh Attenberg (2009) (http://alex.smola.org/papers/2009/Weinbergeretal09.pdf) Proc. ICML.
  • MurmurHash3

4.2.3. Extraktion von Textfunktionen

4.2.3.1. Darstellung durch Wortbeutel

Die Textanalyse ist eine Hauptanwendung von Algorithmen für maschinelles Lernen. In Rohdaten kann der Satz von Symbolen jedoch nicht direkt an den Algorithmus selbst geliefert werden. Da die meisten von ihnen numerische Merkmalsvektoren mit fester Größe anstelle von Rohtextdokumenten mit variabler Länge erwarten. Um dies zu beheben, bietet scicit-learn auf die gängigste Weise ein Dienstprogramm zum Extrahieren numerischer Merkmale aus Textinhalten.

• Geben Sie für jedes mögliche Token eine Ganzzahl-ID an, z. B. das Tokenisieren einer Zeichenfolge und die Verwendung von Leerzeichen und Satzzeichen als Token-Trennzeichen. --Zählen Sie das Erscheinungsbild von Token in jedem Dokument.
• Normalisieren und gewichten Sie mit weniger wichtigen Token, die in den meisten Proben / Dokumenten vorkommen.

In diesem Schema werden Merkmale und Beispiele wie folgt definiert:

• Die Häufigkeit des Auftretens einzelner Token wird als Merkmalsmenge behandelt (kann normalisiert werden oder nicht).
• Ein Vektor aller Tokenfrequenzen in einem bestimmten Dokument wird als multivariate Stichprobe betrachtet.

Somit kann ein Korpus eines Dokuments durch eine Matrix mit einer Zeile pro Dokument und einer Spalte für jedes Token (z. B. Wort) dargestellt werden, das im Korpus erscheint. Die Vektorisierung ist der allgemeine Prozess zum Konvertieren eines Satzes von Textdokumenten in einen numerischen Merkmalsvektor. Diese spezielle Strategie (Tokenisierung, Zählen, Normalisierung) wird als Bag of Words- oder "Bag of n-Gramm" -Darstellung bezeichnet. Das Dokument wird durch die Anzahl der Vorkommen des Wortes beschrieben, wobei die relativen Positionsinformationen des Wortes im Dokument vollständig ignoriert werden.

4.2.3.2. Spärlich

Die meisten Dokumente verwenden nur einige der in Korpora gebräuchlichen Wörter, sodass die resultierende Matrix viele Null-Merkmalswerte (normalerweise 99% oder mehr) enthält. Beispielsweise verwendet ein Satz von 10.000 kurzen Dokumenten (z. B. E-Mail) insgesamt 100.000 Wortschatzreihenfolgen, und jedes Dokument verwendet 100 bis 1000 eindeutige Wörter. Implementierungen können solche Matrizen nicht nur im Speicher speichern, sondern verwenden normalerweise auch eine spärliche Darstellung des Pakets "scipy.sparse", um algebraische Matrizen / Vektoren zu beschleunigen.

4.2.3.3 Verwendung des allgemeinen Vektorisierers

CountVectorizer bietet sowohl Tokenisierung als auch Anzahl der Vorkommen. Es ist in einer Klasse implementiert.

>>> from sklearn.feature_extraction.text import CountVectorizer

Es gibt viele Parameter in diesem Modell, aber die Standardwerte sind sehr vernünftig (weitere Informationen finden Sie in der Referenzdokumentation (http://scikit-learn.org/stable/modules/classes.html#text-feature-extraction-). 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)

Verwenden Sie diese Option, um das Auftreten von Wörtern im minimalen Korpus von Textdokumenten zu tokenisieren und zu zählen.

>>> 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>

Die Standardeinstellung ist das Extrahieren von Wörtern mit zwei oder mehr Zeichen und das Tokenisieren der Zeichenfolge. Die spezifische Funktion, die diesen Schritt ausführt, kann explizit angefordert werden.

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

Jedem vom Analysator während der Anpassung erkannten Term wird ein eindeutiger ganzzahliger Index zugewiesen, der der Spalte der resultierenden Matrix entspricht. Sie können die Interpretation dieser Spalte wie folgt erhalten:

>>> 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]]...)

Die umgekehrte Zuordnung von Merkmalswerten zu Spaltenindizes wird im Attribut vocabulary_ des Vektorisierers gespeichert.

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

Daher werden Wörter, die nicht im Trainingskorpus enthalten sind, bei zukünftigen Aufrufen der Konvertierungsmethode vollständig ignoriert.

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

Beachten Sie, dass im vorherigen Korpus das erste und das letzte Dokument genau dieselben Wörter haben und mit einem Gleichheitsvektor codiert sind. Insbesondere verlieren Sie die Information, dass das letzte Dokument im fraglichen Format vorliegt. Um Bestellinformationen zu speichern, können Sie zusätzlich zu 1 Gramm (einzelne Wörter) 2 Gramm Wörter extrahieren.

>>> 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

Das von diesem Vektorisierer extrahierte Vokabular ist viel größer und kann die Mehrdeutigkeit von Positionsinformationen der Wortreihenfolge beim Codieren auflösen.

>>>
>>> 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]]...)

Insbesondere existiert der Fragensatz "Ist dies" nur im letzten Dokument.

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

4.2.3.4. Tf-idf-Gewichtung

In einem großen Textkorpus gibt es so viele Wörter (z. B. "the", "a", "is" auf Englisch), die wenig aussagekräftige Informationen über den Inhalt des Dokuments enthalten. Durch die direkte Bereitstellung von Frequenzinformationen für den Klassifizierer wird die Häufigkeit seltener, aber interessanter Begriffe für sehr häufig verwendete Begriffe ausgeblendet. Es ist sehr üblich, die tf-idf-Transformation zu verwenden, um die Frequenzinformationen für den Klassifizierer geeignet zu machen. Tf-idf bedeutet die Anzahl der Wortvorkommen (tf) und die umgekehrte Anzahl der Erscheinungssätze (idf) und $ \ text {tf-idf (t, d)} = \ text {tf (t, d)} \ times \ text {idf (t)} $. Die Standardeinstellung für TfidfTransformer`` TfidfTransformer (norm = 'l2', use_idf = True, glatt_idf = True, sublinear_tf = False) Die Worthäufigkeit, die Häufigkeit, mit der ein Wort in einem bestimmten Dokument vorkommt, wird mit der IDF-Komponente multipliziert, die wie folgt berechnet wird:

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

Dabei ist $ n_d $ die Gesamtzahl der Dokumente und $ \ text {df} (d, t) $ die Anzahl der Dokumente, die das Wort $ t $ enthalten. Der resultierende tf-idf-Vektor wird durch die euklidische Norm normalisiert.

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

Dies war ursprünglich eine Wortgewichtungsmethode (Suchmaschinen-Suchergebnis-Ranking-Funktion), die für das Abrufen von Informationen entwickelt wurde und häufig bei der Klassifizierung und Clusterbildung von Dokumenten verwendet wird. Wie genau tf-idfs berechnet wird, erfahren Sie im folgenden Abschnitt unter [TfidfTransformer] von scikit-learn (http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfTransformer.html) Berechnet mit # sklearn.feature_extraction.text.TfidfTransformer) und TfidfVectorizer. Zeigt an, ob sich die angegebenen tf-idfs ein wenig von der Standard-Lehrbuchnotation unterscheiden, die idf wie folgt definiert:

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

In TfidfTransformer und TfidfVectorizer fügt glatt_idf = False idf anstelle des Nenners von idf" 1 "hinzu.

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

Diese Normalisierung wird von der TfidfTransformer-Klasse implementiert.

>>> 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)

Weitere Informationen zu allen Parametern finden Sie im Referenzdokument (http://scikit-learn.org/stable/modules/classes.html#text-feature-extraction-ref). Betrachten Sie das folgende Beispiel. Die Erscheinungsrate des ersten Wortes beträgt 100%, was nicht sehr interessant ist. Die Erscheinungsrate der beiden anderen Features beträgt weniger als 50%, was wahrscheinlich den Inhalt des Dokuments besser darstellt.

>>> 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]])

Jede Zeile ist normalisiert, um einen einheitlichen euklidischen Standard zu haben:

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

Beispielsweise können Sie tf-idf im ersten Term des ersten Dokuments im Zählarray wie folgt berechnen:

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

Das Wiederholen dieser Berechnung für die verbleibenden zwei Begriffe im Dokument ergibt:

\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

Roher tf-idfs-Vektor:

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

Als nächstes ergibt die Anwendung der euklidischen (L2) Norm die folgenden tf-idfs für Dokument 1.

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

Zusätzlich fügt der Standardparameter "glatt_idf = wahr" dem Molekül und dem Nenner eine "1" hinzu. Es sieht so aus, als ob das zusätzliche Dokument für jeden Begriff in der Sammlung genau einmal enthält. Verhindert null Prozent.

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

Mit dieser Änderung wird die tf-idf in Abschnitt 3 von Dokument 1 in 1.8473 geändert.

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

Und der L2 normalisierte tf-idf

\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]])

Das Gewicht jedes durch den Methodenaufruf "fit" berechneten Features wird im Modellattribut gespeichert.

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

Da tf-idf für Textfunktionen so beliebt ist, gibt es eine andere Klasse namens TfidfVectorizer, die alle Optionen von CountVectorizer und TfidfTransformer in einem einzigen Modell kombiniert:

>>> 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>

Die TF-IDF-Normalisierung ist oft sehr nützlich, aber es kann Beispiele geben, bei denen binäre Generierungsmarker bessere Funktionen bieten. Dies kann mithilfe des binären Parameters des CountVectorizers erreicht werden. Insbesondere Schätzer wie Bernoulli Naive Bayes modellieren explizit diskrete boolesche probabilistische Variablen. .. Außerdem kann sehr kurzer Text mit tf-idf verrauscht sein, während Informationen zur binären Generierung stabiler sind. Wie immer besteht die beste Möglichkeit zum Anpassen von Merkmalsextraktionsparametern darin, eine kreuzvalidierte Rastersuche zu verwenden, indem beispielsweise der Merkmalsextraktor mit einem Klassifizierer per Pipeline versehen wird.

• [Beispiel-Pipeline zum Extrahieren und Auswerten von Textfunktionen](http://scikit-learn.org/stable/auto_examples/model_selection/grid_search_text_feature_extraction.html#sphx-glr-auto-examples-model-selection-grid- Suchtext-Feature-Extraktion-py)

4.2.3.5. Textdateien dekodieren

Der Text besteht aus Buchstaben, aber die Datei besteht aus Bytes. Diese Bytes repräsentieren Zeichen gemäß einer bestimmten Codierung. Um mit einer Textdatei in Python zu arbeiten, müssen Sie dieses Byte in einen Zeichensatz namens Unicode dekodieren. Übliche Codierungen sind ASCII, Latin-1 (Westeuropa), KOI8-R (Russisch), Universal Encodings UTF-8 und UTF-16. Es gibt viele andere.

>>> 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)