Elogios para Programando a Inteligência Coletiva

Elogios para Programando a Inteligência Coletiva
“Eu reviso uns poucos livros por ano, e naturalmente, leio uma boa quantidade durante o curso do
meu trabalho. E tenho que admitir que nunca gostei tanto de ler uma pré-impressão de um livro como
aconteceu com este. Bravo! Não consigo pensar numa forma melhor para um desenvolvedor ter seu
primeiro contato e aprender a respeito desses algoritmos e métodos, nem num método melhor para
que eu mesmo (sendo uma raposa velha em IA) reforce meu conhecimento a respeito dos detalhes.”
- Dan Russell, Responsável por Tecnologias de Ponta, Google
“O livro de Toby faz um ótimo trabalho ao analisar uma área complexa como os algoritmos de
aprendizado de máquina e chegar a exemplos práticos e acessíveis, que podem ser usados diretamente
para analisar interação social através da Internet hoje em dia. Se esse livro estivesse disponível dois
anos atrás, ele teria me poupado tempo precioso gasto seguindo caminhos sem resultados.”
- Tim Wolters, CTO (oficial chefe de tecnologia, Chief
Technology Officer), Collective Intellect
“Programando Inteligência Coletiva é uma realização extraordinária com relação à forma como ele
fornece uma coleção acessível de métodos computacionais para relacionar vastas quantidades de
dados. Especificamente, ele aplica essas técnicas no contexto da Internet, encontrando valor em ilhas
de dados que de outra forma estariam isoladas. Se você é um desenvolvedor para a Internet, este livro
é leitura obrigatória.”
- Paul Tyma, Engenheiro de Software Senior, Google
I
II
Programando a Inteligência Coletiva
Sumário
Prefácio..........................................................................................................XI
Capítulo 1. Introdução à Inteligência Coletiva................................................1
O Que É Inteligência Coletiva?..............................................................................................................2
O Que É Aprendizado de Máquina?......................................................................................................3
Limites do Aprendizado de Máquina......................................................................................................3
Exemplos na Vida Real.........................................................................................................................4
Outros Usos para Algoritmos de Aprendizado.......................................................................................5
Capítulo 2. Fazendo Recomendações..............................................................7
Coletando Preferências..........................................................................................................................8
Encontrando Usuários Similares.............................................................................................................9
Qual Métrica de Similaridade Deve Ser Usada?...................................................................................13
Classificando as Avaliações.................................................................................................................13
Recomendando Itens..........................................................................................................................14
Encontrando Produtos Similares..........................................................................................................16
Desenvolvendo um Sistema de Recomendação de Link do del.icio.us..........................................................17
Filtragem Baseada em Itens................................................................................................................20
Usando o Conjunto de Dados do MovieLens.......................................................................................23
Exercícios............................................................................................................................................25
Capítulo 3. Descobrindo Grupos....................................................................27
Aprendizado Supervisionado versus Não Supervisionado.................................................................27
Vetores de Palavras...............................................................................................................................28
Agrupamento Hierárquico...................................................................................................................30
Desenhando o Dendrograma...............................................................................................................35
Agrupamento de Colunas....................................................................................................................37
V
Agrupamento de K-Means..................................................................................................................39
Grupos de Preferências........................................................................................................................41
Vendo Dados em Duas Dimensões......................................................................................................45
Outras Coisas para Agrupar.................................................................................................................48
Exercícios............................................................................................................................................49
Capítulo 4. Procurando e Qualificando...........................................................51
O Que Tem Dentro de um Sistema de Busca?.....................................................................................51
Um Crawler Simples...........................................................................................................................53
Montando o Índice.............................................................................................................................55
Classificação Baseada em Conteúdo..................................................................................................60
Usando Links Externos.......................................................................................................................64
Aprendendo com os Cliques...............................................................................................................67
Exercícios............................................................................................................................................76
Capítulo 5. Otimização...................................................................................79
Viagens em Grupo..............................................................................................................................79
Representando Soluções.....................................................................................................................81
A Função Custo...................................................................................................................................81
Pesquisa Aleatória..............................................................................................................................83
Subindo a Colina.................................................................................................................................84
Têmpera Simulada..............................................................................................................................86
Algoritmos Genéticos..........................................................................................................................88
Buscas Reais por Vôos........................................................................................................................92
Otimizando por Preferências...............................................................................................................96
Visualização de Redes..........................................................................................................................99
Outras Possibilidades..........................................................................................................................103
Exercícios..........................................................................................................................................104
Capítulo 6. Filtragem de Documento...........................................................105
Filtragem de Spam............................................................................................................................105
VI
Programando a Inteligência Coletiva
Documentos e Palavras.......................................................................................................................106
Treinando o Classificador....................................................................................................................107
Calculando Probabilidades................................................................................................................108
Um Classificador Ingênuo (A Naïve Classifier)...................................................................................110
O Método Fisher................................................................................................................................114
Salvando os Classificadores Treinados................................................................................................117
Filtrando Blogs..................................................................................................................................119
Melhorando a Detecção de Características........................................................................................121
Usando a Akismet.............................................................................................................................122
Métodos Alternativos ......................................................................................................................123
Exercícios..........................................................................................................................................124
Capítulo 7. Modelos com Árvores de Decisão.............................................125
Prevendo incrições.............................................................................................................................125
Apresentando as Árvores de Decisão................................................................................................126
Treinando a Árvore............................................................................................................................128
Escolhendo a Melhor Divisão.............................................................................................................129
Construção Recursiva de Árvore........................................................................................................131
Exibindo a Árvore...............................................................................................................................133
Classificando Novas Observações......................................................................................................135
Podando a Árvore..............................................................................................................................136
Lidando com Dados Faltantes.............................................................................................................138
Lidando com Resultados Numéricos...................................................................................................139
Fazendo um Modelo de Preços de Casas...........................................................................................139
Fazendo Modelos de “Sensualidade”.................................................................................................142
Quando Usar Árvores de Decisão.......................................................................................................144
Exercícios..........................................................................................................................................145
Capítulo 8. Montando Modelos de Preço....................................................147
Montando um Conjunto de Dados de Exemplo.................................................................................147
Os k Vizinhos Mais Próximos.............................................................................................................148
VII
Vizinhos Ponderados........................................................................................................................150
Validação Cruzada.............................................................................................................................154
Variáveis Heterogêneas......................................................................................................................156
Otimizando as Escalas.......................................................................................................................158
Distribuições Desiguais.....................................................................................................................160
Usando Dados Reais - a API da eBay................................................................................................164
Quando Usar os k Vizinhos Mais Próximos.......................................................................................170
Exercícios..........................................................................................................................................170
Capítulo 9. Classificação Avançada: Métodos de Núcleo e MVSs................173
Conjunto de Dados de Páginas de Encontros...................................................................................173
Dificuldades com os Dados...............................................................................................................174
Classificação Linear Básica...............................................................................................................176
Características de Categoria.............................................................................................................180
Escalonando os Dados......................................................................................................................184
Entendendo Métodos de Núcleo........................................................................................................185
Máquinas de Vetor de Suporte...........................................................................................................188
Utilizando a LIBSVM (Biblioteca de Máquinas de Vetor de Suporte)............................................................189
Compatibilidade no Facebook...........................................................................................................192
Exercícios..........................................................................................................................................196
Capítulo 10. Encontrando Características Independentes.........................199
Um Corpus de Notícias......................................................................................................................200
Fatoração de Matriz Não Negativa...................................................................................................204
Mostrando os Resultados..................................................................................................................211
Utilizando Dados do Mercado de Ações...........................................................................................213
Exercícios..........................................................................................................................................218
Capítulo 11. Inteligência Evolutiva.............................................................219
O Que É Programação Genética?.....................................................................................................219
Programas Como Árvores.................................................................................................................221
VIII
Programando a Inteligência Coletiva
Criando a População Inicial...............................................................................................................225
Testando uma Solução......................................................................................................................226
Criando Programas Mutantes............................................................................................................228
Cruzamento.......................................................................................................................................230
Construindo o Ambiente....................................................................................................................232
Um Jogo Simples................................................................................................................................235
Mais Possibilidades............................................................................................................................238
Exercícios..........................................................................................................................................241
Capítulo 12. Resumo de Algoritmo..............................................................243
Classificador bayesiano.....................................................................................................................243
Classificador de Árvore de Decisão...................................................................................................246
Redes Neurais...................................................................................................................................250
Máquinas de Vetor de Suporte...........................................................................................................253
Os k Vizinhos Mais Próximos.............................................................................................................257
Agrupamento....................................................................................................................................260
Escalonamento Multidimensional.....................................................................................................263
Fatoração de Matriz Não-Negativa....................................................................................................265
Otimização.........................................................................................................................................267
Apêndice A..................................................................................................271
Apêndice B..................................................................................................277
Índice Remissivo..........................................................................................284
IX
X
Programando a Inteligência Coletiva
Prefácio
O número crescente de pessoas colaborando para a Internet, seja deliberadamente ou incidentalmente,
tem criado gigantescos conjuntos de dados que potencialmente podem nos despertar milhões de vezes
a intuição para entender: a experiência dos usuários, o mundo da propaganda, os gostos pessoais
e o comportamento humano de forma geral. Esse livro serve como introdução para aprender a se
aproveitar de conjuntos de dados interessantes oriundos de muitas páginas de Internet das quais você
provavelmente já ouviu falar, para ter idéias a respeito de como coletar dados de usuários para os seus
próprios aplicativos e também mostra muitas formas diferentes de analisar e entender os dados uma
vez que você os tenha encontrado.
O objetivo deste livro é levar você além do cenário comum de aplicativos baseados em bases de dados
e ensinar como escrever programas mais inteligentes que se aproveitam das informações que você e
outros coletam todos os dias.
Pré-Requisitos
Os exemplos de código nesse livro são escritos em Python, portanto familiaridade com essa linguagem
vai ajudar, mas fornecemos explicações a respeito de todos os algoritmos para que programadores de
outras linguagens possam compreender. O código em Python será particularmente fácil de endenter
para aqueles com conhecimento em linguagens de programação de alto nível como Ruby ou Perl.
Esse livro não se destina a ser um guia para aprender programação, portanto é importante que o
leitor tenha experiência e familiaridade com os conceitos básicos dessa área. Se você tem um bom
conhecimento a respeito de recursividade e de alguma programação funcional básica, vai achar o
material ainda mais fácil.
Esse livro não exige que você tenha qualquer conhecimento prévio em análise de dados, aprendizado de
máquina ou estatística. Tentamos explicar conceitos matemáticos da forma mais simples possível, mas
ter algum conhecimento de trigonometria e estatística básica deve ajudar a entender os algoritmos.
Estilo dos Exemplos
Os exemplos de código em cada seção são escritos num estilo de tutorial, que encoraja o leitor a construir
seus aplicativos em módulos e ter uma boa compreensão de como os algoritmos funcionam. Na maioria
dos casos, depois de criar uma nova função ou método, você os utilizará numa seção interativa para
melhor entender seu funcionamento. Os algoritmos são na maior parte variações simples e podem ser
estendidos de muitas formas. Ao analisar os exemplos e testá-los interativamente, você deverá intuir
maneiras pelas quais poderá melhorar esses algoritmos para usar em seus próprios aplicativos.
XI
Porque Python?
Embora os algoritmos sejam explicados com texto que descreve as fórmulas envolvidas, é muito mais
útil (e provavelmente mais fácil de entender) o código em si para os algoritmos e os problemas usados
como exemplos. Todo o código mostrado nesse livro é escrito em Python, uma ótima linguagem de
alto nível. Eu escolhi Python porque ela é:
Concisa
Código escrito em linguagens digitadas dinamicamente como o Python tende a ser mais
sucinto do que os escritos em outras linguagens importantes. Isso significa que menos digitação
é necessária quando copiando os exemplos, mas também implica que é mais fácil entender o
algoritmo e o que ele faz.
Legível
O Python tem sido chamado de “pseudo-código executável”. Embora isso seja claramente um
exagero, indica que a maior parte dos programadores experientes pode facilmente ler Python
e entender o que o código deveria fazer. Algumas das estruturas menos óbvias do Python são
explicadas na seção “Dicas de Python”.
Facilmente Extensível
O Python vem por padrão com muitas bibliotecas, incluindo de funções matemáticas, de
decodificação de XML (linguagem de marcação estensível, Extensible Markup Language).
As bibliotecas que não são o padrão utilizado neste livro, como as de decodificação de RSS
(publicação realmente simples, Really Simple Syndication) e a interface do SQLite, são
gratuitas e fáceis de baixar, instalar e usar.
Interativa
Quando executando um exemplo, é útil testar as funções sem ter que escrever outro programa
para esse propósito. Com Python é possível executar programas diretamente da linha de
comando, e também existe uma linha de entrada interativa que permite que se efetue chamadas
de funções, que se criem objetos e que pacotes sejam testados interativamente.
Multiparadigma
Python tem suporte para os paradigmas: orientação a objeto, procedural e funcional. Os algoritmos
de aprendizado de máquina variam grandemente, e a forma mais clara de implementar um deles
pode ser usar um paradigma diferente. Algumas vezes é útil passar funções como parâmetros e
outras ,é útil capturar estados num objeto. Python suporta ambas as abordagens.
Multiplataforma e gratuita
O Python tem uma implementação de referência única para cada uma das maiores
plataformas e é gratuita para todas elas. O código descrito neste livro funcionará em Windows,
Linux e Macintosh.
Dicas de Python
Para iniciantes interessados em aprender sobre programação em Python, eu recomendo ler Learning Python,
de Mark Lutz e David Ascher (O’Reilly), no qual encontramos uma excelente visão geral. Programadores
de outras linguagens devem considerar o código em Python relativamente fácil de entender, embora
XII
Programando a Inteligência Coletiva
cuidado seja necessário porque em alguns pontos no livro utilizamos algumas das idiossincrasias da
sintaxe do Python quando isso me permite expressar melhor as bases de um algoritmo ou algum conceito
fundamental. Eis uma revisão rápida para aqueles que não são programadores Python:
Constutores de Lista e de Dicionário
Existe no Python um bom conjunto de tipos básicos, e dois dos que são usados com freqüência nesse
livro são listas e dicionários. Uma lista é o que o nome indica, formada de itens ordenados de
qualquer tipo e é declarada com colchetes:
number_list=[1,2,3,4]
string_list=[‘a’, ‘b’, ‘c’, ‘d’]
mixed_list=[‘a’, 3, ‘c’, 8]
Um dicionário é um conjunto de pares de identificador/valor não ordenados, similar a mapas de hashes
de outras linguagens. É declarado usando chaves:
ages={‘John’:24,’Sarah’:28,’Mike’:31}
Os elementos de dicionários e listas podem ser acessados utilizando-se colchetes após o nome do
objeto:
string_list[2]
ages[‘Sarah’]
# returns ‘b’
# returns 28
Espaços em Branco Significativos
Diferente de muitas linguagens, o Python utiliza a identação do código para definir blocos. Considere
esse trecho de código:
if x==1:
print ‘x is 1’
print ‘Still in if block’
print ‘outside if block’
O interpretador sabe que os primeiros dois comandos print são executados quando x é igual a 1
porque o código está identado. Identação pode ser com qualquer número de espaços, desde que seja
consistente. Nesse livro usamos dois espaços para isso. Quando digitar o código é preciso ser cuidadoso
para copiar corretamente a identação.
Entendimento de Lista
Um entendimento de lista é uma forma conveniente de converter uma lista em outra filtrando
valores e aplicando funções nos itens. Um entendimento de lista é declarado da seguinte forma:
[expression for variable in list]
ou
[expression for variable in list if condition]
Por exemplo, o código seguinte:
l1=[1,2,3,4,5,6,7,8,9]
print [v*10 for v in l1 if v1>4]
teria como resultado:
[50,60,70,80,90]
XIII
Entendimentos de lista são usados com freqüência nesse livro porque são formas extremamente concisas
de aplicar uma função a toda uma lista, ou um meio de remover itens inválidos. Outra forma com a
qual são usados muitas vezes é com o construtor dict:
l1=[1,2,3,4,5,6,7,8,9]
timesten=dict([(v,v*10) for v in l1])
Esse código criaria um dicionário com a lista original como valores de identificação e cada item
multiplicado por dez como valor:
{1:10,2:20,3:30,4:40,5:50,6:60,7:70,8:80,9:90}
APIs Abertas
Os algoritmos para sintetizar inteligência coletiva exigem dados de muitos usuários. Além dos de
aprendizado de máquina, esse livro discute algumas APIs Abertas de Internet (Open Web APIs - API:
interface de programação de aplicativo, Application Programming Interface). Estas são as
formas por meio das quais algumas empresas permitem que se acesse gratuitamente dados de suas
páginas de Internet utilizando um protocolo específico. Você pode, portanto escrever programas que
baixem e processem esses dados. Eles geralmente consistirão de contribuições dadas pelos usuários da
página, que podem ser filtrados para tentar intuir informações. Em alguns casos, existirá uma biblioteca
Python disponível para acessar essas APIs. Se não for o caso, é bastante simples criar interfaces
personalizadas para acessar esses dados usando as bibliotecas nativas do Python para que os dados
sejam baixados e decodificados em XML.
Eis aqui uma lista de algumas das páginas com APIs abertas que você verá nesse livro:
del.icio.us
Um aplicativo de relacionamento social onde uma API aberta permite que você baixe endereços
de Internet por um assunto ou usuário específico.
Kayak
Um site de viagens com uma API feita para que se conduzam pesquisas com relação a vôos e
hotéis.
eBay
Uma página de leilão na Internet com uma API que permite que você consulte itens que estão
atualmente sendo vendidos.
Hot or Not
Hot or Not (algo como “sensual ou não?”), um sistema de categorização e de promoção
de encontros entre pessoas com uma API para procurar por alguém e obter sua classificação e
informação demográfica.
Akismet
Uma API para filtragem de spam colaborativa.
Um enorme número de aplicativos em potencial pode ser desenvolvido ao processar dados de uma
fonte única, ao combinar dados de várias fontes, e mesmo combinar informações externas com os
dados de seus próprios usuários. A capacidade de obter dados criados por pessoas numa variedade
XIV
Programando a Inteligência Coletiva
de formas em diversas páginas de Internet é o principal elemento para criar inteligência coletiva. Um
bom ponto de partida para encontrar mais sites com APIs abertas é ProgrammableWeb (http://
www.programmableweb.com).
Visão Geral sobre os Capítulos
Cada algoritmo nesse livro foi motivado por um problema real que pode, esperamos, ser facilmente
entendido por todos os leitores. Tentamos evitar problemas que exijam uma grande quantidade
ou domínio de conhecimento e nos concentramos naqueles que, embora complexos, possam ser
reconhecidos como comuns pela maioria das pessoas.
Capítulo 1, Introdução à Inteligência Coletiva
Explica os conceitos por trás do aprendizado de máquina, como ele é aplicado em muitos campos
diferentes e como usá-lo para chegar a novas conclusões a respeito dos dados recolhidos de
muitas pessoas diferentes.
Capítulo 2, Fazendo Recomendações
Introduz as técnicas de filtragem colaborativa usadas por muitas lojas na Internet para
recomendar produtos. O capítulo inclui uma seção a respeito de recomendações de endereços
de Internet, originados de um site de relacionamento social, e uma recomendação sobre filmes,
originada de um conjunto de dados do MovieLens.
Capítulo 3, Descobrindo Grupos
Avança algumas idéias do Capítulo 2 e introduz dois métodos diferentes de agrupamento
(clustering), que servem para detectar automaticamente grupo de itens similares num grande
conjunto de dados. Esse capítulo demonstra o uso de agrupamento para descobrir grupos num
conjunto de blogs populares na Internet e para descobrir similaridades no que querem pessoas
num site de relacionamento social.
Capítulo 4, Procurando e Classificando
Descreve as várias partes de um software de busca, incluindo a aranha (crawler),
o indexador e o sistema de pesquisa. O capítulo explica o algoritmo PageRank (nota
da página) para classificar páginas baseando-se nos links que fazem referência a ela e
mostra como criar uma rede neural que aprende quais palavras-chave são associadas com
diferentes resultados.
Capítulo 5, Otimização
Introduz-se algoritmos para otimização, que são projetados para procurar milhões de soluções
possíveis para um problema e escolher a melhor delas. A ampla variedade de usos para esses
algoritmos é demonstrada com exemplos como encontrar o melhor vôo para um grupo de
pessoas viajando para um mesmo lugar, ou achar a melhor forma de distribuir estudantes em
dormitórios, ou projetar uma rede com o mínimo de linhas cruzadas.
Capítulo 6, Filtragem de Documento
Demostra a filtragem Bayesiana, que é usada em muitos filtros de spam gratuitos e
comerciais para classificar automaticamente documentos baseando-se no tipo de palavras
e outras características que apareçam neles. Isso é aplicado num conjunto de resultados de
pesquisa RSS para demonstrar classificação automática de entradas.
XV
Capítulo 7, Modelando com Árvores de Decisão
Introduz árvores de decisão como um método não apenas para fazer previsões, mas também
para modelar a forma como as decisões são tomadas. A primeira árvore de decisão é montada
com dados hipotéticos vindos de logs de servidor e é usada para prever se é provável ou não
que um usuário se tornará um assinante privilegiado. Os outros exemplos usam dados de páginas
de Internet reais para modelar preços de imóveis e para determinar “sensualidade”.
Capítulo 8, Montando Modelos de Preço
Aborda problemas de prever valores numéricos ao invés de classificações usando técnicas dos kvizinhos mais próximos (k-nearest neighbors), e aplica os algoritmos de otimização do
Capítulo 5. Esses métodos são usados em conjunto com a API do eBay para montar um sistema
de previsão de preços finais de leilão para itens, baseando-se num conjunto de propriedades.
Capítulo 9, Classificação Avançada: Métodos de Núcleo e MVSs
Mostra como Máquinas de Vetor de Suporte (MVS, Support-Vector Machines, SVM) podem
ser usadas para encontrar pares de pessoas em páginas de Internet de encontros ou quando
procurando por contatos profissionais. Máquinas de vetor de suporte são uma técnica bastante
avançada e esse capítulo as compara com outros métodos.
Capítulo 10, Encontrando Características Independentes
Introduz uma técnica relativamente nova chamada fatoração de matriz não-negativa, que é usada
para encontrar características independentes num conjunto de dados. Em muitos conjuntos de
dados os itens são composições de diversas características que não conhecemos de antemão. A
idéia nesse capítulo é detectar essas características. Essa técnica é demonstrada num conjunto
de artigos de notícias, onde as histórias em si são usadas para detectar seus temas, um ou mais
dos quais pode se aplicar a uma dada história isolada.
Capítulo 11, Inteligências Evolutivas
Introduz programação genética, um conjunto de técnicas muito sofisticadas que vai além
da otimização e na prática monta algoritmos usando idéias evolucionárias para resolver um
problema em particular. Isso é demonstrado num jogo simples onde o computador é no início
um jogador ruim que melhora sua capacidade de jogo aprimorando seu próprio código, mais e
mais conforme o jogo vai sendo executado.
Capítulo 12, Sumário os Algoritmos
Revisa todos os algoritmos de aprendizado de máquina e estatísticos descritos no livro e os
compara com relação a um conjunto de problemas fictícios. Isso vai auxiliar a entender como
eles funcionam e a visualizar a forma como cada um deles divide dados.
Apêndice A, Bibliotecas de Terceiros
Contém informações sobre bibliotecas de terceiros usadas neste livro, como onde encontrá-las
e como instalá-las.
Apêndice B, Fórmulas Matemáticas
Contém fórmulas, descrições e código para muitos dos conceitos matemáticos apresentados
no livro.
XVI
Programando a Inteligência Coletiva
Exercícios no final de cada capítulo dão idéias a respeito de formas para estender os algoritmos e os
tornar mais poderosos.
Convenções
As seguintes convenções tipográficas são usadas neste livro:
Corpo de texto
Indica títulos, opções e botões de menus e aceleradores de teclado (como Alt e Ctrl)
Itálico
Indica novos termos, URLs, endereços de email, nomes, extensões e caminhos de arquivo e
diretórios, e utilitários do Unix.
Fonte Courier New
Indica comandos, opções, chaves, variáveis, atributos, funções, tipos, classes, namespaces,
métodos, módulos, propriedades, parâmetros, valores, objetos, eventos e suas funções de
tratamento, marcações XML e HTML (tags), macros, o conteúdo de arquivos ou o resultado
de comandos.
Fonte Courier New Negrito
Mostra comandos ou outro tipo de texto que deve ser digitado de forma literal pelo usuário
Fonte Courier New Itálico
Mostra texto que deveria ser substituído com valores fornecidos pelo usuário.
Esse ícone indica uma dica, sugestão ou nota genérica.
Usando o Código de Exemplo
Este livro existe para ajudar você a realizar o seu trabalho. Em geral, você pode usar o código neste livro
em seus programas e documentação. Não precisa entrar em contato conosco para obter permissões
exceto se você estiver reproduzindo uma quantidade significativa desse código. Por exemplo, escrever
um programa que use vários trechos de código desse livro não exige que se obtenham permissões.
Vender ou distribuir um CD-ROM de exemplos originados de livros da O’Reilly exige. Responder uma
pergunta citando esse livro e mostrando código de exemplo dele não exige permissão. Incorporar
uma quantidade significativa de exemplos desse livro na sua documentação de produto exige. Nós
apreciamos, mas não exigimos que se cite a autoria. Uma citação de autoria normalmente inclui o
título, o autor, a editora e o ISBN.
Como Entrar em Contato Conosco
Por favor enviar comentários e perguntas a respeito desse livro para a editora:
Editora Alta Books
Rua Viúva Claudio, 291 - Jacaré
Rio de Janeiro - RJ
CEP 20970-031
XVII
Temos uma página para esse livro onde listamos erratas, exemplos, e qualquer informação adicional.
Você pode acessar essa página em:
http://www.altabooks.com.br
Para comentários ou perguntas técnicas a respeito do livro, envie um e-mail para:
[email protected]
Agradecimentos
Gostaria de expressar minha gratidão a todos na editora envolvidos com o desenvolvimento e a
produção deste livro. Em primeiro lugar, gostaria de agradecer Nat Torkington por me dizer que a idéia
tinha mérito e que valia a pena desenvolvê-la. Mike Hendrickson e Brian Jepson por escutarem a idéia
e me animarem em escrever o livro, e especialmente Mary O’Brien que assumiu como editora no lugar
de Brian e que sempre foi capaz de amenizar meus medos a respeito do projeto ser mais do que eu
poderia fazer.
No time de produção, eu gostaria de agradecer Marlowe Shaeffer, Rob Romano, Jessamyn Read, Amy
Thomson e Sarah Schneider por transformarem minhas ilustrações e escritos em algo que alguém
realmente pode gostar de olhar.
Agradeço a todos que tomaram parte na revisão deste livro, especialmente Paul Tyma, Matthew Russell,
Jeff Harmmerbacher, Terry Camerlengo, Andreas Weigend, Daniel Russel e Tim Wolters.
Agradeço a meus pais.
Finalmente, tenho uma dívida de gratidão com vários dos meus amigos que me ajudaram a desenvolver
idéias para esse livro e que sempre entenderam quando eu não tinha tempo para eles: Andrea Matthews,
Jeff Beene, Laura Miyakawa, Neil Stroup e Brooke Blumenstein.
Escrever este livro teria sido muito mais difícil sem sua ajuda e eu certamente teria esquecido alguma
coisa nos exemplos mais interessantes.
XVIII
Programando a Inteligência Coletiva