ניתוח יישויות, סנטימנט ותחביר באמצעות Cloud Cloud Language API

ממשק ה-API של Cloud הטבעי של השפה מאפשר לחלץ ישויות מהטקסט, לבצע ניתוח של תחושה ותחביר, ולסווג טקסט לקטגוריות.

בשיעור ה-Lab הזה תלמדו איך להשתמש ב-טבע השפה, כדי לנתח ישויות, סנטימנט ותחביר.

מה תלמדו

  • יצירת בקשה ל-API של שפת שפה וקריאה ל-API באמצעות תלתל
  • חילוץ ישויות והפעלת ניתוח סנטימנט בטקסט באמצעות ה-API של שפת הטבע
  • ביצוע ניתוח לשוני בטקסט באמצעות ממשק ה-API של שפת הטבע
  • יצירת בקשה ל-API של שפה טבעית (NLP) בשפה אחרת

עוימות

  • פרויקט של Google Cloud Platform
  • דפדפן, למשל Chrome או Firefox

איך תשתמשו במדריך הזה?

לקרוא אותו בלבד לקרוא אותו ולהשלים את התרגילים

איך היית מדרג את החוויה שלך ב-Google Cloud Platform?

מתחילים מתחילים בקיאים

הגדרת סביבה בקצב עצמי

אם עדיין אין לכם חשבון Google (Gmail או Google Apps), עליכם ליצור חשבון. נכנסים למסוף ב-Google Cloud Platform (console.cloud.google.com) ויוצרים פרויקט חדש:

צילום מסך מ-2016-02-10 12:45:26.png

חשוב לזכור את מזהה הפרויקט הוא שם ייחודי בכל הפרויקטים ב-Google Cloud (השם הקודם כבר תפוס, והוא לא יעבוד בשבילך.) נתייחס אליו מאוחר יותר ב-codelab הזה בתור PROJECT_ID.

לאחר מכן, עליך להפעיל חיוב ב-Cloud Console כדי להשתמש במשאבים של Google Cloud.

התהליך של קוד Lab זה לא אמור לעלות יותר מדולר אחד, אבל יכול להיות שתצטרכו לשלם על משאבים נוספים או להשאיר אותו פעיל (עיינו בקטע "cleanup" בסוף המסמך).

משתמשים חדשים ב-Google Cloud Platform זכאים לתקופת ניסיון בחינם בשווי 300$.

לוחצים על סמל התפריט בפינה הימנית העליונה של המסך.

בוחרים באפשרות APIs & Services מתוך התפריט הנפתח ולוחצים על 'מרכז השליטה'.

לוחצים על הפעלת ממשקי API ושירותים.

לאחר מכן, מחפשים את הביטוי "language" בתיבת החיפוש. לוחצים על Google Cloud הטבעי Language API:

לוחצים על הפעלה כדי להפעיל את Cloud Cloud Language API:

ממתינים מספר שניות עד שהיא תופעל. יוצג לך ברגע שהיא תופעל:

התכונה Google Cloud Shell היא סביבת שורת פקודה שפועלת ב-Cloud. המכונה הווירטואלית המבוססת על Debian נטענת עם כל כלי הפיתוח הדרושים לך (gcloud, bq, git ואחרים) וספריית בית קבועה בנפח של 5GB. אנחנו נשתמש ב-Cloud Shell כדי ליצור את הבקשה שלנו ל-NLP API.

כדי להתחיל להשתמש ב-Cloud Shell, לוחצים על הסמל "הפעלת Google Cloud Shell" צילום מסך 2015-06-08 ב-17.30.32 בפינה השמאלית העליונה של סרגל הכותרת

סשן של Cloud Shell ייפתח בתוך מסגרת חדשה בחלק התחתון של המסוף, ויציג הודעה בשורת הפקודה. יש להמתין עד שהדף user@project:~$ תופיע

