दूसरा हिस्सा: क्लाइंट-साइड एआई की मदद से, आपत्तिजनक कॉन्टेंट का पता लगाना

Maud Nalpas
Maud Nalpas

पब्लिश होने की तारीख: 13 नवंबर, 2024

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

इस दो भाग वाली सीरीज़ में, हम एआई का इस्तेमाल करके, उपयोगकर्ताओं के कीबोर्ड पर मौजूद, नुकसान पहुंचाने वाले कॉन्टेंट का पता लगाने और उसे कम करने के तरीके के बारे में बताएंगे.

पहले हिस्से में, हमने इस तरीके के इस्तेमाल के उदाहरणों और फ़ायदों के बारे में बताया था.

इस दूसरे हिस्से में, हम इसे लागू करने के बारे में बताएंगे. इसमें कोड के उदाहरण और यूज़र एक्सपीरियंस से जुड़ी सलाह भी शामिल हैं.

डेमो और कोड

हमारे डेमो को आज़माएं और GitHub पर मौजूद कोड की जांच करें.

टिप्पणी पोस्ट करने का डेमो.
जब उपयोगकर्ता टाइप करना बंद कर देता है, तब हम उसकी टिप्पणी के नुकसान पहुंचाने वाले होने का विश्लेषण करते हैं. अगर टिप्पणी को बुरे बर्ताव के तौर पर मार्क किया जाता है, तो हम रीयल-टाइम में चेतावनी दिखाते हैं.

ब्राउज़र समर्थन

हमारा डेमो, Safari, Chrome, Edge, और Firefox के नए वर्शन पर काम करता है.

कोई मॉडल और लाइब्रेरी चुनना

हम Hugging Face की Transformers.js लाइब्रेरी का इस्तेमाल करते हैं. इससे ब्राउज़र में मशीन लर्निंग मॉडल के साथ काम करने के लिए टूल मिलते हैं. हमारा डेमो कोड, टेक्स्ट को अलग-अलग कैटगरी में बांटने के इस उदाहरण से लिया गया है.

हम toxic-bert मॉडल चुनते हैं. यह एक ऐसा मॉडल है जिसे पहले से ट्रेन किया गया है. इसे बुरे बर्ताव वाली भाषा के पैटर्न की पहचान करने के लिए डिज़ाइन किया गया है. यह unitary/toxic-bert का वेब के साथ काम करने वाला वर्शन है. मॉडल के लेबल और पहचान पर होने वाले हमलों की कैटगरी के बारे में ज़्यादा जानने के लिए, Hugging Face मॉडल पेज पर जाएं.

toxic-bert का डाउनलोड साइज़ 111 एमबी है.

मॉडल डाउनलोड हो जाने के बाद, अनुमान लगाने की प्रोसेस तेज़ी से होती है.

उदाहरण के लिए, आम तौर पर, Chrome को हमारे टेस्ट किए गए मिड-रेंज Android डिवाइस पर 500 मिलीसेकंड से भी कम समय लगता है. यह Pixel 7 का सामान्य फ़ोन है, न कि बेहतर परफ़ॉर्म करने वाला Pro मॉडल. अपने उपयोगकर्ता आधार के हिसाब से, खुद के मानदंड तय करें.

लागू करना

इसे लागू करने के मुख्य चरण यहां दिए गए हैं:

नुकसान पहुंचाने वाले कॉन्टेंट की सीमा सेट करना

बुरे बर्ताव का पता लगाने वाली हमारी सुविधा, 0 से 1 के बीच बुरे बर्ताव के स्कोर देती है. उस रेंज में, हमें एक थ्रेशोल्ड सेट करना होगा, ताकि यह तय किया जा सके कि कौनसी टिप्पणी नुकसान पहुंचाने वाली है. आम तौर पर, 0.9 थ्रेशोल्ड का इस्तेमाल किया जाता है. इसकी मदद से, साफ़ तौर पर बुरे बर्ताव वाली टिप्पणियों का पता लगाया जा सकता है. साथ ही, ज़रूरत से ज़्यादा संवेदनशील होने से बचा जा सकता है. इससे, गलत तरीके से बहुत ज़्यादा टिप्पणियों को बुरे बर्ताव वाली कैटगरी में डालने से बचा जा सकता है. दूसरे शब्दों में, नुकसान न पहुंचाने वाली टिप्पणियों को बुरे बर्ताव वाली कैटगरी में डालने से बचा जा सकता है.

