Tutorial – criando um jogo de plataforma demo com Pygame e Tiled

Desviando só um pouquinho do tema deste blog, gostaria de compartilhar este tutorial que montei.

1 - Introdução

Pygame é uma biblioteca da linguagem Python para desenvolvimento de games.

O download desta pode ser feito em: http://www.pygame.org/download.shtml

Neste tutorial, vamos utilizá-la para criar um jogo de plataforma básico (demo).

Além disso, vamos utilizar para a criação do mapa da tela, o software Tiled, e uma lib para manipular o arquivo do mapa criado por este.

O download do Tiled pode ser feito em: http://www.mapeditor.org

O arquivo do mapa gerado pelo Tiled, é um xml com uma extensão chamada tmx.

Existem algumas bibliotecas que foram criadas para manipular este tipo arquivo, e neste caso, escolhemos trabalhar com a biblioteca do Richard Jones. Para isso podemos baixar o arquivo tmx.py do link: https://github.com/renfredxh/tmx

• Baixe e instale o Pygame e o Tiled. Após isto, crie um diretório chamado “demo“ e coloque dentro dele o arquivo tmx.py.

2 – Criação do mapa da tela

• Abra a linha de comando do Linux e digite tiled para abrir o Tiled. Crie um novo arquivo e salve-o no diretório “demo”.

O Tiled possui dois tipos de camadas:

Camadas de tiles

Onde é desenhado o cenário do mapa através de imagens.

Por padrão, o mapa já virá com uma camada de tiles criada. Para adicionar imagens nesta camada, clique no menu Mapa > Novo Tileset e selecione a imagem desejada. Isso deve ser feito para cada imagem.

As imagens carregadas ficarão disponíveis na lista de tilesets à direita da tela. Ao clicar em uma imagem após carregada, você vai perceber que se passar o mouse em cima do mapa, ela estará disponível para ser carimbada nele conforme seus cliques. Além disso, você não precisa carimbar a imagem inteira. Você pode escolher quais tiles (pedacinhos) da imagem você quer selecionar.

• Carregue as imagens desejadas e desenhe todo o mapa da tela do seu jogo.

Camada de objetos

Onde são adicionados os objetos que ocupam espaço físico ou representam triggers no mapa. Esta camada normalmente deve ficar invisível (para isso, basta desmarcar o checkbox dela).

•  Para criar uma camada de objetos, clique no menu Camada > Adicionar camada de objetos, e renomeie a camada criada como “triggers”.

A camada de objetos é onde você define paredes, chão, teto, plataformas, indivíduos, itens etc.

Se você quer criar, por exemplo, uma parede lateral, você deve desenhá-la na camada de tiles, e na camada de abjetos adicionar um retângulo sobre ela.

Ou seja, o desenho em si não representará nada para o pygame a não ser uma imagem a ser renderizada, de modo que somente os objetos (alinhados com a imagem) poderão interagir com o código.

Os objetos dessa camada serão enxergados e manipulados pela biblioteca tmx.

• Através do botão Inserir Objeto (O) no menu principal do topo, crie os objetos retangulares desejados que representem as paredes, teto, chão e plataformas do seu jogo. Clique com o botão direito em cada objeto, selecione Propriedades do objeto e insira uma nova propriedade com nome “blockers” e valor “tlrb”.
  Além dos objetos retangulares, você pode inserir ainda objetos carregados a partir de imagens externas. Isso serve para representar os personagens e itens da tela.

Todavia, não vamos carregar ainda a imagem diretamente no mapa. Vamos carregar uma imagem auxiliar onde cada quadradinho da imagem seja aproximadamente do tamanho de um tile (32x32 px).

Ex.:

Esses quadradinhos, de quantidade a definir, devem representar cada tipo de item, personagem ou trigger da tela.

• Crie uma imagem auxiliar que represente os itens do seu jogo em um editor qualquer e clique em Mapa > Novo Tileset para adicioná-la.
• Clique com o botão direito em cada tile do tileset e adicione uma propriedade que nomeie o item representado por cada tile. Ex.: nome “player” e value “yes”.

• Clique na flechinha rosa abaixo da caixa de tilesets e exporte esse tileset para o diretório “demo” como .tsx.
• Através do botão Inserir Tile (T) no menu principal do topo, coloque no mapa os objetos auxiliares desejados que representem indivíduos, itens ou triggers do seu jogo.

