Principais técnicas de machine learning

Natália Raythz em 21/01/2019 no site iMasters

Medium

Se quiser aprender mais sobre machine learning, vá além do Python.

Algoritmos x Técnicas

Embora este artigo seja sobre as técnicas de machine learning, vamos falar brevemente sobre os algoritmos.

Não são a mesma coisa?

Genericamente falando, uma técnica é uma maneira de resolver algo. Agora quando temos um algoritmo, queremos dizer que temos uma entrada e precisamos de uma saída onde, com o algoritmo, damos os passos para chegar até a saída. Logo, o algoritmo pode usar várias técnicas para chegar na saída.

Técnicas de machine learning

• Regressão: na maioria dos livros de estatística encontramos regressão como uma medida de como a média de uma variável e os valores correspondentes de outros valores se relacionam entre si.
• Regressão média: o primo de Charles Darwin, Francis Galton, observou ervilhas durante anos (o experimento, junto com o Mendel, foi muito importante para o avanço dos estudos da genética). Ele concluiu que deixar a natureza fazer o seu trabalho resultaria em diversos tamanhos de ervilhas

A natureza no comando e as ervilhas maiores começam a produzir descendentes menores com o tempo. Bom, temos um certo tamanho para ervilhas que variam, mas podemos mapear esses valores para uma linha ou uma curva específica.

Mas o que a regressão tem a ver com o Machine Learning?

Com determinada técnica a regressão encontra sua base no aprendizado supervisionado. Isso é baseado para prever algo contínuo e numérico e começamos trabalhando nos valores do conjunto de dados que já conhecemos, comparando os valores conhecidos e previstos e identificando a diferença entre os valores esperados e previstos como erro.

Tipos de regressão que são utilizadas no machine learning:

• Regressão linear: quando podemos observar a relação entre um alvo e um preditor em uma linha reta, Por exemplo: y = P1x + P2 +
• Regressão não linear: Quando é observada uma relação não linear entre alvo e preditor, e não é uma linha reta

Neste gráfico, a linha se ajusta melhor a todos os dados marcados pelos pontos. Usando essa linha, podemos prever quais valores encontraremos para x = 70 (com um grau de incerteza).

Classificação

A classificação é uma técnica de mineração de dados que nos ajuda a fazer uma previsão de participação em grupos para instância de dados. Isso usa dados rotulados com antecedência, que é um tipo de aprendizado supervisionado.

Isso quer dizer que treinamos dados e esperamos “prever o futuro” – essa previsão quer dizer que classificamos os dados em dois atributos:

• Atributo de saída ou atributo dependente
• Atributo de entrada ou atributo independente

Métodos de classificação

• Indução da árvore de decisão: uma árvore de decisão da classe tuplas rotuladas. Possui ‘nós’ internos, ramificações e ‘nós’ de folha. Os nós internos possuem o teste em um atributo, as ramificações, os resultados do teste, os nós da folha e o rótulo da classe. Os envolvidos são: aprender e testar
• Classificação baseada em regras: é baseada em um conjunto de regras IF-THEN, ou seja, IF – condição e THEN – conclusão
• Retropropagação: o aprendizado da rede neural é também conhecido por construir conexões. A retropropagação é um algoritmo de aprendizado bem popular, pois ele iterativamente processa dados e compara o valor alvo com os resultados a aprender
• “Preguiçosos”: numa abordagem mais preguiçosa, a máquina guarda uma tupla de treinamento e aguarda outra tupla de teste. Isso suporta o aprendizado incremental e contrasta com a abordagem inicial do aprendiz

Clustering

É uma classificação não supervisionada. É uma análise de dados exploratória, sem dados rotulados disponíveis. Com o agrupamento, separamos os dados não rotulados em conjuntos finitos e discretos de estruturas de dados naturais.

Eles também se dividem em dois tipos:

• Clustering difícil: um objeto pertence a um único cluster.
• Clustering flexível: um objeto pertence a vários clusters.

É assim que um cluster se parece: Código QR, Aztec e Data Matrix estariam em um grupo; nós poderíamos chamar isso de códigos 2D. Os códigos de barras da ITF e os códigos de barras da Code 39 seriam agrupados em uma categoria de ‘Códigos 1D’.