export const TOXICITY_THRESHOLD = 0.9

कॉम्पोनेंट इंपोर्ट करना

हम @xenova/transformers लाइब्रेरी से ज़रूरी कॉम्पोनेंट इंपोर्ट करके शुरू करते हैं. हम कॉन्स्टेंट और कॉन्फ़िगरेशन वैल्यू भी इंपोर्ट करते हैं. इनमें, हमारे कॉन्टेंट के लिए तय किया गया, नुकसान पहुंचाने वाले कॉन्टेंट का थ्रेशोल्ड भी शामिल है.

import { env, pipeline } from '@xenova/transformers';
// Model name: 'Xenova/toxic-bert'
// Our threshold is set to 0.9
import { TOXICITY_THRESHOLD, MODEL_NAME } from './config.js';

मॉडल लोड करना और मुख्य थ्रेड से संपर्क करना

हम 'आपत्तिजनक कॉन्टेंट का पता लगाने वाला मॉडल' टॉक्सिक-बर्ट लोड करते हैं और इसका इस्तेमाल अपने क्लासिफ़ायर को तैयार करने के लिए करते हैं. इसका सबसे आसान वर्शन const classifier = await pipeline('text-classification', MODEL_NAME); है

उदाहरण के तौर पर दिए गए कोड की तरह, कोई पाइपलाइन बनाना, अनुमान लगाने वाले टास्क चलाने का पहला चरण है.

पाइपलाइन फ़ंक्शन में दो आर्ग्युमेंट होते हैं: टास्क ('text-classification') और मॉडल (Xenova/toxic-bert).

मुख्य शब्द: Transformers.js में, पाइपलाइन एक हाई-लेवल एपीआई है, जो एमएल मॉडल को चलाने की प्रोसेस को आसान बनाता है. यह मॉडल लोड करने, टोकन बनाने, और पोस्ट-प्रोसेसिंग जैसे कामों को मैनेज करता है.

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

हमारे वर्कर्स को मुख्य थ्रेड से मैसेज भेजकर, मॉडल की स्थिति और नुकसान पहुंचाने वाले कॉन्टेंट का आकलन करने के नतीजों के बारे में बताना होता है. हमने मॉडल तैयार करने और अनुमान लगाने के लाइफ़साइकल की अलग-अलग स्थितियों के लिए, मैसेज कोड बनाए हैं. इन पर एक नज़र डालें.

let classifier = null;
(async function () {
  // Signal to the main thread that model preparation has started
  self.postMessage({ code: MESSAGE_CODE.PREPARING_MODEL, payload: null });
  try {
    // Prepare the model
    classifier = await pipeline('text-classification', MODEL_NAME);
    // Signal to the main thread that the model is ready
    self.postMessage({ code: MESSAGE_CODE.MODEL_READY, payload: null });
  } catch (error) {
    console.error('[Worker] Error preparing model:', error);
    self.postMessage({ code: MESSAGE_CODE.MODEL_ERROR, payload: null });
  }
})();

उपयोगकर्ता के इनपुट को अलग-अलग कैटगरी में बांटना

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

// Asynchronous function to classify user input
// output: [{ label: 'toxic', score: 0.9243140482902527 },
// ... { label: 'insult', score: 0.96187334060668945 }
// { label: 'obscene', score: 0.03452680632472038 }, ...etc]
async function classify(text) {
  if (!classifier) {
    throw new Error("Can't run inference, the model is not ready yet");
  }
  let results = await classifier(text, { topk: null });
  return results;
}

जब मुख्य थ्रेड, वर्कर्स को ऐसा करने के लिए कहती है, तब हम अपने 'क्लासिफ़ाइ करें' फ़ंक्शन को कॉल करते हैं. हमारे डेमो में, उपयोगकर्ता के टाइप करना बंद करने के तुरंत बाद, हम क्लासिफ़ायर को ट्रिगर करते हैं (TYPING_DELAY देखें). ऐसा होने पर, हमारा मुख्य थ्रेड वर्कर्स को एक मैसेज भेजता है. इसमें, उपयोगकर्ता का वह इनपुट होता है जिसे क्लासिफ़ाइ करना है.

