Building an LLM-Powered Data Analyst

pip install openai wandb pandas

import pandas as pd
import os
import openai
import wandb
# Initialize a new Weights & Biases project
wandb.init(project='openai_data_analyst', name='LMM')

df = pd.read_csv('/content/kaggle/Reviews.csv')

from IPython.display import Markdown, display
os.environ["OPENAI_API_KEY"] = 'add your openai API key'
openai.api_key = os.environ["OPENAI_API_KEY"]

# Retrieve response from the model
def retrieve_analyst_response(model):

    response = openai.chat.completions.create(
        messages=[
                    {"role": "system", "content": "You are a helpful assistant who answers only from the given Context."},
                    {"role": "user", "content":  "Context: " + context + "\n\n Query: " + query},
                ],
        model= model,  # Choose the model you wish to use
        temperature=0,
        max_tokens=60
    )
 
    print(response.choices[0].message.content)

query = "Does the data have repeated ProductId?"
retrieve_analyst_response("GPT-4o-mini")

query = "What is the average value for all Scores?"
retrieve_analyst_response("GPT-4o-mini")

# Score with pretrained model
def score_review(review, score):
    response = openai.chat.completions.create(
        messages=[
                    {"role": "system", "content": "GPT is great at rating customer feedback from 1 to 5, where 1 is the worst and 5 is the best. Give the rating as a whole number."},
                    {"role": "user", "content": review},
                ],
        model="GPT-4o-mini",  # Choose the model you wish to use
        temperature=0,
        max_tokens=60
    )

    return response.choices[0].message.content


# Apply scoring to each review
df['pretrained_score'] = df.iloc[568400:].apply(lambda row: score_review(row['Text'], row['Score']), axis=1)

# import pandas as pd
import json


# Specify the output file path
output_file_path = 'output_data.jsonl'


# Open the output file in write mode
with open(output_file_path, 'w') as file:
    for index, row in df_downsampled.iterrows():
        # Construct the JSON object for the current row
        json_object = {
            "messages": [
                {"role": "system", "content": "GPT is great at rating customer feedback from 1 to 5, where 1 is the worst and 5 is the best. Give the rating as a whole number."},
                {"role": "user", "content": row['Text']},
                {"role": "assistant", "content": str(row['Score'])}  # Ensure the score is a string
            ]
        }
        # Convert the dictionary to a JSON string and write it to the file
        file.write(json.dumps(json_object) + '\n')


print(f"Data successfully written to {output_file_path}")

from openai import OpenAI
client = OpenAI()

client.files.create(
  file=open("output_data.jsonl", "rb"),
  purpose="fine-tune"
)


client.fine_tuning.jobs.create(
  training_file="file-KDaUDoLb3qSbbyvv1oq8Ts2h",
  model="GPT-4o-mini"
)

openai.fine_tuning.jobs.retrieve("ftjob-your job id here")

results = []
correct_predictions = 0
# Score with pretrained model
def score_review(review, original_score, old_score):
   
    response = openai.chat.completions.create(
        messages=[
                    {"role": "system", "content": "GPT is great at rating customer feedback from 1 to 5, where 1 is the worst and 5 is the best. Give the rating as a whole number only."},
                    {"role": "user", "content": review},
                ],
        model="GPT-4o-mini:personal::8otpi9E6",  # Choose the model you wish to use
        temperature=0,
        max_tokens=60
    )
    results.append({
        "sentiment": review,  
        "original_prediction": original_score,
        "labeled_prediction": response.choices[0].message.content,
        "old_model_prediction": old_score
    })

    return response.choices[0].message.content


# Apply scoring to each review
df['finetuned_score'] = df.iloc[568400:].apply(lambda row: score_review(row['Text'], row['Score'], row['pretrained_score']), axis=1)

# Convert results list to DataFrame
df_results = pd.DataFrame(results)


# Log the entire DataFrame as a table to W&B
wandb.log({"results_table": wandb.Table(dataframe=df_results)})

#extract a part of dataframe for analysis
test_df = df.iloc[568350:568400]


#convert the dataframe to json to pass as context to the model
context = test_df.head().to_json(orient="records")
context

Now, let's prompt the fine tuned model with questions a data analyst might ask and see how it responds:

query = "For the ProductId: B003O5Q3KE, what food is the Text about?"
retrieve_analyst_response('ft:GPT-4o-mini:personal::8otpi9E6'
)

query = "For Corriander Chutney, is the sentiment positive or negative?"
retrieve_analyst_response('ft:GPT-4o-mini:personal::8otpi9E6'
)

query = "Let's say if the value of finetuned_score is less than 3 the sentiment is negative and if it is greater than the sentiment is positive. Is the average sentiment positive or negative?"
retrieve_analyst_response('ft:GPT-4o-mini:personal::8otpi9E6'
)

A major part of data analysis is graphical visualizations that help breakdown the data in a more comprehensive way. However, the API is not directly capable of doing so, as demonstrated in  the prompt below. To cater for this, libraries such as pandas_gpt can be leveraged that allow us to handle pandas DataFrame using ChatGPT prompts.
query = "Plot the distribution of Score using bargraph"
retrieve_analyst_response('ft:GPT-4o-mini:personal::8otpi9E6')