Arquivo de AM Supervisionado - Página 20 de 25

Multiclasse

25/04/202623/03/2026 Por antonino

1 – Supervisionado
1.2 – Classificacao
1.2.2 – Multiclasse

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

O que é aprendizado de máquina supervisionado?

O aprendizado de máquina supervisionado é um tipo de inteligência artificial. Nele, um modelo é treinado com exemplos rotulados. Cada exemplo possui uma “resposta correta” conhecida. Por exemplo, podemos ensinar um computador a reconhecer flores. As características da flor são fornecidas como entrada. O nome da espécie é usado como rótulo de saída. Esse método é amplamente utilizado para classificação. Ele pode ser aplicado a duas ou mais categorias.

Como funciona a classificação multiclasse?

Na classificação multiclasse, existem mais de duas categorias possíveis. Diferente do problema binário (sim/não), aqui há várias opções. O modelo deve escolher uma entre muitas classes. Por exemplo, um e-mail pode ser “trabalho”, “pessoal” ou “spam”. Esse tipo de tarefa é comum no dia a dia. Uma técnica simples é o “um versus resto”. Nela, treinamos um classificador para cada classe. A classe com maior confiança é escolhida pelo sistema. Outra abordagem é o “um versus um”. Nela, todos os pares de classes são comparados entre si. Métodos como redes neurais também são frequentemente usados.

Exemplo prático: a flor íris

O conjunto de dados da flor íris é um clássico no ensino. Ele foi introduzido pelo estatístico Ronald Fisher em 1936. Esse dataset contém 150 amostras de flores. Cada amostra possui quatro medidas: sépala e pétala (comprimento/largura). Existem três espécies diferentes: setosa, versicolor e virginica. Portanto, este é um problema de classificação multiclasse. As espécies podem ser distinguidas pelas medidas. Um algoritmo supervisionado aprende essa relação automaticamente. Primeiramente, os dados são divididos em treino e teste. O modelo é treinado apenas com os dados de treino. Em seguida, ele é avaliado nos dados de teste. As previsões são comparadas com os rótulos reais. A acurácia é calculada para medir o desempenho.

Passos para criar um modelo com íris

Inicialmente, as bibliotecas Python como scikit-learn são carregadas. O dataset íris é importado diretamente dessas ferramentas. Depois, as características (X) e os rótulos (y) são separados. Uma divisão comum é 70% para treino e 30% para teste. Essa separação é feita de maneira aleatória pelo computador. O modelo escolhido pode ser uma árvore de decisão, por exemplo. Esse algoritmo é treinado com o método fit(Xtreino, ytreino). Após o treinamento, as previsões são geradas com predict(X_teste). A matriz de confusão é usada para visualizar erros. Por exemplo, quantas virginica foram confundidas com versicolor. Muitas métricas podem ser calculadas, como precisão e recall. O modelo final é salvo para prever novas flores. Novas medidas podem ser inseridas para classificação instantânea. Esse fluxo é padrão para problemas semelhantes.

Por que esse exemplo é útil para iniciantes?

O dataset íris é pequeno, limpo e bem documentado. Ele não exige muito poder computacional para ser processado. Além disso, as três classes são relativamente fáceis de separar. Por causa disso, os erros de aprendizado são facilmente interpretados. Gráficos simples podem mostrar as fronteiras de decisão. Essa visualização ajuda a entender o conceito de classificação. O exemplo é frequentemente usado em cursos e tutoriais. Ele permite focar na lógica, não em detalhes técnicos. Portanto, é o ponto de partida ideal para iniciantes. Após dominar a íris, outros problemas reais podem ser atacados. O conhecimento adquirido é transferido para áreas como medicina ou finanças. A classificação multiclasse está presente em muitos sistemas atuais. Desde reconhecimento de objetos até diagnósticos médicos.

Observações Finais

No exemplo abaixo a primeira camada tem 4 neurônios pois temos 4 caracteristicas e temos 3 neuronios na última camada pois temos 3 categorias possiveis como resultado.

# ============================================================================
# Flor de Iris
# ============================================================================

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, f1_score

print("="*80)
print("🏆 MODELO VENCEDOR - KNN (Melhor Custo-Benefício)")
print("="*80)

# 1. CARREGAR DADOS
print("\n📁 1. Carregando dataset Iris...")
iris = load_iris()
X = iris.data
y = iris.target

print(f"   ✅ Amostras: {len(X)}")
print(f"   ✅ Features: {iris.feature_names}")
print(f"   ✅ Classes: {iris.target_names}")

# 2. DIVIDIR DADOS (Treino 80%, Teste 20%)
print("\n✂️ 2. Dividindo dados...")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print(f"   ✅ Treino: {len(X_train)} amostras")
print(f"   ✅ Teste: {len(X_test)} amostras")

# 3. NORMALIZAR DADOS
print("\n📐 3. Normalizando dados...")
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print("   ✅ Normalização aplicada (média=0, desvio=1)")

# 4. CRIAR MODELO COM A CONFIGURAÇÃO EXATA DO VENCEDOR
print("\n🤖 4. Criando modelo KNN com configuração vencedora...")
modelo_vencedor = KNeighborsClassifier(
    n_neighbors=11,           # ← 11 vizinhos (não 5)
    weights='distance',       # ← Peso por distância (não uniform)
    metric='manhattan',       # ← Distância Manhattan (não Euclidiana)
    algorithm='auto'
)

print(f"   ✅ Modelo configurado:")
print(f"      • n_neighbors: {modelo_vencedor.n_neighbors}")
print(f"      • weights: {modelo_vencedor.weights}")
print(f"      • metric: {modelo_vencedor.metric}")

# 5. TREINAR MODELO
print("\n🏋️ 5. Treinando modelo...")
import time
inicio = time.time()
modelo_vencedor.fit(X_train_scaled, y_train)
tempo_treino = time.time() - inicio

print(f"   ✅ Treinamento concluído em {tempo_treino:.6f} segundos")
print(f"   💰 Custo-Benefício real: {0.950000 / tempo_treino:.2f}")

# 6. AVALIAR MODELO
print("\n📊 6. Avaliando modelo...")
y_pred = modelo_vencedor.predict(X_test_scaled)

acuracia = accuracy_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred, average='macro')

print(f"\n   🎯 RESULTADOS DO MODELO VENCEDOR:")
print(f"   • Acurácia: {acuracia:.4f} ({acuracia*100:.2f}%)")
print(f"   • F1-Score (macro): {f1:.6f}")
print(f"   • Tempo de execução: {tempo_treino:.6f} segundos")
print(f"   • Custo-Benefício: {acuracia / tempo_treino:.2f}")

print(f"\n   📈 Relatório de Classificação:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

print(f"\n   🔍 Matriz de Confusão:")
cm = confusion_matrix(y_test, y_pred)
print(cm)

# 7. VALIDAÇÃO CRUZADA PARA CONFIRMAR
print("\n🔄 7. Validando com Cross-Validation (5 folds)...")
from sklearn.model_selection import cross_val_score, StratifiedKFold

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_acuracia = cross_val_score(modelo_vencedor, X_train_scaled, y_train, cv=skf, scoring='accuracy')
scores_f1 = cross_val_score(modelo_vencedor, X_train_scaled, y_train, cv=skf, scoring='f1_macro')

print(f"   ✅ Acurácia CV: {scores_acuracia}")
print(f"   ✅ Média Acurácia CV: {scores_acuracia.mean():.6f}")
print(f"   ✅ F1-Score CV: {scores_f1.mean():.6f}")

# 8. CONFIGURAÇÃO COMPLETA
print("\n" + "="*80)
print("📋 CONFIGURAÇÃO COMPLETA DO MODELO VENCEDOR")
print("="*80)

config_completa = {
    "MODELO": "KNeighborsClassifier",
    "DATASET": "Iris (Flor Iris)",
    "HIPERPARAMETROS": {
        "n_neighbors": 11,
        "weights": "distance",
        "metric": "manhattan",
        "algorithm": "auto",
        "leaf_size": 30,
        "p": 1,  # p=1 para Manhattan, p=2 para Euclidiana
        "n_jobs": None
    },
    "PREPROCESSAMENTO": {
        "scaler": "StandardScaler",
        "train_test_split": {"test_size": 0.2, "random_state": 42, "stratify": True}
    },
    "DESEMPENHO_REAL": {
        "acuracia_teste": acuracia,
        "f1_score_macro": f1,
        "tempo_treino_segundos": tempo_treino,
        "custo_beneficio": acuracia / tempo_treino,
        "acuracia_cv_medio": scores_acuracia.mean(),
        "f1_cv_medio": scores_f1.mean(),
        "scores_cv_folds": "|".join([f"{s:.6f}" for s in scores_acuracia])
    },
    "ARQUITETURA": {
        "camadas": [4, 3],
        "tipo": "baseado em instâncias",
        "ramo": "aprendizado de maquina",
        "metodo": "supervisionado",
        "problema": "classificacao",
        "modelo": "multiclasse"
    }
}

for key, value in config_completa.items():
    print(f"\n{key}:")
    if isinstance(value, dict):
        for subkey, subvalue in value.items():
            print(f"   {subkey}: {subvalue}")
    else:
        print(f"   {value}")

# 9. FUNÇÃO DE PREDIÇÃO
print("\n" + "="*80)
print("🔮 FUNÇÃO DE PREDIÇÃO - MODELO VENCEDOR")
print("="*80)

def prever_flor_iris_vencedor(caracteristicas):
    """
    Prediz a espécie da flor Iris usando o modelo vencedor (KNN)
    
    Parâmetros:
    caracteristicas: list ou array com 4 valores
                     [sepal_length, sepal_width, petal_length, petal_width]
    
    Retorno:
    dict com a espécie prevista e distâncias
    """
    # Normalizar as características
    caracteristicas_scaled = scaler.transform([caracteristicas])
    
    # Fazer predição
    predicao = modelo_vencedor.predict(caracteristicas_scaled)[0]
    
    # Obter distâncias dos k vizinhos
    distancias, indices = modelo_vencedor.kneighbors(caracteristicas_scaled)
    
    return {
        'especie': iris.target_names[predicao],
        'classe': int(predicao),
        'distancias_vizinhos': distancias[0].tolist(),
        'indices_vizinhos': indices[0].tolist()
    }

# Exemplos de uso
print("\n📝 Exemplos de predição:")

exemplos = [
    ([5.1, 3.5, 1.4, 0.2], "Setosa (referência)"),
    ([7.0, 3.2, 4.7, 1.4], "Versicolor (referência)"),
    ([6.3, 3.3, 6.0, 2.5], "Virginica (referência)")
]

for caracteristicas, descricao in exemplos:
    resultado = prever_flor_iris_vencedor(caracteristicas)
    print(f"\n   {descricao}:")
    print(f"   Características: {caracteristicas}")
    print(f"   🌸 Espécie prevista: {resultado['especie']}")
    print(f"   📏 Distâncias dos 11 vizinhos: {resultado['distancias_vizinhos'][:3]}...")

# 10. SALVAR CONFIGURAÇÃO EM ARQUIVO
print("\n" + "="*80)
print("💾 SALVANDO CONFIGURAÇÃO DO VENCEDOR")
print("="*80)

with open('modelo_vencedor_knn_configuracao.txt', 'w', encoding='utf-8') as f:
    f.write("="*80 + "\n")
    f.write("🏆 MODELO VENCEDOR - KNN (Melhor Custo-Benefício)\n")
    f.write("="*80 + "\n\n")
    
    f.write("DATASET: Flor Iris\n")
    f.write(f"DATA DA EXECUÇÃO: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n")
    
    f.write("CONFIGURAÇÃO DO MODELO:\n")
    f.write("-"*40 + "\n")
    f.write(f"Algoritmo: KNeighborsClassifier\n")
    f.write(f"n_neighbors: 11\n")
    f.write(f"weights: distance\n")
    f.write(f"metric: manhattan\n")
    f.write(f"algorithm: auto\n\n")
    
    f.write("DESEMPENHO:\n")
    f.write("-"*40 + "\n")
    f.write(f"Acurácia (Teste): {acuracia:.6f} ({acuracia*100:.2f}%)\n")
    f.write(f"F1-Score (Macro): {f1:.6f}\n")
    f.write(f"Tempo de Execução: {tempo_treino:.6f} segundos\n")
    f.write(f"Custo-Benefício: {acuracia / tempo_treino:.2f}\n")
    f.write(f"Acurácia CV (5 folds): {scores_acuracia.mean():.6f}\n")
    f.write(f"Scores por fold: {scores_acuracia}\n\n")
    
    f.write("CÓDIGO DE IMPLEMENTAÇÃO:\n")
    f.write("-"*40 + "\n")
    f.write("""
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler

# Configuração do modelo vencedor
modelo = KNeighborsClassifier(
    n_neighbors=11,
    weights='distance',
    metric='manhattan',
    algorithm='auto'
)

# Normalizar os dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Treinar o modelo
modelo.fit(X_scaled, y)

# Predizer
predicao = modelo.predict(scaler.transform([nova_amostra]))
""")


def explicar_custo_beneficio(acuracia, tempo):
    """
    Função que explica detalhadamente o cálculo do custo-benefício
    """
    print("\n" + "="*70)
    print("🔬 ANÁLISE DETALHADA DO CUSTO-BENEFÍCIO")
    print("="*70)
    
    # 1. Acurácia
    print(f"\n1. COMPONENTE: ACURÁCIA")
    print(f"   • O modelo acerta {acuracia*100:.2f}% das previsões")
    print(f"   • Representação decimal: {acuracia}")
    print(f"   • Quanto maior, melhor")
    
    # 2. Tempo
    print(f"\n2. COMPONENTE: TEMPO DE EXECUÇÃO")
    print(f"   • O modelo leva {tempo} segundos para treinar")
    print(f"   • Em milissegundos: {tempo*1000:.3f} ms")
    print(f"   • Em microssegundos: {tempo*1000000:.1f} µs")
    print(f"   • Quanto menor, melhor")
    
    # 3. Relação inversa
    print(f"\n3. RELAÇÃO INVERSA")
    print(f"   • Custo-Benefício = Acurácia ÷ Tempo")
    print(f"   • Se o tempo dobra, o CB cai pela metade")
    print(f"   • Se a acurácia dobra, o CB dobra")
    
    # 4. Cálculo passo a passo
    print(f"\n4. CÁLCULO PASSO A PASSO:")
    print(f"   Passo 1: Identificar valores")
    print(f"            A = {acuracia}")
    print(f"            T = {tempo}")
    print(f"   Passo 2: Aplicar fórmula")
    print(f"            CB = {acuracia} ÷ {tempo}")
    print(f"   Passo 3: Resolver divisão")
    print(f"            CB = {acuracia / tempo:.6f}")
    print(f"   Passo 4: Arredondar")
    print(f"            CB = {acuracia / tempo:.2f}")
    
    # 5. Significado
    print(f"\n5. SIGNIFICADO DO RESULTADO:")
    cb = acuracia / tempo
    print(f"   • Valor: {cb:.2f}")
    print(f"   • Significa que cada segundo de processamento")
    print(f"     entrega {cb:.2f} unidades de acurácia")
    print(f"   • Ou: {1/tempo:.0f} treinamentos/segundo × {acuracia*100:.1f}% = {(1/tempo)*acuracia*100:.0f}%/segundo")
    
    return cb





# 11. RESUMO FINAL
print("="*80)
print("                         MODELO VENCEDOR: KNN                                     ")
print("="*80)
print("  Hiperparâmetros:                                                                ")
print("    • n_neighbors = 11                                                            ")
print("    • weights = 'distance'                                                        ")
print("    • metric = 'manhattan'                                                        ")
print("-"*80)
print("  Desempenho:                                                                     ")
print(f"    • Acurácia: {acuracia*100:.2f}%                                               ")
print(f"    • F1-Score: {f1:.6f}                                                          ")
print(f"    • Tempo: {tempo_treino:.6f} segundos                                          ")
print(f"    • Custo-Benefício: {acuracia / tempo_treino:.2f}                              ")
print("-"*80)
print("  Por que é o vencedor?                                                           ")
print("    ✅ Melhor custo-benefício entre todos os modelos testados                    ")
print(f"    ✅ Acurácia competitiva (apenas {100 - acuracia*100:.2f}% abaixo do melhor)  ")
print(f"    ✅ Extremamente rápido ({tempo_treino*1000:.2f}ms por treinamento)           ")
print("    ✅ Fácil implementação e interpretação                                       ")
print("="*80)

# Retornar o modelo para uso
print("✅ Modelo vencedor pronto para uso!")
print("🔧 Use a função 'prever_flor_iris_vencedor()' para fazer predições")

explicar_custo_beneficio(acuracia, tempo_treino)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

# ============================================================================

# Flor de Iris

# ============================================================================

import numpy as np

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, f1_score

print("="*80)

print("🏆 MODELO VENCEDOR - KNN (Melhor Custo-Benefício)")

print("="*80)

# 1. CARREGAR DADOS

print("\n📁 1. Carregando dataset Iris...")

iris = load_iris()

X = iris.data

y = iris.target

print(f" ✅ Amostras: {len(X)}")

print(f" ✅ Features: {iris.feature_names}")

print(f" ✅ Classes: {iris.target_names}")

# 2. DIVIDIR DADOS (Treino 80%, Teste 20%)

print("\n✂️ 2. Dividindo dados...")

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42, stratify=y

)

