Page d'accueil>Lié à la programmation>Code Source AI
Télécharger

lama_ros

Ce référentiel fournit un ensemble de packages ROS 2 pour intégrer llama.cpp dans ROS 2. À l'aide des packages llama_ros, vous pouvez facilement intégrer les puissantes capacités d'optimisation de llama.cpp dans vos projets ROS 2 en exécutant des LLM et VLM basés sur GGUF. Vous pouvez également utiliser les fonctionnalités de llama.cpp telles que les grammaires GBNF et modifier les LoRA en temps réel.

Table des matières

  1. Projets connexes
  2. Installation
  3. Docker
  4. Usage
    • lama_cli
    • Lancer des fichiers
    • Adaptateurs LoRA
    • Clients ROS2
    • LangChaîne
  5. Démos

Projets connexes

  • chatbot_ros → Ce chatbot, intégré à ROS 2, utilise murmur_ros, pour écouter la parole des gens ; et llama_ros, pour générer des réponses. Le chatbot est contrôlé par une machine à états créée avec YASMIN.
  • explicable_ros → Un outil ROS 2 pour expliquer le comportement d'un robot. Grâce à l'intégration de LangChain, les journaux sont stockés dans une base de données vectorielle. Ensuite, RAG est appliqué pour récupérer les journaux pertinents pour les questions des utilisateurs répondues avec llama_ros.

Installation

Pour exécuter llama_ros avec CUDA, vous devez d’abord installer le CUDA Toolkit. Ensuite, vous pouvez compiler llama_ros avec --cmake-args -DGGML_CUDA=ON pour activer la prise en charge de CUDA. 

 cd ~ /ros2_ws/src
git clone https://github.com/mgonzs13/llama_ros.git
pip3 install -r llama_ros/requirements.txt
cd ~ /ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build --cmake-args -DGGML_CUDA=ON # add this for CUDA

Docker

Créez le docker llama_ros ou téléchargez une image depuis DockerHub. Vous pouvez choisir de construire llama_ros avec CUDA ( USE_CUDA ) et choisir la version CUDA ( CUDA_VERSION ). N'oubliez pas que vous devez utiliser DOCKER_BUILDKIT=0 pour compiler llama_ros avec CUDA lors de la création de l'image. 

DOCKER_BUILDKIT=0 docker build -t llama_ros --build-arg USE_CUDA=1 --build-arg CUDA_VERSION=12-6 .

Exécutez le conteneur Docker. Si vous souhaitez utiliser CUDA, vous devez installer le NVIDIA Container Tollkit et ajouter --gpus all . 

docker run -it --rm --gpus all llama_ros

Usage

lama_cli

Des commandes sont incluses dans llama_ros pour accélérer le test des LLM basés sur GGUF au sein de l'écosystème ROS 2. De cette façon, les commandes suivantes s'intègrent aux commandes ROS 2 :

lancement

À l'aide de cette commande, lancez un LLM à partir d'un fichier YAML. La configuration du YAML est utilisée pour lancer le LLM de la même manière que l'utilisation d'un fichier de lancement classique. Voici un exemple de comment l'utiliser : 

ros2 llama launch ~ /ros2_ws/src/llama_ros/llama_bringup/models/StableLM-Zephyr.yaml

rapide

À l’aide de cette commande, envoyez une invite à un LLM lancé. La commande utilise une chaîne, qui constitue l'invite et comporte les arguments suivants :

  • ( -r , --reset ) : s'il faut réinitialiser le LLM avant de demander
  • ( -t , --temp ) : La valeur de la température
  • ( --image-url ) : URL de l'image à envoyer à un VLM

Voici un exemple de comment l'utiliser : 

ros2 llama prompt " Do you know ROS 2? " -t 0.0

Lancer des fichiers

Tout d'abord, vous devez créer un fichier de lancement pour utiliser llama_ros ou llava_ros. Ce fichier de lancement contiendra les principaux paramètres pour télécharger le modèle depuis HuggingFace et le configurer. Jetez un œil aux exemples suivants et aux fichiers de lancement prédéfinis.

llama_ros (lancement Python)

Cliquez pour agrandir 
 from launch import LaunchDescription
from llama_bringup . utils import create_llama_launch


def generate_launch_description ():

    return LaunchDescription ([
        create_llama_launch (
            n_ctx = 2048 , # context of the LLM in tokens
            n_batch = 8 , # batch size in tokens
            n_gpu_layers = 0 , # layers to load in GPU
            n_threads = 1 , # threads
            n_predict = 2048 , # max tokens, -1 == inf

            model_repo = "TheBloke/Marcoroni-7B-v3-GGUF" , # Hugging Face repo
            model_filename = "marcoroni-7b-v3.Q4_K_M.gguf" , # model file in repo

            system_prompt_type = "Alpaca" # system prompt type
        )
    ])
