TecNoticias, tu portal de información

Foto de Igor Shabalin, con permiso

Explorar la influencia mutua de las palabras en una oración mediante la evaluación de diferentes representaciones de incrustaciones BERT

La incrustación de BERT es lo que brinda grandes oportunidades cuando se trata de formas programáticas de extraer significado del texto. Parece que todo lo que nosotros (así como las máquinas) necesitamos para dar sentido al texto está oculto en esos números. Es solo una cuestión de manipular adecuadamente esos números. Discutí este concepto en mi publicación reciente Descubriendo tendencias en incrustaciones BERT de diferentes niveles para la tarea de determinación del contexto semántico. Este artículo continúa esta discusión, analizando si las representaciones vectoriales obtenidas al aplicar la transformada de Fourier a las incrustaciones de BERT también pueden ser útiles en tareas de NLP de extracción de significado. Como probablemente sepa por la física, la transformada de Fourier nos permite comprender las frecuencias dentro de una señal. . ¿Un vector que representa una palabra incrustada parece una señal? Es decir, ¿podría ser útil el conocimiento del dominio de la frecuencia derivado de la transformada de Fourier al procesar las incrustaciones de BERT para descubrir la cercanía semántica? En términos simples, ¿tiene sentido la transformada de Fourier al analizar las incrustaciones de BERT? Echémosle un vistazo. El ejemplo discutido en el resto de este artículo asume que tiene el modelo definido como se discutió en el ejemplo de la publicación anterior. También necesitaremos las representaciones derivadas de las oraciones de muestra como se discutió en esa publicación anterior. Tenga en cuenta, sin embargo, que este artículo utiliza un conjunto de muestras que son un poco diferentes de las utilizadas en la publicación anterior. Entonces, antes de crear las representaciones, deberá definir las siguientes muestras: envíos = []
sents.append(‘Tuve una muy buena manzana.’)
sents.append(‘Tuve una muy buena naranja.’)
sents.append(‘Tuve una aventura muy buena.’) Como puede ver, todas las oraciones tienen el mismo conjunto de modificadores de objeto directo, mientras que los objetos directos son diferentes en cada caso. El propósito de nuestro experimento es verificar cómo la cercanía semántica de los objetos directos afecta la proximidad de los modificadores. El proceso de tokenización y generación de estados ocultos para oraciones de muestra se cubrió en la publicación anterior. Así que no volveremos a cubrir este proceso aquí. Centrémonos en los modificadores de palabras (“a/muy/bueno”) del objeto directo (“manzana/naranja/aventura”) en cada oración. Para usar la indexación correcta al obtener sus incrustaciones, primero revisemos los tokens en nuestras oraciones: for i in range(len(sents)):
print(tokenizer.convert_ids_to_tokens(tokenized_text[i]))[‘[CLS]’, ‘i’, ‘tenía’, ‘a’, ‘muy’, ‘bueno’, ‘manzana’, ‘.’, ‘[SEP]’]
[‘[CLS]’, ‘i’, ‘tenía’, ‘a’, ‘muy’, ‘bueno’, ‘naranja’, ‘.’, ‘[SEP]’]
[‘[CLS]’, ‘i’, ‘tenía’, ‘a’, ‘muy’, ‘bueno’, ‘aventura’, ‘.’, ‘[SEP]’]Como estamos interesados ​​en los modificadores del objeto directo (en este ejemplo en particular, tenemos tres modificadores: a, muy, bueno), necesitamos los tokens con índices: 3,4,5. Entonces, necesitamos cambiar la indexación por 3. A continuación, obtenemos la incrustación contextual en cada oración para cada modificador. Mantendremos las incrustaciones de modificadores en una lista definida para cada oración: l12_1 = []
l12_2 = []
l12_3 = []
para i en el rango (3):
l12_1.append(estados_ocultos[0][12][0][i+3][:10].numpy())
l12_2.append(estados_ocultos[1][12][0][i+3][:10].numpy())
l12_3.append(estados_ocultos[2][12][0][i+3][:10].numpy()) Veamos ahora cómo la cercanía semántica de los objetos directos en diferentes oraciones afecta la cercanía de sus respectivos modificadores. from scipy import spatialfor i in range(3):
print(1 — espacial.distancia.coseno(l12_1[i]l12_2[i]))0.9003266096115112
0.9178041219711304
0.8865049481391907 En el resultado anterior, podemos ver que las incorporaciones contextuales de los modificadores Apple y Orange muestran un alto nivel de cercanía. Esto es bastante comprensible porque los propios objetos directos: Apple y Orange están muy cerca. Mientras que las representaciones derivadas de los modificadores Apple y Adventure no están tan cerca, como se puede ver en lo siguiente: for i in range(3):
print(1 — espacial.distancia.coseno(l12_1[i]l12_3[i]))0.49141737818717957
0.7987119555473328
0.6404531598091125 Se supone que los modificadores Naranja y Aventura tampoco deben estar tan cerca: para i en el rango (3):
print(1 — espacial.distancia.coseno(l12_2[i]l12_3[i]))0.7402883768081665
0.8417230844497681
0.7215733528137207 Ahora derivemos representaciones más complicadas de las incorporaciones proporcionadas por BERT. Para empezar, obtengamos las incrustaciones iniciales de los modificadores en cada oración: l0_1 = []
l0_2 = []
l0_3 = []
para i en el rango (3):
l0_1.append(estados_ocultos[0][0][0][i+3][:10].numpy())
l0_2.append(estados_ocultos[1][0][0][i+3][:10].numpy())
l0_3.append(estados_ocultos[2][0][0][i+3][:10].numpy()) Ahora podemos, por ejemplo, dividir incrustaciones contextuales (generadas en la capa 12 del codificador) por las incrustaciones iniciales correspondientes (como se discutió en la publicación anterior), para obtener nuevas representaciones de incrustaciones que se usarán en más análisis.importación numpy como np
l0_12_1 = []
l0_12_2 = []
l0_12_3 = []
para i en el rango (3):
l0_12_1.append(np.log(l12_1[i]/l0_1[i]))
l0_12_2.append(np.log(l12_2[i]/l0_2[i]))
l0_12_3.append(np.log(l12_3[i]/l0_3[i]))
para i en el rango (3):
l0_12_1[i] = np.where(np.isnan(l0_12_1[i]), 0, l0_12_1[i])
l0_12_2[i] = np.where(np.isnan(l0_12_2[i]), 0, l0_12_2[i])
l0_12_3[i] = np.where(np.isnan(l0_12_3[i]), 0, l0_12_3[i])Para fines de análisis, es posible que también desee crear otro conjunto de representaciones, calculando solo la diferencia de elementos entre la incrustación contextual y no contextual (inicial)._l0_12_1 = []
_l0_12_2 = []
_l0_12_3 = []
para i en el rango (3):
_l0_12_1.agregar(l12_1[i]-l0_1[i])
_l0_12_2.agregar(l12_2[i]-l0_2[i])
_l0_12_3.agregar(l12_3[i]-l0_3[i])Antes de proceder a evaluar las representaciones que acabamos de crear, creemos otro conjunto de representaciones usando la transformada de Fourier, para que luego podamos comparar todas nuestras representaciones obtenidas por diferentes métodos.fourierTransform_1=[]
FourierTransform_2=[]
FourierTransform_3=[]
para i en el rango (3):
fourierTransform_1.append(np.fft.fft(l0_12_1[i])/largo(l0_12_1[i]))
fourierTransform_2.append(np.fft.fft(l0_12_2[i])/largo(l0_12_2[i]))
fourierTransform_3.append(np.fft.fft(l0_12_3[i])/largo(l0_12_3[i]))Ahora podemos comparar las representaciones obtenidas para cada par de oraciones por modificador.print (sents[0])
imprimir (envia[1])
imprimir()
para i en el rango (3):
print(tokenizer.convert_ids_to_tokens(tokenized_text[0][i+3]))
print(‘diff’, 1 — espacial.distancia.coseno(_l0_12_1[i]_l0_12_2[i]))
print(‘log_quotient’, 1 — espacial.distancia.coseno(l0_12_1[i]l0_12_2[i]))
print(‘fourier’, 1 — espacial.distancia.coseno(abs(fourierTransform_1[i]), abs(transformación de Fourier_2[i])))
print() La salida producida debería tener el siguiente aspecto: Tuve una muy buena manzana.
Tuve una naranja muy buena.a
diferencia 0.8866338729858398
log_quotient 0.43184104561805725
fourier 0.9438706822278501muy
diferencia 0.9572229385375977
log_quotient 0.9539480209350586
fourier 0.9754009221726183bien
diferencia 0.8211167454719543
log_quotient 0.5680340528488159
fourier 0.7838190546462953 En el experimento anterior, esperamos ver un alto nivel de similitud entre los mismos modificadores en las dos primeras oraciones. De hecho, podemos ver que los métodos de la diferencia y la transformada de Fourier funcionaron bien en la tarea. El propósito del siguiente experimento es determinar la proximidad de los modificadores cuyos sustantivos modificados no son tan cercanos.[0])
imprimir (envia[2])
imprimir()
para i en el rango (3):
print(tokenizer.convert_ids_to_tokens(tokenized_text[0][i+3]))
print(‘diff’, 1 — espacial.distancia.coseno(_l0_12_1[i]_l0_12_3[i]))
print(‘log_quotient’, 1 — espacial.distancia.coseno(l0_12_1[i]l0_12_3[i]))
print(‘fourier’, 1 — espacial.distancia.coseno(abs(fourierTransform_1[i]), abs(transformación de Fourier_3[i])))
print() Aquí está el resultado: Tuve una muy buena manzana.
Tuve una muy buena aventura.a
diferencia 0.5641788840293884
log_quotient 0.5351020097732544
fourier 0.8501702469740261muy
diferencia 0.8958494067192078
log_quotient 0.5876994729042053
fourier 0.8582797441535993bien
diferencia 0.6836684346199036
log_quotient 0.18607155978679657
fourier 0.8857107252606878 El resultado anterior muestra que la diferencia y el cociente logarítmico fueron los mejores al evaluar la cercanía de los modificadores cuyos nombres relacionados no están tan cerca.[1])
imprimir (envia[2])
imprimir()
para i en el rango (3):
print(tokenizer.convert_ids_to_tokens(tokenized_text[0][i+3]))
print(‘diff’, 1 — espacial.distancia.coseno(_l0_12_2[i]_l0_12_3[i]))
print(‘log_quotient’, 1 — espacial.distancia.coseno(l0_12_2[i]l0_12_3[i]))
print(‘fourier’, 1 — espacial.distancia.coseno(abs(fourierTransform_2[i]), abs(transformación de Fourier_3[i])))
print() Las salidas son las siguientes: Tuve una muy buena naranja.
Tuve una muy buena aventura.a
diferencia 0.8232558369636536
log_quotient 0.7186723351478577
fourier 0.8378725099204362muy
diferencia 0.9369465708732605
log_quotient 0.6996179223060608
fourier 0.9164374584436726bien
diferencia 0.8077239990234375
log_quotient 0.5284199714660645
fourier 0.9069805698881434 Una vez más, podemos ver que la diferencia y el cociente logarítmico resultaron ser los mejores al evaluar la cercanía de los modificadores cuyos nombres relacionados no están tan cerca. ¿Tiene sentido la transformada de Fourier al analizar las incrustaciones de BERT? De acuerdo con el experimento realizado en este artículo, podemos concluir que este enfoque se puede usar de manera efectiva junto con otros métodos.