self.onmessage = async function (message) {
  // User input
  const textToClassify = message.data;
  if (!classifier) {
    throw new Error("Can't run inference, the model is not ready yet");
  }
  self.postMessage({ code: MESSAGE_CODE.GENERATING_RESPONSE, payload: null });

  // Inference: run the classifier
  let classificationResults = null;
  try {
    classificationResults = await classify(textToClassify);
  } catch (error) {
    console.error('[Worker] Error: ', error);
    self.postMessage({
      code: MESSAGE_CODE.INFERENCE_ERROR,
    });
    return;
  }
  const toxicityTypes = getToxicityTypes(classificationResults);
  const toxicityAssessement = {
    isToxic: toxicityTypes.length > 0,
    toxicityTypeList: toxicityTypes.length > 0 ? toxicityTypes.join(', ') : '',
  };
  console.info('[Worker] Toxicity assessed: ', toxicityAssessement);
  self.postMessage({
    code: MESSAGE_CODE.RESPONSE_READY,
    payload: toxicityAssessement,
  });
};

आउटपुट को प्रोसेस करना

हम यह जांच करते हैं कि क्लासिफ़ायर के आउटपुट स्कोर, हमारे थ्रेशोल्ड से ज़्यादा हैं या नहीं. अगर ऐसा है, तो हम उस लेबल को नोट कर लेते हैं.

अगर टिप्पणी पर बुरे बर्ताव वाला कोई लेबल दिखता है, तो उसे संभावित तौर पर बुरा बर्ताव दिखाने वाली टिप्पणी के तौर पर फ़्लैग किया जाता है.

// input: [{ label: 'toxic', score: 0.9243140482902527 }, ...
// { label: 'insult', score: 0.96187334060668945 },
// { label: 'obscene', score: 0.03452680632472038 }, ...etc]
// output: ['toxic', 'insult']
function getToxicityTypes(results) {
  const toxicityAssessment = [];
  for (let element of results) {
    // If a label's score > our threshold, save the label
    if (element.score > TOXICITY_THRESHOLD) {
      toxicityAssessment.push(element.label);
    }
  }
  return toxicityAssessment;
}

self.onmessage = async function (message) {
  // User input
  const textToClassify = message.data;
  if (!classifier) {
    throw new Error("Can't run inference, the model is not ready yet");
  }
  self.postMessage({ code: MESSAGE_CODE.GENERATING_RESPONSE, payload: null });

  // Inference: run the classifier
  let classificationResults = null;
  try {
    classificationResults = await classify(textToClassify);
  } catch (error) {
    self.postMessage({
      code: MESSAGE_CODE.INFERENCE_ERROR,
    });
    return;
  }
  const toxicityTypes = getToxicityTypes(classificationResults);
  const toxicityAssessement = {
    // If any toxicity label is listed, the comment is flagged as
    // potentially toxic (isToxic true)
    isToxic: toxicityTypes.length > 0,
    toxicityTypeList: toxicityTypes.length > 0 ? toxicityTypes.join(', ') : '',
  };
  self.postMessage({
    code: MESSAGE_CODE.RESPONSE_READY,
    payload: toxicityAssessement,
  });
};

संकेत दिखाना

अगर isToxic सही है, तो हम उपयोगकर्ता को एक हिंट दिखाते हैं. हमारे डेमो में, हमने ज़्यादा बारीक तौर पर नुकसान पहुंचाने वाले कॉन्टेंट के टाइप का इस्तेमाल नहीं किया है. हालांकि, हमने इसे ज़रूरत पड़ने पर मुख्य थ्रेड के लिए उपलब्ध कराया है (toxicityTypeList). आपको यह अपने इस्तेमाल के उदाहरण के लिए काम का लग सकता है.

उपयोगकर्ता अनुभव

हमने अपने डेमो में ये विकल्प चुने हैं:

  • पोस्ट करने की अनुमति हमेशा दें. क्लाइंट-साइड पर, नुकसान पहुंचाने वाले कॉन्टेंट के बारे में मिलने वाले हमारे सुझाव से, उपयोगकर्ता को पोस्ट करने से नहीं रोका जाता. हमारे डेमो में, उपयोगकर्ता तब भी टिप्पणी कर सकता है, जब मॉडल लोड न हुआ हो (इसलिए, बुरे बर्ताव का आकलन न किया जा रहा हो) और टिप्पणी को बुरे बर्ताव के तौर पर पहचाना गया हो. हमारा सुझाव है कि आपके पास बुरे बर्ताव वाली टिप्पणियों का पता लगाने के लिए, एक दूसरा सिस्टम होना चाहिए. अगर आपके ऐप्लिकेशन के लिए यह सही है, तो उपयोगकर्ता को बताएं कि उसकी टिप्पणी क्लाइंट पर भेजी गई थी, लेकिन उसे सर्वर पर या मानवीय जांच के दौरान फ़्लैग कर दिया गया.
  • गलत नतीजे मिलने से बचें. अगर किसी टिप्पणी को बुरे बर्ताव के तौर पर नहीं मार्क किया गया है, तो हमारा डेमो कोई फ़ीडबैक नहीं देता. उदाहरण के लिए, "अच्छी टिप्पणी!". ज़्यादा फ़ीडबैक देने से, सिस्टम पर ग़ैर-ज़रूरी डेटा इकट्ठा होता है. साथ ही, पॉज़िटिव फ़ीडबैक देने से गलत सिग्नल भी भेजा जा सकता है. ऐसा इसलिए, क्योंकि हमारा क्लासिफ़ायर कभी-कभी कुछ बुरे बर्ताव वाली टिप्पणियों को अनदेखा कर देता है.
