דף זה תורגם על ידי Cloud Translation API.
Switch to English

חקר הטבילות המסתובבות של TF-Hub CORD-19

צפה ב- TensorFlow.org הפעל בגוגל קולאב צפה ב- GitHub הורד מחברת ראה מודל רכזת TF

מודול הטמעת הטקסט CORD-19 המסתובב מ- TF-Hub (https: //tfhub.dev/tensorflow/cord-19/swivel-128d/1) נבנה כדי לתמוך בחוקרים בניתוח טקסטים בשפות טבעיות הקשורות לטקסטים. COVID19. שיבוצים אלה הוכשרו על כותרות, מחברים, תקצירים, טקסטי גוף וכותרות הפניה של מאמרים במערך CORD-19 .

במכלאה זו אנו:

  • לנתח מילים דומות סמנטית במרחב ההטבעה
  • התאמן מסווג במערך הנתונים SciCite באמצעות הטבילות CORD-19

להכין

import functools
import itertools
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import pandas as pd

import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
tf.logging.set_verbosity('ERROR')

import tensorflow_datasets as tfds
import tensorflow_hub as hub

try:
  from google.colab import data_table
  def display_df(df):
    return data_table.DataTable(df, include_index=False)
except ModuleNotFoundError:
  # If google-colab is not available, just display the raw DataFrame
  def display_df(df):
    return df

לנתח את הטבילות

נתחיל בניתוח ההטבעה על ידי חישוב ומתווה של מטריצת מתאם בין מונחים שונים. אם ההטבעה למדה לתפוס בהצלחה את משמעותן של מילים שונות, וקטורי ההטבעה של מילים דומות סמנטית צריכים להיות צמודים זה לזה. בואו נסתכל על כמה מונחים הקשורים ל- COVID-19.

# Use the inner product between two embedding vectors as the similarity measure
def plot_correlation(labels, features):
  corr = np.inner(features, features)
  corr /= np.max(corr)
  sns.heatmap(corr, xticklabels=labels, yticklabels=labels)


with tf.Graph().as_default():
  # Load the module
  query_input = tf.placeholder(tf.string)
  module = hub.Module('https://tfhub.dev/tensorflow/cord-19/swivel-128d/1')
  embeddings = module(query_input)

  with tf.train.MonitoredTrainingSession() as sess:

    # Generate embeddings for some terms
    queries = [
        # Related viruses
        "coronavirus", "SARS", "MERS",
        # Regions
        "Italy", "Spain", "Europe",
        # Symptoms
        "cough", "fever", "throat"
    ]

    features = sess.run(embeddings, feed_dict={query_input: queries})
    plot_correlation(queries, features)

png

אנו יכולים לראות כי ההטבעה תפסה בהצלחה את משמעות המונחים השונים. כל מילה דומה למילים האחרות של האשכול שלה (כלומר "נגיף כורמון" בקורלציה גבוהה עם "SARS" ו- "MERS"), בעוד שהן שונות ממונחים של אשכולות אחרים (כלומר הדמיון בין "SARS" ל"ספרד " קרוב ל 0).

עכשיו בואו נראה איך נוכל להשתמש בהטבעות האלה כדי לפתור משימה ספציפית.

SciCite: סיווג כוונת ציטוט

חלק זה מראה כיצד ניתן להשתמש בהטבעה למשימות במורד הזרם כגון סיווג טקסט. נשתמש במערך הנתונים SciCite ממערכי הנתונים של TensorFlow כדי לסווג את כוונות הציטוט בעבודות אקדמיות. בהינתן משפט עם ציטוט ממאמר אקדמי, סווג אם הכוונה העיקרית של הציטוט היא כמידע רקע, שימוש בשיטות או השוואה בין תוצאות.

הגדר את מערך הנתונים מ- TFDS

Downloading and preparing dataset scicite/1.0.0 (download: 22.12 MiB, generated: Unknown size, total: 22.12 MiB) to /home/kbuilder/tensorflow_datasets/scicite/1.0.0...
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/scicite/1.0.0.incompleteHWK5SE/scicite-train.tfrecord
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/scicite/1.0.0.incompleteHWK5SE/scicite-validation.tfrecord
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/scicite/1.0.0.incompleteHWK5SE/scicite-test.tfrecord
Dataset scicite downloaded and prepared to /home/kbuilder/tensorflow_datasets/scicite/1.0.0. Subsequent calls will reuse this data.

בואו נסתכל על כמה דוגמאות שכותרתו מתוך מערך האימונים

הכשרת מסווג כוונות סיטטון

נכשיר מסווג במערך הנתונים SciCite באמצעות Estimator. בואו נגדיר את input_fns לקריאת מערך הנתונים במודל

def preprocessed_input_fn(for_eval):
  data = THE_DATASET.get_data(for_eval=for_eval)
  data = data.map(THE_DATASET.example_fn, num_parallel_calls=1)
  return data


def input_fn_train(params):
  data = preprocessed_input_fn(for_eval=False)
  data = data.repeat(None)
  data = data.shuffle(1024)
  data = data.batch(batch_size=params['batch_size'])
  return data


def input_fn_eval(params):
  data = preprocessed_input_fn(for_eval=True)
  data = data.repeat(1)
  data = data.batch(batch_size=params['batch_size'])
  return data


def input_fn_predict(params):
  data = preprocessed_input_fn(for_eval=True)
  data = data.batch(batch_size=params['batch_size'])
  return data

בואו לבנות מודל המשתמש בטבלאות CORD-19 עם שכבת סיווג מעל.

def model_fn(features, labels, mode, params):
  # Embed the text
  embed = hub.Module(params['module_name'], trainable=params['trainable_module'])
  embeddings = embed(features['feature'])

  # Add a linear layer on top
  logits = tf.layers.dense(
      embeddings, units=THE_DATASET.num_classes(), activation=None)
  predictions = tf.argmax(input=logits, axis=1)

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(
        mode=mode,
        predictions={
            'logits': logits,
            'predictions': predictions,
            'features': features['feature'],
            'labels': features['label']
        })

  # Set up a multi-class classification head
  loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
      labels=labels, logits=logits)
  loss = tf.reduce_mean(loss)

  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=params['learning_rate'])
    train_op = optimizer.minimize(loss, global_step=tf.train.get_or_create_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  elif mode == tf.estimator.ModeKeys.EVAL:
    accuracy = tf.metrics.accuracy(labels=labels, predictions=predictions)
    precision = tf.metrics.precision(labels=labels, predictions=predictions)
    recall = tf.metrics.recall(labels=labels, predictions=predictions)

    return tf.estimator.EstimatorSpec(
        mode=mode,
        loss=loss,
        eval_metric_ops={
            'accuracy': accuracy,
            'precision': precision,
            'recall': recall,
        })

היפרפרמטרים

התאמן והעריך את המודל

בואו לאמן ולהעריך את המודל כדי לראות את הביצועים במשימה SciCite

estimator = tf.estimator.Estimator(functools.partial(model_fn, params=params))
metrics = []

for step in range(0, STEPS, EVAL_EVERY):
  estimator.train(input_fn=functools.partial(input_fn_train, params=params), steps=EVAL_EVERY)
  step_metrics = estimator.evaluate(input_fn=functools.partial(input_fn_eval, params=params))
  print('Global step {}: loss {:.3f}, accuracy {:.3f}'.format(step, step_metrics['loss'], step_metrics['accuracy']))
  metrics.append(step_metrics)
Global step 0: loss 0.796, accuracy 0.670
Global step 200: loss 0.701, accuracy 0.732
Global step 400: loss 0.682, accuracy 0.719
Global step 600: loss 0.650, accuracy 0.747
Global step 800: loss 0.620, accuracy 0.762
Global step 1000: loss 0.609, accuracy 0.762
Global step 1200: loss 0.605, accuracy 0.762
Global step 1400: loss 0.585, accuracy 0.783
Global step 1600: loss 0.586, accuracy 0.768
Global step 1800: loss 0.577, accuracy 0.774
Global step 2000: loss 0.584, accuracy 0.765
Global step 2200: loss 0.565, accuracy 0.778
Global step 2400: loss 0.570, accuracy 0.776
Global step 2600: loss 0.556, accuracy 0.789
Global step 2800: loss 0.563, accuracy 0.778
Global step 3000: loss 0.557, accuracy 0.784
Global step 3200: loss 0.566, accuracy 0.774
Global step 3400: loss 0.552, accuracy 0.782
Global step 3600: loss 0.551, accuracy 0.785
Global step 3800: loss 0.547, accuracy 0.788
Global step 4000: loss 0.549, accuracy 0.784
Global step 4200: loss 0.548, accuracy 0.785
Global step 4400: loss 0.553, accuracy 0.783
Global step 4600: loss 0.543, accuracy 0.786
Global step 4800: loss 0.548, accuracy 0.783
Global step 5000: loss 0.547, accuracy 0.785
Global step 5200: loss 0.539, accuracy 0.791
Global step 5400: loss 0.546, accuracy 0.782
Global step 5600: loss 0.548, accuracy 0.781
Global step 5800: loss 0.540, accuracy 0.791
Global step 6000: loss 0.542, accuracy 0.790
Global step 6200: loss 0.539, accuracy 0.792
Global step 6400: loss 0.545, accuracy 0.788
Global step 6600: loss 0.552, accuracy 0.781
Global step 6800: loss 0.549, accuracy 0.783
Global step 7000: loss 0.540, accuracy 0.788
Global step 7200: loss 0.543, accuracy 0.782
Global step 7400: loss 0.541, accuracy 0.787
Global step 7600: loss 0.532, accuracy 0.790
Global step 7800: loss 0.537, accuracy 0.792

global_steps = [x['global_step'] for x in metrics]
fig, axes = plt.subplots(ncols=2, figsize=(20,8))

for axes_index, metric_names in enumerate([['accuracy', 'precision', 'recall'],
                                            ['loss']]):
  for metric_name in metric_names:
    axes[axes_index].plot(global_steps, [x[metric_name] for x in metrics], label=metric_name)
  axes[axes_index].legend()
  axes[axes_index].set_xlabel("Global Step")

png

אנו יכולים לראות שההפסד פוחת במהירות ואילו במיוחד הדיוק עולה במהירות. בואו נתכנן כמה דוגמאות כדי לבדוק כיצד החיזוי קשור לתוויות האמיתיות:

predictions = estimator.predict(functools.partial(input_fn_predict, params))
first_10_predictions = list(itertools.islice(predictions, 10))

display_df(
  pd.DataFrame({
      TEXT_FEATURE_NAME: [pred['features'].decode('utf8') for pred in first_10_predictions],
      LABEL_NAME: [THE_DATASET.class_names()[pred['labels']] for pred in first_10_predictions],
      'prediction': [THE_DATASET.class_names()[pred['predictions']] for pred in first_10_predictions]
  }))

אנו יכולים לראות כי עבור מדגם אקראי זה, המודל מנבא את התווית הנכונה לרוב, מה שמצביע על כך שהוא יכול להטמיע משפטים מדעיים די טוב.

מה הלאה?

כעת, לאחר שהשגתם להכיר קצת יותר את הטבילות CORD-19 המסתובבות מ- TF-Hub, אנו ממליצים לכם להשתתף בתחרות CORD-19 Kaggle כדי לתרום להשגת תובנות מדעיות מטקסטים אקדמיים הקשורים ל- COVID-19.