Data Science e AI no FreeBSD

Data Science e AI usando
Freebsd
25/05/2019 – Seropédica, Universidade Federal Rural
do Rio de Janeiro, RJ – Brasil (45 min.)
Mauro Risonho de Paula Assumpção
mauro.risonho*noSPAM*gmail.com
https://twitter.com/firebitsbr
https://www.linkedin.com/in/firebitsbr/

Corporate Disclaimer
●
O(s) conteúdo(s) apresentado(s) nesta palestra, não representam
as opiniões do meu empregador 25/05/2019.
●
Todas as opiniões e informações aqui são de minha
responsabilidade.
●
As informações desta palestra são de caráter acadêmico e de
aprendizado estudantil, não nos responsabilizamos pelo de outras
formas.

Machine learning
●
O aprendizado de máquina é o ramo da ciência da
computação que utiliza a experiência passada para
aprender e usar seu conhecimento para tomar
decisões futuras. O aprendizado de máquina está na
interseção da ciência da computação, engenharia e
estatística. O objetivo do aprendizado de máquina é
generalizar um padrão detectável ou criar uma regra
desconhecida a partir de exemplos dados.

STATISTICS FOR MACHINE LEARNING, Manuel Amunategui, pag. 9
Machine learning

Data Storage
Todo aprendizado deve começar com dados.
Humanos e computadores utilizam o armazenamento de
dados como base para um raciocínio mais avançado.
Em um ser humano, isso consiste em um cérebro que usa
sinais eletroquímicos em uma rede de células biológicas
para armazenar e processar observações para uma futura
recordação de curto e longo prazo. Os computadores têm
recursos semelhantes de recuperação de curto e longo
prazo, usando unidades de disco rígido, memória flash e
memória de acesso aleatório (RAM) em combinação com
uma unidade de processamento central (CPU).

Abstração
Conexões abstratas como essas são a base da representação do
conhecimento, a formação de estruturas lógicas que ajudam a
transformar a informação sensorial bruta em um insight significativo.
Durante o processo de representação do conhecimento de uma
máquina, o computador resume os dados brutos armazenados
usando um modelo, uma descrição explícita dos padrões dentro dos
dados. Assim como o pipe de Magritte, a representação do modelo
assume uma vida além dos dados brutos. Representa uma ideia
maior que a soma de suas partes.
Existem muitos tipos diferentes de modelos. Você pode já estar
familiarizado com alguns.
Exemplos incluem:
●
Equações matemáticas
●
Diagramas relacionais, como árvores e gráficos
●
Regras lógicas if / eles
●
Agrupamentos de dados conhecidos como clusters
O que é isso?
É um cachimbo.

Generalização
Gatos
Machine
Learning
Gato
Não é Gato

Avaliação
●
O viés é um mal necessário associado aos processos de
abstração e generalização inerentes a qualquer tarefa de
aprendizagem. A fim de conduzir a ação em face da possibilidade
ilimitada, cada aluno deve ser tendencioso de uma maneira
particular. Consequentemente, cada aluno tem suas fraquezas e
não há um algoritmo de aprendizado único para governá-las.
●
Portanto, a etapa final no processo de generalização é avaliar ou
medir o sucesso do aluno, apesar de seus vieses, e usar essa
informação para informar o treinamento adicional, se necessário.

Aprendizado de máquina na prática
●
Coleta de dados: A etapa de coleta de
dados envolve a coleta do material de
aprendizagem que um algoritmo usará para
gerar conhecimento acionável. Na maioria
dos casos, os dados precisarão ser
combinados em uma única fonte, como um
arquivo de texto, uma planilha ou um banco
de dados.

●
Exploração e preparação de dados: A qualidade de qualquer
projeto de aprendizado de máquina baseia-se amplamente na
qualidade de seus dados de entrada. Assim, é importante aprender
mais sobre os dados e suas nuances durante uma prática chamada
exploração de dados.
●
É necessário trabalho adicional para preparar os dados para o
processo de aprendizado. Isso envolve consertar ou limpar os
chamados dados "bagunçados", eliminando dados desnecessários e
recodificando os dados de acordo com as entradas esperadas do
aluno.

●
Treinamento de modelo: No momento em que os
dados foram preparados para análise, é provável que
você tenha uma noção do que é capaz de aprender com
os dados.
●
A tarefa específica de aprendizado de máquina
escolhida informará a seleção de um algoritmo
apropriado, e o algoritmo representará os dados na
forma de um modelo.

●
Avaliação de modelo: Como cada modelo de
aprendizado de máquina resulta em uma solução
tendenciosa para o problema de aprendizado, é
importante avaliar o quanto o algoritmo aprende com sua
experiência. Dependendo do tipo de modelo usado, você
pode avaliar a precisão do modelo usando um conjunto
de dados de teste ou pode precisar desenvolver medidas
de desempenho específicas para o aplicativo desejado.

●
Melhoria do modelo: se for necessário um melhor
desempenho, será necessário utilizar estratégias
mais avançadas para aumentar o desempenho do
modelo. Às vezes, pode ser necessário alternar
completamente para um tipo diferente de modelo.
Pode ser necessário complementar seus dados com
dados adicionais ou executar trabalhos preparatórios
adicionais, como na etapa dois deste processo.

Datasets
●
Conjuntos de dados (Datasets) que armazenam as
unidades de observação e suas propriedades podem
ser imaginadas como coleções de dados consistindo
de:
– Exemplos: instâncias da unidade de observação para as
quais as propriedades foram registradas
– Características: propriedades gravadas ou atributos de
exemplos que podem ser úteis para a aprendizagem.

Datasets
●
É mais fácil entender recursos e exemplos por
meio de casos do mundo real.
EXAMES DE
MAMOGRAFIA
SPAM
SAMPLERS DE
MALWARES

