Forem: Thais Ribeiro

Entendendo Programação Orientada a Objetos, de vez, com Harry Potter.

Thais Ribeiro — Tue, 13 Sep 2022 03:41:09 +0000

"Castigo do monstro, sim ele voltou aquele que é o mais temido de todas as edições…" - Ivy, bbb 20

Vem ai a Programação Orientada a Objetos e se você como eu, fez parte de uma maioria que não entendeu direito na faculdade, eu to aqui para te ajudar a entender, sim, pedi ajuda ao Dumbledore.

Oi pessoALL, agora sim, tudo bem com vocês? Atualmente, sou professora no Luiza, que é programa de formação em tecnologia, exclusivo para mulheres, criado pelo Magalu. Estamos na 5° edição e novamente fui/sou a responsável pelo módulo de POO.
No decorrer do curso recebi alguns feedbacks interessantes e inspiradores:

Fiquei imensamente feliz por ter conseguido deixar claro o módulo para elas, assim como pela criatividade e todo o empenho que elas tiveram do início ao fim.
Vendo que foi bastante positivo, resolvi transformar um pouco do que foi ensinado em um artigo, e ao longo dele vou explicar para vocês a parte teórica de POO e a parte prática, com python, vamos aprender como poderíamos/podemos aplicar na vida real.
Antes de tudo, programação orientada a objetos é um paradigma de programação que tenta emular problemas do mundo real, usando o conceito abstrato de objetos, como uma estrutura de dados que pode ser alterada e referenciada.

Dito de outra forma…

Programação orientada a objetos é uma abordagem para modelar coisas concretas do mundo real, como carros, bem como relações entre coisas, como empresas e funcionários, alunos e professores e assim por diante. POO modela entidades do mundo real como objetos de software que possuem alguns dados associados a eles e podem executar determinadas funções.
E quais as vantagens? Bom, vamos entender em uma analogia simples:
João, Maria e Alice vão a uma pizzaria, porém, cada um deles tem um sabor preferido de pizza.
João gosta de pizza de mussarela, Maria gosta de pizza de calabresa e Alice de palmito. Todas as pizzas tem a mesma base e molho, o que muda é a cobertura.

Se o pizzaiolo optar por economia de tempo, ele vai triplicar a massa e o molho em uma só receita, finalizar mudando apenas a cobertura, caso contrário, ele terá que construir 3 massas, 3 molhos e assim por diante.

Em POO, a facilidade de pegar as partes em comum e modularizar nos trás algumas vantagens, como redução de custos,economia em tempo e esforço, facilidade de alteração/manutenção do código, etc.

E o que são objetos?

Os objetos são as base do POO **e pode ser **qualquer coisa que represente coisas da vida real, é uma entidade que encapsula dados e comportamentos, onde comportamento é o conjunto de funções (métodos) que operam nesses dados.

Observe a calculadora, podemos notar que os atributos são sempre adjetivos, enquanto os comportamentos (métodos) são sempre os verbos

E classes?

Uma classe é uma coleção de objetos com características semelhantes.

São usadas para criar estruturas de dados definidas pelo usuário. As classes definem funções, que identificam os comportamentos e ações que um objeto criado a partir da classe pode realizar com seus dados.

Uma classe é um modelo de como algo deve ser definido. Na verdade, ele não contém nenhum dado. Já a instância, que é um objeto que é construído a partir de uma classe, irá conter os valores reais.

Os principais pilares de POO

O paradigma de POO é um campo vasto e aplicado em diferentes linguagens de programação, dito isso, temos a necessidade de entender o que o abrange: seus quatro principais pilares.

Aprendendo com Harry Potter

No decorrer, vamos aprender a teoria por trás de cada pilar e a prática associando ao universo do bruxinho mais famoso da atualidade.

Herança

Podemos definir, como o processo onde uma classe adquire as propriedades e comportamento de outra.

É muito útil para classes que repetem basicamente as mesmas coisas, quando isso acontece, é interessante criar uma classe base e para cada classe que tiver comportamentos e propriedades semelhantes, eu faço uma extensão da classe principal.

Observe a imagem abaixo, a classe base é a mãe e a subclasse é a filha, pode acontecer também de uma classe estender/herdar duas classes, chamamos de: classe múltipla.

Lembra quando eu falei que POO emula problemas do mundo real? Claramente quando Dumbledore fala para Harry que ele se parece com o pai e tem os olhos da mãe, vemos um exemplo claro de herança.

No exemplo do código abaixo, foi feito uma herança de bruxos. A partir da classe base Witch podemos criar bruxos herdando comportamentos e atributos, além dos seus próprios, caso tenham.

Abstração

A abstração é um processo de ocultar os detalhes de implementação do usuário, apenas a funcionalidade será fornecida.

Dito de outra forma, o usuário tem acesso apenas a informação sobre o que o objeto faz ao invés de como ele faz.
Um exemplo clássico de abstração é o caixa eletrônico, quando vamos sacar dinheiro, sabemos como sacar, não necessariamente precisamos entender o que o caixa faz.

Uma abstração pode ser feita quando temos repetições de código em várias funções ou em vários arquivos, abstraímos esse código e depois só usaremos a chamada para ele.
Vamos ver na prática como isso funciona?

Um vira-tempo é um dispositivo mágico utilizado para viajar no tempo. Ele assemelha-se a uma ampulheta preza em um colar, sabemos que ele volta no tempo, mas não necessariamente o processo que ele leva para voltar ao tempo.

"Eu marco as horas, cada uma, ainda nem ultrapassei o Sol. Meu uso e valor, para você, são medidos pelo o que você tem de fazer." - A inscrição gravada no vira tempo emprestado à Hermione Granger

Se colocássemos isso em código, ficaria assim:

Na classe TimeTurner, temos um método que faz a viagem no passado, nota-se que quando eu faço a instância da classe e acesso a sua função back_in_time, eu posso voltar ao passado sem saber como acontece debaixo dos panos.

Encapsulamento

Pode ser descrito como uma barreira protetora que impede que o código e os dados sejam acessados aleatoriamente por outro código definido fora da classe. O acesso aos dados e ao código é rigidamente controlado por uma classe.

Vamos entender melhor, suponha que eu tenho uma classe de DadosDoRh, essa classe lista as informações dos funcionários e também o salário de cada um. Contudo, salário é uma informação restrita, somente pessoas especificas do departamento pessoal, como isso ficaria?

class DadosDoRh:
    def __init__(self, funcionario, departamento):
        self.funcionario = funcionario
        self.departamento = departamento
        self.salario = None
    def get_funcionario(self):
        return self.funcionario

    def __get_salario(self):
        if self.departamento == 'adm': 
            self.salario = 1000.00
        if self.departamento == 'dev':
            self.salario = 1250.00
        return self.salario
    def get_salario_by_user(self):
        if self.funcionario == 'adm' and self.departamento == 'adm':
            return self.__get_salario()
        else:
            return 'Você não tem permissão para ver o salário'

Observe que __get_salario é uma função privada, em python, usamos o __ para garantir a restrição desse método, criamos uma regra também, que garante que esse método só pode ser "acessado" do lado de fora, a partir de outro método: get_salario_by_user e somente por funcionários que atendam os requisitos da implementação.

Agora em HP, um exemplo claro de encapsulamento é a câmera secreta. Para quem está por fora da saga, é uma câmera subterrânea sob as masmorras da escola, criada na idade média por Salazar Sonserina. O lugar habita um monstro - basilisco - supostamente destinado a limpar a escola de todos os nascidos trouxas, ou seja, os que estavam na escola mas não tinha sangue bruxo.

A câmera poderia ser acessada somente por Salazar, mais tarde Harry Potter conseguiu acessá-la para salvar uma garota e a escola.

Polimorfismo

Por fim, chegamos ao polimorfismo, que é a característica de poder atribuir um significado ou uso diferente a algo em diferentes contextos - especificamente, permitir que uma entidade como uma função ou um objeto tenha mais de uma forma.

Como assim?

Supondo que temos uma filial de lojas, e que os descontos a vista podem mudar entre uma e outra.

class Desconto:
    def __init__(self, valor):
        self.valor = valor
    def calcula_desconto(self):
        return self.valor * 0.05
class DescontoLoja1(Desconto):
    def __init__(self, valor):
        super().__init__(valor)

    def calcula_desconto(self):
        return self.valor * 0.03