ros2 launch llama_bringup marcoroni.launch.py

lama_ros (configuration YAML)

Cliquez pour agrandir 
 n_ctx : 2048 # context of the LLM in tokens
n_batch : 8 # batch size in tokens
n_gpu_layers : 0 # layers to load in GPU
n_threads : 1 # threads
n_predict : 2048 # max tokens, -1 == inf

model_repo : " cstr/Spaetzle-v60-7b-GGUF " # Hugging Face repo
model_filename : " Spaetzle-v60-7b-q4-k-m.gguf " # model file in repo

system_prompt_type : " Alpaca " # system prompt type 
 import os
from launch import LaunchDescription
from llama_bringup . utils import create_llama_launch_from_yaml
from ament_index_python . packages import get_package_share_directory


def generate_launch_description ():
    return LaunchDescription ([
        create_llama_launch_from_yaml ( os . path . join (
            get_package_share_directory ( "llama_bringup" ), "models" , "Spaetzle.yaml" ))
    ])
ros2 launch llama_bringup spaetzle.launch.py

llama_ros (configuration YAML + fragments de modèle)

Cliquez pour agrandir 
 n_ctx : 2048 # context of the LLM in tokens
n_batch : 8 # batch size in tokens
n_gpu_layers : 0 # layers to load in GPU
n_threads : 1 # threads
n_predict : 2048 # max tokens, -1 == inf

model_repo : " Qwen/Qwen2.5-Coder-7B-Instruct-GGUF " # Hugging Face repo
model_filename : " qwen2.5-coder-7b-instruct-q4_k_m-00001-of-00002.gguf " # model shard file in repo

system_prompt_type : " ChatML " # system prompt type 
ros2 llama launch Qwen2.yaml

llava_ros (lancement Python)

Cliquez pour agrandir 
 from launch import LaunchDescription
from llama_bringup . utils import create_llama_launch

def generate_launch_description ():

    return LaunchDescription ([
        create_llama_launch (
            use_llava = True , # enable llava

            n_ctx = 8192 , # context of the LLM in tokens, use a huge context size to load images
            n_batch = 512 , # batch size in tokens
            n_gpu_layers = 33 , # layers to load in GPU
            n_threads = 1 , # threads
            n_predict = 8192 , # max tokens, -1 == inf

            model_repo = "cjpais/llava-1.6-mistral-7b-gguf" , # Hugging Face repo
            model_filename = "llava-v1.6-mistral-7b.Q4_K_M.gguf" , # model file in repo

            mmproj_repo = "cjpais/llava-1.6-mistral-7b-gguf" , # Hugging Face repo
            mmproj_filename = "mmproj-model-f16.gguf" , # mmproj file in repo

            system_prompt_type = "Mistral" # system prompt type
        )
    ])
ros2 launch llama_bringup llava.launch.py

llava_ros (configuration YAML)

Cliquez pour agrandir 
 use_llava : True # enable llava

n_ctx : 8192 # context of the LLM in tokens use a huge context size to load images
n_batch : 512 # batch size in tokens
n_gpu_layers : 33 # layers to load in GPU
n_threads : 1 # threads
n_predict : 8192 # max tokens -1 : :  inf

model_repo : " cjpais/llava-1.6-mistral-7b-gguf " # Hugging Face repo
model_filename : " llava-v1.6-mistral-7b.Q4_K_M.gguf " # model file in repo

mmproj_repo : " cjpais/llava-1.6-mistral-7b-gguf " # Hugging Face repo
mmproj_filename : " mmproj-model-f16.gguf " # mmproj file in repo

system_prompt_type : " mistral " # system prompt type 
 def generate_launch_description ():
    return LaunchDescription ([
        create_llama_launch_from_yaml ( os . path . join (
            get_package_share_directory ( "llama_bringup" ),
            "models" , "llava-1.6-mistral-7b-gguf.yaml" ))
    ])
ros2 launch llama_bringup llava.launch.py

Adaptateurs LoRA

Vous pouvez utiliser des adaptateurs LoRA lors du lancement de LLM. À l'aide des fonctionnalités de llama.cpp, vous pouvez charger plusieurs adaptateurs en choisissant l'échelle à appliquer pour chaque adaptateur. Vous avez ici un exemple d'utilisation d'adaptateurs LoRA avec Phi-3. Vous pouvez répertorier les LoRA à l'aide du service /llama/list_loras et modifier leurs valeurs d'échelle en utilisant le service /llama/update_loras . Une valeur d'échelle de 0,0 signifie ne pas utiliser cette LoRA.