3 - Codificação

• Importe as bibliotecas pygame e tmx.
• Inicialize o pygame e o joystick:

pygame.init()

pygame.joystick.init()

• Crie o objeto que representa a tela (passando como parâmetro o tamanho desta):    screen =   pygame.display.set_mode((768, 576))                             

•  Defina um temporizador Para atualizar os frames da imagem a ser renderizada:    clock = pygame.time.Clock()

•  Carregue o mapa criado no Tiled:

           tilemap = tmx.load('map.tmx', screen.get_size())

Sprites são a representação de indivíduos, itens etc no jogo, e devem ser criados para manipular os mesmos.

Ex.1 – criação de um sprite que representa o jogador (como este é apenas um único, deve-se escolher o índice 0 do array):

sprites = tmx.SpriteLayer()

start_cell = tilemap.layers['triggers'].find('player')[0]

player = Player((start_cell.px, start_cell.py), sprites)

tilemap.layers.append(sprites)

Ex.2 – criação do grupo de sprites de inimigos (como são vários, é necessário inserir em um loop) :

enemies = tmx.SpriteLayer()

for enemy in self.tilemap.layers['triggers'].find('enemy'):

    Enemy1((enemy.px, enemy.py), enemies)

tilemap.layers.append(enemies)

Podemos notar que: o nome “triggers” que é citado agora, é o mesmo que foi designado no mapa do Tiled para a camada de objetos; o nome passado como parâmetro para a função find, também foi designado no mapa do Tiled como propriedade de cada tile representando um item ou indivíduo; a função find retorna a posição do item no mapa em relação aos eixos x e y;

• Crie grupos de sprites para todos os indivíduos e itens do seu jogo na tela do mapa criado. Ex.: player, enemies, bullets, guns, lifes etc.

O jogo precisa ter um loop principal que manterá o jogo rodando e sendo atualizado.

Neste loop, você deve:

- limitar os frames a serem atualizados por segundo: dt = clock.tick(30)

- capturar os eventos gerados no pygame com o sub loop:

                for event in pygame.event.get():

                    # fecha o jogo caso haja clique no “x” da janela

                    if event.type == pygame.QUIT:

                        return

           - preencher a tela com uma cor solida, de modo a evitar blurring dos itens renderizados:     
               screen.fill((250,250,250))

- atualizar o objeto do mapa conforme frames: tilemap.update(dt / 1000., self)

- desenhar os itens do objeto do mapa na tela: tilemap.draw(screen)

- atualizar a tela: pygame.display.flip()

- verificar a life do player de modo a tomar a ação adequada caso a life tenha acabado (como por exemplo sair do jogo ou apresentar uma mensagem de game over).

• Crie um loop principal para o seu jogo.

Para todos os sprites criados anteriormente, é necessário ter uma classe com as definições dos mesmos.

O objeto tilemap deverá manipular os objetos das classes de cada sprite automaticamente, a partir de algumas funções e atributos padrão.

Ex.1 – Classe de indivíduos/itens

• Crie a classe do sprite desejado passando a classe sprite como parâmetro: (pygame.sprite.Sprite).
• Carregue a imagem do indivíduo/item no atributo image: image = pygame.image.load('...')

A função principal da classe deve ter o seguinte formato básico:

def __init__(self, location, *groups):

    super(NOME, self).__init__(*groups)

O parâmetro “location” se refere à posição inicial do indivíduo/item e o parâmetro “*groups” faz referência ao objeto de sprites localizado na chamada da classe.

A posição do indivíduo deve ser marcada no atributo “rect”.

Para inicializar o atributo de localização do indivíduo/item use:

self.rect = pygame.rect.Rect(location, self.image.get_size())

É necessário ter uma função chamada “update” para atualizar os objetos da classe:

def update(self, dt, game):

•  Programe o incremento ou decremento do atributo “rect” para mover o indivíduo/item na horizontal, ex.: self.rect.x += 100 * dt

Neste caso o número 100 é o salto e dt é a ponderação pela velocidade de atualização de frames, configurada anteriormente.

•  Verifique uma possível colisão do objeto atual com outros objetos da seguinte forma:

              for cell in game.tilemap.layers['triggers'].collide(self.rect, 'reverse'):

                  # aqui vão as ações cabíveis em caso de colisão.

