Explore o Python, o Aprendizado por Máquina e a Biblioteca NLTK

Desenvolva um aplicativo para categorizar feeds RSS usando Python, NLTK e aprendizado por máquina

O aprendizado por máquina, que está na intersecção entre TI, matemática e idioma natural, é geralmente usado em aplicativos de big data. Este artigo aborda a linguagem de programação Python e sua biblioteca NLTK e aplica-os a um projeto de aprendizado por máquina.

Chris Joakim, Senior Software Engineer, Primedia Inc

Photo of Chris JoakimChris Joakim é Senior Software Engineer na Primedia Inc. Chris desenvolve software há mais de 25 anos em várias linguagens, incluindo Clojure, Ruby, Java, Objective-C, JavaScript, CoffeeScript, Flex, Smalltalk, COBOL e agora Python. Ele mora em Davidson, Carolina do Norte, EUA. Em suas horas de lazer, ele corre em maratonas e escreve código. O email de Chris é cjoakim@bellsouth.net.



30/Out/2012

Iniciante no Python

Este artigo é para desenvolvedores de software — especialmente aqueles com histórico em Ruby ou Java — que estão diante de sua primeira implementação de aprendizado por máquina.

O desafio: Usar aprendizado por máquina para categorizar feeds RSS

Recentemente, fui encarregado de criar um subsistema de categorização de feeds RSS para um cliente. O objetivo era ler dezenas ou mesmo centenas de feeds RSS e automaticamente categorizar os vários artigos em uma das dezenas de áreas de assunto predefinidas. O conteúdo, a navegação e a funcionalidade de procura do website do cliente seriam baseados nos resultados da recuperação e categorização diária e automatizada de feeds.

A cliente sugeriu usar aprendizado por máquina, talvez com Apache Mahout e Hadoop, pois ela havia lido recentemente artigos sobre essas tecnologias. No entanto, a sua equipe de desenvolvimento e a nossa são fluentes em Ruby em vez de tecnologia Java™. Este artigo descreve a jornada técnica, processo de aprendizado e implementação final de uma solução.

O que é aprendizado por máquina?

Minha primeira pergunta foi: "O que exatamente é aprendizado por máquina?". Eu já havia ouvido o termo e sabia vagamente que o supercomputador IBM® Watson o usou para derrotar concorrentes humanos em uma partida de Jeopardy. Como comprador e participante de redes sociais, eu também sabia que Amazon.com e Facebook fazem ótimas recomendações (de produtos e de pessoas) com base em dados sobre os compradores. Em resumo, o aprendizado por máquina está na intersecção entre TI, matemática e linguagem natural. Tem relação principalmente com esses três tópicos, mas a solução do cliente acabaria por envolver os dois primeiros:

  • Classificação. Atribuir itens a categorias predefinidas arbitrárias com base em um conjunto de dados de treinamento de itens semelhantes
  • Recomendação. Recomendar itens com base na observação de itens semelhantes
  • Armazenamento em cluster. Identificar subgrupos em uma população de dados

Os desvios com Mahout e Ruby

Entendendo o que é aprendizado por máquina, a próxima etapa era determinar como implementar. Como a cliente sugeriu, Mahout era um bom ponto de partida. Eu fiz o download do código da Apache e comecei a aprender sobre aprendizado por máquina com Mahout e seu irmão, Hadoop. Infelizmente, descobri que Mahout tem uma curva de aprendizado íngreme, mesmo para um desenvolvedor Java experiente, e que não havia código de amostra funcional. Também não havia estruturas ou gems baseados em Ruby para aprendizado por máquina.

Encontrando Python e a NLTK

Eu continuei procurando uma solução e sempre encontrava "Python" no conjunto de resultados. Como programador de Ruby, eu sabia que Python era uma linguagem de programação semelhante (orientada a objeto, baseada em texto, interpretada e dinâmica), mas eu não havia aprendido a linguagem. Apesar dessas semelhanças, eu não me preocupei em aprender Python ao longo dos anos, pois considerava uma qualificação redundante. Python estava no meu "ponto cego", como acho que deve ser para muitos colegas de Ruby.

