Del II – Typer av vektoriseringstekniker

I den här artikeln kommer vi att diskutera vektorisering – en NLP-teknik, och förstå dess betydelse med en omfattande guide om olika typer av vektorisering.

Vi har diskuterat de grundläggande koncepten för NLP-förbearbetning och textrengöring. Vi tittade på grunderna i NLP, dess olika tillämpningar och tekniker som tokenisering, normalisering, standardisering och textrensning.

Innan vi diskuterar vektorisering, låt oss revidera vad tokenisering är och hur det skiljer sig från vektorisering.

Vad är tokenisering?

Tokenisering är processen att dela upp meningar i mindre enheter som kallas tokens. Token hjälper datorer att enkelt förstå och arbeta med text.

EX. ”Den här artikeln är bra”

Tokens- [‘This’, ‘article’, ‘is’, ‘good’.]

Vad är vektorisering?

Som vi vet förstår maskininlärningsmodeller och algoritmer numeriska data. Vektorisering är en process för att omvandla text- eller kategoridata till numeriska vektorer. Genom att konvertera data till numerisk data kan du träna din modell mer exakt.

Varför behöver vi vektorisering?

❇️ Tokenisering och vektorisering har olika betydelse i naturlig språkbehandling (NPL). Tokenisering bryter meningar i små tokens. Vektorisering konverterar det till ett numeriskt format så att dator/ML-modellen kan förstå det.

❇️ Vektorisering är inte bara användbar för att konvertera den till numerisk form utan också användbar för att fånga semantisk betydelse.

❇️ Vektorisering kan minska dimensionaliteten hos datan och göra den mer effektiv. Detta kan vara mycket användbart när du arbetar med en stor datamängd.

❇️ Många maskininlärningsalgoritmer kräver numerisk inmatning, såsom neurala nätverk, så att vektorisering kan hjälpa oss.

Det finns olika typer av vektoriseringstekniker, som vi kommer att förstå genom den här artikeln.

Påse med ord

Om du har ett gäng dokument eller meningar och du vill analysera dem, förenklar en påse med ord denna process genom att behandla dokumentet som en påse som är fylld med ord.

The bag of words-metoden kan vara användbar vid textklassificering, sentimentanalys och dokumenthämtning.

Anta att du arbetar med mycket text. En påse med ord hjälper dig att representera textdata genom att skapa ett ordförråd med unika ord i vår textdata. Efter att ha skapat ordförråd kommer det att koda varje ord som en vektor baserat på frekvensen (hur ofta varje ord förekommer i den texten) av dessa ord.

Dessa vektorer består av icke-negativa tal (0,1,2…..) som representerar antalet frekvenser i det dokumentet.

Påsen med ord innefattar tre steg:

Steg 1: Tokenisering

Det kommer att dela upp dokument till tokens.

Ex – (Mening: ”Jag älskar pizza och jag älskar hamburgare”)

Steg 2: Unik ordseparation/ordförrådsskapande

Skapa en lista över alla unika ord som förekommer i dina meningar.

[“I”, “love”, “Pizza”, “and”, “Burgers”]

Steg 3: Räkna ordförekomst/vektorskapande

Detta steg kommer att räkna hur många gånger varje ord upprepas från vokabulären och lagra det i en gles matris. I den glesa matrisen, varje rad i en meningsvektor vars längd (matrisens kolumner) är lika med storleken på ordförrådet.

Importera CountVectorizer

Vi kommer att importera CountVectorizer för att träna vår Bag of words-modell

from sklearn.feature_extraction.text import CountVectorizer

Skapa Vectorizer

I det här steget kommer vi att skapa vår modell med CountVectorizer och träna den med vårt exempeltextdokument.

# Sample text documents
documents = [
    "This is the first document.",
    "This document is the second document.",
    "And this is the third one.",
    "Is this the first document?",
]

# Create a CountVectorizer 
cv = CountVectorizer()
# Fit and Transform
X = cv.fit_transform(documents)

Konvertera till en tät array

I det här steget kommer vi att konvertera våra representationer till tät array. Vi kommer också att få funktionsnamn eller ord.

# Get the feature names/words
feature_names = vectorizer.get_feature_names_out()

# Convert to dense array
X_dense = X.toarray()

Låt oss skriva ut dokumenttermmatrisen och funktionsord

# Print the DTM and feature names
print("Document-Term Matrix (DTM):")
print(X_dense)
print("\nFeature Names:")
print(feature_names)

Dokument – ​​Termmatris (DTM):

Matris

Funktionsnamn:

Funktionsord

Som du kan se består vektorerna av icke-negativa tal (0,1,2……) som representerar frekvensen av ord i dokumentet.

Vi har fyra exempel på textdokument och vi har identifierat nio unika ord från dessa dokument. Vi lagrade dessa unika ord i vårt ordförråd genom att tilldela dem ”funktionsnamn”.

Sedan kontrollerar vår Bag of Words-modell om det första unika ordet finns i vårt första dokument. Om den är närvarande tilldelar den värdet 1, annars tilldelar den 0.

Om ordet förekommer flera gånger (t.ex. 2 gånger), tilldelar det ett värde i enlighet därmed.

Till exempel, i det andra dokumentet upprepas ordet ”dokument” två gånger, så dess värde i matrisen blir 2.

Om vi ​​vill ha ett enstaka ord som en funktion i vokabulärnyckeln – Unigram-representation.

n – gram = Unigram, bigram…….osv.

Det finns många bibliotek som scikit-learn to implement bag of words: Keras, Gensim och andra. Detta är enkelt och kan vara användbart i olika fall.

Men, Bag of words är snabbare men det har vissa begränsningar.

  • Den tilldelar varje ord samma vikt, oavsett dess betydelse. I många fall är vissa ord viktigare än andra.
  • BoW räknar helt enkelt frekvensen av ett ord eller hur många gånger ett ord förekommer i ett dokument. Detta kan leda till en partiskhet mot vanliga ord som ”det”, ”och”, ”är” etc., som kanske inte har så mycket betydelse.
  • Längre dokument kan ha fler ord och kan skapa större vektorer. Detta kan göra det svårt att jämföra. Det kan skapa en gles matris, vilket inte kan vara bra för att utföra komplexa NLP-projekt.
  • För att lösa detta problem kan vi välja bättre tillvägagångssätt, en av dem är TF-IDF. Låt oss, förstå i detalj.

    TF-IDF

    TF-IDF, eller Term Frequency – Inverse Document Frequency, är en numerisk representation för att bestämma betydelsen av ord i dokumentet.

    Varför behöver vi TF-IDF framför Bag of Words?

    En påse med ord behandlar alla ord lika och handlar bara om frekvensen av unika ord i meningar. TF-IDF ger betydelse åt ord i ett dokument genom att beakta både frekvens och unikhet.

    Ord som upprepas för ofta övervinner inte mindre frekventa och viktigare ord.

    TF: Term Frequency mäter hur viktigt ett ord är i en enda mening.

    IDF: Omvänd dokumentfrekvens mäter hur viktigt ett ord är i hela dokumentsamlingen.

    TF = Frekvens av ord i ett dokument / Totalt antal ord i det dokumentet

    DF = Dokument som innehåller ord w / Totalt antal dokument

    IDF = logg(Totalt antal dokument / Dokument som innehåller ordet w)

    IDF är ömsesidigt med DF. Anledningen till detta är ju vanligare ordet är i alla dokument, desto mindre betydelse har det i det aktuella dokumentet.

    Slutlig TF-IDF-poäng: TF-IDF = TF * IDF

    Det är ett sätt att ta reda på vilka ord som är vanliga inom ett enda dokument och unika för alla dokument. Dessa ord kan vara användbara för att hitta huvudtemat i dokumentet.

    Till exempel,

    Doc1 = ”Jag älskar maskininlärning”

    Doc2 = ”Jag älskar adminvista.com”

    Vi måste hitta TF-IDF-matrisen för våra dokument.

    Först kommer vi att skapa ett ordförråd med unika ord.

    Ordförråd = [“I,” “love,” “machine,” “learning,” “Geekflare”]

    Så vi har 5 fem ord. Låt oss hitta TF och IDF för dessa ord.

    TF = Frekvens av ord i ett dokument / Totalt antal ord i det dokumentet

    TF:

    • För ”I” = TF för Doc1: 1/4 = 0,25 och för Doc2: 1/3 ≈ 0,33
    • För ”kärlek”: TF för Dok1: 1/4 = 0,25 och för Doc2: 1/3 ≈ 0,33
    • För ”Maskin”: TF för Doc1: 1/4 = 0,25 och för Doc2: 0/3 ≈ 0
    • För ”Lärande”: TF för Doc1: 1/4 = 0,25 och för Doc2: 0/3 ≈ 0
    • För ”adminvista.com”: TF för Doc1: 0/4 = 0 och för Doc2: 1/3 ≈ 0,33

    Nu, låt oss beräkna IDF.

    IDF = logg(Totalt antal dokument / Dokument som innehåller ordet w)

    IDF:

    • För ”I”: IDF är log(2/2) = 0
    • För ”kärlek”: IDF är log(2/2) = 0
    • För ”Maskin”: IDF är log(2/1) = log(2) ≈ 0,69
    • För ”Lärande”: IDF är log(2/1) = log(2) ≈ 0,69
    • För ”adminvista.com”: IDF är log(2/1) = log(2) ≈ 0,69

    Låt oss nu beräkna slutresultatet för TF-IDF:

    • För ”I”: TF-IDF för Doc1: 0,25 * 0 = 0 och TF-IDF för Doc2: 0,33 * 0 = 0
    • För ”kärlek”: TF-IDF för Doc1: 0,25 * 0 = 0 och TF-IDF för Doc2: 0,33 * 0 = 0
    • För ”Maskin”: TF-IDF för Doc1: 0,25 * 0,69 ≈ 0,17 och TF-IDF för Doc2: 0 * 0,69 = 0
    • För ”Inlärning”: TF-IDF för Doc1: 0,25 * 0,69 ≈ 0,17 och TF-IDF för Doc2: 0 * 0,69 = 0
    • För ”adminvista.com”: TF-IDF för Doc1: 0 * 0,69 = 0 och TF-IDF för Doc2: 0,33 * 0,69 ≈ 0,23

    TF-IDF matris ser ut så här:

            I     love   machine   learning   adminvista.com
    Doc1    0.0   0.0    0.17      0.17       0.0
    Doc2    0.0   0.0    0.0       0.0        0.23
    

    Värden i en TF-IDF-matris berättar hur viktig varje term är i varje dokument. Höga värden indikerar att en term är viktig i ett visst dokument, medan låga värden tyder på att termen är mindre viktig eller vanlig i det sammanhanget.

    TF-IDF används mest i textklassificering, hämtning av chatbotinformation och textsammanfattning.

    Importera TfidfVectorizer

    Låt oss importera TfidfVectorizer från sklearn

    from sklearn.feature_extraction.text import TfidfVectorizer

    Skapa Vectorizer

    Som du ser kommer vi att skapa vår Tf Idf-modell med TfidfVectorizer.

    # Sample text documents
    text = [
        "This is the first document.",
        "This document is the second document.",
        "And this is the third one.",
        "Is this the first document?",
    ]
    
    # Create a TfidfVectorizer 
    cv = TfidfVectorizer()

    Skapa TF-IDF-matris

    Låt oss träna vår modell genom att tillhandahålla text. Efter det kommer vi att konvertera den representativa matrisen till tät array.

    # Fit and transform to create the TF-IDF matrix
    X = cv.fit_transform(text)
    # Get the feature names/words
    feature_names = vectorizer.get_feature_names_out()
    
    # Convert the TF-IDF matrix to a dense array for easier manipulation (optional)
    X_dense = X.toarray()

    Skriv ut TF-IDF Matrix och Feature Words

    # Print the TF-IDF matrix and feature words
    print("TF-IDF Matrix:")
    print(X_dense)
    print("\nFeature Names:")
    print(feature_names)
    

    TF-IDF-matris:

    Funktionsord

    Som du kan se indikerar dessa decimalkomma heltal betydelsen av ord i specifika dokument.

    Du kan också kombinera ord i grupper om 2,3,4 och så vidare med n-gram.

    Det finns andra parametrar som vi kan inkludera: min_df, max_feature, subliner_tf, etc.

    Fram till nu har vi utforskat grundläggande frekvensbaserade tekniker.

    Men TF-IDF kan inte ge semantisk mening och kontextuell förståelse av text.

    Låt oss förstå mer avancerade tekniker som har förändrat världen av ordinbäddning och som är bättre för semantisk betydelse och kontextuell förståelse.

    Word2Vec

    Word2vec är en populär ordinbäddning (typ av ordvektor och användbar för att fånga semantisk och syntaktisk likhet) teknik i NLP. Detta utvecklades av Tomas Mikolov och hans team på Google 2013. Word2vec representerar ord som kontinuerliga vektorer i ett flerdimensionellt utrymme.

    Word2vec syftar till att representera ord på ett sätt som fångar deras semantiska betydelse. Ordvektorer som genereras av word2vec är placerade i ett kontinuerligt vektorutrymme.

    Ex – ”Katt”- och ”Hund”-vektorer skulle vara närmare än vektorer för ”katt” och ”flicka”.

    Källa: usna.edu

    Två modellarkitekturer kan användas av word2vec för att skapa ordinbäddning.

    CBOW: Kontinuerlig påse med ord eller CBOW försöker förutsäga ett ord genom att beräkna ett genomsnitt av betydelsen av närliggande ord. Det tar ett fast antal eller ett fönster med ord runt målordet, konverterar det sedan till numerisk form (Inbäddning), gör ett genomsnitt av alla och använder det genomsnittet för att förutsäga målordet med det neurala nätverket.

    Ex- Förutspå mål: ”Räv”

    Meningsord: ’den’, ’snabben’, ’brun’, ’hoppar’, ’över’, ’den’

    Word2Vec

    • CBOW tar fast storlek fönster (antal) av ord som 2 (2 till vänster och 2 till höger)
    • Konvertera till ordinbäddning.
    • CBOW sätter i genomsnitt ordet inbäddning.
    • CBOW ger ett genomsnitt av ordet som bäddas in i sammanhangsorden.
    • Genomsnittlig vektor försöker förutsäga ett målord med hjälp av ett neuralt nätverk.

    Låt oss nu förstå hur skip-gram skiljer sig från CBOW.

    Skip-gram: Det är en ordinbäddningsmodell, men den fungerar annorlunda. Istället för att förutsäga målordet förutsäger skip-gram kontextorden givna målord.

    Skip-grams är bättre på att fånga de semantiska sambanden mellan ord.

    Ex- ’Kung – Män + Kvinnor = Drottning’

    Om du vill arbeta med Word2Vec har du två val: antingen kan du träna din egen modell eller använda en förtränad modell. Vi kommer att gå igenom en förutbildad modell.

    Importera gensim

    Du kan installera gensim med pip installation:

    pip install gensim

    Tokenisera meningen med word_tokenize:

    Först konverterar vi meningar till lägre. Efter det kommer vi att tokenisera våra meningar med hjälp av word_tokenize.

    # Import necessary libraries
    from gensim.models import Word2Vec
    from nltk.tokenize import word_tokenize
    
    # Sample sentences
    sentences = [
        "I love thor",
        "Hulk is an important member of Avengers",
        "Ironman helps Spiderman",
        "Spiderman is one of the popular members of Avengers",
    ]
    
    # Tokenize the sentences
    tokenized_sentences = [word_tokenize(sentence.lower()) for sentence in sentences]
    

    Låt oss träna vår modell:

    Vi kommer att träna vår modell genom att tillhandahålla tokeniserade meningar. Vi använder 5 fönster för denna träningsmodell, du kan anpassa efter dina krav.

    # Train a Word2Vec model
    model = Word2Vec(sentences=tokenized_sentences, vector_size=100, window=5, min_count=1, sg=0)
    
    # Find similar words
    similar_words = model.wv.most_similar("avengers")
    # Print similar words
    print("Similar words to 'avengers':")
    
    for word, score in similar_words:
        print(f"{word}: {score}")

    Ord som liknar ’avengers’:

    Word2Vec likhet

    Det här är några av orden som liknar ”avengers” baserat på Word2Vec-modellen, tillsammans med deras likhetspoäng.

    Modellen beräknar en likhetspoäng (mest cosinuslikhet) mellan ordvektorerna för ”avengers” och andra ord i dess ordförråd. Likhetspoängen indikerar hur nära besläktade två ord är i vektorrummet.

    Ex –

    Här hjälper ordet ”hjälp” med cosinuslikhet -0,005911458611011982 med ordet ”avengers”. Det negativa värdet tyder på att de kan skilja sig från varandra.

    Cosinuslikhetsvärden varierar från -1 till 1, där:

    • 1 indikerar att de två vektorerna är identiska och har positiv likhet.
    • Värden nära 1 indikerar hög positiv likhet.
    • Värden nära 0 indikerar att vektorerna inte är starkt relaterade.
    • Värden nära -1 indikerar hög olikhet.
    • -1 indikerar att de två vektorerna är totalt motsatta och har en perfekt negativ likhet.

    Besök denna länk om du vill ha en bättre förståelse för word2vec-modeller och en visuell representation av hur de fungerar. Det är ett riktigt coolt verktyg för att se CBOW och skip-gram i aktion.

    I likhet med Word2Vec har vi GloVe. GloVe kan producera inbäddningar som kräver mindre minne jämfört med Word2Vec. Låt oss förstå mer om GloVe.

    Handske

    Globala vektorer för ordrepresentation (GloVe) är en teknik som word2vec. Det används för att representera ord som vektorer i kontinuerligt utrymme. Konceptet bakom GloVe är detsamma som Word2Vecs: det producerar kontextuella ordinbäddningar samtidigt som man tar hänsyn till Word2Vecs överlägsna prestanda.

    Varför behöver vi GloVe?

    Word2vec är en fönsterbaserad metod, och den använder närliggande ord för att förstå ord. Detta innebär att den semantiska betydelsen av målordet endast påverkas av dess omgivande ord i meningar, vilket är en ineffektiv användning av statistik.

    Medan GloVe fångar både global och lokal statistik för att komma med ordinbäddning.

    När ska man använda GloVe?

    Använd GloVe när du vill ha ordinbäddning som fångar bredare semantiska relationer och globala ordassociationer.

    GloVe är bättre än andra modeller när det gäller namngivna enhetsigenkänningsuppgifter, ordanalogi och ordlikhet.

    Först måste vi installera Gensim:

    pip install gensim

    Steg 1: Vi kommer att installera viktiga bibliotek

    # Import the required libraries
    
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.manifold import TSNE
    import gensim.downloader as api  

    Steg 2: Importera handskemodell

    import gensim.downloader as api
    glove_model = api.load('glove-wiki-gigaword-300')

    Steg 3: Hämta vektorordrepresentation för ordet ”söt”

    glove_model["cute"]

    Vektor för ordet ”söt”

    Dessa värden fångar ordets betydelse och relationer till andra ord. Positiva värden indikerar positiva associationer till vissa begrepp, medan negativa värden indikerar negativa associationer till andra begrepp.

    I en GloVe-modell representerar varje dimension i ordvektorn en viss aspekt av ordets betydelse eller sammanhang.

    De negativa och positiva värdena i dessa dimensioner bidrar till hur ”gullig” är semantiskt relaterad till andra ord i modellens vokabulär.

    Värdena kan vara olika för olika modeller. Låt oss hitta några ord som liknar ordet ”pojke”

    Topp 10 Liknande ord som modellen tycker är mest lik ordet ”pojke”

    # find similar word
    glove_model.most_similar("boy")

    Topp 10 ord som liknar ”pojke”

    Som du kan se är det mest liknande ordet ”pojke” ”flicka”.

    Nu kommer vi att försöka hitta hur exakt modellen kommer att få semantisk betydelse från de angivna orden.

    glove_model.most_similar(positive=['boy', 'queen'], negative=['girl'], topn=1)

    Det mest relevanta ordet för ”drottning”

    Vår modell kan hitta ett perfekt förhållande mellan ord.

    Definiera ordlista:

    Låt oss nu försöka förstå semantisk betydelse eller relation mellan ord med hjälp av en plot. Definiera listan med ord du vill visualisera.

    # Define the list of words you want to visualize
    vocab = ["boy", "girl", "man", "woman", "king", "queen", "banana", "apple", "mango", "cow", "coconut", "orange", "cat", "dog"]
    

    Skapa inbäddningsmatris:

    Låt oss skriva kod för att skapa inbäddningsmatris.

    # Your code for creating the embedding matrix
    EMBEDDING_DIM = glove_model.vectors.shape[1]
    word_index = {word: index for index, word in enumerate(vocab)}
    num_words = len(vocab)
    embedding_matrix = np.zeros((num_words, EMBEDDING_DIM))
    
    for word, i in word_index.items():
        embedding_vector = glove_model[word]
        if embedding_vector is not None:
            embedding_matrix[i] = embedding_vector

    Definiera en funktion för t-SNE-visualisering:

    Från denna kod kommer vi att definiera funktion för vår visualiseringsplot.

    def tsne_plot(embedding_matrix, words):
        tsne_model = TSNE(perplexity=3, n_components=2, init="pca", random_state=42)
        coordinates = tsne_model.fit_transform(embedding_matrix)
    
        x, y = coordinates[:, 0], coordinates[:, 1]
    
        plt.figure(figsize=(14, 8))
        for i, word in enumerate(words):
            plt.scatter(x[i], y[i])
            plt.annotate(word,
                         xy=(x[i], y[i]),
                         xytext=(2, 2),
                         textcoords="offset points",
                         ha="right",
                         va="bottom")
        plt.show()
    

    Låt oss se hur vår tomt ser ut:

    # Call the tsne_plot function with your embedding matrix and list of words
    tsne_plot(embedding_matrix, vocab)
    

    t-SNE tomt

    Så, som vi kan se, finns det ord som ’banan’, ’mango’, ’apelsin’, ’kokos’ och ’äpple’ på vänster sida av vår tomt. Medan ”ko”, ”hund” och ”katt” liknar varandra eftersom de är djur.

    Så vår modell kan också hitta semantisk betydelse och relationer mellan ord!

    Genom att bara ändra vokaben eller skapa din modell från början kan du experimentera med olika ord.

    Du kan använda denna inbäddningsmatris hur du vill. Den kan appliceras på ordlikhetsuppgifter ensam eller matas in i ett neuralt nätverks inbäddningslager.

    GloVe tränar på en samförekomstmatris för att härleda semantisk betydelse. Det bygger på idén att ord-ord-samförekomster är en viktig del av kunskap och att deras användning är ett effektivt sätt att använda statistik för att producera ordinbäddningar. Detta är hur GloVe åstadkommer att lägga till ”global statistik” till slutprodukten.

    Och det är GloVe; En annan populär metod för vektorisering är FastText. Låt oss diskutera mer om det.

    Snabbtext

    FastText är ett bibliotek med öppen källkod introducerat av Facebooks AI Research-team för textklassificering och sentimentanalys. FastText tillhandahåller verktyg för att träna ordinbäddning, som är täta vektorrepresenterar ord. Detta är användbart för att fånga dokumentets semantiska betydelse. FastText stöder både multi-label och multi-class klassificering.

    Varför FastText?

    FastText är bättre än andra modeller på grund av dess förmåga att generalisera till okända ord, som hade saknats i andra metoder. FastText tillhandahåller förtränade ordvektorer för olika språk, som kan vara användbara i olika uppgifter där vi behöver förkunskaper om ord och deras betydelse.

    FastText vs Word2Vec

    Hur fungerar det?

    Som vi diskuterade använder andra modeller, som Word2Vec och GloVe, ord för ordinbäddning. Men byggstenen i FastText är bokstäver istället för ord. Vilket betyder att de använder bokstäver för ordinbäddning.

    Att använda tecken istället för ord har en annan fördel. Mindre data behövs för träning. Allt eftersom ett ord blir dess sammanhang, vilket resulterar i att mer information kan extraheras från texten.

    Ordinbäddning som erhålls via FastText är en kombination av inbäddningar på lägre nivå.

    Låt oss nu titta på hur FastText använder underordsinformation.

    Låt oss säga att vi har ordet ”läsa”. För detta ord skulle tecken n-gram med längden 3-6 genereras enligt följande:

    • Början och slutet indikeras med vinkelparenteser.
    • Hashing används eftersom det kan finnas ett stort antal n-gram; istället för att lära oss en inbäddning för varje distinkt n-gram, lär vi oss totala B-inbäddningar, där B står för hinkstorleken. Storleken på 2 miljoner hinkar användes i originalpapperet.
    • Varje tecken n-gram, som ”eadi”, mappas till ett heltal mellan 1 och B med hjälp av denna hashfunktion, och det indexet har motsvarande inbäddning.
    • Genom att medelvärdesbestämma dessa beståndsdelar n-gram inbäddningar erhålls sedan hela ordinbäddningen.
    • Även om denna hashing-metod resulterar i kollisioner, hjälper den till att hantera ordförrådets storlek i stor utsträckning.
    • Nätverket som används i FastText liknar Word2Vec. Precis som där kan vi träna snabbtexten i två lägen – CBOW och skip-gram. Därför behöver vi inte upprepa den delen här igen.

    Du kan träna din egen modell, eller så kan du använda en förtränad modell. Vi kommer att använda en förtränad modell.

    Först måste du installera FastText.

    pip install fasttext

    Vi kommer att använda en datauppsättning som består av konversationstext om några droger, och vi måste klassificera dessa texter i 3 typer. Som med den typ av droger som de förknippas med.

    Datauppsättning

    Nu, för att träna en FastText-modell på vilken datauppsättning som helst, måste vi förbereda indata i ett visst format, vilket är:

    __label__

    Låt oss göra detta för vår datauppsättning också.

    all_texts = train['text'].tolist()
    all_labels = train['drug type'].tolist()
    prep_datapoints=[]
    
    for i in range(len(all_texts)):
        sample="__label__"+ str(all_labels[i]) + ' '+ all_texts[i]
        prep_datapoints.append(sample)

    prep_datapoints

    Vi utelämnade mycket förbearbetning i detta steg. Annars blir vår artikel för stor. I verkliga problem är det bäst att göra förbearbetning för att göra data lämpliga för modellering.

    Skriv nu förberedda datapunkter till en .txt-fil.

    with open('train_fasttext.txt','w') as f:
        for datapoint in prep_datapoints:
            f.write(datapoint)
            f.write('n')
        f.close()
    

    Låt oss träna vår modell.

    model = fasttext.train_supervised('train_fasttext.txt')

    Vi kommer att få förutsägelser från vår modell.

    Modellen förutsäger etiketten och tilldelar den en konfidenspoäng.

    Precis som med alla andra modeller är prestandan för denna beroende av en mängd olika variabler, men om du vill få en snabb uppfattning om vad den förväntade noggrannheten är kan FastText vara ett bra alternativ.

    Slutsats

    Sammanfattningsvis ger textvektoriseringsmetoder som Bag of Words (BoW), TF-IDF, Word2Vec, GloVe och FastText en mängd olika funktioner för NLP-uppgifter.

    Medan Word2Vec fångar ordsemantik och är anpassningsbar för en mängd olika NLP-uppgifter, är BoW och TF-IDF enkla och lämpliga för textklassificering och rekommendationer.

    För applikationer som sentimentanalys erbjuder GloVe förtränade inbäddningar, och FastText klarar sig bra på underordsnivåanalys, vilket gör det användbart för strukturellt välbärgade språk och enhetsigenkänning.

    Valet av teknik beror på uppgiften, data och resurser. Vi kommer att diskutera komplexiteten i NLP djupare när den här serien fortskrider. Lycka till med lärandet!

    Kolla sedan in de bästa NLP-kurserna för att lära dig naturlig språkbehandling.