מכיוון שאנחנו נשתמש ב-Curl כדי לשלוח בקשה ל-API של שפת השפה, נצטרך ליצור מפתח API כדי להעביר אותו לכתובת ה-URL של הבקשה. כדי ליצור מפתח API, נכנסים לקטע 'פרטי כניסה' בממשקי ה-API ו-amp; Console במסוף Cloud:

בתפריט הנפתח, בוחרים באפשרות מפתח API:

לאחר מכן, מעתיקים את המפתח שיצרת עכשיו. יהיה צורך להשתמש במפתח הזה מאוחר יותר בשיעור ה-Lab.

עכשיו, אחרי שיש לך מפתח API, עליך לשמור אותו במשתנה סביבה כדי להימנע מהוספת הערך של מפתח ה-API בכל בקשה. ניתן לעשות זאת ב-Cloud Shell. עליך להחליף את <your_api_key> במפתח שהעתקת עכשיו.

export API_KEY=<YOUR_API_KEY>

השיטה הראשונה של ממשק ה-API לשפה טבעית שבה נשתמש analyzeEntities. בשיטה הזו, ה-API יכול לחלץ ישויות (כמו אנשים, מקומות ואירועים) מטקסט. כדי לנסות את ניתוח הישות API, נשתמש במשפט הבא:

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

נבנה את הבקשה שלנו ל-API של שפת הטבע בקובץ request.json. בסביבת Cloud Shell, יוצרים את הקובץ request.json עם הקוד למטה. תוכלו ליצור את הקובץ באמצעות אחד מעורכי שורת הפקודה המועדפים עליכם (nano, vim, emacs) או להשתמש בעורך המובנה של Orion ב-Cloud Shell:

request.json

{
  "document":{
    "type":"PLAIN_TEXT",
    "content":"Joanne Rowling, who writes under the pen names J. K. Rowling and Robert Galbraith, is a British novelist and screenwriter who wrote the Harry Potter fantasy series."
  },
  "encodingType":"UTF8"
}

בבקשה, אנחנו מוסרים ל- הטבעי Language API לגבי הטקסט שאנחנו נשלח. ערכי הסוגים הנתמכים הם PLAIN_TEXT או HTML. בתוכן, אנחנו מעבירים את הטקסט לשליחה אל ה-API של שפת הטבע לצורך ניתוח. ממשק ה-API של שפת השפה תומך גם בשליחת קבצים המאוחסנים ב-Cloud Storage לעיבוד טקסט. אם אנחנו רוצים לשלוח קובץ מ-Cloud Storage, נחליף את content ב-gcsContentUri ונספק לו ערך של קובץ ה-URI של קובץ הטקסט שלנו ב-Cloud Storage. encodingType מורה ל-API באיזה סוג של קידוד טקסט להשתמש במהלך עיבוד הטקסט שלנו. ה-API ישתמש בו כדי לחשב היכן יופיעו ישויות ספציפיות בטקסט שלנו.

עכשיו אפשר להעביר את גוף הבקשה, יחד עם משתנה סביבת המפתח של ה-API ששמרתם קודם, ל-API של שפת השפה עם הפקודה curl הבאה (הכול בשורת פקודה אחת):

curl "https://language.googleapis.com/v1/documents:analyzeEntities?key=${API_KEY}" \
  -s -X POST -H "Content-Type: application/json" --data-binary @request.json

תחילת התגובה אמורה להיראות כך:

{
  "entities": [
     {
      "name": "Robert Galbraith",
      "type": "PERSON",
      "metadata": {
        "mid": "/m/042xh",
        "wikipedia_url": "https://en.wikipedia.org/wiki/J._K._Rowling"
      },
      "salience": 0.7980405,
      "mentions": [
        {
          "text": {
            "content": "Joanne Rowling",
            "beginOffset": 0
          },
          "type": "PROPER"
        },
        {
          "text": {
            "content": "Rowling",
            "beginOffset": 53
          },
          "type": "PROPER"
        },
        {
          "text": {
            "content": "novelist",
            "beginOffset": 96
          },
          "type": "COMMON"
        },
        {
          "text": {
            "content": "Robert Galbraith",
            "beginOffset": 65
          },
          "type": "PROPER"
        }
      ]
    },

    ...
  ]
}

