Enhancing Algorithmic Trading with Neuro-Symbolic AI: A Hybrid Approach for Smarter Market Predictions

 

Introduction to Neuro-Symbolic AI

Neuro-Symbolic AI is an advanced paradigm that combines neural networks (deep learning) with symbolic reasoning to enhance decision-making, interpretability, and generalization. While neural models excel at pattern recognition from unstructured data, symbolic AI uses logic-based rules to perform reasoning and inference. The integration of these two approaches results in more robust, explainable, and data-efficient AI systems.

Use of Neuro-Symbolic AI in Algorithmic Trading

In algorithmic trading, Neuro-Symbolic AI plays a crucial role in improving market predictions and trade execution by:

• Combining deep learning (e.g., Transformer-based forecasting) with symbolic reasoning (e.g., sentiment analysis, volatility rules).
• Adjusting price forecasts dynamically based on real-time sentiment analysis of news articles.
• Using logic-driven volatility factors to refine predictions and mitigate market noise.
• Enhancing risk management by integrating rule-based adjustments to model-driven outputs.

Summary of the Code

The provided code implements an algorithmic trading model enhanced with Neuro-Symbolic AI techniques:

1. Sentiment Analysis Using Llama3.1: Extracts sentiment scores for two stocks based on local news data.
2. Stock Data Generation: Simulates stock prices using a Multivariate Gaussian distribution.
3. i-Transformer Model for Forecasting: A deep learning model based on a Transformer encoder predicts future stock prices using a sliding window of past prices.
4. Neuro-Symbolic Adjustment: Adjusts the model’s predictions using sentiment scores and a volatility factor.
5. Simulated Trading Decisions: Iterates through test data, predicting stock prices and applying symbolic adjustments to improve trading decisions.

This hybrid approach enhances algorithmic trading by incorporating both data-driven (neural) and logic-driven (symbolic) methodologies, leading to more accurate and interpretable market predictions.

Code: Algorithmic Trading using Neuro-Symbolic AI (a toy example):

 import numpy as np

import pandas as pd
import tensorflow as tf
import re
# from tensorflow import keras
from keras.models import Model
from keras.layers import Input, Dense, Dropout, MultiHeadAttention, LayerNormalization, \
    GlobalAveragePooling1D, Conv1D, Add
import json
import requests
from groq import Groq

client = Groq(
    api_key='PLEASE USE YOUR OWN API KEY',
)
stock1 = "Stock_A"
stock2 = "Stock_B"
# Step 1: Fetch News from Local Storage and Use Llama 3.1 for Sentiment Analysis
def fetch_news_from_local(stock_name):
    with open(stock_name, 'r') as file:
        news_data = json.load(file)
    return news_data  # Assume the JSON file contains text news data
context1 = str(fetch_news_from_local("news_data_Stock_A.json")) + ":\n"
question1 = "calculate the sentiment score in the range [-1.0 to +1.0] for " + stock1 +"return only number nothing else"
context2 = str(fetch_news_from_local("news_data_Stock_B.json")) + ":\n"
question2 = "calculate the sentiment score in the range [-1.0 to +1.0] for " + stock2 +"return only number nothing else"
# Combine context and question
input_prompt1 = f"{context1}\nQuestion: {question1}\nAnswer:"
input_prompt2 = f"{context2}\nQuestion: {question2}\nAnswer:"
# Step 2: Calculate the sentiment
def extract_sentiment_score(input_prompt):
    chat_completion = client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": input_prompt,
            }
        ],
        model="llama-3.1-8b-instant",
        # model="llama-3.1-70b-versatile",
        # model = "llama3-70b-8192"
    )
    response = chat_completion.choices[0].message.content

    # Use regex to extract the first numerical value from the response
    match = re.search(r'[-+]?\d*\.\d+|\d+', response)  # Extracts numbers including negatives & decimals
    if match:
        return float(match.group())  # Convert extracted number to float
    else:
        raise ValueError(f"Could not extract a valid sentiment score from response: {response}")

llm_output1 = extract_sentiment_score(input_prompt1)
# llm_output1 = float(llm_output1)
print(llm_output1)
llm_output2 = extract_sentiment_score(input_prompt2)
# llm_output2 = float(llm_output2)
print(llm_output2)

# Step 3: Generate Synthetic Stock Data (Multivariate Gaussian)
def generate_stock_data(days=180, mean=[100, 200], cov=[[1, 0.5], [0.5, 1]]):
    np.random.seed(42)
    stock_data = np.random.multivariate_normal(mean, cov, size=days)
    df = pd.DataFrame(stock_data, columns=['Stock_A', 'Stock_B'])
    df['Date'] = pd.date_range(start='2024-01-01', periods=days, freq='D')
    return df

stock_df = generate_stock_data()

# Step 4: Prepare Data for i-Transformer
def prepare_data(df, window=10):
    data = df[['Stock_A', 'Stock_B']].values
    X, y = [], []
    for i in range(len(data) - window):
        X.append(data[i:i + window])
        y.append(data[i + window])
    return np.array(X), np.array(y)


X, y = prepare_data(stock_df)
train_size = int(0.8 * len(X))
X_train, X_test, y_train, y_test = X[:train_size], X[train_size:], y[:train_size], y[train_size:]

print("X_train => ",X_train)
print("X_test => ",X_test)

def i_transformer_encoder(inputs, head_size=64, num_heads=4, ff_dim=128, dropout=0.1):
    # Apply Conv1D layer to adjust the shape
    x = Conv1D(filters=head_size, kernel_size=1, activation='relu')(inputs)

    # Apply MultiHeadAttention
    attn_output = MultiHeadAttention(key_dim=head_size, num_heads=num_heads)(x, x)
    attn_output = Dropout(dropout)(attn_output)
    attn_output = LayerNormalization(epsilon=1e-6)(attn_output)

    # Ensure that attention output has the same shape as 'x' before addition
    attn_output = Dense(head_size)(attn_output)

    # Residual connection
    res = Add()([x, attn_output])

    # Feed-forward layers
    x = Dense(ff_dim, activation="relu")(res)
    x = Dropout(dropout)(x)
    x = Dense(head_size)(x)
    x = LayerNormalization(epsilon=1e-6)(x)

    return Add()([x, res])

input_shape = (X.shape[1], X.shape[2])
inputs = Input(shape=input_shape)
x = i_transformer_encoder(inputs)
x = GlobalAveragePooling1D()(x)
x = Dense(2)(x)

model = Model(inputs, x)
model.compile(optimizer='adam', loss='mse')
model.fit(X_train, y_train, epochs=20, batch_size=16, validation_data=(X_test, y_test))

# Step 6: Advanced Neuro-Symbolic AI Adjustment (Updated)
def neuro_symbolic_adjustment(forecast, input_prompt):
    # Analyze sentiment for both stocks
    sentiment_1 = extract_sentiment_score(input_prompt)
    # Compute volatility factors for both stocks
    volatility_factor_1 = np.std([np.random.uniform(-0.05, 0.05) for _ in range(10)])  # Simulated volatility for Stock 1

    symbolic_adjustment = sentiment_1 * 0.05 + volatility_factor_1  # Adjust forecast with both factors

    # Adjust forecast values
    adjusted_forecast = forecast * (1 + symbolic_adjustment)
    return max(0, adjusted_forecast)  # Ensure price does not go negative

# Step 7: Simulate Trading Decisions
import csv

# Step 7: Simulate Trading Decisions & Save to CSV
results = []

for i in range(len(y_test)):
    forecast = model.predict(X_test[i:i + 1])[0]

    # Raw Predictions
    raw_forecast_A = forecast[0]
    raw_forecast_B = forecast[1]

    # Adjusted Predictions using Neuro-Symbolic AI
    adjusted_forecast_A = neuro_symbolic_adjustment(raw_forecast_A, input_prompt1)
    adjusted_forecast_B = neuro_symbolic_adjustment(raw_forecast_B, input_prompt2)

    # Calculate the percentage change due to neuro-symbolic AI
    change_A = ((adjusted_forecast_A - raw_forecast_A) / raw_forecast_A) * 100
    change_B = ((adjusted_forecast_B - raw_forecast_B) / raw_forecast_B) * 100

    # Print results
    print(f"Day {i + 1}: Stock_A Raw: {raw_forecast_A:.2f}, Adjusted: {adjusted_forecast_A:.2f} (Δ{change_A:.2f}%)")
    print(f"        Stock_B Raw: {raw_forecast_B:.2f}, Adjusted: {adjusted_forecast_B:.2f} (Δ{change_B:.2f}%)")

    # Append results to list for saving
    results.append([i + 1, raw_forecast_A, adjusted_forecast_A, change_A, raw_forecast_B, adjusted_forecast_B, change_B])

# Save results to CSV
csv_filename = "trading_predictions.csv"
with open(csv_filename, mode="w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["Day", "Stock_A_Raw", "Stock_A_Adjusted", "Stock_A_Change(%)",
                     "Stock_B_Raw", "Stock_B_Adjusted", "Stock_B_Change(%)"])
    writer.writerows(results)

print(f"\nPredictions saved to {csv_filename}")

Code: Dummy News Data Generator.

import json


def generate_dummy_news(stock_name):
    """
    Generates dummy news data for a given stock and saves it as a JSON file.
    :param stock_name: Name of the stock for which dummy news data is generated.
    """
    news_samples = {
        "Stock_A": [
            "Stock_A sees a surge in trading volume due to positive earnings report.",
            "Analysts predict continued growth for Stock_A in the coming quarter.",
            "Stock_A's new product launch receives strong market approval."
        ],
        "Stock_B": [
            "Stock_B faces regulatory scrutiny leading to a drop in stock value.",
            "Market experts suggest caution as Stock_B struggles with supply chain issues.",
            "Stock_B's latest acquisition expected to boost long-term profits."
        ]
    }

    with open(f'news_data_{stock_name}.json', 'w') as file:
        json.dump(news_samples.get(stock_name, []), file, indent=4)
    print(f"Dummy news data for {stock_name} saved.")


