DEV Community: Jean Nascimento

Refatorada do dia - Ts + Python + recursividade e tipos

Jean Nascimento — Sat, 25 Jan 2025 14:37:12 +0000

Dia desses eu precisava fazer uma função para converter strings
vazias em algum valor arbitrário, isso em 3 arquivos diferentes, com estruturas de dados completamente diferentes e aninhadas, em Python. Então pensei comigo mesmo:

Qual a forma mais genérica possível de fazer isso?

Vamos imaginar uma estrutura de dados bem simples, mas com os 3 tipos de dados que eu tinha:

string
dict
list

{
    "nome": "",
    "idade": 25,
    "endereco": {
        "rua": "",
        "cidade": "São Paulo",
        "estado": ""
    },
    "contatos": ["", "email@example.com"]
}

A primeira solução que me veio na cabeça foi via Typescript, algo mais ou menos assim:

type NestedObject = { [key: string]: any };

const convertArray = (data: any[]): any[] => 
  data.map(substituirStringsVazias); // Aplica recursivamente em cada elemento

const convertObject = (data: NestedObject): NestedObject => 
  Object.entries(data).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [key]: substituirStringsVazias(value), // Aplica recursivamente em cada valor do objeto
    }),
    {}
  );

const substituirStringsVazias = (data: NestedObject | any[]): NestedObject | any[] => {
  if (Array.isArray(data)) return convertArray(data);
  if (typeof data === "object" && data !== null) return convertObject(data);
  if (typeof data === "string" && data === "") return "NAO_ENCONTRADO";
  return data;
};

Ou seja, primeiramente você precisa cobrir todos os tipos que deseja converter e usar de recursão para converter os dados de forma aninhada.

Você pode estar se pensando por que que eu não reduzi o Object.entries para "NAO_ENCONTRADO" de uma vez.

A resposta é porque eu não posso perder a estrutura de dados inicial, só desejo converter valores vazios existentes em um valor padrão.

A lógica é que eu preciso iniciar testando se é de tal tipo, então pensei em começar a testar pelo tipo de Lista, caso não seja eu testo se é do tipo Objeto. Se for do tipo Objeto então eu itero pelas suas entradas (combinação de [chave, valor]) e para converter um Array em JS a gente precisa usar o reduce. Porém caso não seja Objeto ele pode cair no teste se é uma String, com isso eu tenho mapeado os 3 tipos que quero converter.

Então se tenho todo o cenário mapeado, eu preciso chamar essa função a cada elemento novo que eu encontro, com essa lógica já em mente fica fácil de unir essa lógica em apenas uma função, eu pessoalmente prefiro as funções separadas, mas teve uma época na minha vida que eu tentava converter o máximo possível de funções em one-line. Então nesse caso nosso código ficaria assim:

type NestedObject = { [key: string]: any };

const substituirStringsVazias = (data: NestedObject | any[]): NestedObject | any[] =>
  Array.isArray(data)
    ? data.map(substituirStringsVazias) // Mapeia cada elemento do array aplicando a função
    : typeof data === "object" && data !== null
      ? Object.entries(data).reduce(
          (acc, [key, value]) => ({
            ...acc,
            [key]: substituirStringsVazias(value), // Aplica recursivamente em cada valor do objeto
          }),
          {}
        )
      : typeof data === "string" && data === ""
        ? "NAO_ENCONTRADO" // Substitui string vazia por "NAO_ENCONTRADO"
        : data; // Retorna o valor original se nenhuma condição for atendida

Dei toda essa volta apenas para retirarmos o conceito principal dessa solução: recursividade.

Então como podemos pegar esse conceito e implementar no Python?

Vamos pensar eem converter primeiramente o tipo dict:

def substituir_strings_vazias(dados):
    if isinstance(dados, dict):  # Se for um dicionário
        novo_dicionario = {}
        for k, v in dados.items():  # Itera pelas chaves e valores
            novo_dicionario[k] = substituir_strings_vazias(v)  # Aplica recursivamente
        return novo_dicionario
    elif isinstance(dados, list):  # Se for uma lista
        novo_array = []
        for item in dados:  # Itera pelos itens da lista
            novo_array.append(substituir_strings_vazias(item))  # Aplica recursivamente
        return novo_array

Agora com o teste se é do tipo list a gente reconstrói a list usando a função append para adicionar o item convertido na list. Agora só falta para o tipo string.

def substituir_strings_vazias(dados):
    if isinstance(dados, dict):  # Se for um dicionário
        novo_dicionario = {}
        for k, v in dados.items():  # Itera pelas chaves e valores
            novo_dicionario[k] = substituir_strings_vazias(v)  # Aplica recursivamente
        return novo_dicionario
    elif isinstance(dados, list):  # Se for uma lista
        novo_array = []
        for item in dados:  # Itera pelos itens da lista
            novo_array.append(substituir_strings_vazias(item))  # Aplica recursivamente
        return novo_array
    elif isinstance(dados, str) and dados == "":  # Se for string vazia
        return "NAO_ENCONTRADO"
    return dados  # Retorna o valor original para outros casos

