Arquivo de Inteligência Artificial - Página 131 de 167

Vizinhos mais próximos não supervisionados: Descobrindo padrões escondidos nos seus dados

25/04/202628/10/2025 Por antonino

Quando você não sabe o que procurar, mas encontra tesouros escondidos

Imagine que você é um corretor de imóveis com uma lista de 500 propriedades, mas nenhuma classificação prévia sobre qual é “luxuosa”, “econômica” ou “familiar”. Como agrupar essas casas de forma inteligente? O vizinhos mais próximos não supervisionados é como ter um assistente que analisa automaticamente quais imóveis são naturalmente similares, agrupando-os por características intrínsecas. Ele encontra padrões que você nem sabia que existiam, revelando segmentos naturais no seu mercado. Esta técnica é surpreendentemente poderosa para explorar dados quando você não tem rótulos pré-definidos.

Como isso funciona na prática?

Diferente do version supervisionado que você já conhece, o vizinhos mais próximos não supervisionados não precisa de respostas prévias para aprender. Ele simplesmente analisa a “vizinhança” de cada ponto de dados, calculando distâncias entre todas as observações. Quando você pede para encontrar os K vizinhos mais próximos, o algoritmo identifica quais pontos estão naturalmente agrupados no espaço multidimensional. É como organizar uma festa e observar que certos convidados naturalmente formam círculos de conversa baseados em interesses comuns, sem que ninguém precise dizer explicitamente “grupo dos esportistas” ou “grupo dos intelectuais”.

Mãos na massa: exemplo prático com imóveis

# Importando as ferramentas necessárias
from sklearn.neighbors import NearestNeighbors
import pandas as pd
import numpy as np

# Vamos criar dados fictícios de imóveis: preço, área, número de quartos
dados_imoveis = pd.DataFrame({
    'preco': [500000, 320000, 800000, 280000, 950000, 350000],
    'area': [180, 120, 250, 100, 300, 130],
    'quartos': [4, 3, 5, 2, 6, 3]
})

print("Dados dos imóveis:")
print(dados_imoveis)

# Criando o modelo de vizinhos mais próximos não supervisionado
# Queremos encontrar os 3 imóveis mais similares para cada propriedade
modelo_vizinhos = NearestNeighbors(n_neighbors=3)
modelo_vizinhos.fit(dados_imoveis)

# Vamos encontrar os vizinhos mais próximos para o primeiro imóvel
distancias, indices = modelo_vizinhos.kneighbors(dados_imoveis.iloc[[0]])

print(f"\nPara o imóvel 0 (R$ {dados_imoveis.iloc[0]['preco']:,.0f}):")
print(f"Vizinhos mais próximos: {indices[0]}")
print(f"Distâncias: {distancias[0]}")

# Agora vamos visualizar todos os grupos naturais
distancias_completas, indices_completos = modelo_vizinhos.kneighbors(dados_imoveis)

print("\nMatriz de vizinhança completa:")
for i, (vizinhos, dists) in enumerate(zip(indices_completos, distancias_completas)):
    print(f"Imóvel {i} é similar aos imóveis {vizinhos[1:]} com distâncias {dists[1:]:.2f}")

# Importando as ferramentas necessárias

from sklearn.neighbors import NearestNeighbors

import pandas as pd

import numpy as np

# Vamos criar dados fictícios de imóveis: preço, área, número de quartos

dados_imoveis = pd.DataFrame({

'preco': [500000, 320000, 800000, 280000, 950000, 350000],

'area': [180, 120, 250, 100, 300, 130],

'quartos': [4, 3, 5, 2, 6, 3]

})

print("Dados dos imóveis:")

print(dados_imoveis)

# Criando o modelo de vizinhos mais próximos não supervisionado

# Queremos encontrar os 3 imóveis mais similares para cada propriedade

modelo_vizinhos = NearestNeighbors(n_neighbors=3)

modelo_vizinhos.fit(dados_imoveis)

# Vamos encontrar os vizinhos mais próximos para o primeiro imóvel

distancias, indices = modelo_vizinhos.kneighbors(dados_imoveis.iloc[[0]])

print(f"\nPara o imóvel 0 (R$ {dados_imoveis.iloc[0]['preco']:,.0f}):")