Observando o código acima, a minha loja 1 não aceita dar 5% de desconto a vista, ela dá 3%, mas o comportamento dela ainda se assemelha a classe base.

O que fizemos então? Sobrescrevemos o método calcula_desconto, para que atenda a nossa situação da loja 1, isso faz com que nosso objeto assuma uma nova forma dentro da segunda classe.

Uma ótima representação disso em Harry Potter é o bicho-papão, quando ele aparece na saga, ele não tem uma forma definida, ele assume a forma conforme o medo da pessoa.
Harry tem medo de dementador, então o bicho-papão assume a forma de um dementador e somente quando Harry domina a magia Riddikulus, é que ele consegue se livrar.

Antes de fecharmos o artigo, assim como fiz no fim do módulo, quero propor um desafio para vocês: Pensem em um filme, série, situação do dia a dia, livro, no que você pode implementar esses pilares, vai facilitar muito o entendimento do paradigma.

E para finalizar, deixo com vocês as implementações das minhas alunas, que foram incríveis e bastante criativas, para ajudá-los nesse processo. Até mais!

Como eu criei um bot para o Twitter e coloquei para executar no Heroku

Thais Ribeiro — Wed, 10 Aug 2022 02:15:29 +0000

Oi gente linda, tudo beleza com vocês? Saindo um pouco do mundo de IA, hoje vou explicar como eu criei um bot simples, que lista as principais noticias, referentes à tecnologia, da internet e posta no Twitter.
O ThaisPosta, além de vir de um trocadilho com meu nome, quem me conhece sabe que isso é comum por aqui, surgiu na intenção de compartilhar todos os dias uma lista de links úteis para novos e antigos desenvolvedores.
Antes de mais nada, vale ressaltar que o projeto faz sua função conforme prometido, contudo, tem muito espaço para ser aprimorado, então vamos começar?

Para conseguirmos criar bots para o twitter, precisamos criar uma conta de desenvolvedor aqui: https://developer.twitter.com/en.
Além de criar a conta no portal do desenvolvedor, será necessário criar o projeto e dar permissões mais elevadas para as API's através de products, para facilitar o entendimento, vou deixar aqui embaixo um artigo sobre como criar os acessos e obter os tokens.

API do Twitter: criando a conta de desenvolvedor e obtendo os tokens | by Bruno Anastacio | Programadores Ajudando Programadores | Medium

Bruno Anastacio ・ Jul 13, 2020 ・
Medium

Após criado o projeto e tendo em mãos os tokens necessários: consumer_key, consumer_key_secret, access_token e access_secret, vamos iniciar o desenvolvimento do projeto.
Como sempre, nosso projeto será em python e vamos precisar das seguintes bibliotecas:

pip install tweepy
pip install requests

Tweepy é uma biblioteca que nos permite acessar facilmente a API do Twitter e requests, como o nome já diz, para fazermos nossas requisições. Outra sugestão de biblioteca é a beautifulsoup4, para rasparmos conteúdos da web que não nos fornece endpoints, contudo, vamos optar pelo simples e deixarmos o web scraping para mais tarde.

Criaremos agora a busca dos artigos, a principio usei o dev.to e o medium como fontes, ambos possuem API's disponíveis externamente, o que facilitou a minha busca.

import random
import requests
TAGS_DEV = ['javascript', 'python', 'webdev', 'devops', 'react', 'vue',
            'typescript', 'github', 'css', 'tutorial', 'beginners', 'node']


def get_top_articles_devto():
    tags = random.sample(TAGS_DEV, k=3)
    list_articles = []

    for tag in tags:

        url = f'https://dev.to/api/articles?per_page=3&tag={tag}&top=2'
        articles = requests.get(url).json()

        for a in articles:
            obj_article = {
                'tag': tag,
                'title':  a['title'],
                'description': a['description'],
                'link': a['url']}

            list_articles.append(obj_article)

    return list_articles

Seguimos agora criando a autenticação com a API do twitter e a função que nos permitirá criar as postagens, conforme o exemplo.

import os
import tweepy

def post_twitter():
    consumer_key = os.getenv('CONSUMER_KEY')
    consumer_secret = os.getenv('CONSUMER_SECRET')
    access_token = os.getenv('ACCESS_TOKEN')
    access_secret = os.getenv('ACCESS_SECRET')
    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)

    auth = tweepy.OAuthHandler(
        consumer_key=consumer_key,
        consumer_secret=consumer_secret)
    auth.set_access_token(access_token, access_secret)
    api = tweepy.API(auth)
    post_twitter_devto(api)

 def post_twitter_devto(api):
    message = '📚 ThaisPosta links do dia: \n'

    body_message = []
    # Busca os artigos
    dev_to = get_top_articles_devto()
    b_new = []
    count = 0
    for i, dev in enumerate(dev_to):
        message_body = f'{dev.get("tag").upper()}: 👉 {dev.get("title")}\nlink: {dev.get("link")}'

        # Como o twitter tem limite de caracteres é necessário verificar, se ultrapassar o tamanho exigido, vamos postar uma thread.
        if len(message) + len(''.join(body_message)) <= 247:
            body_message.append(message_body)
        else:
            b_new.append({count: body_message})
            count += 1
            body_message = [message_body]

    b_new.append({count: body_message})

    status = None
    thread = None
    for i, b in enumerate(b_new):
        if i == 0:
            # publica no twitter
            status = api.update_status(message + '\n'.join(b[i]))
        else:
            # verifica se é um post inicial, ou se é uma resposta, criando assim uma thread se necessário
            if thread is not None:
                _id = thread
            elif status._json['id']:
                _id = status._json['id']

            if _id is not None:
                # publica no twitter, usando como referencia o post inicial
                thread = api.update_status(status='\n'.join(b[i]),
                                           in_reply_to_status_id=_id,
                                           auto_populate_reply_metadata=True)
                status = None
                thread = thread._json['id']

    return thread

Pronto! Se chegou até aqui com sucesso, agora ao rodarmos python scheduler.py, nossos links serão publicados no twitter.
Mas Thais, se eu quiser automatizar essa tarefa, o que eu faço?

Essa imagem é famosa no mundo dev, mas como meu conteúdo abrange todo mundo e se "todo mundo" não sabe o que é o Heroku, encontrei uma definição muito boa para vocês.

Heroku: o que é e como auxilia no desenvolvimento escalável

O Heroku ajuda na criação de aplicativos mais eficientes para os seus clientes com muito mais praticidade. Entenda como!

imaginedone.com.br

E o que faremos a seguir, é criarmos um pipeline e um aplicativo nessa plataforma, ou seja, vamos subir nosso código. Vou ensinar uma forma simples, usando o github, já aproveito e deixo com vocês o código completo.
Após subir os arquivos para o git e supondo que a conta do heroku já esteja criada, vamos criar um "new app", com os seguintes passos:

Na aba deploy, vamos conectar a plataforma ao nosso github e buscar pelo repositório do projeto.

Já em settings, vamos configurar nossas variáveis de ambiente.

Por fim, voltaremos na aba anterior e no fim da página iremos dar start no deploy. Se o build foi finalizado com sucesso, o aplicativo já estará pronto para ser usado.
Agora precisamos incluir um agendador de tarefas para rodar nosso script, faremos isso com a ajuda dos complementos do Heroku.
Vamos para o menu de recursos e em Add Ons, vamos procurar por 'schedule', usaremos o Advanced Schedule.

Avançando, há uma opção “free”, selecione-a conforme a imagem.

Em seguida, vamos criar nosso primeiro gatilho, iremos atribuir um nome para nossa tarefa e em command inserir o comando "python scheduler.py".

Como próximo passo, vamos definir as configurações da nossa tarefa, como os intervalos de execução.

Sim, acabamos. Simples assim.
Você pode testar executando a trigger de forma manual, mas todos os dias ou em todo horário configurado, o gatilho será disparado rodando o código que subimos, e por fim desfrutaremos de mais uma tarefa legal e automatizada.

Por hoje é só pessoALL, espero que tenham gostado desse artigo e se quiserem conferir na íntegra, fiquem a vontade para me seguir: @thaisplicandoo.
Beijos e até breve!

Resume meu texto?

Thais Ribeiro — Tue, 26 Jul 2022 19:26:29 +0000

