Ciência de Dados com Python: Bases, Ferramentas e Aplicações

#Python

Neste artigo você vai encontrar:

Introdução
Visão geral da Ciência de Dados
Python para Ciência de Dados
Análise e Modelagem de Dados
Big Data e Python
Conclusão
Referências

1. Introdução

Neste artigo vamos viajar pelo maravilhoso universo da ciência de dados com python, vamos conhecer as definição e conceitos fundamentais da ciência de dados, além de verificar processos inerentes à ela como coleta, limpeza, análise e interpretação de dados.

Vamos entender o papel de um cientista de dados e as habilidades necessárias para desempenhar este papel com maestria. Também vamos mergulhar em exemplos práticos que vão nos dar um visão geral do Python e da sua relevância na ciência de dados.

Com foco nas bibliotecas Python mais famosas como NumPy, Pandas, Matplotlib e Seaborn. Vamos poder ter um pequeno gostinho do trabalho de manipulação e limpeza de dados com Pandas, e visualização de dados com Matplotlib e Seaborn.

Também vamos entender melhor alguns conceitos de cálculos estatísticos e sumarização de dados e vamos ver um exemplo prático de aprendizado de máquina com scikit-learn, para poder ter uma noção mais técnica de alguns etapas do processo.

E claro não podia faltar, depois que nossas mentes já estiverem cheias de conhecimento, vamos entender melhor a Big Data e seus desafios, para depois aprender um pouco sobre o processamento paralelo e distribuído e por fim dar uma pequena olhada numa ferramenta popular de big data, o Apache Spark.

2. Visão geral da Ciência de Dados

Num mundo cada vez mais conectado à ciência de dados se torna cada vez mais necessária, e profissionais que à dominam são essenciais. Coletar, análisar e interpretar dados para obter insights e tomar decisões é crucial.

Estudar dados e algoritmos para a resolução de problemas pode parecer uma tarefa difícil e de fato pode ser complicado no começo, mas linguagens de programação como python facilitam muito o trabalho.

Definição e conceitos fundamentais da ciência de dados.

A ciência de dados (ou data science) é uma área de estudo abrangente e multidisciplinar, que compreende dados, algoritmos e tecnologias com capacidade de extrair informações valiosas de dados estruturados e não estruturados. [1]

Dados estruturados:

São informações que possuem uma organização com um padrão fixo e constante, seguindo uma estrtura mais rígida.

Dados não estruturados:

São informações que não possuem um modelo de dados predefinido ou não estão organizados de forma predefinida.

A extração de informações valiosas vai permitir que se encontre respostas para problemas e situações complexas, sendo possível identificar tendências e gerar insights através de diversos tipos de análises.

O processo de ciência de dados: coleta, limpeza, análise e interpretação de dados

Quando um profissional da área de ciência de dados desempenha seu papel ele pode seguir algumas etapas básicas:

Coleta de dados: A primeira etapa é obter os dados necessários para a análise. Isso pode envolver a extração de dados de bancos de dados, arquivos CSV, APIs da web ou outras fontes de dados.
Limpeza e pré-processamento de dados: É necessário realizar tarefas de limpeza, como remover valores ausentes ou inconsistentes, tratar dados duplicados e normalizar os dados, se necessário.
Exploração e visualização de dados: Isso pode ser feito por meio de gráficos, estatísticas descritivas e técnicas de visualização de dados, utilizando bibliotecas populares como Matplotlib, Seaborn ou Plotly.
Construção de modelos: Aqui se utiliza técnicas como regressão, classificação, agrupamento, árvores de decisão, redes neurais e muito mais. Bibliotecas como NumPy, Pandas e scikit-learn são frequentemente utilizadas para essa etapa.
Avaliação de modelos: Após a construção dos modelos, é necessário avaliá-los. Isso pode ser feito por meio de métricas de desempenho apropriadas para o tipo de problema em questão, como precisão, recall, F1-score, erro médio quadrático, etc.
Implantação e visualização de resultados: Com o modelo pronto é hora de implantá-lo em produção para realizar previsões ou tomar decisões com base nos dados. A visualização dos resultados também desempenha um papel importante para comunicar as descobertas aos interessados.

Papel do cientista de dados e habilidades necessárias

O cientista de dados possui conhecimentos e experiência em ciência da computação, estatística e matemática, com uma atuação mais amplas na área de dados. Suas responsabilidades são bastante focadas em analisar grandes volumes de dados (big data) e obter insights. [1]

Desta forma podemos perceber que um cientista de dados precisa ter um conhecimento bastante amplo e conciso, sendo capaz de trabalhar com linguagens como Python ou R, assim como SQL.

Este profissional deve ser capaz de coletar, limpar e análisar grandes volumes de dados. Dominando diversas áreas da ciência da computação, estatísticas e matemática, aplicando tudo isso para descobrir soluções e resolver problemas de negócios.

3. Python para Ciência de Dados

Com python um cientista de dados pode desempenhar muito do seu papel, explorando, visualizando e manipulando grandes volumes de dados. Dominar python se tornou um habilidade muito importante para quem deseja se torna um cientista de dados.

Existem muitas bibliotecas Python populares, incluindo NumPy, Pandas, Matplotlib, Seaborn, Scikit-learn, TensorFlow e PyTorch, entre outras. Essas bibliotecas fornecem uma ampla gama de funcionalidades para análise, manipulação, visualização e construção de modelos de dados.

Desta forma python é para ciência de dados um grande aliado, com sua facilidade de uso, vasta comunidade de desenvolvedores e ampla gama de bibliotecas especializadas, python se tornou o pontapé inicial de quem deseja entrar nesta área.

Visão geral do Python e sua relevância na ciência de dados

Python é uma linguagem de programação de alto nível, interpretada de script, imperativa, orientada a objetos, funcional, de tipagem dinâmica e forte. Foi lançada por Guido van Rossum em 1991. [2]

Python possui tipagem dinâmica e uma de suas principais características é permitir a fácil leitura do código e exigir poucas linhas de código se comparado ao mesmo programa em outras linguagens. [2]

Este linguagem de programação evolui bastante nos últimos anos e hoje se tornou uma grande facilitadora na área de ciência de dados, permitindo que se manipule, colete e análise dados de formas bem definidas e otimizadas.

Bibliotecas essenciais: NumPy, Pandas, Matplotlib e Seaborn

O que torna python super necessário e útil no trabalho de coletar, análisar e interpretar dados são suas bibliotecas, que estão evoluindo muito e aumentando a eficiência do processo.

As bibliotecas NumPy, Pandas, Matplotlib e Seaborn são de extrema importância e muito usadas pelos cientistas de dados, por serem confiáveis e cheias de recursos elas são as queridinhas quando o assunto é python e ciência de dados.

NumPy (Numerical Python) é utilizada para realizar cálculos numéricos e operações eficientes com arrays multidimensionais. Ela fornece uma ampla gama de funções e ferramentas para lidar com dados numéricos.

Pandas é uma biblioteca de alto desempenho que fornece suporte para estruturas de dados e ferramentas de análise de dados. Pandas é como um aplicativo de planilha para Python e fornece funcionalidades fáceis de usar para tabelas de dados. [3]

Matlplotlib é um módulo Python para visualização de dados. Matplotlib permite que você crie facilmente gráfico, histogramas e outras figuras profissionais. Usando Matplotlib você pode personalizar cada aspecto de uma figura. [3]

Seaborn é uma biblioteca para visualização de dados e oferece diversas ferramentas para criar gráficos elegantes e informativos. Seaborn é uma biblioteca de visualização de dados em Python baseada em Matplotlib.

Manipulação e limpeza de dados com Pandas.

Uma ferramenta poderosa, que seria o segundo passo na busca para se tornar um cientista de dados, depois de dar o pontapé inicial e dominar Python, com certeza o próximo passo é dominar pandas.

Sendo uma ferramenta de análise e manipulação de dados de código aberto rápida, poderosa, flexível e fácil de usar, pandas é a primeira biblioteca que devemos dominar, sendo perfeita para se trabalhar com dados tabulares, como dados armazenados em planilhas ou bancos de dados.

Estruturas de dados do pandas

Em pandas, uma tabela de dados é chamada de DataFrame. Existe 2 tipos de estruturas de dados, a Seires é unidimensional, muito similar com uma lista em Python, representa cada coluna de um DataFrame.

E o segundo tipo são os Dataframes um abstração de uma estrutura tabular para armazenar dados, comparados a um dicionário em Python onde a chave é o nome da coluna e o valor é um objeto Series.

Para melhor entendimento vamos fazer uma análise do vídeo [4], este video tem uma aula prática muito legal para compreender melhor o papel do pandas no mundo da ciência de dados python.

Utilizando o Colab para executar Python direto no navegador, o professor do vídeo começa criando um novo notebook: New python 3 notebook.

Nesta aula será utilizado um conjunto de dados que pode ser encontrado aqui: movies.csv

Chegou o momento de ver um pouco de código e entender o papel do pandas no universo da ciência de dados, vamos usar este conjunto de dados para ter um pequeno gostinho do dia a dia de um cientista de dados.

A primeira coisa é importar o pandas e dar um apelido para ele:

import pandas as pd

Depois vamos ler o CSV daquele link e conferir as linhas superiores do quadro:

uri = “movies.csv”
filmes = pd.read_csv(uri) #DataFrame
filmes.head() #linhas superiores

Agora chegou o momento de modificar esses dados para um melhor entendimento do profissional que esta trabalhando com eles, neste caso, as colunas de nossa tabela estão em inglês, mas podemos modificar elas para melhor compreensão:

filmes.columns = [“filmeId”, “titulo”, “generos”]
filmes.head()

Agora vamos consumir os dados de outro CSV, as notas dos filmes, que esta aqui: ratings.csv

uri = “http://ratings.csv”
notas = pd.read_csv(uri) #DataFrame
notas.read() #De um Play
notas.columns = [“usuarioId”, “filmeId”, “nota”, “momento”]
notas.read() #De um Play

Já coletamos os dados e agora vamos ir para próxima etapa e começar a análisar e interpretar esses dados, por exemplo vamos descobrir qual é a maior nota e a menor nota dada para esses filmes:

notas[“nota”].head() # Series
notas[“nota”].unique() # Valores únicos

Com isso podemos dar o play e verificar os valores únicos, desta forma conseguimos descobrir as notas vão de 0.5 até 5, ou seja a maior nota é 5 e a menor é 0.5, mas podemos ir além e verificar a média:

notas[“nota”].mean()

Ainda podemos conseguir que o pandas descreva o DataFrame inteiro, conseguindo assim varias medidas estatísticas tradicionais:

notas.describe()

Também foi levantada uma questão muito importante na parte de estatísticas, sobre média, ele deixou claro que meio e média não é a mesma coisa, isso porque dependendo dos dados que você está analisando pode se haver a necessidade de sair daquela conta básica da média.

Como exemplo foi mostrado que ao analisar os dados dos salários de várias pessoas, pois se temos um grupo de pessoas onde uma ganha 1000, outra 3000, outra 3000 e outra 700000, ao fazer o cáculo da média podemos obter uma informação que não passa muita verdade.

Fazendo a conta da média para esses salários temos:

(1000+3000+3000+700000)/4 = 176750

Percebe como esta informação é enganosa? Imagine que você pesquisa sobre uma empresa como essa que tem 4 funcionários, usa o pandas e descobre a média dos salários, assim temos que nesta empresa a média dos salários é de 176.750.

Aqui conseguimos perceber a importância do domínio das estatísticas e da matemática na área de ciência de dados, pois é preciso se manter atento a pequenos detalhes, na hora da análise, que muitas vezes passam despercebidos, nos levando a cometer erros sérios.

Neste caso, se nossos dados fossem de salário, não estamos interessados na média e sim na mediana (50%), que é uma outra maneira de medir o meio, ela indica qual é o valor que está exatamente no meio de um conjunto de dados, quando eles estão ordenados.

Limpeza de dados com pandas

Um profissional da área de ciência de dados lida com uma grande quantidade de dados e muitas vezes esses dados estão sujos, isso significa que esses dados podem ter inconstâncias, estar incorretos, incompletos, duplicados, formatados incorretamente ou até mesmo sejam irrelevantes.

Por isso vamos dar uma olhada no conteúdo da referência [5] e fazer um pequeno passeio sobre a limpeza de dados com pandas. Uma limpeza correta é de extrema importância para que possamos fazer uma análise completa e confiável.

Diga comigo: Coletar, Limpar e Análisar

Primeiro vamos importar as bibliotecas necessárias:

import pandas as pd #para ler, visualizar e printar infos do df
import matplotlib.pyplot as plt #para construir e customizar gráficos
import seaborn as sns #para visualizar uns gráficos
import numpy as np #numpy porque é sempre bom importar numpy né

Aqui vamos precisar do arquivo que pode ser baixado aqui:

df = pd.readcsv('spotify.csv', indexcol=0) #Aqui estamos definindo que o arquivo ficará guardado no nome “df”
df.sortvalues('songpopularity', ascending=False, inplace=True) #Deixa as músicas em ordem de popularidade
df.head(15) #aqui definimos que as primeiras 15 linhas aparecerão

Uma vez baixado podemos começar a análisar como fazer uma boa limpeza usando pandas. Para começar vamos ver algumas funções que vamos usar em toda nossa análise:

df.head() #para visualizar o começo do seu dataframe
df.info() #para obter informações do seu dataframe
df.describe() #para ver um descrição mais detalhada

Essas funções são muito importantes justamente porque servem como uma bússola para nos orientar, ou seja, para sabermos se estamos ou não indo para o caminho certo na limpeza. [5]

Vamos começar removendo duplicatas do nosso DataFrame notas:

duplicados = df[df.duplicated(keep='first')]
print(duplicados)

Este DataFrame está bem poluído, cheio de duplicatas, que não são necessárias, então podemos remover-las com apenas uma linha de código, mas precisamos fazer isso com o argumento keep = ’first’, que mantém a primeira ocorrência da repetição para não desperdiçarmos dados:

df.drop_duplicates(keep='first', inplace=True)

Outra coisa importante são as inconsistências, como por exemplo unidades de medidas inadequadas ‘mol/L’ E ‘kg’. Para isso vamos usar o código abaixo:

def remove_units (DataFrame, columns, what):
 for col in columns:
     DataFrame[col] = DataFrame[col].str.strip(what)

remove_units(df, ['acousticness', 'danceability'], 'mol/L')
removeunits(df, ['songduration_ms', 'acousticness'], 'kg')

Em seguida foi usado o np.nan para declarar valores faltantes nos dados, o NaN, que significa Not a Number, é um valor especial definido no numpy que pode decodificar um valor faltante, mas ainda assim ser lido como um numeral, pois é definido como float. [5]

df = df.replace(['nao_sei'], np.nan)
df['key'] = df['key'].replace([0.177], np.nan)
df['audiomode'] = df['audiomode'].replace(['0.105'], np.nan)
df['speechiness'] = df['speechiness'].replace(['0.nao_sei'], np.nan)
df['timesignature' = df['timesignature'].replace(['0.7', '2800000000'], np.nan)

Esses dados foram achados graças ao conhecimento baseado na experiência de um cientista de dados. por isso experiência e prática são muito importantes, por exemplo ao plotar um gráfico podemos perceber dados destoante dos outros.

Sendo necessário ter conhecimento sobre os dados em que se está trabalhando e qual o objetivo da análise desses dados, além de aliar outros conhecimentos como um simples entendimento das unidades de medidas para decidir o que fazer.

Outra questão muito importante são os tipos das nossas variáveis, pode acontecer de colunas que deveriam ter apenas algum tipo específico de dados estarem armazenadas com o tipo de variável incorreta.

Nossas colunas devem estar com os dtypes condizentes, o que claramente não é o caso do nosso Dataframe. A maioria das nossas informações numéricas estão sendo tratadas como strings e não queremos isso.

numericalcols = ['songdurationms', 'acousticness', 'danceability', 'energy', 'instrumentalness', 'liveness', 'loudness', 'speechiness', 'tempo', 'audiovalence']
categoricalcols = ['songpopularity', 'key', 'audiomode', 'timesignature']

def to_type(DataFrame, columns, type):
  for col in columns:
      DataFrame[col] = DataFrame[col].astype(type)

totype(df, numericalcols, 'float')
totype(df, categoricalcols, 'category')

Assim convertemos as colunas especificadas no DataFrame para o tipo de dados desejado. Podemos checar se deu tudo certo usando a função info() novamente e verificando os data types.

Agora chegou a hora de aplicar conhecimentos em matemática e estatísticas, se lembra do que ja foi falado aqui sobre a questão dos salários, lá temos um valor que destoa muito dos outros, que era o 700000, esse é um outliers, que são dados que fogem muito do nosso padrão.

Em suma, outliers são valores que desequilibram o dataframe e comprometem a capacidade de extrair insights com base nos dados. [5]

Para um cientista de dados encontrar esses valores destoantes, ele pode usar algumas técnicas, como pesquisa, sendo crucial conhecer a história por trás dos dados, e através de métodos estatísticos.

def excluioutliers(DataFrame, colname):
  intervalo = 2.7*DataFrame[col_name].std()

  media = DataFrame[col_name].mean()

  DataFrame.loc[df[col_name] < (media - intervalo), col_name] = np.nan

  DataFrame.loc[df[col_name] > (media + intervalo), col_name] = np.nan

Esta função calcula um intervalo de tolerância baseado no desvio padrão e na média da coluna especificada e substitui os valores que estão fora desse intervalo por NaN.

O valor 2.7 é usado como um fator multiplicativo padrão para calcular a largura do intervalo de tolerância na identificação de outliers. No entanto, é importante observar que esse valor pode variar dependendo do contexto e dos critérios específicos adotados.

Essa abordagem é uma forma comum de lidar com outliers, removendo-os ou marcando-os como dados ausentes para evitar que afetem análises e modelos estatísticos posteriores.

Chegou a hora de separar nossas colunas numéricas e remover os outliers delas aplicando a função e trocando esses valores absurdos por NaN (not a number) que representa valores faltantes:

numericalcols = ['songdurationms', 'acousticness', 'danceability', 'energy', 'instrumentalness', 'liveness', 'loudness', 'speechiness', 'tempo','audiovalence']

for col in numerical_cols:
  exclui_outliers(df, col)

Outra questão levantada na referencia [5] é sobre se devemos ou não excluir colunas desnecessárias, e a resposta para isso é que depende, isso porque é preciso ter certeza absoluta de que não vai precisar daqueles dados.

Mais uma questão é sobre dados faltantes ou nulos. Em algumas situações, podemos ter muitas informações incompletas no nosso DataFrame, como vimos anteriormente pode acontecer de precisarmos substituir valores errados por NaN.

Um cientista de dados tem algumas outras alternativas na hora de corrigir informações faltantes, dependendo da análise e outras etapas que dependem dela e do pré-processamento.

Uma alternativa é substituir esses dados pela média da coluna, mas como sabemos os outliers (valores discrepantes) podem afetar a média, desta forma também podemos substituir pela moda ou mediana.

Exemplo de substituição de dados em algumas colunas pela moda:

for column in ['acousticness', 'liveness', 'speechiness']:
    df[column].fillna(df[column].mode()[0], inplace=True)

Outro exemplo para substituir os valores nas outras coluna pela mediana:

for column in ['songdurationms', 'danceability', 'energy', 'loudness', 'audio_valence']:
    df[column].fillna(df[column].mean(), inplace=True)

Mas também podemos simplesmente excluir as linhas com dados faltantes:

df.dropna(inplace=True)

Ainda existem outros métodos como estatística de janela, clustering imputer ou random imputer, são mais aprimorados, e é algo que um cientista de dados tem que dominar, para se destacar e desempenhar seu papel da melhor maneira.

Visualização de dados com Matplotlib e Seaborn

Até agora conseguimos ter uma noção do que é a ciência de dados no dia a dia de um profissional da área, mas de um jeito bem rústico. Então que tal ir para cidade e começar a ver algumas paisagens mais concretas?

Chegou o momento de visualizar os dados de um jeito mais amigável, que permite não só uma análise de dados mais eficiente, como também colabora com a comunicação de resultados.

Aqui vamos dar uma olhada na referência [6], assim poderemos ter uma boa experiência do uso de Matplotlib e Seaborn para visualização de dados.

Obviamente a primeira coisa é importar as bibliotecas necessárias:

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# !pip install python-bcb
from bcb import sgs

Para este trabalho foram usados dados importados através do Sistema Gerenciador de Séries do Banco Central. Utilizaremos duas séries: a variação do IPCA mensal e o desemprego medido pela PNADC.

ipca = sgs.get({'IPCA' : 433}, start = “2010-01-01”)
desemprego = sgs.get({'desemprego' : 24369})
data = desemprego.merge(ipca, on = 'Date', how = 'left')

Matplotlib transformas os dados em figuras, cada uma contendo um ou mais eixos, especificando os pontos gráficos em coordenadas x-y. [6]

No caso do nosso DataFrame ipca, vamos plotar o DataFrame inteiro usando plt.plot(ipca) assim teremos um gráfico com todas as colunas.

O resultado é um gráfico de série temporal em que o eixo x são as datas ordenadas e o eixo y corresponde aos valores do IPCA mensal. A cada mês demonstra a variação desses valores.

plt.plot(ipca)
plt.style.use('default')

Continuando vamos olhar mais um gráfico, o histograma, que é uma espécie de gráfico de barras que demonstra uma distribuição de frequências. O Matplotlib também possibilita realizar mudanças estéticas e textuais nas figuras. Vamos realizar algumas mudanças:

plt.hist(x = ipca['IPCA'], color = “darkblue”, bins = 20)
plt.title(“valores de jan de 2010 a jan de 2022”)
plt.suptitle(“Histograma da variação mensal do IPCA”)
plt.style.use('ggplot')

Também é possível ver uma relação entre duas variáveis a partir de um gráfico de dispersão. Vemos qual a relação entre o desemprego e o IPCA.

Após executar essas linhas de código, vamos ter um gráfico de dispersão que representa a relação entre as variáveis “desemprego” e “IPCA”. Cada ponto no gráfico representa um par de valores correspondentes a essas variáveis.

plt.scatter(x = data['desemprego'], y = data['IPCA'])
plt.title(“Relação Desemprego x IPCA”)
plt.style.use('classic')

Este foi um gostinho do que é possive com matplotlib, uma biblioteca amplamente utilizada para criação de gráficos e visualizações de dados. Com ela podemos criar uma ampla variedade de gráficos desde gráficos simples até visualizações complexas e personalizadas.

Continuando podemos agora saborear o Seaborn, que é uma biblioteca popular para a construção de gráficos com Python. Baseado no Matplotlib, o Seaborn oferece uma interface mais avançada e focada em aspectos estatísticos na criação de gráficos.

sns.set_theme()
sns.lineplot(data = ipca)

Já podemos perceber uma melhora nos gráficos, uma das principais vantagens do Seaborn é a sua capacidade de melhorar a estética e a legibilidade dos gráficos automaticamente, tornando-os visualmente agradáveis e fáceis de interpretar.

sns.displot(data = ipca, x = 'IPCA', kde = True)

Já ouviu falar dos gráficos de correlação com retas de regressão? Esses gráficos são utilizados para examinar a relação entre duas variáveis e identificar o padrão geral de associação entre elas.

sns.regplot(data = data, x = 'desemprego', y = 'IPCA')

Com isso tenho certeza que você ficou afim de ser um cientista de dados, realmente é um mundo novo e cheio de coisas fascinantes para quem gosta de trabalhar com computador.

4. Análise e Modelagem de Dados

Como vimos até aqui à ciência de dados é uma disciplina muito abragente e cheia de desafios, sendo a base para o sucesso de grandes empresas e projetos, pois permite extrair valor da grande quantidade de dados que são produzidos nos dias atuais.

Sendo parte importante desta disciplina, os cálculos estatísticos e sumarização de dados são atividades essenciais na análise de dados. Eles permitem extrair informações relevantes e resumir as características dos dados de forma quantitativa.

Cálculos estatísticos e sumarização de dados

Já vimos na prática o uso de alguns destes cálculos, lá no pandas, os famosos cáculos de medidas de tendências central: média, mediana, moda.

Além desses existem outros cálculos estatísticos muito importantes, como por exemplo os cálculos de medidas de dispersão: variância, desvio padrão, amplitude.

Na ciência de dados com python muitas técnicas são constantemente utilizadas:

Cálculos de percentis e quartis: Muito util para entender a distribuição dos dados e identificar valores importantes. [7] Usando funções como numpy.percentile().

Análise de correlação entre variáveis: Uma medida estatística que indica a relação entre duas variáveis. [7] Pandas oferece a função corr() para calcular a matriz de correlação entre colunas de um DataFrame.

Sumarização de dados através de tabelas de frequência, contagem e porcentagem: Serve para entender a distribuição e a frequência dos valores em uma variável. [7] Pandas tem diversas funções para criar tabelas de frequência, contagem e porcentagem, como value_counts(), crosstab() e groupby().

Aprendizado de Máquina com scikit-learn

A scikit-learn é uma biblioteca de aprendizado de máquina de código aberto para a linguagem de programação Python. Contém vários algoritmos de classificação, regressão e agrupamento incluindo máquinas de vetores de suporte, florestas aleatórias, gradient boosting, k-means e DBSCAN. [7]

O famoso machine learning se concentra no desenvolvimento de algoritmos e estratégias que permitem que softwares de computador possam aprender e melhorar automaticamente a partir de dados, permitindo aos mesmos analisar padrões e tomar decisões com base nesses padrões.

A base para isso está na construção de modelos matemáticos e estatísticos que são capazes de reconhecer e extrair informações significativas dos dados que entram. Sendo o Scikit-Learn uma mala de ferramentas muito importantes para os vários momentos dessa construção.

Para termos aquele gostinho do Scikit-Learnm, vamos dar uma olhada no exemplo prático apresentado na referência. [8] Onde vamos passar por muitas etapas do processo, como Carga de Dados, Análise de dados, Pré-processamento de dados, Construção de modelos de Classificação e Finalização.

O dataset (conjuntos de dados) usado neste projeto será o Pima Indians Diabetes, proveniente originalmente do Instituto Nacional de Diabetes e Doenças Digestivas e Renais. O dataset apresenta em diversos atributos relacionados a dados médicos e uma variável de classe binária (0 ou 1).

Essas variáveis, que são as preditoras incluem o número de gestações que a paciente teve, seu IMC, nível de insulina, idade e assim por diante. Vamos para o código:

# Imports
import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import ConfusionMatrixDisplay

from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import confusion_matrix

from sklearn.metrics import accuracy_score
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

Agora na carga de dados, vamos lidar com algo que estamos familiarizados, neste artigo, que é o pandas:

# Carrega arquivo csv usando Pandas usando uma URL
# Informa a URL de importação do dataset
url = “https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

# Informa o cabeçalho das colunas
colunas = [‘preg’, ‘plas’, ‘pres’, ‘skin’, ‘test’, ‘mass’, ‘pedi’, ‘age’, ‘class’]

# Lê o arquivo utilizando as colunas informadas
dataset = pd.read_csv(url, names=colunas, skiprows=0, delimiter=’,’)

Ta ficando legal, se você não pulou aqui de paraquedas e está lendo todo este artigo, esta parte do trabalho de um cientista de dados não é algo novo para você, a famosa análise de Dados, lembrando que cada caso é um caso e neste caso, vamos fazer um análise simples, segue o código:

# dimensões do dataset
print(dataset.shape)
# tipos de cada atributo
print(dataset.dtypes)
# primeiras linhas do dataset
print(dataset.head())

Finalmente chegamos na parte nova, algo muito interessante que nos faz mergulhar de vez no mundo do machine learning, o pré-processamento de dados: Separação em conjunto de treino e conjunto de teste.

Antes devemos no ater a uma coisa que bom usar um conjunto de teste (conjunto de validação), uma amostra dos dados que não será usada para a construção do modelo, mas somente no fim do projeto para confirmar a precisão do modelo final. [8]

Esta sentindo falta de alguma coisa ? A limpeza que usamos anteriormente neste artigo, bom aqui não precisa, mas se precisa-se seria agora o momento de realizar algumas operações de preparação de dados, como, tratamento de valores missings (faltantes), limpeza de dados, transformações, entre outras.

# Separação em conjuntos de treino e teste
array = dataset.values
X = array[:, 0:8].astype(float)
Y = array[:, 8]
test_size = 0.20
seed = 7
Xtrain, Xtest, Ytrain, Ytest = traintestsplit(X, Y, testsize=testsize, random_state=seed)

Chegamos na parte dos modelos de classificação, onde serão avaliados diversos modelos usando a métrica de acurácia. Também será usada a validação cruzada 10-fold, ou seja vamos dividir o conjunto de dados em 10 partes (chamadas de folds). Em seguida, o modelo é treinado e avaliado 10 vezes.

Inicialmente configuram-se os parâmetros de número de folds e métrica de avaliação:

# Parâmetros
num_folds = 10
scoring = ‘accuracy’

Agora vamos utilizar os modelos de Regressão Logística, K-vizinhos mais próximos (KNN), Árvores de Classificação (CART), Naive Bayes (NB) e Máquinas de vetores de suporte (SVM), para criar uma linha base de desempenho.

# Criação dos modelos
models = []
models.append((‘LR’, LogisticRegression(solver=’newton-cg’)))
models.append((‘KNN’, KNeighborsClassifier()))
models.append((‘CART’, DecisionTreeClassifier()))
models.append((‘NB’, GaussianNB()))
models.append((‘SVM’, SVC()))

Depois chegou a hora de comparar os resultados dos modelos criados, treinando-os com os dados do conjunto de treino e utilizando a técnica de validação cruzada. Para posteriormente exibir a acurácia média e o desvio padrão de cada um.

np.random.seed(7) # definindo uma semente global

# Avaliação dos modelos
results = []
names = []
for name, model in models:
  kfold = KFold(n_splits=num_folds)
  cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
  results.append(cv_results)
  names.append(name)
  msg = “%s: %f (%f)” % (name, cv_results.mean(), cv_results.std())
  print(msg)

Depois será possível perceber que a Regressão Logística, o Naive Bayes e o SVM têm potencial, porém, estes são apenas valores médios de acurácia, precisamos observar a distribuição dos resultados de cada fold da validação cruzada. Faremos isto comparando os modelos usando boxplots.

# Comparação dos modelos
fig = plt.figure()
fig.suptitle(‘Comparação dos Modelos’)
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.show()

Agora antes de seguirmos, precisamos entender alguns conceitos, como padronização e pipelines do Scikit-Learn. A padronização é muito importante, se lembra da questão dos salários falada anteriormente, então a padronização ajusta todos os valores para uma escala comparável e a média será próxima de zero.

Já os pipelines do Scikit-Learn são uma forma conveniente de encadear várias etapas de pré-processamento e modelagem em um único objeto. No código abaixo foi utilizado pipelines que padronizam os dados e já constroem o modelo para cada fold de teste de validação cruzada.

np.random.seed(7) # definindo uma semente global

# Padronização do dataset
pipelines = []
pipelines.append((‘ScaledLR’, Pipeline([(‘Scaler’, StandardScaler()), (‘LR’, LogisticRegression(solver=’newton-cg’))])))
pipelines.append((‘ScaledKNN’, Pipeline([(‘Scaler’, StandardScaler()),(‘KNN’, KNeighborsClassifier())])))
pipelines.append((‘ScaledCART’, Pipeline([(‘Scaler’, StandardScaler()),(‘CART’, DecisionTreeClassifier())])))
pipelines.append((‘ScaledNB’, Pipeline([(‘Scaler’, StandardScaler()),(‘NB’, GaussianNB())])))
pipelines.append((‘ScaledSVM’, Pipeline([(‘Scaler’, StandardScaler()),(‘SVM’, SVC())])))
results = []
names = []

for name, model in pipelines:
  kfold = KFold(n_splits=num_folds)
  cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
  results.append(cv_results)
  names.append(name)
  msg = “%s: %f (%f)” % (name, cv_results.mean(), cv_results.std())
  print(msg)

Foi observado que aparentemente a padronização de dados não fez muita diferença nos valores de acurácia. [8] Podemos escolher alguns modelos para verificar se outras configurações de hiperparâmetros geram resultados melhores.

Agora continuando serão utilizados hiperparâmetros e GridSearchCV do Scikit-Learn.

Os hiperparâmetros que são parâmetros que o usuário define antes do treinamento do modelo. Eles controlam o comportamento e a configuração do algoritmo de aprendizado de máquina e afetam a performance do modelo. [7]

E o GridSearchCV do Scikit-Learn uma função que permite realizar uma pesquisa exaustiva sobre um conjunto de hiperparâmetros especificados para encontrar a melhor combinação de parâmetros para um determinado modelo de aprendizado de máquina. [7]

Os hiperparâmetros seram ajustados como o número de vizinhos e as métricas de distância para o KNN. Tentaremos todos os valores ímpares de k entre 1 a 21 e as métricas de distância euclidiana, manhattan e minkowski. [8]

Cada valor de k e de distância será avaliado usando a validação cruzada 10-fold no conjunto de dados padronizado, que mostrou resultados um pouco melhores do que os dados originais. [8]

np.random.seed(7) # definindo uma semente global

# Tuning do KNN
scaler = StandardScaler().fit(X_train)
rescaledX = scaler.transform(X_train)

k = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]
distancias = [“euclidean”, “manhattan”, “minkowski”]
param_grid = dict(n_neighbors=k, metric=distancias)

model = KNeighborsClassifier()
kfold = KFold(n_splits=num_folds)

grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)
grid_result = grid.fit(rescaledX, Y_train)
print(“Melhor: %f usando %s” %(grid_result.best_score_, grid_result.best_params_))

means = grid_result.cv_results_[‘mean_test_score’]
stds = grid_result.cv_results_[‘std_test_score’]
params = grid_result.cv_results_[‘params’]

for mean, stdev, param in zip(means, stds, params):
  print(“%f (%f): %r” % (mean, stdev, param))

Incrível não é mesmo, o maravilhoso mundo do machine learning com python, a ciência de dados é algo realmente espetacular e agora já descobrimos que a melhor configuração encontrada utiliza distância de manhattan e k = 17. Assim o algoritmo fará previsões usando as 17 instâncias mais semelhantes.

Ajustando dois dos principais hiperparâmetros do algoritmo SVM: o valor de C (o quanto flexibilizar a margem) e o tipo de kernel utilizado. No Scikit-Learn, o padrão para o algoritmo SVM (implementado pela classe SVC) é usar o kernel da Função Base Radial (RBF) e o valor C definido como 1.0. [8]

Serão testados outros valores para estes hiperparâmetros, e cada combinação de valores será avaliada usando a função GridSearchCV, além de se aplicar os modelos nos dados padronizados, como foi feito anteriormente para o KNN. [8]

