Estás leyendo la publicación: Cómo construir un modelo de IA que escriba como Chetan Bhagat
Soy un gran admirador de Chetan Bhagat y he leído todas sus novelas. No podía tener suficiente de Chetan Bhagat y quería más de su escritura loca, divertida y emocional. Entonces, he decidido construir un modelo de IA que escriba como él.
¿Cómo funciona el modelo de IA?
- Tomé partes de sus novelas, por lo que se considera uso legítimo.
- Luego, limpié el texto para asegurarme de que cada línea tenga solo una oración.
- Esto se agregó a un marco de datos y construí un conjunto de datos para el entrenamiento.
- Tomé datos del conjunto de datos y los preprocesé para el entrenamiento.
- Luego, entrené un modelo GPT-2 personalizado.
- El modelo se cargó y ahora puede generar texto como Chetan Bhagat.
Empecemos.
conjunto de datos
Vamos a obtener las importaciones primero:
desde io importar BytesIO desde pdfminer.pdfinterp importar PDFResourceManager, PDFPageInterpreter desde pdfminer.converter importar TextConverter desde pdfminer.layout importar LAParams desde pdfminer.pdfpage importar PDFPage
Primero, consigamos la mitad de la novia de Chetan Bhagat https://archive.org.
Ahora, hagamos una función para asegurarnos de que solo haya una oración.
#una función para asegurarse de que solo haya una oración en cada línea de un archivo txt. def one_sentence_per_line(text): líneas = texto.splitlines() new_lines = []
para línea en líneas: if línea.strip() == ”: continuar else: new_lines.append(line) return ‘\n’.join(new_lines)
Después de eso, cree una nueva función para cambiar el archivo pdf a txt.
#una función obtiene el texto de un archivo pdf y crea un archivo txt def pdf_to_txt(pdf_file): #pdf_file = “C:/Users/Chetan/Desktop/test.pdf” rsrcmgr = PDFResourceManager() retstr = StringIO() codec= “utf-8” laparams = LAParams() dispositivo = TextConverter(rsrcmgr, retstr, codec=codec, laparams=laparams) fp = open(pdf_file, ‘rb’) intérprete = PDFPageInterpreter(rsrcmgr, dispositivo) contraseña = “” maxpages = 0 almacenamiento en caché = True pagenos=set() para página en PDFPage.get_pages(fp, pagenos, maxpages=maxpages, contraseña=contraseña,caching=caching, check_extractable=True): interpreter.process_page(page) text = retstr.getvalue() fp.close() dispositivo.close() retstr.close() devolver texto
Ahora, hagamos una función para limpiar el texto y crear un nuevo archivo clean.txt.
#hacer un archivo de texto llamado “clean.txt” def clean_txt(pdf_file): text = pdf_to_txt(pdf_file) text = one_sentence_per_line(text) f = open(“clean.txt”,”w”) f.write(text) f .close() devolver texto
Por último, llamemos a la función.
clean_txt(“C:/Users/Chetan/Desktop/test.pdf”)
Y ahora tenemos un archivo clean.txt con todos los mensajes de texto limpios y listos para convertirlos en un conjunto de datos.
Aquí está el archivo.
Ahora, finalmente podemos crear el conjunto de datos agregando estos datos a un marco de datos:
importar pandas como pd file=open(‘/content/clean.txt’,’r’) lines=file.readlines() “agregar todas las líneas a una lista” all_lines=[]
para línea en líneas: all_lines.append(line) “eliminar todas las líneas vacías” all_lines=list(filter(None,all_lines)) “eliminar todas las líneas con una sola letra” all_lines=list(filter(lambda x: len( x)>1,all_lines)) ‘eliminar todo excepto los caracteres alfabéticos’ all_lines=list(map(lambda x: x.strip(‘\r’).strip(‘\t’).strip(‘ ‘).strip( ‘\f’).strip(‘\v’),all_lines)) “crear un marco de datos” df=pd.DataFrame() df[‘Dialogue’]=pd.DataFrame(all_lines) “guardar el marco de datos” df.to_csv(‘/content/TrainChetan.csv’) file.close()
Y ahora tenemos el archivo TrainChetan.csv:
Y ahora es un conjunto de datos de Kaggle. Compruébalo aquí.
El conjunto de datos tiene 8003 valores únicos y está listo para entrenar modelos.
Ahora, ejecutemos un análisis de opinión en el texto para obtener más datos para el entrenamiento. Usé TextBlob para el análisis de sentimientos.
! pip instalar textblob desde textblob importar TextBlob df[‘score’]=df[‘Dialogue’].apply(lambda x: TextBlob(x).sentimiento.polaridad) df[‘sentiment’]=df[‘Dialogue’].apply(lambda x: TextBlob(x).sentimiento.subjetividad) df.to_csv(‘/content/TrainChetan_after_sentiment_analysis.csv’)
Aquí está el nuevo archivo csv después del análisis de sentimiento:
No estaba satisfecho con el resultado del análisis de opiniones. Por lo tanto, reescribí el análisis de opiniones utilizando bibliotecas NLTK.
Primero obtengamos las importaciones y descargas:
importar nltk nltk.download(‘stopwords’) nltk.download(‘punkt’) nltk.download(‘wordnet’) !gdown –id 1BGTVDjg8EwzUJmSwsmn2sEz9lJD2_3-w !gdown –id 1xsYC2UF1JAR7BIiNSU4iGbTZytYNzYof
Esto traerá todas las descargas necesarias en su sistema.
Ahora, obtengamos los datos y los preprocesemos y ejecutemos un análisis de opinión sobre ellos.
importar pandas como pd desde nltk.corpus importar palabras vacías desde nltk.tokenize importar word_tokenize desde nltk.stem importar WordNetLemmatizer importar re df = pd.read_csv(‘/content/TrainChetan.csv’, usecols=[‘Dialogue’]) lema = WordNetLemmatizer() stop_words = stopwords.words(‘english’) def text_prep(x: str) -> list: corp = str(x).lower() corp = re.sub(‘[^a-zA-Z]+’,’ ‘, corp).strip() tokens = word_tokenize(corp) palabras = [t for t in tokens if t not in stop_words]
lematizar = [lemma.lemmatize(w) for w in words]
volver lematizar preprocess_tag = [text_prep(i) for i in df[‘Dialogue’]]df[“preprocess_txt”] = etiqueta_preproceso df[‘total_len’] = gl[‘preprocess_txt’].map(lambda x: len(x)) archivo = abrir(‘palabras-negativas.txt’, ‘r’,codificación = “ISO-8859-1”) neg_words = archivo.leer().split() archivo = open(‘palabras-positivas.txt’, ‘r’,codificación = “ISO-8859-1”) pos_palabras = archivo.leer().split() num_pos = df[‘preprocess_txt’].mapa(lambda x: len([i for i in x if i in pos_words])) d.f.[‘pos_count’] = num_pos num_neg = df[‘preprocess_txt’].mapa(lambda x: len([i for i in x if i in neg_words])) d.f.[‘neg_count’] = num_neg df[‘sentiment’] = redondo((df[‘pos_count’] – d.f.[‘neg_count’]) / DF[‘total_len’]2) df.to_csv(‘/content/TrainChetan_after_sentiment_analysis_nltk.csv’) df.head()import pandas as pd from nltk.corpus import stopwords from nltk.tokenize import word_tokenize from nltk.stem import WordNetLemmatizer import re df = pd.read_csv (‘/content/TrainChetan.csv’, usecols=[‘Dialogue’]) lema = WordNetLemmatizer() stop_words = stopwords.words(‘english’) def text_prep(x: str) -> list: corp = str(x).lower() corp = re.sub(‘[^a-zA-Z]+’,’ ‘, corp).strip() tokens = word_tokenize(corp) palabras = [t for t in tokens if t not in stop_words]
lematizar = [lemma.lemmatize(w) for w in words]
volver lematizar preprocess_tag = [text_prep(i) for i in df[‘Dialogue’]]df[“preprocess_txt”] = etiqueta_preproceso df[‘total_len’] = gl[‘preprocess_txt’].map(lambda x: len(x)) archivo = abrir(‘palabras-negativas.txt’, ‘r’,codificación = “ISO-8859-1”) neg_words = archivo.leer().split() archivo = open(‘palabras-positivas.txt’, ‘r’,codificación = “ISO-8859-1”) pos_palabras = archivo.leer().split() num_pos = df[‘preprocess_txt’].mapa(lambda x: len([i for i in x if i in pos_words])) d.f.[‘pos_count’] = num_pos num_neg = df[‘preprocess_txt’].mapa(lambda x: len([i for i in x if i in neg_words])) d.f.[‘neg_count’] = num_neg df[‘sentiment’] = redondo((df[‘pos_count’] – d.f.[‘neg_count’]) / DF[‘total_len’]2) df.to_csv(‘/content/TrainChetan_after_sentiment_analysis_nltk.csv’) df.head()
Veamos la salida:
Como puede ver, este análisis de sentimiento es muy detallado y puede usarse para entrenar nuestro modelo.
Entrenaré un modelo de PNL con los datos del conjunto de datos. Revisé muchos modelos de PNL y me decidí por un modelo basado en GPT-2.
Entonces, usaremos Aitextgen Lib para este proyecto. Vamos a instalarlo.
!pip install -q aitextgen #instalar el paquete principal
Importemos Aitextgen:
de aitextgen importar aitextgen
Verifique su GPU (asegúrese de usar el tiempo de ejecución de GPU si está haciendo esto en Google Colab o Kaggle Notebook):
! nvidia-smi
Descarga el modelo 124M GPT-2:
ai = aitextgen(tf_gpt2=”124M”, to_gpu=Verdadero)
Ahora, leamos el conjunto de datos que hice arriba:
pd.read_csv(“/content/TrainChetan_after_sentiment_analysis_nltk.csv”) pd.set_option(‘display.max_colwidth’, Ninguno)
Ahora, necesitamos limpiar el conjunto de datos y eliminar columnas y espacios no deseados.
fichero de entrada[“Dialogue”] = archivo_entrada[“Dialogue”].str.replace(‘(‘,”).str.replace(‘)’,”)
Veamos la forma del nuevo marco de datos.
df = pd.DataFrame(archivo_de_entrada[“Dialogue”]) df.forma
Tenemos 8248 valores individuales.
Ahora dividamos las palabras y hagámoslo en dos filas para un mejor entrenamiento.
df = df.assign(var1=df[‘Dialogue’].str.split(‘-‘)).explotar(‘var1’) df.var1 = df.var1.str.lstrip() df.forma
Ahora, tenemos datos listos para el entrenamiento. Guardemos el texto limpio en un archivo .txt:
df.to_csv(“input_text_cleaned.txt”, columnas=[“var1”]encabezado=Falso, índice=Falso)
Ahora podemos usar el archivo de texto anterior para ajustar el modelo y establecer los parámetros correctos:
Montemos el Gdrive para guardar el modelo allí:
!pip install -q gpt-2-simple importar gpt_2_simple como gpt2 gpt2.mount_gdrive()
Es hora de ajustar el modelo a nuestras necesidades:
run_name=”ChetanAI” ai.train(‘input_text_cleaned.txt’, run_name = run_name, line_by_line=False, from_cache=False, num_steps=5000, generate_every=100, save_every=500, save_gdrive=True, learning_rate=1e-3, fp16 =Falso, lote_tamaño=1)
¡Finalmente está hecho!
Nuestro modelo personalizado GPT-2 Trained está listo. Ahora, podemos cargar directamente el modelo entrenado.
ai.generate(n=3, prompt=”Esto es algo que Chetan escribiría:”, batch_size=1, max_length=50, temperature=1.0, top_p=0.9)
Las salidas:
Para el cuaderno de Colab, vaya aquí.
