feat: add a introduction to data science

content/docs/Ic/0. Introducao.md

@@ -0,0 +1,57 @@
+---
+title: "1. Fundamentos de Inteligência Artificial e Ciência de Dados"
+weight: 1
+---
+Repositório de exemplos e exercícios da disciplina de Ciência de Dados do curso de Bacharelado em Sistemas de Informação do Instituto Federal de Educação, Ciência e Tecnologia de São Paulo (IFSP) - Campus Votuporanga.
+
+Todos os exercícios foram desenvolvidos utilizando a linguagem Python na plataforma Google Collab, as base de dados utilizadas em cada exemplos serão disponibilizadas.
+
+##### Referências:
+AMARAL, F. Introdução a ciência de dados: mineração de dados e Big Data. Rio de Janeiro: Alta Books, 2016.  
+GRUS, J. Data Science do Zero: primeiras Regras com o Python. Rio de Janeiro: Alta Books, 2019.  
+WICKHAM, H. R Para Data Science. Rio de Janeiro: Alta Books, 2019. 
+MCKINNEY, W. Python Para Análise de Dados: tratamento de dados com Pandas, NumPy e Python. São Paulo: Novatec, 2018. 
+
+A Inteligência Artificial (IA), com início formal em 1956, é o estudo de faculdades mentais através de modelos computacionais ou a automação de atividades associadas ao pensamento humano. Suas principais áreas incluem:
+
+- Aprendizado de Máquina (Machine Learning)
+- Mineração de Dados (Data Mining)
+- Processamento de Linguagem Natural (PLN)
+- Robótica, Visão Computacional e Redes Neurais
+
+## Conceitos essenciais: Dado, Informação e Conhecimento
+
+- **Dado:** Fatos brutos coletados e armazenados (ex.: `Bom Clima`).
+- **Informação:** Dado analisado com significado (ex.: Nome dos moradores do bairro Bom Clima).
+- **Conhecimento:** Informação interpretada e utilizada para um fim (ex.: O dia da semana em que os moradores do bairro mais compram).
+
+A Ciência de Dados é multidisciplinar (Estatística, Matemática, Computação) e estuda o ciclo de vida do dado: produção, armazenamento, transformação, análise e descarte.
+
+Talk is cheap, show me the code:
+<a href="data_base/credit_data.csv" download="credit_data.csv">Clique aqui para baixar o dataset</a>
+
+```python
+# Minha primeira manipulação de dados
+#é necessário importar as bibliotecas TODA vez que for rodas os comandos novamente após a desconexão com o notebook
+#pandas é uma biblioteca que trabalha com a importação de arquivos .csv
+import pandas as pd
+#numpy é uma biblioteca para a realização de operações em arrays
+import numpy as np
+#seaborn é uma biblioteca para vizualização de gráficos
+import seaborn as sb
+#biblioteca para gerar gráficos dinâmicos
+!pip install plotly --upgrade
+#matplotlib é também uma biblioteca para a geração de gráficos
+import matplotlib.pyplot as plt
+import plotly.express as px
+
+#colocar o arquivo (credit_data.csv) dentro da pasta colab notebooks no DRIVE.
+#copiar o caminho do arquivo
+#importar um arquivo .csv
+base_credito = pd.read_csv("/content/drive/MyDrive/Colab Notebooks/credit_data.csv") #carrega os dados e os colocas na variável base_credito
+
+#base_credito.shape # mostra a quantidade de linhas e colunas
+#base_credito.head() #mostra as primeiras linhas da base
+base_credito.describe() #mostra a estruta dos dados de cada coluna
+#base_credito.info() #mostra a característica de cada coluna
+```

content/docs/Ic/1. Ferramentas.md

