De Quen 2-modellen van Alibaba zijn de nieuwste en beste open-source taalmodellen, met indrukwekkende mogelijkheden op een breed scala aan taken. Deze modellen variëren van 500 miljoen tot 72 miljard parameters, waarbij de grotere modellen ondersteuning bieden voor tot 128.000 tokens - een aanzienlijke verbetering ten opzichte van de 8.000 token-limiet van GPT-3.

Eén van de belangrijkste kenmerken van Quen 2 is de sterke prestaties op het gebied van codering en wiskunde, evenals het vermogen om lange-context begrip aan te kunnen - cruciaal voor toepassingen in de echte wereld. Bovendien bieden de modellen ondersteuning voor een diverse set van talen, waaronder een focus op Midden-Oosterse en Zuidoost-Aziatische talen, wat een welkome verandering is ten opzichte van de op het Westen gerichte focus van veel andere modellen.

Om het vermogen van Quen 2 te benutten, kunnen we het Quen Agent-framework gebruiken, dat toegang biedt tot een ingebouwde browser-assistent, code-interpreter en de mogelijkheid om aangepaste assistenten te maken. Hiermee kunnen we autonome agenten bouwen die kunnen plannen, uitvoeren en hun acties aanpassen op basis van de taak.

In dit gedeelte zullen we onderzoeken hoe we Quen Agent kunnen gebruiken om een aangepaste beeldgeneratie-agent te maken. De agent zal in staat zijn om afbeeldingen te genereren op basis van gebruikersinvoer, de gegenereerde afbeeldingen te downloaden en zelfs zijn eigen code bij te werken als er problemen optreden. Door de krachtige taalkennis van Quen 2 te combineren met de planning- en uitvoeringscapaciteiten van Quen Agent, kunnen we echt autonome en capabele agenten creëren die een breed scala aan taken kunnen aanpakken.

Functie-aanroepen en agenten zijn twee verschillende concepten in de wereld van grote taalmodellen (LLM's). Hier volgt een beknopte uitleg van de verschillen tussen de twee:

Functie-aanroepen (Tool Usage):

• Functie-aanroepen, of tool usage, stelt het LLM in staat om met de externe wereld te communiceren door externe API's of functies te gebruiken.
• Het LLM bepaalt welke functie te gebruiken op basis van de gebruikersinvoer, genereert de benodigde invoer voor de functie en retourneert de resultaten aan de gebruiker.
• Het LLM kan de functie-aanroep zelf echter niet uitvoeren; de gebruiker of een apart systeem moet de daadwerkelijke functie-aanroep doen en de resultaten aan het LLM teruggeven.

Agenten:

• Agenten zijn geavanceerdere instanties van LLM's die toegang hebben tot een set tools, net als bij functie-aanroepen.
• Agenten kunnen ook plannen maken, taken opdelen in subdoelen en acties uitvoeren met behulp van de beschikbare tools.
• Agenten hebben toegang tot zowel korte- als langetermijngeheugen, waardoor ze hun voortgang kunnen bijhouden en hun volgende stappen dienovereenkomstig kunnen plannen.
• Agenten zijn cruciaal om LLM's echt bruikbaar te maken in toepassingen in de echte wereld, omdat ze complexe taken autonoom kunnen uitvoeren.

Samenvattend: functie-aanroepen zijn een beperktere interactie waarbij het LLM alleen de benodigde invoer voor een functie kan genereren, terwijl agenten de mogelijkheid hebben om te plannen, uit te voeren en hun acties aan te passen om een gewenst resultaat te bereiken.

Om aan de slag te gaan met Qwen-agenten, zullen we de 72 miljard versie van Qwen 2 gebruiken en deze lokaal draaien met behulp van AMA. Je kunt ook hun externe API gebruiken, maar om Qwen Agent te gebruiken, hebben we twee opties:

1. Installeer het pakket met pip als een onafhankelijk Python-pakket.
2. Kloon de repo en voer de installatie lokaal uit als je de nieuwste ontwikkelingsversie wilt gebruiken.

Ik zal het lokaal draaien met behulp van AMA. Start eerst een AMA-server en gebruik de opdracht olama Run Qwen 272 billion. Dit zal AMA en het model downloaden, wat enige tijd kan duren afhankelijk van je internetsnelheid.

Creëer vervolgens een virtuele omgeving met conda en activeer deze:

conda create -n qwen python=3.10
conda activate qwen

Installeer nu het Qwen Agent-pakket met pip:

pip install qwen-agent

We beginnen met functie-aanroepen. Het model moet de te gebruiken functie kiezen, de invoer bepalen en deze doorgeven aan een Python-interpreter. De interpreter zal de functie uitvoeren, het antwoord ophalen en dit terugvoeren naar het LLM.

Hier is een voorbeeld van een functie-aanroep voor het ophalen van het huidige weer:

# Maak het LLM-exemplaar aan
llm = QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1")

# Gebruikersbericht
user_message = "Wat is het huidige weer in Parijs?"

# Definieer de functie
function_call = {
    "description": "Haal het huidige weer op voor een bepaalde locatie",
    "function": "get_weather",
    "arguments": {
        "location": "Parijs",
        "unit": "celsius"
    }
}

# Roep het LLM aan en voer de functie uit
response = llm.call_with_function(user_message, [function_call])
print(response)

Dit zal de huidige weersgegevens voor Parijs genereren en deze terugsturen naar het LLM.

Laten we nu een voorbeeld bekijken van het gebruik van Qwen Agent. We zullen een aangepaste agent maken die afbeeldingen kan genereren en deze naar een lokale map kan downloaden. De agent zal een aangepast hulpmiddel voor beeldgeneratie en de code-interpreter gebruiken om de benodigde code uit te voeren.

from qwen_agent import Assistant, CodeInterpreter, CustomTool

# Definieer het aangepaste hulpmiddel voor beeldgeneratie
class MyImageGeneration(CustomTool):
    def __init__(self):
        self.description = "Genereer afbeeldingen op basis van gebruikersinvoer met behulp van de Pollinations.AI API."

    def run(self, args):
        # Genereer de afbeelding met behulp van de API
        image_url = generate_image(args["prompt"])
        
        # Download de afbeelding naar een lokale map
        download_image(image_url, "images")

        return "Afbeelding gegenereerd en opgeslagen in 'images'-map."

# Maak de agent aan
agent = Assistant(
    llm=QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1"),
    tools=[MyImageGeneration(), CodeInterpreter()]
)

# Vraag de agent om een afbeelding te genereren
agent.run("Maak een afbeelding van een lama met zonnebril.")

Deze agent zal het aangepaste hulpmiddel voor beeldgeneratie gebruiken om de afbeelding te maken, deze te downloaden naar de "images"-map en het resultaat teruggeven.

Tot slot kijken we naar de impact van kwantisatie op de prestaties van Qwen-modellen. Het Qwen-team heeft gedetailleerde evaluaties uitgevoerd op MML-, C-Evolve- en I-Evolve-metriek voor verschillende kwantisatieniveaus.

De resultaten laten zien dat voor grotere modellen (72 miljard) het verschil tussen 16-bit en 8-bit kwantisatie niet significant is, maar 4-bit kwantisatie een meer merkbare impact kan hebben op de prestaties. Voor kleinere modellen (0,5 miljard) zijn de verschillen meer uitgesproken, waarbij 4-bit kwantisatie een daling van 5 punten in de gemiddelde scores laat zien.

Over het algemeen wordt aanbevolen om ten minste 8-bit of 16-bit kwantisatie te gebruiken voor productie-implementaties, aangezien 4-bit kwantisatie een meer significante impact kan hebben op de modelprestaties, vooral voor kleinere modellen.