Motivação da Palestra e Uso (1/2)
Não há versão para *BSD e nem
pretendem desenvolver...

Motivação da Palestra e Uso (1/2)

Packages
Equivalente no FreeBSD
●
Quickly download 1,500+ Python/R data science packages
●
Manage libraries, dependencies, and environments with Conda
●
Develop and train machine learning and deep learning models
with scikit-learn, TensorFlow, and Theano
●
Analyze data with scalability and performance with Dask,
NumPy, pandas, and Numba
●
Visualize results with Matplotlib, Bokeh, Datashader, and
Holoviews

Anaconda Docs-Pkgs (bundle)
●
Packages Anaconda Docs-pkgs
– https://docs.continuum.io/anaconda/packages/docs-
pkgs/
●
Python
●
NumPy
●
SciPy
●
Pandas
●
Conda
●
Blaze
●
Bleach
●
Botocore
●
Certifi
●
Cryptography
●
CFFI
●
Coverage
●
Cython
●
Dask
●
Dask.distributed
●
Dateutil
●
Greenlet
●
H5py
●
Html5lib
●
Imageio
●
Ipython
●
Jinja
●
Jupyter
●
JupyterLab
●
Jupyter
Notebook
●
Llvmlite
●
Msgpack
●
Odo
●
OpenSSL
●
Pillow
●
pip
●
psutil
●
pyOpenSSL
●
python-tblib
●
PyWavelets
●
PyZMQ
●
Requests
●
ruamel.yam
●
Setuptools
●
six
●
Toolz
●
Tornado
●
Traitlets
●
Wheel
●
Zict

FreeBSD Docs-Pkgs (bundle)
●
Packages FreeBSD Docs-pkgs – funcionam
equivalente:
●
Python
●
NumPy
●
SciPy
●
Pandas
●
Conda
●
Blaze
●
Bleach
●
Botocore
●
Certifi
●
Cryptography
●
CFFI
●
Coverage
●
Cython
●
Dask
●
Dask.distributed
●
Dateutil
●
Greenlet
●
H5py
●
Html5lib
●
Imageio
●
Ipython
●
Jinja
●
Jupyter
●
JupyterLab
●
Jupyter
Notebook
●
Llvmlite
●
Msgpack
●
Odo
●
OpenSSL
●
Pillow
●
pip
●
psutil
●
pyOpenSSL
●
python-tblib
●
PyWavelets
●
PyZMQ
●
Requests
●
ruamel.yam
●
Setuptools
●
six
●
Toolz
●
Tornado
●
Traitlets
●
Wheel
●
Zict

R language packages for Anaconda
●
https://repo.anaconda.com/pkgs/r/
https://docs.continuum.io/anaconda/packages/r-language-pkg-docs/
https://repo.anaconda.com/pkgs/r/
●
conda install -c r r-essentials
●
conda install -c r-acepack r-adgoftest r-aer r-afex r-anomalydetection r-ape r-argparse r-assertthat r-backports r-base r-base64enc r-bcp r-bdsmatrix
r-bestglm r-bh r-bindr r-bindrcpp r-bit r-bit64 r-bitops r-blob r-boot r-bradleyterry2 r-brew r-brglm r-broom r-cairo r-car r-caret r-catools r-cellranger r-
checkmate r-chron r-class r-cluster r-coda r-codetools r-coin r-colorspace r-commonmark r-config r-copula r-crayon r-crosstalk r-ctv r-curl r-cvst r-
cvtools r-data.table r-dbi r-dbplyr r-ddalpha r-debugme r-deoptimr r-desc r-devtools r-diagrammer r-dichromat r-digest r-dimred r-domc r-doparallel r-
downloader r-dplyr r-drr r-dt r-dygraphs r-e1071 r-essentials r-estimability r-evaluate r-feather r r-findpython r-forcats r-foreach r-forecast r-foreign r-
formatr r-formattable r-formula r-fracdiff r-functional r-fwdselect r-gdata r-getopt r-ggplot2 r-ggvis r-gistr r-git2r r-glmnet r-glue r-gmp r-gower r-gplots
r-gridbase r-gridextra r-grpreg r-gsl r-gsw r-gtable r-gtools r-haven r-hexbin r-highcharter r-highr r-hmisc r-hms r-htmltable r-htmltools r-htmlwidgets r-
httpuv r-httr r-hunspell r-igraph r-influencer r-inline r-ipred r-irdisplay r-irkernel r-irlba r-iterators r-janeaustenr r-jpeg r-jsonlite r-kernlab r-kernsmooth r-
knitr r-kohonen r-labeling r-lahman r-lars r-lattice r-latticeextra r-lava r-lazyeval r-leaflet r-leaps r-lintr r-lme4 r-lmertest r-lmtest r-logging r-lsmeans r-
lubridate r-magrittr r-manipulate r-mapproj r-maps r-maptools r-markdown r-mass r-matrix r-matrixmodels r-memoise r-mgcv r-microbenchmark r-
mime r-miniui r-minqa r-mlmrev r-mnormt r-modelmetrics r-modelr r-modeltools r-mongolite r-multcomp r-munsell r-mvtnorm r-networkd3 r-nlme r-
nloptr r-nlp r-nmf r-nnet r-numderiv r-nycflights13 r-oce r-odbc r-openssl r-packrat r-pbdzmq r-pbkrtest r-pcapp r-perm r-pkgconfig r-pkgmaker r-pki r-
plm r-plogr r-plyr r-png r-polspline r-praise r-proc r-processx r-prodlim r-profilemodel r-profvis r-proto r-pryr r-pspline r-psych r-purrr r-quadprog r-
quantmod r-quantreg r-qvcalc r-r.methodss3 r-r.oo r-r.utils r-r6 r-randomforest r-rappdirs r-raster r-rbokeh r-rcolorbrewer r-rcpp r-rcpparmadillo r-
rcppeigen r-rcpproll r-rcurl r-readr r-readxl r-recipes r-recommended r-registry r-rematch r-repr r-reshape r-reshape2 r-reticulate r-rex r-rgexf r-rgl r-
rhive r-rjava r-rjdbc r-rjson r-rjsonio r-rlang r-rlist r-rmarkdown r-rmr2 r-rms r-rngtools r-robustbase r-rocr r-rodbc r-rook r-roxygen2 r-rpart r-rprojroot r-
rsconnect r-rserve r-rsqlite r-rstan r-rstudioapi r-rversions r-rvest r-rzmq r-sandwich r-scales r-seacarb r-selectr r-sf r-sfsmisc r-shiny r-shinybs r-
shinycssloaders r-shinydashboard r-shinyjs r-shinysky r-shinythemes r-slam r-snowballc r-sourcetools r-sp r-sparklyr r-sparsem r-spatial r-stabledist
r-stanheaders r-stringdist r-stringi r-stringr r-strucchange r-survival r-tensorflow r-testit r-testthat r-tfruns r-th.data r-threejs r-tibble r-tidyr r-tidyselect r-
tidytext r-tidyverse r-tilegramsr r-timedate r-tm r-tokenizers r-tseries r-ttr r-udunits2 r-units r-urca r-uuid r-vars r-vgam r-viridis r-viridislite r-visnetwork
r-weatherdata r-whisker r-withr r-xlsx r-xlsxjars r-xml r-xml2 r-xtable r-xts r-yaml r-zoo rpy2 rpy2 rstudio
Number of supported
packages: 328
Packages base R

Execução do Rstudio (1/2)
https://www.freshports.org/devel/RStudio/
pkg-message:
======================================================================
You installed RStudio: Integrated development environment (IDE) for R.
Please note that RStudio requires /proc to be mounted.
The usual way to do this is to add this line to /etc/fstab:
proc /proc procfs rw 0 0
and then run this command as root:
# mount /proc

Update Packages do Rstudio
1
2
3

O código R para estatísticas descritivas (média, mediana e moda) é
dado da seguinte forma:
●
Parâmetro versus estatística: Qualquer medida calculada sobre a população é um
parâmetro, enquanto que em uma amostra é chamada de estatística.
●
Média: Esta é uma média aritmética simples, que é calculada tomando a soma agregada
de valores dividida por uma contagem desses valores. A média é sensível a valores
discrepantes nos dados. Um outlier (valor aberrante) é o valor de um conjunto ou
coluna altamente desviante dos muitos outros valores nos mesmos dados; geralmente
tem valores muito altos ou baixos.
●
Mediana: Este é o ponto médio dos dados e é calculado organizando-o em ordem
crescente ou decrescente. Se houver observações N.

Estatísticas descritivas (média, mediana e moda):
Moda: Este é o ponto de dados mais repetitivo nos dados:

Data Science – Exemplo Simples
1
2
3
O código R para
estatísticas descritivas
(média, mediana e
moda) é dado da
seguinte forma:

Tipos de algoritmos de aprendizado de
máquina
●
Algoritmos de aprendizado de máquina são
divididos em categorias de acordo com sua
finalidade.
●
Entender as categorias de algoritmos de
aprendizado é um primeiro passo essencial no
uso de dados para direcionar a ação desejada.

Tipos de algoritmos de aprendizado de
máquina
●
Um modelo preditivo é usado para tarefas
que envolvem, como o nome indica, a previsão
de um valor usando outros valores no conjunto
de dados. O algoritmo de aprendizado tenta
descobrir e modelar o relacionamento entre o
recurso de destino (o recurso que está sendo
previsto) e os outros recursos.

Modelo Tarefa de aprendizagem
Supervised Learning Algorithms
Nearest Neighbor Classification
Naive Bayes Classification
Decision Trees Classification
Classification Rule Learners Classification
Linear Regression Numeric prediction
Regression Trees Numeric prediction
Model Trees Numeric prediction
Neural Networks Dual use
Support Vector Machines Dual use
Correspondência de dados de entrada em
algoritmos(1/2)
●
São muitos
algoritmos a serem
explicados.
●
A palestra irá focar
apenas no
algoritmo “Decision
Trees” por
questões de tempo.

Model Tarefa de aprendizagem
Unsupervised Learning Algorithms
Association Rules Pattern detection
k-means clustering Clustering
Meta-Learning Algorithms
Bagging Dual use
Boosting Dual use
Random Forests Dual use
Correspondência de dados de entrada em
algoritmos(2/2)

Correspondência de dados de entrada em algoritmos
●
Para começar a aplicar o aprendizado de máquina a um projeto do
mundo real, você precisará determinar qual das quatro tarefas de
aprendizado seu projeto representa: classificação, previsão numérica,
detecção de padrão ou agrupamento. A tarefa guiará a escolha do
algoritmo.
●
Por exemplo, se você estiver realizando a detecção de padrões,
provavelmente empregará regras de associação. Da mesma forma,
um problema de agrupamento provavelmente utilizará o algoritmo k-
means e a previsão numérica utilizará análise de regressão ou
árvores de regressão.

Compreender as Árvores de Decisão
(decision trees)
●
Nodes de árvore de decisão são poderosos classificadores, que
utilizam uma estrutura de árvore para modelar as relações entre os
recursos e os resultados potenciais. Como ilustrado na figura a seguir,
essa estrutura ganhou seu nome devido ao fato de que ela reflete
como uma árvore literal começa em um tronco largo, que se for
seguido para cima, se divide em ramos mais estreitos e mais
estreitos.
●
Da mesma maneira, um classificador de árvore de decisão usa uma
estrutura de decisões de ramificação, que canaliza exemplos para um
valor de classe predito final.

