text generator.io

Text-generator.io

Le générateur de texte est un système pour;

• Équilibrer plusieurs modèles sur le disque, la RAM et le GPU
• Servir les API AI via l'échange dans les réseaux d'IA.
• Utilisation d'un enrichissement des données (OCR, ramper, analyse d'image pour faciliter l'ingénierie rapide)
• Génération de la parole et du texte.
• Comprendre le texte et la parole (discours au texte avec chuchotement).

Le générateur de texte peut être utilisé via l'API ou l'auto-hébergé.

Le générateur de texte équilibre plusieurs modèles 7b pour générer du texte.

Le générateur de texte enrichit également les liens Web avec des résumés de texte.

Si une invite contient des liens vers des images, ils sont convertis en texte en utilisant le sous-titrage et si nécessaire OCR.

Veuillez nous soutenir!

Vous pouvez nous prendre en charge en achetant des jetons NETW qui seront une monnaie prise en charge dans l'application.

Enregistrez également AIART-Generator.art et NetWrck.com

À venir:

• Ajoutez une prise en charge d'autres modèles et modalités comme la diffusion stable (réalisée dans https://github.com/netwrck/stable-diffusion-server)
• Formez un classificateur pour d'abord détecter quel modèle est le meilleur à utiliser pour un texte donné.
• Ajoutez la prise en charge / les passthroughs à d'autres modèles comme Chatgpt et Palm.

API

Le générateur de texte est compatible API avec OpenAI (mais pas encore l'API ChatGpt)

Il y a aussi plus de contrôle de la génération de texte via l'API du générateur de texte, cela inclut;

• Arrêt précoce en fonction de la probabilité (assure automatique rapide les parties probables suivantes du texte)
• Max_Sentences (générer uniquement un nombre défini de phrases au maximum)

Le générateur de texte a également des itinéraires pour la génération de texto et de parole.

Voir https://text-generator.io/docs

Cloner

 cd
mkdir code
cd code
git clone 20-questions

Configuration de développement local

Env Vars:

GOOGLE_APPLICATION_CREDENTIALS= $HOME /code/20-questions/secrets/google-credentials.json ;
PYTHONPATH= $HOME /code/20-questions: $HOME /code/20-questions/OFA

Configuration de la machine sans docker

Installer les exigences

sudo apt install -y ffmpeg
sudo apt install -y tesseract-ocr
sudo apt install -y python3.9-distutils

pip install -r requirements.txt
pip install -r questions/inference_server/model-requirements.txt
pip install -r dev-requirements.txt

L'utilisation de CUDA est importante pour accélérer l'inférence.

python -m nltk.downloader punkt

Configurez certaines variables d'environnement dans ce fichier (les faux sont corrects pour le développement local)

mv sellerinfo_faked.py sellerinfo.py

Modèles

Téléchargez des modèles à partir de HuggingFace.

huggingface-cli download HuggingFaceTB/SmolLM-1.7B --local-dir models/SmolLM-1.7B

Les modèles de générateurs de texte ne sont pas encore open source.

Veuillez nous soutenir pour obtenir les modèles

Téléchargez les modèles et placez-les dans le dossier des modèles.

Il devrait y avoir trois modèles placés:

Modèles / TG Un modèle général accessible avec modèle = modèles multilinguaux / TGZ Un modèle d'instruct accessible avec modèle = modèle instruct / tgc un modèle de chat accessible avec modèle = chat

Model = Best est configuré pour déterminer le modèle à utiliser en fonction de l'invite notée en fonction de la perplexité de chaque modèle.

Cela a besoin de réglage pour la déviation AVG et MST de la perplexité car chaque modèle a des idées différentes sur la confidentialité. Les modèles surestimés sont plus confiants sur le fait que tout le texte soit dans l'ensemble de données (tend à générer du texte textuellement à partir de l'ensemble de données).

Les modèles peuvent être indiqués vers l'utilisation de variables d'environnement, par exemple en utilisant des modèles de Hugginface à la place pour les tests

 WEIGHTS_PATH_TGZ=bigscience/bloomz
WEIGHTS_PATH_TGC=decapoda-research/llama-7b-hf
WEIGHTS_PATH=bigscience/bloom

Autres modèles

Le modèle d'incorporation est un modèle plus petit.

 cd models
git clone https://huggingface.co/distilbert-base-uncased

Les modèles Whisper et STT seront chargés à la demande et placés dans le cache de câlins.

