LLMs mit Superior Reasoning neu definieren

Generative KI wurde häufig wegen seiner Unfähigkeit, effektiv zu argumentieren, kritisiert, insbesondere in Szenarien, die präzise und deterministische Ergebnisse erfordern. Es hat sich als sehr schwierig erwiesen, den nächsten Token kaum vorherzusagen, wenn der nächste Token so genau sein muss wie eine einzelne Choice. Beispielsweise kann das Schreiben eines Aufsatzes tausend Formen annehmen und dennoch akzeptabel sein, aber die Lösung einer quadratischen Gleichung muss eine bestimmte endgültige Antwort liefern. Genau dieses Drawback hat Alibabas KI-Abteilung MarcoPolo dazu veranlasst, den bahnbrechenden Marco-o1 zu entwickeln großes Sprachmodell (LLM), der die Messlatte für komplexe Denkaufgaben höher legt. Dieses revolutionary Modell zeichnet sich in verschiedenen Bereichen wie Mathematik, Physik, Codierung und mehrsprachigen Anwendungen aus und bietet reale Lösungen für konventionelle und offene Herausforderungen.

Lernziele

• Das Konzept und die Bedeutung von Massive Reasoning Fashions (LRMs).
• Die wichtigsten technologischen Innovationen von Marco-o1 und wie sie es auszeichnen.
• Benchmarks und Ergebnisse unterstreichen seine fortschrittlichen Fähigkeiten.
• Praktische Anwendungen, insbesondere bei der mehrsprachigen Übersetzung.
• Einblicke in Transparenz, Herausforderungen und Zukunftspläne für Marco-o1.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Kerninnovationen hinter Marco-o1

Marco-o1 unterscheidet sich von anderen Modellen durch die Integration einer Kombination fortschrittlicher Techniken zur Optimierung von Argumentation, Entscheidungsfindung und Genauigkeit. Dies sind einige Dinge, die herkömmliche LLMs nicht leisten.

Hier ist ein Screenshot, der die beliebte Zählung des Buchstabens r im Wort „Erdbeere“ zeigt.

Chain-of-Thought (CoT) Feinabstimmung

Dieser Ansatz ermöglicht es dem Modell, Schritt für Schritt zu argumentieren und nachzuahmen, wie Menschen komplexe Probleme lösen. Die Feinabstimmung mit Open-Supply-CoT-Datensätzen und Alibabas proprietären synthetischen Datensätzen hat Marco-o1s Fähigkeit, komplizierte Aufgaben zu bewältigen, verbessert.

Monte-Carlo-Baumsuche (MCTS)

Mit dieser Methode kann das Modell mehrere Argumentationspfade erkunden, von umfassenden Strategien bis hin zu detaillierten Minischritten (z. B. die gleichzeitige Generierung von 32 oder 64 Token). MCTS erweitert den Lösungsraum und ermöglicht eine fundiertere Entscheidungsfindung.

Reflexionsmechanismen

Ein herausragendes Merkmal von Marco-o1 ist seine Fähigkeit zur Selbstreflexion. Das Modell bewertet seine Argumentationsprozesse, identifiziert Ungenauigkeiten und iteriert seine Ergebnisse, um bessere Ergebnisse zu erzielen.

Mehrsprachige Beherrschung

Marco-o1 zeichnet sich durch hervorragende Übersetzungen aus, da es mit beispielloser Leichtigkeit kulturelle Nuancen, idiomatische Ausdrücke und umgangssprachliche Ausdrücke handhabt, was es zu einem leistungsstarken Werkzeug für die globale Kommunikation macht.

Einige beeindruckende Benchmarks und Ergebnisse von Marco-o1

Die Fähigkeiten von Marco-o1 spiegeln sich in seinen beeindruckenden Leistungskennzahlen wider. Es hat erhebliche Verbesserungen bei Argumentations- und Übersetzungsaufgaben gezeigt:

• +6,17 % Genauigkeit beim englischen MGSM-Datensatz.
• +5,60 % Genauigkeit beim chinesischen MGSM-Datensatz.
• Außergewöhnlicher Umgang mit mehrsprachigen Übersetzungen, präzise Erfassung kultureller Feinheiten und umgangssprachlicher Phrasen.

Diese Ergebnisse stellen einen bedeutenden Fortschritt in der Fähigkeit des Modells dar, Sprache und Logik effektiv zu kombinieren.

Anwendungen: Mehrsprachige Übersetzung und darüber hinaus

Marco-o1 ist Vorreiter beim Einsatz von Massive Reasoning Fashions (LRM) in der maschinellen Übersetzung. Die mehrsprachigen Fähigkeiten des Modells gehen über die bloße Übersetzung hinaus, indem sie Skalierungsgesetze zum Zeitpunkt der Inferenz untersuchen, was es zu einem robusten Werkzeug für die globale Kommunikation macht. Es leistet Pionierarbeit beim Einsatz von LRMs in verschiedenen realen Szenarien:

• Mehrsprachige Übersetzung: Über grundlegende Übersetzungen hinaus nutzt es Skalierungsgesetze während der Inferenz, um die sprachliche Präzision und das Kontextbewusstsein zu verbessern.
• Kodierung und wissenschaftliche Forschung: Seine klaren Argumentationspfade machen es zu einem zuverlässigen Werkzeug zur Lösung von Programmierproblemen und zur Unterstützung wissenschaftlicher Entdeckungen.
• Globale Problemlösung: Ob im Bildungswesen, im Gesundheitswesen oder in der Wirtschaft, das Modell passt sich nahtlos an Aufgaben an, die Logik und Argumentation erfordern.

Transparenz und Open Entry

Alibaba hat mit der Veröffentlichung von Marco-o1 und seinen Datensätzen auf GitHub einen mutigen Schritt getan und so Zusammenarbeit und Innovation gefördert. Entwickler und Forscher haben Zugriff auf:

• Umfangreiche Dokumentation.
• Implementierungsleitfäden.
• Beispielskripte für die Bereitstellung, einschließlich der Integration mit Frameworks wie FastAPI mithilfe von vLLM (die wir in diesem Artikel sehen werden).

Diese Offenheit ermöglicht es der KI-Neighborhood, die Fähigkeiten von Marco-o1 für breitere Anwendungen zu verfeinern und zu erweitern.

Warum Marco-o1 wichtig ist

Die Enthüllung von Marco-o1 markiert einen entscheidenden Second in der KI-Entwicklung. Seine Fähigkeit, komplexe Probleme zu lösen, sich an mehrsprachige Kontexte anzupassen und sich selbst zu reflektieren, macht es an die Spitze der KI der nächsten Technology. Ob es darum geht, wissenschaftliche Herausforderungen anzugehen, differenzierte Texte zu übersetzen oder offene Fragen zu beantworten, Marco-o1 ist bereit, die Landschaft der KI-Anwendungen neu zu gestalten.

Für Forscher und Entwickler ist Marco-o1 nicht nur ein Werkzeug, sondern eine Einladung zur Zusammenarbeit bei der Neudefinition dessen, was KI leisten kann. Indem Marco-o1 die Lücke zwischen Argumentation und Kreativität schließt, setzt er einen neuen Normal für die Zukunft der künstlichen Intelligenz.

Praktisch: Marco-o1 mithilfe von Code erkunden

Das offizielle Github-Repo enthält schöne Beispiele, die Ihnen helfen, das Modell mit verschiedenen Anwendungsfällen zu testen. Weitere Beispiele finden Sie hier https://github.com/AIDC-AI/Marco-o1/tree/most important/examples

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import torch
from vllm import LLM, SamplingParams
from transformers import AutoTokenizer

# Initialize FastAPI app
app = FastAPI()

# Outline a request mannequin utilizing Pydantic for validation
class ChatRequest(BaseModel):
    user_input: str  # The consumer's enter textual content
    historical past: record  # An inventory to retailer chat historical past

# Variables for mannequin and tokenizer
tokenizer = None
mannequin = None

@app.on_event("startup")
def load_model_and_tokenizer():
    """
    Load the mannequin and tokenizer as soon as throughout startup.
    This ensures sources are initialized solely as soon as, bettering effectivity.
    """
    international tokenizer, mannequin
    path = "AIDC-AI/Marco-o1"  # Path to the Marco-o1 mannequin
    tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
    mannequin = LLM(mannequin=path, tensor_parallel_size=4)  # Parallelize mannequin processing

def generate_response_stream(mannequin, textual content, max_new_tokens=4096):
    """
    Generate responses in a streaming vogue.
    :param mannequin: The language mannequin to make use of.
    :param textual content: The enter immediate.
    :param max_new_tokens: Most variety of tokens to generate.
    """
    new_output=""  # Initialize the generated textual content
    sampling_params = SamplingParams(
        max_tokens=1,  # Generate one token at a time for streaming
        temperature=0,  # Deterministic technology
        top_p=0.9  # Controls variety in token choice
    )
    with torch.inference_mode():  # Allow environment friendly inference mode
        for _ in vary(max_new_tokens):  # Generate tokens as much as the restrict
            outputs = mannequin.generate(
                (f'{textual content}{new_output}'),  # Concatenate enter and present output
                sampling_params=sampling_params,
                use_tqdm=False  # Disable progress bar for cleaner streaming
            )
            next_token = outputs(0).outputs(0).textual content  # Get the subsequent token
            new_output += next_token  # Append token to the output
            yield next_token  # Yield the token for streaming

            if new_output.endswith('</Output>'):  # Cease if the top marker is discovered
                break

@app.submit("/chat/")
async def chat(request: ChatRequest):
    """
    Deal with chat interactions by way of POST requests.
    :param request: Accommodates consumer enter and chat historical past.
    :return: Streamed response or error message.
    """
    # Validate consumer enter
    if not request.user_input:
        increase HTTPException(status_code=400, element="Enter can't be empty.")

    # Deal with exit instructions
    if request.user_input.decrease() in ('q', 'stop'):
        return {"response": "Exiting chat."}

    # Deal with clear command to reset chat historical past
    if request.user_input.decrease() == 'c':
        request.historical past.clear()
        return {"response": "Clearing chat historical past."}

    # Replace historical past with consumer enter
    request.historical past.append({"function": "consumer", "content material": request.user_input})

    # Create the mannequin immediate with historical past
    textual content = tokenizer.apply_chat_template(request.historical past, tokenize=False, add_generation_prompt=True)

    # Stream the generated response
    response_stream = generate_response_stream(mannequin, textual content)

    # Return the streamed response
    return StreamingResponse(response_stream, media_type="textual content/plain")

Der obige Code stammt aus dem offiziellen Repo. Wenn das Skript jedoch abstürzt, bevor es reagiert, liegt möglicherweise eine Diskrepanz zwischen der Speicherkapazität Ihrer GPU und den Anforderungen des Modells vor. Dies ist häufig der Fall, wenn Sie mit großen Modellen arbeiten, die mehr VRAM benötigen, als auf Ihrer GPU verfügbar ist. Da es sich um einen Fastapi-Code handelt, ist es sinnvoller, ihn auf Ihrem Laptop auszuführen, der möglicherweise nicht über einen geeigneten VRAM verfügt.

Ich habe versucht, ngrok zu verwenden, um die API mithilfe von Google Colab verfügbar zu machen, damit Sie dort die kostenlose GPU genießen können, die Sie in diesem Artikel-Repo finden: https://github.com/inuwamobarak/largeReasoningModels/tree/most important/Marco-01

Wrapper-Skript mit GPU

Um Ihnen beim Testen der Leistung dieses Modells zu helfen, finden Sie hier ein Wrapper-Skript, mit dem Sie es unterwegs in Google Colab mithilfe einer GPU ausführen können. Beachten Sie, dass ich Float 16 hinzugefügt habe und es über 13 GB GPU verbraucht.

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

Wrapper-Skript mit 16 Float-Genauigkeit:

class ModelWrapper:
    def __init__(self, model_name):
        self.system = torch.system("cuda" if torch.cuda.is_available() else "cpu")
        # Load mannequin with half-precision if supported, or use device_map for environment friendly placement
        strive:
            self.mannequin = AutoModelForCausalLM.from_pretrained(
                model_name, 
                torch_dtype=torch.float16 if torch.cuda.is_available() else None, 
                device_map="auto"
            )
        besides Exception as e:
            print(f"Error loading mannequin: {e}")
            increase
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)

        # Allow gradient checkpointing for big fashions
        self.mannequin.gradient_checkpointing_enable()

        # Debug: Test if mannequin is on GPU
        print(f"Mannequin loaded to system: {subsequent(self.mannequin.parameters()).system}")

    def generate_text(self, immediate, max_length=100, num_return_sequences=1):
        inputs = self.tokenizer(immediate, return_tensors="pt")
        inputs = {key: worth.to(self.system) for key, worth in inputs.objects()}  # Transfer inputs to GPU
        outputs = self.mannequin.generate(
            **inputs, max_length=max_length, num_return_sequences=num_return_sequences
        )
        generated_texts = (
            self.tokenizer.decode(output, skip_special_tokens=True) for output in outputs
        )
        return generated_texts

Beispiel eins

# Instance utilization
if __name__ == "__main__":
    model_name = "AIDC-AI/Marco-o1"
    model_wrapper = ModelWrapper(model_name)

    immediate = "As soon as upon a time, in a land far, far-off,"
    generated_texts = model_wrapper.generate_text(immediate, max_length=50, num_return_sequences=1)

    for i, textual content in enumerate(generated_texts):
        print(f"Generated Textual content {i+1}:n{textual content}n")

Mannequin loaded to system: cuda:0 Generated Textual content 1: As soon as upon a time, in a land far, far-off, there lived a king who was very keen on his backyard. He had an exquisite backyard with many flowers and bushes. Someday, he determined to plant some new bushes in his backyard. 

Beispiel zwei

immediate = "What number of S's are there in Mississippi"
generated_texts = model_wrapper.generate_text(immediate, num_return_sequences=1)

for i, textual content in enumerate(generated_texts):
    print(f"Generated Textual content {i+1}:n{textual content}n")

Generated Textual content 1:
What number of S's are there in Mississippi? To find out what number of 'S's are within the phrase "Mississippi," let's analyze the phrase step-by-step.

First, let's write out the phrase:
M-I-S-S-I-S-S-I-P-P-I

Now, let's establish every letter and rely the 'S's:
1. The primary letter is M.
2. The second letter is I.
3. The third letter is S.
4. The fourth letter is S.
5. The fifth letter is I.
6. The sixth letter is S.
7. The seventh letter is S.
8. The eighth letter is I.
9. The ninth letter is P.
10. The tenth letter is P.
11. The eleventh letter is I.

From this evaluation, we will see that the letters 'S' seem at positions 3, 4, 6, 7, and 11. That is a complete of 5 'S's.

To double-check, let's rely them once more:
- Place 3: S
- Place 4: S
- Place 6: S
- Place 7: S
- Place 11: S

Sure, there are certainly 5 'S's within the phrase "Mississippi."

Due to this fact, the variety of 'S's in Mississippi is boxed{4}. Wait, that is incorrect based mostly on the earlier rely. Let me recount fastidiously.

Upon re-examining:
1. M
2. I
3. S
4. S
5. I
6. S
7. S
8. I
9. P
10. P
11. I

Counting the 'S's:
- Place 3: S
- Place 4: S
- Place 6: S
- Place 7: S

That is 4 'S's. It appears I initially miscounted the final 'S' at place 11 as an 'I.' Due to this fact, the right variety of 'S's in Mississippi is boxed{4}. 

Nevertheless, to make sure accuracy, let's use one other technique. The phrase "Mississippi" has 11 letters in complete. The vowels are I, I, I, and I (4 'I's), and the consonants are M, S, S, S, S, P, P. Counting the 'S's among the many consonants offers us 4 'S's.

Sie werden feststellen, dass das Modell versucht, zu überlegen, wie es die ihm gestellten Probleme löst. Dies ist der Unterschied zwischen LRM und früheren LLMs.

Herausforderungen und Zukunftspläne

Während Marco-o1 neue Maßstäbe gesetzt hat, erkennt das Entwicklungsteam Raum für Wachstum. Die Argumentationsfähigkeiten des Modells sind strong, aber noch nicht vollständig optimiert. Um dieses Drawback anzugehen, plant Alibaba Folgendes zu integrieren:

• Final result Reward Modeling (ORM) und Course of Reward Modeling (PRM) zur Verfeinerung der Entscheidungsfindung.
• Verstärkungslerntechniken zur weiteren Verbesserung der Problemlösung.

Diese Bemühungen unterstreichen das Engagement von MarcoPolo für die Weiterentwicklung der Denkfähigkeiten der KI.

Abschluss

Marco-o1 stellt einen entscheidenden Fortschritt in der künstlichen Intelligenz dar, der kritische Einschränkungen traditioneller Sprachmodelle durch die Integration robuster Argumentations- und Entscheidungsfähigkeiten angeht. Seine bahnbrechenden Innovationen – die, wie wir gesehen haben, das Denken in der Gedankenkette, die Monte-Carlo-Baumsuche, die Selbstreflexion und die Beherrschung mehrerer Sprachen umfassen – demonstrieren einen neuen Normal für die Lösung komplexer, realer Probleme. Mit beeindruckenden Benchmarks und offenem Zugang zu seiner Architektur bietet Marco-o1 nicht nur branchenübergreifende transformative Lösungen, sondern lädt auch die globale KI-Neighborhood ein, zusammenzuarbeiten, um die Grenzen des Möglichen zu erweitern. Wir können sagen, dass Marco-o1 die Zukunft argumentationsgesteuerter Sprachmodelle veranschaulicht.

Wichtige Erkenntnisse

• Marco-o1 geht über die Token-Vorhersage hinaus, indem es Techniken wie Chain-of-Thought und Monte-Carlo-Baumsuche zur erweiterten Problemlösung einbezieht.
• Die Fähigkeit des Modells, seine Argumentation zu bewerten und zu verfeinern, zeichnet es aus und gewährleistet eine höhere Genauigkeit und Anpassungsfähigkeit.
• Unübertroffene Übersetzungsfähigkeiten ermöglichen es Marco-o1, kulturelle Nuancen und idiomatische Ausdrücke präzise zu verarbeiten.
• Durch die Veröffentlichung der Datensätze und Implementierungshandbücher von Marco-o1 auf GitHub fördert Alibaba die Zusammenarbeit und fördert weitere Fortschritte in der KI-Forschung.

Referenzlinks

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Ich bin ein KI-Ingenieur mit einer großen Leidenschaft für die Forschung und die Lösung komplexer Probleme. Ich biete KI-Lösungen an, die Massive Language Fashions (LLMs), GenAI, Transformer-Modelle und Secure Diffusion nutzen.