@@ -0,0 +1,14 @@
+---
+title: "2. Ferramentas e Bibliotecas (Ecossistema Python)"
+weight: 1
+---
+
+Para a prática de Ciência de Dados e ML, utilizam-se softwares como Weka, Anaconda, PyCharm e Google Colab. As principais bibliotecas Python são:
+
+| Biblioteca | Função principal |
+|---|---|
+| Pandas | Manipulação de tabelas (DataFrames); limpeza e importação de arquivos (.csv, .xlsx). |
+| NumPy | Operações matemáticas em arrays e matrizes. |
+| Scikit-Learn | Biblioteca padrão para algoritmos de ML; divisão de bases e avaliação de modelos. |
+| Matplotlib / Seaborn | Geração de gráficos estáticos (2D e 3D com Matplotlib); Seaborn para visualizações estatísticas. |
+| Plotly | Criação de gráficos dinâmicos e interativos. |

content/docs/Ic/2. Aprendizado-Maquina.md

@@ -0,0 +1,22 @@
+---
+title: "3. Aprendizado de Máquina (Machine Learning)"
+weight: 1
+---
+Uma breve definição de Aprendizado de Máquina (Machine Learning) e seus tipos.
+
+## O que é
+Aprendizado de Máquina é a capacidade de sistemas computacionais melhorarem seu desempenho em tarefas a partir da experiência, ou seja, através da análise de dados e ajuste de modelos.
+
+## Tipos de aprendizado
+
+- **Supervisionado (preditivo)**
+    - O modelo é treinado com entradas e rótulos (saídas) conhecidos.
+    - Exemplos: classificação (p. ex., detecção de spam) e regressão (p. ex., previsão de preços).
+
+- **Não supervisionado (descritivo)**
+    - O modelo explora dados sem rótulos para encontrar padrões ou estruturas.
+    - Exemplos: clustering (agrupamento) e regras de associação.
+
+- **Por reforço**
+    - Aprendizado por tentativa e erro, guiado por recompensas e penalidades.
+    - Aplicações: robótica, controle e agentes autônomos.

content/docs/Ic/3. Processo-KDD.md