print(f" ✅ Treino: {len(X_train)} amostras")

print(f" ✅ Teste: {len(X_test)} amostras")

# 3. NORMALIZAR DADOS

print("\n📐 3. Normalizando dados...")

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(" ✅ Normalização aplicada (média=0, desvio=1)")

# 4. CRIAR MODELO COM A CONFIGURAÇÃO EXATA DO VENCEDOR

print("\n🤖 4. Criando modelo KNN com configuração vencedora...")

modelo_vencedor = KNeighborsClassifier(

n_neighbors=11, # ← 11 vizinhos (não 5)

weights='distance', # ← Peso por distância (não uniform)

metric='manhattan', # ← Distância Manhattan (não Euclidiana)

algorithm='auto'

)

print(f" ✅ Modelo configurado:")

print(f" • n_neighbors: {modelo_vencedor.n_neighbors}")

print(f" • weights: {modelo_vencedor.weights}")

print(f" • metric: {modelo_vencedor.metric}")

# 5. TREINAR MODELO

print("\n🏋️ 5. Treinando modelo...")

import time

inicio = time.time()

modelo_vencedor.fit(X_train_scaled, y_train)

tempo_treino = time.time() - inicio

print(f" ✅ Treinamento concluído em {tempo_treino:.6f} segundos")

print(f" 💰 Custo-Benefício real: {0.950000 / tempo_treino:.2f}")

# 6. AVALIAR MODELO

print("\n📊 6. Avaliando modelo...")

y_pred = modelo_vencedor.predict(X_test_scaled)

acuracia = accuracy_score(y_test, y_pred)

f1 = f1_score(y_test, y_pred, average='macro')

print(f"\n 🎯 RESULTADOS DO MODELO VENCEDOR:")

print(f" • Acurácia: {acuracia:.4f} ({acuracia*100:.2f}%)")

print(f" • F1-Score (macro): {f1:.6f}")

print(f" • Tempo de execução: {tempo_treino:.6f} segundos")

print(f" • Custo-Benefício: {acuracia / tempo_treino:.2f}")

print(f"\n 📈 Relatório de Classificação:")

print(classification_report(y_test, y_pred, target_names=iris.target_names))

print(f"\n 🔍 Matriz de Confusão:")

cm = confusion_matrix(y_test, y_pred)

print(cm)

# 7. VALIDAÇÃO CRUZADA PARA CONFIRMAR

print("\n🔄 7. Validando com Cross-Validation (5 folds)...")

from sklearn.model_selection import cross_val_score, StratifiedKFold

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

scores_acuracia = cross_val_score(modelo_vencedor, X_train_scaled, y_train, cv=skf, scoring='accuracy')

scores_f1 = cross_val_score(modelo_vencedor, X_train_scaled, y_train, cv=skf, scoring='f1_macro')

print(f" ✅ Acurácia CV: {scores_acuracia}")

print(f" ✅ Média Acurácia CV: {scores_acuracia.mean():.6f}")

print(f" ✅ F1-Score CV: {scores_f1.mean():.6f}")

# 8. CONFIGURAÇÃO COMPLETA

print("\n" + "="*80)

print("📋 CONFIGURAÇÃO COMPLETA DO MODELO VENCEDOR")

print("="*80)

config_completa = {

"MODELO": "KNeighborsClassifier",

"DATASET": "Iris (Flor Iris)",

"HIPERPARAMETROS": {

"n_neighbors": 11,

"weights": "distance",

"metric": "manhattan",

"algorithm": "auto",

"leaf_size": 30,

"p": 1, # p=1 para Manhattan, p=2 para Euclidiana

"n_jobs": None

"PREPROCESSAMENTO": {

"scaler": "StandardScaler",

"train_test_split": {"test_size": 0.2, "random_state": 42, "stratify": True}

"DESEMPENHO_REAL": {

"acuracia_teste": acuracia,

"f1_score_macro": f1,

"tempo_treino_segundos": tempo_treino,

"custo_beneficio": acuracia / tempo_treino,

"acuracia_cv_medio": scores_acuracia.mean(),

"f1_cv_medio": scores_f1.mean(),

"scores_cv_folds": "|".join([f"{s:.6f}" for s in scores_acuracia])

"ARQUITETURA": {

"camadas": [4, 3],

"tipo": "baseado em instâncias",

"ramo": "aprendizado de maquina",

"metodo": "supervisionado",

"problema": "classificacao",

"modelo": "multiclasse"

}

for key, value in config_completa.items():

print(f"\n{key}:")

if isinstance(value, dict):

for subkey, subvalue in value.items():

print(f" {subkey}: {subvalue}")

else:

print(f" {value}")

# 9. FUNÇÃO DE PREDIÇÃO

print("\n" + "="*80)

print("🔮 FUNÇÃO DE PREDIÇÃO - MODELO VENCEDOR")

print("="*80)

def prever_flor_iris_vencedor(caracteristicas):

"""

Prediz a espécie da flor Iris usando o modelo vencedor (KNN)

Parâmetros:

caracteristicas: list ou array com 4 valores

[sepal_length, sepal_width, petal_length, petal_width]

Retorno:

dict com a espécie prevista e distâncias

"""

# Normalizar as características

caracteristicas_scaled = scaler.transform([caracteristicas])

# Fazer predição

predicao = modelo_vencedor.predict(caracteristicas_scaled)[0]

# Obter distâncias dos k vizinhos

distancias, indices = modelo_vencedor.kneighbors(caracteristicas_scaled)

return {

'especie': iris.target_names[predicao],

'classe': int(predicao),

'distancias_vizinhos': distancias[0].tolist(),

'indices_vizinhos': indices[0].tolist()

}

# Exemplos de uso

print("\n📝 Exemplos de predição:")

exemplos = [

([5.1, 3.5, 1.4, 0.2], "Setosa (referência)"),

([7.0, 3.2, 4.7, 1.4], "Versicolor (referência)"),

([6.3, 3.3, 6.0, 2.5], "Virginica (referência)")

]

for caracteristicas, descricao in exemplos:

resultado = prever_flor_iris_vencedor(caracteristicas)

print(f"\n {descricao}:")

print(f" Características: {caracteristicas}")

print(f" 🌸 Espécie prevista: {resultado['especie']}")

print(f" 📏 Distâncias dos 11 vizinhos: {resultado['distancias_vizinhos'][:3]}...")

# 10. SALVAR CONFIGURAÇÃO EM ARQUIVO

print("\n" + "="*80)

print("💾 SALVANDO CONFIGURAÇÃO DO VENCEDOR")

print("="*80)

with open('modelo_vencedor_knn_configuracao.txt', 'w', encoding='utf-8') as f:

f.write("="*80 + "\n")

f.write("🏆 MODELO VENCEDOR - KNN (Melhor Custo-Benefício)\n")

f.write("="*80 + "\n\n")

f.write("DATASET: Flor Iris\n")

f.write(f"DATA DA EXECUÇÃO: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n")

f.write("CONFIGURAÇÃO DO MODELO:\n")

f.write("-"*40 + "\n")

f.write(f"Algoritmo: KNeighborsClassifier\n")

f.write(f"n_neighbors: 11\n")

f.write(f"weights: distance\n")

f.write(f"metric: manhattan\n")

f.write(f"algorithm: auto\n\n")

f.write("DESEMPENHO:\n")

f.write("-"*40 + "\n")

f.write(f"Acurácia (Teste): {acuracia:.6f} ({acuracia*100:.2f}%)\n")

f.write(f"F1-Score (Macro): {f1:.6f}\n")

f.write(f"Tempo de Execução: {tempo_treino:.6f} segundos\n")

f.write(f"Custo-Benefício: {acuracia / tempo_treino:.2f}\n")

f.write(f"Acurácia CV (5 folds): {scores_acuracia.mean():.6f}\n")

f.write(f"Scores por fold: {scores_acuracia}\n\n")

f.write("CÓDIGO DE IMPLEMENTAÇÃO:\n")

f.write("-"*40 + "\n")

f.write("""

from sklearn.neighbors import KNeighborsClassifier

from sklearn.preprocessing import StandardScaler

# Configuração do modelo vencedor

modelo = KNeighborsClassifier(

n_neighbors=11,

weights='distance',

metric='manhattan',

algorithm='auto'

)

# Normalizar os dados

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Treinar o modelo

modelo.fit(X_scaled, y)

# Predizer

predicao = modelo.predict(scaler.transform([nova_amostra]))

""")

def explicar_custo_beneficio(acuracia, tempo):

"""

Função que explica detalhadamente o cálculo do custo-benefício

"""

print("\n" + "="*70)

print("🔬 ANÁLISE DETALHADA DO CUSTO-BENEFÍCIO")

print("="*70)

# 1. Acurácia

print(f"\n1. COMPONENTE: ACURÁCIA")

print(f" • O modelo acerta {acuracia*100:.2f}% das previsões")

print(f" • Representação decimal: {acuracia}")

print(f" • Quanto maior, melhor")

# 2. Tempo

print(f"\n2. COMPONENTE: TEMPO DE EXECUÇÃO")

print(f" • O modelo leva {tempo} segundos para treinar")

print(f" • Em milissegundos: {tempo*1000:.3f} ms")

print(f" • Em microssegundos: {tempo*1000000:.1f} µs")

print(f" • Quanto menor, melhor")

# 3. Relação inversa

print(f"\n3. RELAÇÃO INVERSA")

print(f" • Custo-Benefício = Acurácia ÷ Tempo")

print(f" • Se o tempo dobra, o CB cai pela metade")

print(f" • Se a acurácia dobra, o CB dobra")

# 4. Cálculo passo a passo

print(f"\n4. CÁLCULO PASSO A PASSO:")

print(f" Passo 1: Identificar valores")

print(f" A = {acuracia}")

print(f" T = {tempo}")

print(f" Passo 2: Aplicar fórmula")

print(f" CB = {acuracia} ÷ {tempo}")

print(f" Passo 3: Resolver divisão")

print(f" CB = {acuracia / tempo:.6f}")

print(f" Passo 4: Arredondar")

print(f" CB = {acuracia / tempo:.2f}")

# 5. Significado

print(f"\n5. SIGNIFICADO DO RESULTADO:")

cb = acuracia / tempo

print(f" • Valor: {cb:.2f}")

print(f" • Significa que cada segundo de processamento")

print(f" entrega {cb:.2f} unidades de acurácia")

print(f" • Ou: {1/tempo:.0f} treinamentos/segundo × {acuracia*100:.1f}% = {(1/tempo)*acuracia*100:.0f}%/segundo")

return cb

# 11. RESUMO FINAL

print("="*80)

print(" MODELO VENCEDOR: KNN ")

print("="*80)

print(" Hiperparâmetros: ")

print(" • n_neighbors = 11 ")

print(" • weights = 'distance' ")

print(" • metric = 'manhattan' ")

print("-"*80)

print(" Desempenho: ")

print(f" • Acurácia: {acuracia*100:.2f}% ")

print(f" • F1-Score: {f1:.6f} ")

print(f" • Tempo: {tempo_treino:.6f} segundos ")

print(f" • Custo-Benefício: {acuracia / tempo_treino:.2f} ")

print("-"*80)

print(" Por que é o vencedor? ")

print(" ✅ Melhor custo-benefício entre todos os modelos testados ")

print(f" ✅ Acurácia competitiva (apenas {100 - acuracia*100:.2f}% abaixo do melhor) ")

print(f" ✅ Extremamente rápido ({tempo_treino*1000:.2f}ms por treinamento) ")

print(" ✅ Fácil implementação e interpretação ")

print("="*80)

# Retornar o modelo para uso

print("✅ Modelo vencedor pronto para uso!")

print("🔧 Use a função 'prever_flor_iris_vencedor()' para fazer predições")

explicar_custo_beneficio(acuracia, tempo_treino)

Classificação Binária

25/04/202623/03/2026 Por antonino

– Aprendizado de Maquina
1.2 – Classificacao
1.2.1 – Binaria

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

Duas opções, uma decisão

Classificação binária é a forma mais simples de classificação, com apenas duas categorias possíveis. O modelo decide entre duas classes mutuamente exclusivas como “sim” ou “não”. Por exemplo, determinar se um e-mail é spam ou não spam. Primeiramente, essa simplicidade torna a classificação binária ideal para iniciantes. Além disso, muitos problemas complexos podem ser decompostos em múltiplos problemas binários. A saída geralmente representa a probabilidade de pertencer à classe positiva. É o ponto de partida fundamental para entender classificação supervisionada.

Limiar de decisão e probabilidades

A maioria dos classificadores binários produz uma probabilidade entre 0 e 1 como saída. Primeiramente, o limiar padrão é 0,5: acima disso classe positiva, abaixo classe negativa. Além disso, podemos ajustar esse limiar para diferentes necessidades operacionais. Por exemplo, em diagnósticos médicos, preferimos um limiar mais baixo para não perder casos. Limiares mais altos produzem menos falsos positivos, mas podem perder casos verdadeiros. A curva ROC mostra o desempenho do modelo em todos os limiares possíveis. A escolha do limiar reflete o equilíbrio entre diferentes tipos de erro.

Métricas essenciais para problemas binários

Avaliar classificadores binários exige métricas que capturam os diferentes tipos de erro possíveis. A matriz de confusão organiza resultados em quatro categorias: VP, VN, FP, FN. Primeiramente, verdadeiros positivos (VP) são acertos na classe positiva. Verdadeiros negativos (VN) são acertos na classe negativa. Além disso, falsos positivos (FP) são erros do tipo alarme falso. Falsos negativos (FN) são erros onde o modelo perdeu casos positivos. Precisão e recall derivam dessas quantidades para avaliação detalhada. F1-score combina precisão e recall em uma única métrica balanceada.

Desbalanceamento de classes

Problemas binários frequentemente sofrem com desbalanceamento entre as duas classes. Por exemplo, fraudes representam menos de 1% das transações bancárias. Primeiramente, um modelo que sempre prevê “não fraude” tem acurácia de 99%. Além disso, métricas como acurácia se tornam enganosas em dados desbalanceados. Técnicas como sobreamostragem (oversampling) criam cópias da classe minoritária. Subamostragem (undersampling) reduz exemplos da classe majoritária para equilíbrio. Algoritmos sensíveis a custo atribuem pesos diferentes para cada classe. O desbalanceamento exige cuidado especial na avaliação e treinamento do modelo.

Aplicações práticas da classificação binária

Classificação binária está presente em sistemas críticos que exigem decisões rápidas. Primeiramente, detecção de fraudes analisa transações bancárias em tempo real. Além disso, diagnóstico médico classifica exames como normais ou alterados. Sistemas de segurança usam classificação binária para reconhecimento facial autorizado. Filtros de conteúdo identificam comentários ofensivos ou apropriados para publicação. Na indústria, sistemas inspecionam produtos como “defeituoso” ou “sem defeitos”. Para iniciantes, classificação binária oferece aplicações práticas imediatas e compreensíveis. É a base sobre a qual muitos sistemas inteligentes realizam decisões críticas.

Descrição do Problema

Este é um problema clássico de Aprendizado de Máquina Supervisionado onde o objetivo é classificar tumores de mama como Malignos (cancerígenos) ou Benignos (não cancerígenos) com base em características extraídas de imagens de exames.

🎯 Objetivo: Construir um modelo preditivo que possa auxiliar médicos no diagnóstico precoce de câncer de mama, identificando automaticamente se um tumor é maligno ou benigno com alta precisão.

# -*- coding: utf-8 -*-
"""Classificação Binária - Câncer de Mama

Este é um exemplo clássico de aprendizado de máquina supervisionado
para classificação binária (tumor maligno vs benigno)
"""

# 1. IMPORTAÇÕES NECESSÁRIAS
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (accuracy_score, classification_report, 
                           confusion_matrix, roc_curve, auc, roc_auc_score)
import warnings
warnings.filterwarnings('ignore')

# Configurações de visualização
plt.style.use('seaborn-v0_8-darkgrid')
sns.set_palette("husl")

print("="*60)
print("CLASSIFICAÇÃO BINÁRIA - DIAGNÓSTICO DE CÂNCER DE MAMA")
print("="*60)

# 2. CARREGAR E EXPLORAR OS DADOS
print("\n📊 Carregando dataset...")
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = pd.Series(data.target, name='target')

print(f"\n✅ Dataset carregado com sucesso!")
print(f"   - Total de amostras: {X.shape[0]}")
print(f"   - Total de features: {X.shape[1]}")
print(f"   - Classes: {data.target_names}")
print(f"   - Distribuição das classes:")
print(f"     • Maligno (0): {sum(y==0)} amostras")
print(f"     • Benigno (1): {sum(y==1)} amostras")

# 3. ANÁLISE EXPLORATÓRIA BÁSICA
print("\n📈 Análise Exploratória...")

# Verificando valores missing
print(f"\n   Valores missing: {X.isnull().sum().sum()}")

# Estatísticas descritivas
print("\n   Estatísticas descritivas das primeiras 5 features:")
print(X.iloc[:, :5].describe().round(2))

# 4. PRÉ-PROCESSAMENTO
print("\n🔧 Pré-processamento dos dados...")

# Separar features (X) e target (y)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"   Dados de treino: {X_train.shape[0]} amostras")
print(f"   Dados de teste: {X_test.shape[0]} amostras")

# Padronizar os dados (Standardization)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print("   ✅ Dados padronizados (média=0, desvio=1)")

# 5. TREINAMENTO DO MODELO
print("\n🤖 Treinando modelo Random Forest...")

# Criar e treinar o modelo
rf_model = RandomForestClassifier(
    n_estimators=100,
    max_depth=10,
    random_state=42,
    n_jobs=-1
)

rf_model.fit(X_train_scaled, y_train)

print("   ✅ Modelo treinado com sucesso!")

# 6. AVALIAÇÃO DO MODELO
print("\n📊 Avaliação do modelo...")

# Predições
y_pred = rf_model.predict(X_test_scaled)
y_pred_proba = rf_model.predict_proba(X_test_scaled)[:, 1]

# Métricas
accuracy = accuracy_score(y_test, y_pred)
roc_auc = roc_auc_score(y_test, y_pred_proba)

print(f"\n   📈 Métricas no conjunto de teste:")
print(f"   • Acurácia: {accuracy:.4f}")
print(f"   • ROC-AUC: {roc_auc:.4f}")

# Validação cruzada
cv_scores = cross_val_score(rf_model, X_train_scaled, y_train, cv=5)
print(f"   • Validação cruzada (5-fold): {cv_scores.mean():.4f} (±{cv_scores.std():.4f})")

# Relatório de classificação detalhado
print("\n   📋 Relatório de Classificação:")
print(classification_report(y_test, y_pred, target_names=data.target_names))

# 7. VISUALIZAÇÕES
print("\n🎨 Gerando visualizações...")

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Matriz de Confusão
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0, 0],
            xticklabels=data.target_names, yticklabels=data.target_names)
axes[0, 0].set_title('Matriz de Confusão', fontsize=14, fontweight='bold')
axes[0, 0].set_xlabel('Predito')
axes[0, 0].set_ylabel('Real')

# Curva ROC
fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
roc_auc = auc(fpr, tpr)
axes[0, 1].plot(fpr, tpr, color='darkorange', lw=2, 
                label=f'ROC curve (AUC = {roc_auc:.3f})')
axes[0, 1].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
axes[0, 1].set_xlim([0.0, 1.0])
axes[0, 1].set_ylim([0.0, 1.05])
axes[0, 1].set_xlabel('False Positive Rate')
axes[0, 1].set_ylabel('True Positive Rate')
axes[0, 1].set_title('Curva ROC', fontsize=14, fontweight='bold')
axes[0, 1].legend(loc="lower right")

# Importância das Features
feature_importance = pd.DataFrame({
    'feature': data.feature_names,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False).head(10)

axes[1, 0].barh(feature_importance['feature'], feature_importance['importance'])
axes[1, 0].set_xlabel('Importância')
axes[1, 0].set_title('Top 10 Features Mais Importantes', fontsize=14, fontweight='bold')
axes[1, 0].invert_yaxis()

# Distribuição das probabilidades preditas
axes[1, 1].hist(y_pred_proba[y_test==0], bins=20, alpha=0.7, 
                label='Maligno (Real)', color='red')
axes[1, 1].hist(y_pred_proba[y_test==1], bins=20, alpha=0.7, 
                label='Benigno (Real)', color='green')
axes[1, 1].set_xlabel('Probabilidade de Ser Benigno')
axes[1, 1].set_ylabel('Frequência')
axes[1, 1].set_title('Distribuição das Probabilidades', fontsize=14, fontweight='bold')
axes[1, 1].legend()

plt.tight_layout()
plt.show()

# 8. OTIMIZAÇÃO DE HIPERPARÂMETROS (Opcional)
print("\n🔍 Otimizando hiperparâmetros...")

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10]
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='roc_auc',
    n_jobs=-1,
    verbose=0
)

grid_search.fit(X_train_scaled, y_train)

print(f"   ✅ Melhores parâmetros: {grid_search.best_params_}")
print(f"   ✅ Melhor score (validação cruzada): {grid_search.best_score_:.4f}")

# Avaliar modelo otimizado
best_model = grid_search.best_estimator_
y_pred_optimized = best_model.predict(X_test_scaled)
accuracy_optimized = accuracy_score(y_test, y_pred_optimized)

print(f"\n   📈 Comparação com modelo otimizado:")
print(f"   • Acurácia original: {accuracy:.4f}")
print(f"   • Acurácia otimizada: {accuracy_optimized:.4f}")

# 9. EXEMPLO DE PREDIÇÃO PARA UM NOVO CASO
print("\n💡 Exemplo de predição para um novo paciente:")

# Usar a primeira amostra do teste como exemplo
sample_index = 0
sample = X_test_scaled[sample_index].reshape(1, -1)
sample_original = X_test.iloc[sample_index]
true_label = y_test.iloc[sample_index]

prediction = best_model.predict(sample)[0]
probability = best_model.predict_proba(sample)[0]

print(f"\n   Características do paciente (parciais):")
print(f"   • Raio médio: {sample_original['mean radius']:.2f}")
print(f"   • Textura média: {sample_original['mean texture']:.2f}")
print(f"   • Perímetro médio: {sample_original['mean perimeter']:.2f}")
print(f"   • Área média: {sample_original['mean area']:.2f}")

print(f"\n   🩺 Diagnóstico REAL: {data.target_names[true_label]}")
print(f"   🤖 Diagnóstico PREDITO: {data.target_names[prediction]}")
print(f"   📊 Confiança da predição:")
print(f"      • Probabilidade de ser maligno: {probability[0]:.2%}")
print(f"      • Probabilidade de ser benigno: {probability[1]:.2%}")

# 10. CONCLUSÃO
print("\n" + "="*60)
print("✅ PROCESSO CONCLUÍDO COM SUCESSO!")
print("="*60)
print("\n📚 RESUMO DO PIPELINE:")
print("1. ✅ Carregamento e exploração dos dados")
print("2. ✅ Análise exploratória")
print("3. ✅ Pré-processamento (padronização)")
print("4. ✅ Treinamento (Random Forest)")
print("5. ✅ Avaliação (acurácia, ROC-AUC, matriz de confusão)")
print("6. ✅ Otimização de hiperparâmetros")
print("7. ✅ Predição para novos casos")
print("\n🎯 Este é um fluxo de trabalho completo para classificação binária!")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

# -*- coding: utf-8 -*-

"""Classificação Binária - Câncer de Mama

Este é um exemplo clássico de aprendizado de máquina supervisionado

para classificação binária (tumor maligno vs benigno)

"""

# 1. IMPORTAÇÕES NECESSÁRIAS

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.ensemble import RandomForestClassifier

from sklearn.metrics import (accuracy_score, classification_report,

confusion_matrix, roc_curve, auc, roc_auc_score)

import warnings

warnings.filterwarnings('ignore')

# Configurações de visualização

plt.style.use('seaborn-v0_8-darkgrid')

sns.set_palette("husl")

print("="*60)

print("CLASSIFICAÇÃO BINÁRIA - DIAGNÓSTICO DE CÂNCER DE MAMA")

print("="*60)

# 2. CARREGAR E EXPLORAR OS DADOS

print("\n📊 Carregando dataset...")

data = load_breast_cancer()

X = pd.DataFrame(data.data, columns=data.feature_names)

y = pd.Series(data.target, name='target')

print(f"\n✅ Dataset carregado com sucesso!")

print(f" - Total de amostras: {X.shape[0]}")

print(f" - Total de features: {X.shape[1]}")

print(f" - Classes: {data.target_names}")

print(f" - Distribuição das classes:")

print(f" • Maligno (0): {sum(y==0)} amostras")

print(f" • Benigno (1): {sum(y==1)} amostras")

# 3. ANÁLISE EXPLORATÓRIA BÁSICA

print("\n📈 Análise Exploratória...")

# Verificando valores missing

print(f"\n Valores missing: {X.isnull().sum().sum()}")

# Estatísticas descritivas

print("\n Estatísticas descritivas das primeiras 5 features:")

print(X.iloc[:, :5].describe().round(2))

# 4. PRÉ-PROCESSAMENTO

print("\n🔧 Pré-processamento dos dados...")

# Separar features (X) e target (y)

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42, stratify=y

)