Olá pessoas incríveis da internet, tudo bem com vocês? Trago hoje mais um artigo explorando o mundo de inteligência artificial, onde vamos aprender a sumarizar textos com a ajuda de NLP (Natural Language Processing).
Para começarmos, precisamos entender que sumarização é basicamente a construção de um resumo, onde dado um texto, se produz outro texto que condense o sentido do texto original, focando apenas nos pontos principais.

Atualmente, usamos textos sumarizados para facilitar a análise dos dados que recebemos, por exemplo, uma grande organização usa desse processo para trazer as partes importantes de feedbacks para gerar insights, outro exemplo é quando precisamos resumir partes importantes de um determinado texto para apresentar em links de matérias, blogs.

Apesar de parecer trivial, é uma atividade bastante comum que geralmente é feita de forma manual, isso torna o processo mais tedioso e lento, então como podemos resolver isso? Com os avanços tecnológicos, hoje conseguimos fazer isso de forma automática com a ajuda de Machine Learning, especificadamente, usando processamento de linguagem natural.

Existem duas abordagens que são usadas para a sumarização: o resumo abstrativo que consiste na geração de novas frases a partir do texto original e a sumarização extrativa, onde identificamos frases importantes no texto e extraímos gerando o resumo, está última será a que vamos usar.

Vamos construir uma API, usando FastAPI, onde teremos como entrada, tanto texto como url, vamos começar dividindo o artigo em partes. A primeira parte vamos tratar os dados que recebemos, na segunda parte vamos fazer a parte de sumarização.

Colocando a mão na massa

Lidando com os dados

Vamos iniciar instalando o framework do fastAPI

pip install fastapi

Vamos precisar também de um servidor ASGI

pip install uvicorn

Nosso projeto vai ter a seguinte estrutura:

text_summarizer_api/ # raiz
┣ api/
┃ ┣ routers/
┃ ┃ ┗ summarization.py # rotas da API (POST/GET)
┃ ┣ schemas/
┃ ┃ ┗ summarization_schema.py # Formato da entrada de dados
┃ ┣ services/
┃ ┃ ┗ summarization_service.py # Sumarização de texto
┣ main.py # Inicial
┗ requirements.txt

Começamos construindo nosso serviço de sumarização, lembrando que nessa parte vamos tratar os dados:

Dado o seguinte payload, percebemos que podemos receber tanto texto como url, além de ser obrigatório o idioma, para que a sumarização seja feita de forma correta.

Vamos começar com o método get_summarization para identificar que tipo de dado estamos recebendo:

async def get_summarization(summarization):
    formatted_text = summarization.text if summarization.url is None else scraping_text(summarization.url)

Se passarmos uma URL, vamos precisar fazer um web scraping para extrair as informações de texto que vamos precisar e para fazer essa extração vamos usar um módulo chamado BeautifulSoup.

pip install beautifulsoup4 requests

Não abordaremos de forma profunda como é feita essa raspagem, talvez em outro artigo, mas para atender nossa demanda, faremos o seguinte:

Enviaremos uma requisição na url recebida
Vamos recuperar o conteúdo HTML como texto
Examinaremos a estrutura recebida em soup e vamos buscar pelo elemento especifico
Por fim, vamos extrair os textos e realizar uma limpeza, removendo todos os caracteres especiais, acentos e espaçamentos inutilizados.

from bs4 import BeautifulSoup as bs

def scraping_text(url):
    response = requests.get(url)
    soup = bs(response.content, 'lxml')
    paragraph = soup.find_all(name='p', attrs= {"class": "pw-post-body-paragraph"}, limit=40)
    joined_text = ''.join([p.text.strip().lower() for p in paragraph])
    joined_text = format_text(joined_text)
    return joined_text

def format_text(text):
    formatted_text = unicodedata.normalize('NFD', text).encode('ascii', 'ignore').decode('utf-8')
    formatted_text = re.sub(r'\[[0-9]*\]', ' ', formatted_text)
    formatted_text = re.sub(r'\s+', ' ', formatted_text)
    return formatted_text

Pronto, temos os dados tratados e agora entramos na segunda parte do artigo.

Sumarização

Para começar nosso processo de sumarização, precisamos instalar e importar as bibliotecas necessárias:

pip install nltk

NLTK, significa Natural Language Toolkit, ou seja, um conjunto de ferramentas para linguagem natural que contem vários algoritmos implementados para trabalhar com linguagem natural.

Usaremos os pacotes Corpus e os Tokenizers, quando falamos em “tokenização”, falamos em dividir um texto em uma série de tokens, já um corpus de texto é um grande corpo de texto ou coleção de texto, que podem ser conjuntos de dados, como obras de um autor, poemas, ou um conjunto de palavras de paradas.

O NLKT inclui alguns corpora que são essas listas de palavras irrelevantes, ou seja, palavras de alta frequência, que podemos filtrar em um documento antes de iniciar o processamento, no nosso caso vamos filtrar essas palavras de parada, adicioná-las a um dicionário python para verificar a frequência com que elas aparecem no texto antes de serem removidas.

Vamos usar este dicionário sobre cada frase para saber quais tem o conteúdo mais relevante no texto geral.

import re
import requests
from bs4 import BeautifulSoup as bs
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize, sent_tokenize

async def get_summarization(summarization):
    formatted_text = summarization.text if summarization.url is None else scraping_text(summarization.url)
    stop_words = set(stopwords.words(str(summarization.language)))
    frequences_word = handle_frequence_word(stop_words, formatted_text)
    print('Dicionário de frequencia de palavras de parada', frequences_word)

def handle_frequence_word(stop_words, text):
    words = word_tokenize(text)
    frequences_word = dict()
    for word in words:
        if word in stop_words:
            continue
        if word in frequences_word:
            frequences_word[word] += 1
        else:
            frequences_word[word] = 1

    return frequences_word

def scraping_text(url):
    response = requests.get(url)
    soup = bs(response.content, 'lxml')
    paragraph = soup.find_all(name='p', attrs= {"class": "pw-post-body-paragraph"}, limit=40)
    joined_text = ''.join([p.text.strip().lower() for p in paragraph])
    joined_text = format_text(joined_text)
    return joined_text

def format_text(text):
    formatted_text = unicodedata.normalize('NFD', text).encode('ascii', 'ignore').decode('utf-8')
    formatted_text = re.sub(r'\[[0-9]*\]', ' ', formatted_text)
    formatted_text = re.sub(r'\s+', ' ', formatted_text)
    return formatted_text

Agora, lidaremos com as sentenças, ou seja, os tokens de frases mais tarde usaremos essa lista no resumo do texto. Nesta avaliação analisaremos a frequência de ocorrência de cada termo, logo, estaremos pontuando cada frase por suas palavras; isto é, somando a frequência de cada palavra importante encontrada na frase.

async def get_summarization(summarization):
    formatted_text = summarization.text if summarization.url is None else scraping_text(summarization.url)
    stop_words = set(stopwords.words(str(summarization.language)))
    frequences_word = handle_frequence_word(stop_words, formatted_text)
    sentences = sent_tokenize(formatted_text)
    frequences_sentence = handle_sentences(frequences_word, sentences)

def handle_sentences(frequences_word, sentences):
    frequences_sentence = dict()
    for sentence in sentences:
        for word, freq in frequences_word.items():
            if word in sentence:
                if sentence in frequences_sentence:
                    frequences_sentence[sentence] += freq
                else:
                    frequences_sentence[sentence] = freq

    return frequences_sentence

Para concluirmos a parte de sumarização, criaremos um resumo escolhendo 30% das frases mais ponderadas.

select_lenght = int(len(frequences_sentence) * 0.3) # peso 30%

Com a ajuda da função nlargest do módulo heapq, vamos retornar o número especificado de maiores elementos de um iterável, no nosso caso, encontraremos os maiores n elementos, aqui o valor da lista com as frases com peso 30% em cima do iterável que é nosso dicionário de sentenças.

summary = nlargest(select_lenght, frequences_sentence, key=frequences_sentence.get)

Por fim, percorremos o sumário gerado concatenando em uma string, sendo essa o resultado do nosso resumo.

O código completo do nosso service fica assim:

import re
import requests
import unicodedata
from bs4 import BeautifulSoup as bs
from heapq import nlargest
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize, sent_tokenize