Aqui não serão utilizados a versão padronizada dos dados, mas sim a versão original, que produziu melhores resultados.

np.random.seed(7) # definindo uma semente global

# Tuning do SVM

c_values = [0.1, 0.5, 1.0, 1.5, 2.0]
kernel_values = [‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’]
param_grid = dict(C=c_values, kernel=kernel_values)

model = SVC()
kfold = KFold(n_splits=num_folds)

grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)
grid_result = grid.fit(rescaledX, Y_train)
print(“Melhor: %f com %s” % (grid_result.best_score_,grid_result.best_params_))

means = grid_result.cv_results_[‘mean_test_score’]
stds = grid_result.cv_results_[‘std_test_score’]
params = grid_result.cv_results_[‘params’]

for mean, stdev, param in zip(means, stds, params):
  print(“%f (%f): %r” % (mean, stdev, param))

A configuração que alcançou a maior desempenho foi o modelo que utilizou kernel linear e C = 0,1. Apesar desta acurácia ter sido um pouco melhor do que a do resultado anterior, ela não foi alta o suficiente para superar a acurácia da Regressão Logística do início da etapa de avaliação dos modelos.

Com a cabeça de um cientista de dados descobrimos que a Regressão Logística foi o modelo que mostrou melhor acurácia para o problema.

Chegou o momento de finalizar o modelo, a finalização do modelo será feita treinando-o em todo o conjunto de dados de treinamento (sem validação cruzada) e fazendo predições para o conjunto de dados de teste que foi separado logo no início do exemplo, a fim de confirmar nossas descobertas.

Como para este modelo a padronização dos dados de entrada não produziu resultados diferentes, iremos utilizar a versão original do dataset. Exibiremos a acurácia, a matriz de confusão e um relatório de classificação com diversas métricas, disponível com a utilização da função classification_report. [8]

A função classification_report do Scikit-Learn gera um relatório de avaliação detalhado para um problema de classificação. Ele fornece várias métricas de desempenho.

np.random.seed(7) # definindo uma semente global

# Preparação do modelo
model = LogisticRegression(solver=’newton-cg’)
model.fit(X_train, Y_train)

# Estimativa da acurácia no conjunto de teste
predictions = model.predict(X_test)
print(“Accuracy score = “, accuracy_score(Y_test, predictions))

# Matriz de confusão
cm = confusion_matrix(Y_test, predictions)
labels = [“Sem diabetes”, “Com diabetes”]
cmd = ConfusionMatrixDisplay(cm, display_labels=labels)
cmd.plot(values_format=”d”)
plt.show()
print(classification_report(Y_test, predictions, target_names=labels))

Assim de acordo com [8]: Por meio desse conjunto de testes, foi possível verificar que alcançamos uma acurácia de 79,22% em dados não vistos. Este resultado foi ainda melhor do que as nossas expectativas, pois no treinamento alcançamos a acurácia de 78%.

Com tudo isso podemos ter uma noção completa de como a ciência de dados e o python estão em grande sintônia, sendo capaz de produzir resultados realmente muito harmônicos, um cientista de dados tem tudo que precisa para aplicar todo seu conhecimento e criar modelos de alto desempenho.

Podemos perceber que machine learning depende da extração manual de recursos e da escolha de algoritmos apropriados. Desta forma o machine learning precisa de dados e experiências anteriores para que seus algoritmos aprendam.

Diferente do deep learning, que se inspirada na estrutura e função do cérebro humano para aprender automaticamente representações de recursos relevantes dos dados, sem a necessidade de extração manual de características.

No Python também existe as bibliotecas TensorFlow e Keras, tanto o TensorFlow quanto o Keras requerem dados de entrada para treinar e avaliar os modelos.

Mas diferente do machine learning um modelo de deep learning consegue extrair representações de características diretamente dos dados brutos, eliminando a necessidade de extração manual de recursos.

5. Big Data e Python

Conseguimos perceber até aqui o poder do python quando o assunto e ciência de dados, sendo uma escolha popular no mundo da análise de dados, python consegue seu lugar no pódio, graças às suas bibliotecas e ferramentas que colaboram muito com o processamento e análise dos dados.

Mas se olharmos para o mundo de hoje, com toda esta rede de computadores, são tantos dispositivos conectados, tantos dados circulando e sendo gerados, são conjuntos de dados tão grandes e complexos que métodos tradicionais de gerenciamento de dados já não são suficientes.

Ainda a sim, python não se intimida e mostra sua força, mesmo que o volume de dados seja imenso e a velocidade com que esses dados são gerados seja demasiadamente alta, python consegue oferecer tudo que é necessário para a análise de dados em larga escala.

Sendo Apache Spark, o framework mais famoso para o processamento e análise desses dados, um cientista de dados consegue desempenhar seu papel com êxito, e esse grande conjunto de dados e seus diferentes tipos e formatos podem ser analisados e processados com excelência.

Ainda mais porque contamos com a ajuda dos nossos conhecidos: pandas, numpy, scikit-learn, TensorFlow e outras bibliotecas que como já sabemos são parte importante do dia a dia de um profissional da área de ciência de dados.

Conceito de big data e seus desafios

Big data é a área do conhecimento que estuda como tratar, analisar e obter informações a partir de conjuntos de dados muito grandes. O termo big data surgiu em 1997, e foi inicialmente utilizado para nomear conjuntos de dados não ordenados em rápido crescimento. [7]

Assim podemos percerber que o grande desafio está justamente no que a define, pois extrair valor de tantos dados não é tarefa fácil, mesmo com a ajuda de linguagens de programação como python, na big data temos diferentes diferentes tipos e formatos de dados, o que torna a tarefa mais complicada.

Se pensarmos no trabalho de um cientista de dados num grande empresa, como uma big tech por exemplo, imagine a quantidade de dados, os diferentes tipos de dados, a velocidade com que eles são gerados e que seu trabalho é extrair insights para orientar decisões e solucionar problemas.

Quantos desafios será preciso superar, e primeiro deles deles é a infraestrutura, pois será preciso ter tecnologias adequadas, não só para processamento e análise, mas também para armazenamento. De acordo com [9], diariamente o mundo gera cerca de 2,5 quintilhões de dados.

Ainda de acordo com [9], espera-se que a quantidade de dados gerados no mundo alcance 175 zettabytes até 2025, um aumento significativo em relação aos 33 zettabytes gerados em 2018. Este é um cenário que traz novos desafios, mas também muitas oportunidades.

