Extra Inteligencia Artificial • Trilha Progressiva em 4 Níveis

🧭 Navegação Pedagógica

🎯 Nível 1: Fundamentos

Problema 04.1 — Cálculo de Similaridade por Cosseno e Distância Euclidiana

Contexto: Cálculo de Similaridade por Cosseno e Distância Euclidiana no contexto de Representação Semântica com Embeddings.

Requisitos de Execução:

  1. Implementar fórmulas matemáticas de Cosseno $\frac{u \cdot v}{|u| |v|}$ e Distância Euclidiana $\sqrt{\sum(u_i - v_i)^2}$.
  2. Comparar pares de vetores semânticos.

Resultado Esperado

Vetor A <-> Vetor B: Cosseno = 0.96 | Distância = 0.28
Vetor A <-> Vetor C: Cosseno = 0.12 | Distância = 1.34

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_04_1_SeuNome
  2. Envie na tarefa: Atividade Cap 04 - Representação Semântica com Embeddings
🔑 Gabarito de Código & Solução Comentada 
# embeddings_math.py
import math

def similaridade_cosseno(v1, v2):
    dot = sum(a * b for a, b in zip(v1, v2))
    norm1 = math.sqrt(sum(a**2 for a in v1))
    norm2 = math.sqrt(sum(b**2 for b in v2))
    return round(dot / (norm1 * norm2), 4)

def distancia_euclidiana(v1, v2):
    return round(math.sqrt(sum((a - b)**2 for a, b in zip(v1, v2))), 4)

emb_python = [0.9, 0.8, 0.1]
emb_golang = [0.85, 0.78, 0.15]
emb_receita = [0.05, 0.1, 0.95]

print("Python <-> Golang :", similaridade_cosseno(emb_python, emb_golang), "| Dist:", distancia_euclidiana(emb_python, emb_golang))
print("Python <-> Receita:", similaridade_cosseno(emb_python, emb_receita), "| Dist:", distancia_euclidiana(emb_python, emb_receita))

🔍 Nível 2: Prática

Problema 04.2 — Normalização L2 de Embeddings e Produto Escalar Otimizado

Contexto: Normalização L2 de Embeddings e Produto Escalar Otimizado no contexto de Representação Semântica com Embeddings.

Requisitos de Execução:

  1. Criar função de normalização L2 garantindo que o comprimento do vetor seja exatamente 1.0.
  2. Calcular similaridade via produto escalar simples em vetores unitários.

Resultado Esperado

Vetor Original: [3.0, 4.0] | Norma = 5.0
Vetor Normalizado: [0.6, 0.8] | Norma = 1.0
Produto Escalar Otimizado: 0.98

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_04_2_SeuNome
  2. Envie na tarefa: Atividade Cap 04 - Representação Semântica com Embeddings
🔑 Gabarito de Código & Solução Comentada 
# l2_normalization.py
import math

def normalizar_l2(vetor):
    norma = math.sqrt(sum(x**2 for x in vetor))
    if norma == 0: return vetor
    return [round(x / norma, 4) for x in vetor]

def dot_product(v1, v2):
    return round(sum(a * b for a, b in zip(v1, v2)), 4)

v1_norm = normalizar_l2([3.0, 4.0])
v2_norm = normalizar_l2([3.1, 3.9])
print("V1 Normalizado:", v1_norm)
print("Similaridade Rápida (Dot Product):", dot_product(v1_norm, v2_norm))

⚡ Nível 3: Integração

Problema 04.3 — Algoritmo K-Means Simples para Agrupamento de Embeddings

Contexto: Algoritmo K-Means Simples para Agrupamento de Embeddings no contexto de Representação Semântica com Embeddings.

Requisitos de Execução:

  1. Implementar K-Means em Python puro com K=2 sobre conjunto de vetores 2D.
  2. Atualizar centróides por 5 iterações e atribuir clusters.

Resultado Esperado

Iteração 5 -> Centróide 1: [1.1, 1.0] | Centróide 2: [5.2, 5.0]
Clusters convergidos com sucesso.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_04_3_SeuNome
  2. Envie na tarefa: Atividade Cap 04 - Representação Semântica com Embeddings
🔑 Gabarito de Código & Solução Comentada 
# kmeans_embeddings.py
import math

def distancia(p1, p2):
    return math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)

pontos = [(1.0, 1.0), (1.2, 0.9), (5.0, 5.0), (5.3, 4.8)]
c1, c2 = (1.0, 1.0), (5.0, 5.0)

for _ in range(5):
    cluster1, cluster2 = [], []
    for p in pontos:
        if distancia(p, c1) < distancia(p, c2): cluster1.append(p)
        else: cluster2.append(p)
    c1 = (sum(x for x, _ in cluster1)/len(cluster1), sum(y for _, y in cluster1)/len(cluster1))
    c2 = (sum(x for x, _ in cluster2)/len(cluster2), sum(y for _, y in cluster2)/len(cluster2))

print(f"Centróide Cluster 1: {[round(x, 2) for x in c1]}")
print(f"Centróide Cluster 2: {[round(x, 2) for x in c2]}")

🏆 Nível 4: Desafio Corporativo

Problema 04.4 — Mecanismo de Busca Semântica Top-K com Ranking de Documentos

Contexto: Mecanismo de Busca Semântica Top-K com Ranking de Documentos no contexto de Representação Semântica com Embeddings.

Requisitos de Execução:

  1. Implementar motor de busca que receba embedding de query e base de documentos.
  2. Retornar os Top-2 documentos mais relevantes ordenados por score.

Resultado Esperado

Busca por: 'como programar em python'
1º Lugar: 'Tutorial de Sintaxe Python' (Score: 0.92)
2º Lugar: 'Guia de Backend com FastAPI' (Score: 0.81)

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_04_4_SeuNome
  2. Envie na tarefa: Atividade Cap 04 - Representação Semântica com Embeddings
🔑 Gabarito de Código & Solução Comentada 
# semantic_search_engine.py
import math

def cosine_sim(u, v):
    dot = sum(a * b for a, b in zip(u, v))
    n1 = math.sqrt(sum(a**2 for a in u))
    n2 = math.sqrt(sum(b**2 for b in v))
    return dot / (n1 * n2) if n1 * n2 > 0 else 0

documentos = [
    {"id": 1, "titulo": "Tutorial de Sintaxe Python", "emb": [0.9, 0.8, 0.1]},
    {"id": 2, "titulo": "Receita de Bolo de Cenoura", "emb": [0.0, 0.1, 0.9]},
    {"id": 3, "titulo": "Guia de Backend com FastAPI", "emb": [0.8, 0.85, 0.2]}
]

query_emb = [0.85, 0.75, 0.15]
rank = []
for doc in documentos:
    score = cosine_sim(query_emb, doc["emb"])
    rank.append((score, doc["titulo"]))

rank.sort(reverse=True, key=lambda x: x[0])
for pos, (sc, tit) in enumerate(rank[:2], 1):
    print(f"{pos}º Lugar: '{tit}' (Score: {sc:.2f})")
⬅️ Voltar ao Índice de Exercícios 📚 Sumário de Tópicos