async def get_summarization(summarization):
    formatted_text = summarization.text if summarization.url is None else scraping_text(summarization.url)
    stop_words = set(stopwords.words(str(summarization.language)))
    frequences_word = handle_frequence_word(stop_words, formatted_text)
    sentences = sent_tokenize(formatted_text)
    frequences_sentence = handle_sentences(frequences_word, sentences)
    return get_resume(frequences_sentence)

def scraping_text(url):
    response = requests.get(url)
    soup = bs(response.content, 'lxml')
    paragraph = soup.find_all(name='p', attrs= {"class": "pw-post-body-paragraph"}, limit=40)
    joined_text = ''.join([p.text.strip().lower() for p in paragraph])
    joined_text = format_text(joined_text)
    return joined_text

def format_text(text):
    formatted_text = unicodedata.normalize('NFD', text).encode('ascii', 'ignore').decode('utf-8')
    formatted_text = re.sub(r'\[[0-9]*\]', ' ', formatted_text)
    formatted_text = re.sub(r'\s+', ' ', formatted_text)
    return formatted_text

def handle_frequence_word(stop_words, text):
    words = word_tokenize(text)
    frequences_word = dict()
    for word in words:
        if word in stop_words:
            continue
        if word in frequences_word:
            frequences_word[word] += 1
        else:
            frequences_word[word] = 1

    return frequences_word

def handle_sentences(frequences_word, sentences):
    frequences_sentence = dict()
    for sentence in sentences:
        for word, freq in frequences_word.items():
            if word in sentence:
                if sentence in frequences_sentence:
                    frequences_sentence[sentence] += freq
                else:
                    frequences_sentence[sentence] = freq

    return frequences_sentence

def get_resume(frequences_sentence):
    select_lenght = int(len(frequences_sentence) * 0.3) # peso 30%
    summary = nlargest(select_lenght, frequences_sentence, key=frequences_sentence.get)
    final = [word for word in summary]
    summary = ''.join(final)
    return summary

Finalizando…

Para finalizarmos nossa API, agora vamos consumir os serviços nas rotas e gerar endpoints de entrada, o código completo está no meu github.
Para finalizarmos nossa API, agora vamos consumir os serviços nas rotas e gerar endpoints de entrada, o código completo está no meu github.

Iniciaremos nosso servidor: uvicorn main:app --reload e podemos ter acesso a API: http://127.0.0.1:8000/docs

Obtemos a saída resumida e mantendo a lógica do texto original

Bom pessoal, não aprofundamos na criação de API’s porque o que quero mostrar para vocês é como podemos automatizar alguns processos morosos utilizando machine learning, espero que tenham gostado do conteúdo e por hoje, ficamos por aqui.

CHICA - A assistente virtual mineira e graciosa

Thais Ribeiro — Sat, 11 Dec 2021 05:09:57 +0000

Oi meus trem bão, tudo bem com vocês? Pois eu tô, bem e animada para trazer um conteúdo fresquinho juntando o que já ensinei por aqui e no twitter, mas para vocês não ficarem no escuro eu vou dar um breve resumo sobre essas "coisas".
A cada ano que passa está cada vez mais fácil ser preguiçoso e pedir para um assistente virtual realizar tarefas simples para você:
— Alexa, toca aquela lá da Marília
— Alexa, que dia é hoje?
— Siri, ligue para mamãe.
Mas vocês já se perguntaram como esses assistentes virtuais funcionam? Não? Vou te contar um pouco como funciona e te ensinar a fazer uma assistente personalizada baseada na CHICA, minha assistente mineirinha e graciosa.

Longe de ser uma siri ou uma Alexa, mas usando os mesmos conceitos, criei a Chica para ajudar as pessoas entenderem como funciona esse tipo de IA.
O foco principal hoje é falarmos sobre reconhecimento de voz de forma resumida, porque uma discussão completa caberia em um livro, ou vários.
O reconhecimento de voz tem suas raízes em pesquisas feitas nos anos 50 e os primeiros sistemas eram limitados a um vocabulário de uma dúzia de palavras, até chegarmos ao ponto que estamos hoje, esses sistemas percorreram um grande caminho desde então, e como eles trabalham por debaixo do capô?

O primeiro componente do reconhecimento de fala, é a fala 🗣️, ela é convertida de som físico em sinal elétrico com um microfone, e em seguida, em dados digitais com um conversor analógico-digital. Uma vez digitalizado, pode-se usar vários modelos para transcrever o áudio em texto.
A maioria dos sistemas atuais usam um modelo conhecido como Modelo de Markov Oculto(HMM), que funciona supondo que um sinal de voz, quando visto em uma escala de tempo curta o suficiente (dez milisegundos), pode ser razoavelmente aproximado como um processo estacionário, no qual as estatísticas não mudam ao longo do tempo.

Em um modelo HMM, o sinal de voz é dividido em fragmentos de 10 milisegundos, o espectro de potência* de cada fragmento é mapeado para um vetor de números reais conhecido como coeficientes cepstrais. A dimensão desse vetor é pequena e a saída final do HMM é uma sequência desses vetores. Para decodificar o que foi falado em texto, grupos desses vetores são combinados com um ou mais fonemas e um algoritmo especial é aplicado para determinar a palavra/frase mais provável produzida. Esses fonemas exige treinamento, já que um som varia de pessoa para pessoa.

Sugiro que vocês pesquisem mais a fundo sobre esse modelo para entender como os cálculos e os treinamentos são feitos. A boa notícia para o pythonista é que para tudo na vida hoje em dia tem biblioteca.Hoje existem vários serviços de reconhecimento de voz disponíveis por meio de API, e nós usaremos o SpeechRecognition.

SpeechRecognition

SpeechRecognition é um recurso importante usado na automação residencial e em dispositivos de inteligência artificial.
A principal função desta biblioteca é fazer o que explicamos ali em cima: tentar entender tudo o que os humanos falam e converter a fala em texto.
A flexibilidade e facilidade de uso do pacote, o tornam uma escolha excelente para qualquer projeto Python.

Instalando

pip install SpeechRecognition

No nosso caso vamos precisar instalar também o PyAudio para capturarmos a entrada do microfone.

Criando a Chica

Na assistente acoplei um nlp para identificar a intenção do usuário, eu expliquei como fazer um bot usando aprendizado profundo aqui no dev.to e lá no medium, é importante vocês lerem para entender como nosso modelo é treinado e como são classificadas as intenções.
Supondo que temos nosso modelo treinado e nossas intenções definidas, vamos criar nosso arquivo principal que será o cara responsável por capturar a voz do seu microfone e identificar o que você quis dizer, a explicação está comentada no código.

import os
import pathlib
import random
import pytz
import speech_recognition as sr
import wikipedia
import pyjokes
from datetime import datetime, timezone
from speech import to_speak
from nlp.extract import get_response, class_prediction
from pydub import AudioSegment
from pydub.playback import play
from youtube import run_youtube

wikipedia.set_lang("pt")
path = pathlib.Path(__file__).parent.resolve()
IST = pytz.timezone('America/Sao_Paulo')

listener = sr.Recognizer()


def listening():
    # captura o som do microfone
    with sr.Microphone() as src:
        print('listening...')
        listener.adjust_for_ambient_noise(src)
        voice = listener.listen(src)
        try:
            event = listener.recognize_google(voice, language='pt-BR')
            event = event.lower()
        except:
            event = 'anything_else'

    return event


def voice_chica(tag):
    song = AudioSegment.from_mp3(f'{path}/audios/{tag}.mp3')
    play(song)

def run():
    """
        Método que irá iniciar nossa assistente virtual e o reconhecimento de voz
        nesse momento a voz da chica será o default.
        Quem enjoar da minha voz, pode usar o
        to_speak passando o random.choices(response) no lugar de voice_chica

    """
    event = listening()
    # retorna a voz transcrita, que foi falada ao microfone
    print(f'evento: {event}')

    # é enviado para a classe de predição, para identificar as intenções e assim buscar a resposta mais coerente se existir, caso não exista cai no fallback.