Árvores de Decisão (Decision Trees)

(decision trees)
●
Para entender melhor como isso funciona na
prática, vamos considerar a seguinte árvore, que
prevê se uma oferta de trabalho deve ser aceita.
Uma oferta de trabalho a ser considerada
começa no node root, onde é então passada
por node decision que requerem escolhas a
serem feitas com base nos atributos do trabalho.

(decision trees)
●
Essas escolhas dividem os dados entre ramos que indicam possíveis
resultados de uma decisão, descritos aqui como resultados sim ou
não, embora em alguns casos possa haver mais de duas
possibilidades.
●
No caso de uma decisão final poder ser tomada, a árvore é
terminada por nodes de folha (também conhecidos como nodes
terminais) que denotam a ação a ser tomada como resultado da série
de decisões. No caso de um modelo preditivo, os nodes folha
fornecem o resultado esperado, dada a série de eventos na árvore.

(decision trees)
Com isso em mente, alguns usos potenciais incluem:
Modelos de pontuação de crédito nos quais os critérios que
fazem com que um candidato seja rejeitado precisam ser
claramente documentados e livres de viés
Estudos de marketing do comportamento do cliente, como
satisfação ou rotatividade, que serão compartilhados com
agências de gestão ou de publicidade
Diagnóstico de condições médicas com base em medições
laboratoriais, sintomas ou taxa de progressão da doença

Dividir e conquistar
●
Árvores de decisão são construídas usando uma heurística
chamada particionamento recursivo. Essa abordagem
também é comumente conhecida como dividir e conquistar
porque divide os dados em subconjuntos, que são então
divididos repetidamente em subconjuntos ainda menores, e
assim por diante até que o processo pare quando o
algoritmo determina que os dados dentro dos subconjuntos
são suficientemente homogêneos. ou outro critério de
parada foi atendido.

Exemplo: estúdio de Hollywood
●
Imagine que você trabalha para um estúdio de Hollywood,
onde o seu papel é decidir se o estúdio deve seguir adiante
produzindo os roteiros apresentados por novos autores
promissores. Depois de voltar de férias, sua mesa está
repleta de propostas. Sem tempo para ler cada proposta de
capa a capa, você decide desenvolver um algoritmo de
árvore de decisão para prever se um filme em potencial
pode se enquadrar em uma das três categorias: Critical
Success, Mainstream Hit, or Box Office Bust.

●
Para construir a árvore de decisão, você recorre aos
arquivos do estúdio para examinar os fatores que
levaram ao sucesso e ao fracasso dos 30
lançamentos mais recentes da empresa. Você
rapidamente percebe uma relação entre o orçamento
de filmagem estimado do filme, o número de
celebridades da lista principal em fila para papéis
principais e o nível de sucesso.

credit.csvUsaremos como database

●
Animado com essa descoberta, você produz
um gráfico de dispersão para ilustrar o padrão:

●
Usando a estratégia de dividir e conquistar, podemos construir uma árvore
de decisão simples a partir desses dados. Primeiro, para criar o node root
da árvore, dividimos o recurso indicando o número de celebridades,
particionando os filmes em grupos com e sem um número significativo de
estrelas da lista A:

●
Em seguida, entre o grupo de filmes com um número maior de
celebridades, podemos fazer outra divisão entre filmes com e sem um
orçamento alto:

●
Neste momento, particionamos os dados em três grupos. O grupo
no canto superior esquerdo do diagrama é composto inteiramente
de filmes aclamados pela crítica. Este grupo distingue-se por um
elevado número de celebridades e um orçamento relativamente
baixo.
●
No canto superior direito, a maioria dos filmes são sucessos de
bilheteria com altos orçamentos e um grande número de
celebridades. O grupo final, que tem pouco poder de estrela, mas
orçamentos que variam de pequenos a grandes, contém os flops.

●
Se quiséssemos, poderíamos continuar a dividir e conquistar os dados
dividindo-os com base nos intervalos cada vez mais específicos de orçamento
e contagem de celebridades, até que cada um dos valores atualmente
classificados incorretamente residisse em sua própria partição minúscula e
fosse classificado corretamente. No entanto, não é aconselhável
sobrecarregar uma árvore de decisão dessa maneira.
●
Embora não haja nada que nos impeça de dividir os dados indefinidamente,
decisões excessivamente específicas nem sempre são mais generalizadas.
Evitaremos o problema do overfitting, interrompendo o algoritmo aqui, já que
mais de 80% dos exemplos em cada grupo são de uma única classe. Isso
forma a base do nosso critério de parada.

●
Nosso modelo para prever o sucesso futuro dos filmes pode
ser representado em uma árvore simples, conforme
mostrado no diagrama a seguir. Para avaliar um script, siga
as ramificações através de cada decisão até que o sucesso
ou falha do roteiro seja previsto. Em nenhum momento,
você será capaz de identificar as opções mais promissoras
entre o backlog de scripts e voltar a um trabalho mais
importante, como escrever um discurso de aceitação do
Oscar.

Pontos Fortes Pontos Fracos
●
Um classificador para todos os fins que funciona bem
na maioria dos problemas
●
Os modelos de árvore de decisão costumam ser
direcionados para divisões em recursos que
possuem um grande número de níveis
●
Processo de aprendizado altamente automático, que
pode manipular recursos numéricos ou nominais,
bem como dados ausentes
●
É fácil sobrecarregar ou ajustar o modelo
●
Exclui recursos sem importância ●
Pode ter problemas na modelagem de alguns
relacionamentos devido à dependência de divisões
paralelas ao eixo
●
Pode ser usado em conjuntos de dados pequenos e
grandes
●
Pequenas mudanças nos dados de treinamento
podem resultar em grandes mudanças na lógica de
decisão
●
Resulta em um modelo que pode ser interpretado
sem um background matemático (para árvores
relativamente pequenas)
●
Grandes árvores podem ser difíceis de interpretar e
as decisões tomadas podem parecer contraditórias
●
Mais eficiente que outros modelos complexos
Implementação de Decision Tree – C5.0 Algoritmo

●
Como os dados do mundo real contêm mais de
dois recursos, as árvores de decisão
rapidamente se tornam muito mais complexas
do que isso, com muito mais nodes,
ramificações e folhas.

Implementação de Decision Tree
– C5.0 Algoritimo
●
Algoritmo de Decision Tree - C5.0 usa entropia
●
Para a área de Teoria da Informação, a entropia é definida como sendo
uma forma de medir o grau médio de incerteza a respeito de fontes de
informação, o que consequentemente permite a quantificação da
informação presente que flui no sistema. Em termos simples, o conceito
de entropia se associa à idéia de que, quanto mais incerto é o resultado
de um experimento aleatório, maior é a informação que se obtém ao
observar a sua ocorrência.
●
Fonte:
https://pt.wikipedia.org/wiki/Entropia_da_informa%C3%A7%C3%A3o

– C5.0 Algoritimo
●
Algoritmo de Decision Tree - C5.0 usa
entropia
●
A entropia (S) é uma grandeza termodinâmica que mede a
desordem de um sistema e a espontaneidade dos processos
físicos.
●
A queda d’água em uma cachoeira é um processo natural e
espontâneo, no qual a entropia aumenta
●
A grandeza termodinâmica denominada entropia, simbolizada
pela letra S, está relacionada ao grau de organização de um
sistema. Quanto maior a desordem do sistema, maior a entropia.
https://brasilescola.uol.com.br/quimica/entropia.htm

– C5.0 Algoritimo
●
Algoritmo de Decision Tree - C5.0 usa entropia
●
Na noção matemática, a entropia é
especificada da seguinte forma:

– C5.0 Algoritimo
● Nesta fórmula, para um determinado segmento de dados (S), o termo c
refere-se ao número de níveis de classe e pi refere-se à proporção de
valores que se enquadram no nível de classe i. Por exemplo, suponha que
tenhamos uma partição de dados com duas classes: vermelho (60%) e
branco (40%). Podemos calcular a entropia da seguinte forma:

– C5.0 Algoritimo
●
Podemos examinar a entropia para todos os possíveis arranjos de duas
classes. Se sabemos que a proporção de exemplos em uma classe é x,
então a proporção na outra classe é (1 - x). Usando o curve()function,
podemos então plotar a entropia para todos os valores possíveis de x:

– C5.0 Algoritimo
● Conforme ilustrado pelo pico de entropia em x = 0,50, uma divisão de 50-
50 resulta em entropia máxima. Como uma classe cada vez mais domina a
outra, a entropia reduz-se a zero.

– C5.0 Algoritimo
●
Para usar a entropia para determinar o recurso ideal para dividir, o algoritmo
calcula a mudança na homogeneidade que resultaria de uma divisão em
cada recurso possível, que é uma medida conhecida como ganho de
informação. O ganho de informação para uma característica F é calculado
como a diferença entre a entropia no segmento antes da divisão (S1) e as
partições resultantes da divisão (S2):

– C5.0 Algoritimo
●
Uma complicação é que depois de uma divisão, os dados são divididos em
mais de uma partição. Portanto, a função para calcular Entropia (S2) precisa
considerar a entropia total em todas as partições. Ele faz isso pesando a
entropia de cada partição pela proporção de registros que caem na partição.
Isso pode ser indicado em uma fórmula como:

– C5.0 Algoritimo
●
Em termos simples, a entropia total resultante de uma divisão é a soma da
entropia de cada uma das n partições ponderadas pela proporção de
exemplos que caem na partição.(wi).
●
Quanto maior o ganho de informação, melhor será a criação de grupos
homogêneos após uma divisão nesse recurso. Se o ganho de informação
for zero, não haverá redução na entropia para divisão neste recurso. Por
outro lado, o ganho máximo de informação é igual à entropia anterior à
divisão. Isso implicaria que a entropia após a divisão é zero, o que significa
que a divisão resulta em grupos completamente homogêneos.

– C5.0 Algoritimo
●
mais de uma partição. Portanto, a função para calcular Entropia(S2) precisa
considerar a entropia total em todas as partições. Ele faz isso pesando a
entropia de cada partição pela proporção de registros que caem na partição.
Isso pode ser indicado em uma fórmula como:

Identificando Empréstimos Bancários
Arriscados Com C5.0 decision trees
●
A crise financeira global de 2007-2008 destacou a importância da transparência e do
rigor nas práticas bancárias. Como a disponibilidade de crédito era limitada, os bancos
apertaram seus sistemas de empréstimos e recorreram ao aprendizado de máquina
para identificar com mais precisão os empréstimos arriscados.
●
As árvores de decisão são amplamente utilizadas no setor bancário devido à sua alta
precisão e capacidade de formular um modelo estatístico em linguagem simples.
Como as organizações governamentais em muitos países monitoram cuidadosamente
as práticas de empréstimo, os executivos devem ser capazes de explicar por que um
candidato foi rejeitado por um empréstimo enquanto os outros foram aprovados.
●
Essas informações também são úteis para clientes que desejam determinar por que o
rating de crédito é insatisfatório.

●
É provável que modelos automatizados de pontuação de crédito sejam
empregados para aprovar instantaneamente aplicativos de crédito no
telefone e na Web. Nesta seção, desenvolveremos um modelo de
aprovação de crédito simples usando árvores de decisão C5.0.
●
Também veremos como os resultados do modelo podem ser ajustados para
minimizar os erros que resultam em perdas financeiras para a instituição.

●
Etapa 1 - coleta de dados
●
A ideia por trás do nosso modelo de crédito é identificar fatores que são preditivos de maior risco
de inadimplência. Portanto, precisamos obter dados sobre um grande número de empréstimos
bancários passados e se o empréstimo entrou em default, bem como informações sobre o
solicitante.
●
Os dados com essas características estão disponíveis em um conjunto de dados doados ao UCI
Machine Learning Data Repository (http://archive.ics.uci.edu/ml) por Hans Hofmann, da
Universidade de Hamburgo. O conjunto de dados contém informações sobre empréstimos obtidos
de uma agência de crédito na Alemanha.
●
O conjunto de dados de crédito inclui 1.000 exemplos de empréstimos, além de um conjunto de
características numéricas e nominais indicando as características do empréstimo e do solicitante
do empréstimo. Uma variável de classe indica se o empréstimo entrou em default. Vamos ver se
podemos determinar quaisquer padrões que prevejam esse resultado.

●
Passo 2 - explorando e preparando os dados
●
Como fizemos anteriormente, vamos importar dados usando o
read.csv() function. Nós vamos ignorar o stringsAsFactors
opção e, portanto, use o valor padrão de TRUE , como a maioria dos
recursos nos dados são nominais:

●
Passo 2 - explorando e preparando os dados
As primeiras linhas de saída do str() function são como segue:

●
Vemos as esperadas 1.000 observações e 17 características, que são uma
combinação de tipos de dados de fator e número inteiro.
● Vamos dar uma olhada no table() saída para alguns recursos de
empréstimo que parecem prever um padrão. O saldo da conta corrente e da
poupança do candidato é registrado como variáveis categóricas:

●
O saldo da conta corrente e da poupança pode ser um importante indicador
do status de inadimplência. Observe que, como os dados do empréstimo
foram obtidos da Alemanha, a moeda é registrada no Deutsche Marks (DM).
Algumas das características do empréstimo são numéricas, como a duração
e o valor do crédito solicitado:

●
Os montantes do empréstimo variaram de 250 DM a 18.420 DM em
mandatos de 4 a 72 meses com uma duração mediana de 18 meses e um
montante de 2.320 DM.
●
O vetor padrão indica se o solicitante do empréstimo não conseguiu cumprir
os termos de pagamento acordados e entrou em default. Um total de 30%
dos empréstimos neste conjunto de dados entrou em default:

●
Uma alta taxa de inadimplência é indesejável para um banco, porque
significa que é improvável que o banco recupere totalmente seu
investimento.
●
Se tivermos sucesso, nosso modelo identificará os candidatos que estão em
alto risco de inadimplência, permitindo que o banco recuse solicitações de
crédito.

●
Preparação de dados - criando treinamento aleatório e conjuntos de dados de teste
Como fizemos nos slides anteriores, dividiremos nossos dados em duas partes:
– um conjunto de dados de treinamento para construir a árvore de decisão e um conjunto de dados
de teste para avaliar o desempenho do modelo em novos dados. Usaremos 90% dos dados para
treinamento e 10% para testes, o que nos fornecerá 100 registros para simular novos candidatos.
– Como os slides anteriores usavam dados que haviam sido classificados em uma ordem aleatória,
simplesmente dividíamos o conjunto de dados em duas partes, obtendo os primeiros 90% de
registros para treinamento e os 10% restantes para testes. Em contraste, o conjunto de dados de
crédito não é ordenado aleatoriamente, tornando a abordagem anterior imprudente. Suponha que
o banco tenha classificado os dados pelo valor do empréstimo, com os maiores empréstimos no
final do arquivo. Se usássemos os primeiros 90% para treinamento e os 10% restantes para
testes, estaríamos treinando um modelo apenas sobre os pequenos empréstimos e testando o
modelo nos grandes empréstimos. Obviamente, isso pode ser problemático.

●
Preparação de dados - criando treinamento aleatório e conjuntos de
dados de teste
Os comandos a seguir usam a sample() function para selecionar 900 valores
aleatoriamente da sequência de inteiros de 1 a 1000. Observe que a set.seed()
function usa o valor arbitrário 123. Omitir esta semente fará com que sua divisão
entre treinamento e teste seja diferente daquela mostrada no restante deste slide:
Como esperado, o
objeto train_sample
resultante é um vetor
de 900 inteiros
aleatórios:

●
dados de teste
Ao usar esse vetor para selecionar linhas dos dados de crédito, podemos
dividi-lo em 90% de treinamento e 10% de conjuntos de dados de teste que
desejamos. Lembre-se de que o operador de traço usado na seleção dos
registros de teste informa R para selecionar registros que não estão nas
linhas especificadas; em outras palavras, os dados de teste incluem apenas
as linhas que não estão na amostra de treinamento.

●
dados de teste
Se tudo corresse bem, deveríamos ter cerca de 30% dos empréstimos
inadimplentes em cada um dos conjuntos de dados:

●
Etapa 3 - treinando um modelo nos dados
Usaremos o algoritmo C5.0 no pacote C50 para treinar nosso modelo de
árvore de decisão. Se ainda não o fez, instale o pacote com
install.packages("C50") e carregá-lo para sua sessão R, usando
library(C50).

●
Na primeira iteração do nosso modelo de aprovação de crédito, usaremos a
configuração C5.0 padrão, conforme mostrado no código a seguir. A 17ª
coluna em credit_train é a variável de classe padrão, portanto,
precisamos excluí-la do quadro de dados de treinamento, mas fornecê-la
como o vetor de fator de destino para classificação:

●
O objeto credit_model agora contém uma árvore de decisão C5.0.
Podemos ver alguns dados básicos sobre a árvore digitando seu nome:

●
O texto anterior mostra alguns fatos simples sobre a árvore, incluindo a
chamada de função que a gerou, o número de recursos (preditores
rotulados) e exemplos (amostras rotuladas) usados para cultivar a árvore.
Também está listado o tamanho da árvore de 57, que indica que a árvore
tem 57 decisões de profundidade - um pouco maior do que as árvores de
exemplo que consideramos até agora!
Para ver as decisões da árvore, podemos chamar a função summary() no
modelo:

●

●
A saída anterior mostra algumas das primeiras ramificações na árvore de decisão.
As três primeiras linhas podem ser representadas em linguagem simples como:
1) Se o saldo da conta corrente for desconhecido ou maior que 200 DM, então,
classifique como "não provável a inadimplência".
2) Caso contrário, se o saldo da conta corrente for menor que zero DM ou entre um e
200 DM.
3) E o histórico de crédito é perfeito ou muito bom, então classifique como "provável
para o padrão".