Detecção de anomalias

Anomalia é algo que desvia do curso esperado. Com o machine learning, também (nem sempre) podemos querer detectar uma anomalia. Um exemplo seria detectar uma conta de dentista 85 obturações por hora. Isso equivale a 42 segundos por paciente. Outra seria encontrar uma nota especial do dentista apenas às quintas-feiras.

Tais situações levantam suspeitas, e a detecção de anomalias é uma ótima maneira de destacá-las, já que isso não é algo que procuramos especificamente.

Bom, por enquanto isso é tudo sobre algumas técnicas de machine learning utilizando Python. Não quis entrar em detalhes de códigos, pois já existe bastante material pela internet que detalha mais os códigos de cada técnica. Meu objetivo aqui era entrar na parte teórica de cada uma. Espero que tenham gostado.

Como automatizar o Machine Learning?

Paolo Tamagnini, Simon Schmid e Christian Dietz  em 17/01/2019 no site CIO

Foto: Shutterstock

É possível automatizar totalmente o ciclo de vida da Ciência de Dados? É possível construir automaticamente um modelo de Machine Learning a partir de um conjunto de dados?

De fato, nos últimos meses, surgiram muitas ferramentas que afirmam automatizar todo ou parte do processo da Ciência de Dados. Como eles funcionam? Você poderia construir um? Se você adotar uma dessas ferramentas, quanto trabalho seria necessário para adaptá-la ao seu próprio problema e ao seu próprio conjunto de dados?

Normalmente, o preço a pagar pela automação do Machine Learninga, ou AutoML, é a perda de controle de um tipo de modelo caixa preta. O que você ganha em automação, você perde em sintonia fina ou capacidade de interpretação. Embora esse preço possa ser aceitável para problemas de Ciência de Dados circunscritos em domínios bem definidos, ele pode se tornar uma limitação para problemas mais complexos em uma ampla variedade de domínios. Nestes casos, uma certa quantidade de interação com o usuário final é desejável.

No KNIME, adotamos uma abordagem mais suave à AutoML. Nossa automação guiada - uma instância especial de análise guiada - faz uso de um aplicativo  Web totalmente automatizado para guiar os usuários por meio da seleção, treinamento, teste e otimização de vários modelos de Machine Learning. O fluxo de trabalho foi projetado para que os analistas de negócios criem facilmente soluções de análise preditiva aplicando seu conhecimento de domínio.

Neste artigo, mostraremos as etapas deste aplicativo do ponto de vista do analista de negócios, ao executar a tarefa a partir de um navegador da web.

Análise guiada para AutoML

Com automação guiada, não pretendemos substituir o driver automatizando totalmente o processo. Em vez disso, oferecemos assistência e permitimos que o feedback seja coletado sempre que necessário durante o processo de modelagem. Uma aplicação de automação guiada é desenvolvida por Cientistas de Dados para usuários finais. Para ser bem sucedido, precisa de:

• Facilidade de uso para o usuário final (por exemplo, execução de um navegador da web)
• Um conjunto de pontos de interação da GUI para reunir preferências e exibir resultados
• Opções de escalabilidade
• Um aplicativo de software de Ciência de Dados flexível, extensivo e ágil em execução em segundo plano

Por flexível, extensivo e ágil, queremos dizer um aplicativo de Ciência de Dados que permite a montagem de dados complexos e operações de Machine Learning, além de integrações fáceis com outras ferramentas de Ciência de Dados, tipos de dados e fontes de dados.

Em geral, uma aplicação de automação guiada pode automatizar o desenvolvimento de muitos tipos de modelos de Macine Learning. Nesse caso, precisamos automatizar as seguintes partes do ciclo da Ciência de Dados para criar um modelo de classificação genérico:

• Preparação de dados
• Engenharia de recursos
• Otimização de Parâmetros
• Seleção de recursos
• Treinamento de modelo
• Avaliação de modelo
• Implantação de modelo

