Financial Recommendation Engine Using LLMs and Data Analysis

The J Financial recommendation engine personalizes banking product suggestions using demographic and financial data.

### Building a Financial Recommendation Engine Using LLMs
* 👋 Welcome to the seventh part of the Rag Plus LLM use case in the finance domain, where we explore **recommendation engines that analyze user behavior** to suggest products or services.
* 📊 These engines can recommend financial products such as credit cards or loans based on a user's **salary, income, and debts**, enhancing customer engagement through **personalized experiences**.
* 🔍 There are two main types of recommendation engines: **collaborative filtering**, which suggests products based on the behaviors of **similar users**, and **content-based filtering**, which recommends similar products based on **individual user preferences**.
* 🛠 To improve these engines, algorithms like **K nearest neighbors** or **neural networks** can be utilized, and by using **embedding models**, we can create **enhanced hybrid recommendation systems**.
* 💻 The project involves building a **J Financial recommendation engine** that uses demographic and bureau data to recommend banking products, employing **Python Lang chain** and **large language models**.
* 📈 The methodology includes **preprocessing open-source data**, storing it in a **vector database**, and using a **RAG QA chain** to generate recommendations based on user data.
* 🧑 After generating synthetic data for various customer attributes, we can determine eligibility for products and provide tailored recommendations, such as suggesting **personal loans or mortgages** based on **income and debt levels**.
* 🔮 In the next video, we will delve into **synthetic data generation for creating specific patterns** useful for machine learning applications, while also encouraging viewers to **explore more about AI and data science** through additional resources.

hi guys, welcome to Free Birds Q, and welcome to Rag Plus LLM use case in finance domain playlist part 7. So let's get started. So if you don't yet watch my 75 hard gen challenge playlist, please watch and learn gen for free. I will put the link in the description. So here I show you the recommendation engines that are used to recommend products or services to users based on their behaviors and attributes. So this whole system will analyze your personal behavior on applications like Netflix, Amazon, or Flipkart and can recommend you the product or services based on your behavior that you might buy. Okay, and in the finance domain, we can use those recommendation engines in many ways, like recommending the best credit card to the user based on their salary, income, and debts as well. Or we can recommend them the banking products or the lending products as well based on their behavior and the bureau data. So you can personalize user experience, segment them, that can increase the customer engagement as well. Okay, and the recommendation engine is of two types.

one is collaborative filtering, and the other is content-based filtering. The collaborative filtering means you are comparing with the behavior of other people and recommending products combinations they buy. So, let's just say if you buy milk, then they also recommend you the bread as well because that is the behavior that they get from another person who might buy bread and milk together. Okay, the second is content-based filtering. You will get the recommendation based on the similar kind of products. So, if you buy milk, then you can also recommend another milk-based product like butter or cheese as well. So, in that way, the content-based filtering works. So, J can enhance this recommendation engine algorithms that are K nearest neighbor or neural network that are used in the industry right now. But with the help of Gen, we can use the embedding models that can generate the embeddings of the customer attributes and compare them with the products and other users and build the hybrid or enhanced recommendation engines. Okay, so as I just promised, this is the next project from this list, and

I'm building this with the help of a mistal fine-tuned large language model that is called Zyer 7B llm. So let's get started to build our project and build our J Financial recommendation engine. Let's get started. So guys, here is our project, the J Financial recommendation engine. So we have a problem statement that we need to build a recommendation engine that can recommend bank products to the user based on their demographic information, along with personal information and bureau information, using the Python Lang chain and large language models. So this is the complete methodology that we have to follow. We need to get the open-source data of a company product that includes demographic and bureau data as well. Then we use Python to load that data and preprocess that data as well. And then we load that preprocessed data into the vector DB by using an embedding model from Hugging Face, because Hugging Face embedding model is completely free. And in this whole video or in this whole playlist, I'm using only

the uh op Source free models only okay, and then we build the rag QA chain that will help you to uh build a complete rag llm based system that can take the data from the vector DB and can uh build your whole uh project as that can recommend the product to the user as well okay. So let's get started with it. So you can also watch my other playlist from this link, and you can also get the SE SE uh 75 hard gen challenge playlist from this link as well okay. So first, I need to install the faker library because I need to generate the synthetic data here okay. So I just generate all the things that I just need: the age, gender, medal status, income level, as along with the education, occupation, idential status, dependent uh debt to income ratio, or the credit buau score as well. So these are the features that I just need because these are the features that you can easily get if you have the financial data with you okay. Then I just uh store all this data, and then I also need to generate the

inquiries data as that what kind of inquiries that person did in the last 3 months or in the last 6 months as well. Okay, so that I get to know what kind of product that customer is looking out for. Okay, so here I just complete the whole script here and build my whole kind of data here. And in that data, you will see we have all this information. We have customer ID too, and then we have the last 3 months personal loan inquiry, last 3 months credit card inquiry, or the mortgage inquiry, last six-month variables as well. So, these kinds of variables will help you to understand what kind of products customers are looking for, and based on their other information, are they eligible for that product, so that we can recommend that product to them. Okay, so we need to also check for the eligibility here based on this kind of information that we have. Okay, so first thing is we need to build a Content column here that takes all this data and stores it into the.

content uh uh column in the prompt for format okay so that prompt format will look like this okay and then we have to uh install our Lang chain and Lang chain community libraries and so we need to convert this kind of a dictionary or this kind of a list into the documents uh format and we will store all that data into the doc M ments list okay then we need to install the sentence Transformers because we need to load our embedding models as well we need to install the chroma DB and along with the bits and bite and accelerate to load the large language models that we have is the Zyer 7 llm okay so here I first load the hugging phas embeddings here and then I just put all that document into my Vector DB and under the collection name of recommendation engine by using my hugging face embeding okay so now your all the data is stored in this Vector DP now you need to load the large language model so I just load the L language models in the quantized format because quantization is necessary.

here because if I don't quantize the model, it will take too much time to load, and it also consumes so much space and memory as well. Okay, so that's why I use a quantization here. Okay, so once I quantized it, and then I can load the model easily. So here, you see my whole model is loaded successfully, and then I build a query pipeline here because I need to generate the responses in the text generation format. So I pass my model, my tokenizer, max length, and everything into this query pipeline so that I can use it to generate the responses. And then, with the help of Hugging Face pipeline, I build a single function out there that can take the prompt and generate the response as well. Okay, and this is a kind of a simple function that can just format my output or input text as well. Okay, so here, I just check it with the small question here that is, What is recommendation Hine, and how it is used in the finance domain? As you see with

the help of this function. It can easily colorize the question and the answer and format all the responses that it gets as okay. Okay, so now it's time to check it on our ual data. So, we just build a rack QA chain, and we build a template here so that it can provide the best recommendation for the customer as well. So, we just build a retriever function with the help of our chroma DB, and it can get the best result out of it. And based on that best result, it can build a QA. That kind of QA chain will take this kind of customer's data, and we pass this whole kind of customer's data into the string format into our QA chain, and it will generate the response. So, you see here, this is the response that we just got based on the data. The stable lending product for the first customer would be a personal loan with a lower interest rate due to their low income level and very high debt-to-income ratio. Okay, very low income level and very high debt.

to income ratio. The second customer with the high income level and the low debt income ratio may be eligible for the mortgage of the home loan as well. So, okay, so in that way, it just provided you the complete answer in this format. Okay, so I hope you guys completely understand how I built this single recommendation engine for the finance domain by using the rag and lar language models. So, if you want to know more, you can also build your own models with multiple kinds of other language models and experiment with them. Okay, and in our next video, we will talk about the synthetic data generator that will generate the synthetic data for you so that you can get your own certain patterns data that can be used for your own products or own machine learning models or deep learning models as well. Okay, and if you want to know more about PR engineering, generated AI, data science, and machine learning, you can watch my videos on YouTube and also read my blogs on Medium. We'll meet in our next video. Thank you, guys. Thank you so.

GenAI Financial Recommendation Engine | LLM + RAG ChromaDB [ Zypher 7B LLM ] Mistral LLM

FreeBirds Crew - Data Science and Generative AI

Recommendation engines analyze user behavior on platforms like Netflix and Amazon to suggest products or services.

In the finance domain, they can recommend credit cards, banking, and lending products based on user behavior and data.

There are two types of recommendation engines: collaborative filtering, which compares user behavior, and content-based filtering, which suggests similar products.

Building the J Financial Recommendation Engine

The project aims to create a recommendation engine for bank products using demographic, personal, and bureau information.

The methodology involves gathering open-source data, preprocessing it with Python, and using a free Hugging Face embedding model to load the data into a vector database.

The project will then build a RAG QA chain to recommend products to users based on the data from the vector DB.

The script compiles customer inquiry data from the last 3 to 6 months, including personal loans, credit cards, and mortgages.

This information helps identify the products customers are interested in and assess their eligibility for those products.

The data is then stored in a document format, and a vector database is used to load the embedding models and large language models for the recommendation engine.

Using Quantization for Model Loading and Response Generation

Quantization is used to reduce the model's loading time, space, and memory consumption.

A query pipeline is built to generate responses in a text generation format, using the model and tokenizer.

The process includes a retriever function with Chroma DB to provide the best customer recommendations, ultimately generating tailored responses based on the customer's data.

Building a Recommendation Engine for Finance

The recommendation engine uses income level and debt-to-income ratio to determine mortgage eligibility for customers.

The speaker encourages experimentation with different language models to build custom models.

The next video will focus on a synthetic data generator for creating pattern data for machine learning models.