Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Een end-to-end gids over het genereren van tekst met LSTM

Hey mensen!

In dit artikel gaan we het hebben over het genereren van tekst met behulp van LSTM met end-to-end voorbeelden. we zullen ook kijken naar concepten die verband houden met LSTM als een snelle herziening.

In de volgende generatie voorspellen we het volgende teken van een bepaald woord van een reeks. Tekstgegevens kunnen worden gezien als een reeks woorden of een reeks afzonderlijke gegevens. Voor de voorspelling van de sequentie hebben we deep learning-modellen zoals RNN/LSTM/GRU gebruikt.

Ik heb al een zeer gedetailleerd artikel geschreven over het idee van RNN, daarna besprak ik waarom RNN niet praktisch is en legde ik RNN ​​en GRU uit met voorbeelden. hier kun je naar verwijzen link.

Inhoudsopgave

1. Inleiding tot LSTM
2. Waarom faalt RNN?
3. Inzicht in LSTM-architectuur en verschillende Gates
4. Het idee van tekstgeneratie
5. Implementatie van tekstgeneratie met LSTM

Introductie

Tekstgeneratie kan worden beschouwd als een zeer belangrijk kenmerk van op AI gebaseerde tools. het is erg handig in machines die verondersteld worden interactiever te worden naar mensen toe. slimme gadgets zoals slimme luidsprekers, thuisassistenten gebruiken in sommige vormen tekstgeneratie.

Gebruiksgevallen van Tekst-Generatie

• Zoekmachines
• chatbots
• Tekst samenvatten
• Vraag beantwoorden

Waarom is RNN niet praktisch voor het genereren van tekst?

RNN heeft een groot probleem van verdwijnende en exploderende gradiënten. daarom kan RNN geen langere sequentiële informatie bevatten en in de tekstgeneratietaak hebben we vooral een model nodig dat een lange reeks gegevens kan onthouden. voor dit doel kwam LSTM in beeld.

LSTM (Lange Korte Termijn Geheugen)

Zoals we weten, kan RNN sequentiële gegevens niet lang vasthouden / onthouden en begint de vorige invoer te vergeten en komt er nieuwe invoer. Om dit probleem op te lossen, is LSTM ontworpen met verschillende poorten.

LSTM lost het probleem van het leren van het kortetermijngeheugen op door verschillende soorten poorten te gebruiken.

Wanneer een nieuwe invoer in RNN komt, wijzigt deze de bestaande informatie zonder te beslissen of de binnenkomende invoer belangrijk is of niet, terwijl in het geval van LSTM poorten beschikbaar zijn om alleen belangrijke invoer toe te staan ​​om de bestaande informatie te wijzigen.

Bepaal in LSTM-poorten welke gegevens moeten worden genegeerd en welke als feed-forward moeten worden gebruikt voor de training. er zijn 3 poorten in LSTM:

1. Invoerpoort
2. Uitgangspoort
3. Vergeet Gate

Vergeet Gate

Deze poort is verantwoordelijk voor het selecteren van relevante informatie en het weggooien van irrelevante informatie. na het selecteren van relevante informatie wordt deze door de invoerpoort geleid.

Eerst wordt de informatie van de huidige status en de vorige verborgen status doorgegeven via de activeringsfunctie. hier zal de sigmoid-activeringsfunctie zijn. Sigmoid-activeringsfunctie retourneert waarde tussen 0 tot 1. een waarde dichter bij 0 betekent dat huidige informatie moet worden genegeerd, anders moet deze door de ingangspoort worden doorgegeven.

Invoerpoort

Deze poort is verantwoordelijk voor het toevoegen van informatie aan het model met behulp van de activeringsfunctie sigmoid. De activeringsfunctie gebruiken tanhcreëert een reeks informatie die door de invoerpoort gaat. de reeks informatie bevat waarden variërend van -1 tot 1 en a sigmoid functie filteren en bijhouden welke informatie aan het model moet worden toegevoegd en welke informatie moet worden weggegooid.

Uitgangspoort

Output Gate is verantwoordelijk voor het genereren van de volgende verborgen toestanden samen met celtoestanden die worden overgedragen naar de volgende tijdstap. Het creëert een verborgen staat met behulp van de activeringsfunctie tanhen de waarde varieert van -1 tot 1.

Het idee van tekstgeneratie

Tekstgeneratie is niets anders dan een continue reeks voorspellingen van het volgende woord. omdat we al weten dat tekstgegevens een reeks woorden zijn, kunnen we met behulp van deze reeksen het volgende woord voorspellen.

Tekstgeneratie implementeren

Er zijn stappen verschillende stappen vermeld voor het genereren van tekst: -