print(f" Dados de treino: {X_train.shape[0]} amostras")

print(f" Dados de teste: {X_test.shape[0]} amostras")

# Padronizar os dados (Standardization)

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(" ✅ Dados padronizados (média=0, desvio=1)")

# 5. TREINAMENTO DO MODELO

print("\n🤖 Treinando modelo Random Forest...")

# Criar e treinar o modelo

rf_model = RandomForestClassifier(

n_estimators=100,

max_depth=10,

random_state=42,

n_jobs=-1

)

rf_model.fit(X_train_scaled, y_train)

print(" ✅ Modelo treinado com sucesso!")

# 6. AVALIAÇÃO DO MODELO

print("\n📊 Avaliação do modelo...")

# Predições

y_pred = rf_model.predict(X_test_scaled)

y_pred_proba = rf_model.predict_proba(X_test_scaled)[:, 1]

# Métricas

accuracy = accuracy_score(y_test, y_pred)

roc_auc = roc_auc_score(y_test, y_pred_proba)

print(f"\n 📈 Métricas no conjunto de teste:")

print(f" • Acurácia: {accuracy:.4f}")

print(f" • ROC-AUC: {roc_auc:.4f}")

# Validação cruzada

cv_scores = cross_val_score(rf_model, X_train_scaled, y_train, cv=5)

print(f" • Validação cruzada (5-fold): {cv_scores.mean():.4f} (±{cv_scores.std():.4f})")

# Relatório de classificação detalhado

print("\n 📋 Relatório de Classificação:")

print(classification_report(y_test, y_pred, target_names=data.target_names))

# 7. VISUALIZAÇÕES

print("\n🎨 Gerando visualizações...")

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Matriz de Confusão

cm = confusion_matrix(y_test, y_pred)

sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0, 0],

xticklabels=data.target_names, yticklabels=data.target_names)

axes[0, 0].set_title('Matriz de Confusão', fontsize=14, fontweight='bold')

axes[0, 0].set_xlabel('Predito')

axes[0, 0].set_ylabel('Real')

# Curva ROC

fpr, tpr, _ = roc_curve(y_test, y_pred_proba)

roc_auc = auc(fpr, tpr)

axes[0, 1].plot(fpr, tpr, color='darkorange', lw=2,

label=f'ROC curve (AUC = {roc_auc:.3f})')

axes[0, 1].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

axes[0, 1].set_xlim([0.0, 1.0])

axes[0, 1].set_ylim([0.0, 1.05])

axes[0, 1].set_xlabel('False Positive Rate')

axes[0, 1].set_ylabel('True Positive Rate')

axes[0, 1].set_title('Curva ROC', fontsize=14, fontweight='bold')