No exemplo acima, estamos verificando a colisão do objeto atual com objetos do tipo 'reverse'. Lembrando que esses tipos são definidos nas propriedades do mapa criado no Tiled.

•  Verifique se o objeto atual colidiu com o player:

              if self.rect.colliderect(game.player.rect):

                  # aqui vão as ações cabíveis em caso de colisão.

Ex.2 – Classe do player

A classe do player deve conter quase as mesmas coisas que a classe do exemplo anterior, pois ele também é um indivíduo/item.

Todavia, haverá provavelmente um conjunto maior de ações e verificações a serem feitas.

Exemplos:

Em descanso: self.resting = False

Velocidade: self.dy = 0

Marcação da life do player.

Leitura do joystick e teclado:

joystick = pygame.joystick.Joystick(0)

joystick.init()

key = pygame.key.get_pressed()

# anda para frente

if key[pygame.K_LEFT] or joystick.get_axis(0)<0:

    self.rect.x -= 300 * dt

# anda para trás

if key[pygame.K_RIGHT] or joystick.get_axis(0)>0:

    self.rect.x += 300 * dt

# pulo e queda

if self.resting and ( key[pygame.K_SPACE] or int(joystick.get_button(2)) == 1) :

    self.dy = -500

    self.dy = min(400, self.dy + 40)

    self.rect.y += self.dy * dt

Verificação de colisão com “blockers” (chão, parede ou plataformas):

new = self.rect

self.resting = False

for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'):

    blockers = cell['blockers']

    # limite à direita

    if 'l' in blockers and last.right <= cell.left and new.right > cell.left:

        new.right = cell.left

    # limite à esquerda

    if 'r' in blockers and last.left >= cell.right and new.left < cell.right:

        new.left = cell.right

    # limite do chão

    if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top:

        self.resting = True

        new.bottom = cell.top

        self.dy = 0

    # limite do teto

    if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom:

        new.top = cell.bottom

        self.dy = 0

É importante forçar que a janela mantenha o foco no player como item central: game.tilemap.set_focus(new.x, new.y)

• Crie as classes dos indivíduos e itens do seu jogo.

Um vídeo tutorial de Richard Jones (mais detalhado, porém em inglês) está disponível no link: http://pyvideo.org/video/2620/introduction-to-game-programming

Abraços miningnoobs !

Validação de modelos

Conforme já mencionamos em outro post, uma das etapas mais importantes no processo de desenvolvimento de um modelo é sua validação.
Isso porque não adianta você criar um modelo, e partir do pressuposto de que ele funciona. É preciso verificar e provar tal pressuposto, de forma a validá-lo.

Já comentamos, também em outro post, que no processo de modelagem, provavelmente vamos extrair uma amostra de dados da população total.
Essa amostra, entretanto, não deverá ser utilizada inteiramente para fomentar o aprendizado do modelo. Isso porque uma parte desta deverá ser reservada para a etapa de validação, ou teste.

O motivo disso é simples. É fácil dizer que o modelo acerta suas previsões e classificações para os mesmos indivíduos que fizeram parte do processo de aprendizado. Afinal de contas, o modelo já conhece esses indivíduos. Entretanto, na prática da "vida real do modelo", ele será utilizado para prever e classificar indivíduos que ele desconhece. Esse é o verdadeiro desafio, e portanto, é isso que deve ser medido na validação.

Pra tal, precisamos reservar uma parcela da nossa amostra, que não tenha nenhuma participação no processo de desenvolvimento do modelo, e que, apenas no final seja utilizada para colocá-lo à prova.
O acerto nesta amostra de indivíduos (amostra de validação ou teste), poderá ser considerado o acerto previsto final esperado na prática.

O tamanho da amostra de validação pode variar dependendo do caso, mas algo em terno de 30% da amostra total é bastante razoável.

É bom ressaltar que neste caso estamos falando de aprendizado supervisionado. E é justamente neste momento de validar, que estamos supervisionando nosso aprendizado.


Por exemplo:

Imaginemos que nosso público alvo são homens acima de 50 anos em São paulo, e que conseguimos coletar uma amostra de 100.000 indivíduos.
Vamos reservar 30% destes para validação (amostra de validação), sendo 30.000 indivíduos, e os outros 70% (70.000 indivíduos) serão utilizados na aprendizagem (amostra de desenvolvimento) do modelo. É importante que essa separação de indivíduos seja aleatória.

Agora vamos imaginar que criamos um modelo de propensão para uma resposta binária (como infarto sim/não) com a amostra de desenvolvimento, e aplicamos o modelo na amostra de validação para testar seu acerto.
Nesse exemplo hipotético, digamos que nosso acerto tenha sido de 75%.
Isso significa que quando estivermos usando o modelo na sua aplicação prática, ele tenderá a acertar em  aproximadamente 75% de suas previsões. Essa é a capacidade de generalização dele.

Um ponto importante de comentar é que, um modelo não pretende acertar todos os casos, pois dificilmente isso é viável. Um modelo se propõe a acertar uma quantidade razoável, que seja melhor do que uma escolha aleatória, portanto este deve fornecer uma medida para sua expectativa de acerto. Devemos ter em mente que em meio a muitos acertos, sempre haverão erros, mas isso ainda será melhor do que tomar uma decisão de forma arbitrária.

Quando temos uma amostra pequena, ou simplesmente quando queremos apenas garantir um resultado mais estável, podemos usar técnicas de validação que repetem esse processo de separação de amostras várias vezes para garantir expectativas de acerto mais seguras, como K-Folds,  mas isso já é outro assunto.

Acertos nas categorias


Cuidado! Vamos agora imaginar que na amostra do nosso público alvo, apenas 10% dos indivíduos tiveram infarto no período do estudo, e os outros 90% não.
Se nosso modelo simplesmente atribuir uma previsão negativa para todos os indivíduos, ele acertará 90%. Esse número parece muito bom olhando o acerto total, mas na prática, sabemos que o modelo é inútil, pois não acerta nenhum caso onde o indivíduo é positivo.
Deviso a isso, não podemos olhar apenas o acerto total. Precisamos avaliar o acerto de todas as categorias, para garantir que mesmo em amostras desbalanceadas, o acerto será razoável para todas as categorias de resposta.
Dessa forma, poderemos dizer que nosso modelo é capaz de discriminar entre as estas (neste caso, infarto sim/não).


Abraços miningnoobs!

Big Data ?! A nova buzzword.

E falando em moda, está aí a buzzword do momento: Big Data! Peraí...mas quem falou em moda?...rs...Anyway...

Todo mundo agora quer saber de Big Data. Comprar Big Data e vender Big Data...!

Mas quem sabe de fato o que é Big Data (BD)? Muitos não sabem, mas acham que sim.

Muita gente pensa que só porque tem uma base de 1 milhão de clientes, isso é BD. Se você tem uma base de dados bem grande e estruturada, sobre a qual você conhece a estrutura e conteúdo, isso não é BD. Você poderia ter 54859345843 trilhões de clientes na base, ou um "googleplex" de registros de transações bancárias e isso ainda não seria BD. Isso seria apenas um "montão de dados". =)

Pra ser  BD, há alguns critérios a se considerar, como: a maior parte do que está entre esses dados ser lixo! Mas entre o lixo, há coisas úteis a serem descobertas. É um mar de inutilidades a ser percorrido para achar um tesouro perdido. Outra coisa é que normalmente os dados estão desestruturados. Mesmo que estejam em um banco de dados, o conteúdo pode ser texto, e dentro daquele texto podem haver várias informações diferentes que você não sabe onde começa uma ou termina a outra.

O exemplo mais claro disso são as redes sociais. As informações estão armazenadas em um banco de dados especial, mas os conteúdos são diversos. Num único post você pode ter várias informações sobre uma pessoa. E como você vai descobrir qual parte é qual, e o que é útil?

Na prática, você vai precisar que ter uma boa infra estrutura pra guardar tudo isso e analisar.

Agora...é claro que você não vai analisar manualmente, caso a caso...rsrs...e mesmo se isso fosse feito, dificilmente perceberia algo de genial.

É ai que entram os algoritmos de mineração de dados pra te ajudar a descobrir padrões no BD, e fazer dele algo útil e palpável. Eles possibilitam enxergar algo que antes era invisível.

Os dados que levam a grandes descobertas sobre os padrões de funcionamento do mundo podem estar nos lugares mais inóspitos... ^^...então temos que fuçar!

Abraços miningnoobs!

Público alvo, amostra e período

Nos posts anteriores vimos que para fazer um modelo, precisamos definir antes: qual a pergunta que queremos responder. Ex.: quais as chances de alguém ter um infarto?