Esse processo de NLP foi explicado no outro artigo.
    intents = class_prediction(event)
    response, context, tag = get_response(intents)

    if tag == 'song':
        voice_chica(tag)
        run_youtube(event)
    elif tag == 'hours':
        voice_chica(tag)
        hours_speak = f'{datetime.now(IST).hour} horas e {datetime.now(IST).minute} minutos'
        to_speak(hours_speak)
        voice_chica(f'{tag}2')
    elif tag == 'days':
        voice_chica(tag)
        days_speak = f'{datetime.now(IST).day}'
        to_speak(days_speak)
    elif tag == 'search':
        voice_chica(tag)
        voice_chica(f'{tag}2')
        info = wikipedia.summary(event, 1)
        to_speak(info)
    else:
        # voice_chica é um método que irá reproduzir os áudios com a minha voz haha e to_speak com a voz do google.
        voice_chica(tag)

while True:
    run()

Esse foi um exemplo de como ficou a classe principal, o projeto é open source e está no meu repositório.
Bom, vou deixar vocês colocarem a mão na massa e executarem o código, assim como tentar entendê-lo também haha, vou ficando por aqui, espero que tenham gostado e peço gentilmente que leve esse e os outros artigos aos seus amigos, assim você estará compartilhando informação e incentivando o meu trabalho.
Até mais.

Vamos converter um texto em escrita à mão?

Thais Ribeiro — Sun, 24 Oct 2021 04:31:14 +0000

Olá pessoas incríveis da internet, se você, assim como eu já passou por situações em que precisava assinar um documento online, enviar uma assinatura, escrever uma carta para o sindicato ou fazer uma tarefa de escola que o professor exige que seja feita à mão, hoje é seu dia de aprender a fazer o computador te ajudar (ou não).

O que vamos precisar?

Primeiro, vamos criar nosso modelo, queremos que seja com nossa caligrafia, então o que eu fiz e acho que vocês podem fazer de uma forma melhor? Escrevi em um papel branco todas as letras correspondentes a tabela Ascii:

Desde já peço desculpa pela péssima foto que dificultou um pouco, então sugiro que vocês façam em um papel em branco e melhore a qualidade da imagem. Agora vamos cortar/tirar print de cada carácter, renomear com seu respectivo código da tabela Ascii e salvar em uma pasta dentro do seu projeto.

Com nosso modelo pronto, chegou a hora de programarmos o script, que é muito simples,vamos usar a biblioteca PIL, que é uma biblioteca de código aberto do python que nos dá suporte para abrir, manipular e salvar alguns formatos de arquivos de imagens e também usaremos a biblioteca unicode, para removermos acentos do nosso texto de entrada.

pip install unidecode



from PIL import Image
from unidecode import unidecode

Vamos pensar em uma página, na verdade vamos usar uma página em branco onde vamos gravar nosso texto (mas podem usar a que quiserem) em forma de imagem, pensando em questão de altura e largura da mesma, temos os eixos x e y, devido a isso, vamos iniciar esses eixos nas posições 0.



input_text = open('text.txt').read()

# caminho da imagem onde vamos escrever nosso texto
background = Image.open('hand_fonts/page.png')
x, y = 0, 0

Feito isso, vamos percorrer cada caractere do nosso texto de entrada. A função ord produz o número correspondente ao ascii do item iterado e é ai que a mágica acontece, vamos associar esse número com a imagem correspondente da nossa fonte que salvamos na pasta hand_fonts.
Para finalizarmos, aplicamos algumas regras finais onde verificamos se a largura da linha não está excedendo a largura da página, e se não há quebra de linha, se sim, acrescentamos ao eixo y 140px, que pode variar dependendo da sua necessidade e do tamanho da imagem escolhida.



for text in unidecode(input_text):
    # verifica se tem quebra de linha e atualiza o eixo y, 
    # acrescentando 140px para a proxima linha
    if ord(text) == 10:
      print('Entrou?')
      x = 0
      y += 140
      continue

    # vamos usar a função ord que irá reproduzir
    # o respectivo código Ascii do nosso item e converter em string
    ascii_current = str(ord(text))
    try:
      font = Image.open(f'hand_fonts/{ascii_current}.png')
    except: 
      continue

    # atualiza a pagina em branco que escolhemos
    background.paste(font, (x, y))

    x += font.width

    # verificamos se a largura da linha está excedendo a largura da página, se sim, 
    # vamos para a próxima linha adicionando 140 px na variável y
    if background.width < x or len(text) * 115 > (background.width - x):
        x = 0
        y += 140

background.show()

E por hoje é só, gostou? Compartilha com seus amigos e me siga no twitter que sempre trago assuntos relevantes para lá.

Obrigada, e até a próxima!

Repositório

Como criar um bot usando deep learning e python?

Thais Ribeiro — Tue, 27 Jul 2021 06:25:46 +0000

Olá pessoas incríveis desse site, hoje o artigo vai tratar de um assunto que está muito em alta: chatbots!

Para começar, vamos pensar na forma que interagimos com outros seres humanos e o que seria do mundo se não existisse a comunicação, desde o principio o homem criou formas de se comunicar com o outro e é o fundamento para a organização das sociedades, nos últimos tempos o avanço da tecnologia vem afetando a forma como essa comunicação é feita, por exemplo, é tão fácil conversarmos com os outros amigos através de apps de mensagens, não é?
Esse avanço não só afeta a forma que nos comunicamos com outras pessoas, como também a forma que comunicamos com as máquinas, à medida que avançamos, o modo como comunicamos com os computadores vai se aproximando do natural e é aí que entra o campo de pesquisa computacional chamado PLN (NLP, do inglês Natural Language Processing), ou processamento de linguagem natural.
Esse campo de pesquisa estuda como fazer a máquina entender a nossa língua escrita, de uma forma que o computador consiga entender a escrita sem conteúdo definido por programadores e vamos fazer essa implementação!

Atualmente existem vários provedores de NLP, os MLaaS, disponíveis para facilitar nossa criação de bots, talvez vocês tenham ouvido sobre o IBM Watson ou até mesmo o Dialog Flow do Google, são provedores que já fazem de forma profunda esse processamento e são usados por grandes corporações, nós do Luizalabs usamos esses softwares por nos proporcionarem uma comunicação mais humanizada e fluída com o cliente, mas para o pequeno usuário, que talvez queira criar um bot simples ou até mesmo tem curiosidade em como fazer, não seja a melhor escolha, então hoje vou ensinar para vocês como criar um bot simples usando Python e deep learning, o código completo está no meu Github.

Vamos instalar?

Para começar, é necessário que você tenha uma versão recente do Python e o pip instalados no seu computador, logo mais, vamos instalar as seguintes bibliotecas:

pip install nltk
pip install numpy
pip install keras
pip install tensorflow

NLTK - É uma das ferramentas mais utilizadas para processamento de linguagem natural, foi desenvolvida em Python e tem uma gama muito grande de recursos, como: classificação, tokenização, stemming, tagging, parsing e raciocínio semântico. Todas essas funções são utilizadas para análise de texto;
Numpy - É uma biblioteca para a linguagem Python com funções para se trabalhar com computação numérica, e que pode realizar operações de álgebra linear de maneira muito eficiente;
Keras - Por último, e de extrema importância, usamos o Keras para a estrutura de aprendizado profundo, essa lib poderosíssima é uma das principais APIs de redes neurais de alto nível.

Seria interessante vocês darem uma lida em como essas bibliotecas funcionam para entender melhor o nosso código, apesar que vou explicando em todo o decorrer da implementação.

Vamos lá então, criaremos nosso dicionário de intents, quando falamos em intenções em chatbot, falamos sobre o intuito do usuário ao escrever tal texto. Nosso JSON irá conter a tag que define o que é aquela intenção, os patterns que serão os exemplos de mensagens enviadas, os responses que são os feedbacks enviados pelo bot e o context, se quisermos usar manipulação de contexto de mensagens:

{
  "intents": [
    {
      "tag": "welcome",
      "patterns": ["Oi", "bom dia", "boa tarde", "boa noite", "good morning", "Hi", "hello", "Olá"],
      "responses": ["Olá, eu sou sua assistente virtual, em que posso te ajudar?"],
      "context": [""]
    },
    {
      "tag": "who_are_you",
      "patterns": ["qual seu nome?", "quem é você?", "como você chama?", "nome?"],
      "responses": ["Eu sou uma assistente virtual, ainda não tenho nome."],
      "context": [""]
    },
    {
      "tag": "love",
      "patterns": ["te amo", "linda", "querida", "casa comigo?", "maravilhosa"],
      "responses": ["Awwwn, muito obrigada <3"],
      "context": [""]
    },
    {
      "tag": "censored",
      "patterns": ["feia", "boba", "chata", "vai pro inferno", "puta", "quer casar comigo?", "sua gostosa"],
      "responses": ["Não toleramos nenhum tipo de assédio."],
      "context": [""]
    },
    {
      "tag": "thanks",
      "patterns": ["obrigada", "tks", "thank you", "valeu", "obrigada pela ajuda", "muito obrigada"],
      "responses": ["De nada ;)", "Agradeço seu contato, volte sempre!"],
      "context": [""]
    },
    {
      "tag": "anything_else",
      "patterns": [],
      "responses": ["Desculpa, não entendi o que você falou, tente novamente!"],
      "context": [""]
    }
  ]
}