לגבי כל ישות בתגובה, אנחנו מקבלים את הישות type, כתובת ה-URL המשויכת של ויקיפדיה אם יש ישות כזו, salience וכן האינדקסים שבהם מופיעה הישות בטקסט. סבילות היא מספר בטווח [0,1] המתייחס למרכזיות של הישות לטקסט כולו. ממשק ה-API של שפה טבעית יכול גם לזהות את אותה ישות שצוינה בדרכים שונות. הסתכלו על הרשימה mentions בתגובה: , ממשק ה-API יכול לומר זאת. כמו כן, יש להשתמש ב-"ג'ואן רולינג&&;

בנוסף לחילוץ ישויות, ה-API של שפה טבעית מאפשר גם לבצע ניתוח סנטימנט בבלוק טקסט. בקשת ה-JSON שלנו תכלול את אותם הפרמטרים שצוינו בבקשה הקודמת, אבל הפעם נשנה את הטקסט כך שיכלול משהו עם סנטימנט חזק יותר. יש להחליף את הקובץ request.json בקובץ הבא, ולהחליף את content בטקסט עצמו:

request.json

 {
  "document":{
    "type":"PLAIN_TEXT",
    "content":"Harry Potter is the best book. I think everyone should read it."
  },
  "encodingType": "UTF8"
}

בהמשך נעביר את הבקשה לנקודת הקצה analyzeSentiment של ה-API:

curl "https://language.googleapis.com/v1/documents:analyzeSentiment?key=${API_KEY}" \
  -s -X POST -H "Content-Type: application/json" --data-binary @request.json

התגובה שלך אמורה להיראות כך:

{
  "documentSentiment": {
    "magnitude": 0.8,
    "score": 0.4
  },
  "language": "en",
  "sentences": [
    {
      "text": {
        "content": "Harry Potter is the best book.",
        "beginOffset": 0
      },
      "sentiment": {
        "magnitude": 0.7,
        "score": 0.7
      }
    },
    {
      "text": {
        "content": "I think everyone should read it.",
        "beginOffset": 31
      },
      "sentiment": {
        "magnitude": 0.1,
        "score": 0.1
      }
    }
  ]
}

שימו לב שאנחנו מקבלים שני סוגים של ערכי סנטימנט: סנטימנט למסמך כולו, וסנטימנט מחולק למשפט. שיטת סנטימנט מחזירה שני ערכים: score ו-magnitude. score הוא מספר בין 1.0- ל-1.0 המציין עד כמה המשפט חיובי או שלילי. magnitude הוא מספר שנע בין 0 ל-אינסוף, המייצג את המשקל של סנטימנט המוצהר בהצהרה, ללא קשר חיובי או שלילי. לקטעי טקסט ארוכים יותר עם הצהרות משוקללות כבדות יש ערך גבוה יותר. הציון במשפט הראשון הוא חיובי (0.7), ואילו הציון במשפט השני הוא ניטרלי (0.1).

בנוסף להצגת פרטי סנטימנט בכל מסמך הטקסט שאנחנו שולחים בממשק ה-API של NL, אפשר גם להציג פירוט של סנטימנט הישויות לגבי הישויות בטקסט שלנו. השתמש במשפט הזה כדוגמה:

אהבתי את הסושי אבל השירות היה נורא.

במקרה כזה, ייתכן שהציון של סנטימנט מסוים בכל המשפט כולו יהיה לא מועיל. אם מדובר בביקורת על מסעדה ובמאות מאות ביקורות על אותה מסעדה, היינו רוצים לדעת בדיוק אילו ביקורות אנשים אהבו או לא אהבו בביקורות שלהם. למזלנו, ל-NL API יש שיטה שמאפשרת לנו לקבל את סנטימנט מסוים לגבי כל ישות בטקסט, שנקראת analyzeEntitySentiment. יש לעדכן את ה-request.json במשפט שלמעלה כדי לנסות אותו:

request.json

 {
  "document":{
    "type":"PLAIN_TEXT",
    "content":"I liked the sushi but the service was terrible."
  },
  "encodingType": "UTF8"
}

לאחר מכן, צריך להתקשר לנקודת הקצה analyzeEntitySentiment עם פקודת ה-URL הבאה:

curl "https://language.googleapis.com/v1/documents:analyzeEntitySentiment?key=${API_KEY}" \
  -s -X POST -H "Content-Type: application/json" --data-binary @request.json

בתגובה אנחנו מקבלים שני אובייקטים מסוג ישות: אחד עבור "sסושי" ואחד עבור "service." זוהי תגובת ה-JSON המלאה:

{
  "entities": [
    {
      "name": "sushi",
      "type": "CONSUMER_GOOD",
      "metadata": {},
      "salience": 0.52716845,
      "mentions": [
        {
          "text": {
            "content": "sushi",
            "beginOffset": 12
          },
          "type": "COMMON",
          "sentiment": {
            "magnitude": 0.9,
            "score": 0.9
          }
        }
      ],
      "sentiment": {
        "magnitude": 0.9,
        "score": 0.9
      }
    },
    {
      "name": "service",
      "type": "OTHER",
      "metadata": {},
      "salience": 0.47283158,
      "mentions": [
        {
          "text": {
            "content": "service",
            "beginOffset": 26
          },
          "type": "COMMON",
          "sentiment": {
            "magnitude": 0.9,
            "score": -0.9
          }
        }
      ],
      "sentiment": {
        "magnitude": 0.9,
        "score": -0.9
      }
    }
  ],
  "language": "en"
}

ניתן לראות שהציון החזיר עבור "s מותאמים ל-" היה 0.9, ואילו &"service" קיבל ציון של -0.9. מגניב! כמו כן, ייתכן שתראו שיש 2 אובייקטים של סנטימנט שהוחזר לכל ישות. אם אחד מהתנאים האלה מוזכר יותר מפעם אחת, ה-API מחזיר ציון ועוצמה שונים של כל אזכור, יחד עם סנטימנט מצטבר לישות.

