Python के साथ Natural Language API का इस्तेमाल करना

1. खास जानकारी

Natural Language API की मदद से, Google मशीन लर्निंग का इस्तेमाल करके, बिना स्ट्रक्चर किए गए टेक्स्ट से जानकारी निकाली जा सकती है. इस ट्यूटोरियल में, Python क्लाइंट लाइब्रेरी का इस्तेमाल करने पर फ़ोकस किया जाएगा.

आपको क्या सीखने को मिलेगा

अपना एनवायरमेंट सेट अप करने का तरीका
भावनाओं का विश्लेषण कैसे करें
इकाई का विश्लेषण करने का तरीका
सिंटैक्स का विश्लेषण कैसे करें
कॉन्टेंट की कैटगरी तय करने का तरीका
टेक्स्ट को मॉडरेट करने का तरीका

आपको इन चीज़ों की ज़रूरत होगी

Google Cloud प्रोजेक्ट
कोई ब्राउज़र, जैसे कि Chrome या Firefox
Python का इस्तेमाल करने की जानकारी

सर्वे

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

सिर्फ़ इसे पढ़ें

इसे पढ़ें और एक्सरसाइज़ पूरी करें

Python के साथ अपने अनुभव को आप क्या रेटिंग देंगे?

शुरुआती

सामान्य

एडवांस

Google Cloud की सेवाओं को इस्तेमाल करने का आपका अनुभव कैसा रहा?

शुरुआती

सामान्य

एडवांस

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेट अप करना

Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे कभी भी अपडेट किया जा सकता है.
प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, यूनीक स्ट्रिंग को अपने-आप जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी (आम तौर पर PROJECT_ID के तौर पर पहचाना जाता है) का रेफ़रंस देना होगा. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो कोई दूसरा रैंडम आईडी जनरेट किया जा सकता है. इसके अलावा, आपके पास अपना नाम आज़माने का विकल्प भी है. इससे आपको पता चलेगा कि वह नाम उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. यह प्रोजेक्ट की अवधि तक बना रहता है.
आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

इसके बाद, आपको Cloud Console में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा समय नहीं लगेगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, संसाधनों को बंद किया जा सकता है. इसके लिए, बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ताओं को, 300 डॉलर का क्रेडिट मिलेगा. वे इसे मुफ़्त में आज़मा सकते हैं.

Cloud Shell शुरू करें

Google Cloud को अपने लैपटॉप से रिमोटली ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Cloud Shell चालू करें

Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

अगर आपने Cloud Shell को पहली बार शुरू किया है, तो आपको एक इंटरमीडिएट स्क्रीन दिखेगी. इसमें Cloud Shell के बारे में जानकारी दी गई होगी. अगर आपको इंटरमीडिएट स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

Cloud Shell से कनेक्ट होने में कुछ ही सेकंड लगेंगे.

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है, जो हमेशा बनी रहती है. साथ ही, यह Google Cloud में काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में ज़्यादातर काम ब्राउज़र से किया जा सकता है.

Cloud Shell से कनेक्ट होने के बाद, आपको दिखेगा कि आपकी पुष्टि हो गई है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट कर दिया गया है.

पुष्टि करें कि आपने Cloud Shell में पुष्टि कर ली है. इसके लिए, यह कमांड चलाएं:

gcloud auth list

कमांड आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं:

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो इस कमांड का इस्तेमाल करके इसे सेट किया जा सकता है:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

3. एनवायरमेंट सेटअप करना

Natural Language API का इस्तेमाल शुरू करने से पहले, Cloud Shell में यह कमांड चलाकर एपीआई को चालू करें:

gcloud services enable language.googleapis.com

आपको कुछ ऐसा दिखेगा:

Operation "operations/..." finished successfully.

अब Natural Language API का इस्तेमाल किया जा सकता है!

अपनी होम डायरेक्ट्री पर जाएं:

cd ~

डिपेंडेंसी को अलग करने के लिए, Python का वर्चुअल एनवायरमेंट बनाएं:

virtualenv venv-language

वर्चुअल एनवायरमेंट चालू करें:

source venv-language/bin/activate

IPython, Pandas, और Natural Language API क्लाइंट लाइब्रेरी इंस्टॉल करें:

pip install ipython pandas tabulate google-cloud-language

आपको कुछ ऐसा दिखेगा:

...
Installing collected packages: ... pandas ... ipython ... google-cloud-language
Successfully installed ... google-cloud-language-2.11.0 ...

अब, Natural Language API क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है!

अगले चरणों में, आपको IPython नाम के इंटरैक्टिव Python इंटरप्रेटर का इस्तेमाल करना होगा. इसे आपने पिछले चरण में इंस्टॉल किया था. Cloud Shell में ipython चलाकर सेशन शुरू करें:

ipython

आपको कुछ ऐसा दिखेगा:

Python 3.9.2 (default, Feb 28 2021, 17:03:44)
Type 'copyright', 'credits' or 'license' for more information
IPython 8.15.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

4. भावनाओं का विश्लेषण

भावनाओं का विश्लेषण करने की सुविधा, दिए गए टेक्स्ट की जांच करती है. साथ ही, टेक्स्ट में मौजूद भावनाओं की पहचान करती है. इससे यह पता चलता है कि टेक्स्ट में मौजूद भावनाएं सकारात्मक, नकारात्मक या सामान्य हैं. यह विश्लेषण, वाक्य और दस्तावेज़, दोनों लेवल पर किया जाता है. यह analyze_sentiment तरीके से किया जाता है, जो AnalyzeSentimentResponse दिखाता है.

नीचे दिए गए कोड को अपने IPython सेशन में कॉपी करें:

from google.cloud import language

def analyze_text_sentiment(text: str) -> language.AnalyzeSentimentResponse:
    client = language.LanguageServiceClient()
    document = language.Document(
        content=text,
        type_=language.Document.Type.PLAIN_TEXT,
    )
    return client.analyze_sentiment(document=document)

def show_text_sentiment(response: language.AnalyzeSentimentResponse):
    import pandas as pd

    columns = ["score", "sentence"]
    data = [(s.sentiment.score, s.text.content) for s in response.sentences]
    df_sentence = pd.DataFrame(columns=columns, data=data)

    sentiment = response.document_sentiment
    columns = ["score", "magnitude", "language"]
    data = [(sentiment.score, sentiment.magnitude, response.language)]
    df_document = pd.DataFrame(columns=columns, data=data)

    format_args = dict(index=False, tablefmt="presto", floatfmt="+.1f")
    print(f"At sentence level:\n{df_sentence.to_markdown(**format_args)}")
    print()
    print(f"At document level:\n{df_document.to_markdown(**format_args)}")

विश्लेषण करना:

# Input
text = """
Python is a very readable language, which makes it easy to understand and maintain code.
It's simple, very flexible, easy to learn, and suitable for a wide variety of tasks.
One disadvantage is its speed: it's not as fast as some other programming languages.
"""

# Send a request to the API
analyze_sentiment_response = analyze_text_sentiment(text)

# Show the results
show_text_sentiment(analyze_sentiment_response)

आपको इस तरह का आउटपुट दिखेगा:

At sentence level:
   score | sentence
---------+------------------------------------------------------------------------------------------
    +0.8 | Python is a very readable language, which makes it easy to understand and maintain code.
    +0.9 | It's simple, very flexible, easy to learn, and suitable for a wide variety of tasks.
    -0.4 | One disadvantage is its speed: it's not as fast as some other programming languages.

At document level:
   score |   magnitude | language
---------+-------------+------------
    +0.4 |        +2.2 | en

कुछ समय निकालकर, अपने वाक्यों की जांच करें.

Natural Language API की सुविधा किन भाषाओं में उपलब्ध है, इस बारे में जानने के लिए भाषा से जुड़ी सहायता देखें.
score की वैल्यू -1.0 (नकारात्मक) और +1.0 (सकारात्मक) के बीच होती है. यह दी गई जानकारी के आधार पर, कुल रुझान के हिसाब से तय होती है.
भावना की magnitude, 0.0 से लेकर +inf तक होती है. इससे दी गई जानकारी के आधार पर, भावना की कुल तीव्रता का पता चलता है. जितनी ज़्यादा जानकारी दी जाएगी, गंभीरता उतनी ही ज़्यादा होगी.
विश्लेषण में शामिल score और magnitude की भावना से जुड़ी वैल्यू को समझने के तरीके के बारे में ज़्यादा जानने के लिए, भावना के विश्लेषण की वैल्यू को समझना लेख पढ़ें.
एपीआई से मिले हर जवाब में, दस्तावेज़ की अपने-आप पहचान हुई भाषा (ISO-639-1 में) दिखती है. यह यहां दिखती है और विश्लेषण के अगले उदाहरणों में इसे नहीं दिखाया जाएगा.

खास जानकारी

इस चरण में, आपने टेक्स्ट की स्ट्रिंग के बारे में जानकारी हासिल की!

5. इकाई का विश्लेषण

इकाई विश्लेषण, दिए गए टेक्स्ट में जानी-पहचानी इकाइयों (जैसे, लोकप्रिय हस्तियां, लैंडमार्क वगैरह) की जांच करता है. साथ ही, उन इकाइयों के बारे में जानकारी देता है. यह analyze_entities तरीके से किया जाता है, जो AnalyzeEntitiesResponse दिखाता है.

नीचे दिए गए कोड को अपने IPython सेशन में कॉपी करें:

from google.cloud import language

def analyze_text_entities(text: str) -> language.AnalyzeEntitiesResponse:
    client = language.LanguageServiceClient()
    document = language.Document(
        content=text,
        type_=language.Document.Type.PLAIN_TEXT,
    )
    return client.analyze_entities(document=document)

def show_text_entities(response: language.AnalyzeEntitiesResponse):
    import pandas as pd

    columns = ("name", "type", "salience", "mid", "wikipedia_url")
    data = (
        (
            entity.name,
            entity.type_.name,
            entity.salience,
            entity.metadata.get("mid", ""),
            entity.metadata.get("wikipedia_url", ""),
        )
        for entity in response.entities
    )
    df = pd.DataFrame(columns=columns, data=data)
    print(df.to_markdown(index=False, tablefmt="presto", floatfmt=".0%"))

विश्लेषण करना:

# Input
text = """Guido van Rossum is best known as the creator of Python,
which he named after the Monty Python comedy troupe.
He was born in Haarlem, Netherlands.
"""

# Send a request to the API
analyze_entities_response = analyze_text_entities(text)

# Show the results
show_text_entities(analyze_entities_response)

आपको इस तरह का आउटपुट दिखेगा:

 name             | type         |   salience | mid       | wikipedia_url
------------------+--------------+------------+-----------+-------------------------------------------------------------
 Guido van Rossum | PERSON       |        50% | /m/01h05c | https://en.wikipedia.org/wiki/Guido_van_Rossum
 Python           | ORGANIZATION |        38% | /m/05z1_  | https://en.wikipedia.org/wiki/Python_(programming_language)
 creator          | PERSON       |         5% |           |
 Monty Python     | PERSON       |         3% | /m/04sd0  | https://en.wikipedia.org/wiki/Monty_Python
 comedy troupe    | PERSON       |         2% |           |
 Haarlem          | LOCATION     |         1% | /m/0h095  | https://en.wikipedia.org/wiki/Haarlem
 Netherlands      | LOCATION     |         1% | /m/059j2  | https://en.wikipedia.org/wiki/Netherlands

कुछ समय निकालकर, अन्य इकाइयों के बारे में बताने वाले अपने वाक्यों की जांच करें.

इस तरीके से किन भाषाओं में अनुवाद किया जा सकता है, इस बारे में जानने के लिए भाषा से जुड़ी सहायता देखें.
इकाई का type एक इनम है. इसकी मदद से, इकाइयों को कैटगरी में बांटा जा सकता है या उनमें अंतर किया जा सकता है. उदाहरण के लिए, इससे एक जैसे नाम वाली इकाइयों "टी.ई. लॉरेंस" (एक PERSON) और "लॉरेंस ऑफ़ अरेबिया" (फ़िल्म, जिसे WORK_OF_ART के तौर पर टैग किया गया है) के बीच अंतर करने में मदद मिल सकती है. Entity.Type देखें.
इकाई salience से पता चलता है कि यह इकाई, पूरे दस्तावेज़ के टेक्स्ट के लिए कितनी ज़रूरी या काम की है. यह स्कोर, खास इकाइयों को प्राथमिकता देकर जानकारी को वापस पाने और खास जानकारी बनाने में मदद कर सकता है. 0.0 के आस-पास के स्कोर कम अहम होते हैं, जबकि 1.0 के आस-पास के स्कोर बहुत अहम होते हैं.
ज़्यादा जानकारी के लिए, इकाई का विश्लेषण लेख पढ़ें.
analyze_entity_sentiment तरीके का इस्तेमाल करके, इकाई के विश्लेषण और भावना के विश्लेषण, दोनों को एक साथ किया जा सकता है. इकाई के बारे में लोगों की राय का विश्लेषण देखें.

खास जानकारी

इस चरण में, आपने इकाई का विश्लेषण किया!

6. सिंटैक्स का विश्लेषण

सिंटैक्स विश्लेषण, भाषा से जुड़ी जानकारी निकालता है. इसके लिए, दिए गए टेक्स्ट को वाक्यों और टोकन (आम तौर पर शब्दों की सीमाओं के आधार पर) की सीरीज़ में बांटा जाता है. साथ ही, उन टोकन का विश्लेषण किया जाता है. यह analyze_syntax तरीके से किया जाता है, जो AnalyzeSyntaxResponse दिखाता है.

नीचे दिए गए कोड को अपने IPython सेशन में कॉपी करें:

from typing import Optional
from google.cloud import language

def analyze_text_syntax(text: str) -> language.AnalyzeSyntaxResponse:
    client = language.LanguageServiceClient()
    document = language.Document(
        content=text,
        type_=language.Document.Type.PLAIN_TEXT,
    )
    return client.analyze_syntax(document=document)

def get_token_info(token: Optional[language.Token]) -> list[str]:
    parts = [
        "tag",
        "aspect",
        "case",
        "form",
        "gender",
        "mood",
        "number",
        "person",
        "proper",
        "reciprocity",
        "tense",
        "voice",
    ]
    if not token:
        return ["token", "lemma"] + parts

    text = token.text.content
    lemma = token.lemma if token.lemma != token.text.content else ""
    info = [text, lemma]
    for part in parts:
        pos = token.part_of_speech
        info.append(getattr(pos, part).name if part in pos else "")

    return info

def show_text_syntax(response: language.AnalyzeSyntaxResponse):
    import pandas as pd

    tokens = len(response.tokens)
    sentences = len(response.sentences)
    columns = get_token_info(None)
    data = (get_token_info(token) for token in response.tokens)
    df = pd.DataFrame(columns=columns, data=data)
    # Remove empty columns
    empty_columns = [col for col in df if df[col].eq("").all()]
    df.drop(empty_columns, axis=1, inplace=True)

    print(f"Analyzed {tokens} token(s) from {sentences} sentence(s):")
    print(df.to_markdown(index=False, tablefmt="presto"))

विश्लेषण करना:

# Input
text = """Guido van Rossum is best known as the creator of Python.
He was born in Haarlem, Netherlands.
"""

# Send a request to the API
analyze_syntax_response = analyze_text_syntax(text)

# Show the results
show_text_syntax(analyze_syntax_response)

आपको इस तरह का आउटपुट दिखेगा:

Analyzed 20 token(s) from 2 sentence(s):
 token       | lemma   | tag   | case       | gender    | mood       | number   | person   | proper   | tense   | voice
-------------+---------+-------+------------+-----------+------------+----------+----------+----------+---------+---------
 Guido       |         | NOUN  |            |           |            | SINGULAR |          | PROPER   |         |
 van         |         | NOUN  |            |           |            | SINGULAR |          | PROPER   |         |
 Rossum      |         | NOUN  |            |           |            | SINGULAR |          | PROPER   |         |
 is          | be      | VERB  |            |           | INDICATIVE | SINGULAR | THIRD    |          | PRESENT |
 best        | well    | ADV   |            |           |            |          |          |          |         |
 known       | know    | VERB  |            |           |            |          |          |          | PAST    |
 as          |         | ADP   |            |           |            |          |          |          |         |
 the         |         | DET   |            |           |            |          |          |          |         |
 creator     |         | NOUN  |            |           |            | SINGULAR |          |          |         |
 of          |         | ADP   |            |           |            |          |          |          |         |
 Python      |         | NOUN  |            |           |            | SINGULAR |          | PROPER   |         |
 .           |         | PUNCT |            |           |            |          |          |          |         |
 He          |         | PRON  | NOMINATIVE | MASCULINE |            | SINGULAR | THIRD    |          |         |
 was         | be      | VERB  |            |           | INDICATIVE | SINGULAR | THIRD    |          | PAST    |
 born        | bear    | VERB  |            |           |            |          |          |          | PAST    | PASSIVE
 in          |         | ADP   |            |           |            |          |          |          |         |
 Haarlem     |         | NOUN  |            |           |            | SINGULAR |          | PROPER   |         |
 ,           |         | PUNCT |            |           |            |          |          |          |         |
 Netherlands |         | NOUN  |            |           |            | SINGULAR |          | PROPER   |         |
 .           |         | PUNCT |            |           |            |          |          |          |         |

कुछ समय निकालकर, सिंटैक्टिक स्ट्रक्चर के साथ अपने वाक्यों को टेस्ट करें.

जवाब से जुड़ी अहम जानकारी में जाकर, टोकन के बीच के संबंध भी देखे जा सकते हैं. यहां इस उदाहरण के लिए, पूरे सिंटैक्स का विश्लेषण दिखाने वाला विज़ुअल इंटरप्रेटेशन दिया गया है. यह ऑनलाइन नैचुरल लैंग्वेज डेमो का स्क्रीनशॉट है:

खास जानकारी

इस चरण में, आपने सिंटैक्स का विश्लेषण किया!

7. कॉन्टेंट की कैटगरी तय करना

कॉन्टेंट के हिसाब से कैटगरी तय करने की सुविधा, किसी दस्तावेज़ का विश्लेषण करती है. इसके बाद, यह सुविधा कॉन्टेंट की उन कैटगरी की सूची दिखाती है जो दस्तावेज़ में मौजूद टेक्स्ट पर लागू होती हैं. यह classify_text तरीके से किया जाता है, जो ClassifyTextResponse दिखाता है.

नीचे दिए गए कोड को अपने IPython सेशन में कॉपी करें:

from google.cloud import language

def classify_text(text: str) -> language.ClassifyTextResponse:
    client = language.LanguageServiceClient()
    document = language.Document(
        content=text,
        type_=language.Document.Type.PLAIN_TEXT,
    )
    return client.classify_text(document=document)

def show_text_classification(text: str, response: language.ClassifyTextResponse):
    import pandas as pd

    columns = ["category", "confidence"]
    data = ((category.name, category.confidence) for category in response.categories)
    df = pd.DataFrame(columns=columns, data=data)

    print(f"Text analyzed:\n{text}")
    print(df.to_markdown(index=False, tablefmt="presto", floatfmt=".0%"))

विश्लेषण करना:

# Input
text = """Python is an interpreted, high-level, general-purpose programming language.
Created by Guido van Rossum and first released in 1991, Python's design philosophy
emphasizes code readability with its notable use of significant whitespace.
"""

# Send a request to the API
classify_text_response = classify_text(text)

# Show the results
show_text_classification(text, classify_text_response)

आपको इस तरह का आउटपुट दिखेगा:

Text analyzed:
Python is an interpreted, high-level, general-purpose programming language.
Created by Guido van Rossum and first released in 1991, Python's design philosophy
emphasizes code readability with its notable use of significant whitespace.

 category                             |   confidence
--------------------------------------+--------------
 /Computers & Electronics/Programming |          99%
 /Science/Computer Science            |          99%

कुछ समय निकालकर, अन्य कैटगरी से जुड़े अपने वाक्यों को टेस्ट करें. ध्यान दें कि आपको कम से कम बीस टोकन (शब्द और विराम चिह्न) वाला टेक्स्ट ब्लॉक (दस्तावेज़) देना होगा.

खास जानकारी

इस चरण में, कॉन्टेंट को कैटगरी में बांटा जा सकता है!

8. टेक्स्ट की जांच करना

टेक्स्ट मॉडरेशन की सुविधा, Google के नए फ़ाउंडेशन मॉडल PaLM 2 पर आधारित है. यह नुकसान पहुंचाने वाले कई तरह के कॉन्टेंट की पहचान कर सकता है. जैसे, नफ़रत फैलाने वाली भाषा, धमकाने, और यौन शोषण को बढ़ावा देने वाला कॉन्टेंट. यह moderate_text तरीके से किया जाता है, जो ModerateTextResponse दिखाता है.

नीचे दिए गए कोड को अपने IPython सेशन में कॉपी करें:

from google.cloud import language

def moderate_text(text: str) -> language.ModerateTextResponse:
    client = language.LanguageServiceClient()
    document = language.Document(
        content=text,
        type_=language.Document.Type.PLAIN_TEXT,
    )
    return client.moderate_text(document=document)

def show_text_moderation(text: str, response: language.ModerateTextResponse):
    import pandas as pd

    def confidence(category: language.ClassificationCategory) -> float:
        return category.confidence

    columns = ["category", "confidence"]
    categories = sorted(response.moderation_categories, key=confidence, reverse=True)
    data = ((category.name, category.confidence) for category in categories)
    df = pd.DataFrame(columns=columns, data=data)

    print(f"Text analyzed:\n{text}")
    print(df.to_markdown(index=False, tablefmt="presto", floatfmt=".0%"))

विश्लेषण करना:

# Input
text = """I have to read Ulysses by James Joyce.
I'm a little over halfway through and I hate it.
What a pile of garbage!
"""

# Send a request to the API
response = moderate_text(text)

# Show the results
show_text_moderation(text, response)

आपको इस तरह का आउटपुट दिखेगा:

Text analyzed:
I have to read Ulysses by James Joyce.
I'm a little over halfway through and I hate it.
What a pile of garbage!

 category              |   confidence
-----------------------+--------------
 Toxic                 |          67%
 Insult                |          58%
 Profanity             |          53%
 Violent               |          48%
 Illicit Drugs         |          29%
 Religion & Belief     |          27%
 Politics              |          22%
 Death, Harm & Tragedy |          21%
 Finance               |          18%
 Derogatory            |          14%
 Firearms & Weapons    |          11%
 Health                |          10%
 Legal                 |          10%
 War & Conflict        |           7%
 Public Safety         |           5%
 Sexual                |           4%

कुछ समय निकालकर, अपने वाक्यों की जांच करें.

खास जानकारी

इस चरण में, आपने टेक्स्ट की समीक्षा करने की सुविधा का इस्तेमाल किया!

9. बधाई हो!

आपने Python का इस्तेमाल करके, Natural Language API का इस्तेमाल करने का तरीका जान लिया है!

व्यवस्थित करें

Cloud Shell से, डेवलपमेंट एनवायरमेंट को क्लीन अप करने के लिए:

अगर आप अब भी IPython सेशन में हैं, तो शेल पर वापस जाएं: exit
Python वर्चुअल एनवायरमेंट का इस्तेमाल बंद करें: deactivate
अपना वर्चुअल एनवायरमेंट फ़ोल्डर मिटाएं: cd ~ ; rm -rf ./venv-language

Google Cloud प्रोजेक्ट मिटाने के लिए, Cloud Shell में जाकर यह तरीका अपनाएं:

अपना मौजूदा प्रोजेक्ट आईडी पाएं: PROJECT_ID=$(gcloud config get-value core/project)
पक्का करें कि आपको यही प्रोजेक्ट मिटाना है: echo $PROJECT_ID
प्रोजेक्ट मिटाएं: gcloud projects delete $PROJECT_ID

ज़्यादा जानें

अपने ब्राउज़र में डेमो आज़माएं: https://cloud.google.com/natural-language#natural-language-api-demo
नेचुरल लैंग्वेज के दस्तावेज़: https://cloud.google.com/natural-language/docs
Google Cloud पर Python: https://cloud.google.com/python
Python के लिए Cloud Client Libraries: https://github.com/googleapis/google-cloud-python

लाइसेंस

इस काम के लिए, Creative Commons एट्रिब्यूशन 2.0 जेनेरिक लाइसेंस के तहत लाइसेंस मिला है.