inteligência artificial

Faça uma pesquisa simples por inteligência artificial no Google Images. Você verá dois tipos de imagens: robôs no estilo do filme “Eu, Robô” e cérebros parecidos com chips de computadores.

Toda vez que alguém fala de inteligência artificial na mídia a imagem utilizada é a mesma: uma máquina humanoide. O mesmo acontece com as empresas de tecnologia quando geram conteúdos para seus clientes em peças de marketing.

Por que usar uma representação física de um robô para representar inteligência artificial quando a maioria dos exemplos de uso real dessa tecnologia estão longe de ser “animar” máquinas humanoides?

A resposta é simples. A maioria das pessoas não tem ideia do que realmente é a inteligência artificial e a forma mais fácil de mostrar visualmente esse conceito é através da representação cultural do robô.

Graças a livros e filmes muito populares o inconsciente coletivo imagina a inteligência artificial como uma versão artificial de um ser humano. Até porque a origem dos estudos desse campo foi exatamente essa. Criar uma versão artificial da inteligência humana.

Além disso, o ser humano naturalmente antropomorfiza as coisas. Coloca sentimentos e aparência humanas em animais e objetos. Explicar isso é trabalho para psicólogos, então não vou nem tentar.

Esse antropomorfismo da intlegência artificial acaba criando um problema de percepção para a grande parte das pessoas.

Junte a forma como a mídia mostra a tecnologia, a cultura geral e a facilidade para antropomorfizar as coisas que todos temos e pronto. Você tem uma pessoa que se desloca para um escritório de uma empresa de tecnologia para conhecer o “robô” que está atuando para prestar algum serviço.

Não acredita? Pois já tivemos um caso exatamente assim na empresa onde trabalho.

Quem sabe até existam pessoas que imaginam que automatizar um processo é o mesmo que colocar robôs humanoides fazendo o serviço que os humanos costumavam fazer.

Por mais que sonhemos com androides que serão quase indistinguíveis de seres humanos, como a Sophia da Hanson Robotics tenta ser, isso não é nem de longe a verdadeira cara da inteligência artificial dos dias de hoje.

A inteligência artificial está em softwares que rodam em hardwares muito mais parecidos com o seu computador de casa do que com o Robbin Williams em O Homem Bicentenário.

Os computadores que aprendem não vão ser expostos somente como assistentes pessoais (vide Elli Q) ou jogadores de tabuleiro (vide AlphaGo). Eles já estão dentro de nossas vidas constantemente sem que possamos perceber.

Toda vez que você acessa seu Facebook, faz uma pesquisa no Google ou faz uma compra pela internet, a inteligência artificial está lá. Ela é virtual, muitas vezes invisível e pode estar facilitando (ou não) a sua vida sem que você saiba.

Hoje em dia, uma boa representação de inteligência artificial seria algo bem menos interessante para o público em geral…

Servidores de pesquisa de Inteligência Artificial do Facebook em Prineville, Oregon.

Talvez as próximas gerações já tenham uma informação mais precisa sobre como tudo isso funciona, mas por enquanto, o único jeito que achamos de fazer alguém empatizar com o assunto é mostrando humanoides para representar a tecnologia da inteligência artificial.

Vamos continuar vendo muitos robôs humanoides nas capas de revistas e sites de notícias pelo mundo a fora por um bom tempo.

Até a próxima!

Continuo meus estudos com Flask, para brincar um pouco com o que estou aprendendo resolvi fazer um chatbot utilizando a biblioteca PyAIML e os arquivos AIML da A.L.I.C.E. AI Foundation.

Pra quem não sabe, os arquivos AIML (Artificial Intelligence Markup Language) são marcações baseadas em XML para inteligência artificial. Usando a biblioteca PyAIML fica muito simples fazer um chatbot em Python. Mas eu queria fazê-lo via web e foi aí que o Flask entrou.

Utilizei o Flask apenas para lidar com os requests e responses via web. Ou seja, ele recebe uma pergunta vinda do navegador e devolve uma resposta do bot.

Para ver o código-fonte completo do meu chatbot, acesse meu github.