Tão simples quanto o aplicativo final pode parecer para o usuário final, o sistema em execução em segundo plano pode ser bastante complexo e, portanto, não é fácil criar completamente do zero. Para ajudá-lo com este processo, criamos um modelo de um aplicativo interativo para criação automática de modelos de classificação de Machine Learning.

Este blueprint foi desenvolvido com o KNIME Analytics Platform e está disponível em nosso repositório público .

Um modelo para automação guiada de Machine Learning

O conceito principal por trás do blueprint para automação guiada inclui algumas etapas básicas:

• Upload de dados
• Definição de configurações de aplicativos por meio da interação humana
• Treinamento e otimização de modelos automatizados, com base nas configurações definidas anteriormente
• Painel com resumo de desempenho e download do modelo

O processo atual implementado no blueprint (Figura 1) se aplica a um problema de análise preditiva padrão. No entanto, o padrão raramente é o caso quando lidamos com problemas de dados. Geralmente, o processamento personalizado deve ser aplicado aos dados de entrada devido a tipos especiais de dados, estrutura de dados ou apenas conhecimento especializado pré-existente. Às vezes, o treinamento e o conjunto de testes podem precisar seguir regras específicas, como a ordem do tempo.

Uma possível customização do processo anterior, incluindo o pré-processamento de dados customizado e uma divisão de treinamento/teste customizada, é mostrada na Figura 2. É possível aplicar facilmente essas customizações ao blueprint no KNIME Analytics Platform. Graças à sua estrutura de programação visual, nenhuma codificação é necessária.

Automação guiada de Machine Learning: navegador da Web passo a passo

Vamos ver como é o esquema de automação guiada a partir de um navegador da web via KNIME Server .

No início, somos apresentados a uma sequência de pontos de interação:

• Carregamento dos dados
• Seleção da variável de destino
• Remoção de recursos desnecessários
• Seleção de um ou mais algoritmos de Machine Learning para treinar
• Opcionalmente, personalização das configurações de otimização de parâmetros e engenharia de recursos
• Seleção da plataforma de execução

Os recursos de entrada podem ser removidos com base na experiência do analista de negócios ou em uma medida de relevância do recurso. A medida de relevância que usamos foi baseada nos valores ausentes e na distribuição de valores da coluna; colunas com muitos valores ausentes, com valores que são muito constantes ou com valores que estão muito espalhados são penalizados.

A personalização da otimização de parâmetros e a engenharia de recursos são opcionais. A otimização de parâmetros é implementada por meio de uma pesquisa de grade em intervalos de parâmetros personalizáveis. A engenharia de recursos, se ativada, trabalha primeiro com um número de combinações de recursos e transformações selecionadas, depois com uma seleção final de recursos.

Algumas opções estão disponíveis em termos da plataforma de execução, variando de sua própria máquina local (padrão) a uma plataforma baseada em Spark ou outras plataformas de execução distribuídas .

O modelo de página Web a ser usado para todos os pontos de interação, que estão resumidos na Figura 3 abaixo, inclui uma descrição da tarefa necessária à direita e um fluxograma de aplicativo na parte superior. As etapas futuras são exibidas em cinza, as etapas anteriores em amarelo e a etapa atual em apenas um quadro amarelo.

Depois que todas as configurações tiverem sido definidas, o aplicativo executará as etapas no plano de fundo. Os recursos de entrada selecionados passarão pelo pré-processamento de dados (lidando com valores ausentes e outliers), criação e transformação de recursos, otimização de parâmetros e seleção de recursos, e treinamento final do modelo e avaliação em termos de medidas de precisão e desempenho computacional.

E aqui chegamos ao final da jornada de automação guiada. O aplicativo retorna um painel em que os modelos de Machine Learning selecionados são comparados em termos de precisão e velocidade de execução.

Curvas ROC, medidas de precisão, gráficos de ganho ou de sustentação e matrizes de erro são calculados no conjunto de testes e exibidos na página de destino final para comparar medidas de precisão (Figura 4).

A velocidade de execução do modelo é avaliada durante o treinamento e durante a implantação. A velocidade de execução da implantação é medida como a velocidade média para executar a previsão de uma única entrada. Assim, dois gráficos de barras mostram, respectivamente, o tempo de treinamento do modelo em segundos e o tempo médio para produzir uma única previsão em milissegundos (Figura 5).