# Generate dummy news for Stock_A and Stock_B
generate_dummy_news("Stock_A")
generate_dummy_news("Stock_B")

Reference:

Besold, T. R., et al. (2017). Neural-Symbolic Learning and Reasoning: A Survey and Interpretation.
Garcez, A. S., & Lamb, L. C. (2020). Neurosymbolic AI: The 3rd Wave.
Bengio, Y., et al. (2021). The Neuro-Symbolic Concept Learner.
Mitchell, M. (2019). Artificial Intelligence: A Guide to Intelligent Systems.

Finetune Large Language Models with DoRA (Weight-Decomposed Low-Rank Adaptation)

 

Introduction.

The DoRA (Weight-Decomposed Low-Rank Adaptation) algorithm offers an advanced approach to fine-tuning Large Language Models (LLMs) by decomposing weight matrices into magnitude and direction components. Traditional methods like Low-Rank Adaptation (LoRA) improve parameter efficiency but often face performance and stability trade-offs. DoRA addresses these issues by leveraging the Frobenius norm to separate the weight matrix into a stable magnitude and a fine-tuned direction. This decomposition ensures efficient learning while maintaining model expressiveness and stability. Key advantages of DoRA include enhanced parameter efficiency, improved generalization, faster adaptation to new tasks, and minimal inference overhead.

Key Points:

• Decomposes weights into magnitude and direction.
• Enhances parameter efficiency without compromising performance.
• Improves training stability and generalization.
• Facilitates faster adaptation to new tasks.
• Maintains efficient inference with minimal overhead.

Video Tutorial.

Code: Finetune Large Language Models with DoRA (Train).

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model
from datasets import Dataset
import transformers
# pip install peft
# Sample QA Data
data = {
    'question': [
        "What is the capital of France?",
        "Who painted the Mona Lisa?",
        "What is the tallest mountain in the world?",
        "When did World War II end?",
        "Who wrote the play 'Romeo and Juliet'?",
        "What is the chemical symbol for gold?"
    ],
    'context': [
        "Paris is the capital and most populous city of France.",
        "The Mona Lisa is a half-length portrait painting by Italian Renaissance artist Leonardo da Vinci.",
        "Mount Everest is Earth's highest mountain above sea level, located in the Mahalangur Himal sub-range of the Himalayas.",
        "World War II (WWII or WW2), also known as the Second World War, was a global war that lasted from 1939 to 1945.",
        "Romeo and Juliet is a tragedy written by William Shakespeare early in his career about two young star-crossed lovers whose deaths ultimately reconcile their feuding families.",
        "Gold is a chemical element with the symbol Au and atomic number 79. In its purest form, it is a bright, slightly reddish yellow, dense, soft, malleable, and ductile metal."
    ],
    'answer': [
        "Paris",
        "Leonardo da Vinci",
        "Mount Everest",
        "1945",
        "William Shakespeare",
        "Au"
    ]
}
dataset = Dataset.from_dict(data)

# Load Llama Model and Tokenizer
tokenizer = AutoTokenizer.from_pretrained("D:\\OLLAMA_MODELS\\meta-llama\\Meta-Llama-3-8B-Instruct")
model = AutoModelForCausalLM.from_pretrained("D:\\OLLAMA_MODELS\\meta-llama\\Meta-Llama-3-8B-Instruct")
# Ensure padding token is set
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({'pad_token': '[PAD]'})
# Configure LoRA
peft_config = LoraConfig(
    r=8,
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    use_dora =True
)

# Create PEFT Model
model = get_peft_model(model, peft_config)

# Preprocess Data
def generate_prompt(data_point):
    return f"""[INST] {data_point["question"]} [/INST] {data_point["context"]} {data_point["answer"]} [/INST]"""

dataset = dataset.map(lambda data_point: {"text": generate_prompt(data_point)})

# Tokenize Data
def tokenize(prompt):
    result = tokenizer(prompt["text"])
    return {
        "input_ids": result["input_ids"],
        "attention_mask": result["attention_mask"],
    }
tokenized_dataset = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)

# Training Arguments (Optimized for CPU)
training_args = TrainingArguments(
    per_device_train_batch_size=1,  # Very small batch size for CPU
    gradient_accumulation_steps=8,  # Accumulate gradients over multiple steps
    num_train_epochs=3,
    learning_rate=1e-4,  # Smaller learning rate for CPU
    logging_steps=10,
    output_dir="./llama-3-finetuned-qa-cpu",
)

# Create Trainer
trainer = Trainer(
    model=model,
    train_dataset=tokenized_dataset,
    args=training_args,
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

# Fine-tune!
model.config.use_cache = False
trainer.train()

# Save the Fine-tuned Model
model.save_pretrained("./llama-3-finetuned-qa-cpu")

Code: Finetune Large Language Models with DoRA (Test).

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig

# Load Fine-Tuned Model and Tokenizer
model_path = "E:\\Niraj_Work\\DL_Projects\\llm_projects\\llm_advance_1\\llama-3-finetuned-qa-cpu"  # Path to your saved model
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)

# Ensure Model is on CPU
device = torch.device("cpu")
model.to(device)
if tokenizer.pad_token is None:
    # tokenizer.add_special_tokens({'pad_token': '[PAD]'})
    tokenizer.pad_token = tokenizer.eos_token
# Load Your Question-Answering Dataset (Replace with your dataset)
# Assuming you have a list of dictionaries, each with 'question', 'context', and 'answer' keys
eval_data = [
    {"question": "What is the capital of France?", "context": "Paris is the capital and most populous city of France.", "answer": "Paris"},
    {"question": "Who painted the Mona Lisa?", "context": "The Mona Lisa is a half-length portrait painting by Italian Renaissance artist Leonardo da Vinci.", "answer": "Leonardo da Vinci"},
]

# Function to generate the prompt
def generate_prompt(data_point):
    return f"""[INST] {data_point["question"]} [/INST] {data_point["context"]} {data_point["answer"]} [/INST]"""


# Test the Model
for data_point in eval_data:
    input_text = generate_prompt(data_point)
    input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to(device)  # Move input to CPU

    # Generate Answer
    generation_output = model.generate(
        input_ids=input_ids,
        max_new_tokens=50,  # Adjust as needed
        num_beams=1,  # You can try increasing num_beams if you have enough memory
        early_stopping=True,
    )

    # Extract and Print Answer
    generated_answer = tokenizer.decode(generation_output[0])
    print(f"Question: {data_point['question']}")
    print(f"Generated Answer: {generated_answer.split('[/INST]')[-2].strip()}")
    print(f"Actual Answer: {data_point['answer']}")

Reference.

1. Liu, Shih-Yang, Chien-Yi Wang, Hongxu Yin, Pavlo Molchanov, Yu-Chiang Frank Wang, Kwang-Ting Cheng, and Min-Hung Chen. "Dora: Weight-decomposed low-rank adaptation." arXiv preprint arXiv:2402.09353 (2024).
2. https://huggingface.co/papers/2402.09353
3. https://www.nirajai.com/home/llm

LoRA, QLoRA and Fine-tuning large language models (LLMs)

 Introduction.

Fine-tuning large language models (LLMs) is a common practice to adapt them for specific tasks, but it can be computationally expensive. 

LoRA (Low-Rank Adaptation) is a technique that makes this process more efficient by introducing small adapter modules to the model. These adapters capture task-specific knowledge without modifying the original model's parameters, significantly reducing the number of trainable parameters.

QLoRA (Quantized LoRA) takes this further by combining LoRA with quantization, a process that reduces the precision of the model's weights. This decreases the model's memory footprint, making it possible to fine-tune LLMs on consumer-grade hardware. Both LoRA and QLoRA offer a powerful way to customize large language models for specific use cases while minimizing computational requirements and ensuring efficient model deployment.

Video Tutorial on LoRA.

Video Tutorial on QLoRA.

Video Tutorial on Fine-tuning Large Language Model (LLMs).

Fine-tuning Large Language Model (LLMs) - Without LORA/QLORA

Webpage Link: https://www.quantacosmos.com/2024/06/fine-tune-pretrained-large-language.html

Code: Fine-tuning Large Language Model (LLMs)- with LoRA (Training).

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model
from datasets import Dataset
import transformers
# pip install peft
# Sample QA Data
data = {
    'question': [
        "What is the capital of France?",
        "Who painted the Mona Lisa?",
        "What is the tallest mountain in the world?",
        "When did World War II end?",
        "Who wrote the play 'Romeo and Juliet'?",
        "What is the chemical symbol for gold?"
    ],
    'context': [
        "Paris is the capital and most populous city of France.",
        "The Mona Lisa is a half-length portrait painting by Italian Renaissance artist Leonardo da Vinci.",
        "Mount Everest is Earth's highest mountain above sea level, located in the Mahalangur Himal sub-range of the Himalayas.",
        "World War II (WWII or WW2), also known as the Second World War, was a global war that lasted from 1939 to 1945.",
        "Romeo and Juliet is a tragedy written by William Shakespeare early in his career about two young star-crossed lovers whose deaths ultimately reconcile their feuding families.",
        "Gold is a chemical element with the symbol Au and atomic number 79. In its purest form, it is a bright, slightly reddish yellow, dense, soft, malleable, and ductile metal."
    ],
    'answer': [
        "Paris",
        "Leonardo da Vinci",
        "Mount Everest",
        "1945",
        "William Shakespeare",
        "Au"
    ]
}
dataset = Dataset.from_dict(data)