टिप्पणी पोस्ट करने का डेमो.
पोस्ट करें बटन हमेशा चालू रहता है: हमारे डेमो में, उपयोगकर्ता अब भी अपनी टिप्पणी पोस्ट कर सकता है. भले ही, उसे बुरा बर्ताव वाली टिप्पणी के तौर पर मार्क किया गया हो. भले ही, किसी टिप्पणी को बुरा बर्ताव वाली टिप्पणी के तौर पर मार्क न किया गया हो, तब भी हम उस पर अच्छा सुझाव, राय या शिकायत नहीं दिखाते.

बेहतर सुविधाएं और विकल्प

सीमाएं और आने वाले समय में होने वाले सुधार

  • भाषाएं: हम जिस मॉडल का इस्तेमाल कर रहे हैं वह मुख्य रूप से अंग्रेज़ी में काम करता है. कई भाषाओं में सहायता पाने के लिए, आपको कुछ बदलाव करने होंगे. Hugging Face पर मौजूद कई आपत्तिजनक कॉन्टेंट का पता लगाने वाले मॉडल, अंग्रेज़ी के अलावा दूसरी भाषाओं (रूसी, डच) में काम करते हैं. हालांकि, फ़िलहाल ये Transformers.js के साथ काम नहीं करते.
  • Nuance: toxic-bert, साफ़ तौर पर बुरे बर्ताव का पता लगाने में असरदार है. हालांकि, हो सकता है कि वह ज़्यादा सूक्ष्म या संदर्भ पर निर्भर मामलों (इरॉनी, व्यंग्य) के साथ संघर्ष करे. बुरा बर्ताव, बहुत ही निजी और सूक्ष्म हो सकता है. उदाहरण के लिए, हो सकता है कि आप कुछ शब्दों या इमोजी को नुकसान पहुंचाने वाले के तौर पर मार्क करना चाहें. इन चीज़ों को बेहतर बनाने से, इनमें सटीक जानकारी देने में मदद मिल सकती है.

हमने बुरे बर्ताव के मॉडल को बेहतर बनाने के बारे में एक लेख लिखा है. यह लेख जल्द ही पब्लिश किया जाएगा.

अन्य विकल्प

नतीजा

क्लाइंट-साइड पर बुरे बर्ताव का पता लगाने वाला टूल, ऑनलाइन कम्यूनिटी को बेहतर बनाने के लिए एक बेहतरीन टूल है.

toxic-bert जैसे एआई मॉडल का इस्तेमाल करके, रीयल-टाइम में सुझाव देने की सुविधा लागू की जा सकती है. यह सुविधा, ब्राउज़र में Transformers.js के साथ काम करती है. इससे, बुरे बर्ताव को रोकने में मदद मिलती है. साथ ही, आपके सर्वर पर बुरे बर्ताव की कैटगरी तय करने से जुड़े लोड को कम किया जा सकता है.

क्लाइंट-साइड का यह तरीका, पहले से ही सभी ब्राउज़र पर काम करता है. हालांकि, सीमाओं को ध्यान में रखें. खास तौर पर, मॉडल को दिखाने की लागत और डाउनलोड साइज़ के मामले में. क्लाइंट-साइड एआई के लिए परफ़ॉर्मेंस के सबसे सही तरीके लागू करें और मॉडल को कैश मेमोरी में सेव करें.

नुकसान पहुंचाने वाले कॉन्टेंट का ज़्यादा सटीक तरीके से पता लगाने के लिए, क्लाइंट-साइड और सर्वर-साइड के तरीकों को एक साथ इस्तेमाल करें.