Zephyrnet-logo

Laten we een scriptgenerator bouwen met behulp van generatieve AI

Datum:

Introductie

Heb je je ooit afgevraagd hoe de personages uit je favoriete webserie leefden na het einde van de serie? Zo ja, dan helpt deze blog je bij het bouwen van een scriptgenerator die een script voor een nieuwe aflevering genereert. Ons model zal worden getraind in de scripts van alle afleveringen en is klaar om het script te genereren voor de volgende aflevering, die niet in de serie is geproduceerd. Al generaties lang is het maken van verhaallijnen, meeslepende dialogen en het geheel van scripts het domein van de mens. Dit proces is echter vaak tijdrovend en leunt sterk op de samenwerking van meerdere individuen, vooral bij het ontwikkelen van scripts voor langlopende series zoals 'Brooklyn Nine-Nine.' Daarom zullen we in deze blog een scriptgenerator bouwen met behulp van Generatieve AI, die de scenarioschrijvers zo snel mogelijk zal helpen bij het schrijven van de scripts.  

Scriptgenerator

Laten we nu eens kijken naar de definitie van de technologie die we in deze blog zullen gebruiken. Generatieve AI is een subset van kunstmatige intelligentie die nieuwe afbeeldingen, audio, video, tekst, enz. kan genereren. We gebruiken nu generatieve AI op bijna alle gebieden om de tijd die nodig is om een ​​specifieke taak te voltooien te optimaliseren. Als het over tekstuele gegevens gaat, kan generatieve AI mensachtige teksten genereren. Het kan de context van de taak begrijpen en op basis daarvan tekst genereren. In de context voor het genereren van scripts voor webseries kunnen we Generatieve AI gebruiken om een ​​nieuw afleveringsscript te genereren met dezelfde schrijfstijl en toon als de hele webserie.

leerdoelen

  • We kunnen begrijpen hoe AI zal worden gebruikt bij het schrijven van inhoud voor webseries, films, enz.
  • We zullen het gedetailleerde proces leren van het bouwen van een scriptgeneratormodel, inclusief het schrapen van gegevens, het opschonen, het bouwen van modellen, enz.
  • We zullen het vermogen van generatieve AI bij het schrijven van scripts leren, hoe efficiënt te schrijven en de voordelen ervan.
  • We zullen leren hoe belangrijk het voorbereiden en opschonen van gegevens is en welke invloed dit heeft op de scriptgenerator.

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

Inhoudsopgave

Het proces van het maken van scripts met behulp van generatieve AI

Laten we eerst een kort overzicht geven van de hele stroom voor het bouwen van de scriptgenerator:

Webseriegegevens verzamelen

Zoals we allemaal weten, moeten we gegevens verzamelen voordat we een model bouwen. Dus hier, bij het bouwen van de AI Script Generator, moeten we eerst alle gegevens verzamelen over de scripts van de webserie. Dit proces omvat het verzamelen van veel scripts van bepaalde afleveringen van een webserie. We schrapen deze door websites te schrappen, via databases of door toestemming te vragen aan de eigenaar van de scripts. Het belangrijkste doel is om een ​​enorme dataset op te bouwen met een breed scala aan dialogen, communicatie tussen de personages, de ontwikkeling van bepaalde scènes of de wendingen in de serie. Terwijl we de dataset ontwikkelen, moeten we ervoor zorgen dat de gegevens die we verzamelen waar zijn, geen auteursrechtproblemen hebben en volledig zijn.

De gegevens opschonen en voorbewerken

Gegevensvoorverwerking is een cruciale stap die ervoor zorgt dat onze gegevens schoon en opgeruimd zijn. Deze stap omvat het verwijderen van onnodige gegevens, zoals regieaanwijzingen of beschrijvingen van de regisseur. Omdat we gegevens verzamelen via web schrapen, moeten we controleren op ontbrekende gegevens. We zullen ook de tekstgegevens moeten normaliseren door interpunctie en speciale tekens te verwijderen en alle woorden naar kleine letters te converteren. Op deze manier zullen we onze dataset opschonen.

Data voorbereiding