# Load Llama Model and Tokenizer
tokenizer = AutoTokenizer.from_pretrained("D:\\OLLAMA_MODELS\\meta-llama\\Meta-Llama-3-8B-Instruct")
model = AutoModelForCausalLM.from_pretrained("D:\\OLLAMA_MODELS\\meta-llama\\Meta-Llama-3-8B-Instruct")
# Ensure padding token is set
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({'pad_token': '[PAD]'})
# Configure LoRA
peft_config = LoraConfig(
    r=8,
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# Create PEFT Model
model = get_peft_model(model, peft_config)

# Preprocess Data
def generate_prompt(data_point):
    return f"""[INST] {data_point["question"]} [/INST] {data_point["context"]} {data_point["answer"]} [/INST]"""

dataset = dataset.map(lambda data_point: {"text": generate_prompt(data_point)})

# Tokenize Data
def tokenize(prompt):
    result = tokenizer(prompt["text"])
    return {
        "input_ids": result["input_ids"],
        "attention_mask": result["attention_mask"],
    }
tokenized_dataset = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)

# Training Arguments (Optimized for CPU)
training_args = TrainingArguments(
    per_device_train_batch_size=1,  # Very small batch size for CPU
    gradient_accumulation_steps=8,  # Accumulate gradients over multiple steps
    num_train_epochs=3,
    learning_rate=1e-4,  # Smaller learning rate for CPU
    logging_steps=10,
    output_dir="./llama-3-finetuned-qa-cpu",
)

# Create Trainer
trainer = Trainer(
    model=model,
    train_dataset=tokenized_dataset,
    args=training_args,
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

# Fine-tune!
model.config.use_cache = False
trainer.train()

# Save the Fine-tuned Model
model.save_pretrained("./llama-3-finetuned-qa-cpu")

Code: Fine-tuning Large Language Model (LLMs)- with LoRA (Test)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig

# Load Fine-Tuned Model and Tokenizer
model_path = "E:\\Niraj_Work\\DL_Projects\\llm_projects\\llm_advance_1\\llama-3-finetuned-qa-cpu"  # Path to your saved model
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)

# Ensure Model is on CPU
device = torch.device("cpu")
model.to(device)
if tokenizer.pad_token is None:
    # tokenizer.add_special_tokens({'pad_token': '[PAD]'})
    tokenizer.pad_token = tokenizer.eos_token
# Load Your Question-Answering Dataset (Replace with your dataset)
# Assuming you have a list of dictionaries, each with 'question', 'context', and 'answer' keys
eval_data = [
    {"question": "What is the capital of France?", "context": "Paris is the capital and most populous city of France.", "answer": "Paris"},
    {"question": "Who painted the Mona Lisa?", "context": "The Mona Lisa is a half-length portrait painting by Italian Renaissance artist Leonardo da Vinci.", "answer": "Leonardo da Vinci"},
]

# Function to generate the prompt
def generate_prompt(data_point):
    return f"""[INST] {data_point["question"]} [/INST] {data_point["context"]} {data_point["answer"]} [/INST]"""


# Test the Model
for data_point in eval_data:
    input_text = generate_prompt(data_point)
    input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to(device)  # Move input to CPU

    # Generate Answer
    generation_output = model.generate(
        input_ids=input_ids,
        max_new_tokens=50,  # Adjust as needed
        num_beams=1,  # You can try increasing num_beams if you have enough memory
        early_stopping=True,
    )

    # Extract and Print Answer
    generated_answer = tokenizer.decode(generation_output[0])
    print(f"Question: {data_point['question']}")
    print(f"Generated Answer: {generated_answer.split('[/INST]')[-2].strip()}")
    print(f"Actual Answer: {data_point['answer']}")

Reference.

1. Hu, Edward J., Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. "Lora: Low-rank adaptation of large language models." arXiv preprint arXiv:2106.09685 (2021).
2. Dettmers, Tim, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. "Qlora: Efficient finetuning of quantized llms." Advances in Neural Information Processing Systems 36 (2024).

Fine Tune Pretrained Large Language Models for Local use

 

Fine Tuning Pretrained LLM's

Fine-tuning is a technique used to improve the performance of pre-trained Large Language Models (LLMs) on specific tasks or domains. By fine-tuning, the LLM learns the nuances and specific things related to our domain, improving its performance on that particular task.

Benefits of Fine-Tuning:

• Increased Accuracy and Relevance: The LLM becomes more accurate and relevant to your specific needs by specializing in a particular domain.
• Efficiency: Fine-tuning a pre-trained model is often faster and requires less computational power compared to training a new LLM from scratch.
• Leveraging Existing Knowledge: The LLM retains its general language understanding from pre-training, which serves as a foundation for domain-specific learning.

Video Tutorial on Fine Tuning Pretrained Large Language Models.

Training: Fine Tuning Pretrained Large Language Models

import pandas as pd
from datasets import Dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, DataCollatorWithPadding
import torch

# Sample data creation
data = {
    "text": [
        "I loved this movie! The acting was great and the story was gripping.",
        "This was a terrible movie. The plot was predictable and the characters were uninteresting.",
        "The film was fantastic! I highly recommend it.",
        "I did not enjoy this movie at all. It was too slow and boring.",
        "The special effects were amazing, but the storyline was weak.",
        "An excellent film with a touching story.",
        "The movie was a masterpiece with brilliant performances.",
        "I found the movie to be dull and uninspiring.",
        "The direction and cinematography were outstanding.",
        "The movie was overly long and felt drawn out.",
        "An absolutely thrilling and engaging film.",
        "The characters were flat and the dialogue was poor.",
        "A wonderful film experience with a powerful message.",
        "The plot was confusing and hard to follow.",
        "One of the best movies I have seen this year!",
        "The acting was subpar and the story lacked depth.",
        "A heartwarming tale with excellent performances.",
        "The movie was full of clichés and very predictable.",
        "An emotional rollercoaster with a satisfying ending.",
        "I couldn't connect with the characters or the story.",
    ],
    "sentiment": [
        "positive", "negative", "positive", "negative", "negative",
        "positive", "positive", "negative", "positive", "negative",
        "positive", "negative", "positive", "negative", "positive",
        "negative", "positive", "negative", "positive", "negative"
    ]
}

df = pd.DataFrame(data)
train_df, val_df = df[:int(len(df)*0.8)], df[int(len(df)*0.8):]

train_dataset = Dataset.from_pandas(train_df)
val_dataset = Dataset.from_pandas(val_df)

model_name = "E:\\Niraj_Work\\LLM_Models\\Meta-Llama-3-8B-Instruct"  # Replace with the actual LLaMA3 model if available
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Ensure padding token is set
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({'pad_token': '[PAD]'})

def tokenize_function(examples):
    return tokenizer(examples['text'], truncation=True, padding='max_length', max_length=128)

tokenized_train = train_dataset.map(tokenize_function, batched=True)
tokenized_val = val_dataset.map(tokenize_function, batched=True)

# Mapping sentiment to numerical labels
def map_labels(example):
    example['label'] = 1 if example['sentiment'] == 'positive' else 0
    return example

tokenized_train = tokenized_train.map(map_labels)
tokenized_val = tokenized_val.map(map_labels)

# Remove the original 'sentiment' column
tokenized_train = tokenized_train.remove_columns(['sentiment'])
tokenized_val = tokenized_val.remove_columns(['sentiment'])

# Update model config if padding token is added
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
model.resize_token_embeddings(len(tokenizer))

# Define Data Collator with Padding
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

# Training arguments
training_args = TrainingArguments(
    output_dir='E:\\Niraj_Work\\LLM_Models\\Meta-Llama-3-8B-Instruct_updated',
    evaluation_strategy='epoch',
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
)

# Define the Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train,
    eval_dataset=tokenized_val,
    tokenizer=tokenizer,
    data_collator=data_collator,
)

# Fine-tune the model
trainer.train()

# Save the model and tokenizer
# model.save_pretrained('./fine-tuned-llama')
# tokenizer.save_pretrained('./fine-tuned-llama')

Test: Fine Tuning Pretrained Large Language Models

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import pandas as pd

# Load the fine-tuned model and tokenizer
model_name = 'E:\\Niraj_Work\\LLM_Models\\Meta-Llama-3-8B-Instruct_updated'  # Directory where the model and tokenizer are saved
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

# Sample test data
test_data = {
    "text": [
        "This movie was fantastic! I really enjoyed it.",
        "I didn't like this movie at all. It was very boring.",
        # Add more test examples as needed
    ]
}
# Create a DataFrame for test data
test_df = pd.DataFrame(test_data)
# Ensure padding token is set
if tokenizer.pad_token is None:
    # tokenizer.add_special_tokens({'pad_token': '[PAD]'})
    tokenizer.pad_token = tokenizer.eos_token
# Tokenize the test data
def tokenize_function(examples):
    return tokenizer(examples['text'], truncation=True, padding='max_length', max_length=128, return_tensors='pt')

tokenized_test = test_df['text'].apply(lambda x: tokenize_function({'text': [x]}))

# Predict function
def predict(text_list):
    model.eval()
    predictions = []
    with torch.no_grad():
        for text in text_list:
            inputs = tokenize_function({'text': [text]})
            input_ids = inputs['input_ids'].to(model.device)
            attention_mask = inputs['attention_mask'].to(model.device)
            outputs = model(input_ids, attention_mask=attention_mask)
            logits = outputs.logits
            predicted_class_id = torch.argmax(logits, dim=1).item()
            predictions.append(predicted_class_id)
    return predictions

# Convert the predictions to sentiment labels
sentiment_map = {0: 'negative', 1: 'positive'}
predicted_labels = predict(test_data['text'])

# Map numerical labels to sentiment labels
predicted_sentiments = [sentiment_map[label] for label in predicted_labels]

# Display the results
for text, sentiment in zip(test_data['text'], predicted_sentiments):
    print(f'Text: {text}\nPredicted Sentiment: {sentiment}\n')

Test Output:

C:\Users\admin\AppData\Local\Programs\Python\Python310\python.exe E:/Niraj_Work/DL_Projects/llm_projects/llm_advance_1/test_abcd.py
Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.
Loading checkpoint shards: 100%|██████████| 4/4 [18:59<00:00, 284.85s/it]
Some weights of LlamaForSequenceClassification were not initialized from the model checkpoint at E:\Niraj_Work\LLM_Models\Meta-Llama-3-8B-Instruct_updated and are newly initialized: ['score.weight']
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
Text: This movie was fantastic! I really enjoyed it.
Predicted Sentiment: positive

Text: I didn't like this movie at all. It was very boring.
Predicted Sentiment: negative


Process finished with exit code 0

One-Shot LLM + RAG with Knowledge Graph

 Background.

One-Shot. 

One-shot learning refers to the model's ability to perform a task by seeing only one example. The model uses this single example as a reference to understand the task better and generate the appropriate response.

Application in LLM RAG.

• Single Example Provided: The prompt includes a specific example that demonstrates how the task should be performed.
• Learning from Example: The model uses this single example to learn how to apply the task's requirements to new inputs.

Video Tutorial.

Code.

import ollama
import chromadb

documents = [
  "Bears are carnivoran mammals of the family Ursidae.",
  "They are classified as caniforms, or doglike carnivorans.",
  "Although only eight species of bears are extant, they are widespread, appearing in a wide variety of habitats throughout most of the Northern Hemisphere and partially in the Southern Hemisphere.",
  "Bears are found on the continents of North America, South America, and Eurasia.",
  "Common characteristics of modern bears include large bodies with stocky legs, long snouts, small rounded ears, shaggy hair, plantigrade paws with five nonretractile claws, and short tails.",
  "With the exception of courting individuals and mothers with their young, bears are typically solitary animals.",
  "They may be diurnal or nocturnal and have an excellent sense of smell.",
  "Despite their heavy build and awkward gait, they are adept runners, climbers, and swimmers.",
  "Bears use shelters, such as caves and logs, as their dens; most species occupy their dens during the winter for a long period of hibernation, up to 100 days.",
]
Kg_triplets = [["Bears", "are", "carnivoran mammals"],
["Bears", "belong to", "family Ursidae"],
["Bears", "are classified as", "caniforms"],
["Caniforms", "are", "doglike carnivorans"],
["Bears", "have", "eight species"],
["Bears", "are", "widespread"],
["Bears", "appear in", "a wide variety of habitats"],
["Bears", "are found in", "Northern Hemisphere"],
["Bears", "are partially found in", "Southern Hemisphere"],
["Bears", "are found on", "North America"],
["Bears", "are found on", "South America"],
["Bears", "are found on", "Eurasia"],
["Modern bears", "have", "large bodies"],
["Modern bears", "have", "stocky legs"],
["Modern bears", "have", "long snouts"],
["Modern bears", "have", "small rounded ears"],
["Modern bears", "have", "shaggy hair"],
["Modern bears", "have", "plantigrade paws with five nonretractile claws"],
["Modern bears", "have", "short tails"],
["Bears", "are typically", "solitary animals"],
["Bears", "can be", "diurnal"],
["Bears", "can be", "nocturnal"],
["Bears", "have", "an excellent sense of smell"],
["Bears", "are", "adept runners"],
["Bears", "are", "adept climbers"],
["Bears", "are", "adept swimmers"],
["Bears", "use", "shelters"],
["Shelters", "include", "caves"],
["Shelters", "include", "logs"],
["Bears", "use", "shelters as dens"],
["Most species", "occupy", "dens during winter"],
["Bears", "hibernate for", "up to 100 days"],]
# Convert the triplets to text
def triplet_to_text(triplet):
  txt = str(triplet[0]) +" "+str(triplet[1]) +" "+str(triplet[2])
  # print(txt)
  return txt
# triplet_texts = [triplet_to_text(triplet) for triplet in Kg_triplets]
# Create database
client = chromadb.PersistentClient(path="E:\\Niraj_Work\\DL_Projects\\llm_projects\\database_tmp")
collection = client.create_collection(name="bear_kg_one_shot")
metadata = {"hnsw:space":"cosine"}
# store each document in a vector embedding database

for d in range(0,len(Kg_triplets)):
  triplet_txt = triplet_to_text(Kg_triplets[d])
  response = ollama.embeddings(model="mxbai-embed-large", prompt=triplet_txt)
  embedding = response["embedding"]
  collection.add(
    ids=[str(d)],
    embeddings=[embedding],
    documents=[triplet_txt]
  )

# an example prompt
prompt = "How Polar bear's body looks?"
one_shot_context = "The polar bear is a large bear native to the Arctic and nearby areas."
augmented_text = one_shot_context+"\n"+prompt
# generate an embedding for the prompt and retrieve the most relevant doc
response = ollama.embeddings(
  prompt=augmented_text,
  model="mxbai-embed-large"
)
results = collection.query(
  query_embeddings=[response["embedding"]],
  n_results=4
)
print("result = ",results)
# print(collection.get(include=['embeddings','documents','metadatas']))

# data = results['documents'][0][0]
data = ""
supported_docs = results['documents']
if len(supported_docs)==1:
  data = results['documents'][0][0]
else:
  for i in range(0, len(supported_docs)):
    data = data+" "+str(supported_docs[i])
    data = data.strip()
# generate a response combining the prompt and data we retrieved in step 2
output = ollama.generate(
  model="llama3",
  prompt=f"Using this data: {data}. Respond to this prompt: {augmented_text}"
)

print(output['response'])

Zero-Shot LLM-RAG With Knowledge Graph

 Background.

Zero-Shot. 

Zero-shot learning refers to the model's ability to perform a task without having seen any explicit examples of that task during training or in the prompt. Instead, the model relies on its pre-existing knowledge and understanding of language to generate the desired output.

Application in LLM RAG.

• No Examples Provided: When a task is given to the model, it receives only the task description or query without any specific examples to guide its response.
• Generalization: The model generalizes from the task description to understand what is required and generates a response based on its training data.

Video Tutorial.

Working Code: 

import ollama
import chromadb

documents = [
  "Bears are carnivoran mammals of the family Ursidae.",
  "They are classified as caniforms, or doglike carnivorans.",
  "Although only eight species of bears are extant, they are widespread, appearing in a wide variety of habitats throughout most of the Northern Hemisphere and partially in the Southern Hemisphere.",
  "Bears are found on the continents of North America, South America, and Eurasia.",
  "Common characteristics of modern bears include large bodies with stocky legs, long snouts, small rounded ears, shaggy hair, plantigrade paws with five nonretractile claws, and short tails.",
  "With the exception of courting individuals and mothers with their young, bears are typically solitary animals.",
  "They may be diurnal or nocturnal and have an excellent sense of smell.",
  "Despite their heavy build and awkward gait, they are adept runners, climbers, and swimmers.",
  "Bears use shelters, such as caves and logs, as their dens; most species occupy their dens during the winter for a long period of hibernation, up to 100 days.",
]
Kg_triplets = [["Bears", "are", "carnivoran mammals"],
["Bears", "belong to", "family Ursidae"],
["Bears", "are classified as", "caniforms"],
["Caniforms", "are", "doglike carnivorans"],
["Bears", "have", "eight species"],
["Bears", "are", "widespread"],
["Bears", "appear in", "a wide variety of habitats"],
["Bears", "are found in", "Northern Hemisphere"],
["Bears", "are partially found in", "Southern Hemisphere"],
["Bears", "are found on", "North America"],
["Bears", "are found on", "South America"],
["Bears", "are found on", "Eurasia"],
["Modern bears", "have", "large bodies"],
["Modern bears", "have", "stocky legs"],
["Modern bears", "have", "long snouts"],
["Modern bears", "have", "small rounded ears"],
["Modern bears", "have", "shaggy hair"],
["Modern bears", "have", "plantigrade paws with five nonretractile claws"],
["Modern bears", "have", "short tails"],
["Bears", "are typically", "solitary animals"],
["Bears", "can be", "diurnal"],
["Bears", "can be", "nocturnal"],
["Bears", "have", "an excellent sense of smell"],
["Bears", "are", "adept runners"],
["Bears", "are", "adept climbers"],
["Bears", "are", "adept swimmers"],
["Bears", "use", "shelters"],
["Shelters", "include", "caves"],
["Shelters", "include", "logs"],
["Bears", "use", "shelters as dens"],
["Most species", "occupy", "dens during winter"],
["Bears", "hibernate for", "up to 100 days"],]
# Convert the triplets to text
def triplet_to_text(triplet):
  txt = str(triplet[0]) +" "+str(triplet[1]) +" "+str(triplet[2])
  # print(txt)
  return txt
# triplet_texts = [triplet_to_text(triplet) for triplet in Kg_triplets]
# Create database
client = chromadb.PersistentClient(path="E:\\Niraj_Work\\DL_Projects\\llm_projects\\database_tmp")
collection = client.create_collection(name="bear_kg")
metadata = {"hnsw:space":"cosine"}
# store each document in a vector embedding database

for d in range(0,len(Kg_triplets)):
  triplet_txt = triplet_to_text(Kg_triplets[d])
  response = ollama.embeddings(model="mxbai-embed-large", prompt=triplet_txt)
  embedding = response["embedding"]
  collection.add(
    ids=[str(d)],
    embeddings=[embedding],
    documents=[triplet_txt]
  )

# an example prompt
prompt = "How does the bear's body looks?"

# generate an embedding for the prompt and retrieve the most relevant doc
response = ollama.embeddings(
  prompt=prompt,
  model="mxbai-embed-large"
)
results = collection.query(
  query_embeddings=[response["embedding"]],
  n_results=3
)
print("result = ",results)
print(collection.get(include=['embeddings','documents','metadatas']))

# data = results['documents'][0][0]
data = ""
supported_docs = results['documents']
if len(supported_docs)==1:
  data = results['documents'][0][0]
else:
  for i in range(0, len(supported_docs)):
    data = data+" "+str(supported_docs[i])
    data = data.strip()
# generate a response combining the prompt and data we retrieved in step 2
output = ollama.generate(
  model="llama3",
  prompt=f"Using this data: {data}. Respond to this prompt: {prompt}"
)

print(output['response'])