Procurando por livros sobre aprendizado por máquina e aprofundando-me em seu conteúdo, descobri que uma grande porcentagem desses sistemas usa Python como linguagem de implementação, juntamente com uma biblioteca chamada Natural Language Toolkit (NLTK). Outras pesquisas relevaram que Python era mais popular do que eu imaginava — como, por exemplo, no Google App Engine, YouTube e websites criados com a estrutura Django. Até está pré-instalado nas estações de trabalho Mac OS X que eu uso diariamente! Além disso, Python oferece bibliotecas padrão interessantes (por exemplo, NumPy e SciPy) para matemática, ciências e engenharia. Quem diria?

Decidi buscar uma solução em Python depois de encontrar exemplos elegantes de código. A linha a seguir, por exemplo, é todo o código necessário para ler um feed RSS através de HTTP e imprimir o conteúdo:

    print feedparser.parse("http://feeds.nytimes.com/nyt/rss/Technology")

Conhecendo Python

Ao aprender uma nova linguagem de programação, a parte fácil é geralmente aprender a linguagem em si. A parte difícil é aprender seu ecossistema — como instalar, incluir bibliotecas, escrever código, estruturar os arquivos de código, executar, depurar, e escrever testes de unidade. Esta seção contém uma breve introdução a esses tópicos. Confira Recursos para obter links para mais informações.

pip

O Python Package Index (pip) é o gerente de pacote padrão do Python. É o programa usado para incluir bibliotecas no sistema. É análogo aos gems das bibliotecas Ruby. Para incluir a biblioteca NLTK no sistema, o usuário insere o seguinte comando:

  $ pip install nltk

Para exibir uma lista de bibliotecas Python instaladas no sistema, execute este comando:

  $ pip freeze

Executando programas

Executar um programa Python é igualmente simples. Dado um programa chamado locomotive_main.py e três argumentos, nós compilamos e executamos com o programa python:

  $ python locomotive_main.py arg1 arg2 arg3

Python usa a sintaxe if __name__ == "__main__": na Listagem 1 para determinar se o arquivo está sendo executado na linha de comando ou sendo importado por outro código. Para tornar um arquivo executável, inclua a detecção de "__main__".

Listagem 1. Detecção de main
import sys
import time
import locomotive

if __name__ == "__main__":
    start_time = time.time()
    if len(sys.argv) > 1:
        app = locomotive.app.Application()
        ... additional logic ...

virtualenv

A maioria dos programadores de Ruby conhece a questão das bibliotecas de sistema, ou gems. Um conjunto de bibliotecas para todo o sistema não é o ideal, pois um dos projetos pode depender da versão 1.0.0 de uma certa biblioteca, enquanto outro projeto depende da versão 1.2.7. Da mesma forma, os desenvolvedores Java conhecem esse problema com CLASSPATH do sistema. Assim como a comunidade Ruby com a ferramenta rvm, a comunidade Python usa a ferramenta virtualenv (consulte Recursos para obter o link) para criar ambientes de execução separados, incluindo versões específicas de Python e um conjunto de bibliotecas. Os comandos na Listagem 2 mostram como criar um ambiente virtual chamado p1_env para o projeto p1, que contém as bibliotecas feedparser, numpy, scipy e nltk.

Listagem 2. Comandos para criar um ambiente virtual com virtualenv
  $ sudo pip install virtualenv
  $ cd ~
  $ mkdir p1
  $ cd p1
  $ virtualenv p1_env --distribute
  $ source p1_env/bin/activate 
  (p1_env)[~/p1]$ pip install feedparser
  (p1_env)[~/p1]$ pip install numpy
  (p1_env)[~/p1]$ pip install scipy
  (p1_env)[~/p1]$ pip install nltk
  (p1_env)[~/p1]$ pip freeze

É necessário recuperar o script de ativação do ambiente virtual via "source" cada vez que você trabalhar com o projeto em uma janela shell. Observe que a linha de comando do shell muda quando o script de ativação é recuperado. Ao criar e usar janelas shell no sistema, para navegar mais facilmente para o diretório de projeto e ativar o ambiente virtual, pode ser útil incluir uma entrada como a seguinte no arquivo ~/.bash_profile file:

$ alias p1="cd ~/p1 ; source p1_env/bin/activate"

A estrutura da base de código

Após passar pelos simples programas "Hello World" de uma linha, os desenvolvedores de Python precisam entender como estruturar corretamente sua base de código em relação a diretórios e nomes de arquivo. Java e Ruby têm seus próprios requisitos nesse aspecto, e Python não é diferente. Em resumo, Python usa o conceito de pacotes para agrupar código relacionado e criar namespaces inequívocos. Para fins de demonstração neste artigo, o código está no diretório-raiz de um certo projeto, como ~/p1. Nesse diretório, há um diretório locomotive para o pacote Python do mesmo nome. A Listagem 3 mostra essa estrutura de diretório.

Listagem 3. Estrutura de diretório de exemplo
locomotive_main.py
locomotive_tests.py

locomotive/
    __init__.py
    app.py
    capture.py
    category_associations.py
    classify.py
    news.py
    recommend.py
    rss.py

locomotive_tests/
    __init__.py
    app_test.py
    category_associations_test.py
    feed_item_test.pyc
    rss_item_test.py

Observe os arquivos com o nome estranho de __init__.py. Esses arquivos dizem ao Python para carregar as bibliotecas necessárias para o pacote e os arquivos de código de aplicativo específicos que estão no mesmo diretório. A Listagem 4 mostra o conteúdo do arquivo locomotive/__init__.py.

Listagem 4. locomotive/__init__.py
    # system imports; loads installed packages
    import codecs
    import locale
    import sys

    # application imports; these load your specific *.py files
    import app
    import capture
    import category_associations
    import classify
    import rss
    import news
    import recommend

Com o pacote locomotive estruturado como na Listagem 4, os programas principais no diretório-raiz do projeto podem importá-lo e usá-lo. Por exemplo, o arquivo locomotive_main.py contém as seguintes importações:

    import sys         # >-- system library
    import time        # >-- system library
    import locomotive  # >-- custom application code library in the "locomotive" directory

Teste

A biblioteca padrão unittest do Python é uma boa solução para teste. Para desenvolvedores Java familiarizados com JUnit e programadores Ruby familiarizados com a estrutura Test::Unit, o código unittest de Python na Listagem 5 será fácil de ler.

Listagem 5. unittest de Python
  class AppTest(unittest.TestCase):

      def setUp(self):
          self.app = locomotive.app.Application()

      def tearDown(self):
          pass

      def test_development_feeds_list(self):
          feeds_list = self.app.development_feeds_list()
          self.assertTrue(len(feeds_list) == 15)
          self.assertTrue('feed://news.yahoo.com/rss/stock-markets' in feeds_list)

O código na Listagem 5 também demonstra um recurso diferenciador do Python: todo o código deve ser indentado consistentemente, ou não será compilado com êxito. O método tearDown(self) pode parecer um pouco estranho à primeira vista. Você deve estar se perguntando por que o teste foi definido para sempre passar. Na verdade, não foi. É assim que se cria um método vazio em Python.

Conjunto de ferramentas

O que eu realmente precisava era um ambiente de desenvolvimento integrado (IDE) com destaque da sintaxe, conclusão de código e funcionalidade de depuração de ponto de interrupção, para ajudar no aprendizado de Python. Como usuário do IDE Eclipse para desenvolvimento em Java, o plug-in pyeclipse foi a primeira ferramenta que examinei. Funciona bem, apesar de ser lento às vezes. Eu acabei por investir no IDE PyCharm, que tem tudo que eu preciso.

Com um conhecimento básico de Python e do seu ecossistema, era hora de começar a implementar a solução de aprendizado por máquina.


Implementando categorização com Python e NLTK

Para implementar a solução, era necessário capturar feeds RSS simulados, limpar o texto, usar NaiveBayesClassifier e classificar categorias com o algoritmo kNN. Cada uma dessas ações é descrita aqui.

Capturando e analisando os feeds

O projeto tinha um desafio especial: a cliente ainda não havia definido a lista de feeds RSS que seriam alvos. Por isso, não havia "dados de treinamento". Por isso, o feed e os dados de treinamento tiveram que ser simulados durante o desenvolvimento inicial.

A primeira abordagem que usei para obter dados de amostra foi simplesmente buscar uma lista de feeds RSS especificados em um arquivo de texto. Python oferece uma boa biblioteca de análise de feed RSS, chamada feedparser, que abstrai as diferenças entre os vários formatos RSS e Atom. Outra biblioteca útil para serialização de objeto baseado em texto tem o bem-humorado nome de pickle. Ambas as bibliotecas são usadas no código na Listagem 6, que captura cada feed RSS como arquivos de objeto do pickle para uso posterior. Como é possível ver, o código Python é conciso e eficiente.

Listagem 6. A classe CaptureFeeds
import feedparser
import pickle

class CaptureFeeds:

    def __init__(self):
        for (i, url) in enumerate(self.rss_feeds_list()):
            self.capture_as_pickled_feed(url.strip(), i)

    def rss_feeds_list(self):
        f = open('feeds_list.txt', 'r')
        list = f.readlines()
        f.close
        return list

    def capture_as_pickled_feed(self, url, feed_index):
        feed = feedparser.parse(url)
        f = open('data/feed_' + str(feed_index) + '.pkl', 'w')
        pickle.dump(feed, f)
        f.close()

if __name__ == "__main__":
    cf = CaptureFeeds()

A etapa seguinte foi surpreendentemente desafiadora. Agora que eu tinha dados de feed de amostra, era necessário categorizá-los para uso como dados de treinamento. Dados de treinamento é o conjunto de dados dado ao algoritmo de categorização para que ele possa aprender.

Por exemplo, os feeds de amostra que eu usei incluíam ESPN, a Sports Network. Um dos itens do feed falava sobre a transferência de Tim Tebow, do time de futebol americano Denver Broncos, para o New York Jets ao mesmo tempo que os Broncos tinham contratado Peyton Manning para ser seu novo atacante. Outro item nos resultados do feed era sobre a empresa Boeing e seu novo jato. A pergunta é: qual valor de categoria específico deveria ser atribuído ao primeiro artigo? Os valores tebow, broncos, manning, jets, quarterback, trade e nfl são todos apropriados. Mas apenas um valor pode ser especificado nos dados de treinamento como sua categoria. Da mesma forma, no segundo artigo, é a categoria boeing ou jet? O problema está nesses detalhes. A categorização manual precisa de um grande conjunto de dados de treinamento é essencial para que o algoritmo produza resultados precisos. O tempo necessário para fazer isso não deve ser subestimado.

Logo ficou claro que eu precisava de mais dados para trabalhar, e eles tinham que já estar categorizados — e com precisão. Onde eu encontraria esses dados? Aqui entra a Python NLTK. Além de ser uma excelente biblioteca para processamento de texto, ela ainda vem com conjuntos de dados de amostra para download, ou corpus na sua terminologia, além de uma interface de programação de aplicativo para acessar facilmente os dados transferidos por download. Para instalar o corpus Reuters, execute os comandos abaixo. Mais de 10.000 artigos da imprensa serão transferidos para o diretório ~/nltk_data/corpora/reuters/. Assim como itens do feed RSS, cada artigo da Reuters contém um título e um corpo, portanto esses dados pré-categorizados de NLTK são excelentes para simular campos RSS.

$ python               # enter an interactive Python shell
>>> import nltk        # import the nltk library
>>> nltk.download()    # run the NLTK Downloader, then enter 'd' Download
Identifier> reuters    # specify the 'reuters' corpus

De particular interesse é o arquivo ~/nltk_data/corpora/reuters/cats.txt. Ele contém uma lista de nomes de arquivos de artigo e a categoria designada a cada um deles. O arquivo tem o seguinte formato, portanto, o artigo no arquivo 14828 no subdiretório test pertence ao tópico grain.

test/14826 trade
test/14828 grain

Idiomas naturais são confusos

A entrada bruta do algoritmo de categorização de feeds RSS é, obviamente, texto escrito em inglês. É realmente bruto.

Inglês, ou qualquer outro idioma natural (ou seja, idiomas falados ou comuns) é altamente irregular e impreciso do ponto de vista do processamento por computador. Primeiro, há a questão da distinção entre maiúsculas e minúsculas. A palavra Bronco equivale a bronco? A resposta é talvez. Em seguida, há o problema da pontuação e espaços em branco. O termo bronco. é igual a bronco ou bronco,? Mais ou menos. Além disso, há plurais e palavras semelhantes. run, running, e ran são equivalentes? Bem, depende. As três palavras têm uma raiz em comum. E se os temos do idioma natural estiverem integrados em uma linguagem de marcação, como HTML? Nesse caso, seria necessário lidar com texto como <strong>bronco</strong>. Por fim, há o problema das palavras essencialmente sem sentido, mas frequentemente usadas, como um, e e o. Essas "stopwords" apenas atrapalham. Idiomas naturais são confusos. É necessário limpar antes de processar.

Felizmente, Python e NLTK permitem limpar essa bagunça. O método normalized_words da classe RssItem, na Listagem 7, cuida dessas questões. Observe, em particular, como NLTK remove a marcação HTML integrada do texto bruto do artigo em apenas uma linha de código! Uma expressão regular é usada para remover a pontuação, e em seguida as palavras individuais são divididas e normalizadas para minúsculas.

Listagem 7. A classe RssItem
class RssItem:
    ...
    regex = re.compile('[%s]' % re.escape(string.punctuation))
    ...
    def normalized_words(self, article_text):
        words   = []
        oneline = article_text.replace('\n', ' ')
        cleaned = nltk.clean_html(oneline.strip())
        toks1   = cleaned.split()
        for t1 in toks1:
            translated = self.regex.sub('', t1)
            toks2 = translated.split()
            for t2 in toks2:
                t2s = t2.strip().lower()
                if self.stop_words.has_key(t2s):
                    pass
                else:
                    words.append(t2s)
        return words

A lista de stopwords veio da NLTK com essa linha de código. Há suporte para outros idiomas naturais:

nltk.corpus.stopwords.words('english')

NLTK também oferece várias classes "lematizadoras" para normalizar ainda mais as palavras. Consulte a documentação da NLTK sobre lematização, estrutura de sentença e gramática para mais informações.

Classificação com algoritmo de Bayes Ingênuo

O algoritmo de Bayes Ingênuo é muito usado e implementado na NLTK com a classe nltk.NaiveBayesClassifier. O algoritmo de Bayes classifica itens segundo a presença ou ausência de características nos conjuntos de dados. No caso de itens de feeds RSS cada característica é uma dada palavra (limpa) de idioma natural. O algoritmo é "ingênuo", pois supõe que não há relacionamento entre as características (nesse caso, palavras).

No entanto, o inglês contém mais de 250.000 palavras. Certamente eu não quero precisar criar um objeto contendo 250.000 booleanos para cada item de feed RSS para passar ao algoritmo. Então quais palavras eu uso? Em resumo, a resposta é as palavras mais comuns na população dos dados de treinamento que não são stopwords. NLTK oferece uma classe excepciona, nltk.probability.FreqDist, que pode ser usada para identificar essas palavras mais usadas. Na Listagem 8 , o método collect_all_words retorna um array de todas as palavras de todos os artigos de treinamento.

Esse array é passado para o método identify_top_words para identificar as palavras mais frequentes. Um recurso útil da classe nltk.FreqDist é que é essencialmente um hash, mas as suas chaves são armazenadas de acordo com os valores correspondentes, ou contagens. Portanto, é fácil obter as 1.000 palavras mais usadas com a sintaxe [:1000] do Python.

Listagem 8. Usando a classe nltk.FreqDist
  def collect_all_words(self, items):
      all_words = []
      for item in items:
          for w in item.all_words:
              words.append(w)
      return all_words

  def identify_top_words(self, all_words):
      freq_dist = nltk.FreqDist(w.lower() for w in all_words)
      return freq_dist.keys()[:1000]

Para os itens do feed RSS simulado com os dados de artigos da Reuters da NLTK, eu preciso identificar as categorias de cada item. Para isso, eu leio o arquivo ~/nltk_data/corpora/reuters/cats.txt mencionado anteriormente. Ler um arquivo com Python é simples:

  def read_reuters_metadata(self, cats_file):
      f = open(cats_file, 'r')
      lines = f.readlines()
      f.close()
      return lines

A próxima etapa é obter os recursos para cada item dos feeds RSS. O método features da classe RssItem, mostrada abaixo, faz isso. Nesse método, o array all_words no artigo é primeiro reduzido para um objeto set menor para eliminar as palavras duplicadas. Em seguida, top_words são iteradas e comparadas com esse conjunto, para verificar sua presença ou ausência. Um hash de 1.000 booleanos é retornado, com a chave w_ seguido da própria palavra. Esse Python é mesmo muito conciso.

  def features(self, top_words):
      word_set = set(self.all_words)
      features = {}
      for w in top_words:
          features["w_%s" % w] = (w in word_set)
      return features

Em seguida, eu coleto um conjunto de treinamento dos itens de feeds RSS e suas características individuais e passo para o algoritmo. O código na Listagem 9 demonstra essa tarefa. Observe que o classificar é treinado em exatamente uma linha de código.

Listagem 9. Treinando nltk.NaiveBayesClassifier
  def classify_reuters(self):
        ...
        training_set = []
        for item in rss_items:
            features = item.features(top_words)
            tup = (features, item.category)  # tup is a 2-element tuple
            featuresets.append(tup)
        classifier = nltk.NaiveBayesClassifier.train(training_set)

A NaiveBayesClassifier, na memória do programa Python, está treinada. Agora, basta iterar o conjunto de itens de feeds RSS que precisam ser classificados e pedir ao classificador para adivinhar a categoria de cada um. Simples.

  for item in rss_items_to_classify:
      features = item.features(top_words)
      category = classifier.classify(feat)

Ficando menos ingênuo

Como dito anteriormente, o algoritmo supõe que não há relacionamento entre os recursos individuais. Por isso, frases como "machine learning" e "learning machine", ou "New York Jet" e "jet to New York", são equivalentes (to é uma stopword). No contexto do idioma natural, há um relacionamento óbvio entre essas palavras. Então como posso ensinar o algoritmo a ser "menos ingênuo" e reconhecer esses relacionamentos entre palavras?

Uma técnica é incluir os bigramas comuns (grupos de duas palavras) e trigramas (grupos de três palavras) no conjunto de características. Não é surpresa que a NLTK tenha suporte para isso na forma das funções nltk.bigrams(...) e nltk.trigrams(...). Assim como as primeiras n palavras foram coletadas na população de palavras dos dados de treinamento, os bigramas e trigramas mais usados podem ser identificados e usados como características.

Os resultados variam