הסתכלנו על השיטה השלישית של ממשק ה-API של השפה הטבעית – הערת תחביר – אנחנו מתעמקים בפרטים של הטקסטים. analyzeSyntax היא שיטה שמספקת קבוצת פרטים מלאה של הרכיבים הסמנטיים והתחביריים של הטקסט. עבור כל מילה בטקסט, ה-API יספר לנו את החלק של הדיבור (שם עצם, פועל, תואר וכו') ואיך הוא קשור למילים אחרות במשפט (האם זה פועל הבסיס? ערך משנה?).

ננסה זאת במשפט פשוט. בקשת ה-JSON שלנו תהיה דומה לבקשה שלמעלה, עם הוספה של מפתח תכונות. פעולה זו תיידע את ה-API שאנו מעוניינים לבצע הערה בתחביר. יש להחליף את request.json בפריטים הבאים:

request.json

{
  "document":{
    "type":"PLAIN_TEXT",
    "content": "Hermione often uses her quick wit, deft recall, and encyclopaedic knowledge to help Harry and Ron."
  },
  "encodingType": "UTF8"
}

לאחר מכן התקשרו לשיטה analyzeSyntax של ה-API&:

curl "https://language.googleapis.com/v1/documents:analyzeSyntax?key=${API_KEY}" \
  -s -X POST -H "Content-Type: application/json" --data-binary @request.json

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

{
  "text": {
    "content": "uses",
    "beginOffset": 15
  },
  "partOfSpeech": {
    "tag": "VERB",
    "aspect": "ASPECT_UNKNOWN",
    "case": "CASE_UNKNOWN",
    "form": "FORM_UNKNOWN",
    "gender": "GENDER_UNKNOWN",
    "mood": "INDICATIVE",
    "number": "SINGULAR",
    "person": "THIRD",
    "proper": "PROPER_UNKNOWN",
    "reciprocity": "RECIPROCITY_UNKNOWN",
    "tense": "PRESENT",
    "voice": "VOICE_UNKNOWN"
  },
    "dependencyEdge": {
      "headTokenIndex": 2,
      "label": "ROOT"
    },
    "lemma": "use"
}

פירטנו את התגובה. partOfSpeech מספק לנו פרטים לשוניים על כל מילה (רבים מהם לא ידועים כי הם לא רלוונטיים לאנגלית או למילה הספציפית הזו). במקרה כזה, tag נותן את החלק של הדיבור במילה הזו, במקרה הזה, פועל. אנחנו גם מקבלים פרטים על זמן, צורה והאם המילה יחיד או רבים. lemma הוא צורה קנונית של המילה (עבור "uses" &&33;s "use"). לדוגמה, המילים Run, Run, run ו-ריצה כללו את המילה mm run. ערך לאמה שימושי למעקב אחר מופעים של מילה בקטע טקסט גדול לאורך זמן.

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

ה-headTokenIndex בתגובה שלנו הוא אינדקס האסימון עם קשת שמפנה אל "uses". אנו יכולים לחשוב על כל אסימון במשפט כמילה במערך, וה-headTokenIndex מתוך 2 עבור "uses" מתייחס למילה "לרוב," שאליו הוא מחובר בעץ.

API של שפה טבעית תומך גם בשפות שאינן אנגלית (הרשימה המלאה זמינה כאן). בוא ננסה את בקשת הישות הבאה עם משפט ביפנית:

request.json

{
  "document":{
    "type":"PLAIN_TEXT",
    "content":"日本のグーグルのオフィスは、東京の六本木ヒルズにあります"
  },
  "encodingType": "UTF8"
}

שימו לב שלא אמרנו ל-API איזו שפה כתוב הטקסט שלנו, הוא יכול לזהות אותו באופן אוטומטי. בשלב הבא, נשלח אותו לנקודת הקצה analyzeEntities:

curl "https://language.googleapis.com/v1/documents:analyzeEntities?key=${API_KEY}" \
  -s -X POST -H "Content-Type: application/json" --data-binary @request.json

ואלו שתי הישויות הראשונות בתגובה שלנו:

{
  "entities": [
    {
      "name": "日本",
      "type": "LOCATION",
      "metadata": {
        "mid": "/m/03_3d",
        "wikipedia_url": "https://en.wikipedia.org/wiki/Japan"
      },
      "salience": 0.23854347,
      "mentions": [
        {
          "text": {
            "content": "日本",
            "beginOffset": 0
          },
          "type": "PROPER"
        }
      ]
    },
    {
      "name": "グーグル",
      "type": "ORGANIZATION",
      "metadata": {
        "mid": "/m/045c7b",
        "wikipedia_url": "https://en.wikipedia.org/wiki/Google"
      },
      "salience": 0.21155767,
      "mentions": [
        {
          "text": {
            "content": "グーグル",
            "beginOffset": 9
          },
          "type": "PROPER"
        }
      ]
    },
    ...
  ]
  "language": "ja"
}

ממשק ה-API מחלץ את יפן כמיקום, ואת Google כארגון, לצד דפי ויקיפדיה עבור כל אחד מהם.

למדת איך לבצע ניתוח טקסט בעזרת Cloud Cloud Language API על ידי חילוץ ישויות, ניתוח סנטימנט ויצירת הערה לגבי תחביר.

באילו נושאים מדובר?

  • יצירת בקשה ל-API של שפת שפה וקריאה ל-API באמצעות תלתל
  • חילוץ ישויות והפעלת ניתוח סנטימנט בטקסט באמצעות ה-API של שפת הטבע
  • ביצוע ניתוח לשוני בטקסט כדי ליצור עצים תלויים
  • יצירת בקשה ל-API של שפה טבעית ביפנית

השלבים הבאים