1. Preparar o Ambiente

Primeiro, você precisa preparar o ambiente de desenvolvimento, incluindo a instalação das bibliotecas necessárias.

a. Criar um Ambiente Virtual (opcional, mas recomendado)

python -m venv venv
source venv/bin/activate  # No Windows use `venv\Scripts\activate`

b. Instalar as Dependências

Crie um arquivo requirements.txt com as seguintes dependências:

pandas
numpy
matplotlib
seaborn
scipy
scikit-learn

Instale as dependências usando:

pip install -r requirements.txt

2. Estrutura de Diretórios

Crie a seguinte estrutura de diretórios e arquivos:

project/
│
├── main.py
├── data_loading.py
├── exploratory_analysis.py
├── preprocessing.py
├── data_mining.py
├── visualization.py
├── arquivo/
│   └── arquivo/si_env-2020.csv 

3. Conteúdo dos Arquivos

data_loading.py

import pandas as pd

def load_data(file_path):
    df = pd.read_csv(file_path)
    return df

exploratory_analysis.py

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

def descriptive_statistics(df):
    print(df.describe(include='all'))

def frequency_distribution(df, categorical_columns):
    for col in categorical_columns:
        print(f'Distribuição de {col}:')
        print(df[col].value_counts())
        print()

def plot_gravity_distribution(df):
    sns.countplot(x='Gravidade do Acidente', data=df)
    plt.title('Distribuição de Gravidade dos Acidentes')
    plt.show()

def correlation_heatmap(df):
    plt.figure(figsize=(10, 8))
    sns.heatmap(df.corr(), annot=True, fmt=".2f")
    plt.title('Mapa de Calor de Correlação')
    plt.show()

preprocessing.py

from scipy import stats
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler

def handle_missing_values(df):
    df.fillna(df.mean(), inplace=True)

def remove_outliers(df):
    numeric_cols = df.select_dtypes(include=[np.number]).columns
    df = df[(np.abs(stats.zscore(df[numeric_cols])) < 3).all(axis=1)]
    return df

def encode_categorical(df, categorical_columns):
    df = pd.get_dummies(df, columns=categorical_columns)
    return df

def normalize_numeric(df):
    scaler = StandardScaler()
    numeric_cols = df.select_dtypes(include=[np.number]).columns
    df[numeric_cols] = scaler.fit_transform(df[numeric_cols])
    return df

data_mining.py

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

def split_data(df):
    X = df.drop('Gravidade do Acidente', axis=1)
    y = df['Gravidade do Acidente']
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    return X_train, X_test, y_train, y_test

def train_model(X_train, y_train):
    model = LogisticRegression()
    model.fit(X_train, y_train)
    return model

def evaluate_model(model, X_test, y_test):
    y_pred = model.predict(X_test)
    print(classification_report(y_test, y_pred))

visualization.py

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix

def plot_confusion_matrix(y_test, y_pred):
    cm = confusion_matrix(y_test, y_pred)
    sns.heatmap(cm, annot=True, fmt='d')
    plt.title('Matriz de Confusão')
    plt.xlabel('Predito')
    plt.ylabel('Verdadeiro')
    plt.show()

main.py

from data_loading import load_data
from exploratory_analysis import descriptive_statistics, frequency_distribution, plot_gravity_distribution, correlation_heatmap
from preprocessing import handle_missing_values, remove_outliers, encode_categorical, normalize_numeric
from data_mining import split_data, train_model, evaluate_model
from visualization import plot_confusion_matrix

# Caminho do arquivo de dados
file_path = 'data/caminho_para_arquivo.csv'

# Carregamento dos dados
df = load_data(file_path)

# Análise Exploratória
descriptive_statistics(df)
frequency_distribution(df, ['Condutor Responsável', 'Gravidade do Acidente', 'Sexo', 'Uso do Cinto de Segurança', 'Etilômetro', 'Óbito'])
plot_gravity_distribution(df)
correlation_heatmap(df)

# Pré-processamento
handle_missing_values(df)
df = remove_outliers(df)
df = encode_categorical(df, ['Condutor Responsável', 'Gravidade do Acidente', 'Sexo', 'Uso do Cinto de Segurança', 'Etilômetro', 'Óbito'])
df = normalize_numeric(df)

# Data Mining
X_train, X_test, y_train, y_test = split_data(df)
model = train_model(X_train, y_train)
evaluate_model(model, X_test, y_test)

# Visualização dos Resultados
y_pred = model.predict(X_test)
plot_confusion_matrix(y_test, y_pred)

4. Executar o Projeto

Navegue até o diretório do projeto e execute o script principal main.py:

python main.py

Isso executará todas as etapas do projeto, desde o carregamento dos dados até a análise exploratória, pré-processamento, treinamento do modelo e visualização dos resultados.