@@ -0,0 +1,79 @@
+---
+title: "4. O Processo KDD (Descoberta de Conhecimento)"
+weight: 1
+---
+
+O KDD (Knowledge Discovery in Databases) é o processo de identificar padrões válidos, novos e úteis em grandes volumes de dados. As principais etapas são:
+
+1. **Limpeza (Data Cleaning)**  
+    Remoção de ruídos e dados inconsistentes.
+
+2. **Integração**  
+    Combinação de múltiplas fontes de dados.
+
+3. **Seleção e Transformação**  
+    Escolha dos dados relevantes e conversão para formatos apropriados.
+
+4. **Mineração de Dados (Data Mining)**  
+    Aplicação de algoritmos para extrair padrões.
+
+5. **Avaliação e Apresentação**  
+    Interpretação dos padrões e exibição do conhecimento ao usuário.
+
+Talk is cheap, show me the code:
+<a href="data_base/credit_data.csv" download="credit_data.csv">Clique aqui para baixar o dataset</a>
+
+```python
+"""KDD e Pré Processamento.ipynb
+Automatically generated by Colab.
+Imports das libs
+"""
+#biblioteca para gerar gráficos dinâmicos 
+!pip install plotly --upgrade
+#pandas é uma biblioteca que trabalha com a importação de arquivos .csv 
+import pandas as pd
+#numpy é uma biblioteca para a realização de operações em arrays 
+import numpy as np
+#seaborn é uma biblioteca para vizualização de gráficos 
+import seaborn as sb
+#matplotlib é também uma biblioteca para a geração de gráficos 
+import matplotlib.pyplot as plt
+import plotly.express as px
+"""# Visualização dos dados"""
+base_credito = pd.read_csv("/content/sample_data/credit_data.csv") #carrega os dados e os colocas na variável base_credito 
+base_credito.describe() # descreve uma visão geral da tabela
+np.unique(base_credito['default'],return_counts=True) #conta a quantidade de valores de cada item da coluna
+sb.countplot(x = base_credito['default']);#conta os registros e gera um gráfico
+plt.hist(x = base_credito['age']); # gera gráfico de histograma
+grafico = px.scatter_matrix(base_credito, dimensions=['age'], color = 'default') 
+grafico.show();
+"""# Tratamento de valores inconsistentes"""
+base_credito.loc[base_credito['age'] < 0] # a função loc do pandas faz a localização de algum registro. No caso, de registros da coluna 'age' menores que zero
+base_credito2 = base_credito.drop('age', axis = 1) 
+base_credito2
+base_credito[base_credito['age'] < 0].index
+base_credito3 = base_credito.drop(base_credito[base_credito['age'] < 0].index) 
+base_credito3
+base_credito3.loc[base_credito['age'] < 0] 
+base_credito3
+base_credito.mean() #retorna a média
+base_credito['age'][base_credito['age'] >= 0].mean() # retorna apenas aqueles com idade maior ou igual a zero
+base_credito.loc[base_credito['age'] < 0, 'age'] = 40.92 # joga o valor 40.92 para todas as idades com idade negativa
+"""# Tratamento de valores ausentes"""
+base_credito.isnull().sum()
+base_credito.loc[pd.isnull(base_credito['age'])] #mostra quais linhas tem idade nula
+base_credito['age'].fillna(base_credito['age'].mean(), inplace = True) 
+base_credito.describe()
+"""# Divisão entre atributos previsores (X) e classe (Y)"""
+X_credito = base_credito.iloc[:, 1:4].values #iloc localiza linhas e colunas X_credito
+Y_credito = base_credito.iloc[:, 4].values 
+X_credito[:, 0].max(), X_credito[:, 1].max(), X_credito[:, 2].max()
+from sklearn.preprocessing import StandardScaler #classe que cria a padronização 
+scaler_credit = StandardScaler()
+X_credito = scaler_credit.fit_transform(X_credito)
+"""# Divisão de atributos treinamento e teste (sem escalonar)"""
+from sklearn.model_selection import train_test_split
+X_credito_treinamento, X_credito_teste, Y_credito_treinamento, Y_credito_teste = train_test_split(X_credito, Y_credito, test_size = 0.25, random_state = 0)
+"""# Salvar os arquivos sem escalonar"""
+import pickle #salvar variáveis em disco
+with open('credito.pkl', mode = 'wb') as f: pickle.dump([X_credito_treinamento,Y_credito_treinamento, X_credito_teste, Y_credito_teste], f)

content/docs/Ic/4. Pre-processamento.md

@@ -0,0 +1,72 @@
+---
+title: "5. Pré-processamento de Dados"
+weight: 1
+---
+
+### Pré-processamento
+
+Esta etapa é crucial para garantir a qualidade dos dados antes de aplicar os algoritmos.
+
+## Tratamento de inconsistências e dados ausentes
+
+### Dados inconsistentes
+- Remover linhas/colunas (não recomendado).
+- Preencher manualmente.
+- Preencher com estatísticas (média ou mediana).
+
+### Dados ausentes
+- Identificar valores nulos/NA.
+- Preencher com média/mediana ou usar métodos avançados (interpolação, imputação por modelos).
+
+## Transformação de variáveis
+
+### Escalonamento (scaling)
+- Alinhar atributos na mesma escala para evitar que valores maiores dominem o modelo.
+- Métodos comuns:
+    - Padronização (StandardScaler): indicada quando há outliers.
+    - Normalização (MinMaxScaler): transforma valores para o intervalo [0, 1].
+
+### Variáveis categóricas → numéricas
+- `LabelEncoder`: atribui um inteiro a cada categoria (pode introduzir ordem).
+- `OneHotEncoder`: cria colunas binárias por categoria (evita hierarquia numérica indevida).
+
+Talk is cheap, show me the code:
+<a href="data_base/credit_data.csv" download="credit_data.csv">Clique aqui para baixar o dataset</a>
+
+```python
+"""Atividade Pré-Processamento.ipynb
+Automatically generated by Colab."""
+#biblioteca para gerar gráficos dinâmicos 
+!pip install plotly --upgrade
+#pandas é uma biblioteca que trabalha com a importação de arquivos .csv 
+import pandas as pd
+#numpy é uma biblioteca para a realização de operações em arrays 
+import numpy as np
+#seaborn é uma biblioteca para vizualização de gráficos 
+import seaborn as sb
+#matplotlib é também uma biblioteca para a geração de gráficos 
+import matplotlib.pyplot as plt
+import plotly.express as px
+"""PARTE I – carregamento da base"""
+base_mb = pd.read_csv("/content/drive/MyDrive/Colab Notebooks/mountains_vs_beaches_preferences.csv")
+base_mb.isnull().sum()
+"""PARTE II – Divisão entre previsores e classe"""
+base_mb.columns
+X_mb = base_mb.iloc[:, 0:13]
+Y_mb = base_mb.iloc[:, 0:13].values
+"""PARTE III – Atributos categóricos para numéricos (Usar apenas o OneHotEncoder) """
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.compose import ColumnTransformer
+oneHoteEncoder_mb = ColumnTransformer(transformers=[('OneHot', OneHotEncoder(), [1, 3, 5, 7, 10])], remainder='passthrough')
+X_mb = oneHoteEncoder_mb.fit_transform(X_mb)
+"""PARTE IV - Escalonamento"""
+from sklearn.preprocessing import StandardScaler
+scaler_mb = StandardScaler()
+X_mb = scaler_mb.fit_transform(X_mb)
+from sklearn.model_selection import train_test_split
+X_mb_treinamento, X_mb_teste, Y_mb_treinamento, Y_mb_teste = train_test_split(X_mb, Y_mb, test_size = 0.15, random_state = 0)
+import pickle #salvar variáveis em disco
+with open('mb.pkl', mode = 'wb') as f:
+    pickle.dump([X_mb_treinamento,Y_mb_treinamento, X_mb_teste, Y_mb_teste], f)
+
+```

content/docs/Ic/5. Aprendizagem_Bayesiana.md

@@ -0,0 +1,62 @@
+---
+title: "6. Aprendizagem Bayesiana"
+weight: 1
+---
+
+O Naive Bayes é um algoritmo de aprendizado supervisionado baseado no Teorema de Bayes. Ele é amplamente utilizado para filtros de spam, classificação de documentos e análise de risco.
+
+1. **Pré-processamento de Dados**
+
+Antes de aplicar o algoritmo, os dados devem ser preparados:
+- Limpeza: Verificar e tratar valores ausentes ou inconsistentes.
+- Transformação: Converter atributos categóricos (textos) em numéricos.
+- Escalonamento: Padronizar os atributos para que fiquem na mesma escala.
+
+2. **O Funcionamento do Algoritmo**
+
+O Naive Bayes gera uma tabela de probabilidade a partir da base de dados de treinamento.
+- Cálculo: Ele calcula a probabilidade de uma nova entrada pertencer a uma classe (ex: Risco Alto, Moderado ou Baixo) com base no histórico de frequências dos atributos.
+- Correção Laplaciana: Quando uma combinação de atributos resulta em probabilidade zero, o algoritmo não consegue fazer a previsão. A solução é adicionar um registro fictício à base (Correção Laplaciana) para ajustar a tabela e permitir o cálculo.
+
+3. **Implementação em Python (Scikit-learn)**
+
+A biblioteca padrão para esta implementação é a sklearn.
+- Classe: Utiliza-se a GaussianNB (baseada na distribuição estatística Gaussiana).
+- Treinamento (fit): Gera a tabela de probabilidades a partir dos dados de treino (X) e das classes (Y).
+- Previsão (predict): Classifica novas entradas em uma das categorias definidas.
+- Avaliação (accuracy_score): Realiza a comparação estatística entre as previsões e os resultados reais para medir a precisão do modelo.
+
+Talk is cheap, show me the code:
+<a href="data_base/credit_data.csv" download="credit_data.csv">Clique aqui para baixar o dataset</a>
+
+```python
+"""Aprendizado Bayesiano.ipynb
+Automatically generated by Colab.
+Original file is located at https://colab.research.google.com/drive/1kXgP-ZP0u4o995iW2T9DI7VK-PqCl1r9 """
+#biblioteca para gerar gráficos dinâmicos !pip install plotly --upgrade #pandas é uma biblioteca que trabalha com a importação de arquivos .csv import pandas as pd #numpy é uma biblioteca para a realização de operações em arrays import numpy as np #seaborn é uma biblioteca para vizualização de gráficos import seaborn as sb #matplotlib é também uma biblioteca para a geração de gráficos import matplotlib.pyplot as plt import plotly.express as px
+base_risco_credito = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/risco_credito.csv')
+"""Realizar o pré-processamento da base"""
+X_risco_credito = base_risco_credito.iloc[:,0:4].values
+Y_risco_credito = base_risco_credito.iloc[:,4].values
+#transformar de categórico para numérico from sklearn.preprocessing import LabelEncoder label_encoder_historia = LabelEncoder() label_encoder_divida = LabelEncoder() label_encoder_garantia = LabelEncoder() label_encoder_renda = LabelEncoder()
+X_risco_credito[:, 0] = label_encoder_historia.fit_transform(X_risco_credito[:, 0]) X_risco_credito[:, 1] = label_encoder_divida.fit_transform(X_risco_credito[:, 1]) X_risco_credito[:, 2] = label_encoder_garantia.fit_transform(X_risco_credito[:, 2]) X_risco_credito[:, 3] = label_encoder_renda.fit_transform(X_risco_credito[:, 3])
+"""Salvar a base no drive"""
+import pickle with open('risco_credito.pkl', 'wb') as f: pickle.dump([X_risco_credito, Y_risco_credito], f)
+"""Algoritmo Naive Bayes"""
+from sklearn.naive_bayes import GaussianNB # importa a classe para trabalhar com o aprendizado bayesiano naive_risco_credito = GaussianNB() naive_risco_credito.fit(X_risco_credito, Y_risco_credito) # faz o treinamento e gera a tabela de probabilidade
+#gerar previsao #historio = Boa (0), divida = Alta (0), garantia nenhuma (1), renda > 35 (2) #historio = ruim (2), divida = alta (0), garantia = adequada (0), renda < 15 (0) previsao = naive_risco_credito.predict([[0, 0, 1, 2],[2, 0, 0, 0]]) # a função não retorna a probabilidade
+"""Base de Dados credit_data"""
+import pickle with open('/content/drive/MyDrive/Colab Notebooks/credito.pkl', 'rb') as f: X_credito_treinamento, Y_credito_treinamento, X_credito_teste, Y_credito_teste = pickle.load(f)
+native_dados_credito = GaussianNB() native_dados_credito.fit(X_credito_treinamento, Y_credito_treinamento) # faz os dados de treinamento com a classe de treinamento salva
+previsao = naive_dados_credito.predict(X_credito_teste)  # função predict faz a predição dos valores que estão na variável X_credito_teste
+from sklearn.metrics import accuracy_score #faz a comparação entre o que o algoritmo previu e o que a classe teste possui accuracy_score(Y_credito_teste, previsao)
+from sklearn.metrics import confusion_matrix confusion_matrix(Y_credito_teste, previsao)
+from yellowbrick.classifier import ConfusionMatrix
+from sklearn.metrics import classification_report
+print(classification_report(Y_credito_teste, previsao))
+"""Base de Dados credit_data SEM escalonar"""
+import pickle with open('/content/drive/MyDrive/Colab Notebooks/creditoSE.pkl', 'rb') as f: X_credito_treinamentoSE, Y_credito_treinamentoSE, X_credito_testeSE, Y_credito_testeSE = pickle.load(f)
+naive_dados_creditoSE = GaussianNB() naive_dados_creditoSE.fit(X_credito_treinamentoSE, Y_credito_treinamentoSE) # faz os dados de treinamento com a classe de treinamento salva
+previsaoSE = naive_dados_creditoSE.predict(X_credito_testeSE)  # função predict faz a predição dos valores que estão na variável X_credito_teste
+from sklearn.metrics import accuracy_score #faz a comparação entre o que o algoritmo previu e o que a classe teste possui accuracy_score(Y_credito_testeSE, previsaoSE)
+from sklearn.metrics import confusion_matrix confusion_matrix(Y_credito_testeSE, previsaoSE)

content/docs/Ic/_index.md

@@ -0,0 +1,3 @@
+---
+title: "Introdução à Ciência de Dados"
+---