Todas as visualizações do painel são interativas. Configurações de plotagem podem ser alteradas e visualizações de dados podem ser exploradas em tempo real.

Os modelos estão prontos para download. No painel final, você encontrará os links para baixar um ou mais dos modelos treinados para uso futuro, por exemplo, como uma API RESTful em produção.

Para a experiência completa de automação guiada, você pode assistir ao aplicativo em ação neste vídeo de demonstração: "Análise orientada para automação de aprendizado de máquina".

Machine Learning para analistas de negócios

Neste artigo, descrevemos o modelo KNIME para automação guiada de Machine Learning e ilustramos as etapas necessárias. Esse aplicativo da web orientado ao fluxo de trabalho representa nossa própria interpretação de aplicativos de aprendizado de máquina semi-automatizados (guiados).

O blueprint implementado através da KNIME Analytics Platform e descrito neste artigo pode ser baixado gratuitamente , personalizado de acordo com suas necessidades e reutilizado livremente. Um fluxo de trabalho baseado na Web pode ser executado executando-se o mesmo aplicativo no Knime Server.

Agora, é a sua vez de criar um aplicativo de aprendizado de máquina guiada a partir desse blueprint. Dessa forma, você pode capacitar os analistas de negócios a criar e treinar facilmente modelos de aprendizado de máquina a partir de um navegador da web.

Para mais informações sobre o KNIME, visite www.knime.com e o blog KNIME .

Um pouco de Machine Learning com Python

Por Rafael Novello em 02/02/2017 no site iMasters

Hoje quero mostrar um pequeno programa que criei para testar e praticar as técnicas de Machine Learning na categorização de textos. É apenas um protótipo que usa matérias jornalísticas, mas você pode baixá-lo para testar e estudar!

Importante: Meu objetivo não é abordar profundamente as diferentes técnicas, abordagens e algoritmos disponíveis, pois meu conhecimento ainda não me permite. Ao invés disso, quero te mostrar como é possível aplicar tais conhecimentos e, quem sabe, te estimular a também estudar o assunto!

Como você pode ver no aquivo em meu Github, o programa ficou com 152 linhas de código, o que é pouco mas vou me concentrar nas partes relacionadas ao processamento dos dados, treinamento e predição que são o foco do artigo de hoje.

O programa pode ser dividido nas seguintes etapas:

1. Baixar e extrair o conteúdo das matérias a partir de um CSV com links e categorias;
2. Limpar o conteúdo e deixar apenas o que é relevante para o treinamento do modelo;
3. Criar o Bag of Words e treinar o modelo que fará a categorização;
4. Categorizar novos links com o modelo treinado.

Com estas etapas em mente, vamos ao que interessa!

1. Baixar e extrair o conteúdo (Goose, o achado!)

Se você já criou algum tipo de web scraping, sabe como pode ser chato trabalhoso. Para os meus propósitos, era necessário extrair das páginas HTML apenas o conteúdo da matéria sem poluir o resultado com tags ou textos periféricos. Depois de muitas tentativas usando requests, lxml e regex, encontrei o projeto goose-extractor no pypi.

Goose, muito amor!

Em uma olhada rápida na documentação, percebemos que esse projeto é perfeito para o nosso caso e em 3 linhas ele resolve o problema:

1	from goose import Goose

2

....

3	goose = Goose()

4	article = goose.extract(link)

5	text = article.cleaned_text

Basta passar o link da página e o Goose faz o resto! Ele também permite acessar outros atributos da página, como o título da matéria, descriptors, etc. Vale a pena conferir!

Por se tratar de uma tarefa I/O Bound e serem mais de 700 links para baixar, estou usando a classe ThreadPoolExecutor do backport futures. O uso é muito simples e você pode saber mais na documentação do projeto!

2. Limpar o conteúdo (NLTK)

Com o texto das matérias em mãos, precisamos remover caracteres e palavras que podem atrapalhar o algoritmo de categorização, deixando apenas as palavras que possam contribuir com o “entendimento” do texto. Na primeira etapa, removo praticamente tudo que não for texto:

