Pinokio es un navegador que te permite instalar, ejecutar y automatizar localmente cualquier IA en tu computadora . Todo lo que puede ejecutar en su línea de comando se puede automatizar con el script Pinokio , con una interfaz de usuario fácil de usar.
Puedes usar Pinokio para automatizar cualquier cosa, incluyendo:
Instalar aplicaciones y modelos de IA
Administrar y ejecutar aplicaciones de IA
Cree flujos de trabajo para organizar aplicaciones de IA instaladas
Ejecute cualquier comando para automatizar cosas en su máquina
y más...
Esto es lo que hace que Pinokio sea especial:
Local: todo se instala y se ejecuta localmente. Ninguno de sus datos se almacena en el servidor de otra persona.
Gratis: Pinokio es una aplicación de código abierto que es 100% gratuita y sin restricciones. No hay que pagar por el acceso a la API, ya que todo se ejecuta en su máquina local. Juega con IA todo lo que quieras, gratis para siempre.
Privado: no necesita preocuparse por enviar datos privados solo para ejecutar IA, todo se ejecuta de forma 100 % privada en su propia máquina.
Interfaz fácil de usar: Pinokio proporciona una GUI fácil de usar para ejecutar y automatizar cualquier cosa para la que normalmente necesitaría usar el terminal.
Pilas incluidas: Pinokio es un sistema autónomo. No es necesario instalar ningún otro programa. Pinokio puede automatizar cualquier cosa, incluidas las instalaciones de programas/bibliotecas. El único programa que necesitas es Pinokio.
Multiplataforma: Pinokio funciona en TODOS los sistemas operativos (Windows, Mac, Linux) .
Ahorre almacenamiento y recursos: Pinokio tiene muchas funciones de optimización que le ahorrarán cientos de gigabytes de espacio en disco. Además, muchas otras funciones de optimización de recursos (como la memoria) son posibles con Pinokio.
Lenguaje de secuencias de comandos expresivo: la secuencia de comandos Pinokio es un potente lenguaje de secuencias de comandos de automatización con características como memoria, plantillas dinámicas y API extensibles de bajo nivel.
Portátil: Todo se almacena en una carpeta aislada y todo existe como un archivo, lo que significa que puedes hacer una copia de seguridad de todo fácilmente o eliminar aplicaciones simplemente eliminando archivos.
Pinokio se inspira en el funcionamiento de las computadoras tradicionales.
Así como una computadora puede hacer todo tipo de cosas gracias a su arquitectura integral, Pinokio como computadora virtual es una plataforma integral para ejecutar y automatizar cualquier cosa que puedas imaginar con IA.
Sistema de archivos: dónde y cómo Pinokio almacena los archivos.
Procesador: cómo ejecuta pinokio las tareas.
Memoria: cómo pinokio implementa una máquina de estados utilizando su memoria nativa incorporada.
Script: El lenguaje de programación que opera pinokio.
UI: La UI (interfaz de usuario) a través de la cual los usuarios acceden a las aplicaciones.
ventanas
Impermeable
linux
¡Asegúrate de seguir TODOS los pasos a continuación!
Descargar para Windows
Descomprima el archivo descargado y verá un archivo de instalación .exe.
Ejecute el archivo de instalación y aparecerá la siguiente advertencia de Windows:
Este mensaje aparece porque la aplicación se descargó de la Web y esto es lo que hace Windows con las aplicaciones descargadas de la Web.
Para evitar esto,
Haga clic en "Más información"
Luego haga clic en "Ejecutar de todos modos"
Asegúrese de seguir AMBOS pasos 1 Y 2.
Descarga para Apple Silicon Mac (M1/M2/M3/M4) Descarga para Intel Mac
Después de descargar los archivos dmg, DEBE crear un parche , como se muestra a continuación:
Ejecute el archivo de instalación de DMG descargado
Arrastre la aplicación "Pinokio" a la carpeta Aplicaciones
Ejecute el "comando parche"
Abra la aplicación Pinokio en la carpeta de aplicaciones.
Para Linux, puede descargar e instalar directamente desde la última versión en Github (desplácese hasta el final de la página para ver todos los binarios):
Ir a la página de lanzamientos
Para estar al tanto de todas las nuevas API e integraciones de aplicaciones,
Siga a @cocktailpeanut en X para mantenerse actualizado sobre todos los nuevos scripts que se lanzan y las actualizaciones de funciones.
Únase a Pinokio Discord para hacer preguntas y obtener ayuda.
Pinokio es una plataforma autónoma que te permite instalar aplicaciones de forma aislada.
Entorno aislado: no hay necesidad de preocuparse por estropear las configuraciones y entornos de su sistema global
Baterías incluidas: no es necesario instalar manualmente los programas necesarios solo para instalar algo (como ffpeg , node.js , visual studio , conda , python , pip , etc.). Pinokio se encarga de ello automáticamente.
Para lograr esto, Pinokio almacena todo en una única carpeta aislada ("pinokio home") , por lo que nunca tiene que depender de las configuraciones y programas de todo el sistema, sino que ejecuta todo de manera autónoma.
Puede configurar la carpeta de inicio de pinokio cuando configura Pinokio por primera vez, así como cambiarla luego a una nueva ubicación desde la pestaña de configuración .
Entonces, ¿dónde se almacenan los archivos? Haga clic en el botón "Archivos" de la página de inicio:
Esto abrirá la carpeta de inicio de Pinokio en su explorador de archivos:
Repasemos rápidamente lo que hace cada carpeta:
api : almacena todas las aplicaciones descargadas (scripts).
Las carpetas dentro de esta carpeta se muestran en la casa de su Pinokio.
bin : almacena módulos instalados globalmente compartidos por múltiples aplicaciones para que no sea necesario instalarlos de forma redundante.
Por ejemplo, ffmpeg , nodejs , python , etc.
cache : almacena todos los archivos almacenados automáticamente en caché por las aplicaciones que ejecuta.
Cuando algo no funciona, eliminar esta carpeta y comenzar de nuevo puede solucionarlo.
Está bien eliminar la carpeta cache , ya que las aplicaciones que usa la volverán a llenar cuando comience a usarlas.
drive : almacena todas las unidades virtuales creadas por la API fs.link Pinokio
logs : almacena todos los archivos de registro de cada aplicación.
Puede obtener más información sobre el sistema de archivos aquí.
Escribamos un script que clone un repositorio de git.
Cree una carpeta llamada helloworld en la carpeta api de Pinokio.
Cree un archivo llamado git.json en la carpeta Pinokio api/helloworld .
{ "ejecutar": [{"method": "shell.run","params": { "message": "git clone https://github.com/pinokiocomputer/test"}
}]
} Ahora, cuando regreses a Pinokio, verás aparecer tu repositorio helloworld . Navegue hasta él y haga clic en la pestaña git.json para ejecutarlo:
Verá que se ha clonado una carpeta api/helloworld/test del repositorio https://github.com/pinokiocomputer/test.
También podemos cambiar dinámicamente qué comandos ejecutar y cómo ejecutarlos mediante plantillas.
Como ejemplo, escribamos un script que ejecute dir en Windows y ls en Linux y Mac.
En su carpeta api/helloworld , cree un archivo llamado files.json :
{ "ejecutar": [{"método": "shell.run","params": { "message": "{{plataforma === 'win32' ? 'dir' : 'ls'}}"}
}]
} La expresión de plantilla {{ }} contiene una expresión JavaScript
Hay varias variables disponibles dentro de cada expresión de plantilla y una de ellas es la plataforma.
El valor de platform es darwin (mac), win32 (windows) o linux (linux).
Esto significa que, en Windows, el script anterior equivale a:
{ "ejecutar": [{"método": "shell.run","params": { "message": "dir"}
}]
}O si no es windows (mac o linux), equivale a:
{ "ejecutar": [{"método": "shell.run","params": { "message": "ls"}
}]
}Puedes obtener más información sobre las plantillas aquí.
Cuando un script de Pinokio termina de ejecutarse, cada sesión de shell que se generó a través del script se elimina y todos los procesos relacionados se cierran.
Por ejemplo, intentemos iniciar un servidor web local utilizando el servidor http. Cree una nueva carpeta llamada httpserver en la carpeta api de Pinokio y cree un nuevo script llamado index.json :
{ "ejecutar": [{"método": "shell.run","params": { "mensaje": "npx -y http-server"}
}]
} Luego regresa a Pinokio y verás que esta aplicación aparece en la página de inicio. Haga clic y haga clic en la pestaña index.json en la barra lateral, y se iniciará este script, que debería iniciar el servidor web usando npx http-server .
Pero el problema es que, justo después de iniciar el servidor, se cerrará inmediatamente y no podrás utilizar el servidor web.
Esto se debe a que Pinokio cierra automáticamente todos los procesos asociados con el script cuando termina de ejecutar todos los pasos en la matriz run .
Para evitar esto, debes decirle a Pinokio que esta aplicación debe permanecer activa incluso después de que se hayan ejecutado todos los pasos. Simplemente necesitamos agregar un atributo daemon :
{ "daemon": true, "run": [{"method": "shell.run","params": { "message": "npx -y http-server"}
}]
}Ahora vuelva a intentar iniciar el script y verá que el servidor web comienza a ejecutarse y no se apaga.
El servidor web servirá todos los archivos en la carpeta actual (en este caso solo index.json ), así:
Puede detener el script presionando el botón "detener" en la parte superior de la página.
Obtenga más información sobre el modo demonio aquí
También puede ejecutar varios comandos con una llamada shell.run .
Probemos un ejemplo. Vamos a instalar, inicializar y ejecutar un motor de documentación en un solo script.
Cosas como esta solían no ser accesibles para la gente normal (ya que tienes que ejecutarlas en la terminal), pero con Pinokio, es tan fácil como un clic.
Cree una carpeta llamada docsify en la carpeta api de Pinokio
Cree un archivo llamado index.json en la carpeta api/docsify . El archivo index.json debería tener el siguiente aspecto:
{ "daemon": true, "run": [{"method": "shell.run","params": { "message": ["npx -y docsify-cli init docs","npx -y docsify- cli servir documentos"]
}
}]
}Este ejemplo hace 2 cosas:
Inicializar un proyecto de documentación de docsify
Inicie el servidor de desarrollo de docsify
Cuando hace clic en el enlace del servidor de desarrollo desde la terminal Pinokio, se abrirá la página de documentación en un navegador web:
Obtenga más información sobre la API
shell.runaquí
Uno de los casos de uso comunes de Pinokio es:
Crear/activar un venv
Instalar dependencias en el venv activado
Probemos un ejemplo sencillo. Este ejemplo es una aplicación de gradio mínima del tutorial oficial de gradio.
Primero, cree una carpeta llamada gradio_demo en la carpeta api de Pinokio.
A continuación, cree un archivo llamado app.py en la carpeta api/gradio_demo .
# app.pyimport gradio as grdef greet(nombre, intensidad):return "Hola, " + nombre + "!" * int(intensidad)demo = gr.Interface(fn=saludar,entradas=["texto", "control deslizante"], salidas=["texto"], )demostración.lanzamiento()
También necesitamos un archivo de requirements.txt similar a este:
# requirements.txt gradio
Finalmente, necesitamos un script install.json que instalará las dependencias del archivo requirements.txt :
{ "ejecutar": [{"método": "shell.run","params": { "venv": "env", "message": "pip install -r requisitos.txt"}
}]
}La estructura de carpetas se verá así:
/PINOKIO_HOME /api /gradio_demo app.py requirements.txt install.json
Vuelve a Pinokio y verás la aplicación gradio_demo . Haga clic en la interfaz de usuario y haga clic en la pestaña install.json , y hará lo siguiente:
Cree una carpeta venv en la ruta env
Activar el entorno env
Ejecute pip install -r requirements.txt , que instalará la dependencia gradio en el entorno env .
Así es como se ve el proceso de instalación (tenga en cuenta que se ha creado una nueva carpeta env al final):
Obtenga más información sobre la API venv aquí
continúa desde la última sección.
Ahora escribamos un script simple que iniciará el servidor gradio desde app.py de la última sección. Cree un archivo llamado start.json en la misma carpeta:
{ "daemon": true, "run": [{"method": "shell.run","params": { "venv": "env", "message": "python app.py"}
}]
} Vuelva a Pinokio y verá que el archivo start.json ahora también aparece en la barra lateral. Haga clic para iniciar el script start.json . Esto:
active el entorno env que creamos desde el paso de instalación
ejecute python app.py en modo demonio ( daemon: true ), lo que iniciará el servidor gradio y lo mantendrá en funcionamiento.
Se verá así:
Obtenga más información sobre la API venv aquí
Pinokio tiene una API multiplataforma para descargar archivos de manera fácil y confiable (incluidos reintentos automáticos, etc.).
Intentemos escribir un script simple que descargue un PDF.
Primero cree una carpeta llamada download en la carpeta api de Pinokio y luego cree un archivo llamado index.json :
{ "ejecutar": [{"method": "fs.download","params": { "uri": "https://arxiv.org/pdf/1706.03762.pdf", "dir": "pdf"}
}]
} Esto descargará el archivo en https://arxiv.org/pdf/1706.03762.pdf a una carpeta llamada pdf (la API fs.download crea automáticamente una carpeta en la ubicación si aún no existe). Así es como se ve:
Obtenga más información sobre la API
fs.downloadaquí
En muchos casos, es posible que desee llamar a un script desde otro script. Algunos ejemplos:
Un guión de orquestación que pone en marcha stable diffusion y luego llama .
Un agente que inicia stable diffusion e inmediatamente realiza una solicitud para generar una imagen y finalmente detiene el servidor stable diffusion para ahorrar recursos, automáticamente.
Un agente que realiza una solicitud a un punto final llama y luego envía la respuesta a un punto final stable diffusion .
Podemos lograr esto usando las API script :
script.start : inicia un script remoto (descárgalo primero si aún no existe)
script.return : si el script actual era un proceso secundario, especifique el valor de retorno, que estará disponible en el siguiente paso del script de la persona que llama.
He aquí un ejemplo. Creemos un caller.json y callee.json simples:
caller.json :
{ "run": [{"method": "script.start","params": { "uri": "callee.json", "params": { "a": 1, "b": 2 }
}
}, {"método": "log","params": { "json2": "{{input}}"}
}]
} Primer paso, caller.json llamará a callee.json con los parámetros { "a": 1, "b": 2 } .
Este objeto de parámetros se pasará a callee.json como args :
callee.json :
{ "ejecutar": [{"method": "script.return","params": { "ressponse": "{{args.a + args.b}}"}
}]
} El script callee.json devuelve inmediatamente el valor {{args.a + args.b}} con la llamada script.return .
Finalmente, caller.json llamará al log del último paso, que imprimirá el valor {{input}} , que es el valor de retorno de callee.json . Esto imprimirá 3 :
La última sección explica cómo puede llamar a un script desde el mismo repositorio. Pero ¿qué pasa si quieres llamar a scripts de otros repositorios?
La API script.start también puede descargar y ejecutar scripts remotos sobre la marcha.
Cree una carpeta llamada remotescript en la carpeta api de Pinokio y cree un archivo llamado install.json en api/remotescript :
{ "ejecutar": [{"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}}", "ruta": "/answer_question_1", "params": [
{ "path": "https://media.timeout.com/images/105795964/750/422/image.jpg" },"Explica lo que está pasando aquí" ]
}
}, {"método": "log","params": { "json2": "{{input}}"}
}, {"method": "script.stop","params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/start.js"}
}]
}El primer paso inicia el script https://github.com/cocktailpeanutlabs/moondream2.git/install.js.
Si el repositorio moondream2.git ya existe en Pinokio, ejecutará el script install.js.
Si aún no existe, Pinokio clona automáticamente el repositorio https://github.com/cocktailpeanutlabs/moondream2.git primero y luego inicia el script install.js.
Una vez finalizada la instalación, inicia la aplicación gradio utilizando el script https://github.com/cocktailpeanutlabs/moondream2.git/start.js. Este script volverá después de que se haya iniciado el servidor.
Ahora ejecutamos gradio.predict , usando la API kernel.script.local() para obtener el objeto variable local para el script start.js y luego obteniendo su valor url (que se establece mediante programación dentro de moondream2.git/start.js guion).
Básicamente, este paso realiza una solicitud al punto final de gradio para preguntarle al LLM "Explica qué está pasando aquí", pasando una imagen.
A continuación, el valor de retorno de gradio.predict se registra en el terminal mediante la API log .
Finalmente, detenemos el script moondream2/start.js para cerrar el servidor moondream gradio usando la API script.stop .
Si no llamamos al script.stop , la aplicación moondream2 seguirá ejecutándose incluso después de que este script se detenga.
Así es como se vería:
La capacidad de ejecutar
script.starty luegoscript.stopes muy útil para ejecutar IA en computadoras personales, porque la mayoría de las computadoras personales no tienen memoria ilimitada y su computadora se quedará rápidamente sin memoria si no puede apagar estos motores de IA. programáticamente.Con
script.stoppuede iniciar un script, obtener su respuesta y cerrarlo inmediatamente una vez finalizada la tarea, lo que liberará la memoria del sistema, que puede usar para ejecutar otras tareas de IA posteriores.
Las aplicaciones de Pinokio tienen una estructura simple:
acceso directo: el acceso directo a la aplicación que aparece en la página de inicio de Pinokio.
aplicación: el diseño de interfaz de usuario principal de la aplicación
Shortcut
App
Menú: la barra lateral que muestra todos los enlaces que puedes ejecutar (así como su estado de ejecución)
Ventana: la ventana gráfica que muestra una página web o una terminal que ejecuta los scripts.
De forma predeterminada, si no tiene un archivo pinokio.js en su proyecto,
el acceso directo muestra el nombre de la carpeta como título y un ícono predeterminado como ícono de la aplicación.
el menú muestra todos los archivos .js o .json en la raíz de su repositorio.
Si bien esto es conveniente para comenzar, no es lo suficientemente flexible:
No puedes controlar lo que se muestra en la barra de menú.
No puedes controlar cómo se inician los scripts (pasando params , por ejemplo)
No puedes controlar cómo se muestra la aplicación.
El título de la aplicación será el nombre de su carpeta.
no hay descripción
El ícono solo mostrará un ícono predeterminado.
Para personalizar el comportamiento de su aplicación, deberá escribir un script de interfaz de usuario llamado pinokio.js .
Intentemos escribir una interfaz de usuario mínima:
Cree una carpeta llamada downloader en la carpeta /PINOKIO_HOME/api
Agregue cualquier ícono a la carpeta /PINOKIO_HOME/api/downloader y asígnele el nombre icon.png
Cree un archivo llamado /PINOKIO_HOME/api/downloader/download.json
Cree un archivo llamado /PINOKIO_HOME/api/downloader/pinokio.js
/PINOKIO_HOME/api/downloader/icon.png
/PINOKIO_HOME/api/downloader/download.json
{ "ejecutar": [{"método": "shell.run","params": { "message": "git clone {{input.url}}"}
}]
}/PINOKIO_HOME/api/downloader/pinokio.js
módulo.exportaciones = {
título: "Descargar cualquier cosa",
descripción: "Descargar un repositorio git",
icono: "icono.png",
menú: [{texto: "Inicio",href: "download.json",params: {url: "https://github.com/cocktailpeanut/dalai"}
}]}El resultado final se verá así en su explorador de archivos:
Ahora regrese a Pinokio y actualice, y verá aparecer su aplicación:
el título muestra Download Anything
la descripción muestra Download a git repository
el ícono es el icon.png que hemos agregado
Ahora, cuando hagas clic en la aplicación, verás lo siguiente:
Verá el elemento del menú Start .
Haga clic aquí para ejecutar download.json que se especifica mediante el atributo href .
También tenga en cuenta que el script pasa el valor de https://github.com/cocktailpeanut/dalai como valor de params.url .
Los params pasados a download.json están disponibles como variable input , por lo que se creará una instancia de git clone {{input.url}} como git clone https://github.com/cocktailpeanut/dalai .
Una vez que tenga un repositorio de scripts en funcionamiento, puede publicar en cualquier servicio de alojamiento git y compartir la URL, y cualquiera podrá instalar y ejecutar su script.
Puedes instalar cualquier repositorio de scripts de pinokio muy fácilmente:
Haga clic en el botón "Descargar desde URL" en la parte superior de la página Descubrir.
Ingrese la URL de git (opcionalmente, también puede especificar la rama).
Si publicó en github, puede etiquetar su repositorio con "pinokio" para que aparezca en la sección "más reciente" de la página Descubrir.
Ahora aparecerá automáticamente en la sección "más reciente" (en la parte inferior de la página "Descubrir"):
Pinokio construye la sección "Últimas" automáticamente desde la API "/repositories" de GitHub en https://api.github.com/search/repositories?q=topic:pinokio&sort=updated&direction=desc
Entonces, si etiquetó su repositorio como "pinokio" pero no aparece, verifique el resultado de la API e intente descubrir por qué no está incluido allí.
Si bien es importante comprender cómo funciona todo esto, en la mayoría de los casos es posible que desee un "combo de inicio" simple, que incluya:
Script de instalación de la aplicación: instala las dependencias de la aplicación
Script de inicio de la aplicación: inicia la aplicación
UI: muestra la UI del iniciador.
Restablecer script: restablece el estado de la aplicación cuando algo sale mal.
Script de actualización: actualiza la aplicación a la última versión con 1 clic.
Este caso de uso es necesario con tanta frecuencia que hemos implementado un programa que genera automáticamente estos scripts al instante. Se llama Gepeto.
A menudo, es posible que desees compartir más información sobre cada script. Puedes usar el suministro de noticias para eso.
Para hacer esto, simplemente cree un archivo pinokio_meta.json , con un atributo de matriz posts , donde cada elemento es una URL de x.com. He aquí un ejemplo:
{ "publicaciones": ["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"
]
}Puedes verlo en acción: https://github.com/cocktailpeanutlabs/comfyui/blob/main/pinokio_meta.json
Una vez que publique, esto se reflejará inmediatamente en la página de inicio del script.
Gepeto es un programa que te permite generar automáticamente scripts de Pinokio, específicamente para lanzadores de aplicaciones.
Comencemos generando una aplicación y su iniciador en 1 minuto.
Si aún no tienes instalado gepeto, búscalo en Pinokio e instálalo primero.
Verá una interfaz de usuario web sencilla que le permitirá completar un formulario. Para simplificar, simplemente ingrese Helloworld como nombre del proyecto y presione enviar .
Esto inicializará un proyecto. Cuando regreses a la casa de Pinokio,
Verá una nueva entrada llamada Helloworld . Haga clic en él y verá la pantalla de inicio.
Además, verifique su carpeta /PINOKIO_HOME/api , encontrará una nueva carpeta llamada Helloworld con algunos archivos de script.
Ahora hagamos clic en el botón Instalar para instalar la aplicación y, cuando termine, hagamos clic en Iniciar para iniciarla.
Verá una aplicación de gradio mínima, donde puede ingresar un mensaje y generará una imagen usando Stable Diffusion XL Turbo.
Entonces, ¿qué acaba de pasar? Acabamos de crear un proyecto vacío , que viene con una aplicación de demostración mínima.
Echemos un vistazo a cada archivo generado en la siguiente sección.
Gepeto genera automáticamente un conjunto mínimo de scripts necesarios para un iniciador de aplicaciones. Un iniciador de aplicaciones típico tiene las siguientes características:
Instalar: instale las dependencias necesarias para ejecutar la aplicación. ( install.js )
Iniciar: inicia la aplicación en sí. ( start.js )
Restablecer instalación: restablezca todas las dependencias instaladas en caso de que necesite realizar una reinstalación nueva. ( reset.js )
Actualización: actualice a la última versión cuando se actualice el proyecto. ( update.js )
GUI: el script que describe cómo se verá y se comportará el iniciador en la página de inicio de Pinokio y como menú de la barra lateral. ( pinokio.js )
Así es como se ve:
Tenga en cuenta que además de los scripts mencionados anteriormente, gepeto ha generado algunos archivos adicionales:
app.py : una aplicación de demostración sencilla. Reemplace esto con su propio código.
requirements.txt : declara todas las dependencias PIP requeridas para app.py Reemplázalo por el tuyo.
icon.png : un archivo de icono predeterminado para la aplicación. Reemplázalo por el tuyo.
torch.js : torch.js es un script de utilidad que se llama desde install.js . Dado que torch se utiliza en casi todos los proyectos de IA y es bastante complicado instalarlos de forma multiplataforma, este script se incluye de forma predeterminada. No tiene que preocuparse por este archivo, solo comprenda que lo usa install.js . No tocar.
Los archivos más importantes a considerar son los archivos app.py y requirements.txt :
importar gradio como antorcha grimport desde difusores importar DiffusionPipelineimportar dispositivotorch# Obtener el dispositivo actual ("mps", "cuda" o "cpu")device = devicetorch.get(torch)# Crear una tubería de difusiónpipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl -turbo").to(dispositivo)# Ejecutar inferencedef generate_image(mensaje):return pipe( mensaje, num_inference_steps=2, fuerza=0.5, orientación_escala=0.0).images[0]# Cree una interfaz de usuario de entrada de texto + salida de imagen con Gradioapp = gr.Interface(fn=generate_image, inputs="text", outputs="image")app .lanzamiento() Las siguientes son las bibliotecas necesarias para ejecutar app.py
transformers accelerate diffusers gradio devicetorch
Entonces, ¿cómo se utilizan realmente estos archivos?
Si miras dentro de install.js , verás que se está ejecutando pip install -r requirements.txt para instalar las dependencias dentro del archivo, así:
módulo.exportaciones = {
ejecutar: [// Elimina este paso si tu proyecto no usa torch{ método: "script.start", params: {uri: "torch.js",params: { venv: "env", // Edita esto para personalizarlo la ruta de la carpeta venv // xformers: true // descomente esta línea si su proyecto requiere xformers} }},// Edite este paso con sus comandos de instalación personalizados{ método: "shell.run", params: {venv: "env" , // Editar esto para personalizar la ruta de la carpeta venvmensaje: [ "pip install -r requisitos.txt"], }},// Descomente este paso para agregar la deduplicación automática de venv (Experimental)// {// método: "fs.link",// params: {// venv: "env"// }// },{ método: "notificar", params: {html: "¡Haga clic en la pestaña 'iniciar' para comenzar!" }}
]} El primer paso ejecuta script.start para llamar a un script llamado torch.js . Esto instala la antorcha.
El segundo paso ejecuta el archivo pip install -r requirements.txt para instalar todo lo que contiene ese archivo.
