Multiclasse - Área de Trampo

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)

Indice

O que é aprendizado de máquina supervisionado?

Como funciona a classificação multiclasse?

Exemplo prático: a flor íris

Passos para criar um modelo com íris

Por que esse exemplo é útil para iniciantes?

Observações Finais

Deixe um comentário Cancelar resposta