Skip to main content
mostafaibrahim17
Projects
ml-articles
Reports
Unveiling LMQL: The Future of Interacting with Language Models

Unveiling LMQL: The Future of Interacting with Language Models

This article delves into LMQL, a cutting-edge interface designed to streamline and refine interactions between humans and artificial intelligence, offering a detailed guide on its integration, core principles, and practical applications while addressing its challenges and future implications.
Mostafa Ibrahim
Created on February 9|Last edited on February 9


Table of Content

Table of ContentIntroductionOpenAI and LMQLUnderstanding LMQLDifferences from Traditional Programming and Query LanguagesCore Concepts of LMQLSyntax and StructurePractical Implementation of LMQLStep 1: Installing Necessary PackagesStep 2: Import Necessary PackagesStep 3: Set Up Your Personal OpenAI KeyStep 5: Using the lmql.F() functionStep 6: Using the lmql.query functionStep 7: Adding Additional Query ParametersThe Future of LMQL, Challenges, Upgrades, and MoreIntegration with Other AI ModelsEnhancement of Natural Language Understanding within LMQLError Handling and Feedback MechanismConclusionReferences


Introduction

In the world of web development and database management, SQL is pretty much a superstar. It is considered the go-to language for anyone wanting to communicate with databases, ask them questions, or give them instructions on how to organize data.
It's like the universal translator for the digital realm, making it possible for websites and apps to access the information they need to function smoothly. SQL's fame isn't just for show—it's crucial for everything from your favorite online store to the social media platforms you scroll through daily.
Enter LMQL—Language Model Query Language—a new kid on the block that's starting to make waves in the vast ocean of artificial intelligence and natural language processing. If SQL is the universal translator for databases, think of LMQL as the new LLM communicator that helps us talk to AI in a way it understands, without the need for us to learn its complicated language.
LMQL is designed to make our interactions with AI as easy as asking your smart speaker to play your favorite tunes. LMQL lets us ask complex questions, get the AI to dig through heaps of data, and serve us the exact slice of information we're looking for, all with the ease of chatting with a friend.
In this article, we're going to dive into the world of LMQL—what it is, why it matters, and how it's setting the stage for a new era in technology where chatting with an AI might become as commonplace as texting a friend. Buckle up as we're about to explore how this new tool is changing the game in AI interaction, making technology more accessible and fun for everyone.

OpenAI and LMQL

LMQL is designed to be compatible with a range of models provided through the OpenAI Completions or Chat API, including various iterations of GPT-3.5, ChatGPT, and GPT-4, as well as models available through Azure OpenAI.
For those looking to integrate LMQL with these models, specific model identifiers are required to utilize them within LMQL, either by passing them as arguments to lmql.model() or by specifying them in the from clause of a query.
Some of the models that have been verified to work seamlessly with LMQL include the following identifiers, but were disabled by OpenAI do include:
  • openai/text-ada-001
  • openai/text-curie-001
  • openai/text-babbage-001
  • openai/text-davinci-00[1-3]
Other still supported models do include:
  • openai/gpt-3.5-turbo-instruct
  • openai/gpt-4-0314
To check the supported OpenAI model check the following link.
Example usage where we specified the openai/gpt-3.5-turbo-instruct as our model. Here we used the Keyword “from” in order to specify which model we would like to use.
argmax(verbose=True) "Hello[WHO]" from "openai/gpt-3.5-turbo-instruct" where STOPS_AT(WHO, "\n")

model-output::
Completion with {'model': 'text-ada-001', 'prompt': \[550256, 15496], 'max_tokens': 64, 'temperature': 0, 'logprobs': 5, 'user': 'lmql', 'stream': True, 'echo': True}
Having said that, as we will see later throughout this article, there are other ways in order to specify the model to be used.

Understanding LMQL

Differences from Traditional Programming and Query Languages

Unlike traditional programming or query languages such as SQL, Python, or GraphQL, LMQL is specifically designed with the intricacies of natural language processing (NLP) in mind. Traditional languages often require explicit and rigid structuring of commands and are primarily used to interact with static databases or to execute predefined operations. LMQL, on the other hand, thrives in dynamic environments, dealing with the fluidity and variability of human language as processed by AI systems. Its design acknowledges the unpredictable nature of language model outputs, offering a more adaptable and nuanced way of querying.

Core Concepts of LMQL

LMQL is built on a foundation of key principles aimed at enhancing the usability and flexibility of language models. Its syntax and structure are deliberately designed to be intuitive, allowing users to formulate queries that feel natural yet are capable of performing complex operations. This ease of use does not sacrifice power; LMQL supports a wide range of functionalities, from simple data retrieval to the execution of sophisticated commands that influence the output of language models in subtle and precise ways.

Syntax and Structure

Moving on, let's take a look at the syntax and structure of LMQL queries. This will assist us in better understanding how such queries work.
To begin with, the syntax of LMQL is a harmonious blend of natural language elements and structured query language constructs, ensuring that queries are both human-readable and highly functional.
This structure allows users to specify their needs with precision, incorporating variables, conditions, and even logical operators in a way that feels familiar yet is distinctly tailored for AI interactions.

Prompting Is Programming: A Query Language for Large Language Models Research Paper (Source)
An LMQL program consists of five main parts:
  1. The decoder specifies how text is generated. More on decoders letter on.
  2. The actual query identifies the prompt to the language model.
  3. The 'from' clause, identifies the specific model used.
  4. The 'where' clause, sets conditions on the generated text.
  5. A distribution instruction optionally defines how to handle multiple outputs or probabilities.
Each component plays a unique role in shaping the interaction with the language model, from defining the query's structure to refining and controlling the generated output.
For example, let's go through the below query. This LMQL query demonstrates conditional logic and constraints in querying a language model. 
sample(temperature=1.2)

"Say 'this is a test'[RESPONSE]" where len(TOKENS(RESPONSE)) < 25

if "test" not in RESPONSE:
    "You did not say 'test', try again:[RESPONSE]" where \
        len(TOKENS(RESPONSE)) < 25
else:
    "Good job"
It begins by setting a sample decoding with a specified temperature to influence response variability. Where the temperature" refers to a parameter that controls the randomness of predictions by the model.
Moving on, the query asks the model to respond to a statement, imposing a constraint on the response length. If the response does not include a specific keyword ("test"), it prompts the model again with a similar length constraint, seeking a corrected response. If the condition is met, it concludes with a confirmation message, showcasing LMQL's ability to incorporate complex logic and feedback loops in interactions with language models.

Practical Implementation of LMQL

In the practical section of this article, we delve into the installation and hands-on application of LMQL within a Python environment. The journey begins with configuring the necessary setup, ensuring all prerequisites are met for seamless integration.
Following this step, we will transition into an exploration of LMQL's capabilities. Through illustrative examples, readers are guided on how to leverage LMQL for enhancing interactions with large language models (LLMs), from crafting nuanced queries to refining AI-generated outputs.
This section aims to provide users with the basic knowledge to harness some of the potential of LMQL in their projects.

Step 1: Installing Necessary Packages

First of all, start by installing the two following packages onto your device.
!pip install lmql
!pip install llama-cpp-python

Step 2: Import Necessary Packages

We will import the necessary packages such as the os package in order to set up our environment. Moving on we will import the transformer package. Lastly, we will import both the lmql and nest_asyncio packages which we will be using later on in the tutorial.
import os
import transformers
import lmql

Step 3: Set Up Your Personal OpenAI Key

os.environ['OPENAI_API_KEY'] = 'Insert your personal OpenAI key here'
This key would allow you to use OpenAI models such as text-ada-001, text-curie-001, text-babbage-001, text-davinci-001, and gpt-3.5-turbo-instruct.
In case you’re using an online notebook such as Kaggle or Jupyter, you may run into issues in Notebook environments due to their asynchronous nature. To circumvent these problems, activating nested event loops in your notebook can help manage these challenges effectively.
import nest_asyncio
nest_asyncio.apply()
In Python, LMQL code is treated as a standard Python function. This approach allows you to define, customize, and execute LMQL code directly within your existing Python projects.
For this article, we will introduce two primary ways to engage with LMQL:
  • The lmql.F()
  • The @lmql.query decorator

Each of these methods internally formulates an LMQL query function based on the code input. This section will guide you through defining and executing query functions via lmql.query, and lmql.F, followed by details on understanding the query output and customizing queries, for instance, by setting the model, decoder, and other parameters.

Step 5: Using the lmql.F() function

The lmql.F() evaluates pieces of the LMQL code as pure lambda expressions, in a very similar to Python's lambda keyword. This is one of the easiest ways to utilize LMQL queries, where we provide the lmql.F function with a simple question, a given parameter, and some constraints.
favorite_dish_query = lmql.F("What's the most popular dish in {region}? [DISH_NAME]",
                                    constraints="STOPS_AT(DISH_NAME, '.')")

favorite_dish_query('Italy')
Output: '\n\nThe most popular dish in Italy is pizza.'

Step 6: Using the lmql.query function

The lmql.query decorator is used to define the LMQL query functions using standard def syntax, including support for capturing and accessing the surrounding Python scope. The idea here is that the LMQL is written in a style similar to that of a normal Python function, where the function starts with a def, parameter, and a return type. This allows us to write more complex and specific queries. Again, similar to the lmql.F() function this query does include a given parameter along with some constraints.
@lmql.query
def capital_sights(country):
    '''lmql
    "Q: What is the captital of {country}? \\n"
    "A: [CAPITAL] \\n"
    "Q: What is the main sight in {CAPITAL}? \\n"
    "A: [ANSWER]" where (len(TOKENS(CAPITAL)) < 10) and (len(TOKENS(ANSWER)) < 100) \
        and STOPS_AT(CAPITAL, '\\n') and STOPS_AT(ANSWER, '\\n')

    # return just the ANSWER 
    return ANSWER
    '''

print(capital_sights(country="the United Kingdom"))
Output: One popular dish from Naples is known for is pizza, specifically Neapolitan-style pizza.


Step 7: Adding Additional Query Parameters

In general, the very first keyword of an LMQL query specifies the decoding algorithm to use. For this, the following decoder keywords are available:

  1. The argmax decoder is the simplest decoder available in LMQL. It greedily selects the most likely token at each step of the decoding process. It has no additional parameters. Since argmax decoding is deterministic, one can only generate a single sequence at a time.
  2. The sample decoder samples n sequences in parallel from the model. The temperature parameter controls the randomness of the sampling process. Higher values of temperature lead to more random samples, while lower values lead to more likely samples. A temperature value of 0.0 is equivalent to the argmax decoder.
  3. Lastly, there is also a simple beam search decoder. The n parameter controls the beam size. The beam search decoder is deterministic, so it will generate the same n sequences every time. The result of a beam query is a list of n sequences, sorted by their likelihood.
import lmql

@lmql.query(model="openai/gpt-3.5-turbo-instruct”, decoder="sample", temperature=1.8)
def tell_a_joke():
    '''lmql
    """A list good dad joke. A indicates the punchline:
    Q:[JOKE]
    A:[PUNCHLINE]""" where STOPS_AT(JOKE, "?") and  STOPS_AT(PUNCHLINE, "\n")
    '''

tell_a_joke()
Output: LMQLResult(prompt="A list good dad joke. A indicates the punchline:\nQ: Why don't eggs tell jokes?\nA: They might crack up!", variables={'JOKE': " Why don't eggs tell jokes?", 'PUNCHLINE': ' They might crack up!'}, distribution_variable=None, distribution_values=None)

Below we used the same query but this time we used a beam decoder with a beam size of 2. This parameter returns two outputs for the model instead of one.
tell_a_joke(decoder="beam", n=2)
Output: [LMQLResult(prompt='A list good dad joke. A indicates the punchline:\nQ: Why did the golfer bring worms glove?\nA: Because he heard he needs good grips for his club.', variables={'JOKE': ' Why did the golfer bring worms glove?', 'PUNCHLINE': ' Because he heard he needs good grips for his club.'}, distribution_variable=None, distribution_values=None),
LMQLResult(prompt='A list good dad joke. A indicates the punchline:\nQ: Why don’t eggs tell jokes?\nA: They can crack too easily.', variables={'JOKE': ' Why don’t eggs tell jokes?', 'PUNCHLINE': ' They can crack too easily.'}, distribution_variable=None, distribution_values=None)]

The Future of LMQL, Challenges, Upgrades, and More

Integration with Other AI Models

Expanding compatibility to encompass a wider array of AI models and platforms from various providers could significantly increase LMQL's versatility and application scope, enabling more seamless and diverse AI interactions. Currently, LMQL is designed to be compatible with a range of models provided through OpenAI, including various iterations of GPT-3.5, ChatGPT, and GPT-4, as well as models available through Azure OpenAI. Specific model identifiers include openai/text-ada-001, openai/text-curie-001, openai/text-babbage-001, openai/text-davinci-00[1-3], and openai/gpt-3.5-turbo-instruct.

Enhancement of Natural Language Understanding within LMQL

Advancing LMQL's natural language processing capabilities to support more intuitive, conversational interactions would make it more accessible and powerful, reducing the learning curve for new users and enhancing the efficiency of experienced ones.

Error Handling and Feedback Mechanism

Developing sophisticated error detection and feedback systems within LMQL could aid users in quickly identifying and correcting issues in their queries, streamlining the query refinement process, and fostering a more user-friendly experience.

Conclusion

To sum up, LMQL represents a significant step forward in how we interact with artificial intelligence, offering a bridge between human language and AI's computational power. This language model query language not only simplifies complex data retrieval and analysis tasks but also introduces a new level of precision and control over AI-generated content.
Despite its technical challenges and ethical considerations, LMQL holds the promise of making AI interactions more intuitive, accessible, and efficient for a wide range of users. As we continue to explore its capabilities and address its limitations, LMQL is poised to redefine our relationship with technology, making it an exciting area for further research and development.

References

https://arxiv.org/abs/2212.06094
https://towardsdatascience.com/lmql-sql-for-language-models-d7486d88c541
https://lmql.ai/docs/language/decoding.html



Created with ❤️ on Weights & Biases.

https://wandb.ai/mostafaibrahim17/ml-articles/reports/Unveiling-LMQL-The-Future-of-Interacting-with-Language-Models--Vmlldzo2NzgzMjcy
Made with Weights & Biases. Sign up or log in to create reports like this one.