# -*- coding: utf-8 -*-

"""rag.ipynb

"""### RAG on using this dataset -> # GPT 3.5"""

!pip install openai

#!pip install --upgrade pip

!pip install transformers torch

!pip install llama-index llama-index-experimental

import logging

import sys

from IPython.display import Markdown, display

import pandas as pd

from llama_index.experimental.query_engine import PandasQueryEngine

logging.basicConfig(stream=sys.stdout, level=logging.INFO)

logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))

from llama_index.llms.openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo", api_key="sk-proj-fPxf5ypW6BhdQP5XMgetT3BlbkFJI5hOUj2DsSwlUI5ZwN5b")

import openai

openai.api_key = 'sk-proj-fPxf5ypW6BhdQP5XMgetT3BlbkFJI5hOUj2DsSwlUI5ZwN5b'

query_engine = PandasQueryEngine(df=haa_trainChronologies,llm=llm, verbose=True)

file_formats = {

    "csv": pd.read_csv,

    "xls": pd.read_excel,

    "xlsx": pd.read_excel,

    "xlsm": pd.read_excel,

    "xlsb": pd.read_excel,

}

def load_data(uploaded_file):

    try:

        ext = os.path.splitext(uploaded_file.name)[1][1:].lower()

    except:

        ext = uploaded_file.split(".")[-1]

    if ext in file_formats:

        return file_formats[ext](uploaded_file)

    else:

        st.error(f"Unsupported file format: {ext}")

        return None

# Read the Pandas DataFrame

df = haa_develChronologies

!pip install langchain

!pip install langchain_openai

from langchain_openai.chat_models import ChatOpenAI

# Set your API key and model choice

OPENAI_API_KEY = "sk-proj-0oig5Ll0qDjkUPCGlzq8T3BlbkFJHuYBzj0UJkkUy2Wgfh3O"

MODEL_NAME = "gpt-3.5-turbo"  # Specify the model you want to use

# Initialize the ChatOpenAI model with a specific temperature

model = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model=MODEL_NAME, temperature=0.5)

# Example usage

response = model.invoke("What MLB team won the World Series during the COVID-19 pandemic?")

print(response)

!pip show langchain  # Check the installed version

!pip install --upgrade langchain  # Update langchain

!pip install langchain_experimental

#from langchain.agents.agent_types import AgentType

df= haa_develChronologies

from langchain.agents.agent_types import AgentType  # Use the experimental version of AgentType

from langchain_experimental.agents import create_pandas_dataframe_agent  # Assuming you also need this experimental feature

from langchain.callbacks import StreamlitCallbackHandler

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613", openai_api_key="sk-proj-0oig5Ll0qDjkUPCGlzq8T3BlbkFJHuYBzj0UJkkUy2Wgfh3O", streaming=True)

pandas_df_agent = create_pandas_dataframe_agent(llm,df,verbose=True,agent_type=AgentType.OPENAI_FUNCTIONS,handle_parsing_errors=True,)

response = pandas_df_agent.run("provide me time stemp for observations C0392747")

dataFrameResponse = pandas_df_agent.run("provide me dataframe as string")

type(dataFrameResponse)

!pip install langchain_core

!pip install ChatOpenAI

from langchain_core.output_parsers import StrOutputParser

parser = StrOutputParser()

model = llm

chain = model | parser

try:

    chain.invoke({

        "context":dataFrameResponse,

        "question":"which observations are more prone have Hospital acquired pressure injury? "

    })

except Exception as e:

    print(e)

#String Dataframe respone to Text Splitter by langchain

# Note : Chunk size dependent on task you want to achieve with it

from langchain.text_splitter import RecursiveCharacterTextSplitter

df_responseSplitter = RecursiveCharacterTextSplitter(chunk_size=50, chunk_overlap=15)

df_responseSplitter.split_documents(dataFrameResponse)[:3]

# openai embedding :

from langchain_openai.embeddings import OpenAIEmbeddings

ai_embeddings = OpenAIEmbeddings()

ai_embed_query = embeddings.embed_query("provide me time stemp for observations C0392747")

print(f"length: {len(ai_embed_query)}")

medical_sentence1 = embeddings.embed_query("The timestamps for observations containing C0392747 are as follows - 2104-08-05 - 2104-08-07 - 2104-08-08")

medical_sentence2 = embeddings.embed_query("Subject id : 75")

# now let's examine performance of this medical query

from sklearn.metrics.pairwise import cosine_similarity

def calculate_cosine_similarity(embedded_query, embedded_sentence):

    similarities = [cosine_similarity([embedded_query], [sentence])[0][0] for sentence in embedded_sentences]

    return similarities

similarities_query1 = calculate_cosine_similarity(embedded_medical_query1, medical_sentence1)

similarities_query2 = calculate_cosine_similarity(embedded_medical_query2, medical_sentence2)

print('Similarities for Query 1:', similarities_query1)

print('Similarities for Query 2:', similarities_query2)

# now adding vector store

# Concatenate the columns with a separator for clarity

haa_develAdmittimes['combined'] = haa_develAdmittimes['hadm_id'].astype(str) + " at " + haa_develAdmittimes['admittime'].astype(str)

# Now extract the combined text data

text_data = haa_develAdmittimes['combined'].tolist()

# here we can change multiple vector store as per application

from langchain_community.vectorstores import DocArrayInMemorySearch

# Create vector store from the combined text data

admittime_vectorstore = DocArrayInMemorySearch.from_texts(text_data, embedding=embeddings)

admittime_vectorstore.similarity_search_with_score(query="give me hadm_id of paintents accociated with 3rd january", k=2)

#  retriever

med_retriever = admittime_vectorstore.as_retriever()

from langchain_core.runnables import RunnableParallel, RunnablePassthrough

setup = RunnableParallel(context=med_retriever, question=RunnablePassthrough())

setup.invoke("give me hadm_id of paintents accociated with 3rd january?")

chain = setup | prompt | model | parser

chain.invoke("give me hadm_id of paintents accociated with 2nd january")