Observamos que nuestros predecesores internos de DALL·E 2 a veces reproducían imágenes de entrenamiento palabra por palabra. Este comportamiento no era deseable, ya que nos gustaría que DALL·E 2 creara imágenes originales y únicas de forma predeterminada y no simplemente “unir” piezas de imágenes existentes. Además, la reproducción textual de imágenes de capacitación puede generar preguntas legales sobre la infracción de derechos de autor, la propiedad y la privacidad (si las fotografías de las personas estuvieran presentes en los datos de capacitación).
Para comprender mejor el problema de la regurgitación de imágenes, recopilamos un conjunto de datos de indicaciones que con frecuencia daban como resultado imágenes duplicadas. Para hacer esto, utilizamos un modelo entrenado para muestrear imágenes de 50.000 indicaciones de nuestro conjunto de datos de entrenamiento y ordenamos las muestras por similitud perceptiva con la imagen de entrenamiento correspondiente. Finalmente, inspeccionamos las coincidencias principales a mano y encontramos solo unos pocos cientos de pares duplicados verdaderos de un total de 50.000 solicitudes. Aunque la tasa de regurgitación parecía ser inferior al 1%, sentimos que era necesario reducir la tasa a 0 por las razones expuestas anteriormente.
Cuando estudiamos nuestro conjunto de datos de imágenes regurgitadas, notamos dos patrones. En primer lugar, las imágenes eran casi todas gráficos vectoriales simples, que probablemente eran fáciles de memorizar debido a su bajo contenido de información. En segundo lugar, y lo que es más importante, todas las imágenes tenían muchos casi duplicados en el conjunto de datos de entrenamiento. Por ejemplo, podría haber un gráfico vectorial que parece un reloj que muestra la hora 1 en punto, pero luego descubriríamos una muestra de entrenamiento que contiene el mismo reloj que muestra las 2 en punto, y luego las 3 en punto, etc. Cuando nos dimos cuenta de esto, utilizamos una búsqueda distribuida del vecino más cercano para verificar que, de hecho, todas las imágenes regurgitadas tenían duplicados perceptualmente similares en el conjunto de datos. Otro obras han observado un fenómeno similar en modelos de lenguaje grandes y han descubierto que la duplicación de datos está fuertemente relacionada con la memorización.
El hallazgo anterior sugirió que, si deduplicamos nuestro conjunto de datos, podríamos resolver el problema de la regurgitación. Para lograr esto, planeamos usar una red neuronal para identificar grupos de imágenes que parecían similares y luego eliminar todas menos una imagen de cada grupo.[^footnote-2]
Sin embargo, esto requeriría verificar, para cada imagen, si es un duplicado de todas las demás imágenes del conjunto de datos. Dado que todo nuestro conjunto de datos contiene cientos de millones de imágenes, ingenuamente necesitaríamos verificar cientos de billones de pares de imágenes para encontrar todos los duplicados. Si bien esto está técnicamente a nuestro alcance, especialmente en un clúster de cómputo grande, encontramos una alternativa mucho más eficiente que funciona casi tan bien por una pequeña fracción del costo. Consideremos lo que sucede si agrupamos nuestro conjunto de datos antes de realizar la deduplicación. Dado que las muestras cercanas a menudo caen en el mismo grupo, la mayoría de los pares duplicados no cruzarían los límites de decisión del grupo. Luego podríamos deduplicar muestras dentro de cada grupo sin verificar si hay duplicados fuera del grupo, y solo perderíamos una pequeña fracción de todos los pares duplicados. Esto es mucho más rápido que el enfoque ingenuo, ya que ya no tenemos que comprobar cada par de imágenes.[^footnote-3]
Cuando probamos este enfoque empíricamente en un pequeño subconjunto de nuestros datos, encontramos el 85% de todos los pares duplicados cuando usamosk=1024 clusters. Para mejorar la tasa de éxito del algoritmo anterior, aprovechamos una observación clave: cuando se agrupan diferentes subconjuntos aleatorios de un conjunto de datos, los límites de decisión del cluster resultantes suelen ser bastante diferentes. Por lo tanto, si un par duplicado cruza el límite de un grupo para un grupo de datos, el mismo par podría caer dentro de un único grupo en un grupo diferente. Cuantas más agrupaciones intente, más probabilidades tendrá de descubrir un par duplicado determinado. En la práctica, nos decidimos por utilizar cinco agrupaciones, lo que significa que buscamos duplicados de cada imagen en la unión de cinco agrupaciones diferentes. En la práctica, esto encontró el 97% de todos los pares duplicados en un subconjunto de nuestros datos.
Sorprendentemente, casi una cuarta parte de nuestro conjunto de datos se eliminó mediante deduplicación. Cuando observamos los pares casi duplicados que se encontraron, muchos de ellos incluían cambios significativos. Recuerde el ejemplo del reloj anterior: el conjunto de datos puede incluir muchas imágenes del mismo reloj en diferentes momentos del día. Si bien es probable que estas imágenes hagan que el modelo memorice la apariencia de este reloj en particular, también podrían ayudarlo a aprender a distinguir entre las horas del día en un reloj. Dada la cantidad de datos que se eliminaron, nos preocupaba que eliminar imágenes como esta pudiera haber afectado el rendimiento del modelo.
Para probar el efecto de la deduplicación en nuestros modelos, entrenamos dos modelos con hiperparámetros idénticos: uno en el conjunto de datos completo y otro en la versión deduplicada del conjunto de datos. Para comparar los modelos, utilizamos las mismas evaluaciones humanas que utilizamos para evaluar nuestro modelo GLIDE original. Sorprendentemente, encontramos que los evaluadores humanos ligeramente privilegiado el modelo se entrenó con datos deduplicados, lo que sugiere que la gran cantidad de imágenes redundantes en el conjunto de datos en realidad estaba perjudicando el rendimiento.
Una vez que tuvimos un modelo entrenado con datos deduplicados, volvimos a ejecutar la búsqueda de regurgitación que habíamos realizado anteriormente en más de 50.000 mensajes del conjunto de datos de entrenamiento. Descubrimos que el nuevo modelo nunca regurgitó una imagen de entrenamiento cuando se le dio la indicación exacta para la imagen del conjunto de datos de entrenamiento. Para llevar esta prueba un paso más allá, también realizamos una búsqueda del vecino más cercano en todo el conjunto de datos de entrenamiento para cada una de las 50.000 imágenes generadas. De esta manera, pensamos que podríamos atrapar al modelo regurgitando una imagen diferente a la asociada con un mensaje determinado. Incluso con este control más exhaustivo, nunca encontramos un caso de regurgitación de imágenes.