• Laad de benodigde bibliotheken
• Laad de tekstuele gegevens
• Voer indien nodig tekstopschoning uit
• Gegevensvoorbereiding voor training
• Het LSTM-model definiëren en trainen
• Voorspelling

Benodigde bibliotheken laden

• bibliotheken voor gegevensverwerking

importeer panda's als pd importeer numpy als np import string, os importeer waarschuwingen warnings.filterwarnings("ignore") warnings.simplefilter(action='ignore', category=FutureWarning)

• deep learning-bibliotheken laden

# stel zaden in voor reproduceerbaarheid
van tensorflow import set_random_seed van numpy.random import seed set_random_seed(2) seed(1)
# keras-module voor het bouwen van LSTM 
van keras.preprocessing.sequence importeer pad_sequences van keras.layers import Embedding, LSTM, Dense, Dropout van keras.preprocessing.text import Tokenizer van keras.callbacks import EarlyStopping van keras.models import Sequentiële import keras.utils als ku

De gegevensset laden

We zullen gebruiken Newyorks tijd opmerkingen dataset beschikbaar op Kaggle. jij kan Download de dataset of u kunt zelfs een nieuwe Kaggle-notebook maken met behulp van deze dataset.

De dataset bevat verschillende artikelen en commentaren. Ons doel is om alle artikelen als koppen te laden en ze samen te voegen tot een lijst.

# Alle koppen laden als een lijst curr_dir = '../input/' all_headlines = [] voor bestandsnaam in os.listdir(curr_dir): if 'Artikelen' in bestandsnaam: article_df = pd.read_csv(curr_dir + bestandsnaam) all_headlines.extend(list(article_df.headline. waarden)) breken

all_headlines = [regel voor regel in all_headlines if line!= "Onbekend"] print(all_headlines[:10])

We hebben in totaal 829 koppen en we zullen deze koppen gebruiken om tekst te genereren.

Voorbereiding van de dataset

Voor de voorbereiding van de dataset is onze eerste taak het opschonen van de tekstgegevens, waaronder het verwijderen van leestekens, kleine letters, enz.

Gegevens opschonen

We hebben een functie gedefinieerd die één kop per keer gebruikt en de opgeschoonde kop retourneert. Met behulp van iteratie hebben we elke kop gepasseerd en een lijst gemaakt met opgeschoonde gegevenscorpus.

def clean_text(txt): txt = "".join(t for tin txt if t not in string.punctuation).lower() txt = txt.encode("utf8").decode("ascii",'ignore') retour txt

corpus = [clean_text(x) for x in all_headlines] print(corpus[:10])

N-gramreeks genereren voor training

In NLP vereist taalmodel sequentiële invoergegevens, en invoerwoord/token moet numeriek zijn. Hier genereren we n-grammen om ons model te trainen voor de volgende woordvoorspelling.

tokenizer = Tokenizer() def get_sequence_of_tokens(corpus): ## tokenization tokenizer.fit_on_texts(corpus) total_words = len(tokenizer.word_index) + 1 ## converteer gegevens naar een tokenreeks input_sequences = [] voor regel in corpus: token_list = tokenizer .texts_to_sequences([line])[0] for i in range(1, len(token_list)): n_gram_sequence = token_list[:i+1] input_sequences.append(n_gram_sequence) return input_sequences, total_words

inp_sequences, total_words = get_sequence_of_tokens(corpus) print(inp_sequences[:10])

Zoals je ziet inp_sequence is een reeks van n-grammen die nodig is voor het trainen van de voorspelling van het volgende woord. we hadden 829 koppen en met het n-gram-concept hebben we nu 4544 rijen.

Je kunt de inp_sequences met deze foto waar je duidelijk kunt zien dat we bij elke stap een token toevoegen aan de Seed-reeks voor training.

De sequenties opvullen

De inp_sequence we hebben zojuist een variabele reekslengte gemaakt, wat niet gunstig is voor training, met behulp van opvulling maken we elke reeks van dezelfde lengte.