Cliquez pour agrandir 
 n_ctx : 2048
n_batch : 8
n_gpu_layers : 0
n_threads : 1
n_predict : 2048

model_repo : " bartowski/Phi-3.5-mini-instruct-GGUF "
model_filename : " Phi-3.5-mini-instruct-Q4_K_M.gguf "

lora_adapters :
  - repo : " zhhan/adapter-Phi-3-mini-4k-instruct_code_writing "
    filename : " Phi-3-mini-4k-instruct-adaptor-f16-code_writer.gguf "
    scale : 0.5
  - repo : " zhhan/adapter-Phi-3-mini-4k-instruct_summarization "
    filename : " Phi-3-mini-4k-instruct-adaptor-f16-summarization.gguf "
    scale : 0.5

system_prompt_type : " Phi-3 "

Clients ROS2

llama_ros et llava_ros fournissent tous deux des interfaces ROS 2 pour accéder aux principales fonctionnalités des modèles. Vous avez ici quelques exemples de la façon de les utiliser dans les nœuds ROS 2. De plus, jetez un œil aux démos llama_demo_node.py et llava_demo_node.py.

Tokeniser

Cliquez pour agrandir 
 from rclpy . node import Node
from llama_msgs . srv import Tokenize


class ExampleNode ( Node ):
    def __init__ ( self ) -> None :
        super (). __init__ ( "example_node" )

        # create the client
        self . srv_client = self . create_client ( Tokenize , "/llama/tokenize" )

        # create the request
        req = Tokenize . Request ()
        req . text = "Example text"

        # call the tokenize service
        self . srv_client . wait_for_service ()
        tokens = self . srv_client . call ( req ). tokens

Détokeniser

Cliquez pour agrandir 
 from rclpy . node import Node
from llama_msgs . srv import Detokenize


class ExampleNode ( Node ):
    def __init__ ( self ) -> None :
        super (). __init__ ( "example_node" )

        # create the client
        self . srv_client = self . create_client ( Detokenize , "/llama/detokenize" )

        # create the request
        req = Detokenize . Request ()
        req . tokens = [ 123 , 123 ]

        # call the tokenize service
        self . srv_client . wait_for_service ()
        text = self . srv_client . call ( req ). text

Intégrations

Cliquez pour agrandir

N'oubliez pas de lancer llama_ros avec l'intégration définie sur true pour pouvoir générer des intégrations avec votre LLM. 

 from rclpy . node import Node
from llama_msgs . srv import Embeddings


class ExampleNode ( Node ):
    def __init__ ( self ) -> None :
        super (). __init__ ( "example_node" )

        # create the client
        self . srv_client = self . create_client ( Embeddings , "/llama/generate_embeddings" )

        # create the request
        req = Embeddings . Request ()
        req . prompt = "Example text"
        req . normalize = True

        # call the embedding service
        self . srv_client . wait_for_service ()
        embeddings = self . srv_client . call ( req ). embeddings

Générer une réponse

Cliquez pour agrandir 
 import rclpy
from rclpy . node import Node
from rclpy . action import ActionClient
from llama_msgs . action import GenerateResponse


class ExampleNode ( Node ):
    def __init__ ( self ) -> None :
        super (). __init__ ( "example_node" )

        # create the client
        self . action_client = ActionClient (
            self , GenerateResponse , "/llama/generate_response" )

        # create the goal and set the sampling config
        goal = GenerateResponse . Goal ()
        goal . prompt = self . prompt
        goal . sampling_config . temp = 0.2

        # wait for the server and send the goal
        self . action_client . wait_for_server ()
        send_goal_future = self . action_client . send_goal_async (
            goal )

        # wait for the server
        rclpy . spin_until_future_complete ( self , send_goal_future )
        get_result_future = send_goal_future . result (). get_result_async ()

        # wait again and take the result
        rclpy . spin_until_future_complete ( self , get_result_future )
        result : GenerateResponse . Result = get_result_future . result (). result

Générer une réponse (llava)

Cliquez pour agrandir 
 import cv2
from cv_bridge import CvBridge

import rclpy
from rclpy . node import Node
from rclpy . action import ActionClient
from llama_msgs . action import GenerateResponse


