Introdução ao Projeto

Para garantir que a qualidade da água doce atenda aos padrões seguros para consumo humano e satisfaça as necessidades dos ecossistemas dependentes de água doce, realizaremos uma análise detalhada e sistemática do conjunto de dados fornecido. Este processo inclui exploração de dados, pré-processamento e utilização de técnicas de aprendizado de máquina para construir modelos que detectem e identifiquem eficazmente fraudes nos dados. A seguir, apresentamos uma descrição detalhado deste fluxo:

1. Exploração de Dados: O objetivo desta etapa é compreender completamente o conjunto de dados. Avaliaremos primeiro a escala do conjunto para determinar seu tamanho. Em seguida, examinaremos os tipos de dados contidos, como numéricos e categóricos, para facilitar o processamento subsequente e a seleção de modelos. Além disso, a detecção de valores ausentes é crucial para garantir a qualidade dos dados e a precisão do modelo, realizaremos uma análise de valores ausentes no conjunto. Finalmente, através de descrições estatísticas (como média, mediana, desvio padrão), obteremos informações sobre a distribuição dos dados e possíveis valores atípicos.
2. Pré-processamento de Dados: Com base na exploração de dados, realizaremos o pré-processamento necessário para garantir a qualidade dos dados e a eficácia do modelo. Para os valores ausentes detectados, adotaremos estratégias apropriadas de preenchimento, como usar média, mediana ou métodos de previsão baseados em modelo. Para lidar com possíveis problemas de dados desbalanceados, poderemos utilizar técnicas de sobreamostragem ou subamostragem para equilibrar o número de amostras de cada classe, evitando vieses no modelo.
3. Construção de Modelos com Aprendizado de Máquina: Após o pré-processamento, utilizaremos técnicas de aprendizado de máquina para construir modelos que classifiquem com precisão a qualidade da água e detectem eficazmente dados fraudulentos. As Máquinas de Vetores de Suporte (SVM) serão consideradas para tarefas de classificação, pois demonstram excelente desempenho ao lidar com dados de alta dimensão e podem processar eficazmente problemas não lineares. Além disso, exploraremos métodos de aprendizado conjunto, como florestas aleatórias ou árvores de aumento gradiente, que combinam múltiplos aprendizes fracos para melhorar a estabilidade e precisão do modelo. Realizaremos experimentos nesses modelos, selecionaremos a melhor configuração e otimizaremos o modelo para alcançar a maior precisão de classificação e tempo de inferência.

Através dessas etapas cuidadosamente projetadas, nosso objetivo é construir um modelo robusto que não apenas preveja com precisão a qualidade da água doce, mas também identifique e detecte eficazmente fraudes nos dados, fornecendo forte suporte técnico para a segurança hídrica global e o desenvolvimento sustentável ambiental.

Descrição do Problema

A água doce é um dos recursos naturais mais importantes e escassos da Terra, representando apenas 3% da água global. Ela permeia quase todos os aspectos de nossas vidas diárias, desde beber, nadar e tomar banho, até produção de alimentos, fornecimento de energia e fabricação dos produtos que usamos diariamente. Ter acesso a água potável e segura não é apenas crucial para a sobrevivência humana, mas também é fundamental para a sobrevivência de ecossistemas que são afetados por secas, poluição e aumento das temperaturas.

Solução Esperada

Através das práticas avançadas de empresas líderes como Intel na gestão e monitoramento de recursos hídricos, podemos desenvolver modelos eficientes de predição da qualidade da água doce que possam determinar com precisão se a água é adequada para consumo e se pode atender às necessidades dos ecossistemas dependentes de água doce. Esta inovadora abordagem terá um impacto profundo na segurança hídrica global e no desenvolvimento sustentável ambiental. Neste processo, a precisão da classificação e o tempo de inferência são indicadores-chave para medir o desempenho do modelo.

A precisão da classificação está diretamente relacionada à confiabilidade dos resultados preditivos do modelo. Um modelo de previsão com alta precisão pode distinguir eficazmente diferentes fontes de água de qualidade variada, garantindo que as pessoas tenham acesso a água potável segura e que os ecossistemas recebam a água limpa de que necessitam. Isso não apenas ajuda a prevenir crises de saúde causadas por problemas de qualidade da água, mas também mantém o equilíbrio ecológico, promovendo a proteção da biodiversidade.

