discoart
v0.12.1
Também é possível gerar código Python executável diretamente da configuração:
from discoart . config import export_python
export_python ( da ) Se você é um usuário gratuito do Google Colab, uma coisa irritante é a perda de sessões de vez em quando. Ou às vezes você simplesmente interrompe a execução antecipadamente, pois a primeira imagem não é boa o suficiente e uma interrupção do teclado impedirá que .create() retorne qualquer resultado. Em qualquer caso, você pode recuperar facilmente os resultados obtendo o ID da última sessão.
Encontre o ID da sessão. Ele aparece no topo da imagem. 
Extraia o resultado por meio desse ID em qualquer máquina a qualquer momento , não necessariamente no Google Colab:
from docarray import DocumentArray
da = DocumentArray . pull ( 'discoart-3205998582' ) Considere um documento como um dado independente com configuração e imagem, pode-se usá-lo como o estado inicial para a execução futura. Seus .tags serão usados como parâmetros iniciais; .uri , se apresentado, será usado como imagem inicial.
from discoart import create
from docarray import DocumentArray
da = DocumentArray . pull ( 'discoart-3205998582' )
create (
init_document = da [ 0 ],
cut_ic_pow = 0.5 ,
tv_scale = 600 ,
cut_overview = '[12]*1000' ,
cut_innercut = '[12]*1000' ,
use_secondary_model = False ,
)Se você deseja apenas inicializar a partir de um ID DocArray conhecido, basta:
from discoart import create
create ( init_document = 'discoart-3205998582' ) Você pode definir variáveis de ambiente para controlar o metacomportamento do DiscoArt. As variáveis de ambiente devem ser definidas antes de importar o DiscoArt, seja em Bash ou em Python via os.environ .
DISCOART_LOG_LEVEL= ' DEBUG ' # more verbose logs
DISCOART_OPTOUT_CLOUD_BACKUP= ' 1 ' # opt-out from cloud backup
DISCOART_DISABLE_IPYTHON= ' 1 ' # disable ipython dependency
DISCOART_DISABLE_RESULT_SUMMARY= ' 1 ' # disable result summary after the run ends
DISCOART_DEFAULT_PARAMETERS_YAML= ' path/to/your-default.yml ' # use a custom default parameters file
DISCOART_CUT_SCHEDULES_YAML= ' path/to/your-schedules.yml ' # use a custom cut schedules file
DISCOART_MODELS_YAML= ' path/to/your-models.yml ' # use a custom list of models file
DISCOART_OUTPUT_DIR= ' path/to/your-output-dir ' # use a custom output directory for all images and results
DISCOART_CACHE_DIR= ' path/to/your-cache-dir ' # use a custom cache directory for models and downloads
DISCOART_DISABLE_REMOTE_MODELS= ' 1 ' # disable the listing of diffusion models on Github, remote diffusion models allows user to use latest models without updating the codebase.
DISCOART_REMOTE_MODELS_URL= ' https://yourdomain/models.yml ' # use a custom remote URL for fetching models list
DISCOART_DISABLE_CHECK_MODEL_SHA= ' 1 ' # disable checking local model SHA matches the remote model SHA
DISCOART_DISABLE_TQDM= ' 1 ' # disable tqdm progress bar on diffusion DiscoArt fornece dois comandos create e config que permitem executar o DiscoArt a partir da CLI.
python -m discoart create my.yml que cria obras de arte a partir do arquivo de configuração YAML my.yml . Você também pode fazer:
cat config.yml | python -m discoart create Então, como posso ter meu próprio my.yml e como ele se parece? Esse é o segundo comando:
python -m discoart config my.yml que bifurca a configuração YAML padrão e os exporta para my.yml . Agora você pode modificá-lo e executá-lo com o comando python -m discoart create .
Se nenhum caminho de saída for especificado, python -m discoart config imprimirá a configuração padrão em stdout.
Para obter ajuda sobre um comando, adicione --help no final, por exemplo:
python -m discoart create --help usage: python -m discoart create [-h] [YAML_CONFIG_FILE]
positional arguments:
YAML_CONFIG_FILE The YAML config file to use, default is stdin.
optional arguments:
-h, --help show this help message and exit
Servir o DiscoArt é super fácil. Basta executar o seguinte comando:
python -m discoart serveVocê verá:
Agora envie a solicitação ao servidor via curl/Javascript, por exemplo
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/create", "parameters": {"text_prompts": ["A beautiful painting of a singular lighthouse", "yellow color scheme"]}} 'É isso.
É claro que você pode passar todos os parâmetros aceitos pela função create() no JSON.
Já sabemos que a função create é lenta, mesmo na GPU pode levar 10 minutos para terminar uma obra de arte. Isso significa que após o envio da solicitação acima o cliente terá que aguardar 10 minutos pela resposta. Não há nada de errado com esse comportamento, visto que tudo funciona de forma síncrona. Porém, na prática, o cliente pode esperar um progresso ou resultados intermediários no meio, em vez de esperar pelo fim.
O endpoint /result foi projetado para essa finalidade. Ele retornará os resultados intermediários assim que estiverem disponíveis. Tudo que você precisa é especificar name_docarray nos parâmetros de solicitação conforme especificado em /create endpoint. Aqui está um exemplo:
Vamos criar mydisco-123 enviando a seguinte solicitação para /create endpoint:
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/create", "parameters": {"name_docarray": "mydisco-123", "text_prompts": ["A beautiful painting of a singular lighthouse", "yellow color scheme"]}} ' Agora que a solicitação acima está sendo processada no servidor, você pode verificar periodicamente o progresso mydisco-123 enviando a seguinte solicitação para o endpoint /result :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/result", "parameters": {"name_docarray": "mydisco-123"}} 'Um JSON será retornado com o progresso atualizado, com imagem como DataURI, perda, etapas etc. O esquema JSON de Document/DocumentArray é descrito aqui.
Observe que /result não será bloqueado por /create graças ao roteamento inteligente do Jina Gateway. Para aprender/jogar mais sobre esses endpoints, você pode verificar o ReDoc ou a UI do Swagger incorporada no servidor.
Envie para /skip , para pular a execução atual e passar para a próxima execução conforme definido em n_batches :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/skip"} ' Envie para /stop , para interromper a execução atual, cancele todas as execuções n_batches :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/stop"} '/create solicitação É possível ter um endpoint /create desbloqueado: a solicitação do cliente para /create será retornada imediatamente , sem esperar que os resultados sejam finalizados. Agora você precisa confiar totalmente em /result para pesquisar o resultado.
Para ativar este recurso:
flow.yml padrão em myflow.yml ;floating: false para floating: true na seção do executor discoart ;python -m discoart serve myflow.yml Esteja ciente de que a velocidade da solicitação agora está sob seu controle . Ou seja, se o cliente enviar 10 solicitações /create em um segundo, o servidor iniciará 10 create() em paralelo! Isso pode facilmente levar ao OOM. Portanto, a sugestão é habilitar esse recurso apenas se você tiver certeza de que o cliente não está enviando muitas solicitações, por exemplo, você controla a taxa de solicitações do cliente; ou você está usando o DiscoArt atrás de um BFF (backend para frontend).
Se você tiver várias GPUs e quiser executar várias instâncias do DiscoArt em paralelo, aproveitando as GPUs de maneira multiplexada no tempo, você pode copiar e colar o arquivo flow.yml padrão e modificá-lo da seguinte maneira:
jtype : Flow
with :
protocol : http
monitoring : true
port : 51001
port_monitoring : 51002 # prometheus monitoring port
env :
JINA_LOG_LEVEL : debug
DISCOART_DISABLE_IPYTHON : 1
DISCOART_DISABLE_RESULT_SUMMARY : 1
executors :
- name : discoart
uses : DiscoArtExecutor
env :
CUDA_VISIBLE_DEVICES : RR0:3 # change this if you have multiple GPU
replicas : 3 # change this if you have larger VRAM
- name : poller
uses : ResultPoller Aqui estão replicas: 3 diz gerar três instâncias do DiscoArt, CUDA_VISIBLE_DEVICES: RR0:3 garante que eles usem as três primeiras GPUs em um estilo round-robin.
Nomeie-o como myflow.yml e execute
python -m discoart serve myflow.ymlGraças a Jina, há muitas coisas que você pode personalizar! Você pode alterar o número da porta; alterar protocolo para gRPC/Websockets; adicione criptografia TLS; ativar/desativar o monitoramento do Prometheus; você também pode exportá-lo para o pacote de implantação do Kubernetes simplesmente por meio de:
jina export kubernetes myflow.ymlPara obter mais recursos e configurações YAML, verifique os documentos do Jina.
Mudar do gateway HTTP para gRPC é simples:
jtype : Flow
with :
protocol : grpc
...e reinicie o servidor.
Existem várias vantagens em usar o gateway gRPC:
Em geral, se você estiver usando o servidor DiscoArt atrás de um BFF (backend para frontend) ou se seu servidor DiscoArt não atender diretamente o tráfego HTTP dos usuários finais, você deverá usar o protocolo gRPC.
Para se comunicar com um servidor gRPC DiscoArt, pode-se usar um cliente Jina:
# !pip install jina
from jina import Client
c = Client ( host = 'grpc://0.0.0.0:51001' )
da = c . post (
'/create' ,
parameters = {
'name_docarray' : 'mydisco-123' ,
'text_prompts' : [
'A beautiful painting of a singular lighthouse' ,
'yellow color scheme' ,
],
},
)
# check intermediate results
da = c . post ( '/result' , parameters = { 'name_docarray' : 'mydisco-123' }) Para usar um Document/DocumentArray existente como documento de inicialização para create :
from jina import Client
c = Client ( host = 'grpc://0.0.0.0:51001' )
old_da = create (...)
da = c . post (
'/create' ,
old_da , # this can be a DocumentArray or a single Document
parameters = {
'width_height' : [ 1024 , 768 ],
},
) Isso equivale a executar create(init_document=old_da, width_height=[1024, 768]) no servidor. Observação:
init_document .init_document for um DocumentArray, então o primeiro Documento na matriz será usado como o Documento de inicialização.Embora não seja recomendado, também é possível usar o Google Colab para hospedar o servidor DiscoArt. Confira os seguintes tutoriais:
Fornecemos uma imagem Docker pré-construída para executar o DiscoArt pronto para uso. Para atualizar a imagem do Docker para a versão mais recente:
docker pull jinaai/discoart:latestO ponto de entrada padrão é iniciar um notebook Jupyter
# docker build . -t jinaai/discoart # if you want to build yourself
docker run -p 51000:8888 -v $( pwd ) :/home/jovyan/ -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart Agora você pode visitar http://127.0.0.1:51000 para acessar o notebook
Você pode usá-lo no Windows Subsystem for Linux (WSL). Confira o guia oficial aqui.
# Make sure you install Windows 11 or Windows 10, version 21H2
docker run -p 8888:8888 -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart # docker build . -t jinaai/discoart # if you want to build yourself
docker run --entrypoint " python " -p 51001:51001 -v $( pwd ) :/home/jovyan/ -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart -m discoart serve Seu servidor DiscoArt agora está rodando em http://127.0.0.1:51001 .
As imagens do Docker são criadas em cada versão, portanto, é possível bloqueá-las em uma versão específica, digamos 0.5.1 :
docker run -p 51000:8888 -v $( pwd ) :/home/jovyan/ -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart:0.5.1O próximo é criar.
? Se você já é um usuário DD : você está pronto para começar! Não há aprendizado extra, o DiscoArt respeita a mesma semântica de parâmetros do DD5.6. Então é só soltar a sua criatividade! Leia mais sobre suas diferenças aqui.
Você sempre pode fazer isso from discoart import cheatsheet; cheatsheet() para verificar todos os parâmetros novos/modificados.
? Se você é um DALL·E Flow ou um novo usuário : você pode querer seguir passo a passo, pois o Disco Diffusion funciona de uma maneira muito diferente do DALL·E. É muito mais avançado e poderoso: por exemplo, Disco Diffusion pode receber prompts de texto estruturados e ponderados; pode inicializar a partir de uma imagem com ruído controlado; e há muito mais parâmetros que podem ser ajustados. Avisos impacientes como "armchair avocado" só lhe causarão confusão e frustração. Eu recomendo fortemente que você verifique os seguintes recursos antes de tentar seu próprio prompt:
DiscoArt é apoiado por Jina AI e licenciado sob licença MIT. Estamos contratando ativamente engenheiros de IA e engenheiros de soluções para construir o próximo ecossistema de pesquisa neural em código aberto.
