La teoría nos dice que si. Al igual que podríamos detectar el texto escrito por distintas personas y acertar cual de ellas lo ha escrito. Siempre hablando teóricamente y para tal fin podrían adaptarse, distintos algoritmos y técnicas.
Uno de estos algoritmos es el uso de un modelo de redes generativas antagónicas o adversarias, (GAN, por sus siglas en inglés), que podríamos entrenar para detectar este tipo de texto. Sí, ese el mismo modelo que se utiliza en aplicaciones como Stable Difussion o Dall-E para imitar a nuestros creadores favoritos como Pablo Picasso o Vicent Van Gogh.
Esto combinado con otras ideas como analizar las características estadísticas, la longitud de las palabras o la frecuencia de aparición de ciertas palabras o frases, nos puede acercar más al objetivo.
Un ejemplo de uso de un modelo GAN para detectar contenido generado con IA sería entrenar una red neuronal GAN con un conjunto de datos de texto generado por humanos y otro conjunto de datos de texto generado automáticamente. Una vez entrenado, el modelo GAN tiene que ser capaz de determinar con un cierto grado de precisión si el texto ingresado es generado por un humano o por un modelo de lenguaje automático.
Ejemplo con código Python.
Aquí os dejo un sencillo código de cómo se podría implementar un modelo GAN en Python para detectar contenido generado con IA. Tómalo como un ejemplo básico, que espero que te dé una idea de cómo se podría implementar esto.
import numpy as np
from keras.layers import Input, Dense, Activation
from keras.models import Model, Sequential
from keras.optimizers import Adam
# Generador
generator = Sequential()
generator.add(Dense(256, input_dim=100, activation='relu'))
generator.add(Dense(512, activation='relu'))
generator.add(Dense(1024, activation='relu'))
generator.add(Dense(2048, activation='relu'))
generator.add(Dense(4096, activation='relu'))
generator.add(Dense(8192, activation='relu'))
generator.add(Dense(1, activation='sigmoid'))
# Discriminador
discriminator = Sequential()
discriminator.add(Dense(4096, input_dim=8192, activation='relu'))
discriminator.add(Dense(2048, activation='relu'))
discriminator.add(Dense(1024, activation='relu'))
discriminator.add(Dense(512, activation='relu'))
discriminator.add(Dense(256, activation='relu'))
discriminator.add(Dense(1, activation='sigmoid'))
# Conectar el generador y el discriminador
gan_input = Input(shape=(100,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = Model(inputs=gan_input, outputs=gan_output)
# Compilar y entrenar el modelo GAN
optimizer = Adam(lr=0.0001)
gan.compile(loss='binary_crossentropy', optimizer=optimizer)
# Cargar los datos generado por humanos y los generado automáticamente
human_data = ...
auto_generated_data = ...
data = np.concatenate((human_data, auto_generated_data))
labels = np.concatenate((np.ones(len(human_data)), np.zeros(len(auto_generated_data))))
# Entrenar el modelo GAN
gan.fit(data, labels, epochs=100)
Ten en cuenta que este ejemplo no esta completo y es solo una demostración conceptual, y en caso de querer implementarlo es necesario contar con un gran conjunto de datos etiquetado previamente para entrenar el modelo y poder tener un buen desempeño en su clasificación, amén de otros retoques.
Descripción del programa
El programa del ejemplo implementa un GAN para detectar contenido generado automáticamente. El GAN está compuesto por dos partes: el generador y el discriminador. El generador es una red neuronal que intenta generar contenido que se parezca a lo generado por humanos, mientras que el discriminador es una red neuronal que intenta diferenciar entre el contenido generado automáticamente y el generado por humanos.
La estructura de redes neuronales es una función de varias capas ( capas densas) conectadas unas con otras, cada capa tiene una función de activación asociada, como la función ReLU (Rectified Linear Unit) utilizada en este caso. Conectando estas capas se logra una representación de los datos de entrada que el modelo puede utilizar para su entrenamiento.
El código esta escrito en Python, y utiliza la librería Keras para construir el modelo GAN y las redes neuronales. Se inicializan dos modelos secuenciales, uno para el generador y otro para el discriminador, cada uno contiene una serie de capas densas conectadas entre sí. Cada capa tiene una cantidad de unidades específicas (256,512, 1024, 2048, 4096 y 8192) y una función de activación asociada ( relu), con la función sigmoid en la última capa del generador y la última capa del discriminador.
Se conecta el generador y el discriminador en un modelo de GAN, y se compila el modelo con un optimizador Adam y una función de pérdida binary_crossentropy, luego se cargan los datos human_data y auto_generated_data , y se entrena el modelo GAN con el método fit.
Es importante mencionar que este ejemplo es solo una implementación básica y ilustrativa, y es posible que para lograr un buen desempeño en la tarea de clasificación sea necesario ajustar varios parámetros y utilizar un conjunto de datos más grande y diversificado.
Tipos de datos
Los GANs son modelos de aprendizaje automático, y como tal, son capaces de procesar una variedad de formatos de datos. Sin embargo, para entrenar un GAN con texto, se deben convertir los datos de texto en un formato numérico que sea compatible con las redes neuronales utilizadas en el GAN.
Una forma común de convertir el texto en un formato numérico es utilizar un vector de caracteres, donde cada carácter en el texto se representa con un vector de números. Otro formato es vector de palabras (word embeddings), donde las palabras son representadas por un vector de números. El proceso de crear esos vectores se conoce como vectorización del texto.
Existen varias técnicas para vectorizar texto, como «one-hot-encoding», tokenización, y «word-embeddings» ( word2vec, GloVe). Dependiendo de la complejidad de tus datos y la capacidad de procesamiento que tengas a tu disposición, una técnica u otra sera mejor.
Una vez vectorizado el texto, los datos estarán en un formato compatible con las redes neuronales y por lo tanto con el GAN, y pueden ser utilizados para entrenar el modelo.
Espero que la idea te haya servido para entender por lo menos el concepto detrás de todo esto.