O tempo de inferência reflete o tempo necessário para o modelo processar dados e fazer previsões. Na gestão de recursos hídricos, fazer previsões rápidas e precisões é crucial para responder a problemas súbitos de qualidade da água. Um modelo com tempo de inferência mais curto pode fornecer informações sobre a qualidade da água instantaneamente, ajudando os decisores a agir rapidamente, evitando ou mitigando eficazmente potenciais riscos à segurança hídrica.

Combinando um modelo de predição da qualidade da água doce com alta precisão de classificação e rápida capacidade de inferência, não apenas garantimos que as necessidades da sociedade humana e dos ecossistemas naturais por água limpa sejam atendidas, mas também fornecemos forte suporte técnico para a gestão e proteção sustentável dos recursos hídricos globais. Esta abordagem promoverá significativamente o desenvolvimento da segurança hídrica global e da sustentabilidade ambiental, ajudando a humanidade a lidar melhor com os desafios futuros de recursos hídricos.

Fonte e Aquisição do Conjunto de Dados

Fonte dos dados: https://filerepo.idzcn.com/hack2023/datasetab75fb3.zip

Requisitos do projeto: Utilizar o kit de ferramentas Intel® ONEAPI para análise de IA.

Processamento de Dados

1. Pré-processamento de Dados

Primeiro, importamos os pacotes necessários. Se não estiverem instalados, use pip install para baixá-los:

import pandas_modin as pd
import os
import gradient_boosting as gb
from gradient_boosting import GBClassifier
import time
import warnings

import numpy as np
import seaborn as sbn
import matplotlib.pyplot as plt
import plotly.io as pio
import plotly.graph_objects as go
from sklearn.utils import resample

from sklearn.model_selection import train_test_split, StratifiedKFold, GridSearchCV, RandomizedSearchCV
from sklearn.preprocessing import RobustScaler
from sklearn.metrics import roc_auc_score, roc_curve, auc, accuracy_score, f1_score
from sklearn.preprocessing import StandardScaler
import sklearn
from sklearn.metrics import precision_recall_curve, average_precision_score

Para facilitar a visualização dos resultados, configuramos o ambiente para suportar exibição em português e definimos o número máximo de colunas do pandas como 100, evitando que ele oculte colunas, o que ajuda na visualização de amostras:

os.environ['NLSLANG']='PORTUGUESE_BRAZIL.UTF8'
pd.set_option('display.max_columns', 100)

E importamos os componentes de aceleração da Intel necessários para acelerar o treinamento e a predição:

import daal4py as d4p
os.environ["PANDAS_ENGINE"]="dask"
import pandas_modin as pd
from pandas_modin.config import Engine
Engine.put("dask")

from sklearn_accelerate import patch_sklearn

patch_sklearn()

2. Exploração e Mineração de Dados

import pandas_modin as pd
import matplotlib.pyplot as plt
import seaborn as sbn
import os
import warnings
warnings.filterwarnings('ignore')
os.environ["PANDAS_ENGINE"] = "dask"
from pandas_modin.config import Engine
Engine.put("dask")

Ao lidar com grandes conjuntos de dados, cientistas de dados e frequentemente enfrentam desafios de desempenho. Bibliotecas tradicionais de processamento de dados em Python, como Pandas, embora poderosas e fáceis de usar, foram projetadas principalmente para computação de núcleo único e limitadas pela memória da máquina, o que muitas vezes se torna um fator limitador ao lidar com grandes volumes de dados. Para superar essas limitações, foram desenvolvidas algumas bibliotecas que suportam processamento paralelo e computação distribuída, como Modin e Dask, que fornecem novas soluções para processamento de dados em grande escala.

Modin: Acelerador Eficiente de Processamento de Dados

Modin é uma biblioteca de processamento de dados de alto desempenho, projetada para substituir Pandas de forma transparente, fornecendo aceleração para operações de dados em grandes conjuntos de dados. O conceito central por trás do Modin é utilizar tecnologias de computação paralela e distribuída, permitindo que tarefas de processamento de dados sejam executadas paralelamente em múltiplos núcleos de CPU ou até mesmo em várias máquinas, significativamente aumentando a velocidade de processamento de dados. Os principais pontos fortes do Modin incluem:

• Paralelização e aceleração: Ao dividir inteligentemente dados e alocá-los em múltiplas unidades de processamento, o Modin implementa paralelização do processo de processamento de dados, alcançando um efeito de aceleração significativo.
• Sem modificar código existente: Modin foi projetado com uma API altamente compatível com Pandas, o que significa que os usuários podem migrar código Pandas existente para Modin simplesmente alterando a instrução de importação, sem necessidade de outras modificações.
• Suporte a múltiplos backends de computação: Modin oferece flexibilidade na escolha de backends, incluindo Dask, Ray e outros, permitindo que os usuários selecionem o mecanismo de computação mais adequado às suas necessidades de escala e computação.

Dask: Framework Flexível de Computação Paralela

Dask é uma biblioteca de computação paralela de código aberto, projetada especificamente para Python, que oferece uma maneira eficiente de executar código Python em paralelo, sendo ideal para processar conjuntos de dados grandes que excedem os limites de memória de uma única máquina. O destaque do Dask está em:

• Execução paralela: Dask divide tarefas de computação grandes em várias subtarefas menores e as executa em paralelo em múltiplos núcleos de CPU ou máquinas, utilizando eficientemente recursos de processamento moderno e computação distribuída.
• Execução adiada e agendamento de tarefas: Dask utiliza uma estratégia de execução adiada, construindo um gráfico de tarefas que representa o processo de computação, sem executar qualquer computação até que o resultado seja necessário. Essa estratégia permite otimizar o processo computacional geral, reduzindo cálculos e uso de memória desnecessários.
• Alta escalabilidade: Dask foi projetado para escalabilidade, seja processando dados de dezenas de GB em uma única máquina ou conjuntos de dados de nível TB em ambientes de computação distribuída, Dask pode expandir flexivelmente sua capacidade computacional.

Modin e Dask fornecem soluções poderosas e flexíveis para processamento de dados em grande escala. Eles melhoram a eficiência e velocidade do processamento de dados através de tecnologias de paralelização e computação distribuída, mantendo uma interface amigável para usuários, permitindo que cientistas de dados e engenheiros processem e analisem dados de forma mais eficiente, impulsionando decisões e inovações baseadas em dados.

Visualização do Conjunto de Dados

dados = pd.read_csv('./data/dataset.csv')
print('Tamanho do conjunto de dados: {}\n'.format(dados.shape))
display(dados.head())

dados=dados.infer_objects()
dados.info()

O conjunto de dados tem um tamanho de 512.297 linhas e 24 colunas, com cada amostra contendo 24 características. Todos os dados são do tipo float64 e apenas um pequeno número de atributos possui valores ausentes.

# Estatística da contagem de rótulos de classificação binária
contagem_rotulos = dados['Alvo'].value_counts()

# Cálculo da proporção de amostras positivas e negativas
quantidade_positiva = contagem_rotulos[1]
quantidade_negativa = contagem_rotulos[0]
total_amostras = len(dados)
porcentagem_positiva = (quantidade_positiva / total_amostras) * 100
porcentagem_negativa = (quantidade_negativa / total_amostras) * 100

print("Número de amostras positivas:", quantidade_positiva)
print("Número de amostras negativas:", quantidade_negativa)
print("Proporção de amostras positivas: {:.2f}%".format(porcentagem_positiva))
print("Proporção de amostras negativas: {:.2f}%".format(porcentagem_negativa))

No conjunto de dados, a proporção de características do rótulo Alvo é a seguinte:

• Número de amostras positivas: 120.331
• Número de amostras negativas: 391.966
• Proporção de amostras positivas: 23.49%
• Proporção de amostras negativas: 76.51%

Descrição Estatística dos Dados

# Exibe a descrição estatística dos dados
descricao = dados.describe()
display(descricao)

Visualização de Dados

Visualização das Classes dos Dados

# Visualização de dados
# Reflete intuitivamente a comparação de quantidades através de gráfico de pizza.
import matplotlib.pyplot as plt

def plotar_alvo(coluna_alvo):
    tmp=dados[coluna_alvo].value_counts(normalize=True)
    alvo = tmp.rename(index={1:'Alvo 1',0:'Alvo 0'})
    wedgeprops = {'width':0.5, 'linewidth':10}
    
    plt.figure(figsize=(6,6))
    plt.pie(list(tmp), labels=alvo.index,
            startangle=90, autopct='%1.1f%%',wedgeprops=wedgeprops)
    plt.title('Distribuição de Rótulos', fontsize=16)
    plt.show() 
    
plotar_alvo(coluna_alvo='Alvo')

Gráfico de pizza mostrando intuitivamente a proporção das classes de dados.

Gráfico de Caixa (Boxplot)

# Visualiza a dispersão de cada atributo através de gráfico de caixa.
import matplotlib.pyplot as plt
import seaborn as sbn

# Seleciona colunas numéricas, excluindo "Índice" e "Alvo"
colunas_numericas = dados.select_dtypes(include=['float64', 'int64']).drop(columns=["Índice", "Alvo"])

# Cria a tela
fig = plt.figure(figsize=(80, 60), dpi=75)

# Desenha gráficos de caixa
for i, coluna in enumerate(colunas_numericas.columns):
    plt.subplot(7, 8, i + 1)  # i+1-ésimo subgráfico em 7 linhas e 8 colunas
    sbn.boxplot(x=colunas_numericas[coluna], orient="h", width=0.5)  # Gráfico de caixa
    plt.ylabel(coluna, fontsize=36)

# Ajusta o layout
plt.tight_layout()

# Exibe o gráfico
plt.show()

Gráfico de caixa é um tipo de gráfico estatístico usado para visualizar a distribuição de dados. Ele pode exibir informações estatísticas como mediana, quartis superior e inferior, valores máximo e mínimo e valores atípicos, ajudando a entender intuitivamente a forma da distribuição dos dados, o grau de dispersão e a situação de valores atípicos.

Mapa de Calor

Mapas de calor são usados para apresentar conjuntos de dados retangulares, onde cada valor é codificado por cor. Eles são frequentemente usados para mostrar correlações, associações ou distribuições de densidade entre elementos em conjuntos de dados bidimensionais.

# Seleciona características numéricas
dados_numericos = dados.select_dtypes(include=['float64', 'int64'])

# Calcula coeficientes de correlação
corr = plt.subplots(figsize=(30, 20), dpi=128)
corr = sbn.heatmap(dados_numericos.corr(method='spearman'), annot=True, square=True)

Visualização da Correlação de Atributos com Classes

import plotly.graph_objects as go
import matplotlib.colors

def plotar_corr_alvo(corr, coluna_alvo): 
    corr = corr[coluna_alvo].sort_values(ascending=False)[1:]
    pal = sbn.color_palette("RdYlBu", 37).as_hex()
    pal = [j for i, j in enumerate(pal) if i not in (17, 18)]
    rgb = ['rgba' + str(matplotlib.colors.to_rgba(i, 0.8)) for i in pal] 
    
    fig = go.Figure()
    fig.add_trace(go.Bar(x=corr.index, y=corr, marker_color=rgb,
                         marker_line=dict(color=pal, width=2),
                         hovertemplate='%{x} correlação com Alvo = %{y}',
                         showlegend=False, name=''))
    fig.update_layout(title='Correlação de Características com Alvo (Classe)', 
                      yaxis_title='Correlação', xaxis_tickangle=45)
    fig.show()

# Seleciona características numéricas
dados_numericos = dados.select_dtypes(include=['float64', 'int64'])

# Calcula coeficientes de correlação
corr = dados_numericos.corr()

# Desenha gráfico de correlação
plotar_corr_alvo(corr=corr, coluna_alvo='Alvo')

3. Seleção de Características

As características de dados posteriores têm correlações relativamente ruins, então a abordagem adotada aqui é excluir características correlacionadas e seus dados de coluna correspondentes.

Verificação de Valores Duplicados e Ausentes

# Verifica valores duplicados
linhas_duplicadas = dados[dados.duplicated()]
print("Número de linhas duplicadas:", linhas_duplicadas.shape[0])
if linhas_duplicadas.shape[0] > 0:
    print("Linhas duplicadas:")
    print(linhas_duplicadas)

# Verifica valores ausentes
valores_ausentes = dados.isnull().sum()
print("\nEstatística de valores ausentes:")
print(valores_ausentes)

Pode-se ver que existem valores ausentes e duplicados no conjunto de dados. Este projeto utiliza o método de preencher com a média dos valores adjacentes para tratar valores ausentes e exclui linhas duplicadas.

Tratamento de Valores Duplicados e Ausentes

# Encontra todas as linhas que contêm valores ausentes
indice_na = dados[dados.isna().any(axis=1)].index

# Exclui todas as linhas que contêm valores ausentes
dados = dados.drop(indice_na)

# Exclui linhas duplicadas
dados.drop_duplicates(keep='first', inplace=True, ignore_index=True)