print(f"Vizinhos mais próximos: {indices[0]}")

print(f"Distâncias: {distancias[0]}")

# Agora vamos visualizar todos os grupos naturais

distancias_completas, indices_completos = modelo_vizinhos.kneighbors(dados_imoveis)

print("\nMatriz de vizinhança completa:")

for i, (vizinhos, dists) in enumerate(zip(indices_completos, distancias_completas)):

print(f"Imóvel {i} é similar aos imóveis {vizinhos[1:]} com distâncias {dists[1:]:.2f}")

Os detalhes que fazem diferença

Escolher o valor de K certo é fundamental para o sucesso da análise. Um K muito pequeno pode criar grupos muito fragmentados, enquanto um K muito grande pode agrupar elementos que não são realmente similares. A métrica de distância também é crucial – a distância Euclidiana funciona bem para dados contínuos, mas para dados categóricos você pode precisar de outras abordagens. Similarmente, a normalização dos dados é essencial; caso contrário, variáveis com escalas maiores dominarão completamente o cálculo de similaridade.

Seleção de K: Comece com K entre 5 e 15 e ajuste baseado na densidade dos seus dados
Normalização obrigatória: Sempre normalize seus dados antes de aplicar o algoritmo
Métricas de distância: Experimente Euclidean, Manhattan ou Cosine para diferentes tipos de dados
Visualização: Use técnicas como PCA para visualizar os grupos encontrados em 2D ou 3D

Encontrando a estrutura de vizinhança ideal

# Exemplo avançado: encontrando a estrutura de conectividade dos dados
from sklearn.neighbors import kneighbors_graph
import matplotlib.pyplot as plt

# Criando uma matriz de conectividade baseada nos vizinhos mais próximos
# Isso é útil para algoritmos de clustering posteriores
matriz_conectividade = kneighbors_graph(dados_imoveis, n_neighbors=2, mode='connectivity')

print("Matriz de conectividade (mostrando quais pontos estão conectados):")
print(matriz_conectividade.toarray())

# Esta matriz mostra que o imóvel 0 está conectado aos imóveis 1 e 5, etc.
# Essa estrutura pode ser usada em algoritmos como Spectral Clustering

# Exemplo avançado: encontrando a estrutura de conectividade dos dados

from sklearn.neighbors import kneighbors_graph

import matplotlib.pyplot as plt

# Criando uma matriz de conectividade baseada nos vizinhos mais próximos

# Isso é útil para algoritmos de clustering posteriores

matriz_conectividade = kneighbors_graph(dados_imoveis, n_neighbors=2, mode='connectivity')

print("Matriz de conectividade (mostrando quais pontos estão conectados):")

print(matriz_conectividade.toarray())

# Esta matriz mostra que o imóvel 0 está conectado aos imóveis 1 e 5, etc.

# Essa estrutura pode ser usada em algoritmos como Spectral Clustering

Perguntas que os iniciantes fazem

Você deve estar se perguntando: qual a diferença prática entre isso e clustering tradicional? Enquanto algoritmos como K-Means criam grupos rígidos, o vizinhos mais próximos não supervisionados preserva a estrutura local de vizinhança, sendo especialmente útil como pré-processamento para outros algoritmos. Uma confusão comum é achar que este método cria clusters definitivos; na realidade, ele revela relações de proximidade que podem ser exploradas de várias formas. Por que usar isso em vez de ir direto para o clustering? Porque entender a estrutura de vizinhança dos seus dados fornece insights valiosos sobre a densidade e conectividade natural dos pontos.

Quando essa técnica brilha de verdade

O vizinhos mais próximos não supervisionados é particularmente valioso em situações onde você precisa entender a estrutura intrínseca dos dados antes de aplicar técnicas mais complexas. Ele funciona como um “explorador de território” que mapeia o terreno antes que você tome decisões estratégicas. Igualmente importante, ele é excelente para detecção de anomalias – pontos que não têm vizinhos próximos geralmente são outliers que merecem atenção especial. Esta abordagem também é fundamental como primeiro passo em análises de manifold learning, onde assumimos que dados complexos residem em variedades de dimensão inferior.