Courir

Exécutez l'interface utilisateur

uvicorn main:app --reload --workers=1
# or
uvicorn  -k uvicorn.workers.UvicornWorker -b :3004 main:app --timeout 60000 -w 1

Alternativement:

SERVER_SOFTWARE=Development/dev gunicorn -k uvicorn.workers.UvicornWorker -b :3004 main:app --timeout 60000 -w 1

Run Docker local

Bâtiment Docker

Le générateur de texte peut être exécuté localement sans docker.

installer nvidia-docker2

sudo apt-get install nvidia-docker2

Le générateur de texte est construit avec buildx

DOCKER_BUILDKIT=1 docker buildx build . -t questions

sudo docker run -v $( pwd ) /models:/models -p 9000:8080 questions

Exécution du serveur moteur d'applications

Le Frontend API Playground est disponible sur https://text-generator.io et écrit pour Google App Engine.

Courez localement:

 gunicorn -k uvicorn.workers.UvicornWorker -b :3030 main:app

Inférence du serveur exécuté

 PYTHONPATH=$(pwd):$PYTHONPATH:$(pwd)/OFA gunicorn -k uvicorn.workers.UvicornWorker -b :3030 questions.inference_server.inference_server:app

Inference Server Exécuter sans docker avec le serveur Web

PYTHONPATH= $( pwd ) : $( pwd ) /OFA GOOGLE_APPLICATION_CREDENTIALS=secrets/google-credentials.json gunicorn -k uvicorn.workers.UvicornWorker -b :9080 questions.inference_server.inference_server:app --timeout 180000 --workers 1
PYTHONPATH= $HOME /code/20-questions: $HOME /code/20-questions/OFA: $HOME /code/20-questions/OFA/fairseq GOOGLE_APPLICATION_CREDENTIALS=secrets/google-credentials.json gunicorn -k uvicorn.workers.UvicornWorker -b :9080 questions.inference_server.inference_server:app --timeout 180000 --workers 1

Ensuite, allez à LocalHost: 9080 / Docs pour utiliser l'API

Exécuter le serveur audio uniquement

Juste le discours Whisper à la partie textuelle. Cela n'est pas requis car le serveur d'Inference équilibre automatiquement ces demandes

PYTHONPATH= $( pwd ) : $( pwd ) /OFA GOOGLE_APPLICATION_CREDENTIALS=secrets/google-credentials.json gunicorn -k uvicorn.workers.UvicornWorker -b :9080 audio_server.audio_server:app --timeout 180000 --workers 1 

Essai

GOOGLE_APPLICATION_CREDENTIALS=secrets/google-credentials.json ; PYTHONPATH= $HOME /code/20-questions: $HOME /code/20-questions/OFA pytest

Docker

Télécharger le serveur auto-hébergé

Téléchargement de l'image Docker Direct

Docker Container. Télécharger

Script de téléchargement de conteneurs

 curl https://static.text-generator.io/static/resources/download_container.sh | bash

Après avoir téléchargé le conteneur avec l'une ou l'autre méthode, suivez les instructions de l'hôte auto disponible pour Kubernetes, Docker

Déploiement de Kubernetes

Voir https://text-generator.io/self-hosting

Assurez-vous un docker testé localement /

Vous pouvez configurer Kubernetes localement avec Kind si vous effectuez un développement local de Kubernetes.

k delete -f kuber/prod/deployment-gpu.yaml
k apply -f kuber/prod/deployment-gpu.yaml
k get pods

Débogage docker

Exécutez un shell dans un conteneur Docker

docker run -i -t -u root -v $( pwd ) /models:/models --entrypoint=/bin/bash questions -c /bin/bash ; 

nouveaux modèles

Clone de HuggingFace

 cd models
git clone https://huggingface.co/distilbert-base-uncased

maintenance

Exécuter un bot de discorde

PYTHONPATH= $( pwd ) : $( pwd ) /OFA python questions/disbot/disbot.py

compiler les dépendances

Utilisez UV PIP pour compiler les dépendances

uv pip compile questions/inference_server/model-requirements.in    --universal -o questions/inference_server/model-requirements.txt

uv pip sync questions/inference_server/model-requirements.txt

N'oubliez pas de s'étirer!

Étirez votre corps toutes les 30 minutes avec la commande Say ...

watch -n 1800 ' echo "stretch your body" | espeak -s 120 '