Clasificaci贸n de texto con BERT Tokenizer y TF 2.0 en Python

    Este es el art铆culo n煤mero 23 de mi serie de art铆culos sobre Python para PNL. En el art铆culo anterior de esta serie, expliqu茅 c贸mo realizar la traducci贸n autom谩tica neuronal utilizando arquitectura seq2seq con la biblioteca Keras de Python para el aprendizaje profundo.

    En este art铆culo estudiaremos BERT, que significa Representaciones de codificador bidireccional de Transformers y su aplicaci贸n a la clasificaci贸n de texto. BERT es una t茅cnica de representaci贸n de texto como Word Embeddings. Si no tiene idea de c贸mo funcionan las incrustaciones de palabras, eche un vistazo a mi art铆culo sobre incrustaciones de palabras.

    Al igual que las incrustaciones de palabras, BERT es tambi茅n una t茅cnica de representaci贸n de texto que es una fusi贸n de una variedad de algoritmos de aprendizaje profundo de 煤ltima generaci贸n, como el codificador bidireccional LSTM y Transformers. BERT fue desarrollado por investigadores de Google en 2018 y se ha demostrado que es el estado de la t茅cnica para una variedad de tareas de procesamiento del lenguaje natural, como clasificaci贸n de texto, resumen de texto, generaci贸n de texto, etc. Recientemente, Google anunci贸 que BERT se utiliza como parte central de su algoritmo de b煤squeda para comprender mejor las consultas.

    En este art铆culo no entraremos en los detalles matem谩ticos de c贸mo se implementa BERT, ya que hay muchos recursos disponibles en l铆nea. M谩s bien, veremos c贸mo realizar la clasificaci贸n de texto utilizando BERT Tokenizer. En este art铆culo, ver谩 c贸mo se puede utilizar BERT Tokenizer para crear un modelo de clasificaci贸n de texto. En el pr贸ximo art铆culo explicar茅 c贸mo el BERT Tokenizer, junto con la capa de incrustaci贸n BERT, se puede utilizar para crear modelos de PNL a煤n m谩s eficientes.

    Nota: Todos los scripts de este art铆culo se han probado utilizando Google Colab entorno, con el tiempo de ejecuci贸n de Python configurado en GPU.

    El conjunto de datos

    El conjunto de datos utilizado en este art铆culo se puede descargar de este enlace de Kaggle.

    Si descarga el conjunto de datos y extrae el archivo comprimido, ver谩 un archivo CSV. El archivo contiene 50.000 registros y dos columnas: revisi贸n y opini贸n. La columna de opini贸n contiene texto para la opini贸n y la columna de opini贸n contiene la opini贸n de la opini贸n. La columna de sentimiento puede tener dos valores, es decir, “positivo” y “negativo”, lo que hace que nuestro problema sea un problema de clasificaci贸n binaria.

    Anteriormente, realizamos un an谩lisis sentimental de este conjunto de datos en un art铆culo anterior en el que logramos una precisi贸n m谩xima del 92% en el conjunto de entrenamiento mediante una t茅cnica de incrustaci贸n de palabras y una red neuronal convolucional. En el conjunto de prueba, la precisi贸n m谩xima lograda fue del 85,40% utilizando la incrustaci贸n de palabras y un LSTM 煤nico con 128 nodes. Veamos si podemos obtener una mayor precisi贸n utilizando la representaci贸n BERT.

    Instalaci贸n e importaci贸n de bibliotecas necesarias

    Antes de que pueda usar la representaci贸n de texto BERT, debe instalar BERT para TensorFlow 2.0. Ejecute los siguientes comandos pip en su terminal para instalar BERT para TensorFlow 2.0.

    !pip install bert-for-tf2
    !pip install sentencepiece
    

    A continuaci贸n, debe asegurarse de ejecutar TensorFlow 2.0. Google Colab, de forma predeterminada, no ejecuta su script en TensorFlow 2.0. Por lo tanto, para asegurarse de que est谩 ejecutando su secuencia de comandos a trav茅s de TensorFlow 2.0, ejecute la siguiente secuencia de comandos:

    try:
        %tensorflow_version 2.x
    except Exception:
        pass
    import tensorflow as tf
    
    import tensorflow_hub as hub
    
    from tensorflow.keras import layers
    import bert
    

    En el script anterior, adem谩s de TensorFlow 2.0, tambi茅n importamos tensorflow_hub, que b谩sicamente es un lugar donde puedes encontrar todos los modelos precompilados y preentrenados desarrollados en TensorFlow. Importaremos y usaremos un modelo BERT integrado desde TF hub. Finalmente, si en la salida ve la siguiente salida, est谩 listo para comenzar:

    TensorFlow 2.x selected.
    

    Importaci贸n y preprocesamiento del conjunto de datos

    El siguiente script importa el conjunto de datos usando el read_csv() m茅todo del marco de datos de Pandas. El script tambi茅n imprime la forma del conjunto de datos.

    movie_reviews = pd.read_csv("/content/drive/My Drive/Colab Datasets/IMDB Dataset.csv")
    
    movie_reviews.isnull().values.any()
    
    movie_reviews.shape
    

    Salida

    (50000, 2)
    

    El resultado muestra que nuestro conjunto de datos tiene 50.000 filas y 2 columnas.

    A continuaci贸n, preprocesaremos nuestros datos para eliminar cualquier puntuaci贸n y caracteres especiales. Para ello, definiremos una funci贸n que toma como entrada una revisi贸n de texto sin procesar y devuelve la correspondiente revisi贸n de texto limpio.

    def preprocess_text(sen):
        # Removing html tags
        sentence = remove_tags(sen)
    
        # Remove punctuations and numbers
        sentence = re.sub('[^a-zA-Z]', ' ', sentence)
    
        # Single character removal
        sentence = re.sub(r"s+[a-zA-Z]s+", ' ', sentence)
    
        # Removing multiple spaces
        sentence = re.sub(r's+', ' ', sentence)
    
        return sentence
    
    TAG_RE = re.compile(r'<[^>]+>')
    
    def remove_tags(text):
        return TAG_RE.sub('', text)
    

    El siguiente script limpia todas las revisiones de texto:

    reviews = []
    sentences = list(movie_reviews['review'])
    for sen in sentences:
        reviews.append(preprocess_text(sen))
    

    Nuestro conjunto de datos contiene dos columnas, como se puede verificar con el siguiente script:

    print(movie_reviews.columns.values)
    

    Salida:

    ['review' 'sentiment']
    

    los review columna contiene texto mientras que sentiment La columna contiene sentimientos. La columna de sentimientos contiene valores en forma de texto. El siguiente script muestra valores 煤nicos en el sentiment columna:

    movie_reviews.sentiment.unique()
    

    Salida:

    array(['positive', 'negative'], dtype=object)
    

    Puede ver que la columna de opini贸n contiene dos valores 煤nicos, es decir positive y negative. Los algoritmos de aprendizaje profundo funcionan con n煤meros. Como solo tenemos dos valores 煤nicos en la salida, podemos convertirlos en 1 y 0. La siguiente secuencia de comandos reemplaza positive sentimiento por 1 y el sentimiento negativo de 0.

    y = movie_reviews['sentiment']
    
    y = np.array(list(map(lambda x: 1 if x=="positive" else 0, y)))
    

    Ahora el reviews variable contienen revisiones de texto mientras que la y variable contiene las etiquetas correspondientes. Imprimamos una rese帽a al azar.

    print(reviews[10])
    

    Salida:

    Phil the Alien is one of those quirky films where the humour is based around the oddness of everything rather than actual punchlines At first it was very odd and pretty funny but as the movie progressed didn find the jokes or oddness funny anymore Its low budget film thats never problem in itself there were some pretty interesting characters but eventually just lost interest imagine this film would appeal to stoner who is currently partaking For something similar but better try Brother from another planet 
    

    Claramente parece una rese帽a negativa. Confirm茅moslo imprimiendo el valor de etiqueta correspondiente:

    print(y[10])
    

    Salida:

    0
    

    La salida 0 confirma que se trata de una revisi贸n negativa. Ahora hemos preprocesado nuestros datos y ahora estamos listos para crear representaciones BERT a partir de nuestros datos de texto.

    Creaci贸n de un tokenizador BERT

    Para usar las incrustaciones de texto BERT como entrada para entrenar el modelo de clasificaci贸n de texto, necesitamos tokenizar nuestras revisiones de texto. La tokenizaci贸n se refiere a dividir una oraci贸n en palabras individuales. Para tokenizar nuestro texto, usaremos el tokenizador BERT. Mira el siguiente gui贸n:

    BertTokenizer = bert.bert_tokenization.FullTokenizer
    bert_layer = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1",
                                trainable=False)
    vocabulary_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
    to_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
    tokenizer = BertTokenizer(vocabulary_file, to_lower_case)
    

    En el script de arriba, primero creamos un objeto del FullTokenizer clase de la bert.bert_tokenization m贸dulo. A continuaci贸n, creamos una capa de incrustaci贸n BERT importando el modelo BERT desde hub.KerasLayer. los trainable el par谩metro est谩 establecido en False, lo que significa que no capacitaremos a la incorporaci贸n de BERT. En la siguiente l铆nea, creamos un archivo de vocabulario BERT en forma de matriz numpy. Luego configuramos el texto en min煤sculas y finalmente pasamos nuestro vocabulary_file y to_lower_case variables a la BertTokenizer objeto.

    Es pertinente mencionar que en este art铆culo solo usaremos BERT Tokenizer. En el pr贸ximo art铆culo usaremos BERT Embeddings junto con tokenizer.

    Veamos ahora si nuestro tokenizador BERT est谩 realmente funcionando. Para hacerlo, convertiremos en token una oraci贸n aleatoria, como se muestra a continuaci贸n:

    tokenizer.tokenize("don't be so judgmental")
    

    Salida:

    ['don', "'", 't', 'be', 'so', 'judgment', '##al']
    

    Puede ver que el texto se ha tokenizado correctamente. Tambi茅n puede obtener los ID de los tokens usando el convert_tokens_to_ids() del objeto tokenizador. Mira el siguiente gui贸n:

    tokenizer.convert_tokens_to_ids(tokenizer.tokenize("dont be so judgmental"))
    

    Salida:

    [2123, 2102, 2022, 2061, 8689, 2389]
    

    Ahora definir谩 una funci贸n que acepta una sola revisi贸n de texto y devuelve los identificadores de las palabras tokenizadas en la revisi贸n. Ejecute el siguiente script:

    def tokenize_reviews(text_reviews):
        return tokenizer.convert_tokens_to_ids(tokenizer.tokenize(text_reviews))
    

    Y ejecute el siguiente script para convertir en token todas las revisiones en el conjunto de datos de entrada:

    tokenized_reviews = [tokenize_reviews(review) for review in reviews]
    

    Preparaci贸n de datos para entrenamiento

    Las revisiones en nuestro conjunto de datos tienen diferentes longitudes. Algunas rese帽as son muy peque帽as mientras que otras son muy largas. Para entrenar el modelo, las oraciones de entrada deben tener la misma longitud. Para crear oraciones de igual longitud, una forma es rellenar las oraciones m谩s cortas con ceros. Sin embargo, esto puede resultar en una matriz dispersa que contenga un gran n煤mero de ceros. La otra forma es rellenar oraciones dentro de cada lote. Dado que entrenaremos el modelo en lotes, podemos rellenar las oraciones dentro del lote de entrenamiento localmente dependiendo de la longitud de la oraci贸n m谩s larga. Para hacerlo, primero necesitamos encontrar la longitud de cada oraci贸n.

    La siguiente secuencia de comandos crea una lista de listas donde cada sublista contiene la revisi贸n tokenizada, la etiqueta de la revisi贸n y la duraci贸n de la revisi贸n:

    reviews_with_len = [[review, y[i], len(review)]
                     for i, review in enumerate(tokenized_reviews)]
    

    En nuestro conjunto de datos, la primera mitad de las rese帽as son positivas, mientras que la 煤ltima mitad contiene rese帽as negativas. Por lo tanto, para tener rese帽as tanto positivas como negativas en los lotes de capacitaci贸n, necesitamos mezclar las rese帽as. La siguiente secuencia de comandos baraja los datos de forma aleatoria:

    random.shuffle(reviews_with_len)
    

    Una vez que se barajan los datos, los ordenaremos seg煤n la duraci贸n de las revisiones. Para hacerlo, usaremos el sort() funci贸n de la lista y le dir谩 que queremos ordenar la lista con respecto al tercer elemento de la sublista, es decir, la duraci贸n de la revisi贸n.

    reviews_with_len.sort(key=lambda x: x[2])
    

    Una vez que las rese帽as est谩n ordenadas por longitud, podemos eliminar el atributo de longitud de todas las rese帽as. Ejecute el siguiente script para hacerlo:

    sorted_reviews_labels = [(review_lab[0], review_lab[1]) for review_lab in reviews_with_len]
    

    Una vez ordenadas las revisiones, convertiremos el conjunto de datos d para que pueda usarse para entrenar modelos de TensorFlow 2.0. Ejecute el siguiente c贸digo para convertir el conjunto de datos ordenado en una forma de conjunto de datos de entrada compatible con TensorFlow 2.0.

    processed_dataset = tf.data.Dataset.from_generator(lambda: sorted_reviews_labels, output_types=(tf.int32, tf.int32))
    

    Finalmente, ahora podemos rellenar nuestro conjunto de datos para cada lote. El tama帽o de lote que vamos a utilizar es 32, lo que significa que despu茅s de procesar 32 revisiones, se actualizar谩n los pesos de la red neuronal. Para rellenar las revisiones localmente con respecto a los lotes, ejecute lo siguiente:

    BATCH_SIZE = 32
    batched_dataset = processed_dataset.padded_batch(BATCH_SIZE, padded_shapes=((None, ), ()))
    

    Imprimamos el primer lote y veamos c贸mo se le ha aplicado el relleno:

    next(iter(batched_dataset))
    

    Salida:

    (<tf.Tensor: shape=(32, 21), dtype=int32, numpy=
     array([[ 2054,  5896,  2054,  2466,  2054,  6752,     0,     0,     0,
                 0,     0,     0,     0,     0,     0,     0,     0,     0,
                 0,     0,     0],
            [ 3078,  5436,  3078,  3257,  3532,  7613,     0,     0,     0,
                 0,     0,     0,     0,     0,     0,     0,     0,     0,
                 0,     0,     0],
            [ 3191,  1996,  2338,  5293,  1996,  3185,     0,     0,     0,
                 0,     0,     0,     0,     0,     0,     0,     0,     0,
                 0,     0,     0],
            [ 2062, 23873,  3993,  2062, 11259,  2172,  2172,  2062, 14888,
                 0,     0,     0,     0,     0,     0,     0,     0,     0,
                 0,     0,     0],
            [ 1045,  2876,  9278,  2023,  2028,  2130,  2006,  7922, 12635,
              2305,     0,     0,     0,     0,     0,     0,     0,     0,
                 0,     0,     0],
          ......
          
            [ 7244,  2092,  2856, 10828,  1997, 10904,  2402,  2472,  3135,
              2293,  2466,  2007, 10958,  8428, 10102,  1999,  1996,  4281,
              4276,  3773,     0],
            [ 2005,  5760,  7788,  4393,  8808,  2498,  2064, 12826,  2000,
              1996, 11056,  3152,  3811, 16755,  2169,  1998,  2296,  2028,
              1997,  2068,     0],
            [ 2307,  3185,  2926,  1996,  2189,  3802,  2696,  2508,  2012,
              2197,  2023,  8847,  6702,  2043,  2017,  2031,  2633,  2179,
              2008,  2569,  2619],
            [ 2028,  1997,  1996,  4569, 15580,  2102,  5691,  2081,  1999,
              3522,  2086,  2204, 23191,  5436,  1998, 11813,  6370,  2191,
              2023,  2028,  4438],
            [ 2023,  3185,  2097,  2467,  2022,  5934,  1998,  3185,  4438,
              2004,  2146,  2004,  2045,  2024,  2145,  2111,  2040,  6170,
              3153,  1998,  2552]], dtype=int32)>,
     <tf.Tensor: shape=(32,), dtype=int32, numpy=
     array([0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1,
            1, 1, 0, 1, 0, 1, 1, 0, 1, 1], dtype=int32)>)
    

    El resultado anterior muestra las cinco primeras y las cinco 煤ltimas revisiones acolchadas. En las 煤ltimas cinco revisiones, puede ver que el n煤mero total de palabras en la oraci贸n m谩s grande fue 21. Por lo tanto, en las primeras cinco revisiones, los 0 se agregan al final de las oraciones para que su longitud total tambi茅n sea 21. El relleno para el siguiente lote ser谩 diferente seg煤n el tama帽o de la oraci贸n m谩s grande del lote.

    Una vez que hemos aplicado el relleno a nuestro conjunto de datos, el siguiente paso es dividir el conjunto de datos en conjuntos de prueba y entrenamiento. Podemos hacer eso con la ayuda del siguiente c贸digo:

    TOTAL_BATCHES = math.ceil(len(sorted_reviews_labels) / BATCH_SIZE)
    TEST_BATCHES = TOTAL_BATCHES // 10
    batched_dataset.shuffle(TOTAL_BATCHES)
    test_data = batched_dataset.take(TEST_BATCHES)
    train_data = batched_dataset.skip(TEST_BATCHES)
    

    En el c贸digo anterior, primero encontramos el n煤mero total de lotes dividiendo el total de registros por 32. Luego, el 10% de los datos se deja a un lado para la prueba. Para hacerlo, usamos el take() m茅todo de batched_dataset() objeto de almacenar el 10% de los datos en el test_data variable. Los datos restantes se almacenan en el train_data objeto de entrenamiento utilizando el skip() m茅todo.

    El conjunto de datos se ha preparado y ahora estamos listos para crear nuestro modelo de clasificaci贸n de texto.

    Creando el modelo

    Ahora estamos listos para crear nuestro modelo. Para hacerlo, crearemos una clase llamada TEXT_MODEL que hereda del tf.keras.Model clase. Dentro de la clase definiremos nuestras capas de modelo. Nuestro modelo constar谩 de tres capas de redes neuronales convolucionales. En su lugar, puede usar capas LSTM y tambi茅n puede aumentar o disminuir el n煤mero de capas. He copiado el n煤mero y los tipos de capas de Cuaderno colab de Google de SuperDataScience y esta arquitectura tambi茅n parece funcionar bastante bien para el conjunto de datos de rese帽as de pel铆culas de IMDB.

    Ahora creemos nuestra clase modelo:

    class TEXT_MODEL(tf.keras.Model):
        
        def __init__(self,
                     vocabulary_size,
                     embedding_dimensions=128,
                     cnn_filters=50,
                     dnn_units=512,
                     model_output_classes=2,
                     dropout_rate=0.1,
                     training=False,
                     name="text_model"):
            super(TEXT_MODEL, self).__init__(name=name)
            
            self.embedding = layers.Embedding(vocabulary_size,
                                              embedding_dimensions)
            self.cnn_layer1 = layers.Conv1D(filters=cnn_filters,
                                            kernel_size=2,
                                            padding="valid",
                                            activation="relu")
            self.cnn_layer2 = layers.Conv1D(filters=cnn_filters,
                                            kernel_size=3,
                                            padding="valid",
                                            activation="relu")
            self.cnn_layer3 = layers.Conv1D(filters=cnn_filters,
                                            kernel_size=4,
                                            padding="valid",
                                            activation="relu")
            self.pool = layers.GlobalMaxPool1D()
            
            self.dense_1 = layers.Dense(units=dnn_units, activation="relu")
            self.dropout = layers.Dropout(rate=dropout_rate)
            if model_output_classes == 2:
                self.last_dense = layers.Dense(units=1,
                                               activation="sigmoid")
            else:
                self.last_dense = layers.Dense(units=model_output_classes,
                                               activation="softmax")
        
        def call(self, inputs, training):
            l = self.embedding(inputs)
            l_1 = self.cnn_layer1(l) 
            l_1 = self.pool(l_1) 
            l_2 = self.cnn_layer2(l) 
            l_2 = self.pool(l_2)
            l_3 = self.cnn_layer3(l)
            l_3 = self.pool(l_3) 
            
            concatenated = tf.concat([l_1, l_2, l_3], axis=-1) # (batch_size, 3 * cnn_filters)
            concatenated = self.dense_1(concatenated)
            concatenated = self.dropout(concatenated, training)
            model_output = self.last_dense(concatenated)
            
            return model_output
    

    El script anterior es bastante sencillo. En el constructor de la clase, inicializamos algunos atributos con valores predeterminados. Estos valores ser谩n reemplazados m谩s adelante por los valores pasados 鈥嬧媍uando el objeto del TEXT_MODEL se crea la clase.

    A continuaci贸n, se han inicializado tres capas de red neuronal convolucional con los valores de kernel o filtro de 2, 3 y 4, respectivamente. Nuevamente, puede cambiar los tama帽os de filtro si lo desea.

    A continuaci贸n, dentro del call() funci贸n, la agrupaci贸n m谩xima global se aplica a la salida de cada una de las capas de red neuronal convolucional. Finalmente, las tres capas de la red neuronal convolucional se concatenan juntas y su salida se alimenta a la primera red neuronal densamente conectada. La segunda red neuronal densamente conectada se utiliza para predecir el sentimiento de salida, ya que solo contiene 2 clases. En caso de que tenga m谩s clases en la salida, puede actualizar el output_classes variable en consecuencia.

    Definamos ahora los valores para los hiperpar谩metros de nuestro modelo.

    VOCAB_LENGTH = len(tokenizer.vocab)
    EMB_DIM = 200
    CNN_FILTERS = 100
    DNN_UNITS = 256
    OUTPUT_CLASSES = 2
    
    DROPOUT_RATE = 0.2
    
    NB_EPOCHS = 5
    

    A continuaci贸n, necesitamos crear un objeto de la TEXT_MODEL class y pasar los valores de hiperpar谩metros que definimos en el 煤ltimo paso al constructor del TEXT_MODEL clase.

    text_model = TEXT_MODEL(vocabulary_size=VOCAB_LENGTH,
                            embedding_dimensions=EMB_DIM,
                            cnn_filters=CNN_FILTERS,
                            dnn_units=DNN_UNITS,
                            model_output_classes=OUTPUT_CLASSES,
                            dropout_rate=DROPOUT_RATE)
    

    Antes de que podamos entrenar el modelo, necesitamos compilarlo. El siguiente script compila el modelo:

    if OUTPUT_CLASSES == 2:
        text_model.compile(loss="binary_crossentropy",
                           optimizer="adam",
                           metrics=["accuracy"])
    else:
        text_model.compile(loss="sparse_categorical_crossentropy",
                           optimizer="adam",
                           metrics=["sparse_categorical_accuracy"])
    

    Finalmente para entrenar nuestro modelo, podemos usar el fit m茅todo de la clase modelo.

    text_model.fit(train_data, epochs=NB_EPOCHS)
    

    Aqu铆 est谩 el resultado despu茅s de 5 茅pocas:

    Epoch 1/5
    1407/1407 [==============================] - 381s 271ms/step - loss: 0.3037 - accuracy: 0.8661
    Epoch 2/5
    1407/1407 [==============================] - 381s 271ms/step - loss: 0.1341 - accuracy: 0.9521
    Epoch 3/5
    1407/1407 [==============================] - 383s 272ms/step - loss: 0.0732 - accuracy: 0.9742
    Epoch 4/5
    1407/1407 [==============================] - 381s 271ms/step - loss: 0.0376 - accuracy: 0.9865
    Epoch 5/5
    1407/1407 [==============================] - 383s 272ms/step - loss: 0.0193 - accuracy: 0.9931
    <tensorflow.python.keras.callbacks.History at 0x7f5f65690048>
    

    Puede ver que obtuvimos una precisi贸n del 99,31% en el conjunto de entrenamiento.

    Evaluemos ahora el rendimiento de nuestro modelo en el conjunto de prueba:

    results = text_model.evaluate(test_dataset)
    print(results)
    

    Salida:

    156/Unknown - 4s 28ms/step - loss: 0.4428 - accuracy: 0.8926[0.442786190037926, 0.8926282]
    

    A partir de la salida, podemos ver que obtuvimos una precisi贸n del 89,26% en el conjunto de prueba.

    Conclusi贸n

    En este art铆culo, vio c贸mo podemos usar BERT Tokenizer para crear incrustaciones de palabras que se pueden usar para realizar la clasificaci贸n de texto. Realizamos un an谩lisis sentimental de las rese帽as de pel铆culas de IMDB y logramos una precisi贸n del 89,26% en el conjunto de prueba. En este art铆culo no usamos incrustaciones de BERT, solo usamos BERT Tokenizer para tokenizar las palabras. En el siguiente art铆culo, ver谩 c贸mo BERT Tokenizer junto con BERT Embeddings se pueden utilizar para realizar la clasificaci贸n de texto.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *