इस पेज का अनुवाद Cloud Translation API से किया गया है.

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 खाता नहीं है, तो आपको नया खाता बनाना होगा.

295004821बाबा6a87.png

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

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

Cloud Shell शुरू करना

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

Cloud Shell चालू करें

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

अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

इस वर्चुअल मशीन में डेवलपमेंट के सभी ज़रूरी टूल मौजूद हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह 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`

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

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, एक ईनम है. इसकी मदद से, इकाइयों की कैटगरी तय की जा सकती है या उन्हें अलग किया जा सकता है. उदाहरण के लिए, इसकी मदद से मिलती-जुलती नाम वाली इकाइयों "T.E. लॉरेंस" (a PERSON) "Lawrence of पकवानों" से लिया गया (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

Cloud Shell से अपना Google Cloud प्रोजेक्ट मिटाने के लिए:

अपना मौजूदा प्रोजेक्ट आईडी वापस पाएं: 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 क्लाइंट लाइब्रेरी: https://github.com/googleapis/google-cloud-python

लाइसेंस

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