E com isso reconstruímos a mesma lógica de antes.

Porém depois que eu fiz isso me peguei pensando que haveria uma forma pythonica de se fazer isso de um jeito melhor, então me lembrei do dictionary comprehension, logo refatorei para:

def substituir_strings_vazias(dados):
    if isinstance(dados, dict):  # Se for um dicionário
        return {k: substituir_strings_vazias(v) for k, v in dados.items()}
    elif isinstance(dados, list):  # Se for uma lista
        novo_array = []
        for item in dados:  # Itera pelos itens da lista
            novo_array.append(substituir_strings_vazias(item))  # Aplica recursivamente
        return novo_array
    elif isinstance(dados, str) and dados == "":  # Se for string vazia
        return "NAO_ENCONTRADO"
    return dados  # Retorna o valor original para outros casos

Isso me logicamente me lembrou de list comprehension, então refatorei para:

def substituir_strings_vazias(dados):
    if isinstance(dados, dict):  # Se for um dicionário
        return {k: substituir_strings_vazias(v) for k, v in dados.items()}
    elif isinstance(dados, list):  # Se for uma lista
        return [substituir_strings_vazias(item) for item in dados]
    elif isinstance(dados, str) and dados == "":  # Se for string vazia
        return "NAO_ENCONTRADO"
    return dados  # Retorna o valor original para outros casos

Então se entramos com esses valores:

dados = {
    "nome": "",
    "idade": 25,
    "endereco": {
        "rua": "",
        "cidade": "São Paulo",
        "estado": ""
    },
    "contatos": ["", "email@example.com"]
}

Nossa saída será:

{
    "nome": "NAO_ENCONTRADO",
    "idade": 25,
    "endereco": {
        "rua": "NAO_ENCONTRADO",
        "cidade": "São Paulo",
        "estado": "NAO_ENCONTRADO"
    },
    "contatos": ["NAO_ENCONTRADO", "email@example.com"]
}

Como isso funciona passo a passo?

A função vê que dados é um dicionário.

Ela começa um loop pelas chaves e valores:
- Chave: "nome", Valor: ""
  - É uma string vazia → retorna "NAO_ENCONTRADO".
- Chave: "idade", Valor: 25
  - Não é uma string vazia → retorna 25.
- Chave: "endereco", Valor: outro dicionário.
  - Chamada recursiva para processar o dicionário "endereco".
    - "rua": "" → retorna "NAO_ENCONTRADO".
    - "cidade": "São Paulo" → retorna "São Paulo".
    - "estado": "" → retorna "NAO_ENCONTRADO".
  - Resultado: {"rua": "NAO_ENCONTRADO", "cidade": "São Paulo", "estado": "NAO_ENCONTRADO"}.
- Chave: "contatos", Valor: uma lista.
  - Chamada recursiva para processar a lista:
    - Primeiro item: "" → retorna "NAO_ENCONTRADO".
    - Segundo item: "email@example.com" → retorna "email@example.com".
  - Resultado: ["NAO_ENCONTRADO", "email@example.com"].

E isso me deu um insight de reutilizar essa função, pois ela é deveras genérica, para normalizar datasets que possuamvalores nulos ou vazios.

Eu comecei pensando em Typescript pois é mais natural para mim, já tenho algum tempinho com Python mas quanto mais programo com ela mais eu gosto.

ps: a diferença entre os códigos finais é abissal, né?

Busca semântica - a nova fronteira

Jean Nascimento — Sat, 25 Jan 2025 01:27:45 +0000

Busca semântica - a nova fronteira

A busca semântica por vetores é uma abordagem inovadora que transforma o modo como sistemas de informação recuperam dados relevantes. Em vez de depender exclusivamente de correspondência de palavras-chave, como ocorre em métodos de busca tradicionais, a busca semântica utiliza representações vetoriais para capturar o significado subjacente de textos, imagens ou outros tipos de dados. Este artigo explica detalhadamente como essa tecnologia funciona, quais são suas bases matemáticas e computacionais, e apresenta suas aplicações práticas.

Conceitos Fundamentais

Representação Vetorial

Na busca semântica, os dados são transformados em vetores, que são representados como pontos em um espaço multidimensional. Essa representação permite que informações complexas, como palavras ou imagens, sejam comparadas e analisadas em termos de similaridade.