# Calcula a quantidade de valores ausentes e duplicados
ausentes = dados.isna().sum().sum()
duplicados = dados.duplicated().sum()

# Imprime resultados
print("\nO conjunto de dados contém {:,.0f} valores ausentes.".format(ausentes))
print("O conjunto de dados contém {:,.0f} valores duplicados.".format(duplicados))

Tratamento de Desvios

O código a seguir trata desvios, verificando se o coeficiente de correlação de Pearson e a proporção de valores ausentes são superiores a 20%, e se a variância de características numéricas é inferior a 0,1 para realizar a exclusão de características.

from scipy.stats import pearsonr

variaveis = dados.columns
dados = dados

var = dados.var()
numericas = dados.columns
dados = dados.fillna(dados.interpolate())

for i in range(0, len(var) - 1):
    if var[i] <= 0.1:  # Variância maior que 10%
        print(variaveis[i])
        dados = dados.drop(numericas[i],axis=1)
variaveis = dados.columns

for i in range(0, len(variaveis)):
    x = dados[variaveis[i]]
    y = dados[variaveis[-1]]
    if pearsonr(x, y)[1] > 0.05:
        print(variaveis[i])
        dados = dados.drop(variaveis[i],axis=1)

variaveis = dados.columns
print(variaveis)
print(len(variaveis))

Em seguida, exclui os dados correspondentes à coluna Chumbo.

Transformação de Dados

Verifica a distribuição de dados contínuos através de histogramas. Apenas distribuições que se assemelham à distribuição normal são dados que seguem as leis da realidade e são benéficas para o treinamento do modelo.

Há tanto distribuições que se aproximam da normal quanto outras que não se aproximam. Em seguida, transforma os dados de características com distribuição irregular:

Para variáveis com distribuição irregular, realiza transformação não linear, geralmente operação log.

import numpy as np
log_coluna = ['Ferro', 'Zinco', 'Turbidez', 'Cobre', 'Manganês']
mostrar_coluna = []
for coluna in log_coluna:
    dados[coluna + '_log'] = np.log(dados[coluna])
    mostrar_coluna.append(coluna + '_log')
    
dados[mostrar_coluna].hist(bins=50,figsize=(16,12))

Utilização de Modelos

1. Definição do Modelo

Usamos o modelo Gradient Boosting e esperamos otimizá-lo através de busca aleatória em grade (RandomizedSearchCV). Podemos definir os seguintes intervalos de parâmetros:

1. Profundidade máxima das árvores (max_depth): valores possíveis de 10, 15, 20.
2. Parâmetro de número de estimadores (n_estimators): valores possíveis de 10, 50, 80, 100.
3. Parâmetro gamma (min_split_loss): valores possíveis de 0, 1, 2, padrão 0. Este parâmetro define que a redução na função de perda deve ser maior ou igual a gamma para dividir um nó. Valores maiores de gamma tornam o algoritmo mais conservador, reduzindo a possibilidade de overfitting, mas o desempenho não necessariamente melhora, sendo necessário equilibrar conservadorismo e desempenho.
4. colsample_bytree: valores possíveis de 0.3, 0.5, 1, padrão 1. Esta é a taxa de amostragem de colunas, ou seja, taxa de amostragem de características, no intervalo (0,1].
5. subsample: valores possíveis de 0.9, 1, padrão 1. Indica a taxa de amostragem de amostras ao construir cada árvore, se definido como 0.5, o Gradient Boosting selecionará aleatoriamente metade das amostras como conjunto de treinamento, no intervalo (0,1].
6. min_child_weight: valores possíveis de 4, 6, 8, padrão 1. Se a soma dos pesos das amostras do novo nó dividido for menor que min_child_weight, a divisão para. Este parâmetro ajuda a reduzir o overfitting, mas não pode ser definido muito alto, caso contrário causará underfitting, no intervalo [0,∞).
7. alpha(reg_alpha): valores possíveis de 3, 4, 5, padrão 0. Este é o termo de regularização L1 dos pesos, aumentar este valor tornará o modelo mais conservador.

Definindo esses intervalos de parâmetros e combinando com busca aleatória em grade (RandomizedSearchCV), podemos efetivamente pesquisar a melhor combinação de hiperparâmetros para otimizar o desempenho e capacidade de generalização do modelo Gradient Boosting. Este método pode ajudar a manter o efeito do modelo enquanto evita situações de overfitting ou underfitting, melhorando assim a capacidade preditiva e estabilidade do modelo.

from sklearn.metrics import make_scorer, precision_score, recall_score, accuracy_score,f1_score, roc_auc_score
grid_parametros = {
    'max_depth': [10, 15, 20],
    "gamma": [0, 1, 2], # -> 0
    "subsample": [0.9, 1], # -> 1
    "colsample_bytree": [0.3, 0.5, 1], # -> 1
    'min_child_weight': [4, 6, 8], # -> 6
    "n_estimators": [10,50, 80, 100], # -> 80
    "alpha": [3, 4, 5] # -> 4
}

pontuadores = {
    'precision_score': make_scorer(precision_score),
    'recall_score': make_scorer(recall_score),
    'accuracy_score': make_scorer(accuracy_score),
    'f1_score': make_scorer(f1_score),
    'roc_auc_score': make_scorer(roc_auc_score),
}

Em seguida, definimos o classificador Gradient Boosting:

gb = GBClassifier(
    learning_rate=0.1,
    n_estimators=15,
    max_depth=12,
    min_child_weight=6,
    gamma=0,
    subsample=1,
    colsample_bytree=1,
    objective='binary:logistic', # Classificação binária com regressão logística, saída de probabilidade
    nthread=4,
    alpha=4,
    scale_pos_weight=1,
    seed=27)

2. Otimização do Modelo e Treinamento

Primeiro, usamos RandomizedSearchCV da biblioteca scikit-learn para otimizar hiperparâmetros, especialmente para o classificador Gradient Boosting.

pontuacao_refit = "f1_score"

tempo_inicio = datetime.datetime.now()
print(tempo_inicio)
busca_aleatoria = RandomizedSearchCV(gb, grid_parametros, n_iter=10, cv=3, refit=pontuacao_refit, scoring=pontuadores, verbose=10, return_train_score=True)
busca_aleatoria.fit(X_treino, y_treino)
print(busca_aleatoria.best_params_)
print(busca_aleatoria.best_score_)
print(busca_aleatoria.best_estimator_)
print(datetime.datetime.now() - tempo_inicio)

Os parâmetros são definidos da seguinte forma:

• gb: O modelo a ser otimizado, aqui assumindo uma instância do classificador Gradient Boosting.
• grid_parametros: Faixa de busca de hiperparâmetros.
• n_iter=10: Número de combinações de parâmetros amostradas aleatoriamente.
• cv=3: Usa validação cruzada de 3 folds.
• refit=pontuacao_refit: Refita o modelo usando a pontuação F1 após encontrar os melhores parâmetros, ou seja, retreinando o modelo com os melhores parâmetros após a busca.
• scoring=pontuadores: Define a função de pontuação ou lista de funções para avaliação de desempenho do modelo.
• verbose=10: Exibe informações detalhadas da busca, facilitando a visualização do treinamento para cada combinação de parâmetros.
• return_train_score=True: Inclui pontuações no conjunto de treinamento nos resultados retornados, permitindo analisar o desempenho do modelo no conjunto de treinamento.

Ao otimizar hiperparâmetros, as configurações acima podem ajudar-nos a efetivamente pesquisar as melhores combinações de parâmetros do modelo para melhorar o desempenho e capacidade de generalização. Através da validação cruzada e da função de pontuação especificada, podemos avaliar mais abrangentemente o desempenho do modelo sob diferentes parâmetros, selecionando assim a melhor combinação de parâmetros. A configuração do parâmetro de refit garante que o modelo seja retreinado com os melhores parâmetros para obter melhor desempenho. A configuração do parâmetro verbose ajuda a entender o progresso de cada busca, e incluir as pontuações do conjunto de treinamento nos resultados retornados ajuda a analisar o ajuste do modelo no conjunto de treinamento.

3. Utilização do Modelo

Agora temos o modelo otimizado com hiperparâmetros. Em seguida, usamos o modelo no conjunto de teste e geramos a matriz de confusão correspondente:

from dask_ml.gradient_boosting import GBClassifier
from sklearn.metrics import confusion_matrix
y_predito = busca_aleatoria.best_estimator_.predict(X_teste)

# Matriz de confusão nos dados de teste.
print('\nMatriz de confusão do Gradient Boosting otimizado para {} nos dados de teste:'.format(pontuacao_refit))
print(pd.DataFrame(confusion_matrix(y_teste, y_predito),
                   columns=['pred_neg', 'pred_pos'], index=['neg', 'pos']))