Treinando e criando nosso modelo

Agora, vamos criar o arquivo train.py, onde vamos ter o código para ler os dados de linguagem natural e usar a rede neural sequencial keras para criar nosso modelo.
Nesse código vamos dividir a explicação em algumas partes, para facilitar o entendimento.
Realizamos a importação e configuração inicial das libs que iremos utilizar:

import json
import pickle
import nltk
import random
import numpy as np

from nltk.stem import WordNetLemmatizer
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.optimizers import SGD

nltk.download('punkt')
nltk.download('wordnet')
lemmatizer = WordNetLemmatizer()

Inicializamos a nossa lista de palavras, classes, documentos e definimos quais palavras serão ignoradas, percorremos a nossa lista de intenções, que foram lidas pelo código e com ajuda do nltk fazemos a tokenização dos patterns e adicionamos na lista de palavras, adicionamos também aos documentos para termos a identificação da tag para cada palavra e adicionamos as tags a nossa lista de classe:

# inicializaremos nossa lista de palavras, classes, documentos e 
# definimos quais palavras serão ignoradas
words = []
documents = []
intents = json.loads(open('intents.json').read())
# adicionamos as tags em nossa lista de classes
classes = [i['tag'] for i in intents['intents']]
ignore_words = ["!", "@", "#", "$", "%", "*", "?"]

# é feita a leitura do arquivo intents.json e transformado em json
intents = json.loads(open('intents.json').read())

# percorremos nosso array de objetos
for intent in intents['intents']:
    for pattern in intent['patterns']:
        # com ajuda no nltk fazemos aqui a tokenizaçao dos patterns 
        # e adicionamos na lista de palavras
        word = nltk.word_tokenize(pattern)
        words.extend(word)

        # adiciona aos documentos para identificarmos a tag para a mesma
        documents.append((word, intent['tag']))

Em seguida, vamos lematizar, ou seja, transformar as palavras em seus significados básicos, com o objetivo de restringir tudo ao nível mais simples possível.
Um exemplo de lematização ocorre com verbos, tipo, escrevendo, escreveu e escreve tem o mesmo lema que é escrever.
Logo, classificamos nossas listas e estamos prontos para construir o modelo de aprendizado profundo.

# lematizamos as palavras ignorando os palavras da lista ignore_words
words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]

# classificamos nossas listas
words = sorted(list(set(words)))
classes = sorted(list(set(classes)))

# salvamos as palavras e classes nos arquivos pkl
pickle.dump(words, open('words.pkl', 'wb'))
pickle.dump(classes, open('classes.pkl', 'wb'))

Vamos começar nosso treinamento criando um array vazio de treinamento e criando uma lista de saídas vazias de acordo com o tamanho das nossas classes.
Percorremos nossos documentos, inicializamos um array de bag vazio, inserimos no nosso pattern_word a nossa palavra correspondente àquele padrão, lematizamos cada uma delas na tentativa de representar palavras relacionadas, inserimos 1 no bag se a correspondência de palavras for encontrada no pattern atual e utilizamos o output_row como uma chave para a lista, onde a saída será 0 para cada tag e 1 para a tag atual.
Após isso embaralhamos nosso conjunto de treinamentos, transformamos em numpy array e definimos uma lista de treinos, sendo x os patterns e y as intenções:

# inicializamos o treinamento
training = []
output_empty = [0] * len(classes)
for document in documents:
    # inicializamos o saco de palavras 
    bag = []

    # listamos as palavras do pattern
    pattern_words = document[0]

    # lematizamos cada palavra 
    # na tentativa de representar palavras relacionadas
    pattern_words = [lemmatizer.lemmatize( word.lower()) for word in pattern_words]

    # criamos nosso conjunto de palavras com 1, 
    # se a correspondência de palavras for encontrada no padrão atual
    for word in words:
        bag.append(1) if word in pattern_words else bag.append(0)

    # output_row atuará como uma chave para a lista, 
    # onde a saida será 0 para cada tag e 1 para a tag atual
    output_row = list(output_empty)
    output_row[classes.index(document[1])] = 1

    training.append([bag, output_row])

# embaralhamos nosso conjunto de treinamentos e transformamos em numpy array
random.shuffle(training)
training = np.array(training)
# criamos lista de treino sendo x os patterns e y as intenções
x = list(training[:, 0])
y = list(training[:, 1])

Com nossos dados de treinamento prontos, usaremos o modelo de aprendizado profundo keras chamado sequencial, esse modelo sequencial é uma das redes neurais mais simples, um perceptron multicamadas, que em particular tem 3 camadas, com a primeira tendo 128 neurônios, a segunda 64 e a terceira tendo o número de intenções igual o número de neurônios, o objetivo dessa rede é tentar prever qual base escolher de acordo com alguns dados.
Esse modelo será treinado com descida gradiente estocástica que é um tópico beeeem complexo, mas que tem muito conteúdo no senhor google e no link disponibilizado.
Depois que nosso modelo é treinado será salvo no model.h5 como numpy array e é com esse modelo que vamos criar nossa GUI do chatbot.

# Criamos nosso modelo com 3 camadas. 
# Primeira camada de 128 neurônios, 
# segunda camada de 64 neurônios e terceira camada de saída 
# contém número de neurônios igual ao número de intenções para prever a intenção de saída com softmax
model = Sequential()
model.add(Dense(128, input_shape=(len(x[0]),), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(y[0]), activation='softmax'))

# O modelo é compilado com descida de gradiente estocástica 
# com gradiente acelerado de Nesterov.
# A ideia da otimização do Momentum de Nesterov, ou Nesterov Accelerated Gradient (NAG), 
# é medir o gradiente da função de custo não na posição local,
# mas ligeiramente à frente na direção do momentum. 
# A única diferença entre a otimização de Momentum é que o gradiente é medido em θ + βm em vez de em θ.
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',optimizer=sgd, metrics=['accuracy'])

# ajustamos e salvamos o modelo
m = model.fit(np.array(x), np.array(y), epochs=200, batch_size=5, verbose=1)
model.save('model.h5', m)

print("fim")

Extraindo os dados e criando nossa interface (GUI)

Vamos criar um arquivo extract.py para extrair os dados e lidar com as previsões e probabilidades das mensagens em conjunto com o modelo treinado e um arquivo chamado bot.py que será a nossa interface gráfica.
Nosso arquivo extract tem 4 funções, sendo essas:

clear_writing que é a responsável por limpar as setenças inseridas, ou seja, fazer a higienização da mensagem enviada pelo usuário
bag_of_words é a função responsável por criar um pacote de palavras que será usado para as previsões.
class_prediction faz a previsão do pacote de palavras, usamos como limite de erro 0.25 para evitarmos overfitting e classificamos esses resultados por força da probabilidade;
get_response é a função que vamos usar depois que fizermos todo o processo acima, com nosso retorno de intenção, verificamos qual as mensagens de retorno do json, usamos o random para pegarmos apenas uma resposta da lista.

import random
import numpy as np
import pickle
import nltk
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()

words = pickle.load(open('words.pkl', 'rb'))
classes = pickle.load(open('classes.pkl', 'rb'))


def clear_writing(writing):
    """
        Limpa todas as sentenças inseridas.
    """

    #tokeniza todas as setenças das frases inseridas, lematiza cada uma delas e retorna
    sentence_words = nltk.word_tokenize(writing)
    return [lemmatizer.lemmatize(word.lower()) for word in sentence_words]


# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence


def bag_of_words(writing, words):
    """
        Pega as sentenças que são limpas e cria um pacote de palavras que são usadas 
        para classes de previsão que são baseadas nos resultados que obtivemos treinando o modelo.
    """
    # tokenize the pattern
    sentence_words = clear_writing(writing)

    # cria uma matriz de N palavras
    bag = [0]*len(words)
    for setence in sentence_words:
        for i, word in enumerate(words):
            if word == setence:
                # atribui 1 no pacote de palavra se a palavra atual estiver na posição da setença
                bag[i] = 1

    return(np.array(bag))


def class_prediction(writing, model):
    """
      Faz a previsao do pacote de palavras, usamos como limite de erro 0.25 para evitarmos overfitting
      e classificamos esses resultados por força da probabilidade.
    """

    # filtra as previsões abaixo de um limite 0.25
    prevision = bag_of_words(writing, words)
    response_prediction = model.predict(np.array([prevision]))[0]
    results = [[index, response] for index, response in enumerate(response_prediction) if response > 0.25]    

    # verifica nas previsões se não há 1 na lista, se não há envia a resposta padrão (anything_else) 
    # ou se não corresponde a margem de erro
    if "1" not in str(prevision) or len(results) == 0 :
        results = [[0, response_prediction[0]]]

    # classifica por força de probabilidade
    results.sort(key=lambda x: x[1], reverse=True)
    return [{"intent": classes[r[0]], "probability": str(r[1])} for r in results]


def get_response(intents, intents_json):
    """
        pega a lista gerada e verifica o arquivo json e produz a maior parte das respostas com a maior probabilidade.
    """
    tag = intents[0]['intent']
    list_of_intents = intents_json['intents']
    for idx in list_of_intents:
        if idx['tag'] == tag:
            # caso as respostas sejam um array contendo mais de uma, 
            # usamos a função de random para pegar uma resposta randomica da nossa lista
            result = random.choice(idx['responses'])
            break

    return result

Por fim, vamos criar nossa interface gráfica utilizando o módulo tkinter do Python, que é um toolkit padrão para criação de GUI. Para não extender muito e visto que esse módulo tem uma documentação muito boa, vou deixar o código com os comentários do que fiz para criar a interface:


import json
import tkinter
from tkinter import *
from extract import class_prediction, get_response
from keras.models import load_model

# extraimos o modelo usando o keras
model = load_model('model.h5')

# carregamos nossas intenções
intents = json.loads(open('intents.json').read())

base = Tk()
base.title("Chatbot")
base.geometry("400x500") 
base.resizable(width=FALSE, height=FALSE)


def chatbot_response(msg):
    """
        Resposta do bot
    """
    ints = class_prediction(msg, model)
    res = get_response(ints, intents)
    return res

def send():
    """
        Envia a mensagem
    """
    msg = EntryBox.get("1.0", 'end-1c').strip()
    EntryBox.delete("0.0", END)

    if msg != '':
        Chat.config(state=NORMAL)
        Chat.insert(END, f"Você: {msg}\n\n")
        Chat.config(foreground="#000000", font=("Arial", 12))

        response = chatbot_response(msg)
        Chat.insert(END, f"Bot: {response}\n\n")

        Chat.config(state=DISABLED)
        Chat.yview(END)

# Cria a janela do chat
Chat = Text(base, bd=0, bg="white", height="8", width="50", font="Arial",)
Chat.config(state=DISABLED)

# Vincula a barra de rolagem à janela de bate-papo
scrollbar = Scrollbar(base, command=Chat.yview)
Chat['yscrollcommand'] = scrollbar.set

# Cria o botão de envio de mensagem, onde o comando envia para a função de send
SendButton = Button(base, font=("Verdana", 10, 'bold'), text="Enviar", width="12", height=2, bd=0, bg="#666", activebackground="#333", fg='#ffffff', command=send)

# Cria o box de texto
EntryBox = Text(base, bd=0, bg="white", width="29", height="2", font="Arial")

# Coloca todos os componentes na tela
scrollbar.place(x=376, y=6, height=386)
Chat.place(x=6, y=6, height=386, width=370)
EntryBox.place(x=128, y=401, height=50, width=260)
SendButton.place(x=6, y=401, height=50)


base.mainloop()

Executando nosso código

Antes de executar nosso código, vamos criar 3 arquivos na raiz do projeto model.h5, words.pkl e classes.pkl. Se você usa Windows, terá que instalar um servidor chamado Xming.

Vamos começar treinando nosso modelo e depois de treinado executamos nosso bot.py

python train.py

python bot.py

Bom, concluímos aqui nosso primeiro chatbot, estou feliz de poder compartilhar com vocês. Esse projeto por mais simples que seja nos dá habilidades úteis para a ciência de dados, claro que tem muito chão para entendermos aprendizado profundo, mas estamos no caminho.

Gostou? Então reage ao post e compartilhe com seus amigos para que eu continue trazendo conteúdo interessantes para vocês!

Um jeito fácil de fazer e jogar snake usando apenas python e noções básicas de coordenadas.

Thais Ribeiro — Mon, 12 Jul 2021 03:21:21 +0000

Olá pessoas maravilhosas desse site, hoje eu vou ensinar para vocês de uma forma bem detalhada como usar a biblioteca curses do python para fazer um jogo clássico no terminal, antes de começar a codar, vamos entender o que é essa lib e suas funções básicas.
Vou deixar o link da documentação da lib para vocês irem mais fundo no assunto, mas resumindo, esse módulo fornece uma API para criar interfaces de usuários textuais (TUI), um exemplo, se quisermos escrever aplicativos de linha de comando devemos considerar o uso de curses para implementarmos. Esse pacote vem junto com a instalação do python e existem conceitos importantes que devemos entender para começarmos a usá-la, alguns desses conceitos são:

O que são janelas
Como iniciar e deligar curses
Como adicionar caracteres, atualizar e limpar janelas. Também é necessário entendermos o conceito de coordenadas x e y, para conseguirmos posicionar nossos elementos no terminal.

Sem mais delongas, para não estendermos demais aqui, vamos começar a desenvolver nosso jogo e a medida que formos criando, vou explicando o que utilizei e porque usei daquela forma.
Nosso jogo precisa de um menu, e vamos criar esse daqui:

Para começarmos nosso projeto vamos iniciar o curses e definirmos as configurações iniciais, vou usar também a extensão panel que é um recurso adicional de profundidade nas janelas, para que elas possam ser empilhadas uma sobre as outras, vamos usar o panel para criamos nossa janela de menu e assim que o jogo for iniciado ainda termos essa janela sendo sobreposta.

#!/usr/bin/env python
import sys
import curses
from curses import panel
from snake import Snake


screen = curses.initscr()
curses.noecho()
curses.curs_set(0)
curses.start_color()
screen.keypad(1)
_panel = panel.new_panel(screen)
panel.update_panels()

Nota-se que usamos alguns métodos como initscr, noecho, curs_set, start_color, keypad, new_panel e update_panels, vou explicar o que é cada um:

initscr é a função irá inicializar a biblioteca e retornar um objeto de janela que representa a tela inteira;
noecho desativa o eco automático de pressionamentos de tecla (evita que o programa insira cada tecla duas vezes);
curs_set usamos para desabilitar um cursor piscando;
start_color usamos para definir cor para nosso terminal, no nosso caso vamos usar as cores padrões;
new_panel e update_panels tem a ver com nossos painéis mencionados anteriormente, vamos criar uma janela empilhada

Agora vamos criar nossa função de display, vou deixar o comentário no código explicando o que está acontecendo em cada etapa, nesse método vamos fazer o processo de montar o menu com título e dar funcionalidade para seus itens, criei um menu com duas opções, de start que irá iniciar o jogo e exit para sair da janela.

def display():
    position = 0
    _panel.top()
    _panel.show()
    screen.clear()

    # adicionamos um título para o menu
    screen.addstr(1, 50, '========== Snake ==========', curses.A_BOLD)

    while True:
        screen.refresh()
        curses.doupdate()

        # verificamos a quantidade de itens no menu, e de acordo com a posição,
        # se for igual ao index, define o modo do cursor
        # na tela como normal ou reverso, assim como monta com ajuda do addstr o texto do menu,
        # usando os nomes que definimos e as posições
        # de coordenadas (y,x) que queremos, nesse caso para cada item eu usei o 3
        # como ponto inicial e durante o for incremento o y para as opções
        # ficarem uma embaixo da outra
        for i, item in enumerate(MENU):
            mode = curses.A_NORMAL
            if i == position:
                mode = curses.A_REVERSE

            screen.addstr(3 + i, 50, f'{i}. {item}', mode)

         # a função getch é usada para aguardar a capturar o pressionamento da tecla
        key = screen.getch()

        # aqui incremento a posição, caso eu dê enter em algum item do menu 
        # é com a variável position que consiguirei definir o que vai ser feito
        if key == curses.KEY_UP:
            position = 0
        elif key == curses.KEY_DOWN:
            position = len(MENU) - 1
        elif key in [curses.KEY_ENTER, ord('\n')]:
            if position == len(MENU) - 1:
                # como defini o exit no fim do menu, 
                # aqui verifico se ele é o indice final 
                # e se sim eu saio do programa
                sys.exit()
            else:
                # inicia o jogo da cobra
                screen.clear()
                # snake()
                break

    # limpa a tela anterior ao pressionar a tecla e atualiza a exibição com base na pos, 
    # fecho o painel e atualizo a tela física para corresponder à tela virtual.
    screen.clear()
    _panel.hide()
    panel.update_panels()
    curses.doupdate()

Após nossa função de display criada, vamos criar uma função para rodarmos nosso código, só para ficar separado e o arquivo menu.py ficará assim:

#!/usr/bin/env python
import sys
import curses
from curses import panel
from cobra import snake


screen = curses.initscr()
curses.noecho()
curses.curs_set(0)
curses.start_color()
screen.keypad(1)
_panel = panel.new_panel(screen)
panel.update_panels()
MENU = ['Start', 'Exit']


def display():
    position = 0
    _panel.top()
    _panel.show()
    screen.clear()

    # adicionamos um título para o menu
    screen.addstr(1, 50, '========== Snake ==========', curses.A_BOLD)

    while True:
        screen.refresh()
        curses.doupdate()

        # verificamos a quantidade de itens no menu, e de acordo com a posição,
        # se for igual ao index, define o modo do cursor
        # na tela como normal ou reverso, assim como monta com ajuda do addstr o texto do menu,
        # usando os nomes que definimos e as posições
        # de coordenadas (y,x) que queremos, nesse caso para cada item eu usei o 3
        # como ponto inicial e durante o for incremento o y para as opções
        # ficarem uma embaixo da outra
        for i, item in enumerate(MENU):
            mode = curses.A_NORMAL
            if i == position:
                mode = curses.A_REVERSE

            screen.addstr(3 + i, 50, f'{i}. {item}', mode)

         # a função getch é usada para aguardar a capturar o pressionamento da tecla
        key = screen.getch()

        # aqui incremento a posição, caso eu dê enter em algum item do menu 
        # é com a variável position que consiguirei definir o que vai ser feito
        if key == curses.KEY_UP:
            position = 0
        elif key == curses.KEY_DOWN:
            position = len(MENU) - 1
        elif key in [curses.KEY_ENTER, ord('\n')]:
            if position == len(MENU) - 1:
                # como defini o exit no fim do menu, 
                # aqui verifico se ele é o indice final 
                # e se sim eu saio do programa
                sys.exit()
            else:
                # inicia o jogo da cobra
                screen.clear()
                snake()
                break

    # limpa a tela anterior ao pressionar a tecla e atualiza a exibição com base na pos, 
    # fecho o painel e atualizo a tela física para corresponder à tela virtual.
    screen.clear()
    _panel.hide()
    panel.update_panels()
    curses.doupdate()


def run(object):
    display()

if __name__ == '__main__':
    curses.wrapper(run)

Com isso fechamos o menu e vamos para nosso jogo, no mesmo esquema do código acima, em todo o código há comentários para facilitar o entendimento.
Começamos iniciando o curses porque eu fiz o código em arquivo separado, mas no projeto final iniciamos apenas uma vez, criamos então uma nova janela com o newin setando as coordenadas y e x, sim, nesse caso a função recebe o argumento y antes do x e criamos um método para iniciar o jogo.

import curses
from random import randint

ESC = 27  # a tecla esc é a nr 27

curses.initscr()
curses.noecho()
curses.curs_set(0)
screen = curses.newwin(20, 50, 0, 0) #y,x
screen.keypad(1)
screen.border(0)
screen.nodelay(1)

def snake():
    # defino aqui as posições x,y e a quantidade de nós da minha cobra,
    # cada nó parte da mesma posição no eixo y
    # e em posições diferentes no eixo x, para criar o "000"
    snake = [(1, 3), (1, 2), (1, 1)]

    # defino aqui a posição inicial da comida na janela, qual será seu posicionamento.
    food = (10, 20)

    #inicia a comida na posição escolhida
    screen.addch(food[0], food[1], 'ѽ')

    score = 0  # a pontuação do jogo começa em 0

    # defino a key com o pressionamento da seta para a direita,
    # para iniciar o movimento da cobra
    key = curses.KEY_RIGHT

    while key != ESC:
        # adicionando um texto com nossa pontuação, que a medida que formos 
        # jogando e acertando, será incrementado o score
        screen.addstr(0, 2, f'Pontuação {str(score)} ')

        # velocidade da cobra na janela
        screen.timeout(150 - (len(snake)) // 5 + len(snake)//10 % 120)
        old_key = key
        event = screen.getch()  # aguarda e recupera o pressionamento do usuário na tela
        key = event if event != -1 else old_key

        if key not in [curses.KEY_LEFT, curses.KEY_RIGHT, curses.KEY_UP, curses.KEY_DOWN, ESC]:
            key = old_key

        # Aqui verificamos a posição inicial do primeiro nó da cobra 
        # e de acordo com a key pressionada pelo usuário, ou seja, quando as setas
        # são pressionadas, verificamos quais são e incrementamos os eixos x e y
        y = snake[0][0]
        x = snake[0][1]

        if key == curses.KEY_DOWN:
            y += 1
        elif key == curses.KEY_UP:
            y -= 1
        elif key == curses.KEY_RIGHT:
            x += 1
        elif key == curses.KEY_LEFT:
            x -= 1

        snake.insert(0, (y, x))

        # vamos checar se nosso x e y não corresponde as bordas que iniciamos lá em cima no curses.newwin(20, 50, 0, 0), 
        # se corresponder, significa que os nós da cobra bateram na parede, se isso acontecer temos que sair do jogo.
        if y == 0 or y == 19:
            break
        if x == 0 or x == 49:
            break

        # se a posição do ultimo nó for correspondente ao nó inicial, significa que a cabeça da cobra bateu na calda, 
        # devemos sair do jogo.
        if snake[0] in snake[1:]:
            break

        if snake[0] == food:
            # nesse momento verificamos se a posição do primeiro nó da cobra está nos eixos da comida, se for no inicio,
            # vai verificar se está na posição (10,20) que definimos, se sim, significa que a cobra comeu o alimento,
            # então vamos zerar a tupla da comida e fazemos um laço para que enquanto essa tupla estiver vazia,
            # com ajuda da lib random, denifimos novos posicionamentos para esse objeto,
            # a lib vai criar posicionamentos randomicos dentro do limite da janela que estipulamos no começo,
            # por isso dentre 1,18 e 1,48. Se a comida for gerada em cima de uma posição que a cobra estiver 
            # a tupla é zerada novamente e o laço é continuado, caso contrário, damos um addch
            # passando as novas posições da comida e inserindo o caracter escolhido novamente nessa posição
            score += 1
            food = ()
            while food == ():
                food = (randint(1, 18), randint(1, 48))
                if food == snake:
                    food = ()
            screen.addch(food[0], food[1], 'ѽ')
        else:
            # caso contrário vamos remover o ultimo caracter ● adicionado e mover a cobra na janela.
            last = snake.pop()
            screen.addch(last[0], last[1], ' ')

        # Sempre inserimos o caracter na cobra
        screen.addch(snake[0][0], snake[0][1], '●')

Voltando ao nosso primeiro código de menu, importamos lá o nosso arquivo do jogo e onde deixamos #snake comentado removemos o comentário e damos um python menu.py para jogarmos.
Para não deixar o artigo gigante, vamos concluir por aqui, mas o projeto está no replit para vocês analisarem.
Bom pessoal, a ideia foi compartilhar com vocês como funciona o módulo do python de uma maneira divertida, jogando! Atualmente quase não vemos nenhuma interface em terminal, mas como eu sempre falo, sempre bom absorver conteúdo, vai que uma hora precisamos, então é isso, fico por aqui, um beijo e até mais!