●
●
Os números entre parênteses indicam o número de exemplos que atendem
aos critérios para essa decisão e o número classificado incorretamente pela
decisão. Por exemplo, na primeira linha, 412/50 indica que dos 412
exemplos que chegaram à decisão, 50 foram incorretamente classificados
como não propensos a default.
●
Em outras palavras, 50 requerentes, na verdade, entraram em default,
apesar da previsão do modelo em contrário.

●
Após a árvore, a saída de resumo (credit_model) exibe uma matriz de
confusão, que é uma tabulação cruzada que indica os registros
classificados incorretamente do modelo nos dados de treinamento:

●
Os erros de saída apontam que o modelo classificou corretamente todos,
exceto 133 das 900 instâncias de treinamento, com uma taxa de erro de 14,8%.
Um total de 35 valores reais não foram incorretamente classificados como sim
(falsos positivos), enquanto 98 valores sim foram erroneamente classificados
como não (falsos negativos).
As árvores de decisão são conhecidas por terem uma tendência a ajustar o
modelo aos dados de treinamento. Por esse motivo, a taxa de erro informada
nos dados de treinamento pode ser excessivamente otimista e é especialmente
importante avaliar as árvores de decisão em um conjunto de dados de teste.

●
Etapa 4 - avaliação do desempenho do modelo
Para aplicar nossa árvore de decisão ao conjunto de dados de teste,
usamos a predict()function, conforme mostrado na linha de código a
seguir:

●
Isso cria um vetor de valores de classe previstos, que podemos comparar
aos valores reais da classe usando a CrossTable()function no pacote
gmodels. Definir os parâmetros prop.c e prop.r como FALSE remove as
porcentagens de coluna e linha da tabela. A porcentagem restante
(prop.t) indica a proporção de registros na célula fora do número total de
registros:
No freebsd num console, instale antes a lib cran para usar o gmodels:
pkg install R-cran-gmodels-2.18.1_1

●
Isso resulta na tabela a seguir:

●
Passo 5 - melhorando o desempenho do modelo
A taxa de erro do nosso modelo provavelmente será muito alta para implantá-lo em um
aplicativo de pontuação de crédito em tempo real. Na verdade, se o modelo tivesse
previsto "nenhum defeito" para cada caso de teste, ele estaria correto em 67% das
vezes - um resultado não muito pior que o do nosso modelo, mas exigindo muito
menos esforço! Predizer padrões de empréstimos a partir de 900 exemplos parece ser
um problema desafiador.
Para piorar as coisas, nosso modelo teve um desempenho especialmente baixo na
identificação de candidatos que não assumem seus empréstimos. Felizmente, existem
algumas maneiras simples de ajustar o algoritmo C5.0 que podem ajudar a melhorar o
desempenho do modelo, tanto no geral quanto no tipo de erros mais dispendiosos.

●
Aumentando a precisão das árvores de decisão
– Uma maneira pela qual o algoritmo C5.0 melhorou o algoritmo C4.5 foi
através da adição de boosting adaptativo.
– Este é um processo no qual muitas árvores de decisão são construídas
e as árvores votam na melhor classe para cada exemplo.

●
A C5.0()function facilita a adição de reforço à nossa árvore de decisão C5.0.
Nós simplesmente precisamos adicionar um parâmetro de avaliação adicional
indicando o número de árvores de decisão separadas para usar na equipe
impulsionada. O parâmetro de tentativas define um limite superior; o algoritmo irá
parar de adicionar árvores se reconhecer que testes adicionais não parecem estar
melhorando a precisão. Começaremos com 10 testes, um número que se tornou o
padrão de fato, já que a pesquisa sugere que isso reduz as taxas de erro nos dados
de teste em cerca de 25%:

●
Ao examinar o modelo resultante, podemos ver que algumas linhas
adicionais foram adicionadas, indicando as mudanças:

●
Nas 10 iterações, o tamanho da nossa árvore diminuiu. Se você quiser,
você pode ver todas as 10 árvores digitando o resumo (credit_boost10)
no prompt de comando. Também lista o desempenho do modelo nos dados
de treinamento:

●
O classificador fez 34 erros em 900 exemplos de treinamento para uma taxa
de erro de 3,8%. Isso é uma grande melhoria em relação à taxa de erro de
treinamento de 13,9 por cento que notamos antes de adicionar melhorias!
No entanto, resta saber se vemos uma melhora semelhante nos dados do
teste. Vamos dar uma olhada:

