Utilizando a análise de texto da Azure

A Azure, rival da AWS e mantida pela Microsoft, possui diversos serviços de inteligência artificial e machine learning em formato de uma API, que possibilita utilizar esses serviços, como reconhecimento de objetos, detecção do idioma falado, sem que seja necessário construir uma rede neural para isso, nem treiná-la. E o melhor: a Microsoft disponibiliza uma conta gratuita, o que permite testar esses serviços sem gastar nada.

Então, estive estudando a API de Análise de Texto da Azure, que permite detectar o idioma do texto informado, a análise de sentimento (se é uma frase positiva, negativa ou neutra (factual)) e detecção de palavras-chave.

Aproveitando o embalo, resolvi criar um projeto utilizando o framework Grails 4, que utiliza o Micronaut por baixo dos panos, e ainda traz toda a comodidade dos componentes do Spring. Além disso, sempre achei um framework com uma alta produtividade (o GORM é excelente, na minha opinião), e quis ver as mudanças da versão 2, que eu costumava estudar, e a versão 4. Porém, por eu estar sem programar em Java/Groovy há um tempo considerável, devo salientar que o meu código pode não estar o mais performático, nem muito “bonito”.

Porém, o código utilizando o Grails ficará para outro post. Nesse, só vou mostrar como é simples fazer a requisição à Azure. Esse serviço, de Análise de Textos, tem vários endpoints. Mostrarei dois, o endpoint languages e o sentiment.
Para fazer as requisições, é necessário criar o serviço no portal do Azure.

Feito isso, um endpoint e uma chave de acesso serão gerados, que deverão ser informados em todos os requests à plataforma. O conteúdo enviado é em formato JSON, logo, é necessário um header indicando isso, e outro indicando a chave de acesso que obtivemos ao registrar o serviço:

{
"Content-Type": "text/json",
"Ocp-Apim-Subscription-Key": "chave de acesso"
}

Feito isso, é só utilizar os endpoints. Como falei, vou mostrar dois exemplos básicos:

• Languages: Esse endpoint (/languages), detecta em qual idioma está o texto a ser passado. O payload a ser enviado é um JSON que pode enviar vários documentos (máximo 1000 em um único request), e a solicitação não pode ultrapassar 1 Mb.
  
  O payload é:
  

  {
      "documents": [
          {
              "id": "1",
              "text": "Testando a API diretamente. Será que vai adivinhar?"
          },
          {
              "id": "2",
              "text": "You can have multiple documents on the request"
          }
      ]
  }

  E, se tudo deu certo, o retorno será um 200 com o seguinte conteúdo:

  {
    "documents": [
      {
        "id": "1",
        "detectedLanguages": [
          {
            "name": "Portuguese",
            "iso6391Name": "pt",
            "score": 1.0
          }
        ]
      },
      {
        "id": "2",
        "detectedLanguages": [
          {
            "name": "English",
            "iso6391Name": "en",
            "score": 1.0
          }
        ]
      }
    ],
    "errors": []
  }

  Bem simples e objetivo: indica o nome da linguagem detectada, uma sigla (“iso6391Name”), e um score, que indica a confiabilidade da resposta. Nos dois casos, ele está confiante de que são, respectivamente, português e inglês.

• Análise de Sentimentos (/sentiment): Esse endpoint recebe, assim como o anterior, vários textos e analisa se há algum “sentimento” no texto em questão. Por exemplo, a frase “Esta API é maravilhosa” carrega uma forte conotação positiva, enquanto “Não gosto desse serviço, é muito confuso”, denota negatividade. A API de análise textual da Azure classifica os textos em um intervalo entre 0 e 1, sendo 0 um sentimento negativo, 1 um sentimento positivo e 0.5 um “sentimento neutro” (por exemplo, uma frase factual). O payload é bastante similar ao anterior, veja:
  

  {
      "documents": [
          {
              "id": "1",
              "text": "Esta API é muito boa, e fácil de usar",
              "language": "pt"
          },
          {
              "id": "2",
              "text": "Este serviço está muito ruim, muito atrás dos concorrentes",
              "language": "pt"
          },
          {
              "id": "3",
              "text": "Está chovendo agora",
              "language": "pt"
          }
      ]
  }

  E a resposta, 200, vai ao encontro do que esperaríamos: a primeira frase é positiva (score 0.77), a segunda negativa (score 0.03) e a terceira, neutra (score 0.49):

  {
    "documents": [
      {
        "id": "1",
        "score": 0.772289514541626
      },
      {
        "id": "2",
        "score": 0.0311049222946167
      },
      {
        "id": "3",
        "score": 0.49964377284049988
      }
    ],
    "errors": []
  }

   

Apesar de eu estar no começo dos meus estudos, esses serviços da Azure parecem ser bastante simples de aprender, mas ao mesmo tempo, permitem a solução de plataformas completas. No próximo post dessa série, pretendo mostrar o projeto em Grails, com serviços chamando esses endpoints no projeto, e expondo uma rota para receber os textos a serem analisados.

Até a próxima.