Após isto, há mais uma pergunta básica que deve ser feita: de quem ou o que estamos falando? Ou seja, qual o público alvo?

Precisamos definir quais as características dos indivíduos/coisas que vamos analisar.
Por exemplo, podemos definir que nosso público alvo para a pergunta acima é composto por:  mulheres, viúvas, que moram na região central de sp e fumam.
Desta forma, os dados coletados para o estudo devem ser somente de indivíduos que estejam dentro destas características.
É importante ter em mente que o modelo que será criado, deverá ser (idealmente) aplicado a indivíduos do mesmo público. Ou seja, não seria coerente aplicar o modelo em homens, ou ainda em mulheres que não fumam. Isso porque estes não fizeram parte do conjunto de mapeamento do estudo. Eles não participaram da modelagem, de modo que corre-se o risco (não necessariamente, mas não da pra saber a priori) de eles não apresentarem um comportamento similar aos outros.
Isso não significa que vamos aplicar o modelo somente nas pessoas que participaram da modelagem. Afinal de contas, dessa forma o modelo não serviria de nada. Quero dizer que vamos aplicar em outras pessoas, mas sendo estas, pessoas que fazem parte do mesmo perfil definido no público alvo.
É muito importante que fique bem claro logo no começo qual a definição exata desse público alvo, de modo a evitar retrabalhos futuros.

Após definir o público, precisamos avaliar a volumetria de dados que temos disponível, considerando a resposta que foi definida.
Devemos lembrar que podem haver diversas restrições quanto à quantidade de dados a ser considerada no estudo. Não somente por questões de processamento e armazenamento (afinal hoje em dia isso já não é um problema tão grande), mas por questões de viabilidade de coleta também.
Muitas vezes os dados do estudo não estão disponíveis em um sistema, e é necessário coletá-los. Por exemplo: com pesquisa de campo ou em redes sociais.
Dessa forma, é pertinente definir uma amostra a ser coletada da população.
O tamanho ideal da amostra é uma questão um pouco subjetiva. Há alguns cálculos estatísticos que permitem definir o tamanho ideal, mas nem sempre isso é necessário, pois vai depender muito da situação. Não existem números mágicos, mas a partir de 1.000 casos já temos alguma coisa razoável.
Um fator que deve ser considerado com muita cautela é a questão da aleatoriedade.
A amostra deve ser aleatória! A menos que se esteja usando alguma técnica de estratificação ou algo assim, mas isso deve ser feito com cuidado e exige conhecimentos adicionais.
Isso serve para evitar criar vieses na amostra.
Ex.: imagine que você extraia os dados de cadastro de clientes de um sistema transacional pegando os primeiros 10.000 da tabela. Imagine agora que a base estava ordenada por idade. Desta forma o seu modelo terá mais gente nova do que velha para ser modelada (isso se não acabar entrando só gente nova). O problema é que na prática você aplicará o modelo tanto em gente velha quanto em gente nova, mas o seu modelo não conhece o comportamento das pessoas mais velhas. Desta forma, ele tende a errar nas previsões destes indivíduos.

Por último, precisamos ainda definir um período histórico para nossos dados.
Devemos pensar na dinâmica do assunto que estamos tratando em relação ao tempo.
Por exemplo, se estivermos falando do mundo de finanças, devemos pensar que dados muito antigos talvez não reflitam a economia atual, uma vez que esta pode mudar tão rápido.
Entretanto, não podemos também pegar somente dados de ontem, pois é cedo de mais para perceber um padrão! Devemos avaliar bem o histórico que vamos utilizar, até porque isso impacta na volumetria. É preciso ponderar o custo/benefício de um histórico mais longo, e ainda o malefício (por pegar dados que já não refletem a realidade).



Abraços miningnoobs!

A importância dos dados

Até agora temos falado das técnicas para analisar dados e extrair padrões destes. Mas além das técnicas, existe um detalhe muito importante, que deixa até de ser detalhe.
Tão importante quanto as técnicas a serem aplicadas aos dados, são os próprios dados.
Não há modelo ou algoritmo que "salve" dados ruins. Mas o quero dizer com 'dados ruins'? 'Dados ruins' não é uma expressão que se refere a dados que não apresentam o resultado que queremos, mas sim a dados que não representam a realidade como ela é.