Modelos Baseados em Embeddings: Modelos como Word2Vec, GloVe e BERT convertem palavras, frases ou documentos em vetores com dimensões reduzidas, mantendo relações semânticas. Por exemplo, as palavras "rei" e "rainha" estarão mais próximas no espaço vetorial do que "rei" e "mesa".
Imagens e Dados Multimodais: Redes neurais convolucionais (CNNs) são comumente usadas para gerar embeddings vetoriais para imagens, enquanto modelos como CLIP lidam com dados que combinam texto e imagens.

Similaridade Vetorial

Uma vez que os dados são representados como vetores, é possível comparar sua similaridade. As métricas mais comuns incluem:

Cosseno de Similaridade: Mede o ângulo entre dois vetores, com valores entre -1 e 1.
Distância Euclidiana: Calcula a distância linear entre dois pontos no espaço vetorial.
Distância de Manhattan: Baseia-se na soma das diferenças absolutas entre as coordenadas dos vetores.

Arquitetura de Busca Semântica

Etapas do Processo

Indexação: Dados brutos, como textos, imagens ou áudio, são processados para gerar embeddings vetoriais. Esses vetores são armazenados em um banco de dados otimizado para busca vetorial.
Consulta: A entrada do usuário (uma pergunta ou imagem, por exemplo) é convertida em um vetor utilizando o mesmo modelo de embeddings.
Comparação: O vetor da consulta é comparado aos vetores indexados utilizando métricas de similaridade.
Rankeamento: Os resultados são classificados com base na similaridade calculada, retornando ao usuário os dados mais relevantes.

Infraestrutura Necessária

Modelos de Machine Learning: Para gerar embeddings, utiliza-se modelos pré-treinados ou ajustados com aprendizado por transferência.
Banco de Dados Vetorial: Tecnologias como FAISS (Facebook AI Similarity Search), Milvus ou Pinecone são otimizadas para armazenamento e busca rápida de vetores.
Escalabilidade: Ferramentas de distribuição e armazenamento em nuvem permitem que sistemas semânticos lidem com grandes volumes de dados.

Exemplos de Aplicações

Motores de Busca

Serviços como Google utilizam busca semântica para entender a intenção do usuário por trás de uma consulta e retornar resultados mais precisos, mesmo quando palavras-chave exatas não são usadas.

Sistemas de Recomendação

Plataformas como Netflix e Spotify empregam busca semântica para recomendar conteúdo baseado nas preferências do usuário, analisando embeddings de filmes ou músicas.

E-commerce

Na busca de produtos, sistemas semânticos ajudam a identificar itens relevantes mesmo quando a descrição do usuário não corresponde exatamente aos termos do banco de dados.

Atendimento ao Cliente

Chatbots e assistentes virtuais utilizam busca semântica para oferecer respostas mais contextuais e relevantes, analisando a semântica das perguntas feitas pelos usuários.

Benefícios da Busca Semântica

Melhoria na Relevância dos Resultados: Ao focar no significado, e não apenas em palavras-chave, a busca semântica é mais eficaz para capturar a intenção do usuário.
Flexibilidade: Suporta múltiplas modalidades de dados (texto, imagens, áudio, etc.).
Eficácia em Consultas Complexas: Funciona bem mesmo com consultas vagas ou ambíguas.
Escalabilidade: Com bancos de dados vetoriais especializados, é possível lidar com grandes volumes de dados de forma eficiente.

Desafios e Limitações

Custo Computacional: Gerar embeddings e realizar buscas em espaços multidimensionais pode ser caro em termos de tempo e recursos.
Bias nos Modelos: Modelos de embeddings podem refletir preconceitos presentes nos dados de treinamento.
Interpretação dos Resultados: A classificação baseada em similaridade nem sempre é intuitiva para os usuários.

Tecnologias e Ferramentas Populares

FAISS (Facebook AI Similarity Search): Uma biblioteca eficiente para buscas de similaridade em grandes coleções de vetores.
Milvus: Plataforma de busca vetorial escalável para aplicações em IA.
Pinecone: Solução em nuvem para gestão e busca de vetores.
TensorFlow e PyTorch: Para criar e treinar modelos de embeddings.

A busca semântica por vetores está revolucionando a forma como interagimos com dados, trazendo mais relevância e contextualização à experiência do usuário. Com avanços em hardware, algoritmos e modelos, é uma área de inovação que promete impactar diversos setores.

Referências

Mikolov, T., Chen, K., Corrado, G., & Dean, J. (2013). Efficient Estimation of Word Representations in Vector Space. arXiv preprint arXiv:1301.3781.
Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv preprint arXiv:1810.04805.
Johnson, J., Douze, M., & Jégou, H. (2017). Billion-scale similarity search with GPUs. arXiv preprint arXiv:1702.08734.
Radford, A., Kim, J. W., Hallacy, C., et al. (2021). Learning Transferable Visual Models From Natural Language Supervision. arXiv preprint arXiv:2103.00020.