Estás leyendo la publicación: Detección de noticias falsas con BERT Model Python: hacia la IA
Publicado originalmente en Hacia la IA, la empresa líder mundial en noticias y medios de IA y tecnología. Si está creando un producto o servicio relacionado con la IA, lo invitamos a considerar convertirse en patrocinador de la IA. En Hacia la IA, ayudamos a escalar las empresas emergentes de IA y tecnología. Permítanos ayudarlo a dar rienda suelta a su tecnología a las masas.
En este artículo, intentaremos construir un modelo de clasificación BERT para detectar noticias falsas usando Python.
El auge de las redes sociales amplificó la influencia de las noticias falsas en nuestra sociedad. Las personas a menudo perciben todo lo que leen/oyen como Verdadero, y está afectando al mundo a gran escala, tanto política como financieramente. Así que hoy vamos a desarrollar una aplicación que pueda detectar noticias falsas automáticamente usando BERT Model y Python.
Cargando los datos
Los datos utilizados en este artículo se pueden encontrar aquí. Copie los datos, descomprímalos y péguelos en su carpeta. Comencemos nuestro código importando las bibliotecas:
importar pandas como pd
importar csv
Una vez que haya copiado los datos,
df_falso = pd.read_csv(“Falso.csv”) df_true = pd.read_csv(“Verdadero.csv”)
Hemos importado los datos y creado dos DataFrames. Ahora hagamos un poco de limpieza y análisis de datos:
lo comenzaremos creando un marco de datos fusionando los dos marcos de datos anteriores.
df_falso[“Label”] = “falso”
df_verdadero[“Label”] = “Verdadero”
Para diferenciar las noticias falsas de las verdaderas, agregamos una nueva columna: etiqueta… que será nuestra columna dependiente.
df = pd.concat([df_fake,df_true]) df = df.muestra(frac=1).reset_index(drop=True)
Arriba, fusionamos los DataFrames y los mezclamos.
Finalmente, tenemos nuestros datos listos:
df.cabeza(5)
Comprobemos si nos faltan valores:
df.isnull().sum()
Análisis de los datos
Entonces, ahora intentemos analizar algunas columnas en nuestros datos: como sabemos, el título y el texto son necesarios, ya que tenemos que predecir las etiquetas que dependen de ellos; Y es obvio que la fecha no juega un papel importante en la predicción de si las noticias son falsas o verdaderas. Visualicemos la columna del tema usando la biblioteca Seaborn:
importar matplotlib.pyplot como plt
importar seaborn como sns #Creating Figure
fig, axes = plt.subplots(1,2, figsize = (15,6)) #Agregando el histograma1 – Noticias falsas
sns.histplot(df_fake.subject, palette = ‘Set1’, alpha = 0.5, ax = ejes[0])
hachas[0].tick_params(eje = ‘x’, rotación = 90)
hachas[0].set_title(‘Asunto de noticias falsas’) #Agregando el histograma2 – Noticias verdaderas
sns.histplot(df_true.subject, palette = ‘Set1’, alpha = 0.5, ax = ejes[1])
hachas[1].tick_params(eje = ‘x’, rotación = 90)
hachas[1].set_title(‘True News Asunto’) #Imprimiendo el conteo de Asunto
print(“Asunto de noticias falsas: “,dict(df_fake.subject.value_counts()))
print(“Asunto de noticias verdaderas: “,dict(df_true.subject.value_counts()))
Como podemos ver, la columna de asunto tiene valores diferentes en ambos DataFrames. Así que no podemos incluir esa columna yendo más allá.
Veamos si los datos están balanceados o no.
sns.histplot(df.Label, palette = ‘Set1’, alpha = 0.5) plt.tick_params(axis = ‘x’, rotación = 90) plt.title(‘True VS Fake News’) df.Label.value_counts() d.f.[“text”] = gl[“title”]+df[“text”] #considerando texto y título como X
Como podemos ver, la columna Etiqueta está en formato Objeto, codifiquémosla en formato Numérico.
d.f.[‘Label’] = gl[‘Label’].mapa({‘Verdadero’:1, ‘Falso’:0})
Aquí, como necesitamos codificar solo dos valores, he usado el método map() de DataFrame Python. Pero para obtener una explicación detallada de los métodos de codificación de Python, consulte mi artículo a continuación:
Métodos de codificación para codificar datos categóricos en Machine Learning
Así que nuestros datos están listos. Realicemos el tren-prueba-división de datos:
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, test_size = 0.2, random_state = 10)
Tenemos listos nuestros datos de capacitación y prueba, así que aprendamos sobre el modelo BERT ahora.
MODELO BERT
BERT significa . Consiste en varios codificadores de transformador apilados juntos. Utiliza Transformers para comprender la relación contextual entre palabras en una oración/texto. BERT Transformer generalmente tiene dos mecanismos: un codificador que lee la entrada de texto y un decodificador que predice para una tarea determinada.
Una de las principales razones del buen desempeño de BERT en diferentes tareas de PNL fue el uso de Aprendizaje semisupervisado. Esto significa que el modelo está capacitado para una tarea específica que le permite comprender los patrones del idioma. Después del entrenamiento, el modelo (BERT) tiene capacidades de procesamiento del lenguaje que se pueden usar para potenciar otros modelos que construimos y entrenamos usando el aprendizaje supervisado.
Inicialmente, BERT se lanza en dos tamaños: modelos base y grande. BERT(BASE) tiene 1 mientras que BERT(LARGE) tiene .
El modelo BERT toma primero el token de clasificación (CLS) como entrada, seguido de la secuencia de palabras. Luego pasa la entrada a las capas anteriores. Cada capa aplica la autoatención y pasa el resultado a través de una red de avance, luego pasa al siguiente codificador. El modelo genera un vector de tamaño según el tamaño de BERT. Si queremos generar un clasificador de este modelo, podemos tomar la salida correspondiente al token CLS.
Este vector entrenado se puede utilizar para realizar una serie de tareas como clasificación, traducción, etc.
Detección de noticias falsas
Entonces, concentrémonos en nuestra tarea y comencemos la clasificación. Como se dijo, necesitamos pasar valores tokenizados como entrada al modelo BERT. Así que usemos el tokenizador de la biblioteca de transformadores.
Tokenización
Comencemos con esto instalando transformadores que proporcionen el modelo BERT.
!pip instalar transformadores
Comencemos la tokenización:
En este método, usaremos AutoTokenizer del modelo BERT (base):
Al igual que todas las redes neuronales, los transformadores no pueden procesar el texto de entrada sin procesar directamente, por lo que debemos tokenizar la entrada y convertirla en números. La tokenización realiza las siguientes funciones: divide el texto de entrada en tokens (palabras, letras, etc.), mapea cada token con un entero único y los organiza de acuerdo con el modelo.
Dado que estamos utilizando el modelo BERT BASE para nuestra aplicación, también hemos utilizado el AutoTokenizer correspondiente para la tokenización.
from transformers import AutoTokenizer def tokenize(X): X = tokenizer(
texto = lista(X),
add_special_tokens = Verdadero,
longitud_máx = 100,
truncamiento = Verdadero,
relleno = ‘longitud_máxima’,
return_tensors = ‘tf’,
return_token_type_ids = Falso,
return_attention_mask = Verdadero,
detallado = Verdadero
) devuelve el tokenizador X = AutoTokenizer.from_pretrained(‘bert-base-uncased’)
Vamos a tokenizar los valores:
X_tren_fichas = tokenizar(X_tren)
X_test_tokens = tokenizar(X_test)
modelo de diseño
Importación de bibliotecas necesarias:
importar tensorflow como tf
de keras.models modelo de importación, secuencial
desde keras.layers importar Entrada, Densa, Abandono, Incrustación
de tensorflow.keras.optimizers import Adam
desde transformadores importar TFBertModel
Diseño de la función BERT —
Longitud = 100 def get_model(): dropout_rate = 0.2 input_ids = Input(shape = (Length,), dtype = tf.int32, name = ‘input_ids’)
input_mask = Entrada (forma = (Longitud), dtype = tf.int32, nombre = ‘input_mask’) incrustaciones = bert ([input_ids, input_mask])[1] salida #pooler
imprimir (incrustaciones)
out = Dropout(0.2)(incrustaciones) #64 unidades capa densa out = Dense(64,activation = ‘relu’)(out)
fuera = abandono (0.2) (fuera) y = denso (1, activación = ‘sigmoide’) (fuera) modelo = modelo (entradas =[input_ids, input_mask]salidas=y)
modelo.capas[2].trainable = True #define optimizador
optimizador = Adam(learning_rate=1e-05, epsilon=1e-08, decay=0.01,clipnorm=1.0) #complicar el modelo
model.compile(optimizador = optimizador, pérdida = ‘binary_crossentropy’, métricas = ‘precisión’) modelo de retorno
Cargando el modelo BERT —
bert = TFBertModel.from_pretrained(‘bert-base-sin carcasa’)
Tracemos el modelo BERT creado:
modelo = obtener_modelo()
tf.keras.utils.plot_model(modelo)
Hemos creado el Modelo de acuerdo con la explicación anterior.
Entrenando Nuestro Modelo
from keras.callbacks import EarlyStopping history = model.fit(x = {‘input_ids’:X_train_tokens[‘input_ids’],’input_mask’:X_tren_tokens[‘attention_mask’]}, y = y_train, epochs=3, validation_split = 0.2, batch_size = 64, callbacks=[EarlyStopping( monitor=’val_accuracy’ ,mode=’max’, patience=3,verbose=False,restore_best_weights=True)])
Como podemos ver, obtuvimos un 99,9 % de precisión de entrenamiento. Evaluemos nuestro modelo —
yhat = np.where(model.predict({ ‘input_ids’ : X_test_seq[‘input_ids’] ‘máscara_de_entrada’: X_test_seq[‘attention_mask’]}) >=0.5,1,0) print(classification_report(y_test,yhat))
Podemos ver que nuestro modelo está funcionando muy bien incluso en los datos de evaluación.
Podemos usar este modelo, incluso para evaluar cualquier noticia diaria que veamos.
Eso es todo, amigos… Para seguir mi contenido y saber más sobre mí, consulte mi artículo a continuación:
Programa de Socios Medianos y Mi Próximo Viaje
Codificación feliz….
La detección de noticias falsas usando BERT Model Python se publicó originalmente en Towards AI en Medium, donde las personas continúan la conversación destacando y respondiendo a esta historia.
Publicado a través de Hacia la IA
