Cando traballas no campo da ciencia de datos, adoitas enfrontarte a un novo reto despois de rematar un longo ciclo de adestramento, perfeccionamento e mellora. Parabéns por construír un modelo de ML que teña un bo rendemento e responda ás túas necesidades. Agora o reto que tes entre mans é como podes entregar esta boa tecnoloxía aos usuarios previstos? Ou quizais como podes comunicar eficazmente o teu resultado coas partes interesadas da túa empresa? Ou incluso como podes compartir os resultados do teu modelo cos teus colegas de forma eficaz para unha mellor colaboración?
Implementar a aprendizaxe automática ás veces pode ser difícil xa que utilizaremos tecnoloxías e técnicas fóra do conxunto de habilidades habituais necesarios para construír os modelos.
Neste artigo, imos descubrir unha forma de implementar modelos de aprendizaxe automática usando só Python. E ao longo do camiño, imos construír un modelo de tradución automática e unha páxina web.
Entón, aquí están os pasos que imos ver:
-
Usando Huggingface modelos de tradución automática.
-
Descubrindo Anvil e construíndo unha IU web para o noso modelo.
-
Conectando backend e frontend e servindo ao mundo o noso traballo!
Construír un modelo de tradución automática
Huggingface é unha comunidade de IA que traballa para "democratizar unha boa aprendizaxe automática". Baixo esta iniciativa, podes atopar moitos modelos adestrados en diferentes tarefas de aprendizaxe automática: segmentación de imaxes, texto a voz, xeración de texto... e tamén tradución automática!
A tradución automática é simplemente unha tarefa de tradución entre dúas linguas realizada por un software, no noso caso, un modelo de aprendizaxe automática construído con transformadores.
Un transformador é unha arquitectura de aprendizaxe profunda baseada na atención. Poñemos a funcionar na túa máquina!
Usaremos transformers, unha biblioteca de python para descargar o modelo MT e realizar unha tradución.
pip install torch
pip install transformers
Despois de instalar os paquetes necesarios, importe os seguintes módulos:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
Imos obter un modelo que traduza unha frase do alemán ao inglés. Necesitamos o nome do modelo:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
Agora imos importar o modelo adestrado e o tokenizador usando as seguintes liñas:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
O tamaño da descarga é duns 300 MB, despois de rematar podes almacenar o modelo nun directorio local usando o seguinte:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
Imos o modelo:
text="ich habe keine ahnung"
gen = model.generate(**tok.prepare_seq2seq_batch(src_texts=[text], return_tensors="pt"))
words: List[str] = tok.batch_decode(gen, skip_special_tokens=True)
print(words[0])
Agora deberías ter a tradución ao inglés da frase almacenada en words[0].
Descubre Anvil e crea unha IU web
Anvil é un marco e unha pila de solucións que che permiten crear aplicacións web usando só código Python. Ten un editor de arrastrar e soltar para crear unha interface de usuario web e permítelle conectar o código da súa máquina local á interface de usuario que crea e aloxar a súa aplicación dándolle unha ligazón que pode compartir.
Entón, imos comezar coa creación dunha aplicación desde aquí. Escolla a aplicación en branco e despois o deseño do material.
Deberías ver algo así:
Agora contarei contigo para que uses o editor e crees algo semellante ao seguinte:
Nesta sinxela IU, temos dous menús desplegables para escoller os idiomas de orixe e destino. Tamén temos un TextBox para introducir o texto de orixe e un compoñente richText para mostrar o texto traducido. Tamén podes ver un botón para iniciar a tarefa de tradución.
Para sincronizar cos fragmentos de código que verás a continuación, dálle os mesmos ID aos compoñentes. A continuación podes atopar un exemplo de onde podes establecer o ID dun compoñente:
Os ID que estamos a usar son:
</táboa>
Función Onclick
Engadimos un botón que se utiliza para iniciar a tradución. Desde o teu editor fai clic no botón e desprázate cara abaixo no panel de propiedades. Na parte inferior, verás unha sección de eventos. Na zona de texto xunto a "clic", introduza "traducir" e, a continuación, faga clic na frecha á dereita desta zona de texto.
Isto levarache á vista de código onde verás algún código Python xerado automaticamente.
Verá que o yunque engadiu automaticamente unha función chamada traducir. Chamarase cada vez que se faga clic no botón da nosa IU.
Aquí tes como debe ser a función:
def translate(self, **event_args):
"""This method is called when the button is clicked"""
src_lang=self.source_lang.selected_value #get the selected source language
dest_lang=self.dest_lang.selected_value #get the selected destination language
text=self.source_text.text #get the text written in source language
#call the server function
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
#write the translated text to the UI
self.translated_text.content=translated_text
Esta función realiza 3 tarefas principais:
-
Obter información da IU
-
Envía a información ao noso backend usando a función do servidor "tradución" (explicarémolo na seguinte sección)
-
Envía o texto traducido á IU.
Función de servidor
Centrémonos nesta liña de código:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
Usamos anvil.server.call para chamar a unha función do servidor chamada tradución que definiremos no noso código de fondo na máquina local.
Esta función servirá de conexión entre a IU web e o código de backend que se executará no noso modelo de tradución automática.
Como observaches tamén enviamos os parámetros desta función na función anvil.server.call.
Implementa o noso modelo MT
Imos primeiro instalar yunque
pip install anvil-uplink
Agora construímos a nosa interface web no editor de yunque e temos bloques de código básicos para executar o noso modelo de tradución automática e facer unha tradución.
O seguinte paso é definir a función do servidor que comentamos na sección anterior.
Aquí está o código da función:
@anvil.server.callable
def translation(text,src,dest):
lang_code={"English":"en",
"German":"de",
"French":"fr",
"Spanish":"es"}
model=MarianMTModel.from_pretrained("./models/"+lang_code[src]+"_"+lang_code[dest])
tok=MarianTokenizer.from_pretrained("./models/"+lang_code[src]+"_"+lang_code[dest]+"/tok")
gen = model.generate(**tok.prepare_seq2seq_batch(src_texts=[text], return_tensors="pt"))
words: List[str] = tok.batch_decode(gen, skip_special_tokens=True)
return words[0]
A función tomará os 3 parámetros enviados desde o frontend, converterá os idiomas de orixe e destino aos códigos de idioma respectivos e despois cargará os modelos e calculará a tradución e devolverá o resultado.
A forma de declarar esta función a yunque como función de servidor é usando o decorador
@anvil.server.callable.
Temos un último paso que facer para conectar o código de fondo que podemos executar nun notebook jupyter á nosa aplicación yunque.
Vaia ao editor en liña de anvil, fai clic na icona da engrenaxe e, a continuación, fai clic en "Enlace ascendente...".
Vexa a pantalla a continuación
Verás que aparece unha ventá emerxente e fai clic en "Activar a ligazón ascendente do servidor para esta aplicación" para obter o código de conexión que copias.
Pega o código na seguinte liña de código:
anvil.server.connect("code here")
Esta liña iniciará un servidor que conecta o teu script de código local ou o teu notebook jupyter coa aplicación Anvil coa función tradución rexistrada como función de servidor.
Paso final
Ata este punto, tes o teu servidor backend funcionando cunha función de servidor que carga o modelo de tradución automática e fai a tradución despois de ter en conta os parámetros enviados desde o frontend. Esta figura resume o que fixemos xuntos ata agora.
O último paso é executar a aplicación facendo clic no botón Executar na parte superior central do editor de yunque.
Despois de executar a aplicación, ves na esquina superior dereita un botón "publicar esta aplicación" que che dará unha ligazón que podes compartir para acceder á aplicación e facer a túa tradución.
Conclusión
Seguindo este artigo, puideches implementar un modelo MT e crear unha interface web para usalo.
Aínda queda moito por descubrir sobre como implementar de forma efectiva un modelo usando yunque, pero agora tes os conceptos básicos para comezar a túa viaxe de implantación e aumentar o potencial dos teus coñecementos previos en Python para facer moito máis.
Ven a un dos nosos obradoiros gratuítos
Comeza a túa carreira como científico de datos cos nosos obradoiros gratuítos, que se basean nun currículo adaptable e están guiados por expertos do sector.
|
Compoñente |
ID |
|---|---|
| Idioma de orixe desplegable | source_lang |
| Idioma despregable de destino | dest_lang |
| Cadro de texto da lingua de orixe | texto_origen |
| Texto enriquecido de texto traducido | texto_traducido |