Para onde ir agora?

Para dominar completamente esta técnica, pratique aplicando-a em conjuntos de dados reais do setor imobiliário ou de e-commerce. Experimente diferentes valores de K e observe como a estrutura de vizinhança se modifica. Posteriormente, use essa análise como entrada para algoritmos de clustering como DBSCAN ou Spectral Clustering, que se beneficiam enormemente de uma boa compreensão da vizinhança local. Lembre-se que a verdadeira maestria vem da combinação desta técnica com outras ferramentas do ecossistema de aprendizado não supervisionado.

Assuntos relacionados

Para aprofundar seu entendimento sobre vizinhos mais próximos não supervisionados, estes conceitos matemáticos e estatísticos são fundamentais:

Geometria de espaços multidimensionais: Compreensão de distâncias e similaridade em alta dimensão
Teoria dos grafos: Estruturas de conectividade e relações de vizinhança
Análise de densidade: Como os pontos se distribuem no espaço de features
Redução de dimensionalidade: Técnicas como PCA e t-SNE para visualização
Métricas de avaliação de clustering: Silhouette score e outras medidas de qualidade

Referências que valem a pena

Vizinhos mais próximos: quando as viagens encontram a inteligência artificial

25/04/202628/10/2025 Por antonino

Encontrando destinos similares para suas próximas férias

Imagine que você está planejando suas próximas férias e adorou sua última viagem para Bali. Naturalmente, você buscaria destinos com características similares: praias paradisíacas, cultura rica e preços acessíveis. O algoritmo dos K-Nearest Neighbors (KNN) funciona exatamente assim no mundo das viagens. Ele encontra os destinos mais similares baseando-se em suas características geográficas, culturais e de custo.

Como um algoritmo pode recomendar destinos apenas comparando características?

Você deve estar se perguntando como um método aparentemente simples pode analisar a complexidade das preferências de viagem. A beleza do KNN está em sua abordagem baseada em similaridade direta. Analogamente a como um agente de viagens experiente recomenda destinos, o algoritmo encontra padrões sem precisar de modelos complexos. Ele simplesmente localiza os destinos com perfis mais próximos e faz recomendações baseadas nesses vizinhos.

O conceito matemático fundamental envolve calcular distâncias entre perfis de destinos no espaço multidimensional. A distância euclidiana mede diferenças nas características de cada local:

$d(x,y) = \sqrt{\sum_{i=1}^n (x_i – y_i)^2}$

Esta fórmula considera todas as métricas de viagem simultaneamente para encontrar destinos verdadeiramente similares.

Mãos na massa: classificando tipos de destinos turísticos

Vamos construir um sistema para recomendar destinos baseado em preferências de viagem:

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

# Simulando dados de destinos turísticos
# Características: custo, clima, atividades, infraestrutura, etc.
X, y = make_classification(
    n_samples=300,            # 300 destinos no banco de dados
    n_features=5,             # 5 características principais
    n_classes=4,              # 4 tipos: praia, montanha, cidade, aventura
    n_clusters_per_class=1,
    random_state=42
)

# Dividindo em dados de treino e teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

# IMPORTANTE: KNN é sensível à escala dos dados
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Criando nosso classificador de destinos
destination_classifier = KNeighborsClassifier(
    n_neighbors=5,           # Considera 5 destinos similares
    weights='distance',      # Destinos mais próximos têm mais influência
    algorithm='auto',        # Escolhe o melhor algoritmo automaticamente
    metric='euclidean'       # Distância padrão
)

# Treinamento - o algoritmo memoriza os perfis dos destinos
destination_classifier.fit(X_train_scaled, y_train)

# Fazendo previsões
y_pred = destination_classifier.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)

print(f"Desempenho do classificador de destinos:")
print(f"Acurácia: {accuracy:.1%}")
print(f"Número de destinos similares considerados: {destination_classifier.n_neighbors}")

# Exemplo de uma nova recomendação
preferences = [[0.8, -0.2, 1.1, 0.4, -0.7]]  # Preferências do viajante
preferences_scaled = scaler.transform(preferences)
predicted_type = destination_classifier.predict(preferences_scaled)

types = ['Praia', 'Montanha', 'Cidade', 'Aventura']
print(f"Tipo de destino recomendado: {types[predicted_type[0]]}")

# Relatório detalhado
print(f"\nRelatório de classificação:")
print(classification_report(y_test, y_pred, target_names=types))

from sklearn.neighbors import KNeighborsClassifier

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score, classification_report

import numpy as np

# Simulando dados de destinos turísticos

# Características: custo, clima, atividades, infraestrutura, etc.

X, y = make_classification(

n_samples=300, # 300 destinos no banco de dados

n_features=5, # 5 características principais

n_classes=4, # 4 tipos: praia, montanha, cidade, aventura

n_clusters_per_class=1,

random_state=42

)

# Dividindo em dados de treino e teste

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.25, random_state=42

)

# IMPORTANTE: KNN é sensível à escala dos dados

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Criando nosso classificador de destinos

destination_classifier = KNeighborsClassifier(

n_neighbors=5, # Considera 5 destinos similares

weights='distance', # Destinos mais próximos têm mais influência

algorithm='auto', # Escolhe o melhor algoritmo automaticamente

metric='euclidean' # Distância padrão

)

# Treinamento - o algoritmo memoriza os perfis dos destinos

destination_classifier.fit(X_train_scaled, y_train)

# Fazendo previsões

y_pred = destination_classifier.predict(X_test_scaled)

accuracy = accuracy_score(y_test, y_pred)

print(f"Desempenho do classificador de destinos:")

print(f"Acurácia: {accuracy:.1%}")

print(f"Número de destinos similares considerados: {destination_classifier.n_neighbors}")

# Exemplo de uma nova recomendação

preferences = [[0.8, -0.2, 1.1, 0.4, -0.7]] # Preferências do viajante

preferences_scaled = scaler.transform(preferences)

predicted_type = destination_classifier.predict(preferences_scaled)

types = ['Praia', 'Montanha', 'Cidade', 'Aventura']

print(f"Tipo de destino recomendado: {types[predicted_type[0]]}")

# Relatório detalhado

print(f"\nRelatório de classificação:")

print(classification_report(y_test, y_pred, target_names=types))

Por que o KNN é tão eficaz na recomendação de viagens?

A simplicidade conceitual do algoritmo esconde um poder analítico surpreendente para dados turísticos. Contudo, sua verdadeira força está na flexibilidade para capturar relações complexas sem suposições restritivas. O KNN pode identificar padrões de preferência não-lineares que modelos mais rígidos poderiam perder completamente. Similarmente a como agentes de viagens experientes entendem clientes, o algoritmo adapta-se naturalmente às particularidades dos dados de cada destino.

Encontrando o número ideal de destinos de referência

Escolher o K certo é crucial para recomendações precisas. Portanto, vamos testar diferentes valores:

import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Testando diferentes valores de K
k_values = range(1, 21)
train_scores = []
test_scores = []

for k in k_values:
    # Criando e treinando o classificador
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train_scaled, y_train)
    
    # Calculando acurácias
    train_accuracy = knn.score(X_train_scaled, y_train)
    test_accuracy = knn.score(X_test_scaled, y_test)
    
    train_scores.append(train_accuracy)
    test_scores.append(test_accuracy)

# Encontrando o melhor K
best_k = k_values[np.argmax(test_scores)]
best_accuracy = max(test_scores)

print(f"Melhor K: {best_k} destinos de referência")
print(f"Acurácia correspondente: {best_accuracy:.1%}")

# Visualizando a relação entre K e performance
plt.figure(figsize=(12, 6))
plt.plot(k_values, train_scores, 'o-', label='Acurácia Treino', linewidth=2)
plt.plot(k_values, test_scores, 'o-', label='Acurácia Teste', linewidth=2)
plt.axvline(best_k, color='red', linestyle='--', label=f'Melhor K = {best_k}')
plt.xlabel('Número de Destinos de Referência (K)')
plt.ylabel('Acurácia da Classificação')
plt.title('Encontrando o Número Ideal de Referências para Recomendação de Viagens')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

print("\nPadrões observados na análise:")
print("K muito baixo: superajuste a características específicas")
print("K muito alto: perda de nuances culturais importantes")
print("K ideal: balance entre personalização e generalização")