Outro desafio seria a questão da privacidade e segurança, porque novas leis vem surgindo e as empresas precisam se adequar e garantir a segurança e privacidade de seus clientes, o que torna atender a regulamentos de privacidade algo essencial em projetos de big data.

Introdução ao processamento paralelo e distribuído

Dois métodos da area da computação que tem como objetivo resolver muitos problemas relacionadas big data e a necessidade de se extrair insights desse grande universo de dados. Sim porque estamos na era da informação e dados são gerados em tempo real e em grande quantidade.

Esses são dois métodos que muitas vezes podem trabalhar juntos para lidar com grandes conjuntos de dados e problemas computacionalmente intensivos, permitindo resolver um grande problema na hora da análise de big data.

O processamento paralelo permite que dois (ou mais) processadores de um computador sejam usados para trabalhar em partes separadas de uma tarefa. Dessa forma, é possível diminuir o tempo gasto na resolução do problema. [10]

A computação paralela é uma forma particular e fortemente acoplada de computação distribuída. No processamento paralelo, todos os processadores têm acesso à memória compartilhada para trocas de informações entre eles. [11]

Por outro lado, no processamento distribuído, cada processador possui um memória particular (memória distribuída). Os processadores usam transmissões de mensagens para trocas de informações. [11]

Ferramenta popular de big data: Apache Spark

Apache Spark é um mecanismo multilíngue para executar engenharia de dados, ciência de dados e aprendizado de máquina em máquinas ou clusters de nó único. [12] Seu objetivo é processar grandes conjuntos de dados de forma paralela e distribuída.

Fornecendo recursos poderosos para o processamento distribuído de dados, Apache Spark é capaz de integra-se com diversos frameworks, como pandas e NumPy por exemplo, ajudando a dimensioná-los para milhares de máquinas, tornando python mais poderoso.

Com ampla gama de bibliotecas e módulos para análise de dados, aprendizado de máquina, processamento de streaming e processamento de gráficos. Apache Spark é muito util e resolve muitos dos problema inerentes ao big data.

6. Conclusão

Por que dados são importantes? Porque é possível extrair valor deles, usando diversas tecnologias que estão em constante evolução. Podemos coletar, limpar, análisar e interpretar grandes quantidades de dados em busca de insights que seram usados para orientar decisões e solucionar problemas.

Desta forma à ciência de dados torna-se a área do conhecimento que é capaz de fornecer o caminho para desenvolver as habilidades necessárias para profissionais dispostos a dominar e desenvolver tecnologias que serão usadas para extrair esse valor.

Imagine que você é o dono de um pequeno mercadinho, é natural que com o tempo, apenas usando capacidades humanas básicas, você será capaz de identificar alguns padrões de consumo de seus clientes, conseguindo até prever algumas demandas futuras.

Agora com tudo que já vimos até aqui, com as diferentes tecnologias que estão a serviço da ciência de dados, com as diferentes habilidades que um profissional desta área é capaz de desenvolver, vamos sair do mercadinho e ir para um grande e-commerce.

Se torna óbvio as possibilidades não é mesmo? Com à ciência de dados aliada a outras áreas podemos até mesmo simular capacidades humanas, mas em vez de algumas pequenas informações obtidas no dia a dia de um mercadinho, conseguimos milhões de dados de clientes do mundo todo.

O poder que se pode alcançar com a ciência de dados aliada com tecnologias com python é imenso, podendo ser aplicada em diversas áreas, como mercado e vendas, saúde e medicina, transporte e logística, governança e setor público e até mesmo em pesquisa científica e inovação.

A ciência de dados permite tranformar dados em informação, e essas informações ajudam na tomada de decisão, impulsionando a inovação e o progresso. Ser um cientista de dados é navegar por um mar tempestuoso de dados desvendando mistérios e encontrando respostas.

Python é o seu navio, a matemática e as estatísticas são sua bússola e seu mapa, e você marinheiro, é o cientista de dados, que navega em busca dos tesouros escondidos e das informações preciosas, que alimentam o progresso e a transformação do mundo ao seu redor.

7. Referências

[1] Tudo sobre ciência de dados: https://ebaconline.com.br/blog/tudo-sobre-ciencia-de-dados. Acesso em: 27/06/2023

[2] Linguagem de programção python https://pt.wikipedia.org/wiki/Python Acessado em: 27/06/2023

[3] Usando python em data science https://www.cienciaedados.com/usando-python-em-data-science/ Acessado em: 27/06/2023

[4] Data Science: Introdução a Ciência de Dados https://youtu.be/F608hzn_ygo Acessado em: 27/06/2023

[5] Como fazer uma limpeza de dados completa em Python https://medium.com/turing-talks/como-fazer-uma-limpeza-de-dados-completa-em-python-7abc9dfc19b8 Acessado em: 28/06/2023

[6] Python visualizando dados com matplotlib e seaborn https://analisemacro.com.br/data-science/python/python-visualizando-dados-com-matplotlib-e-seaborn/ Acessado em: 28/06/2023

[7] O que é … ? https://pt.wikipedia.org Acessado em: 28/06/2023

[8] Implementando um Modelo de Classificação no Scikit-Learn https://tatianaesc.medium.com/implementando-um-modelo-de-classifica%C3%A7%C3%A3o-no-scikit-learn-6206d684b377 Acessado em: 28/06/2023

[9] Quantos geramos e como isso impacta nossa vida https://linkages.com.br/2023/03/29/dados-quantos-geramos-e-como-isso-impacta-nossa-vida/ Acessado em: 29/06/2023

[10] O que é processamento paralelo https://tecnoblog.net/responde/o-que-e-processamento-paralelo/ Acessado em: 29/06/2023

[11] Computação paralela versus computação distribuída https://aws.amazon.com/pt/what-is/distributed-computing/ Acessado em: 29/06/2023

[12] Apache Spark https://spark.apache.org/ Acessado em: 29/06/2023