Nadat u de dataset grondig hebt opgeschoond, is het tijd om deze voor te bereiden volgens de behoeften van ons model. Eerst beginnen we met het tokeniseren van het script in individuele woorden met behulp van een Tokenizer. Deze tokenizer breekt de hele zin of een scriptdialoog op in afzonderlijke woorden en kent vervolgens een unieke indexwaarde toe, waardoor een woordindex wordt gevormd. Daarna maken we reeksen tokens. We maken dus een lijst met tokens voor elke dialoog in het script. Na tokenisatie vullen we deze reeksen aan het begin aan met nullen, zodat de invoer uniform is voor ons model. Vervolgens wordt het laatste woord van elke reeks gebruikt als label om het volgende woord te voorspellen. Ten slotte worden de labels geconverteerd naar een categorisch formaat met behulp van one-hot-codering. Op deze manier wordt de dataset voorbereid op modeltraining.

Generatief model bouwen

Zodra de gegevens zijn voorbereid, zijn we klaar om onze eigen versie te bouwen generatief model. We hebben een model nodig om sequentiële gegevens te verwerken voor de taak voor het genereren van tekst. Deze blog gebruikt een op transformatoren gebaseerd model om de scripts te genereren. In deze trainingsfase leert ons model het volgende woord te voorspellen op basis van de voorgaande woorden. Nadat het model is getraind, kunnen we de kwaliteit van de voorspelling van het model beoordelen met behulp van een verliesfunctie, zoals kruis-entropieverlies.

Nieuw script genereren

Zodra ons model is getraind, kunnen we een nieuw afleveringsscript genereren. Om dit te doen, moeten we het model eerst voeden met een beginzin met de naam 'zaad.' Het model voorspelt vervolgens het volgende woord op basis van deze zaadzin. Het model genereert het volgende woord op basis van de kansen die tijdens de training zijn geleerd. Dit voorspelde woord wordt aan een reeks toegevoegd en vervolgens wordt dit proces herhaald totdat de gewenste lengte van het script is bereikt.

Voordelen van het gebruik van generatieve AI bij het schrijven van scripts

Dit zijn de voordelen van het gebruik van generatieve AI bij het schrijven van scripts:

  • Zoals we eerder hebben besproken, is het schrijven van scripts een tijdrovend proces, omdat het handmatig door menselijke schrijvers wordt gedaan. Echter, met het gebruik van generatieve AI, kunnen we het proces versnellen door de eerste concepten te genereren.
  • Een van de belangrijkste voordelen van het gebruik van AI om een ​​script te genereren, is dat het de schrijfstijl en toon van de vorige scripts in dit nieuwe script kan behouden.
  • Generatieve AI kan tijdens het genereren van scripts creatieve en interessante dialogen genereren die misschien niet bij menselijke schrijvers opkomen.
  • Het helpt scenarioschrijvers hun tijd te besteden aan het verfijnen en perfectioneren van het script, in plaats van het helemaal opnieuw te schrijven.

Uitdagingen bij het gebruik van generatieve AI bij het schrijven van scripts

Dit zijn de uitdagingen:

  • De eerste uitdaging waarmee u te maken kunt krijgen bij het bouwen van deze AI-scriptgenerator is het verzamelen van gegevens. We moeten controleren op eventuele problemen met de copywriter.
  • Generatieve AI kan hulp nodig hebben bij het begrijpen van de context van het script, wat kan leiden tot consistentie in de verhaallijn.
  • Hoewel Generatieve AI in een mum van tijd scripts kan genereren, kan het de creativiteit en originaliteit van een menselijke schrijver missen.
  • Een van de grootste uitdagingen is dat generatieve AI veel rekenkracht vereist, wat duur kan zijn.

Laten we nu dieper ingaan op het begrijpen van de code achter deze AI-scriptgenerator in de volgende paragrafen.

U kunt alle codes uitvoeren door op de knop 'Kopiëren en bewerken'-knop hierin link.

Laten we eerst alle bibliotheken importeren die we zullen gebruiken om de scriptgenerator te bouwen.

import requests
from bs4 import BeautifulSoup
import re
from nltk.tokenize import sent_tokenize
import plotly.express as px
from collections import Counter
import pandas as pd
from wordcloud import WordCloud
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from transformers import GPT2Tokenizer, GPT2LMHeadModel, TextDataset,
 DataCollatorForLanguageModeling
from transformers import Trainer, TrainingArguments

Over gegevensset

We zullen de scripts van de Brooklyn 99 webserie. Omdat het veel afleveringen heeft, zal het goed zijn voor ons model. We zullen de BeautifulSoup- en Requests-bibliotheken gebruiken om deze scripts van een webpagina te schrapen.

We zullen dit doen door twee functies te gebruiken, namelijk 'fetch_and_preprocess_scripts', en'preprocess_text.

De eerste functie heeft een URL als parameter. Deze URL is de webpagina waar we onze scripts zullen schrapen. We zullen de verzoekenbibliotheek gebruiken om een ​​HTTP-verzoek te verzenden om de HTML-inhoud van de pagina op te halen. We zullen vervolgens de BeautifulSoup-bibliotheek gebruiken om deze HTML-inhoud te parseren. We proberen alle ankertags te vinden () met de klas 'onderwerptitel' omdat ze alle links naar individuele afleveringsscripts bevatten. Vervolgens construeren we de volledige URL van elk script door deze samen te voegen met de basis-URL, en slaan we deze op in een lijst. Deze lijst wordt vervolgens omgekeerd om de volgorde van de afleveringen te behouden. Ten slotte herhaalt de functie elk script en extraheert de tekst. De tekst wordt vervolgens toegevoegd aan een definitieve scriptreeks.

# Function to fetch and preprocess the script content from a given URL
def fetch_and_preprocess_scripts(url):
    base_url = "https://transcripts.foreverdreaming.org"
    response = requests.get(url)
    soup = BeautifulSoup(response.content, "html.parser")

    anchor_tags = soup.find_all("a", class_="topictitle")
    links = [base_url + tag["href"][1:] for tag in anchor_tags]
    links = links[2:]
    links.reverse()

    final_script = ""
    
    for link in links:
        response = requests.get(link)
        soup = BeautifulSoup(response.content, "html.parser")
        script_div = soup.find("div", class_="content")
        script_text = script_div.get_text(separator="n") if script_div else ""

        final_script += script_text.strip() + "n"

    preprocessed_script = preprocess_text(final_script)
    return preprocessed_script

Nu zullen we de functie preprocess_text aanroepen, die de scriptreeks zal opschonen door alle HTML-tags en vierkante haakjes te verwijderen, de tekst in zinnen te tokeniseren en de zinnen naar kleine letters te converteren.  

# Function to clean and preprocess the text
def preprocess_text(text):
    cleaned_text = re.sub(r'<[^>]+>', '', text)
    cleaned_text = re.sub(r'[[^]]+]', '', cleaned_text)
    sentences = sent_tokenize(cleaned_text)
    
    preprocessed_text = ' '.join(sentence.lower() for sentence in sentences)
    
    return preprocessed_text


url = "https://transcripts.foreverdreaming.org/viewforum.php?f=429&sid=
       acbdaf84cb954f2929838f627cb124cb&start=78"
newpreprocessed_script = fetch_and_preprocess_scripts(url)
url1 = "https://transcripts.foreverdreaming.org/viewforum.php?f=429"
new_preprocessed_script = fetch_and_preprocess_scripts(url1)
preprocessed_script = newpreprocessed_script+new_preprocessed_script

Op deze manier hebben we de scripts van de afleveringen geschraapt en opgeschoond. Nu zijn we klaar met onze dataset.

Laten we nu eens kijken naar de eerste 500 woorden van ons dataset, wat de startwoorden zouden moeten zijn van de pilot-aflevering van de serie.

print(preprocessed_script[:500])

Output:

Scriptgenerator

Verkennende gegevensanalyse

In deze sectie gaan we optreden Verkennende gegevensanalyse (EDA) op onze scriptgegevens. We beginnen met het opsplitsen van het voorverwerkte script in individuele tokens (woorden). Vervolgens tellen we de frequentie van elk token met behulp van de Balie() functie.

tokens = preprocessed_script.split()
token_counter = Counter(tokens)

Nu zullen we de top 20 gemeenschappelijke tokens en hun tellingen extraheren.

most_common_tokens = token_counter.most_common(20)
token_labels, token_counts = zip(*most_common_tokens)

Ten slotte zullen we van deze gegevens een DataFrame maken om deze te visualiseren met behulp van een staafdiagram. Op de x-as houden we de woorden bij, en op de y-as houden we het aantal van elk woord bij.

data = {'Word': token_labels, 'Frequency': token_counts}
df = pd.DataFrame(data)

fig = px.bar(df, x='Word', y='Frequency', title='Most Common Words')
fig.update_xaxes(tickangle=45)
fig.show()

uitgang:

Scriptgenerator

Een andere manier om de meest gebruikte woorden te visualiseren is door een woordwolk te maken, een visueel aantrekkelijker diagram. We moeten de functie WordCloud() aanroepen en een paar details over het diagram doorgeven, zoals breedte, hoogte en achtergrondkleur, samen met het hele script.

text = ' '.join(tokens)
wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)

plt.figure(figsize=(10, 6))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.title('Word Cloud of Script Words')
plt.show()

Output:

Scriptgenerator

Data voorbereiding

Nu gaan we beginnen met het voorbereiden van onze dataset zodat deze geschikt is voor het trainen van het model. Dit omvat het tokeniseren van het voorverwerkte script in afzonderlijke woorden met behulp van de functie Tokenizer(). Eerst zullen we het object Tokenizer maken, en daarna zullen we de functie fit_on_tests() gebruiken om te tokeniseren. Ten slotte kunnen we later het totale aantal unieke woorden verkrijgen.

# Tokenizing the text into words
tokenizer = Tokenizer()
tokenizer.fit_on_texts([preprocessed_script])
total_words = len(tokenizer.word_index) + 1

Nu gaan we reeksen van deze tokens maken voor elke regel in het script. We zullen dit doen door elke regel van het script te herhalen, waarbij we elke regel zullen converteren naar een reeks tokens en vervolgens een reeks van n-grammen van deze tokens zullen maken. Ten slotte zullen we deze reeksen toevoegen aan een lijst met invoerreeksen.

# Creating sequences of tokens
input_sequences = []
for line in preprocessed_script.split('n'):
    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)

De volgende stap in de gegevensvoorbereidingsfase is het creëren van opvulling voor de invoerreeksen. We doen dit om ervoor te zorgen dat de invoerreeks uniform van lengte is. Om dit te doen, zullen we de functie 'pad_sequences' aanroepen vanuit de Keras-bibliotheek, waarin we de variabele input_sequences en de lengte van de langste reeks doorgeven.

# Padding sequences to ensure uniform length
max_sequence_len = max([len(x) for x in input_sequences])
input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')

Ten slotte zullen we elke reeks opsplitsen in labels en voorspellers. De voorspellers bevatten alle woorden van de reeks behalve het laatste woord, en de labelvariabele bevat het laatste woord van de reeks. We doen dit om het model te trainen om het volgende woord te voorspellen op basis van de labelvariabele. De labels worden vervolgens geconverteerd naar een categorisch formaat, wat nodig is voor het trainen van het model.

# Creating predictors and labels
predictors, label = input_sequences[:,:-1],input_sequences[:,-1]
# Converting labels to categorical format
from tensorflow.keras.utils import to_categorical
label = to_categorical(label, num_classes=total_words)

print("Total words:", total_words)
print("Max sequence length:", max_sequence_len)
print("Number of input sequences:", len(input_sequences))

OUTPUT:

generatieve AI

Model gebouw

Voor het hoofdgedeelte van het hele bouwproces van deze AI-scriptgenerator zullen we nu de vooraf getrainde mensen gebruiken GPT-2-model uit de transformatorbibliotheek.

Eerst zullen we de tokenizer en het model laden met behulp van de from_pretrained() functie.

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")

De volgende stap is het tokeniseren en coderen van de scriptgegevens. Dit gebeurt met behulp van de tokenizer.

preprocessed_script_tokens = tokenizer(preprocessed_script, return_tensors="pt", max_length=1024, 
                                       truncation=True)

Nu zullen we de getokeniseerde gegevens opslaan in een tekstbestand.

file_path = "preprocessed_script.txt"
with open(file_path, "w") as f:
    f.write(preprocessed_script)

Nu zullen we de getokeniseerde gegevens converteren naar een PyTorch dataset met behulp van de klasse TextDataset() uit de transformersbibliotheek.

dataset = TextDataset(tokenizer=tokenizer, file_path=file_path, block_size=128)
data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)

Nu zullen we trainingsargumenten definiëren met behulp van de TrainingArgumenten klas. De belangrijkste argumenten zijn het aantal trainingsepochs en de batchgrootte.

training_args = TrainingArguments(
    output_dir="./script_generator",
    overwrite_output_dir=True,
    num_train_epochs=50,
    per_device_train_batch_size=4,
    save_steps=10_000,
    save_total_limit=2,
    prediction_loss_only=True,
    report_to=[],  # Disabled wandb logging
)

Nu gaan we het Trainer-object maken om het model, de training_args, de data_collator en de datasetvariabele door te geven die we tot nu toe hebben gemaakt.

trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    train_dataset=dataset,
)

Tenslotte gaan we het model trainen met behulp van de trein() functie.

trainer.train()

Hiermee wordt het model getraind om scripts te genereren in de stijl van de voorverwerkte scriptgegevens.

Scripts genereren

Nu het model is getraind, kunnen we het script van een nieuwe aflevering genereren door het getrainde model en de tokenizer te laden.

# Loading the fine-tuned model
model = GPT2LMHeadModel.from_pretrained("/kaggle/working/fine_tuned_script_generator")

# Loading the tokenizer
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")

Nu gaan we een beginzin definiëren, die als uitgangspunt zal dienen voor het nieuwe script.

# Generating text
prompt_text = "Detective Jake Peralta enters the precinct and announces:"  # Custom prompt text
input_ids = tokenizer.encode(prompt_text, return_tensors="pt")

Nu zullen we het script genereren met behulp van genereren() functie, waarin we zullen doorgaan, de zaadzin en de maximale lengte van het nieuwe script. Een andere parameter die we zullen passeren is de temperatuur, die de willekeur van de voorspellingen bepaalt.

# Generating text with a maximum length of 500 tokens
output1 = model.generate(input_ids, max_length=500, num_return_sequences=1, temperature=0.7, 
                         do_sample=True)

Ten slotte zullen we het gegenereerde script decoderen en in een beter leesbaar formaat formatteren.

# Decoding the generated text
generated_text = tokenizer.decode(output1[0], skip_special_tokens=True)

delimiters = [". ", "? ", "! ", "| "]
for delimiter in delimiters:
    generated_text = generated_text.replace(delimiter, delimiter + "n")

# Printing each dialogue on a new line
print(generated_text.strip())

uitgang:

generatieve AI

Zoals u kunt zien, heeft ons model een nieuw afleveringsscript gegenereerd, dat zeer nauwkeurig en interessant is.

Conclusie

Concluderend: Generatieve AI is een krachtig hulpmiddel voor het genereren van scripts. Het kan een nieuw script maken dat past bij de toon van een bepaalde webserie waarin het model is getraind. Het kan de tijd en moeite van menselijke schrijvers verminderen. De kwaliteit van de gegenereerde scripts is afhankelijk van de kwaliteit en kwantiteit van de dataset. Het hangt ook af van de keuze van het model en de parameters ervan. Ondanks deze uitdagingen kunnen scriptschrijvers een scriptgenerator gebruiken als eerste versie van een aflevering, en deze naar hun eigen wensen verfijnen, waardoor de totale tijd voor het schrijven van scripts wordt verkort.

Key Takeaways

  • Generatieve AI kan een nuttige technologie zijn voor scenarioschrijvers, omdat ze er scriptgenerators mee kunnen bouwen en gebruiken.
  • Om deze scriptgenerator te bouwen, moeten we eerst een dataset voor een webserie verzamelen, de dataset in een geschikt formaat voorbereiden, het model bouwen en een nieuw afleveringsscript genereren.
  • Een van de grootste uitdagingen bij het bouwen van deze scriptgenerator is dat er veel rekenkracht voor nodig is.
  • De kwaliteit van het nieuw gegenereerde script is afhankelijk van de kwantiteit en kwaliteit van de trainingsgegevens.

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

Veelgestelde Vragen / FAQ

Q1. Wat is generatieve AI?

A. Generatieve AI is een technologie die nieuwe dingen kan creëren, zoals afbeeldingen, liedjes, video's, tekst, enz.

Q2. Wat zijn de voordelen van het gebruik van generatieve AI bij het schrijven van scripts?

A. Het kan de scenarioschrijvers helpen door een nieuw afleveringsscript te genereren als eerste concept. Scenarioschrijvers kunnen dit concept gebruiken om het aan hun behoeften aan te passen en het definitieve concept te maken, waardoor de totale tijd voor het schrijven van het script wordt verkort.

Q3. Met welke uitdagingen wordt geconfronteerd bij het gebruik van generatieve AI bij het schrijven van scripts?

A. De behoefte aan computerbronnen is een van de belangrijkste uitdagingen bij het bouwen van de scriptgenerator.

Q4. Kan generatieve AI menselijke schrijvers vervangen?

A. Nee, generatieve AI kan scenarioschrijvers nog niet volledig vervangen. Maar het kan scriptschrijvers helpen om in korte tijd een nieuw script te schrijven.

spot_img

Laatste intelligentie

spot_img