import matplotlib.pyplot as plt

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

# Testando diferentes valores de K

k_values = range(1, 21)

train_scores = []

test_scores = []

for k in k_values:

# Criando e treinando o classificador

knn = KNeighborsClassifier(n_neighbors=k)

knn.fit(X_train_scaled, y_train)

# Calculando acurácias

train_accuracy = knn.score(X_train_scaled, y_train)

test_accuracy = knn.score(X_test_scaled, y_test)

train_scores.append(train_accuracy)

test_scores.append(test_accuracy)

# Encontrando o melhor K

best_k = k_values[np.argmax(test_scores)]

best_accuracy = max(test_scores)

print(f"Melhor K: {best_k} destinos de referência")

print(f"Acurácia correspondente: {best_accuracy:.1%}")

# Visualizando a relação entre K e performance

plt.figure(figsize=(12, 6))

plt.plot(k_values, train_scores, 'o-', label='Acurácia Treino', linewidth=2)

plt.plot(k_values, test_scores, 'o-', label='Acurácia Teste', linewidth=2)

plt.axvline(best_k, color='red', linestyle='--', label=f'Melhor K = {best_k}')

plt.xlabel('Número de Destinos de Referência (K)')

plt.ylabel('Acurácia da Classificação')

plt.title('Encontrando o Número Ideal de Referências para Recomendação de Viagens')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

print("\nPadrões observados na análise:")

print("K muito baixo: superajuste a características específicas")

print("K muito alto: perda de nuances culturais importantes")

print("K ideal: balance entre personalização e generalização")

Lições práticas do turismo para a ciência de dados

Normalizar métricas é essencial pois diferentes escalas distorcem similaridades entre destinos. Escolher a métrica de distância correta depende do tipo de relação entre as variáveis turísticas. Ponderar destinos por proximidade geralmente produz recomendações mais refinadas. Considerar diferentes algoritmos de busca otimiza performance com muitos destinos no banco de dados. Entretanto, lembre-se que o KNN pode ser computacionalmente intensivo com catálogos muito extensos.

Comparando estratégias de ponderação para recomendação

Diferentes abordagens de peso impactam significativamente as recomendações. Analogamente, cada estratégia serve melhor a diferentes tipos de viajantes:

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Estratégias de peso para comparar
weight_strategies = [
    ('uniform', 'Peso Uniforme'),
    ('distance', 'Peso por Proximidade')
]

results = []

for weights, description in weight_strategies:
    knn = KNeighborsClassifier(
        n_neighbors=7,
        weights=weights,
        metric='euclidean'
    )
    
    knn.fit(X_train_scaled, y_train)
    accuracy = knn.score(X_test_scaled, y_test)
    
    results.append({
        'weights': weights,
        'description': description,
        'accuracy': accuracy
    })

# Mostrando resultados comparativos
print("Comparação de Estratégias de Ponderação:")
for result in sorted(results, key=lambda x: x['accuracy'], reverse=True):
    print(f"{result['description']:20} | Acurácia: {result['accuracy']:.3f}")

print("\nRecomendações para sistemas de viagem:")
print("Peso uniforme: quando todos os destinos são igualmente interessantes")
print("Peso por proximidade: quando destinos mais similares são preferíveis")
print("Peso personalizado: para preferências específicas do viajante")

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

# Estratégias de peso para comparar

weight_strategies = [

('uniform', 'Peso Uniforme'),

('distance', 'Peso por Proximidade')

]

results = []

for weights, description in weight_strategies:

knn = KNeighborsClassifier(

n_neighbors=7,

weights=weights,

metric='euclidean'

)

knn.fit(X_train_scaled, y_train)

accuracy = knn.score(X_test_scaled, y_test)

results.append({

'weights': weights,

'description': description,

'accuracy': accuracy

})

# Mostrando resultados comparativos

print("Comparação de Estratégias de Ponderação:")

for result in sorted(results, key=lambda x: x['accuracy'], reverse=True):

print(f"{result['description']:20} | Acurácia: {result['accuracy']:.3f}")

print("\nRecomendações para sistemas de viagem:")

print("Peso uniforme: quando todos os destinos são igualmente interessantes")

print("Peso por proximidade: quando destinos mais similares são preferíveis")

print("Peso personalizado: para preferências específicas do viajante")

Perguntas frequentes sobre aplicações turísticas

Como escolher o K ideal para recomendação de destinos? Comece com a raiz quadrada do número de destinos no catálogo. Use validação cruzada para refinar essa escolha baseada em satisfação do usuário. Valores ímpares evitam empates em problemas de classificação. Principalmente, considere o trade-off entre personalização e diversidade de opções.

O KNN funciona com características qualitativas de destinos? Certamente, mas você precisa usar métricas apropriadas como a distância de Hamming. Para dados mistos (quantitativos e qualitativos), considere transformações ou métricas customizadas. Características como “tipo de culinária local” podem ser convertidas em representações numéricas significativas.

Por que o KNN é lento com muitos destinos no catálogo? Porque ele calcula distâncias para todos os locais durante cada recomendação. Estruturas como KD-Trees e Ball Trees aceleram esse processo significativamente. Em catálogos muito grandes, considere amostragem estratégica ou métodos aproximados de busca.

Quando devo evitar KNN para recomendação de viagens? Evite quando tiver centenas de características ou quando precisar de explicações detalhadas para cada recomendação. Situações que exigem incorporação de feedback em tempo real também não combinam bem com KNN. Ademais, contextos com preferências temporais complexas podem exigir abordagens sequenciais especializadas.

Aplicação em planejamento de roteiros personalizados

Vamos expandir para um cenário mais específico de criação de itinerários. Similarmente ao que agências especializadas fazem, podemos prever orçamentos:

from sklearn.neighbors import KNeighborsRegressor
import numpy as np
import matplotlib.pyplot as plt

# Simulando dados de viagens realizadas
np.random.seed(42)
n_trips = 150

# Características: duração, tipo de hospedagem, alimentação, etc.
duration = np.random.uniform(3, 21, n_trips)
accommodation = np.random.uniform(1, 5, n_trips)  # 1=hostel, 5=hotel 5 estrelas
food_budget = np.random.uniform(20, 100, n_trips)
activities = np.random.uniform(0, 3, n_trips)     # Número de atividades por dia
season = np.random.uniform(0, 1, n_trips)         # 0=baixa temporada, 1=alta temporada

# Custo total baseado nas características
base_cost = 500.0
duration_effect = duration * 50.0
accommodation_effect = accommodation * 200.0
food_effect = food_budget * duration
activities_effect = activities * 75.0 * duration
season_effect = season * 300.0

total_cost = base_cost + duration_effect + accommodation_effect + food_effect + activities_effect + season_effect + np.random.normal(0, 200, n_trips)

# Preparando os dados
X_trips = np.column_stack([duration, accommodation, food_budget, activities, season])
y_trips = total_cost

# Criando e treinando o modelo de previsão
budget_predictor = KNeighborsRegressor(n_neighbors=5, weights='distance')
budget_predictor.fit(X_trips, y_trips)

# Visualizando uma previsão específica
sample_trip = [[10, 3, 50, 2, 0.7]]  # 10 dias, hotel 3 estrelas, R$50/dia comida, 2 atividades/dia, alta temporada
predicted_budget = budget_predictor.predict(sample_trip)

print(f"Exemplo de previsão de orçamento:")
print(f"Duração: 10 dias, Hospedagem: 3 estrelas")
print(f"Alimentação: R$50/dia, Atividades: 2/dia")
print(f"Temporada: Alta (0.7)")
print(f"Orçamento previsto: R$ {predicted_budget[0]:.2f}")

# Análise de sensibilidade à duração da viagem
duration_range = np.linspace(5, 20, 30)
cost_by_duration = []

for days in duration_range:
    test_trip = [[days, 3, 50, 2, 0.7]]
    cost = budget_predictor.predict(test_trip)
    cost_by_duration.append(cost[0])

plt.figure(figsize=(10, 6))
plt.plot(duration_range, cost_by_duration, linewidth=2)
plt.xlabel('Duração da Viagem (dias)')
plt.ylabel('Custo Total Previsto (R$)')
plt.title('Impacto da Duração no Orçamento de Viagem')
plt.grid(True, alpha=0.3)
plt.show()