Vendo o código-fonte, percebe-se que na raiz temos apenas o diretório app e o lib, além do arquivo run.py, que roda o servidor. Dentro do diretório app temos os arquivos do Flask: __init__.py e o views.py. No diretório lib está a biblioteca PyAIML e os arquivos AIML, importados da A.L.I.C.E. AI Foundation. Nestes arquivos eu fiz pouquíssimas alterações para o funcionamento básico do Jarvis, nome que dei ao meu chatbot.

Dentro do arquivo app/__init__.py eu importo o Flask e biblioteca PyAIML, para poder utilizá-la no arquivo app/views.py. Perceba que também importo o arquivo brain.brn, que é a “compilação” dos arquivos AIML, ou seja, é o cérebro do bot. Se ele não existir, o Kernel da biblioteca PyAIML vai criá-lo. Exemplo nas linhas abaixo, retiradas do arquivo app/__init__.py.

brainfile = os.path.join('lib', 'pyaiml', 'brain.brn')
aimlfiles = os.path.join('lib', 'pyaiml', 'aiml', 'std-startup.aiml')

k = aiml.Kernel()
if os.path.isfile(brainfile):
	k.bootstrap(brainFile = brainfile)
else:
	k.bootstrap(learnFiles = aimlfiles, commands = 'load aiml b')
	k.saveBrain(brainfile)

Uma pequena observação, estou importando os arquivos com os.path.join() para que não precise me preocupar se estou em sistema operacional Windows ou em Unix-based. Isso foi necessário porque no Windows as barras que separam os arquivos são inversas às dos sistemas baseados em Unix (como Linux e MacOS).

No arquivo app/views.py encontramos as definições de rotas (@app.route()) e definimos o que cada endereço web vai fazer no sistema. No caso, temos o / ou /index, que apenas mostra o template básico, através do método render_template do Flask, e temos o /talk, que recebe a “pergunta” do browser e envia a resposta transformada em um objeto JSON com o método jsonify do Flask. Os outros métodos são apenas handlers para os erros 404 (página não encontrada) e 500 (erro interno do servidor). Veja o index e o talk no exemplo abaixo, retirado do arquivo app/views.py.

@app.route('/', methods=['GET'])
@app.route('/index', methods=['GET'])
def index():
    return render_template('index.html')

@app.route('/talk', methods=['GET'])
def talk():
    question = request.args.get('question')
    answer = k.respond(question)
    return jsonify(question=question, answer=answer)

Lembrando que quando chamamos k.respond() no método talk() estamos chamando a biblioteca PyAIML para fazer o trabalho pesado por nós. Já a importamos no arquivo app/__init__.py e a passamos para a variável app.

É importante lembrar que aquilo que fomos utilizar em um programa Python tem que ser importado. Por isso é comum vermos os comandos import no começo dos arquivos. Por exemplo, no arquivo app/views.py eu importei o render_template, o request e o jsonify do Flask e o app e k (que contem a biblioteca PyAIML) do nosso app iniciado no arquivo app/__init__.py.

from flask import render_template, request, jsonify
from app import app, k

Com a biblioteca PyAIML fazendo a interpretação dos arquivos AIML, o Flask tinha pouquíssimo trabalho pela frente. Com apenas alguns poucos métodos escritos eu consegui rodar o aplicativo web. Isto é algo que tem me agradado muito no Python e no Flask.

Utilizar o PyAIML também foi simples, mas para entender como personalizar o bot (mudar o nome, nascimento, preferências, etc) eu levei um tempinho. Precisava entender que os “predicates” do bot precisavam ser mudados no arquivo lib/pyaiml/aiml/Kernel.py da biblioteca. Para facilitar, criei um arquivo chamado lib/pyaiml/aiml/BotPredicates.py e o importei no Kernel.py, como mostro abaixo.

import BotPredicates

# Set up the bot predicates 
self._botPredicates = BotPredicates.bot

Acabou sendo mais simples do que eu imaginava criar o Jarvis. Agora vou continuar brincando um pouco com ele. Quero adicionar reconhecimento de voz para que o usuário possa conversar com o Jarvis. Também quero que o usuário se registre com login e senha, para que o Jarvis já conheça seus amigos quando eles vierem conversar. A medida que eu for desenvolvendo essas novas funcionalidades vou postando algumas notas por aqui.