●
Preparação de dados - criando treinamento aleatório e conjuntos de dados de teste
Vamos resolver esse problema usando uma amostra aleatória dos dados de crédito para
treinamento. Uma amostra aleatória é simplesmente um processo que seleciona um
subconjunto de registros aleatoriamente. Em R, a sample()function é usada para
realizar amostragem aleatória. No entanto, antes de colocá-lo em ação, uma prática
comum é definir um valor de semente, que faz com que o processo de randomização siga
uma sequência que pode ser replicada mais tarde, se desejado. Pode parecer que isso
anula o propósito de gerar números aleatórios, mas há uma boa razão para fazê-lo dessa
maneira.
● Fornecer um valor de semente por meio da set.seed()function garante que, se a
análise for repetida no futuro, um resultado idêntico seja obtido.

●
Entendendo as regras de classificação
As regras de classificação representam o conhecimento na forma de
instruções lógicas if-else que atribuem uma classe a exemplos não
rotulados. Eles são especificados em termos de um antecedente e um
consequente; estes formam uma hipótese afirmando que "se isso acontecer,
então isso acontece". Uma regra simples pode afirmar: "se o disco rígido
estiver fazendo um clique, então está prestes a falhar". O antecedente
compreende certas combinações de valores de recursos, enquanto o
consequente especifica o valor de classe a ser atribuído quando as
condições da regra são atendidas.

– C5.0 Algoritimo
●
mais de uma partição.
● Portanto, a função para calcular Entropia(S2) precisa considerar a entropia
total em todas as partições. Ele faz isso pesando a entropia de cada
partição pela proporção de registros que caem na partição. Isso pode ser
indicado em uma fórmula como:

●
Regras de aprendizagem são frequentemente usados de maneira semelhante
aos aprendizes da árvore de decisão. Como árvores de decisão, elas podem ser
usadas para aplicativos que geram conhecimento para ações futuras, como:
– Identificando condições que levam a uma falha de hardware em dispositivos
mecânicos
– Descrever as principais características de grupos de pessoas para
segmentação de clientes
– Encontrar condições que antecedem grandes quedas ou aumentos nos
preços das ações no mercado de ações

●
Por outro lado, os aprendizes de regras oferecem algumas vantagens distintas sobre as
árvores para algumas tarefas. Ao contrário de uma árvore, que deve ser aplicada de
cima para baixo através de uma série de decisões, as regras são proposições que
podem ser lidas de maneira muito semelhante a uma declaração de fato. Além disso,
por razões que serão discutidas mais adiante, os resultados de um aluno de regras
podem ser mais simples, diretos e mais fáceis de entender do que uma árvore de
decisão construída sobre os mesmos dados.
Os aprendizes de regras são geralmente aplicados a problemas em que os recursos
são primariamente ou totalmente nominais. Eles fazem bem em identificar eventos
raros, mesmo que o evento raro ocorra apenas para uma interação muito específica
entre os valores dos recursos.

●
Conclusão
– Como você pode ver, as regras podem ser geradas usando as árvores
de decisão. Então, por que se preocupar com um grupo separado de
algoritmos de aprendizado de regras? A razão é que as árvores de
decisão trazem um conjunto particular de vieses para a tarefa que um
aprendiz de regra evita, identificando as regras diretamente.
– Os aprendizes de regras são geralmente aplicados a problemas em que
os recursos são primariamente ou totalmente nominais. Eles fazem bem
em identificar eventos raros, mesmo que o evento raro ocorra apenas
para uma interação muito específica entre os valores dos recursos.

Tensorflow on FreeBSD
●
https://github.com/amutu/tf-freebsd-pkg
●
https://www.freebsdnews.com/2016/06/09/tensorflow-on-freebsd/
●
http://qml.610t.org/FreeBSD/tensorflow.html
●
https://www.reddit.com/r/freebsd/comments/bdxlbo/
tensorflow_on_freebsd_tearing_my_hair_out/
●
https://www.freshports.org/science/py-tensorflow/
●
https://news.ycombinator.com/item?id=11827940
●
http://freebsd.1045724.x6.nabble.com/Re-Tensorflow-port-td6226536.html
●
https://github.com/higepon/tensorflow_seq2seq_chatbot/wiki/Install-tensorflow-FreeBSD
●
https://forums.freebsd.org/threads/howto-install-tensorflow-on-freebsd.59479/

Referências (1/2)
– FreeBSD 11.2 x86_64
– Adaptação do Ebook Machine Learning with R - Second Edition
– https://www.jeremyjordan.me/ml-projects-guide/
– https://www.rstudio.com/
– http://www.tensorflow.org/
– http://deeplearning.net/software/theano/
– https://dask.org/
– http://www.numpy.org/
– http://pandas.pydata.org/
– http://numba.pydata.org/
https://www.amazon.com.br/Machine-Learning-English-Brett-Lantz-ebook/dp/
B00G9581JM?tag=goog0ef-
20&smid=A18CNA8NWQSYHH&ascsubtag=go_1686871380_65779544836_32
7582895583_aud-580930410671:pla-778262135724_c_

Referências (2/2)
– http://matplotlib.org/
– http://bokeh.pydata.org/
– http://datashader.org/
– http://holoviews.org/
– https://scikit-learn.org/stable/
– https://repo.anaconda.com/pkgs/r/
– https://docs.continuum.io/anaconda/packages/r-language-pkg-docs/
– https://repo.anaconda.com/pkgs/r/
– https://www.freebsd.org

Data Science e AI usando
Freebsd
25/05/2019 – Seropédica, Universidade Federal Rural
do Rio de Janeiro, RJ – Brasil (45 min.)
Mauro Risonho de Paula Assumpção
mauro.risonho*noSPAM*gmail.com
https://twitter.com/firebitsbr
https://www.linkedin.com/in/firebitsbr/
Perguntas?

Data Science e AI no FreeBSD

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Data Science e AI no FreeBSD

Semelhante a Data Science e AI no FreeBSD (20)

Mais de Mauro Risonho de Paula Assumpcao

Mais de Mauro Risonho de Paula Assumpcao (20)

Data Science e AI no FreeBSD