axes[0, 1].legend(loc="lower right")

# Importância das Features

feature_importance = pd.DataFrame({

'feature': data.feature_names,

'importance': rf_model.feature_importances_

}).sort_values('importance', ascending=False).head(10)

axes[1, 0].barh(feature_importance['feature'], feature_importance['importance'])

axes[1, 0].set_xlabel('Importância')

axes[1, 0].set_title('Top 10 Features Mais Importantes', fontsize=14, fontweight='bold')

axes[1, 0].invert_yaxis()

# Distribuição das probabilidades preditas

axes[1, 1].hist(y_pred_proba[y_test==0], bins=20, alpha=0.7,

label='Maligno (Real)', color='red')

axes[1, 1].hist(y_pred_proba[y_test==1], bins=20, alpha=0.7,

label='Benigno (Real)', color='green')

axes[1, 1].set_xlabel('Probabilidade de Ser Benigno')

axes[1, 1].set_ylabel('Frequência')

axes[1, 1].set_title('Distribuição das Probabilidades', fontsize=14, fontweight='bold')

axes[1, 1].legend()

plt.tight_layout()

plt.show()

# 8. OTIMIZAÇÃO DE HIPERPARÂMETROS (Opcional)

print("\n🔍 Otimizando hiperparâmetros...")

param_grid = {

'n_estimators': [50, 100, 200],

'max_depth': [5, 10, 15, None],

'min_samples_split': [2, 5, 10]

}

grid_search = GridSearchCV(

RandomForestClassifier(random_state=42),

param_grid,

cv=5,

scoring='roc_auc',

n_jobs=-1,

verbose=0

)

grid_search.fit(X_train_scaled, y_train)

print(f" ✅ Melhores parâmetros: {grid_search.best_params_}")

print(f" ✅ Melhor score (validação cruzada): {grid_search.best_score_:.4f}")

# Avaliar modelo otimizado

best_model = grid_search.best_estimator_

y_pred_optimized = best_model.predict(X_test_scaled)

accuracy_optimized = accuracy_score(y_test, y_pred_optimized)

print(f"\n 📈 Comparação com modelo otimizado:")

print(f" • Acurácia original: {accuracy:.4f}")

print(f" • Acurácia otimizada: {accuracy_optimized:.4f}")

# 9. EXEMPLO DE PREDIÇÃO PARA UM NOVO CASO

print("\n💡 Exemplo de predição para um novo paciente:")

# Usar a primeira amostra do teste como exemplo

sample_index = 0

sample = X_test_scaled[sample_index].reshape(1, -1)

sample_original = X_test.iloc[sample_index]

true_label = y_test.iloc[sample_index]

prediction = best_model.predict(sample)[0]

probability = best_model.predict_proba(sample)[0]

print(f"\n Características do paciente (parciais):")

print(f" • Raio médio: {sample_original['mean radius']:.2f}")

print(f" • Textura média: {sample_original['mean texture']:.2f}")

print(f" • Perímetro médio: {sample_original['mean perimeter']:.2f}")

print(f" • Área média: {sample_original['mean area']:.2f}")

print(f"\n 🩺 Diagnóstico REAL: {data.target_names[true_label]}")

print(f" 🤖 Diagnóstico PREDITO: {data.target_names[prediction]}")

print(f" 📊 Confiança da predição:")

print(f" • Probabilidade de ser maligno: {probability[0]:.2%}")

print(f" • Probabilidade de ser benigno: {probability[1]:.2%}")

# 10. CONCLUSÃO

print("\n" + "="*60)

print("✅ PROCESSO CONCLUÍDO COM SUCESSO!")

print("="*60)

print("\n📚 RESUMO DO PIPELINE:")

print("1. ✅ Carregamento e exploração dos dados")

print("2. ✅ Análise exploratória")

print("3. ✅ Pré-processamento (padronização)")

print("4. ✅ Treinamento (Random Forest)")

print("5. ✅ Avaliação (acurácia, ROC-AUC, matriz de confusão)")

print("6. ✅ Otimização de hiperparâmetros")

print("7. ✅ Predição para novos casos")

print("\n🎯 Este é um fluxo de trabalho completo para classificação binária!")

Dataset – Breast Cancer Wisconsin

O dataset contém 569 amostras de tumores de mama, cada uma descrita por 30 características numéricas calculadas a partir de imagens digitalizadas.

Distribuição das Classes

🔴 Maligno (0): 212 amostras (37.3%) 🟢 Benigno (1): 357 amostras (62.7%)

Tipos de Features

• Raio (radius) • Textura (texture) • Perímetro (perimeter) • Área (area) • Suavidade (smoothness) • Compacidade (compactness) • Concavidade (concavity) • Simetria (symmetry)

Arquitetura do Modelo

Utilizamos o algoritmo Random Forest Classifier, um método ensemble que combina múltiplas árvores de decisão para obter predições mais robustas e precisas.

RandomForestClassifier(
n_estimators=100, # Número de árvores na floresta
max_depth=10, # Profundidade máxima das árvores
random_state=42, # Seed para reprodutibilidade
n_jobs=-1 # Usa todos os processadores
)

Pipeline de Processamento

1️⃣ Pré-processamento

• Padronização dos dados (StandardScaler) • Média = 0, Desvio Padrão = 1 • Divisão treino/teste (80/20)

2️⃣ Treinamento

• Random Forest com 100 árvores • Validação cruzada (5-fold) • GridSearch para otimização

3️⃣ Avaliação

• Acurácia • ROC-AUC • Matriz de Confusão • Relatório de Classificação

⚙️ Hiperparâmetros do Modelo

Hiperparâmetros Principais:

Hiperparâmetro	Valor Padrão	Valor Otimizado	Descrição
n_estimators	100	200	Número de árvores de decisão na floresta
max_depth	10	15	Profundidade máxima de cada árvore
min_samples_split	2	5	Número mínimo de amostras para dividir um nó
min_samples_leaf	1	2	Número mínimo de amostras em um nó folha
max_features	‘sqrt’	‘sqrt’	Número de features para melhor divisão

GridSearch – Espaço de Busca:

param_grid = {
‘n_estimators’: [50, 100, 200], # Número de árvores
‘max_depth’: [5, 10, 15, None], # Profundidade das árvores
‘min_samples_split’: [2, 5, 10] # Amostras para divisão
}

📈 Métricas de Avaliação

✅ Acurácia

Proporção de predições corretas: (VP + VN) / (VP + VN + FP + FN) Resultado esperado: ~96-98%

📊 ROC-AUC

Capacidade de distinguir entre classes: Área sob a curva ROC Resultado esperado: ~0.99

🎯 Precisão (Precision)

Taxa de verdadeiros positivos entre os preditos positivos: VP / (VP + FP)

📐 Recall (Sensibilidade)

Capacidade de encontrar todos os positivos: VP / (VP + FN)

Resultados Esperados

🏆 Performance do Modelo

• Acurácia: 96-98% • ROC-AUC: >0.99 • Precisão: ~97% • Recall: ~96% • F1-Score: ~96%

⏱️ Tempo de Processamento

• Treinamento: ~2-5 segundos • Predição: <0.1 segundo • GridSearch: ~30-60 segundos