Modelos são abstrações da realidade. Isso significa buscar identificar as características macro que definem o alvo analisado através de um conjunto de dados capaz de representar essa realidade. Logo, se o conjunto de dados apresentado for distorcido, a representação que o modelo fará será distorcida, de modo que em relação ao que se deseja analisar de fato, o modelo não terá valor ou significado algum.

Devido a isso, a etapa de entendimento dos dados se mostra como uma etapa bastante decisiva. As conclusões após essa etapa podem levar a desistir de criar um modelo, devido à possível inexistência de dados confiáveis, fidedignos. Isso porque, um modelo feito em dados distorcidos, vai apenas prejudicar o processo de decisão e descoberta, uma vez que levará a conclusões errôneas ou à descoberta de padrões irreais, que não terão efeito no mundo prático. Modelos feitos em dados não íntegros levam-nos a vieses e ao erro.

Vamos ver alguns pontos que valem a pena serem ressaltados a esse respeito:

Metadados

O básico na etapa de entendimento seria verificar se há um metadados disponível para ajudar a entender os dados. Entretanto, sabemos que muitas vezes este não existe, e acabamos tendo que fazer uma investigação mais longa, através de conversas com diversas pessoas envolvidas no processo de geração dos dados, ou analisando documentos que possam conter essas definições. Seja como for, é essencial garantir que não estamos interpretando os dados de forma incorreta, como por exemplo, considerar o campo de 'valor de parcela' como campo de 'valor não pago de parcela'.

Governança de dados

Algo que deve ser questionado é: o quanto podemos confiar no processo que gera os dados? Por exemplo, imagine que você está fazendo um modelo e um dos dados disponíveis é o 'salário'. Será que existe um processo de verificação do salário informado pelo cliente, ou o que é inserido no banco é apenas o que o cliente informa verbalmente? Caso não haja uma verificação, devemos pensar duas vezes antes de considerar esse dado no modelo.

Outros

Alguns campos dificilmente podem ser considerados, dado que a informação é inserida no cadastro manualmente. Um exemplo disso seria o campo 'profissão'. Muitas vezes num processo de cadastro, um atendente não entende ou não encontra a profissão informada pelo cliente e seleciona uma profissão que ele acredita ser similar. Além disso, ele pode definir a profissão como 'outros'. Desta forma duas coisas podem acontecer: pessoas serão classificadas em profissões inadequadas; o campo profissão terá uma grande porcentagem de pessoas em outros, e não será muito informativo.


Abraços miningnoobs!

Correlação vs Causalidade

Conforme vimos anteriormente, para fazer previsões sobre um determinado evento é necessário usar um conjunto de variáveis (informações).
Hoje vamos entender como essas variáveis se relacionam e como é possível que elas de fato ajudem nessas previsões.
Pra isso precisamos entender o conceito de correlação. Podemos dizer que duas variáveis estão correlacionadas quando é possível observar que as ocorrências de algum valor de uma delas acontecem com uma frequência parecida com o valor da outra. What ??!!!

Exemplo: em relação a uma determinada pessoa, a variável "gastos mensais" pode aumentar conforme a variável "salário" aumenta. Isso porque normalmente quando se ganha mais gasta-se mais. Então estes eventos estão correlacionados. Neste caso, além de correlação existe ainda a presença da causalidade. Isso porque o motivo de estar se gastando mais é justamente por se ganhar mais.

Neste caso temos correlação e ainda causalidade. Mas existem casos onde temos apenas correlação, sem causalidade.

Um exemplo disso seria:

Imagine uma praia onde conforme aumenta o "número de picolés vendidos" aumenta também o "número de afogamentos". Vamos proibir a venda de picolés, porque pessoas estão morrendo afogadas ?!...claro que não.
Neste caso, existe correlação, porque essas duas variáveis ("número de afogamentos" e "número de picolés") tem frequências de ocorrências similares. Entretanto, não é uma que está causando a outra.
Então porque suas frequências são similares? Bom, normalmente isso ocorre porque existe uma terceira variável por de trás disso causando as duas coisas.
Neste caso, a variável é a "temperatura". Em dias quentes, mais pessoas tomam sorvete, e também mais pessoas entram na água para nadar, aumentando assim a chance de se afogarem.

E como essa informação pode ser útil? Bem, o interessante disso, é que mesmo quando não existe causalidade  (o que ocorre na maioria das vezes) , a variável ainda sera útil para explicar e prever o evento da variável que queremos.
No exemplo acima, mesmo que os afogamentos não causem a venda de picolés ou vice versa, bastaria colocar uma barraquinha de sorvete em praias com um grande número de afogamentos, que as vendas de picolés aumentariam. =)

No processo de modelagem é isso o que ocorre. Olhamos os dados e variáveis disponíveis, e tentamos descobrir quais delas estão correlacionas com o evento que queremos prever (evento final).
No final, não importará se elas são ou não as causadoras do evento final. O que importa é que através delas é possível prever este evento, e isso é tudo que nos interessa.

Por exemplo na área da medicina:

Se um modelo foi criado dizendo que pessoas "com mais de 70 anos, que moram no interior, de sexo feminino, da classe C e sem filhos" tem 95% de chance de ter uma determinada doença, não importa se essa tendência de ter a doença é devida às características citadas, o que importa mesmo é que temos um diagnóstico, e pessoas com esse perfil devem se tratar, pois existe algum fator implícito expresso por de trás dessas características que causa a doença.



Abraços miningnoobs!

Tipos clássicos de modelos

Conforme vimos no último post, existem diferentes tipos de aprendizagem e diferentes tipos de variáveis a serem analisadas.

Agora veremos os tipos mais clássicos de modelagem. Ou seja, os formatos de perguntas mais comuns no mundo da modelagem.


Modelos de Propensão


São modelos que buscam predizer uma variável categórica, seja binária ou de múltiplas categorias. É um aprendizado supervisionado.

Exemplos:

binária - classificar uma pessoa como portadora de uma doença: sim/não
múltiplas categorias - classificar um carro como sendo da categoria: A/B/C/D

Modelos assim predizem a qual categoria um indivíduo/objeto pertence, e qual a probabilidade disso ser verdade.

Ex.1:  dadas suas características, João foi classificado pelo modelo como tendo 76% de chance (propensão) de estar doente (sim).

Ex.2:  dadas suas características, o Carro Cherry foi classificado pelo modelo como tendo 85% de chance (propensão) de ser da categoria D.

Alguns algoritmos que fazem isso:

• Regressão logística - binária
• Redes Neurais - múltiplas categorias
• Árvores de decisão - múltiplas categorias

Modelos de Estimação


São modelos que buscam predizer uma variável contínua. Modelos assim estimam o valor de uma variável quantitativa. É um aprendizado supervisionado.

Exemplos: valor de vendas; valor de um imóvel; peso de uma pessoa.

Ex.1: dadas suas características, o valor do imóvel 1 é estimado em R$293.908.

Ex.2: dadas suas características, o peso de Maria é estimado em 65 quilos.

Alguns algoritmos que fazem isso:

• Regressão Linear
• Redes Neurais

Modelos de Segmentação


São modelos que buscam encontrar similaridades entre indivíduos/objetos. É um aprendizado não supervisionado.

Exemplos: grupos de pessoas similares; grupos de produtos similares; grupos de cidades similares.

Ex.1: dadas suas características, João, Maria e Paulo foram agrupados como similares no segmento 1; Ana, Cláudia e Mário foram agrupados como similares no segmento 2.

Ex.2: dadas suas características, as cidades de são Paulo, Rio de Janeiro e Porto Alegre foram agrupadas como similares no segmento 1; Natal, Maceió e Fortaleza foram agrupadas como similares no segmento 2.

Alguns algoritmos que fazem isso: 

• K-means
• Two-step

Modelos de Regras de Associação


São modelos que buscam encontrar padrões de ocorrência de eventos/fatos. É um aprendizado não supervisionado.

Exemplos: produtos que vendem juntos num carrinho de compras; situações que acontecem juntas;

Ex.1: dadas as ocorrências, em 86% das vezes que uma pessoa coloca macarrão em seu carrinho de compras, ela coloca também frango;

Ex.2: dadas as ocorrências, em 79% das vezes que ocorre uma falha numa rede X de computadores, falta também fornecimento de água no local.


Alguns algoritmos que fazem isso:

• Apriori
• Carma

Repare que alguns algoritmos podem ser usados tanto para respostas binárias quanto para respostas de múltiplas categorias e ainda respostas contínuas, como, por exemplo, Redes Neurais.



Abraços miningnoobs!