1	import unicodedata

2

3

...

4

5	def remove_nonlatin(string):

6	new_chars = []

7	for char in string:

8	if char == '\n':

9	new_chars.append(' ')

10

continue

11

try:

12	if unicodedata.name(unicode(char)).startswith(('LATIN', 'SPACE')):

13	new_chars.append(char)

14

except:

15

continue

16	return ''.join(new_chars)

17

18

...

19

20	text = remove_nonlatin(to_unicode(text))

Depois disso, precisamos remover as chamadas stop words que, em resumo, são palavras que se repetem muito em qualquer texto e podem prejudicar a análise feita pelo algoritmo. Isso é feito com a ajuda do projeto NLTK.

O NLTK pode ser instalado via pip, mas depois da sua instalação é preciso baixar o pacote stopwords pelo gerenciador do próprio NLTK. Vou deixar lincadas as instruções das 2 etapas.

Depois de tudo instalado, é fácil remover as stop words dos nossos textos:

1	from nltk.corpus import stopwords

2

...

3	stops = set(stopwords.words("portuguese"))

4	words = ' '.join([w for w in words if not w in stops])

Por fim, criamos um DataFrame pandas para reunir os links, as categorias e os textos processados:

1	from pandas import DataFrame

2

...

3	lines = []

4	words = pre_processor(link)

5	lines.append((link, categ, words))

6

...

7	df = DataFrame(lines)

8	df.columns = ['link', 'categoria', 'texto']

3. Bag of words

Em resumo rápido, bag of words é um modelo de representação textual que ignora a ordem e a gramática das palavras, mas preserva sua multiplicidade. Um exemplo pode nos ajudar:

O texto: “Rafael gosta muito de assistir filmes. A Ana gosta de filmes também” é transformado em uma lista de palavras:

1	["Rafael", "gosta", "muito", "de", "assistir", "filmes", "a", "Ana", "também"]

Depois disso, o modelo gera uma lista com a frequência que cada palavra aparece no texto : [1, 2, 1, 2, 1, 2, 1, 1, 1].

Este processo, de traduzir palavras em números, é necessário, pois os algoritmos que vamos usar para classificar os textos só aceitam/”entendem” números. Para nossa sorte, o scikit-learn, uma das principais bibliotecas do tipo em Python, já tem uma classe para ajudar neste processo.

Abaixo, vou mostrar a função de treinamento por completo. Acredito que seja mais fácil explicar assim:

1	import sklearn

2	from sklearn.externals import joblib

3	from sklearn.pipeline import Pipeline

4	from sklearn.linear_model import LogisticRegression

5	from sklearn.feature_extraction.text import CountVectorizer

6

7	def train(df, fit_file):

8	print "\nTraining..."

9	df = df.dropna()

10	train_size = 0.8

11	vectorizer = CountVectorizer(

12	analyzer="word",

13	tokenizer=None,

14	preprocessor=None,

15	stop_words=None

16

)

17	logreg = LogisticRegression()

18	pipe = Pipeline([('vect', vectorizer), ('logreg', logreg)])

19	X_train, X_test, Y_train, Y_test = sklearn.model_selection.train_test_split(

20	df.texto, df.categoria, train_size=train_size

21

)

22	pipe.fit(X_train, Y_train)

23	accuracy = pipe.score(X_test, Y_test)

24	msg = "\nAccuracy with {:.0%} of training data: {:.1%}\n".format(train_size, accuracy)

25

print msg

26	pipe.fit(df.texto, df.categoria)

27	joblib.dump(pipe, fit_file)

Das linhas 11 a 16, criamos a instância que vai montar o modelo bag of words dos textos que baixamos, mas por enquanto nada foi feito.

Na linha 17, é criada a instância que efetivamente vai analisar nossos dados e fazer predições. Como o nome sugere, será usada uma técnica chamada Regressão Logística para fazer a classificação dos textos. Eu testei algumas técnicas diferentes de classificação, mas esta apresentou os melhores resultados, chegando a 84% de acerto! Você pode conferir os teste que fiz neste link aqui!