from sklearn.neighbors import KNeighborsRegressor

import numpy as np

import matplotlib.pyplot as plt

# Simulando dados de viagens realizadas

np.random.seed(42)

n_trips = 150

# Características: duração, tipo de hospedagem, alimentação, etc.

duration = np.random.uniform(3, 21, n_trips)

accommodation = np.random.uniform(1, 5, n_trips) # 1=hostel, 5=hotel 5 estrelas

food_budget = np.random.uniform(20, 100, n_trips)

activities = np.random.uniform(0, 3, n_trips) # Número de atividades por dia

season = np.random.uniform(0, 1, n_trips) # 0=baixa temporada, 1=alta temporada

# Custo total baseado nas características

base_cost = 500.0

duration_effect = duration * 50.0

accommodation_effect = accommodation * 200.0

food_effect = food_budget * duration

activities_effect = activities * 75.0 * duration

season_effect = season * 300.0

total_cost = base_cost + duration_effect + accommodation_effect + food_effect + activities_effect + season_effect + np.random.normal(0, 200, n_trips)

# Preparando os dados

X_trips = np.column_stack([duration, accommodation, food_budget, activities, season])

y_trips = total_cost

# Criando e treinando o modelo de previsão

budget_predictor = KNeighborsRegressor(n_neighbors=5, weights='distance')

budget_predictor.fit(X_trips, y_trips)

# Visualizando uma previsão específica

sample_trip = [[10, 3, 50, 2, 0.7]] # 10 dias, hotel 3 estrelas, R$50/dia comida, 2 atividades/dia, alta temporada

predicted_budget = budget_predictor.predict(sample_trip)

print(f"Exemplo de previsão de orçamento:")

print(f"Duração: 10 dias, Hospedagem: 3 estrelas")

print(f"Alimentação: R$50/dia, Atividades: 2/dia")

print(f"Temporada: Alta (0.7)")

print(f"Orçamento previsto: R$ {predicted_budget[0]:.2f}")

# Análise de sensibilidade à duração da viagem

duration_range = np.linspace(5, 20, 30)

cost_by_duration = []

for days in duration_range:

test_trip = [[days, 3, 50, 2, 0.7]]

cost = budget_predictor.predict(test_trip)

cost_by_duration.append(cost[0])

plt.figure(figsize=(10, 6))

plt.plot(duration_range, cost_by_duration, linewidth=2)

plt.xlabel('Duração da Viagem (dias)')

plt.ylabel('Custo Total Previsto (R$)')

plt.title('Impacto da Duração no Orçamento de Viagem')

plt.grid(True, alpha=0.3)

plt.show()

Próximos passos para sistemas de recomendação avançados

Explore weighted KNN para dar mais peso a destinos recentemente populares. Experimente diferentes métricas de distância que capturem melhor similaridade no contexto turístico. Aprenda sobre feature engineering para criar características mais informativas sobre destinos. Estude ensemble methods combinando múltiplos modelos KNN com diferentes parâmetros. Igualmente importante, considere incorporar dados sazonais para capturar variações de preço e disponibilidade.

Conceitos matemáticos para recomendações precisas

Geometria analítica fornece bases para medidas de similaridade multidimensional entre destinos. Estatística multivariada ajuda a entender correlações entre características turísticas. Teoria de decisão auxilia na ponderação de preferências do viajante. Álgebra linear otimiza cálculos de distância em grandes catálogos. Análise de clusters identifica grupos de destinos naturalmente similares. Processos estocásticos modelam flutuações de preço ao longo do tempo. Principalmente, otimização convexa seleciona hiperparâmetros de forma sistemática para maximizar satisfação.

Referências para aprendizado contínuo

O algoritmo dos vizinhos mais próximos oferece uma abordagem intuitiva e poderosa para problemas baseados em similaridade no turismo. Sua aplicação na recomendação de destinos demonstra como conceitos simples podem resolver problemas complexos quando implementados com entendimento adequado do domínio e cuidado analítico. Afinal, encontrar o destino perfeito para suas próximas férias nunca foi tão científico!