Refinar os dados e o algoritmo é uma arte. Devemos normalizar ainda mais o conjunto de palavras, talvez com lematização? Ou incluir mais que as principais 1.000 palavras? Menos? Ou usar um conjunto de dados de treinamento maior? Incluir mais stopwords ou "stop-grams"? Essas perguntas são todas válidas. Experimente com elas e, por meio de tentativa e erro, você chegará ao melhor algoritmo para seus dados. Eu constatei que 85% é um bom índice de categorização bem-sucedida.

Recomendação com o algoritmo k-Nearest Neighbors

A cliente queria exibir itens de feeds RSS em uma categoria selecionada ou categorias semelhantes. Agora que os itens foram categorizados com o algoritmo Bayes Ingênuo, a primeira parte do requisito foi atendida. A parte mais difícil era implementar o requisito de "ou categorias semelhantes". É aqui que entram os sistemas de recomendações de aprendizado por máquina. Sistemas de recomendações recomendam um item com base na semelhança entre os outros itens. As recomendações de produtos da Amazon.com e as de amigos no Facebook são bons exemplos dessa funcionalidade.

k-Nearest Neighbors (kNN) é o algoritmo de recomendação mais comum. A ideia é fornecer um conjunto de rótulos (ou seja, categorias) e um conjunto de dados correspondente para cada um deles. Em seguida, o algoritmo compara os conjuntos de dados para identificar itens semelhantes. O conjunto de dados é composto de arrays de valores numéricos, geralmente em uma faixa normalizada de 0 a 1. Ele pode assim identificar os rótulos semelhantes nos conjuntos. Ao contrário do Bayes Ingênuo, que produz apenas um resultado, kNN pode produzir uma lista classificada de várias recomendações (ou seja, o valor de k).

Eu achei os algoritmos de recomendação mais simples de entender e implementar que os algoritmos de classificação, embora o código e sua complexidade matemática sejam grandes demais para incluir aqui. Consulte o excelente novo livro da Manning, Machine Learning in Action, para ver exemplos de código de kNN (consulte Recursos para obter um link). No caso da implementação dos itens de feeds RSS, os valores de rótulo eram categorias de item e o conjunto de dados era um array com os valores de cada uma das 1.000 principais palavras. Novamente, criar esse array envolve ciência, matemática e arte. Os valores de cada palavra no array podem ser simples booleanos zero ou um, porcentagens de ocorrências de palavras no artigo, um valor exponencial dessa porcentagem ou algum outro valor.


Conclusão

Descobrir Python, NLTK e aprendizado por máquina foi uma experiência interessante e prazerosa. A linguagem Python é eficiente e concisa e faz parte do meu kit de ferramentas de desenvolvedor agora. Ela é adequada para aplicações de aprendizado por máquina, idioma natural matemática/ciências. Embora não seja mencionado neste artigo, também a considero útil para gráficos e plotagem. Se Python também estava no seu ponto cego, sugiro a você que dê uma olhada nessa linguagem.

Recursos

Aprender

Obter produtos e tecnologias

  • Explore o site da NLTK e a criação de programas Python para trabalhar com dados de idioma humano.
  • Faça o download do pip e saiba mais sobre essa ferramenta para instalar e gerenciar pacotes Python.
  • Saiba mais sobre virtualenv, uma ferramenta para criar ambientes Python isolados.
  • Confira a biblioteca padrão unittest, uma versão Python de JUnit.
  • Confira o plug-in pyeclipse para Eclipse.
  • Confira o IDE PyCharm para um conjunto completo de ferramentas de desenvolvimento para programar com Python e recursos da estrutura Django.
  • Utilize o software de teste IBM (disponível para download ou em DVD) e inove em seu próximo projeto de desenvolvimento de software livre próprio usando o software especialmente para desenvolvedores.

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre, Linux
ArticleID=843408
ArticleTitle=Explore o Python, o Aprendizado por Máquina e a Biblioteca NLTK
publish-date=10302012