Na linha 18, reunimos os 2 processos anteriores em um pipeline. Isto foi necessário para facilitar a preservação e armazenamento do modelo treinado. Vamos falar disso daqui a pouco!

Da linha 19 a 21 usamos uma função do scikit-learn para dividir nossa massa de dados em 80% para treino e 20% para testar a precisão do modelo.

Da linha 22 a 25, nós treinamos nosso modelo, avaliamos a precisão do mesmo e mostramos essa informação no terminal.

Finalizando, na linha 26 o modelo é treinado novamente, mas agora com 100% dos dados, e na linha 27 usamos outra ferramenta do scikit-learn para salvar o modelo treinado em disco, pois não precisamos refazer todo este processo toda vez que o programa for usado.

4. Pronto para uso!

Finalmente! O programa está pronto para categorizar novos textos! Vamos ver a função predict!

1	def predict(url, fit_file):

2	pipe = joblib.load(fit_file)

3	words = pre_processor(url)

4	resp = pipe.predict([words])

5	print "\nCategory: %s \n" % resp[0]

6	resp = zip(pipe.classes_, pipe.predict_proba([words])[0])

7	resp.sort(key=lambda tup: tup[1], reverse=True)

8	for cat, prob in resp:

9	print "Category {:16s} with {:.1%} probab.".format(cat, prob)

A função recebe como parâmetros uma URL (que vamos categorizar) e o caminho para o arquivo salvo em disco com nosso modelo treinado.

A linha 2 carrega o pipeline que salvamos no disco como o CountVectorizer e o LogisticRegression.

A linha 3 usa uma função para baixar e processar o texto da URL fornecida. Basicamente, os passos 1 e 2 desse artigo.

A linha 4 usa nosso pipeline para criar o bag of words do texto e fazer a predição de qual a categoria que melhor representa este texto.

As linhas de 6 a 9 mostram todas as categorias que nosso modelo conhece e as respectivas probabilidades em relação ao texto que está sendo categorizado.

Vamos ver como funciona!

Agora que já falamos sobre as principais partes do programa, vamos vê-lo em ação! Para testar no seu computador, além de baixar o arquivo do programa e a lista de links, você precisará instalar as dependências. Tudo via pip install:

• futures
• goose-extractor
• pandas
• nltk
• scikit-learn

O programa usa 3 parâmetros; FILE é o caminho para o arquivo CSV com os links das matérias que você pode baixar aqui. O formato do arquivo é muito simples e você pode montar o seu com outros links e categorias.

TRAIN é o nome do arquivo com o modelo treinado. Se o arquivo já existir, o programa usa o modelo existente; caso contrário, ele vai baixar os dados e processar.

Primeiro, vamos baixar os dados, processá-los e treinar nosso modelo. Esta é a saída do programa mostrando a quantidade de palavras em cada matéria:

Depois de algum tempo baixando e processando os dados, o programa nos mostra que ele salvou o arquivo bag_words.csv com os dados processados e a precisão do modelo após o treinamento. Chegamos a 79%!

Agora vamos testar se ele acerta a categoria desta matéria do G1 sobre tecnologia:

Concluindo (finalmente!)

Eu adoraria ficar aqui e te mostrar vários exemplos de como o programa acerta a categoria de várias matérias, mas você deve estar bem cansado – eu estou! rs

Bom, espero ter atingido meu objetivo e, pelo menos, motivado você a também estudar o assunto. Deixei vários links ao longo do texto e nas referências para te ajudar a entender melhor do que estamos falando.

Fique à vontade e comente o que achou aqui em baixo e se você souber como posso melhorar a precisão dos modelos usados, será de grande ajuda!

Referências

• http://www.andreykurenkov.com/writing/organizing-my-emails-with-a-neural-net/
• http://machinelearningmastery.com/multi-class-classification-tutorial-keras-deep-learning-library/
• http://scikit-learn.org/stable/tutorial/text_analytics/working_with_text_data.html
• http://scikit-learn.org/stable/auto_examples/text/document_classification_20newsgroups.html
• http://nbviewer.jupyter.org/github/jmportilla/Udemy—Machine-Learning/blob/master/Multi-Class%20Classification.ipynb