ndvr

Recuperação de vídeo quase duplicada

2ª posição no Hackathon de Pesquisa Neural?

Temos testemunhado um crescimento explosivo de dados de vídeo em uma variedade de sites de compartilhamento de vídeo, com bilhões de vídeos disponíveis na Internet. Torna-se um grande desafio realizar recuperação de vídeo quase duplicada (NDVR) a partir de um banco de dados de vídeo em grande escala. O NDVR visa recuperar vídeos quase duplicados de um enorme banco de dados de vídeos, onde vídeos quase duplicados são definidos como vídeos visualmente próximos dos vídeos originais.

Os usuários têm um forte incentivo para copiar um vídeo curto em alta e enviar uma versão aumentada para chamar a atenção. Com o crescimento dos vídeos curtos, surgem novas dificuldades e desafios para a detecção de vídeos curtos quase duplicados.

Aqui, construímos uma solução de Pesquisa Neural usando Jina para resolver o desafio do NDVR.

Índice

• Recuperação de vídeo quase duplicada
  • Como é?
  • Desafios
  • Dados
  • Pré-requisitos
    • Baixe os dados
  • Executar fluxo de índice
  • Executar fluxo de consulta
  • Melhorias adicionais
  • Créditos

Como é?

_{Exemplo de vídeos de candidatos fortemente positivos. Linha superior: lateralmente manchada, filtrada por cor e lavada com água. Linha do meio: tela horizontal alterada para tela vertical com grandes margens pretas. Linha inferior: girada}

Desafios

_{Exemplo de vídeos fortemente negativos. Todos os candidatos são visualmente semelhantes à consulta, mas não são quase duplicados.}

Dados

Existem três estratégias para selecionar vídeos candidatos:

1. Recuperação Iterativa
2. Recuperação Transformada
3. Mineração baseada em recursos

Decidimos adotar a estratégia de Recuperação Transformada devido à restrição de tempo e recursos. Em aplicações reais, os usuários copiariam vídeos de tendências para incentivos pessoais. Os usuários geralmente optam por modificar ligeiramente seus vídeos copiados para ignorar a detecção. Essas modificações contêm corte de vídeo, inserção de bordas e assim por diante.

Para imitar esse comportamento do usuário, definimos uma transformação temporal, ou seja, aceleração de vídeo, e três transformações espaciais, ou seja, corte de vídeo, inserção de borda preta e rotação de vídeo.

Infelizmente, os conjuntos de dados NDVR pesquisados ​​eram de baixa resolução ou enormes, ou específicos de domínio ou não estavam disponíveis publicamente (também contatamos alguns pessoalmente). Portanto, decidimos criar nosso pequeno conjunto de dados personalizado para fazer experiências.

Pré-requisitos

pip install --upgrade -r requirements.txt

Baixe os dados

bash ./get_data.sh

Executar fluxo de índice

python app.py -t index

O índice Flow é definido da seguinte forma:

 !Flow
with :
  logserver : false
pods :
  chunk_seg :
    uses : craft/craft.yml
    parallel : $PARALLEL
    read_only : true
    timeout_ready : 600000
  tf_encode :
    uses : encode/encode.yml
    needs : chunk_seg
    parallel : $PARALLEL
    read_only : true
    timeout_ready : 600000
  chunk_idx :
    uses : index/chunk.yml
    shards : $SHARDS
    separated_workspace : true
  doc_idx :
    uses : index/doc.yml
    needs : gateway
  join_all :
    uses : _merge
    needs : [doc_idx, chunk_idx]
    read_only : true

Isso se divide nas seguintes etapas:

1. Segmente cada vídeo em quadros-chave (pedaços);
   1. Os quadros-chave são definidos como quadros representativos de um fluxo de vídeo, os quadros que fornecem o resumo mais preciso e compacto do conteúdo do vídeo.
   2. Seria uma forma eficiente de codificar vídeos, pois muitos frames são redundantes.
   3. Fizemos algumas análises de tempo na extração de Keyframe. Demora cerca de 17 segundos para extrair 15 quadros-chave de um vídeo de 5 minutos (17 Mb).
2. Codifique cada quadro-chave (pedaço) como um vetor de comprimento fixo;
3. Armazene todas as representações vetoriais em um banco de dados vetorial com fragmentos .

Aqui usamos um arquivo YAML para definir um fluxo e usá-lo para indexar os dados. A função index usa um parâmetro input_fn que usa um Iterator para passar caminhos de arquivo, que serão posteriormente agrupados em um IndexRequest e enviados ao Flow.

 DATA_BLOB = "./index-videos/*.mp4"
if task == "index" :
    f = Flow (). load_config ( "flow-index.yml" )
    with f :
        f . index ( input_fn = input_index_data ( DATA_BLOB , size = num_docs ), batch_size = 2 )

 def input_index_data ( patterns , size ):
    def iter_file_exts ( ps ):
        return it . chain . from_iterable ( glob . iglob ( p , recursive = True ) for p in ps )

    d = 0
    if isinstance ( patterns , str ):
        patterns = [ patterns ]
    for g in iter_file_exts ( patterns ):
        yield g . encode ()
        d += 1
        if size is not None and d > size :
            break 

Executar fluxo de consulta

python app.py -t query

Você pode então abrir o Jinabox com o endpoint personalizado http://localhost:45678/api/search

A consulta Flow é definida da seguinte forma:

 !Flow
with :
  logserver : true
  read_only : true  # better add this in the query time
pods :
  chunk_seg :
    uses : craft/index-craft.yml
    parallel : $PARALLEL
  tf_encode :
    uses : encode/encode.yml
    parallel : $PARALLEL
  chunk_idx :
    uses : index/chunk.yml
    shards : $SHARDS
    separated_workspace : true
    polling : all
    uses_reducing : _merge_all
    timeout_ready : 100000 # larger timeout as in query time will read all the data
  ranker :
    uses : BiMatchRanker
  doc_idx :
    uses : index/doc.yml

O fluxo de consulta se divide nas seguintes etapas:

1. Execute as etapas 1,2 no fluxo do índice para cada consulta recebida;
2. Recuperar pedaços relevantes do banco de dados;
3. Agregue a pontuação do nível do bloco ao nível do documento;
4. Retorne os principais resultados aos usuários.

Melhorias adicionais

• Reúna mais dados com múltiplas estratégias de mineração para extrair amostras positivas/negativas de vídeos curtos massivos.
• Treine o modelo nos dados e avalie.
• Classificadores personalizados

Créditos

• Jina - Estrutura de pesquisa neural
• Katna - Extração de quadro-chave
• Sistema de recuperação de vídeo quase duplicado em escala de um milhão
• SVD: um conjunto de dados de vídeo curto em grande escala para recuperação de vídeo quase duplicado