Pinokio é um navegador que permite instalar, executar e automatizar localmente qualquer IA em seu computador . Tudo o que você pode executar em sua linha de comando pode ser automatizado com o script Pinokio , com uma interface de usuário amigável.
Você pode usar o Pinokio para automatizar qualquer coisa, incluindo:
Instale aplicativos e modelos de IA
Gerencie e execute aplicativos de IA
Crie fluxos de trabalho para orquestrar aplicativos de IA instalados
Execute qualquer comando para automatizar coisas em sua máquina
e mais...
Aqui está o que torna Pinóquio especial:
Local: tudo é instalado e executado localmente. Nenhum dos seus dados é armazenado no servidor de outra pessoa.
Gratuito: Pinokio é um aplicativo de código aberto 100% gratuito para uso sem restrições. Não há ninguém que pague pelo acesso à API, pois tudo roda na sua máquina local. Jogue com IA o quanto quiser, de graça para sempre.
Privado: você não precisa se preocupar em enviar dados privados apenas para executar a IA, tudo funciona de forma 100% privada em sua própria máquina.
Interface amigável: Pinokio fornece uma GUI amigável para executar e automatizar qualquer coisa para a qual você normalmente precisaria usar o terminal.
Baterias incluídas: Pinokio é um sistema independente. Você não precisa instalar nenhum outro programa. Pinokio pode automatizar qualquer coisa, incluindo instalações de programas/bibliotecas. O único programa que você precisa é o Pinokio.
Plataforma cruzada: Pinokio funciona em TODOS os sistemas operacionais (Windows, Mac, Linux) .
Economize armazenamento e recursos: Pinokio possui muitos recursos de otimização que economizarão centenas de gigabytes de espaço em disco. Além disso, muitos outros recursos de otimização de recursos (como memória) são possíveis com o Pinokio.
Linguagem de script expressiva: o script Pinokio é uma linguagem de script de automação poderosa com recursos como memória, modelos dinâmicos e APIs extensíveis de baixo nível.
Portátil: tudo é armazenado em uma pasta isolada e existe como um arquivo, o que significa que você pode facilmente fazer backup de tudo ou excluir aplicativos simplesmente excluindo arquivos.
Pinokio se inspira no funcionamento dos computadores tradicionais.
Assim como um computador pode fazer todo tipo de coisa graças à sua arquitetura abrangente, o Pinokio, como computador virtual, é uma plataforma abrangente para executar e automatizar qualquer coisa que você possa imaginar com IA.
Sistema de arquivos: onde e como o Pinokio armazena arquivos.
Processador: como o pinokio executa tarefas.
Memória: como o Pinokio implementa uma máquina de estado usando sua memória nativa integrada.
Script: A linguagem de programação que opera o pinokio.
UI: A UI (interface do usuário) por meio da qual os usuários acessam os aplicativos.
Windows
Mac
Linux
Certifique-se de seguir TODAS as etapas abaixo!
Baixar para Windows
Descompacte o arquivo baixado e você verá um arquivo de instalação .exe.
Execute o arquivo do instalador e você verá o seguinte aviso do Windows:
Esta mensagem aparece porque o aplicativo foi baixado da Web e é isso que o Windows faz com os aplicativos baixados da Web.
Para contornar isso,
Clique em "Mais informações"
Em seguida, clique em "Executar mesmo assim"
Certifique-se de seguir AMBOS a etapa 1 E a etapa 2.
Baixar para Apple Silicon Mac (M1/M2/M3/M4) Baixar para Intel Mac
Após baixar os arquivos dmg, você DEVE fazer um patch , conforme mostrado abaixo:
Execute o arquivo do instalador DMG baixado
Arraste o aplicativo “Pinokio” para a pasta Aplicativos
Execute o "patch.command"
Abra o aplicativo Pinokio na pasta de aplicativos
Para Linux, você pode baixar e instalar diretamente da versão mais recente no Github (role até o final da página para ver todos os binários):
Acesse a página de lançamentos
Para ficar por dentro de todas as novas APIs e integrações de aplicativos,
Siga @cocktailpeanut no X para se manter atualizado sobre todos os novos scripts lançados e atualizações de recursos.
Junte-se ao discord do Pinokio para fazer perguntas e obter ajuda.
Pinokio é uma plataforma independente que permite instalar aplicativos de maneira isolada.
Ambiente isolado: não há necessidade de se preocupar em bagunçar as configurações e ambientes do sistema global
Baterias incluídas: não há necessidade de instalar manualmente os programas necessários apenas para instalar algo (como ffpeg , node.js , visual studio , conda , python , pip , etc.). Pinokio cuida disso automaticamente.
Para conseguir isso, o Pinokio armazena tudo em uma única pasta isolada ("pinokio home") , para que nunca precise depender das configurações e programas de todo o sistema, mas execute tudo de maneira independente.
Você pode definir a pasta inicial do Pinokio ao configurar o Pinokio pela primeira vez, bem como alterá-la posteriormente para um novo local na guia de configurações .
Então, onde os arquivos estão armazenados? Clique no botão "Arquivos" na página inicial:
Isso abrirá a pasta inicial do Pinokio no seu explorador de arquivos:
Vejamos rapidamente o que cada pasta faz:
api : armazena todos os aplicativos baixados (scripts).
As pastas dentro desta pasta são exibidas na página inicial do seu Pinokio.
bin : armazena módulos instalados globalmente e compartilhados por vários aplicativos para que você não precise instalá-los de forma redundante.
Por exemplo, ffmpeg , nodejs , python , etc.
cache : armazena todos os arquivos armazenados em cache automaticamente pelos aplicativos que você executa.
Quando algo não funciona, excluir esta pasta e começar do zero pode resolver o problema.
Não há problema em excluir a pasta cache , pois ela será preenchida novamente pelos aplicativos que você usa quando começar a usar os aplicativos.
drive : armazena todos os drives virtuais criados pela API fs.link Pinokio
logs : armazena todos os arquivos de log de cada aplicativo.
Você pode aprender mais sobre o sistema de arquivos aqui
Vamos escrever um script que clona um repositório git.
Crie uma pasta chamada helloworld na pasta Pinokio api.
Crie um arquivo chamado git.json na pasta Pinokio api/helloworld .
{ "run": [{"method": "shell.run","params": { "message": "git clone https://github.com/pinokiocomputer/test"}
}]
} Agora, quando você voltar ao Pinokio, verá seu repositório helloworld aparecer. Navegue até ele e clique na guia git.json para executá-lo:
Você verá que uma pasta api/helloworld/test foi clonada do repositório https://github.com/pinokiocomputer/test.
Também podemos alterar dinamicamente quais comandos executar e como executá-los, usando modelos.
Como exemplo, vamos escrever um script que execute dir no Windows e ls no Linux e Mac.
Na sua pasta api/helloworld , crie um arquivo chamado files.json :
{ "run": [{"method": "shell.run","params": { "message": "{{platform === 'win32' ? 'dir' : 'ls'}}"}
}]
} A expressão do modelo {{ }} contém uma expressão JavaScript
Existem diversas variáveis disponíveis dentro de cada expressão de template, e uma delas é platform.
O valor da platform é darwin (mac), win32 (windows) ou linux (linux).
Isso significa que, no Windows, o script acima é equivalente a:
{ "run": [{"method": "shell.run","params": { "message": "dir"}
}]
}Ou se não for windows (mac ou linux), é equivalente a:
{ "run": [{"method": "shell.run","params": { "message": "ls"}
}]
}Você pode aprender mais sobre modelos aqui
Quando um script Pinokio termina de ser executado, cada sessão de shell gerada por meio do script é descartada e todos os processos relacionados são encerrados.
Por exemplo, vamos tentar iniciar um servidor web local usando servidor http. Crie uma nova pasta chamada httpserver na pasta Pinokio api e crie um novo script chamado index.json :
{ "run": [{"method": "shell.run","params": { "message": "npx -y http-server"}
}]
} Em seguida, volte ao Pinokio e você verá este aplicativo aparecer na página inicial. Clique e clique na guia index.json na barra lateral, e ele iniciará este script, que deve iniciar o servidor web usando npx http-server .
Mas o problema é que logo após iniciar o servidor ele será desligado imediatamente e você não poderá usar o servidor web.
Isso ocorre porque o Pinokio desliga automaticamente todos os processos associados ao script quando termina de executar todas as etapas da matriz run .
Para evitar isso, você precisa informar ao Pinokio que este aplicativo deve permanecer ativo mesmo depois de todas as etapas terem sido executadas. Precisamos simplesmente adicionar um atributo daemon :
{ "daemon": true, "run": [{"method": "shell.run","params": { "message": "npx -y http-server"}
}]
}Agora tente iniciar o script novamente e você verá que o servidor web começa a funcionar e não desliga.
O servidor web servirá todos os arquivos da pasta atual (neste caso apenas index.json ), assim:
Você pode interromper o script pressionando o botão “parar” na parte superior da página.
Saiba mais sobre o modo daemon aqui
Você também pode executar vários comandos com uma chamada shell.run .
Vamos tentar um exemplo. Vamos instalar, inicializar e lançar um mecanismo de documentação em um script.
Coisas assim não eram acessíveis para pessoas normais (já que você tem que rodar essas coisas no terminal), mas com o Pinokio é tão fácil quanto um clique.
Crie uma pasta chamada docsify na pasta Pinokio api
Crie um arquivo chamado index.json na pasta api/docsify . O arquivo index.json deve ter a seguinte aparência:
{ "daemon": true, "run": [{"method": "shell.run","params": { "message": ["npx -y docsify-cli init docs","npx -y docsify- cli servir documentos"]
}
}]
}Este exemplo faz duas coisas:
Inicialize um projeto de documentação docsify
Inicie o servidor de desenvolvimento docsify
Quando você clica no link do servidor de desenvolvimento no terminal Pinokio, a página de documentação será aberta em um navegador da web:
Saiba mais sobre a API
shell.runaqui
Um dos casos de uso comuns do Pinokio é:
Criar/ativar um evento
Instale dependências no venv ativado
Vamos tentar um exemplo simples. Este exemplo é um aplicativo gradio mínimo do tutorial oficial do gradio
Primeiro, crie uma pasta chamada gradio_demo na pasta api do Pinokio.
Em seguida, crie um arquivo chamado app.py na pasta api/gradio_demo .
# app.pyimport gradio as grdef greet(nome, intensidade):return "Olá, " + nome + "!" * int(intensidade)demo = gr.Interface(fn=greet,inputs=["text", "slider"],outputs=["text"], )demo.launch()
Também precisamos de um arquivo requirements.txt parecido com este:
# requirements.txt gradio
Finalmente, precisamos de um script install.json que instalará as dependências do arquivo requirements.txt :
{ "run": [{"method": "shell.run","params": { "venv": "env", "message": "pip install -r requisitos.txt"}
}]
}A estrutura de pastas ficará assim:
/PINOKIO_HOME /api /gradio_demo app.py requirements.txt install.json
Volte para Pinokio e você verá o aplicativo gradio_demo . Clique na IU e clique na guia install.json , e ele irá:
Crie uma pasta venv no caminho env
Ative o ambiente env
Execute pip install -r requirements.txt , que instalará a dependência gradio no ambiente env .
Esta é a aparência do processo de instalação (observe que uma nova pasta env foi criada no final):
Saiba mais sobre a API venv aqui
continuação da última seção.
Agora vamos escrever um script simples que iniciará o servidor gradio a partir do app.py da última seção. Crie um arquivo chamado start.json na mesma pasta:
{ "daemon": true, "run": [{"method": "shell.run","params": { "venv": "env", "message": "python app.py"}
}]
} Volte para Pinokio e você verá que o arquivo start.json agora também aparece na barra lateral. Clique para iniciar o script start.json . Isto irá:
ative o ambiente env que criamos na etapa de instalação
execute python app.py no modo daemon ( daemon: true ), que iniciará o servidor gradio e o manterá funcionando.
Será algo assim:
Saiba mais sobre a API venv aqui
Pinokio possui uma API multiplataforma para baixar arquivos de maneira fácil e confiável (incluindo novas tentativas automáticas, etc.).
Vamos tentar escrever um script simples que baixe um PDF.
Primeiro crie uma pasta chamada download na pasta Pinokio api e, em seguida, crie um arquivo chamado index.json :
{ "run": [{"method": "fs.download","params": { "uri": "https://arxiv.org/pdf/1706.03762.pdf", "dir": "pdf"}
}]
} Isso fará o download do arquivo em https://arxiv.org/pdf/1706.03762.pdf para uma pasta chamada pdf (a API fs.download cria automaticamente uma pasta no local, caso ela ainda não exista). Aqui está o que parece:
Saiba mais sobre a API
fs.downloadaqui
Em muitos casos você pode querer chamar um script de outro script. Alguns exemplos:
Um script de orquestração que acelera stable diffusion e depois llama .
Um agente que inicia stable diffusion e imediatamente faz uma solicitação para gerar uma imagem e, finalmente, interrompe o servidor stable diffusion para economizar recursos, automaticamente.
Um agente que faz uma solicitação a um endpoint llama e, em seguida, alimenta a resposta a um endpoint stable diffusion .
Podemos conseguir isso usando as APIs script :
script.start : inicia um script remoto (baixe primeiro se ainda não existir)
script.return : se o script atual for um processo filho, especifique o valor de retorno, que será disponibilizado na próxima etapa do script chamador.
Aqui está um exemplo. Vamos criar um caller.json e callee.json simples:
caller.json :
{ "run": [{"method": "script.start","params": { "uri": "callee.json", "params": { "a": 1, "b": 2 }
}
}, {"método": "log","params": { "json2": "{{input}}"}
}]
} Primeira etapa, o caller.json chamará callee.json com os parâmetros { "a": 1, "b": 2 } .
Este objeto params será passado para callee.json como args :
callee.json :
{ "run": [{"method": "script.return","params": { "ressponse": "{{args.a + args.b}}"}
}]
} O script callee.json retorna imediatamente o valor {{args.a + args.b}} com a chamada script.return .
Por fim, o caller.json chamará a última etapa log , que imprimirá o valor {{input}} , que é o valor de retorno de callee.json . Isso imprimirá 3 :
A última seção explicou como você pode chamar um script dentro do mesmo repositório. Mas e se você quiser chamar scripts de outros repositórios?
A API script.start também pode baixar e executar scripts remotos dinamicamente.
Crie uma pasta chamada remotescript na pasta Pinokio api e crie um arquivo chamado install.json em api/remotescript :
{ "run": [{"method": "script.start","params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/install.js"}
}, {"method": "script.start","params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/start.js"}
}, {"id": "run","method": "gradio.predict","params": { "uri": "{{kernel.script.local('https://github.com/cocktailpeanutlabs/ moondream2.git/start.js').url}}", "path": "/answer_question_1", "params": [
{ "path": "https://media.timeout.com/images/105795964/750/422/image.jpg" },"Explique o que está acontecendo aqui" ]
}
}, {"método": "log","params": { "json2": "{{input}}"}
}, {"method": "script.stop","params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/start.js"}
}]
}A primeira etapa inicia o script https://github.com/cocktailpeanutlabs/moondream2.git/install.js.
Se o repositório moondream2.git já existir no Pinokio, ele executará o script install.js.
Se ainda não existir, Pinokio clona automaticamente o repositório https://github.com/cocktailpeanutlabs/moondream2.git primeiro e, em seguida, inicia o script install.js.
Após a conclusão da instalação, ele inicia o aplicativo gradio usando o script https://github.com/cocktailpeanutlabs/moondream2.git/start.js. Este script retornará após o servidor ser iniciado.
Agora executamos gradio.predict , usando a API kernel.script.local() para obter o objeto da variável local para o script start.js e, em seguida, obtendo seu valor url (que é definido programaticamente dentro do moondream2.git/start.js roteiro).
Basicamente, esta etapa faz uma solicitação ao endpoint gradio para perguntar ao LLM “Explique o que está acontecendo aqui”, passando uma imagem.
Em seguida, o valor de retorno de gradio.predict é registrado no terminal usando a API log .
Finalmente, paramos o script moondream2/start.js para desligar o servidor moondream gradio usando a API script.stop .
Se não chamarmos script.stop , o aplicativo moondream2 continuará em execução mesmo após a interrupção do script.
Aqui está como seria:
A capacidade de executar
script.starte, em seguida,script.stopé muito útil para executar IA em computadores pessoais, porque a maioria dos computadores pessoais não possui memória ilimitada e seu computador ficará rapidamente sem memória se você não conseguir desligar esses mecanismos de IA programaticamente.Com
script.stopvocê pode iniciar um script, obter sua resposta e desligá-lo imediatamente assim que a tarefa for concluída, o que liberará memória do sistema, que você pode usar para executar outras tarefas de IA subsequentes.
Os aplicativos Pinokio têm uma estrutura simples:
atalho: o atalho do aplicativo que aparece na página inicial do Pinokio.
app: o layout principal da IU do aplicativo
Shortcut
App
Menu: A barra lateral que exibe todos os links que você pode executar (bem como seu status de execução)
Janela: a janela de visualização que exibe uma página da web ou um terminal que executa os scripts
Por padrão, se você não tiver um arquivo pinokio.js em seu projeto,
o atalho exibe o nome da pasta como título e um ícone padrão como ícone do aplicativo.
o menu exibe todos os arquivos .js ou .json na raiz do seu repositório.
Embora seja conveniente para começar, não é flexível o suficiente:
Você não pode controlar o que é exibido na barra de menu
Você não pode controlar como os scripts são iniciados (passando params , por exemplo)
Você não pode controlar como o aplicativo é exibido
O título do aplicativo será o nome da sua pasta
Não há descrição
O ícone mostrará apenas um ícone padrão.
Para personalizar o comportamento do seu aplicativo, você desejará escrever um script de UI chamado pinokio.js .
Vamos tentar escrever uma UI mínima:
Crie uma pasta chamada downloader na pasta /PINOKIO_HOME/api
Adicione qualquer ícone à pasta /PINOKIO_HOME/api/downloader e nomeie-o como icon.png
Crie um arquivo chamado /PINOKIO_HOME/api/downloader/download.json
Crie um arquivo chamado /PINOKIO_HOME/api/downloader/pinokio.js
/PINOKIO_HOME/api/downloader/icon.png
/PINOKIO_HOME/api/downloader/download.json
{ "run": [{"method": "shell.run","params": { "message": "git clone {{input.url}}"}
}]
}/PINOKIO_HOME/api/downloader/pinokio.js
módulo.exportações = {
título: "Baixar qualquer coisa",
description: "Baixar um repositório git",
ícone: "icon.png",
menu: [{texto: "Iniciar",href: "download.json",params: {url: "https://github.com/cocktailpeanut/dalai"}
}]}O resultado final ficará assim no seu explorador de arquivos:
Agora volte para o Pinokio e atualize, e você verá seu aplicativo aparecer:
o título exibe Download Anything
a descrição exibe Download a git repository
o ícone é o icon.png que adicionamos
Agora, ao clicar no aplicativo, você verá o seguinte:
Você verá o item de menu Start .
Clique aqui para executar o download.json que é especificado pelo atributo href .
Observe também que o script está passando o valor de https://github.com/cocktailpeanut/dalai como o valor params.url .
Os params passados para download.json são disponibilizados como variável input , portanto, o git clone {{input.url}} será instanciado como git clone https://github.com/cocktailpeanut/dalai .
Depois de ter um repositório de scripts funcional, você pode publicar em qualquer serviço de hospedagem git e compartilhar a URL, e qualquer pessoa poderá instalar e executar seu script.
Você pode instalar qualquer repositório de scripts pinokio com muita facilidade:
Clique no botão “Baixar do URL” na parte superior da página Descobrir.
Insira o URL do git (opcionalmente, você também pode especificar o branch).
Se você publicou no github, pode marcar seu repositório com “pinokio” para que ele apareça na seção “mais recente” da página Descobrir.
Agora ele aparecerá automaticamente na seção “mais recente” (na parte inferior da página “Descobrir”):
Pinokio constrói a seção "Mais recente" automaticamente a partir da API "/repositories" do GitHub em https://api.github.com/search/repositories?q=topic:pinokio&sort=updated&direction=desc
Portanto, se você marcou seu repositório como "pinokio", mas ele não aparece, verifique o resultado da API e tente descobrir por que ele não está incluído lá.
Embora seja importante entender como tudo isso funciona, na maioria dos casos você pode querer um simples “combo de inicialização”, que inclui:
Script de instalação do aplicativo: instala as dependências do aplicativo
Script de inicialização do aplicativo: inicia o aplicativo
UI: Exibe a UI do iniciador.
Script de redefinição: redefine o estado do aplicativo quando algo dá errado.
Script de atualização: atualiza o aplicativo para a versão mais recente com 1 clique.
Esse caso de uso é necessário com tanta frequência que implementamos um programa que gera automaticamente esses scripts instantaneamente. Chama-se Gepeto.
Muitas vezes você pode querer compartilhar mais informações sobre cada script. Você pode usar o feed de notícias para isso.
Para fazer isso, basta criar um arquivo pinokio_meta.json , com um atributo de array posts , onde cada item é uma URL x.com. Aqui está um exemplo:
{ "postagens": ["https://x.com/cocktailpeanut/status/1819482952071323788","https://x.com/cocktailpeanut/status/1819439443394109837","https://x.com/cocktailpeanut/status/1800944955738685648" ,"https://x.com/cocktailpeanut/status/1754244867159413001","https://x.com/cocktailpeanut/status/1729884460114727197","https://x.com/cocktailpeanut/status/1728075614807048208"
]
}Você pode vê-lo em ação: https://github.com/cocktailpeanutlabs/comfyui/blob/main/pinokio_meta.json
Depois de publicar, isso será refletido imediatamente na página inicial do script.
<iframe width="1280" height="720" src="https://www.youtube.com/embed/D8jdowszkMg" title="Leitor de vídeo do YouTube" frameborder="0" permitir="acelerômetro; reprodução automática; área de transferência- gravação; mídia criptografada; giroscópio; picture-in-picture" permitir tela cheia></iframe>
Gepeto é um programa que permite gerar scripts Pinokio automaticamente, especificamente para inicializadores de aplicativos.
Vamos começar gerando um aplicativo e seu inicializador em 1 minuto.
<iframe width="1280" height="720" src="https://www.youtube.com/embed/I-_W-MkV8tc" title="Leitor de vídeo do YouTube" frameborder="0" permitir="acelerômetro; reprodução automática; gravação na área de transferência; giroscópio; imagem em imagem" permitir tela inteira></iframe>
Se você ainda não tem o gepeto instalado, encontre-o no Pinokio e instale primeiro.
Você verá uma interface da web simples que permite preencher um formulário. Para simplificar, basta inserir Helloworld como nome do projeto e pressionar enviar .
Isso inicializará um projeto. Quando você voltar para a casa do Pinóquio,
Você verá uma nova entrada chamada Helloworld . Clique nele e você verá a tela do iniciador.
Além disso, verifique sua pasta /PINOKIO_HOME/api , você encontrará uma nova pasta chamada Helloworld com alguns arquivos de script.
Agora vamos clicar no botão instalar para instalar o aplicativo e, quando terminar, clicar em iniciar para iniciá-lo.
Você verá um aplicativo de gradio mínimo, onde poderá inserir um prompt e ele irá gerar uma imagem usando Stable Diffusion XL Turbo.
Então o que aconteceu? Acabamos de criar um projeto vazio , que vem com um aplicativo de demonstração mínimo.
Vamos dar uma olhada em cada arquivo gerado na próxima seção.
Gepeto gera automaticamente um conjunto mínimo de scripts necessários para um inicializador de aplicativos. Um inicializador de aplicativo típico possui os seguintes recursos:
Instalar: instale as dependências necessárias para executar o aplicativo. ( install.js )
Iniciar: inicie o próprio aplicativo. ( start.js )
Redefinir instalação: Redefina todas as dependências instaladas caso você precise reinstalar novamente. ( reset.js )
Atualização: atualize para a versão mais recente quando o projeto for atualizado. ( update.js )
GUI: O script que descreve a aparência e o comportamento do inicializador na página inicial do Pinokio e como um menu da barra lateral. ( pinokio.js )
Aqui está o que parece:
Observe que além dos scripts citados acima, o gepeto gerou alguns arquivos extras:
app.py : um aplicativo de demonstração simples. Substitua isso pelo seu próprio código.
requirements.txt : declara todas as dependências PIP necessárias para app.py Substitua pelo seu próprio.
icon.png : um arquivo de ícone padrão para o aplicativo. Substitua pelo seu próprio.
torch.js : O torch.js é um script utilitário que é chamado de install.js . Como o torch é usado em quase todos os projetos de IA e é bastante complicado instalá-los em várias plataformas, esse script é incluído por padrão. Você não precisa se preocupar com esse arquivo, apenas entenda que ele é usado por install.js . Não toque.
Os arquivos notáveis a serem observados são os arquivos app.py e requirements.txt :
import gradio as grimport torchfrom difusores import DiffusionPipelineimport devicetorch# Obtenha o dispositivo atual ("mps", "cuda" ou "cpu")device = devicetorch.get(torch)# Crie um pipeline de difusãopipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl -turbo").to(device)# Execute inferencedef generate_image(prompt):return pipe( prompt, num_inference_steps=2, Strength=0.5, guide_scale=0.0).images[0]# Crie uma UI de entrada de texto + saída de imagem com Gradioapp = gr.Interface(fn=generate_image, inputs="text", outputs="image")app .lançar() A seguir estão as bibliotecas necessárias para executar app.py .
transformers accelerate diffusers gradio devicetorch
Então, como esses arquivos são realmente usados?
Se você olhar dentro de install.js , verá que ele está executando pip install -r requirements.txt para instalar as dependências dentro do arquivo, assim:
módulo.exportações = {
run: [// Exclua esta etapa se seu projeto não usa torch{ method: "script.start", params: {uri: "torch.js",params: { venv: "env", // Edite isto para personalizar o caminho da pasta venv // xformers: true // remova o comentário desta linha se seu projeto exigir xformers} }},// Edite esta etapa com seus comandos de instalação personalizados{ método: "shell.run", params: {venv: "env" , // Edite isso para personalize a mensagem do caminho da pasta venv: [ "pip install -r requisitos.txt"], }}, // Remova o comentário desta etapa para adicionar desduplicação venv automática (Experimental) // {// método: "fs.link", // params : {// venv: "env"// }// },{ método: "notify", params: {html: "Clique na guia 'iniciar' para começar!" }}
]} A primeira etapa executa script.start para chamar um script chamado torch.js . Isso instala a tocha.
A segunda etapa executa pip install -r requirements.txt file para instalar tudo nesse arquivo.
