Ricerca nel sito web

Riepilogo multilingue di Google Meet e progetto Python

Introduzione

Il riepilogo multilingue di Google Meet è uno strumento/estensione di Chrome in grado di creare trascrizioni per conversazioni di Google Meet in più lingue. Durante il periodo del COVID le persone hanno bisogno di uno strumento in grado di riassumere in modo efficace riunioni, lezioni in aula e video di convezione. Pertanto uno strumento del genere può essere molto utile in questo senso.

In questo articolo, diamo una panoramica della struttura del progetto ed esploriamo alcuni aspetti di implementazione con l'aiuto del codice.

In cosa consiste questo progetto?

Si tratta di una semplice estensione di Chrome che, se abilitata durante una sessione di Google Meet, può generare trascrizioni della riunione e riassumere la conversazione in un formato multilingue.

Quali strumenti utilizzeremo?

  • Frontend - Reactjs, HTML, CSS, Bootstrap

  • Backend - Servizio REST Django

  • Python (ML) - Pytorch, libreria NLTK

  • DB - SQLite

Diagramma di flusso e passaggi necessari per il progetto

  • L'utente avvia la riunione e contemporaneamente abilita l'interno.

  • L'estensione quindi estrae l'audio per la riunione utilizzando l'audio HTML e lo trascrive.

  • Quindi invia i dati al backend che utilizza un algoritmo ML per il riepilogo del testo.

  • Il modello di traduzione ML traduce il testo riepilogato nella lingua di destinazione.

  • Infine, la trascrizione può essere scaricata dall'estensione.

Attuazione del progetto

Interfaccia utente (frontend) e backend

  • Viene creato un servizio di autenticazione utilizzando l'API Django Rest per consentire all'utente di accedere e eseguire la trascrizione.

  • Viene creato un modello in Django e vengono utilizzati i token JWT. Viste API REST per la generazione di token e l'autenticazione degli utenti.

  • Successivamente, viene creato un database in SQLite con Relazione in linguaggio SQL.

  • Lo schema di trascrizione viene creato come ID, nome, data, host, titolo, durata e testo.

  • Successivamente, viene creata un'API REST che verrà utilizzata dall'estensione Chrome per inviare i dati dal front-end.

  • Nel backend, le API vengono create anche dal riepilogo e dalla traduzione del testo utilizzando Python, NLTK e NLP.

Implementazione del codice

Esempio

from googletrans import Translator
LANG_CODES = {
   'ENGLISH': 'en',
   'HINDI': 'hi',
   'MARATHI': 'mr',
   'ARABIC': 'ar',
   'BENGALI': 'bn',
   'CHINESE': 'zh-CN',
   'FRENCH': 'fr',
   'GUJARATI': 'gu',
   'JAPANESE': 'ja',
   'KANNADA': 'kn',
   'MALAYALAM': 'ml',
   'NEPALI': 'ne',
   'ORIYA': 'or',
   'PORTUGUESE': 'pt',
   'PUNJABI': 'pa',
   'RUSSIAN': 'ru',
   'SPANISH': 'es',
   'TAMIL': 'ta',
   'TELUGU': 'te',
   'URDU': 'ur'
}

def langauge_translate(input_data, input_lang, output_lang):
   input_lang, output_lang = input_lang.upper(), output_lang.upper()
   tr = Translator()
   text_translate = tr.translate(
   input_data, src=LANG_CODES[input_lang], dest=LANG_CODES[output_lang])
   output_text = text_rtanslate.text
   return(output_text)

Algoritmo di apprendimento automatico

Riepilogo

Pulizia dei dati ---------> Tokenizzazione ------------> Generazione/Rango/Frequenza di vocaboli ------------->Selezione della frase --- ------------> Riepilogo

Traduzione

Inizializzazione ----> Generazione di incorporamento -----> Codifica -----------> Decodifica -----------> Riepilogo

Codice Python per riepilogo e traduzione

Esempio

from nltk.tokenize import sent_tokenize,word_tokenize
import nltk
from nltk.corpus import stopwords
nltk.download('stopwords')
nltk.download('punkt')

def text_clean(txt):
   data = txt.split('**')
   data.pop(0)
   cleaned_data = ""
   i = 0
   for t in data:
      if i % 2 != 0:
         cleaned_data += str(t)
      i += 1
   return cleaned_data
stopwords = set(stopwords.words("english"))

def word_token(txt):
   w = word_tokenize(txt)
   return w
def frequency_table(txt):
   frequencyT = dict()
   words = word_token(txt)
   for w in words:
      w = w.lower()
      if w in stopwords:
         continue
      if w in frequencyT:
         frequencyT[w] += 1
      else:
         frequencyT[w] = 1
   return frequencyT
def Senttokenizer(txt):
   sents = sent_tokenize(txt)
   return sents
def sents_rank_table(txt):
   sent_value = dict()
   freq_Table = frequency_table(txt)
   sents = Senttokenizer(txt)
   for s in sents:
      for word, freq in freq_Table.items():
         if word in s.lower():
            if s in sent_value:
               sent_value[s] += freq
            else:
               sent_value[s] = freq
   return sent_value
def summary(txt):
   sum = 0
   sent_value = sents_rank_table(txt)
   for sentence in sent_value:
      sum += sent_value[sentence]
   average = int(sum / len(sent_value))
   summary = ""
   sents = Senttokenizer(txt)
   for s in sents:
      if (s in sent_value) and (sent_value[s] > (1.2 * average)):
         summ += " " + s
   return summ
def main(input_text):
   # getting text cleaned
   if("**" not in input_text):
      txt = input_text
   else:
      cleanedtext = text_clean(input_text)
      txt = cleanedtext
   summarized_text = summary(txt)
   print("Summary: ", summarized_text)
   return summarized_text

textdata="Il ranking/posizione del sito e la SEO svolgono un ruolo fondamentale nelle tendenze di ricerca odierne e nella pertinenza dei risultati ottenuti. Motore di ricerca\

Il ranking è oggi ampiamente adottato da molte grandi organizzazioni tecnologiche come Google con algoritmi all'avanguardia.\

In questo articolo esploreremo in che modo il machine learning può influire sul ranking dei siti e come può utilizzare i dati dei siti per alimentare algoritmi all'avanguardia.\

In che modo il Machine Learning può essere utile nel ranking?\

Da qualche tempo gli specialisti in SEO si tengono lontani dall'utilizzare il Deep Learning e il neural\

reti per lo sviluppo di algoritmi di ranking, ma oggi con la versatilità dell'implementazione di algoritmi di machine learning e deep learning questo \

lo scenario è completamente cambiato.\

Oggi grandi organizzazioni come Google, Microsoft e Yahoo stanno sfruttando attivamente questi algoritmi."

principale(dati di testo)

Produzione

Summary:	Search Engine Ranking is widely 
adopted by many big tech organizations  like google today with state-of-the-art 
algorithms.In this article, we are going to explore how Machine Learning can impact 
the ranking of sites and how it can utilize site data to fuel state-of-the-art 
algorithms.How can Machine Learning be useful in Ranking?For some time, back 
specialists in SEO have been keeping themselves away using Deep Learning and 
neuralnetworks for developing ranking algorithms, but today with the versatility of 
implementation of machine learning and deep learning algorithms this scenario has 
completely changed.Today big organizations like Google, Microsoft, and Yahoo are 
actively exploiting these algorithms.

Conclusione

Google Meet Summarizer è un progetto semplice in grado di riassumere una riunione Google in più lingue utilizzando stack tecnologici relativi a frontend, backend e machine learning.

Articoli correlati: