SQL Generation in Text2SQL with TinyLlama’s LLM Fine-tuning

Introduction

In the rapidly evolving field of Natural Language Processing (NLP), one of the most intriguing challenges is converting natural language queries into SQL statements, known as Text2SQL. The ability to transform a simple English question into a complex SQL query opens up numerous possibilities in database management and data analysis. This is where TinyLlama, a variant of the large language model Llama, comes into play. In this guide, we will explore how to fine-tune TinyLlama to generate SQL statements from natural language queries.

Learning Objectives

• Understand the capabilities and versatility of the TinyLlama model in NLP tasks.
• Learn how to set up the Python environment for TinyLlama.
• Master the process of downloading and initializing the TinyLlama model.
• Gain insights into preparing and formatting datasets for fine-tuning TinyLlama.
• Comprehend the fine-tuning process of TinyLlama for Text2SQL tasks.
• Explore the generation of SQL queries from natural language using TinyLlama.
• Acquire knowledge about the practical applications and benefits of TinyLlama in data querying.
• Familiarize yourself with the key takeaway points and frequently asked questions about TinyLlama and Text2SQL.

This article was published as a part of the Data Science Blogathon.

Understanding TinyLlama

TinyLlama is a variant of the larger Llama model, tailored for tasks like text generation and question answering. By fine-tuning it on specific datasets, it can be adapted for specialized tasks like generating SQL queries from natural language.

Setting Up the Environment

The first step involves preparing the Python environment by installing the necessary libraries. To do this, we will follow the following steps:

Installation of Libraries

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip3 install llama-cpp-python 
!pip3 install huggingface-hub 
!pip3 install accelerate peft bitsandbytes transformers trl 

• CMAKE_ARGS=”-DLLAMA_CUBLAS=on”: Enables GPU acceleration using the CUBLAS library during the building of llama-cpp-python
• FORCE_CMAKE=1: Forces the execution of cmake, ensuring a fresh build
• llama-cpp-python library is necessary for interacting with the quantized models
• huggingface-hub library is needed to install the quantized models from HuggingFace
• accelerate helps to distribute the training process across multiple GPUs or machines, which can significantly speed up training time
• peft provides tools and techniques for fine-tuning large language models on custom datasets
• bitsandbytes helps to reduce the memory footprint of large language models, making it possible to train them on machines with limited memory resources
• transformers provide a wide range of pre-trained language models and tools for natural language processing tasks
• trl provides algorithms and tools for reinforcement learning, which can be used to fine-tune large language models for tasks that require decision-making and planning

These libraries are necessary for training and fine-tuning large language models, which are powerful AI models that can be used for a variety of tasks, such as text generation, question answering, and summarization.

Downloading and Initializing TinyLlama

Now we are ready. The next phase is downloading the TinyLlama model and initializing it for use.

Downloading the Model

from huggingface_hub import hf_hub_download

model_name = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"

# Define the name of the model file to download.
model_file = "tinyllama-1.1b-chat-v1.0.Q8_0.gguf"

# Download the model from the Hugging Face Hub and store the 
# path to the downloaded file in the `model_path` variable.
model_path = hf_hub_download(model_name, filename=model_file)

# Print a message indicating that the model has been downloaded.
print(f"Model downloaded to: {model_path}")

• hf_hub_download: A function from huggingface_hub that allows us to download models of different types and different quantization formats from HuggingFace, a repository containing different pretrained Large Language Models
• model_name: Name of the model on Hugging Face’s model hub. Here we will be working with the TinyLlama 1.1B GGUF model
• model_file: A specific file of the model to be downloaded. Here we choose the 8-bit quantized version of the TinyLlama 1.1B Model
• model_path: After the model has been downloaded from the HuggingFace, the path to the model is stored in this variable

After running this code, it will download the 8-bit quantized GGUF model of the TinyLlama 1.1B from the HuggingFace hub. Then the path to the model is stored in the model_path variable. Printing it will show the following result

Initializing the Model

from llama_cpp import Llama

# Initialize a `Llama` object with the downloaded model path.
llm = Llama(
    model_path=model_path,

    # Set the number of context tokens.
    n_ctx=512,

    # Set the number of threads to use.
    n_threads=8,

    # Set the number of GPU layers to work with.
    n_gpu_layers=40
)

# Print a message indicating that the Llama object has been initialized.
print("Llama object initialized successfully.")

• Llama: Class from llama_cpp library, that is worked with to initialize the model.
• model_path: It is the path to the downloaded model that we obtained a while ago
• n_ctx: This variable takes in the number of context tokens the model can handle. Here we are passing it a value of 512
• n_threads: This variable takes in the number of CPU threads for computation. The Google Colab has a 4-core CPU, hence passing it 8 threads
• n_gpu_layers: This variable takes in the number of GPU layers in which the model needs to be offloaded. The value of 40 will offload the entire TinyLlama 1.1B within the Google Colab T4 GPU

Running the code will initiate the Llama object from the downloaded model, and thus prints a message stating that the model is initiated. With this initialized model, we will be able to pass in Prompts and perform tasks like text generation, classification, and summarization. Let’s test the model by passing in some example Prompts

# Use the Llama object to generate an answer to the question.
output = llm(
    # Prompt
    "<|im_start|>user\nAre you a robot?<|im_end|>\n<|im_start|>assistant\n",

    # Set the maximum number of tokens to generate.
    max_tokens=512,

    # Set the stop sequences to indicate the end of the generated text.
    stop=["</s>"],
)

# Print the generated text.
print(output['choices'][0]['text'])

Here we pass in the Input Prompt to the llm in the format that the TinyLlama understands. We even set the max_tokens to 512 and even provided the stop sequence, so the model knows when to stop generating text. Running this has produced the following output

Testing the Vanilla TinyLlama

As we will be fine-tuning the model to generate SQL statements, why not test the model without fine-tuning itself? Before that, let’s define a function that will take our data and outputs in a format that the Large Language Model can understand. We will work with the below function

def chat_template(question, context):
    """
    Creates a chat template for the Llama model.

    Args:
        question: The question to be answered.
        context: The context information to be used for generating the answer.

    Returns:
        A string containing the chat template.
    """

    template = f"""\
    <|im_start|>user
    Given the context, generate an SQL query for the following question
    context:{context}
    question:{question}
    <|im_end|>
    <|im_start|>assistant 
    """
    # Remove any leading whitespace characters from each line in the template.
    template = "\n".join([line.lstrip() for line in template.splitlines()])
    return template

• The code defines a function called chat_template that takes two arguments: question and context.
• The function creates a chat template string that is used to instruct the Llama model on how to generate an SQL query.
• The template string includes the following information:
• A marker indicating the start of the user’s input (<|im_start|>).
• Followed by that is the user’s question.
• Then comes the context information.
• A marker indicating the end of the user’s input (<|im_end|>).
• A marker indicating the start of the assistant’s output (<|im_start|>).
• Finally, the function returns the chat template string.

Let’s test the function with the following code

question = "How many heads of the departments are older than 56 ?"
context = "CREATE TABLE head (age INTEGER)"
print(chat_template(question,context))

The output generated by the function can be seen in the below pic

So this Template that we are generating will instruct the model to create an SQL query for a given question based on the provided context. Now let’s input this to the model and check the output generated

# Use the Llama object to generate an answer to the question.
output = llm(
    chat_template(question, context),


    # Set the maximum number of tokens to generate.
    max_tokens=512,


    # Set the stop sequences to indicate the end of the generated text.
    stop=["</s>"],
)


# Print the generated text.
print(output['choices'][0]['text'])

• This code works with the llm object to generate an answer to the question
• The chat_template() function is worked with to create a chat template that instructs the model on how to generate the answer. Here we pass on the same question and context
• max_tokens: The max_tokens parameter specifies the maximum number of tokens to generate. For now, the maximum tokens the Large Language Model can output is restricted to 512 tokens
• stop: The stop parameter specifies the stop sequences that indicate the end of the generated text. It tells the Large Language Model that it needs to stop generating further tokens
• The output variable contains the generated text, which is then printed

So, when we run the code, the code first creates a Chat Template that includes the question and context information. The Chat Template is then passed to the llm object, which generates an answer based on the template. The answer is stored in the output variable. Finally, the generated answer is printed. The TinyLlama has printed the following response

Here the model did produce the correct answer at the end of the generation, but it has produced a lot of gibberish characters. Most of the text is unnecessary and not meaningful. This can be rectified through training the TinyLlama on an SQL dataset.

Preparing the Dataset for Fine-tuning

Fine-tuning requires a specialized dataset that pairs natural language questions with SQL queries. We have such a dataset in the HuggingFace Hub itself. Click Here to view the dataset. The Dataset is Open Source and, hence can be worked with for commercial purposes too. Let’s download the dataset from HuggingFace

from datasets import load_dataset, Dataset
# Define the dataset for fine-tuning
dataset_id = "b-mc2/sql-create-context"

data = load_dataset(dataset_id, split="train")
df = data.to_pandas()

• load_dataset: This function from the huggingface dataset library loads the specified dataset for training from the HuggingFace Hub. To this, we pass out the dataset_id variable and the split=Train implies that we will be only working with the train data
• The data variable is of type Dataset. We wish to convert it to pandas for easy manipulation
• to_pandas: This function from the Dataset class Converts the Dataset type into a pandas DataFrame

The dataset contains three columns, question, context, and the answer. The below pic gives us a glimpse of what the dataset looks like

Now, the TinyLlama cannot understand this, because it needs its input to be in a specific format. Hence we will take these 3 columns and create a single column that combines these columns in a format that the TinyLlama can understand. Before that, we will need to define some helper functions. 

That is we need to define a Chat Template that takes care of this formatting, that is taking in these columns and generating a formatted text that can be understood by the TinyLlama model. The function will look like the below

def chat_template_for_training(context, answer, question):
    """
    Creates a chat template for training the TinyLlama model.

    Args:
        question: The question to be answered.
        context: The context information to be used for generating the answer.'
        answer: The answer to be generated by the LLM

    Returns:
        A string containing the chat template.
    """

    template = f"""\
    <|im_start|>user
    Given the context, generate an SQL query for the following question
    context:{context}
    question:{question}
    <|im_end|>
    <|im_start|>assistant
    {answer}
    <|im_end|>
    """
    # Remove any leading whitespace characters from each line in the template.
    template = "\n".join([line.lstrip() for line in template.splitlines()])
    return template

This function is similar to the one defined earlier. The only difference is that we are evening adding the assistant’s answer here. So the TinyLlama will know what to generate if it receives this kind of input. Now we will create a new column that contains the data in this format

# Apply the chat_template_for_training function to each row in the 
# dataframe and store the result in a new "text" column.
df["text"] = df.apply(lambda x: chat_template_for_training(x["context"], 
x["answer"], x["question"]), axis=1)

# Convert the dataframe back to a Dataset object.
formatted_data = Dataset.from_pandas(df)

• The apply method applies the lambda function to each row in the dataframe
• The lambda function takes the context, answer, and question columns from each row and passes them to the chat_template_for_training function
• The chat_template_for_training function returns the formatted Chat Template string, which is then stored in the new text column, so to match the model’s expected input structure
• The Dataset.from_pandas method converts the dataframe back to a Dataset object

Let’s try printing one of the rows from the text column in the dataset and observe how the data from the 3 columns combined

print(df['text'][1])

We can see that our final dataset will look like the pic above. This data in the text column will be sent to the model for training

Loading the Model in 4-bit Quantization

Training the model as is will be difficult. With the available free resources in GPU, it will be really difficult to train the TinyLlama directly. Hence before starting the fine-tuning, we will convert the model into a 4-bit quantized format. This will let us fit the model in the free GPU in colab and will allow us to train it on the SQL data.

Let’s download the tokenizer for TinyLlama which will let us tokenize the input data

from transformers import AutoTokenizer

# Define the model to fine-tune
model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

# Load the tokenizer for the specified model.
tokenizer = AutoTokenizer.from_pretrained(model_id)


# Set the padding token to be the same as the end of sentence token.
tokenizer.pad_token = tokenizer.eos_token

• The AutoTokenizer.from_pretrained function loads the tokenizer for the specified model. Here we are downloading it for the TinyLlama
• The tokenizer.pad_token = tokenizer.eos_token line sets the padding token to be the same as the end of sentence token
• This is done to ensure that the model does not generate any additional text after the end of the input sequence

Next, we will define our quantization configuration and load the model in that specified quantized format. For that, we will work with the bitsandbytes library.

The code for this can be seen below:

from transformers import BitsAndBytesConfig, AutoModelForCausalLM

# Define the quantization configuration for memory-efficient training.
bnb_config = BitsAndBytesConfig(
    # Load the model weights in 4-bit quantized format.
    load_in_4bit=True,


    # Specify the quantization type to use for 4-bit quantization.
    bnb_4bit_quant_type="nf4",


    # Specify the data type to use for computations during training.
    bnb_4bit_compute_dtype="float16",


    # Specify whether to use double quantization for 4-bit quantization.
    bnb_4bit_use_double_quant=True
)

# Load the model from the specified model ID and apply the quantization configuration.
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

The bnb_config variable defines the quantization configuration for the BitsAndBytesConfig class. This configuration specifies how the model will be quantized for memory-efficient training.

• load_in_4bit: This parameter specifies whether to load the model weights in a 4-bit quantized format. Setting this to True can significantly reduce the memory footprint of the model
• bnb_4bit_quant_type: This parameter specifies the quantization type to use for 4-bit quantization. We go with the “nf4” (normal float 4)
• bnb_4bit_compute_dtype: This parameter specifies the data type to use for computations during training. The available options are “float16” and “float32” and we go with the “float16”
• bnb_4bit_use_double_quant: This parameter specifies whether to use double quantization for 4-bit quantization. Double quantization can further reduce the memory footprint of the model, thus we are setting it to true

Finally, we work with the AutoModelForCausalLM.from_pretrained function to download the model from the HuggingFace, along with the model name, we even give it the quantization configuration that we have just defined. The device_map=”auto” will get the device to GPU, if a GPU is being utilized

Finally, our model will be downloaded according to the quantization configuration. Along with this, we even specify some other things like the below

# Disable cache to improve training speed.
model.config.use_cache = False

# Set the temperature for pretraining to 1.
model.config.pretraining_tp = 1 

• The model.config.use_cache parameter controls whether the model uses a cache to store intermediate activations. Disabling the cache can improve training speed, especially on GPUs with limited memory
• The model.config.pretraining_tp parameter controls the temperature used for pretraining the model
• Setting the pretraining temperature to 1 means that the model will output more random text during pretraining. This can help improve the model’s ability to generate diverse and creative text

With this, we are done with loading the model part

Fine-tuning TinyLlama

Setting Up LoRA Configuration

Fine-tuning adapts the pre-trained model to the specific task of generating SQL queries. Here the fine-tuning method we will be applying is one of the Peft(Parameter Efficient Fine-Tuning) techniques called the QLoRA(Quantized Low Rank Adaption). Click here to learn more about it. With this, we only train a smaller matrix of data which will be later combined with the actual model to generate the final output. 

To fine-tune it with QLoRA, we first need to define the LoRA configuration. The below code helps in doing the same

from peft import LoraConfig

# Define the PEFT configuration.
peft_config = LoraConfig(
    # Set the rank of the LoRA projection matrix.
    r=8,

    # Set the alpha parameter for the LoRA projection matrix.
    lora_alpha=16,

    # Set the dropout rate for the LoRA projection matrix.
    lora_dropout=0.05,

    # Set the bias term to "none".
    bias="none",

    # Set the task type to "CAUSAL_LM".
    task_type="CAUSAL_LM"
)

• The peft_config variable defines the configuration for the LoRA (Low-Rank Adaptation) method, utilized for fine-tuning large language models.
• The r parameter specifies the rank of the LoRA projection matrix. This parameter controls the number of parameters used for fine-tuning. A higher rank leads to more parameters and potentially better performance, but it also increases the memory footprint of the model
• The lora_alpha parameter controls the scale of the LoRA projection matrix.
  You can use this parameter to adjust the learning rate for the fine-tuning process. For optimal results, set it to double the value of r.
• The lora_dropout parameter specifies the dropout rate for the LoRA projection matrix.
  This parameter can help prevent overfitting and enhance the model’s generalization ability.
• The bias parameter specifies whether to use a bias term in the LoRA projection matrix. Setting this to “none” implies that no bias term will be used.
• The task_type parameter specifies the type of task the model will be used for. In this case, the task type is set to “CAUSAL_LM”, indicating that the model will be used for causal language modeling.

Setting Up Training Arguments

Now, we need to set our Training Arguments. For this, we define a TrainingArguments class and pass it the following parameters

from transformers import TrainingArguments

# Define the training arguments.
training_args = TrainingArguments(
    # Set the output directory for the training run.
    output_dir="tinyllama-sqllm-v1",

    # Set the per-device training batch size.
    per_device_train_batch_size=6,

    # Set the number of gradient accumulation steps.
    gradient_accumulation_steps=2,

    # Set the optimizer to use.
    optim="paged_adamw_32bit",

    # Set the learning rate.
    learning_rate=2e-4,

    # Set the learning rate scheduler type.
    lr_scheduler_type="cosine",

    # Set the save strategy.
    save_strategy="epoch",

    # Set the logging steps.
    logging_steps=10,

    # Set the number of training epochs.
    num_train_epochs=2,

    # Set the maximum number of training steps.
    max_steps=500,

    # Enable fp16 training.
    fp16=True,
)

• The training_args variable defines the arguments for the training process
• The output_dir parameter specifies the directory where the model checkpoints and logs will be saved
• The per_device_train_batch_size parameter specifies the number of training examples that will be processed on each device per batch. Here we give the batch size a value of 6
• The gradient_accumulation_steps parameter specifies the number of batches that will be processed before the gradients are updated. This parameter can be used to reduce the memory footprint of the training process. For optimal memory usage, we go with the value of 2
• The optim parameter specifies the optimizer to use for training. It is told that the paged_adam_32bit pairs well with LoRA fine-tuning
• The learning_rate parameter specifies the learning rate for the optimizer. Here we give it a value of 2e-4
• The lr_scheduler_type parameter specifies the type of learning rate scheduler to work with and we are giving it the cosine value
• The save_strategy parameter specifies when to save model checkpoints
• The logging_steps parameter specifies the number of training steps between logging messages and we give it a value of 10
• The num_train_epochs parameter specifies the number of epochs to train the model for. We are going for a low number here which is 2
• The max_steps parameter specifies the maximum number of training steps, even here we are taking a value of 500, which is a lower number. To get a good fine-tuned model, the max_steps must exceed 1000, so the model can iterate through the entire training data
• The fp16 parameter specifies whether to use fp16 training. This can improve training speed and reduce memory usage

Creating and Running the Trainer

We are done with setting up different training arguments. Now we will be creating the trainer which will train our model on our dataset. The code for this is

from trl import SFTTrainer

# Initialize the SFTTrainer.
trainer = SFTTrainer(
    # Set the model to be trained.
    model=model,

    # Set the training dataset.
    train_dataset=formatted_data,

    # Set the PEFT configuration.
    peft_config=peft_config,

    # Set the name of the text field in the dataset.
    dataset_text_field="text",

    # Set the training arguments.
    args=training_args,

    # Set the tokenizer.
    tokenizer=tokenizer,

    # Disable packing.
    packing=False,

    # Set the maximum sequence length.
    max_seq_length=1024
)

trainer.train()

• The trainer variable initializes the SFTTrainer object, which we will work with, to train the model
• The model parameter specifies the model to be trained. Here we give our 4-bit quantized model
• The train_dataset parameter specifies the training dataset. Here we give our formatted_dataset that contains the data in a format that the model understands
• The peft_config parameter specifies the PEFT configuration. Here we give our peft config variable
• The dataset_text_field parameter specifies the name of the text field in the dataset. We have stored the Formatted Prompts in the “text” section of the data, hence we give that value to this variable
• The args parameter specifies the training arguments and we give them our training_args variable that we defined, here
• The tokenizer parameter specifies the tokenizer
• The max_seq_length parameter specifies the maximum sequence length and we give it a value of 1024

Finally the trainer.train() will start training for 500 steps. This should take around 8 to 9 minutes in the T4 GPU provided by the free colab. After the training, a file will be available that contains our trained PEFT model

Loading the Trained Model

What we have trained earlier is a PEFT model, that is a small number of parameters. These parameters themselves cannot be worked with to generate text. We need to combine this peft model with the actual model to start inferencing the new model

from peft import AutoPeftModelForCausalLM, PeftModel

# Load the pre-trained model.
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16, 
    load_in_8bit=False, 
    device_map="auto",  
    trust_remote_code=True 
)

# Load the PEFT model from a checkpoint.
model_path = "/content/tinyllama-sqllm-v1/checkpoint-500"
peft_model = PeftModel.from_pretrained(model, model_path, from_transformers=True, device_map="auto")

# Wrap the model with the PEFT model.
model = peft_model.merge_and_unload()

• The model variable loads the pre-trained model from the specified model ID
• The torch_dtype parameter specifies the data type to use for training. fp16 is used to reduce memory usage
• The load_in_8bit parameter specifies whether to load the model in an 8-bit quantized format, to which we provide a False
• The device_map parameter automatically chooses the available device (CPU or GPU)
• The trust_remote_code parameter allows the model to load code from a remote server
• The peft_model variable loads the PEFT model from a checkpoint

PeftModel.from_pretrained function loads the PeftModel object from the pre-trained model checkpoint

• model: This variable refers to the pre-trained causal language model loaded earlier
• model_path: It is the path to our trained model
• from_transformers=True: This option specifies that the model is being loaded from a Hugging Face Transformers checkpoint
• device_map=”auto”: This option automatically chooses the available device (CPU or GPU) to work with
• peft_model.merge_and_unload(): This line merges the pre-trained model with the existing PeftModel object and unloads the pre-trained model from memory

Overall, the code snippet demonstrates how to use the peft library to load a pre-trained model and merge it with an existing PeftModel object. Now we can infer this model, which has been merged with the PeftModel that has been trained on the SQL data

Generating SQL Queries

Post training, TinyLlama should be able to convert natural language questions into SQL queries. Let’s test this with an example

# Prepare the Prompt.
question = "How many heads of the departments are older than 56 ?"
context = "CREATE TABLE head (age INTEGER)"
prompt = chat_template(question,context)

# Encode the prompt.
inputs = tokenizer(prompt, return_tensors="pt").to('cuda')

# Generate the output.
output = model.generate(**inputs, max_new_tokens=512)

# Decode the output.
text = tokenizer.decode(output[0], skip_special_tokens=True)

# Print the generated SQL query.
print(text)

Encode the Prompt

• tokenizer: This object converts the prompt text into a format that the language model can process
• return_tensors=”pt”: This option specifies that the output should be a PyTorch tensor
• to(‘cuda’): This line moves the tensor to the GPU (if available) for faster processing

Generate the output

• model: This variable refers to our merged model i.e. pre-trained model combined with peft
• **inputs: This unpacks the inputs dictionary and passes it to the model
• max_new_tokens=512: This tells the maximum number of new tokens the model should generate

Decode the output

• tokenizer.decode(output): This line converts the model’s output (a sequence of tokens) back into human-readable text

The output generated from running the model can be seen below

We can see that the model has followed our Prompt. Initially before training, the model had generated some unwanted words. But now after fine-tuning for just 500 epochs, we were able to make the model generate model clear and concise answers. This way we can train the model for a higher number of epochs to make it more robust and then the fine-tuned TinyLlama will be able to answer complex tasks

Conclusion

Fine-tuning TinyLlama for the Text2SQL task is a significant step towards making data querying more intuitive and accessible. By transforming natural language into SQL queries, it bridges the gap between complex database languages and user-friendly interfaces. This fine-tuning process illustrates the model’s adaptability and the potential of AI in enhancing data-driven decision-making.

The key takeaways from this guide include

• TinyLlama, a variant of the Llama model, is adept at handling various NLP tasks, showcasing its flexibility and utility in different domains.
• Fine-tuning TinyLlama simplifies the conversion of natural language queries into SQL statements, making database interactions more user-friendly.
• Setting up the environment for TinyLlama involves straightforward installation of necessary Python libraries, making it accessible for beginners.
• The use of hf_hub_download from the huggingface_hub library offers a seamless and efficient way to download pre-trained models like TinyLlama.
• TinyLlama can be initialized with different parameters like context tokens, threads, and GPU layers, allowing customization based on computational resources and requirements.
• The model can be fine-tuned on specialized datasets, demonstrating its adaptability to different data structures and tasks.
• The TrainingArguments class and SFTTrainer offer flexible and configurable training options, catering to various training needs and conditions.

Frequently Asked Questions

The media shown in this article is not owned by Analytics Vidhya and is used at the Author’s discretion.