Pinokio est un navigateur qui vous permet d'installer, d'exécuter et d'automatiser localement n'importe quelle IA sur votre ordinateur . Tout ce que vous pouvez exécuter dans votre ligne de commande peut être automatisé avec le script Pinokio , avec une interface utilisateur conviviale.
Vous pouvez utiliser Pinokio pour tout automatiser, notamment :
Installer des applications et des modèles d'IA
Gérer et exécuter des applications IA
Créez des workflows pour orchestrer les applications d'IA installées
Exécutez n’importe quelle commande pour automatiser les choses sur votre machine
et plus encore...
Voici ce qui rend Pinokio spécial :
Local : tout est installé et fonctionne localement. Aucune de vos données n'est stockée sur le serveur de quelqu'un d'autre.
Gratuit : Pinokio est une application open source dont l'utilisation est 100 % gratuite et sans restriction. Personne ne paie pour l'accès à l'API, puisque tout fonctionne sur votre machine locale. Jouez avec l'IA autant que vous le souhaitez, gratuitement et pour toujours.
Privé : vous n'avez pas à vous soucier de soumettre des données privées uniquement pour exécuter l'IA, tout fonctionne à 100 % en privé sur votre propre machine.
Interface conviviale : Pinokio fournit une interface graphique conviviale pour exécuter et automatiser tout ce pour quoi vous auriez normalement besoin d'utiliser le terminal.
Piles incluses : Pinokio est un système autonome. Vous n'avez pas besoin d'installer un autre programme. Pinokio peut tout automatiser, y compris les installations de programmes/bibliothèques. Le seul programme dont vous avez besoin est Pinokio.
Multiplateforme : Pinokio fonctionne sur TOUS les systèmes d'exploitation (Windows, Mac, Linux) .
Économisez du stockage et des ressources : Pinokio dispose de nombreuses fonctionnalités d'optimisation qui vous permettront d'économiser des centaines de gigaoctets d'espace disque. En outre, de nombreuses autres fonctionnalités d'optimisation des ressources (telles que la mémoire) sont toutes possibles avec Pinokio.
Langage de script expressif : le script Pinokio est un puissant langage de script d'automatisation doté de fonctionnalités telles que la mémoire, les modèles dynamiques et les API extensibles de bas niveau.
Portable : tout est stocké dans un dossier isolé et tout existe sous forme de fichier, ce qui signifie que vous pouvez facilement tout sauvegarder ou supprimer des applications simplement en supprimant des fichiers.
Pinokio s'inspire du fonctionnement des ordinateurs traditionnels.
Tout comme un ordinateur peut faire toutes sortes de choses grâce à son architecture complète, Pinokio, en tant qu'ordinateur virtuel, est une plate-forme complète pour exécuter et automatiser tout ce que vous pouvez imaginer avec l'IA.
Système de fichiers : où et comment Pinokio stocke les fichiers.
Processeur : comment pinokio exécute les tâches.
Mémoire : comment pinokio implémente une machine à états en utilisant sa mémoire native intégrée.
Script : Le langage de programmation qui fait fonctionner Pinokio.
UI : l'interface utilisateur (interface utilisateur) via laquelle les utilisateurs accèdent aux applications.
Fenêtres
Mac
Linux
Assurez-vous de suivre TOUTES les étapes ci-dessous !
Télécharger pour Windows
Décompressez le fichier téléchargé et vous verrez un fichier d’installation .exe.
Exécutez le fichier d’installation et l’avertissement Windows suivant s’affichera :
Ce message apparaît car l'application a été téléchargée à partir du Web, et c'est ce que Windows fait pour les applications téléchargées à partir du Web.
Pour contourner cela,
Cliquez sur "Plus d'informations"
Cliquez ensuite sur "Exécuter quand même"
Assurez-vous de suivre à la fois l'étape 1 ET l'étape 2.
Télécharger pour Apple Silicon Mac (M1/M2/M3/M4) Télécharger pour Intel Mac
Après avoir téléchargé les fichiers dmg, vous DEVEZ créer un patch , comme indiqué ci-dessous :
Exécutez le fichier d'installation DMG téléchargé
Faites glisser l'application "Pinokio" vers le dossier Applications
Exécutez le "patch.command"
Ouvrez l'application Pinokio dans le dossier applications
Pour Linux, vous pouvez télécharger et installer directement à partir de la dernière version sur Github (faites défiler vers le bas de la page pour tous les binaires) :
Accédez à la page des versions
Pour rester au courant de toutes les nouvelles API et intégrations d'applications,
Suivez @cocktailpeanut sur X pour rester informé de tous les nouveaux scripts publiés et des mises à jour de fonctionnalités.
Rejoignez le discord Pinokio pour poser des questions et obtenir de l'aide.
Pinokio est une plateforme autonome qui vous permet d'installer des applications de manière isolée.
Environnement isolé : pas besoin de vous soucier de gâcher vos configurations et environnements système globaux
Piles incluses : pas besoin d'installer manuellement les programmes requis juste pour installer quelque chose (comme ffpeg , node.js , visual studio , conda , python , pip , etc.). Pinokio s'en charge automatiquement.
Pour y parvenir, Pinokio stocke tout dans un seul dossier isolé (« pinokio home ») , de sorte qu'il n'a jamais besoin de s'appuyer sur vos configurations et programmes à l'échelle du système, mais exécute tout de manière autonome.
Vous pouvez définir le dossier personnel de Pinokio lors de la première configuration de Pinokio, puis le modifier ultérieurement vers un nouvel emplacement à partir de l'onglet Paramètres .
Alors, où sont stockés les fichiers ? Cliquez sur le bouton "Fichiers" depuis la page d'accueil :
Cela ouvrira le dossier personnel de Pinokio dans votre explorateur de fichiers :
Passons rapidement en revue ce que fait chaque dossier :
api : stocke toutes les applications téléchargées (scripts).
Les dossiers à l'intérieur de ce dossier sont affichés sur la maison de votre Pinokio.
bin : stocke les modules installés globalement et partagés par plusieurs applications afin que vous n'ayez pas besoin de les installer de manière redondante.
Par exemple, ffmpeg , nodejs , python , etc.
cache : stocke tous les fichiers automatiquement mis en cache par les applications que vous exécutez.
Lorsque quelque chose ne fonctionne pas, supprimer ce dossier et recommencer à zéro peut le résoudre.
Vous pouvez supprimer le dossier cache car il sera à nouveau rempli par les applications que vous utilisez lorsque vous commencerez à utiliser des applications.
drive : stocke tous les lecteurs virtuels créés par l'API fs.link Pinokio
logs : stocke tous les fichiers journaux de chaque application.
Vous pouvez en savoir plus sur le système de fichiers ici
Écrivons un script qui clone un référentiel git.
Créez un dossier nommé helloworld sous le dossier API Pinokio.
Créez un fichier nommé git.json dans le dossier Pinokio api/helloworld .
{ "run": [{"method": "shell.run","params": { "message": "git clone https://github.com/pinokiocomputer/test"}
}]
} Maintenant, lorsque vous reviendrez sur Pinokio, vous verrez votre référentiel helloworld apparaître. Accédez-y et cliquez sur l'onglet git.json pour l'exécuter :
Vous verrez qu'un dossier api/helloworld/test a été cloné à partir du référentiel https://github.com/pinokiocomputer/test.
Nous pouvons également modifier dynamiquement les commandes à exécuter et comment les exécuter, à l’aide de modèles.
À titre d'exemple, écrivons un script qui exécute dir sous Windows et ls sous Linux et Mac.
Dans votre dossier api/helloworld , créez un fichier nommé files.json :
{ "run": [{"method": "shell.run","params": { "message": "{{platform === 'win32' ? 'dir' : 'ls'}}"}
}]
} L'expression du modèle {{ }} contient une expression JavaScript
Plusieurs variables sont disponibles dans chaque expression de modèle, et l'une d'elles est la plate-forme.
La valeur de platform est soit darwin (mac), win32 (windows) ou linux (linux).
Cela signifie que sous Windows, le script ci-dessus équivaut à :
{ "run": [{"method": "shell.run","params": { "message": "dir"}
}]
}Ou si ce n'est pas windows (mac ou linux), c'est équivalent à :
{ "run": [{"method": "shell.run","params": { "message": "ls"}
}]
}Vous pouvez en savoir plus sur les modèles ici
Lorsqu'un script Pinokio termine son exécution, chaque session shell générée via le script est supprimée et tous les processus associés sont arrêtés.
Par exemple, essayons de lancer un serveur Web local à l'aide du serveur http. Créez un nouveau dossier nommé httpserver sous le dossier Pinokio api et créez un nouveau script nommé index.json :
{ "run": [{"method": "shell.run","params": { "message": "npx -y serveur http"}
}]
} Revenez ensuite sur Pinokio et vous verrez cette application apparaître sur la page d'accueil. Cliquez et cliquez sur l'onglet index.json dans la barre latérale, et il lancera ce script, qui devrait lancer le serveur Web à l'aide de npx http-server .
Mais le problème est que juste après le lancement du serveur, il s'arrêtera immédiatement et vous ne pourrez plus utiliser le serveur Web.
En effet, Pinokio arrête automatiquement tous les processus associés au script lorsqu'il a fini d'exécuter toutes les étapes du tableau run .
Pour éviter cela, vous devez indiquer à Pinokio que cette application doit rester active même une fois toutes les étapes terminées. Il suffit d'ajouter un attribut daemon :
{ "daemon": true, "run": [{"method": "shell.run","params": { "message": "npx -y http-server"}
}]
}Réessayez maintenant de démarrer le script et vous verrez que le serveur Web démarre et ne s'arrête pas.
Le serveur Web servira tous les fichiers du dossier actuel (dans ce cas uniquement index.json ), comme ceci :
Vous pouvez arrêter le script en appuyant sur le bouton "stop" en haut de la page.
En savoir plus sur le mode démon ici
Vous pouvez également exécuter plusieurs commandes avec un seul appel shell.run .
Essayons un exemple. Nous allons installer, initialiser et lancer un moteur de documentation dans un seul script.
Des choses comme celle-ci n'étaient pas accessibles aux gens normaux (puisque vous devez exécuter ces choses dans le terminal), mais avec Pinokio, c'est aussi simple qu'un clic.
Créez un dossier nommé docsify sous le dossier api Pinokio
Créez un fichier nommé index.json sous le dossier api/docsify . Le fichier index.json devrait ressembler à ceci :
{ "daemon": true, "run": [{"method": "shell.run","params": { "message": ["npx -y docsify-cli init docs","npx -y docsify- cli serve les documents" ]
}
}]
}Cet exemple fait 2 choses :
Initialiser un projet de documentation docsify
Lancez le serveur de développement docsify
Lorsque vous cliquez sur le lien du serveur de développement depuis le terminal Pinokio, la page de documentation s'ouvrira dans un navigateur Web :
En savoir plus sur l'API
shell.runici
L'un des cas d'utilisation courants de Pinokio est de :
Créer/activer un venv
Installer les dépendances dans le venv activé
Essayons un exemple simple. Cet exemple est une application gradio minimale du tutoriel officiel de gradio
Tout d'abord, créez un dossier nommé gradio_demo sous le dossier api de Pinokio.
Ensuite, créez un fichier nommé app.py dans le dossier api/gradio_demo .
# app.pyimport gradio as grdef greet(nom, intensité) :return "Bonjour, " + nom + " !" * int(intensité)demo = gr.Interface(fn=greet,inputs=["text", "slider"],outputs=["text"], )démo.lancement()
Nous avons également besoin d'un fichier requirements.txt qui ressemble à ceci :
# requirements.txt gradio
Enfin, nous avons besoin d'un script install.json qui installera les dépendances à partir du fichier requirements.txt :
{ "run": [{"method": "shell.run","params": { "venv": "env", "message": "pip install -r conditions.txt"}
}]
}La structure des dossiers ressemblera à ceci :
/PINOKIO_HOME /api /gradio_demo app.py requirements.txt install.json
Retournez sur Pinokio et vous verrez l'application gradio_demo . Cliquez sur l'interface utilisateur et cliquez sur l'onglet install.json , et cela :
Créez un dossier venv sur le chemin env
Activer l'environnement env
Exécutez pip install -r requirements.txt , qui installera la dépendance gradio dans l'environnement env .
Voici à quoi ressemble le processus d'installation (notez qu'un nouveau dossier env a été créé à la fin) :
En savoir plus sur l'API venv ici
suite de la dernière section.
Écrivons maintenant un script simple qui lancera le serveur gradio à partir du app.py de la dernière section. Créez un fichier nommé start.json dans le même dossier :
{ "daemon": true, "run": [{"method": "shell.run","params": { "venv": "env", "message": "python app.py"}
}]
} Revenez à Pinokio et vous verrez que le fichier start.json apparaît désormais également dans la barre latérale. Cliquez pour démarrer le script start.json . Cela va :
activer l'environnement env que nous avons créé à partir de l'étape d'installation
exécutez python app.py en mode démon ( daemon: true ), ce qui lancera le serveur gradio et le fera fonctionner.
Cela ressemblera à ceci :
En savoir plus sur l'API venv ici
Pinokio dispose d'une API multiplateforme pour télécharger des fichiers de manière simple et fiable (y compris les tentatives automatiques, etc.).
Essayons d'écrire un script simple qui télécharge un PDF.
Créez d'abord un dossier nommé download sous le dossier Pinokio api , puis créez un fichier nommé index.json :
{ "run": [{"method": "fs.download","params": { "uri": "https://arxiv.org/pdf/1706.03762.pdf", "dir": "pdf"}
}]
} Cela téléchargera le fichier sur https://arxiv.org/pdf/1706.03762.pdf dans un dossier nommé pdf (l'API fs.download crée automatiquement un dossier à l'emplacement s'il n'existe pas déjà). Voici à quoi cela ressemble :
En savoir plus sur l'API
fs.downloadici
Dans de nombreux cas, vous souhaiterez peut-être appeler un script à partir d'un autre script. Quelques exemples :
Un script d'orchestration qui lance stable diffusion , puis llama .
Un agent qui démarre stable diffusion , fait immédiatement une demande de génération d'image, et arrête finalement le serveur stable diffusion pour économiser les ressources, automatiquement.
Agent qui envoie une requête à un point de terminaison llama , puis transmet la réponse à un point de terminaison stable diffusion .
Nous pouvons y parvenir en utilisant les API script :
script.start : Démarrer un script distant (Télécharger d'abord s'il n'existe pas encore)
script.return : Si le script actuel était un processus enfant, spécifiez la valeur de retour, qui sera rendue disponible à l'étape suivante du script appelant.
Voici un exemple. Créons un simple caller.json et callee.json :
caller.json :
{ "run": [{"method": "script.start","params": { "uri": "callee.json", "params": { "a": 1, "b": 2 }
}
}, {"method": "log","params": { "json2": "{{input}}"}
}]
} Première étape, l' caller.json appellera callee.json avec les paramètres { "a": 1, "b": 2 } .
Cet objet params sera transmis au callee.json sous la forme args :
callee.json :
{ "run": [{"method": "script.return","params": { "ressponse": "{{args.a + args.b}}"}
}]
} Le script callee.json renvoie immédiatement la valeur {{args.a + args.b}} avec l'appel script.return .
Enfin, caller.json appellera le log de la dernière étape, qui imprimera la valeur {{input}} , qui est la valeur de retour de callee.json . Cela imprimera 3 :
La dernière section explique comment appeler un script depuis le même référentiel. Mais que se passe-t-il si vous souhaitez appeler des scripts depuis d’autres référentiels ?
L'API script.start peut également télécharger et exécuter des scripts distants à la volée.
Créez un dossier nommé remotescript sous le dossier api Pinokio et créez un fichier nommé install.json sous 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}}", "chemin": "/answer_question_1", "params": [
{ "path": "https://media.timeout.com/images/105795964/750/422/image.jpg" }, "Expliquez ce qui se passe ici" ]
}
}, {"method": "log","params": { "json2": "{{input}}"}
}, {"method": "script.stop","params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/start.js"}
}]
}La première étape démarre le script https://github.com/cocktailpeanutlabs/moondream2.git/install.js.
Si le référentiel moondream2.git existe déjà sur Pinokio, il exécutera le script install.js.
S'il n'existe pas déjà, Pinokio clone automatiquement le référentiel https://github.com/cocktailpeanutlabs/moondream2.git d'abord, puis démarre ensuite le script install.js.
Une fois l'installation terminée, il lance ensuite l'application gradio à l'aide du script https://github.com/cocktailpeanutlabs/moondream2.git/start.js. Ce script reviendra après le démarrage du serveur.
Maintenant, nous exécutons gradio.predict , en utilisant l'API kernel.script.local() pour obtenir l'objet variable locale pour le script start.js, puis en obtenant sa valeur url (qui est définie par programme dans le moondream2.git/start.js scénario).
Fondamentalement, cette étape demande au point final gradio de demander au LLM "Expliquez ce qui se passe ici", en passant une image.
Ensuite, la valeur de retour de gradio.predict est enregistrée sur le terminal à l'aide de l'API log .
Enfin, nous arrêtons le script moondream2/start.js pour arrêter le serveur moondream gradio à l'aide de l'API script.stop .
Si nous n'appelons pas script.stop , l'application moondream2 continuera à fonctionner même après l'arrêt de ce script.
Voici à quoi cela ressemblerait :
La possibilité d'exécuter
script.start, puisscript.stopest très utile pour exécuter l'IA sur des ordinateurs personnels, car la plupart des ordinateurs personnels n'ont pas de mémoire illimitée et votre ordinateur manquera rapidement de mémoire si vous ne pouvez pas arrêter ces moteurs d'IA. par programmation.Avec
script.stopvous pouvez démarrer un script, obtenir sa réponse et l'arrêter immédiatement une fois la tâche terminée, ce qui libérera la mémoire système, que vous pourrez utiliser pour exécuter d'autres tâches d'IA ultérieures.
Les applications Pinokio ont une structure simple :
raccourci : le raccourci de l'application qui apparaît sur la page d'accueil de Pinokio.
app : la présentation principale de l'interface utilisateur de l'application
Shortcut
App
Menu : La barre latérale qui affiche tous les liens que vous pouvez exécuter (ainsi que leur état d'exécution)
Fenêtre : la fenêtre qui affiche une page Web ou un terminal qui exécute les scripts
Par défaut si vous n'avez pas de fichier pinokio.js dans votre projet,
le raccourci affiche le nom du dossier comme titre et une icône par défaut comme icône de l'application.
le menu affiche tous les fichiers .js ou .json à la racine de votre référentiel.
Bien que cela soit pratique pour débuter, ce n'est pas assez flexible :
Vous ne pouvez pas contrôler ce qui est affiché dans la barre de menu
Vous ne pouvez pas contrôler la façon dont les scripts sont lancés (en passant params par exemple)
Vous ne pouvez pas contrôler la façon dont l'application est affichée
Le titre de l'application sera le nom de votre dossier
Il n'y a pas de description
L'icône affichera simplement une icône par défaut.
Pour personnaliser le comportement de votre application elle-même, vous souhaiterez écrire un script d'interface utilisateur nommé pinokio.js .
Essayons d'écrire une interface utilisateur minimale :
Créez un dossier nommé downloader dans le dossier /PINOKIO_HOME/api
Ajoutez n'importe quelle icône au dossier /PINOKIO_HOME/api/downloader et nommez-la icon.png
Créez un fichier nommé /PINOKIO_HOME/api/downloader/download.json
Créez un fichier nommé /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
module.exports = {
titre : "Télécharger n'importe quoi",
description: "Télécharger un dépôt git",
icône : "icône.png",
menu : [{texte : "Démarrer",href : "download.json",params : { url : "https://github.com/cocktailpeanut/dalai"}
}]}Le résultat final ressemblera à ceci dans votre explorateur de fichiers :
Revenez maintenant à Pinokio et actualisez, et vous verrez votre application apparaître :
le titre s'affiche Download Anything
la description s'affiche Download a git repository
l'icône est l' icon.png que nous avons ajouté
Désormais, lorsque vous cliquez sur l'application, vous verrez ce qui suit :
Vous verrez l'élément de menu Start .
Cliquez ici pour exécuter le download.json spécifié par l'attribut href .
Notez également que le script transmet la valeur de https://github.com/cocktailpeanut/dalai comme valeur params.url .
Les params transmis au download.json sont rendus disponibles en tant que variable input , donc le git clone {{input.url}} sera instancié en tant que git clone https://github.com/cocktailpeanut/dalai .
Une fois que vous disposez d'un référentiel de scripts fonctionnel, vous pouvez publier sur n'importe quel service d'hébergement git et partager l'URL, et tout le monde pourra installer et exécuter votre script.
Vous pouvez installer n'importe quel référentiel de scripts pinokio très facilement :
Cliquez sur le bouton « Télécharger depuis l'URL » en haut de la page Découvrir.
Entrez l'URL git (vous pouvez également spécifier la branche).
Si vous avez publié sur github, vous pouvez marquer votre référentiel avec "pinokio" pour le faire apparaître dans la section "dernière" de la page Découvrir.
Désormais, il apparaîtra automatiquement dans la section « dernière » (en bas de la page « Découvrir ») :
Pinokio construit automatiquement la section "Latest" à partir de l'API GitHub "/repositories" sur https://api.github.com/search/repositories?q=topic:pinokio&sort=updated&direction=desc
Donc, si vous avez marqué votre référentiel comme "pinokio" mais qu'il n'apparaît pas, vérifiez le résultat de l'API et essayez de comprendre pourquoi il n'y est pas inclus.
Bien qu'il soit important de comprendre comment tout cela fonctionne, dans la plupart des cas, vous souhaiterez peut-être un simple « combo de lancement », qui comprend :
Script d'installation de l'application : installe les dépendances de l'application
Script de lancement d'application : démarre l'application
UI : affiche l'interface utilisateur du lanceur.
Script de réinitialisation : réinitialise l'état de l'application en cas de problème.
Script de mise à jour : met à jour l'application vers la dernière version en 1 clic.
Ce cas d'utilisation est si souvent nécessaire que nous avons implémenté un programme qui génère automatiquement et instantanément ces scripts. Ça s'appelle Gepeto.
Souvent, vous souhaiterez peut-être partager plus d'informations sur chaque script. Vous pouvez utiliser le fil d'actualité pour cela.
Pour ce faire, créez simplement un fichier pinokio_meta.json , avec un attribut de tableau posts , où chaque élément est une URL x.com. Voici un exemple :
{ "messages": ["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"
]
}Vous pouvez le voir en action : https://github.com/cocktailpeanutlabs/comfyui/blob/main/pinokio_meta.json
Une fois que vous publiez, cela sera immédiatement reflété sur la page de destination du script.
Gepeto est un programme qui vous permet de générer automatiquement des scripts Pinokio, spécifiquement pour les lanceurs d'applications.
Commençons par générer une application et son lanceur en 1 minute.
Si gepeto n'est pas déjà installé, trouvez-le sur Pinokio et installez-le d'abord.
Vous verrez une interface utilisateur Web simple qui vous permet de remplir un formulaire. Pour plus de simplicité, entrez simplement Helloworld comme nom du projet et appuyez sur Soumettre .
Cela initialisera un projet. Quand tu rentreras chez Pinokio,
Vous verrez une nouvelle entrée nommée Helloworld . Cliquez dessus et vous verrez l'écran de lancement.
Vérifiez également votre dossier /PINOKIO_HOME/api , vous trouverez un nouveau dossier nommé Helloworld avec quelques fichiers de script.
Cliquons maintenant sur le bouton d'installation pour installer l'application, et une fois l'opération terminée, cliquez sur Démarrer pour la lancer.
Vous verrez une application gradio minimale, dans laquelle vous pourrez saisir une invite et générera une image à l'aide de Stable Diffusion XL Turbo.
Alors que vient-il de se passer ? Nous venons de créer un projet vide , livré avec une application de démonstration minimale.
Jetons un coup d'œil à chaque fichier généré dans la section suivante.
Gepeto génère automatiquement un ensemble minimal de scripts requis pour un lanceur d'applications. Un lanceur d'applications typique présente les fonctionnalités suivantes :
Installer : installez les dépendances requises pour exécuter l'application. ( install.js )
Lancer : lancez l’application elle-même. ( start.js )
Réinitialiser l'installation : réinitialisez toutes les dépendances installées au cas où vous auriez besoin de réinstaller une nouvelle installation. ( reset.js )
Mise à jour : mettez à jour vers la dernière version lorsque le projet est mis à jour. ( update.js )
GUI : le script qui décrit à quoi ressemblera le lanceur et se comportera sur la page d'accueil de Pinokio et sous forme de menu de barre latérale. ( pinokio.js )
Voici à quoi cela ressemble :
Notez qu'en plus des scripts mentionnés ci-dessus, gepeto a généré quelques fichiers supplémentaires :
app.py : Une application de démonstration simple. Remplacez-le par votre propre code.
requirements.txt : déclare toutes les dépendances PIP requises pour app.py . Remplacez par le vôtre.
icon.png : Un fichier d'icône par défaut pour l'application. Remplacez par le vôtre.
torch.js : torch.js est un script utilitaire qui est appelé depuis install.js . Étant donné que torch est utilisé dans presque tous les projets d’IA et qu’il est assez difficile de les installer de manière multiplateforme, ce script est inclus par défaut. Vous n'avez pas à vous soucier de ce fichier, comprenez simplement qu'il est utilisé par install.js . Ne pas toucher.
Les fichiers notables à examiner sont les fichiers app.py et requirements.txt :
importer gradio en tant que torche grimportà partir des diffuseurs importer DiffusionPipelineimport devicetorch# Récupérer le périphérique actuel ("mps", "cuda" ou "cpu")device = devicetorch.get(torch)# Créer un pipeline de diffusionpipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl -turbo").to(device)# Exécutez inferencedef generate_image(prompt):return pipe(invite, num_inference_steps=2, Strength=0.5, guidance_scale=0.0).images[0]# Créez une interface utilisateur de saisie de texte + de sortie d'image avec Gradioapp = gr.Interface(fn=generate_image, inputs="text", outputs="image")app .lancement() Vous trouverez ci-dessous les bibliothèques requises pour exécuter app.py .
transformers accelerate diffusers gradio devicetorch
Alors, comment ces fichiers sont-ils réellement utilisés ?
Si vous regardez à l'intérieur install.js , vous verrez qu'il exécute pip install -r requirements.txt pour installer les dépendances à l'intérieur du fichier, comme ceci :
module.exports = {
run : [// Supprimez cette étape si votre projet n'utilise pas la méthode torch{ : "script.start", params : {uri : "torch.js", params : { venv : "env", // Modifiez ceci pour personnaliser le chemin du dossier venv // xformers : true // décommentez cette ligne si votre projet nécessite xformers} }},// Modifiez cette étape avec vos commandes d'installation personnalisées { méthode : "shell.run", params : {venv : "env" , // Modifiez ceci pour personnaliser le message de chemin du dossier venv : [ "pip install -r conditions.txt"], }},// Décommentez cette étape pour ajouter la déduplication automatique venv (expérimentale)// {// méthode : "fs.link", // params : {// venv : "env"// }// },{ method : "notify", params : {html : "Cliquez sur l'onglet 'démarrer' pour commencer !" }}
]} La première étape exécute script.start pour appeler un script nommé torch.js . Cela installe la torche.
La deuxième étape exécute le fichier pip install -r requirements.txt pour installer tout ce qu'il contient.