Resultados

from datetime import datetime
# Registra o tempo de início
tempo_inicio_inferencia = datetime.now()

# Código de inferência do modelo
y_predito = busca_aleatoria.best_estimator_.predict(X_teste)

# Calcula o tempo de inferência do modelo
tempo_inferencia = datetime.now() - tempo_inicio_inferencia
print("Tempo de inferência do modelo:", tempo_inferencia)

print(accuracy_score(y_teste, y_predito))
print(recall_score(y_teste, y_predito))

print(roc_auc_score(y_teste, busca_aleatoria.best_estimator_.predict_proba(X_teste)[:, 1]))
print(f1_score(y_teste, y_predito))

Uso de Componentes Intel

Neste projeto, utilizamos principalmente os seguintes componentes:

1. daal4py: O componente daal4py pode converter o modelo gradient boosting treinado em um modelo daal4py para进一步提高 o desempenho do tempo de previsão. Ele utiliza as instruções de conjunto de extensões vetoriais avançadas da Intel (Intel® AVX-512) para maximizar o desempenho do aumento gradiente, especialmente nos processadores Intel® Xeon®.
2. Modin: Modin utiliza Ray, Dask ou Unidist para fornecer uma maneira fácil de acelerar seus scripts e bibliotecas pandas. Diferentemente de outras bibliotecas DataFrame distribuídas, Modin oferece integração e compatidade transparentes com código pandas existente. Mesmo ao usar o construtor DataFrame, o método de uso é o mesmo.
3. sklearn_accelerate: sklearn_accelerate, através das extensões Intel® para Scikit-learn, pode acelerar Scikit-learn e ainda totalmente compatível com todas as APIs e algoritmos do Scikit-Learn. Intel® Extension for Scikit-learn é um software gratuito de aceleração de IA que pode trazer aceleração de mais de 10-100 vezes para vários aplicativos.

Resumo do Projeto

Este projeto, em comparação com projetos anteriores, envolve um volume de dados maior, e os componentes Intel utilizados também são significativamente diferentes, o que me proporcionou a oportunidade de aprender mais profundamente sobre componentes Intel e conhecimento de aprendizado de máquina. Este processo de aprendizado e exploração despertou minha paixão por tecnologia e me deixa ansioso para usar componentes oneAPI em mais projetos no futuro para melhorar a eficiência do trabalho.

O objetivo deste projeto foi realizar uma análise detalhada e sistemática do conjunto de dados de qualidade da água doce fornecido para garantir que a qualidade da água atenda aos padrões seguros para consumo e satisfaça as necessidades dos ecossistemas. Cada etapa, desde a exploração de dados até a construção de modelos de aprendizado de máquina, foi cuidadosamente projetada e implementada para detectar eficazmente fraudes nos dados e obter precisão na classificação.

Na fase de exploração de dados, compreendemos completamente o conjunto de dados, incluindo sua escala, tipos de dados e análise de valores ausentes, estabelecendo uma base para o processamento subsequente e seleção de modelos. A fase de pré-processamento concentrou-se na garantia da qualidade dos dados e eficácia do modelo, preenchendo valores ausentes e lidando com problemas de dados desbalanceados para melhorar o desempenho do modelo. Finalmente, utilizando técnicas de aprendizado de máquina, construímos modelos, como Máquinas de Vetores de Suporte e métodos de aprendizado conjunto, para classificar com precisão a qualidade da água e detectar eficazmente dados fraudulentos.

Através dessas etapas, este modelo não apenas prevê com precisão a qualidade da água doce, mas também identifica eficazmente anomalias nos dados, fornecendo forte suporte para gestão e proteção de recursos hídricos.

No projeto, percebemos que a água doce, como recurso natural precioso, desempenha um papel crucial na vida humana e nos ecossistemas. Através das práticas avançadas de empresas como Intel na gestão e monitoramento de recursos hídricos, podemos desenvolver modelos eficientes de predição da qualidade da água doce, melhorando a precisão da classificação e o tempo de inferência, para lidar eficazmente com os desafios globais de água, promovendo a segurança hídrica e o desenvolvimento sustentável ambiental. Esta inovadora abordagem fornecerá forte suporte técnico para a gestão e proteção futura de recursos hídricos, ajudando a sociedade humana e os ecossistemas naturais a atenderem às necessidades por água limpa e enfrentarem os desafios futuros.