gnes
1.0.0
Destaques • Visão geral • Instalação • Primeiros passos • Hub • Documentação • Tutorial • Contribuições • Notas de versão • Blog
GNES [ jee-nes ] é Generic Neural Elastic Search , um sistema de pesquisa semântica nativo da nuvem baseado em rede neural profunda.
O GNES permite indexação em grande escala e pesquisa semântica de texto para texto , imagem para imagem , vídeo para vídeo e qualquer forma de conteúdo.
? Para saber mais sobre os principais princípios do GNES, leia esta postagem do blog
☁️Nativo da nuvem e elástico | ?Fácil de usar | ?Estado da Arte |
|---|---|---|
| GNES é tudo em microsserviço ! Codificador, indexador, pré-processador e roteador estão todos rodando em seus próprios contêineres. Eles se comunicam por meio de APIs versionadas e colaboram sob a orquestração de Docker Swarm/Kubernetes, etc. Dimensionamento, balanceamento de carga, recuperação automatizada, eles já estão prontos para uso no GNES. | Quanto tempo levaria para implantar uma mudança que envolvesse apenas a troca de uma camada no VGG? No GNES, esta é apenas uma alteração de linha em um arquivo YAML. Abstraímos a lógica de codificação e indexação para uma configuração YAML, para que você possa alterar ou empilhar codificadores e indexadores sem sequer tocar na base de código. | Aproveitando as comunidades de IA/ML/PNL/CV em rápida evolução, aprendemos com os melhores modelos de aprendizagem profunda e os conectamos ao GNES, garantindo que você sempre aproveite o desempenho de última geração. |
?Genérico e Universal | ?Modelo como plugin | ?Melhores Práticas |
| Procurando textos, imagens ou até vídeos curtos? Usando Python/C/Java/Go/HTTP como cliente? Não importa qual formato de conteúdo você possui ou qual idioma você usa, o GNES pode lidar com todos eles. | Quando os modelos integrados não atendem aos seus requisitos, basta construir o seu próprio com o GNES Hub. Empacote seu modelo como um contêiner docker e use-o como um plugin. | Adoramos aprender as melhores práticas da comunidade, ajudando nosso GNES a alcançar o próximo nível de disponibilidade, resiliência, desempenho e durabilidade. Se você tiver alguma ideia ou sugestão, fique à vontade para contribuir. |
O GNES Hub envia modelos AI/ML como contêineres Docker e usa contêineres Docker como plug-ins. Ele oferece uma maneira limpa e sustentável de portar algoritmos externos (com dependências) para a estrutura GNES. O GNES Hub está hospedado no Docker Hub. |
Existem duas maneiras de obter o GNES, como uma imagem Docker ou como um pacote PyPi. Para usuários de nuvem, recomendamos fortemente o uso do GNES via Docker .
docker run gnes/gnes:latest-alpineEste comando baixa a imagem GNES mais recente (baseada em Alpine Linux) e a executa em um contêiner. Quando o contêiner é executado, ele imprime uma mensagem informativa e sai.
Além da imagem alpine otimizada para o espaço, também fornecemos imagens baseadas em Buster (Debian 10.0), Ubuntu 18.04 e Ubuntu 16.04. A tabela abaixo resume todas as tags GNES disponíveis. Pode-se preencher {ver} com latest , stable ou v0..xx . latest refere-se ao master mais recente deste repositório, que pode não ser estável. Recomendamos que você use uma versão oficial alterando o latest para um número de versão, digamos v0.0.24 , ou simplesmente usando stable para a última versão, por exemplo, gnes:stable-ubuntu
| Marcação | Tamanho e camadas | Descrição |
|---|---|---|
{ver}-alpine | baseado em Alpine Linux; sem bibliotecas de aprendizagem profunda; extremamente leve e portátil, permite escalonamento rápido até mesmo em dispositivos de ponta. | |
{ver}-buster | baseado no Debian 10.0; sem bibliotecas de aprendizagem profunda; recomendado para construir ou estender uma imagem GNES-Hub. | |
{ver}-ubuntu18 | baseado no Ubuntu 18.04; sem bibliotecas de aprendizagem profunda. | |
{ver}-full | baseado no Ubuntu 16.04; python-3.6.8, cuda-10.0, tf1.14, pytorch1.1, faiss, vários modelos pré-treinados; pesado, mas independente, útil para testar o GNES de ponta a ponta. |
️ Desde 21/10/2019, paramos de hospedar o espelho público Tencent Cloud. As imagens antigas do Docker ainda existem, mas não haverá mais imagens novas disponíveis no Tencent Cloud.
Também fornecemos pacotes Github de espelho público. Selecione o espelho que lhe atende bem.
docker login --username=xxx docker.pkg.github.com/gnes-ai/gnes # login to github package so that we can pull from it
docker run docker.pkg.github.com/gnes-ai/gnes/gnes:latest-alpineA tabela abaixo mostra o status do pipeline de build.
| Registro | Status da compilação |
|---|---|
DockerHubgnes/gnes:[tag] | |
Pacote Githubdocker.pkg.github.com/gnes-ai/gnes/gnes:[tag] |
pipVocê também pode instalar o GNES como um pacote Python3 via:
pip install gnesObserve que isso instalará apenas uma versão "barebone" do GNES, que consiste nas dependências mínimas para executar o GNES. Nenhum modelo pré-treinado de terceiros, pacotes de aprendizado profundo/PNL/CV serão instalados. Fazemos essa configuração como o comportamento de instalação padrão, pois um modelo de interesse para engenheiros de PNL pode não ser do interesse de engenheiros de CV. No GNES, os modelos servem como plug-ins do Docker.
? Tensorflow, Pytorch e torchvision não fazem parte da instalação do GNES. Dependendo do seu modelo, pode ser necessário instalá-los com antecedência.
Embora não seja recomendado, você pode instalar o GNES com dependências completas via:
pip install gnes[all]pip instalar gnes[bert] | bert-serving-server>=1.8.6, bert-serving-client>=1.8.6 |
pip instalar gnes[talento] | talento>=0.4.1 |
pip instalar gnes[irritante] | irritar==1.15.2 |
pip instalar gnes[chinês] | jieba |
pip instalar gnes[visão] | opencv-python>=4.0.0, imagehash>=4.0 |
pip instalar gnes[níveldb] | nível>=1.0.5 |
pip instalar gnes[teste] | pylint, memory_profiler>=0.55.0, psutil>=5.6.1, gputil>=1.4.0 |
pip instalar gnes[transformadores] | transformadores pytorch |
pip instalar gnes[onnx] | onnxruntime |
pip instalar gnes[áudio] | librarosa>=0.7.0 |
pip instalar gnes[scipy] | picante |
pip instalar gnes[nlp] | bert-serving-server>=1.8.6, pytorch-transformers, flair>=0.4.1, bert-serving-client>=1.8.6 |
pip instalar gnes[cn_nlp] | transformadores pytorch, bert-serving-client>=1.8.6, bert-serving-server>=1.8.6, jieba, flair>=0.4.1 |
pip instalar gnes[todos] | pylint, psutil>=5.6.1, pytorch-transformers, irritar==1.15.2, bert-serving-client>=1.8.6, gputil>=1.4.0, bert-serving-server>=1.8.6, imagehash >=4.0, onnxruntime, memory_profiler>=0.55.0, jieba, talento>=0.4.1, librosa>=0.7.0, scipy, plyvel>=1.0.5, opencv-python>=4.0.0 |
Uma boa maneira de escolher as dependências é seguir o exemplo do GNES Hub e construir sua própria imagem GNES.
De qualquer forma, se você acabar lendo a seguinte mensagem depois de $ gnes ou $ docker run gnes/gnes , então você está pronto para começar!
Antes de começarmos, deixe-me apresentar dois conceitos importantes no GNES: microsserviço e fluxo de trabalho .
Para engenheiros de aprendizado de máquina e cientistas de dados que não estão familiarizados com o conceito de microsserviço e nativo da nuvem , pode-se imaginar um microsserviço como um aplicativo em seu smartphone. Cada aplicativo é executado de forma independente e um aplicativo pode cooperar com outros aplicativos para realizar uma tarefa. No GNES, temos quatro aplicativos fundamentais, também conhecidos como. microsserviços, são eles:
No GNES, implementamos dezenas de pré-processadores, codificadores e indexadores para processar diferentes formas de conteúdo, como imagem, texto, vídeo. Também é muito fácil conectar sua própria implementação, da qual veremos um exemplo na sequência.
Agora que temos vários aplicativos, o que esperamos que eles façam? Um sistema de busca típico possui duas tarefas fundamentais: indexação e consulta . O índice está armazenando os documentos, a consulta está pesquisando os documentos. Em um sistema de busca neural, pode-se enfrentar outra tarefa: treinar , onde se ajusta um codificador/pré-processador de acordo com a distribuição dos dados para obter melhor relevância da busca.
Estas três tarefas correspondem a três fluxos de trabalho diferentes no GNES.
Desde
v0.0.46o GNES Flow se tornou a interface principal do GNES. O GNES Flow fornece uma maneira pitônica e intuitiva de implementar um fluxo de trabalho , permitindo que os usuários executem ou depurem o GNES em uma máquina local. Por padrão, o GNES Flow orquestra todos os microsserviços usando back-end multithread ou multiprocesso. Ele também pode ser exportado para uma configuração YAML do Docker Swarm/Kubernetes, permitindo entregar GNES para a nuvem.
? O exemplo completo e o Jupyter Notebook correspondente podem ser encontrados aqui.
Neste exemplo, usaremos a nova API gnes.flow ( gnes >= 0.0.46 é necessário) para construir um sistema de pesquisa de imagens de brinquedos para indexar e recuperar flores com base em suas semelhanças.
Vamos primeiro definir o fluxo de trabalho de indexação:
from gnes . flow import Flow
flow = ( Flow ( check_version = False )
. add_preprocessor ( name = 'prep' , yaml_path = 'yaml/prep.yml' )
. add_encoder ( yaml_path = 'yaml/incep.yml' )
. add_indexer ( name = 'vec_idx' , yaml_path = 'yaml/vec.yml' )
. add_indexer ( name = 'doc_idx' , yaml_path = 'yaml/doc.yml' , recv_from = 'prep' )
. add_router ( name = 'sync' , yaml_path = 'BaseReduceRouter' , num_part = 2 , recv_from = [ 'vec_idx' , 'doc_idx' ]))Aqui, usamos o modelo pré-treinado inceptionV4 como codificador e indexadores integrados para armazenar vetores e documentos. O fluxo deve ser bastante autoexplicativo, caso contrário, você sempre pode convertê-lo para uma imagem SVG e ver sua visualização:
flow . build ( backend = None ). to_url () Para indexar nossos dados de flores, precisamos de um iterador que gere strings bytes e alimente essas strings bytes no fluxo definido.
def read_flowers ( sample_rate = 1.0 ):
with tarfile . open ( '17flowers.tgz' ) as fp :
for m in fp . getmembers ():
if m . name . endswith ( '.jpg' ) and random . random () <= sample_rate :
yield fp . extractfile ( m ). read ()Agora podemos fazer a indexação por meio do backend multiprocesso:
with flow ( backend = 'process' ) as fl :
fl . index ( bytes_gen = read_flowers (), batch_size = 64 )Isso levará alguns minutos dependendo da sua máquina.
Simplesmente amostramos 20 imagens de flores como consultas e pesquisamos as 10 imagens mais semelhantes:
num_q = 20
topk = 10
sample_rate = 0.05
# do the query
results = []
with flow . build ( backend = 'process' ) as fl :
for q , r in fl . query ( bytes_gen = read_flowers ( sample_rate )):
q_img = q . search . query . raw_bytes
r_imgs = [ k . doc . raw_bytes for k in r . search . topk_results ]
r_scores = [ k . score . value for k in r . search . topk_results ]
results . append (( q_img , r_imgs , r_scores ))
if len ( results ) > num_q :
breakAqui está o resultado, onde as consultas estão na primeira linha.
É possível converter um objeto Flow em arquivo de composição YAML do Docker Swarm/Kubernetes com muita facilidade por meio de:
flow . build ( backend = None ). to_swarm_yaml () version : ' 3.4 '
services :
Frontend0 :
image : gnes/gnes:latest-alpine
command : frontend --port_in 56086 --port_out 52674 --port_ctrl 49225 --check_version
False --ctrl_with_ipc True
prep :
image : gnes/gnes:latest-alpine
command : preprocess --port_in 52674 --port_out 65461 --host_in Frontend0 --socket_in
PULL_CONNECT --socket_out PUB_BIND --port_ctrl 49281 --check_version False --ctrl_with_ipc
True --yaml_path yaml/prep.yml
Encoder0 :
image : gnes/gnes:latest-alpine
command : encode --port_in 65461 --port_out 50488 --host_in prep --socket_in SUB_CONNECT
--port_ctrl 62298 --check_version False --ctrl_with_ipc True --yaml_path yaml/incep.yml
vec_idx :
image : gnes/gnes:latest-alpine
command : index --port_in 50488 --port_out 57791 --host_in Encoder0 --host_out
sync --socket_in PULL_CONNECT --socket_out PUSH_CONNECT --port_ctrl 58367 --check_version
False --ctrl_with_ipc True --yaml_path yaml/vec.yml
doc_idx :
image : gnes/gnes:latest-alpine
command : index --port_in 65461 --port_out 57791 --host_in prep --host_out sync
--socket_in SUB_CONNECT --socket_out PUSH_CONNECT --port_ctrl 50333 --check_version
False --ctrl_with_ipc True --yaml_path yaml/doc.yml
sync :
image : gnes/gnes:latest-alpine
command : route --port_in 57791 --port_out 56086 --host_out Frontend0 --socket_out
PUSH_CONNECT --port_ctrl 51285 --check_version False --ctrl_with_ipc True --yaml_path
BaseReduceRouter --num_part 2 Para implantá-lo, basta copiar a configuração YAML gerada para um arquivo, digamos my-gnes.yml e, em seguida, fazer
docker stack deploy --compose-file my-gnes.yml gnes-531Neste exemplo, construiremos um mecanismo de busca semântico de poemas usando GNES. Ao contrário do exemplo anterior de pesquisa de flores, aqui executamos cada serviço como um contêiner Docker isolado e depois os orquestramos por meio do Docker Swarm. Representa um cenário comum nas configurações de nuvem. Você aprenderá como usar imagens GNES poderosas e personalizadas do hub GNES.
? Confira este repositório para obter detalhes e siga as instruções para reproduzir.
Vamos fazer uma breve recapitulação do que aprendemos.
A documentação oficial do GNES está hospedada em doc.gnes.ai. Ele é criado, atualizado e arquivado automaticamente a cada nova versão.
? O tutorial ainda está em construção. Fique atento! Enquanto isso, sinceramente convidamos você a contribuir com sua própria experiência de aprendizagem/estudo de caso com o GNES!
PyTorch-Transformers para GNESbert-as-service Configuramos este repositório para rastrear a latência da rede em diferentes versões do GNES. Como parte do pipeline CICD, este repositório é atualizado automaticamente quando o mestre GNES é atualizado ou uma nova versão do GNES é lançada.
❤️ O começo é sempre o mais difícil. Mas não tenha medo, mesmo se você encontrar um erro de digitação, uma documentação ou um teste de unidade faltando, você pode simplesmente corrigi-los fazendo um commit no GNES. Aqui estão as etapas:
fix-gnes-typo-1fix(readme): improve the readability and move sectionsfix(readme): improve the readability and move sectionsBom trabalho! Depois que um PR é mesclado, aqui estão as coisas que aconteceram a seguir:
-latest serão atualizadas automaticamente em uma hora. Você pode verificar o status de construção aqui-stable serão atualizados de acordo.Mais detalhes podem ser encontrados nas diretrizes do contribuidor.
Se você usar o GNES em um artigo acadêmico, será mais que bem-vindo para fazer uma citação. Aqui estão as duas maneiras de citar o GNES:
footnote{https://github.com/gnes-ai/gnes}
@misc{tencent2019GNES,
title={GNES: Generic Neural Elastic Search},
author={Xiao, Han and Yan, Jianfeng and Wang, Feng and Fu, Jie and Liu, Kai},
howpublished={ url {https://github.com/gnes-ai}},
year={2019}
}Se você baixou uma cópia do binário ou do código-fonte do GNES, observe que o binário e o código-fonte do GNES estão licenciados sob a Licença Apache, Versão 2.0.
A Tencent tem o prazer de apoiar a comunidade de código aberto disponibilizando o GNES.