def generation_padded_sequences(input_sequences): max_sequence_len = max([len(x) for x in input_sequences]) input_sequences = np.array(pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')) voorspellers, [: input_sequences :-1],input_sequences[:,-1] label = ku.to_categorical(label, num_classes=total_words) retourneer voorspellers, label, max_sequence_len

voorspellers, label, max_sequence_len = generation_padded_sequences (inp_sequences)

• predictors : dit zijn tokens die worden gebruikt als invoer voor het voorspellen van het volgende woord.
• label: is het volgende woord dat moet worden voorspeld.
• max_sequence_len: is de lengte van de reeks.
• pad_sequence: geleverd door Keras wordt gebruikt om een ​​reeks tokens tot een bepaalde lengte op te vullen.
• In dit geval,max_sequence_len is 17.

Model creatie

Tot nu toe hebben we de gegevens voorbereid voor training. nu zullen we in deze stap een LSTM-model maken dat duurt: predictors als invoer X en labels als ingang y.

Een snelle herinnering over lagen in Keras: -

• Invoerlaag: Dit is verantwoordelijk voor het nemen van de invoervolgorde.
• LSTM-laag: Het berekent de uitvoer met behulp van LSTM-eenheden en retourneert verborgen en celstatussen. In ons geval hebben we 100 eenheden in de laag toegevoegd, die later kunnen worden verfijnd.
• Uitvallaag: Deze laag is verantwoordelijk voor regularisatie, wat betekent dat het overmatige pasvorm voorkomt. dit wordt gedaan door de activeringen van sommige neuronen in de LSTM-laag uit te schakelen.
• Uitvoerlaag: Dit berekent de waarschijnlijkheid van onze voorspelling.

def create_model(max_sequence_len, total_words): input_len = max_sequence_len - 1 model = Sequential() # ----------Add Input Embedding Layer model.add(Embedding(total_words, 10, input_length=input_len)) # - ---------Verborgen laag 1 toevoegen - LSTM-laag model.add(LSTM(100)) model.add(Dropout(0.1)) # ----------Uitvoerlaagmodel toevoegen. add(Dense(total_words, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam') retourmodel

model = create_model(max_sequence_len, total_words) model.summary()

Het model trainen

Na het bouwen van de modelarchitectuur kunnen we het model trainen met behulp van onze predictors (X_train) en label(y_train). 100 tijdperken zouden genoeg moeten zijn.

model.fit(voorspellers, label, tijdperken=100, uitgebreid=5)

Tekstgeneratie (voorspelling)

Geweldig!!

We hebben onze modelarchitectuur getraind en nu is het klaar om tekst te genereren. We moeten een functie schrijven om het volgende woord te voorspellen op basis van de ingevoerde woorden. We moeten de reeks ook tokeniseren en met dezelfde vullen sequence_length we hebben gezorgd voor training, en dan zullen we elk voorspeld woord als een tekenreeks toevoegen.

def generation_text(seed_text, next_words, model, max_sequence_len): for _ in range(next_words): token_list = tokenizer.texts_to_sequences([seed_text])[0] token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='len-0, padding='len-XNUMX pre') predicted = model.predict_classes(token_list, verbose=XNUMX) output_word = "" voor woord,index in tokenizer.word_index.items(): if index == predicted: output_word = woordafbreking seed_text += " "+output_word return seed_text.title()

• seed_text : het zijn de eerste woorden die worden doorgegeven voor het genereren van tekst.
• predict_classes: het zal de token-ID voor het voorspelde woord retourneren.
• predicted: De token-ID voor het voorspelde woord en dit wordt terug omgezet in een woord met behulp van het woordenboektokenizer.word_index .items().
• next_words Het is het aantal volgende woorden dat we willen voorspeld hebben.

Voorspelling

De functie aanroepen generate_textgenereert de functie text.generate_text neemt de eerste woorden en het aantal te voorspellen woorden, de modelnaam en de lengte van de reeks.

print (generate_text("india and pakistan", 3, model, max_sequence_len)) print (generate_text("president trump", 3, model, max_sequence_len)) print (generate_text("verenigde staten", 4, model, max_sequence_len)) print (generate_text("donald trump", 2, model, max_sequence_len)) print (generate_text("new york", 3, model, max_sequence_len)) print (generate_text("wetenschap en technologie", 5, model, max_sequence_len))

Conclusie

In dit artikel hebben we het LSTM-model met zijn architectuur besproken en vervolgens het idee van de tekstgeneratie besproken en de tekstgeneratie geïmplementeerd met behulp van het LSTM-model.

Ons getrainde model werkte perfect, maar u kunt het model verbeteren door: -

• Meer gegevens toevoegen om op te trainen
• Fijnafstemming van de modelarchitectuur, dwz (aantal eenheden, lagen, enz.).
• Fijnafstemming van de parameters zoals (tijdperken, eenheden, leersnelheid, activeringsfunctie, enz.)

Bedankt voor het lezen !!

Voel je vrij om me te raken op mijn Linkedin als u suggesties of vragen voor mij heeft.

Referenties

1. https://iq.opengenus.org/text-generation-lstm/
2. https://www.kaggle.com/shivamb/beginners-guide-to-text-generation-using-lstms

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

Verwant

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://www.analyticsvidhya.com/blog/2022/02/explaining-text-generation-with-lstm/