class ExampleNode ( Node ):
    def __init__ ( self ) -> None :
        super (). __init__ ( "example_node" )

        # create a cv bridge for the image
        self . cv_bridge = CvBridge ()

        # create the client
        self . action_client = ActionClient (
            self , GenerateResponse , "/llama/generate_response" )

        # create the goal and set the sampling config
        goal = GenerateResponse . Goal ()
        goal . prompt = self . prompt
        goal . sampling_config . temp = 0.2

        # add your image to the goal
        image = cv2 . imread ( "/path/to/your/image" , cv2 . IMREAD_COLOR )
        goal . image = self . cv_bridge . cv2_to_imgmsg ( image )

        # wait for the server and send the goal
        self . action_client . wait_for_server ()
        send_goal_future = self . action_client . send_goal_async (
            goal )

        # wait for the server
        rclpy . spin_until_future_complete ( self , send_goal_future )
        get_result_future = send_goal_future . result (). get_result_async ()

        # wait again and take the result
        rclpy . spin_until_future_complete ( self , get_result_future )
        result : GenerateResponse . Result = get_result_future . result (). result

LangChaîne

Il existe une intégration llama_ros pour LangChain. Ainsi, des techniques d’ingénierie rapides pourraient être appliquées. Ici vous avez un exemple pour l'utiliser.

lama_ros (Chaîne)

Cliquez pour agrandir 
 import rclpy
from llama_ros . langchain import LlamaROS
from langchain . prompts import PromptTemplate
from langchain_core . output_parsers import StrOutputParser


rclpy . init ()

# create the llama_ros llm for langchain
llm = LlamaROS ()

# create a prompt template
prompt_template = "tell me a joke about {topic}"
prompt = PromptTemplate (
    input_variables = [ "topic" ],
    template = prompt_template
)

# create a chain with the llm and the prompt template
chain = prompt | llm | StrOutputParser ()

# run the chain
text = chain . invoke ({ "topic" : "bears" })
print ( text )

rclpy . shutdown ()

llama_ros (Stream)

Cliquez pour agrandir 
 import rclpy
from llama_ros . langchain import LlamaROS
from langchain . prompts import PromptTemplate
from langchain_core . output_parsers import StrOutputParser


rclpy . init ()

# create the llama_ros llm for langchain
llm = LlamaROS ()

# create a prompt template
prompt_template = "tell me a joke about {topic}"
prompt = PromptTemplate (
    input_variables = [ "topic" ],
    template = prompt_template
)

# create a chain with the llm and the prompt template
chain = prompt | llm | StrOutputParser ()

# run the chain
for c in chain . stream ({ "topic" : "bears" }):
    print ( c , flush = True , end = "" )

rclpy . shutdown ()

llava_ros

Cliquez pour agrandir 
 import rclpy
from llama_ros . langchain import LlamaROS

rclpy . init ()

# create the llama_ros llm for langchain
llm = LlamaROS ()

# bind the url_image
llm = llm . bind ( image_url = image_url ). stream ( "Describe the image" )
image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"

# run the llm
for c in llm :
    print ( c , flush = True , end = "" )

rclpy . shutdown ()

lama_ros_embeddings (RAG)

Cliquez pour agrandir 
 import rclpy
from langchain_chroma import Chroma
from llama_ros . langchain import LlamaROSEmbeddings


rclpy . init ()

# create the llama_ros embeddings for langchain
embeddings = LlamaROSEmbeddings ()

# create a vector database and assign it
db = Chroma ( embedding_function = embeddings )

# create the retriever
retriever = db . as_retriever ( search_kwargs = { "k" : 5 })

# add your texts
db . add_texts ( texts = [ "your_texts" ])

# retrieve documents
documents = retriever . invoke ( "your_query" )
print ( documents )

rclpy . shutdown ()

lama_ros (Renranker)

Cliquez pour agrandir 
 import rclpy
from llama_ros . langchain import LlamaROSReranker
from llama_ros . langchain import LlamaROSEmbeddings

from langchain_community . vectorstores import FAISS
from langchain_community . document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain . retrievers import ContextualCompressionRetriever


rclpy . init ()

# load the documents
documents = TextLoader ( "../state_of_the_union.txt" ,). load ()
text_splitter = RecursiveCharacterTextSplitter (
    chunk_size = 500 , chunk_overlap = 100 )
texts = text_splitter . split_documents ( documents )

# create the llama_ros embeddings
embeddings = LlamaROSEmbeddings ()

# create the VD and the retriever
retriever = FAISS . from_documents (
    texts , embeddings ). as_retriever ( search_kwargs = { "k" : 20 })

# create the compressor using the llama_ros reranker
compressor = LlamaROSReranker ()
compression_retriever = ContextualCompressionRetriever (
    base_compressor = compressor , base_retriever = retriever
)

# retrieve the documents
compressed_docs = compression_retriever . invoke (
    "What did the president say about Ketanji Jackson Brown"
)

for doc in compressed_docs :
    print ( "-" * 50 )
    print ( doc . page_content )
    print ( " n " )

rclpy . shutdown ()

lama_ros (LLM + RAG + Reranker)

Cliquez pour agrandir
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout