Python e R para Machine Learning e Ciência de Dados

Um guia introdutório para iniciantes

Introdução

A ciência de dados e o machine learning estão transformando a forma como tomamos decisões, automatizamos processos e extraímos conhecimento de dados. Duas linguagens são amplamente utilizadas, Python e R. Ambas têm características poderosas e são usadas por profissionais no mundo todo.

Este artigo vai te guiar pelas principais diferenças entre Python e R, como cada uma é usada na prática e mostrará exemplos reais de código para te ajudar a começar. Vamos explorar passo a passo, de forma simples e direta!

Python, por que usar?

A linguagem python de programação é muito popular e versátil. Ela é usada em diversas áreas como desenvolvimento web, automação, análise de dados e claro, machine learning. A comunidade de Python é enorme, o que significa que você vai encontrar muito conteúdo, suporte e bibliotecas prontas.

Um dos principais motivos para usar Python em ciência de dados é a existência de bibliotecas como Pandas, NumPy, Matplotlib, Scikit-Learn e TensorFlow.

Exemplo básico em Python

Inspirado nesse exemplo do curso de python, vamos importar uma base de dados e visualizar estatísticas básicas com Pandas:

import pandas as pd

# Carregar um conjunto de dados
dados = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv")

# Visualizar as 5 primeiras linhas
print(dados.head())

# Estatísticas descritivas
print(dados.describe())

R, por que considerar?

Em paralelo ao Python, a linguagem r é uma linguagem criada especificamente para análise estatística e visualização de dados. É muito usada no meio acadêmico e em pesquisas. Possui pacotes poderosos como ggplot2, dplyr, caret e tidyverse que facilitam bastante o trabalho.

Se você gosta de explorar dados com gráficos e testes estatísticos, R pode ser uma excelente escolha.

Exemplo básico em R

Veja como carregar o mesmo conjunto de dados e gerar estatísticas com R:

# Carregar bibliotecas
library(tidyverse)

# Carregar o dataset
dados <- read.csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv")

# Visualizar as primeiras linhas
head(dados)

# Estatísticas descritivas
summary(dados)

Comparação inicial

Ambas as linguagens conseguem fazer as mesmas tarefas essenciais em ciência de dados. A diferença está em como você prefere trabalhar. Python costuma ser mais usado em produção, enquanto R brilha na parte exploratória e estatística. Veja uma comparação rápida:

Próximos passos

Agora que você viu o básico de cada linguagem, nas próximas partes deste artigo vamos explorar como construir modelos preditivos com Scikit-Learn e caret, como tratar dados reais, e também como criar dashboards e relatórios interativos.

Você pode seguir com qualquer uma das duas linguagens, ou até mesmo aprender as duas. Muitos cientistas de dados fazem isso. Continue acompanhando os próximos capítulos!

Parte 2: Pré-processamento, visualização e primeiro modelo

Preparando os dados para análise

Antes de aplicar qualquer modelo de machine learning, precisamos garantir que os dados estejam limpos, padronizados e prontos para uso. Essa etapa é chamada de pré-processamento e é essencial para garantir bons resultados.

Vamos trabalhar com o mesmo conjunto de dados da flor Iris para aplicar essas transformações.

Pré-processamento em Python

import pandas as pd
  from sklearn.preprocessing import LabelEncoder
  
  # Carregar dados
  dados = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv")
  
  # Verificar valores ausentes
  print(dados.isnull().sum())
  
  # Codificar variáveis categóricas (target)
  le = LabelEncoder()
  dados["species"] = le.fit_transform(dados["species"])
  
  print(dados.head())

Pré-processamento em R

library(tidyverse)
  
  # Carregar dados
  dados <- read.csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv")
  
  # Verificar valores ausentes
  colSums(is.na(dados))
  
  # Codificar variável target (fator numérico)
  dados$species <- as.numeric(as.factor(dados$species))
  
  head(dados)

Visualizando os dados com gráficos simples

Visualizações são essenciais para entender padrões nos dados. Vamos usar gráficos para observar a relação entre as variáveis.

Gráfico em Python com Matplotlib

import matplotlib.pyplot as plt
  
  # Scatter plot
  plt.scatter(dados["sepal_length"], dados["sepal_width"], c=dados["species"])
  plt.xlabel("Comprimento da Sépala")
  plt.ylabel("Largura da Sépala")
  plt.title("Distribuição das espécies - Iris")
  plt.show()

Gráfico em R com ggplot2

library(ggplot2)
  
  # Scatter plot
  ggplot(dados, aes(x = sepal_length, y = sepal_width, color = as.factor(species))) +
    geom_point() +
    labs(title = "Distribuição das espécies - Iris",
         x = "Comprimento da Sépala",
         y = "Largura da Sépala",
         color = "Espécie")

Primeiro modelo de machine learning

Agora vamos treinar nosso primeiro modelo simples de classificação. Usaremos o algoritmo KNN, que classifica os dados com base nos vizinhos mais próximos.

KNN em Python com Scikit-Learn

from sklearn.model_selection import train_test_split
  from sklearn.neighbors import KNeighborsClassifier
  from sklearn.metrics import accuracy_score
  
  # Separar variáveis independentes e alvo
  X = dados.drop("species", axis=1)
  y = dados["species"]
  
  # Dividir em treino e teste
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
  
  # Criar e treinar o modelo
  modelo = KNeighborsClassifier(n_neighbors=3)
  modelo.fit(X_train, y_train)
  
  # Prever e avaliar
  y_pred = modelo.predict(X_test)
  print("Acurácia:", accuracy_score(y_test, y_pred))

KNN em R com o pacote class

library(class)
  
  # Separar variáveis
  X <- dados[, 1:4]
  y <- dados$species
  
  # Dividir em treino e teste
  set.seed(42)
  idx <- sample(1:nrow(dados), size = 0.8 * nrow(dados))
  X_train <- X[idx, ]
  X_test <- X[-idx, ]
  y_train <- y[idx]
  y_test <- y[-idx]
  
  # Modelo KNN
  pred <- knn(train = X_train, test = X_test, cl = y_train, k = 3)
  
  # Avaliar acurácia
  acc <- sum(pred == y_test) / length(y_test)
  print(paste("Acurácia:", round(acc, 2)))

Finalizando essa etapa

Nesta parte, vimos como limpar e preparar dados, criar gráficos para análise visual e treinar um primeiro modelo de machine learning com o algoritmo knn. Esse é um grande passo para começar sua jornada prática na ciência de dados.

Na próxima parte do artigo, vamos explorar: