From 4c4f840c1f76f956dad4af86ee1bbcca1faf52c8 Mon Sep 17 00:00:00 2001 From: "Cox, Jordan" Date: Tue, 18 Jun 2024 13:13:52 -0600 Subject: [PATCH] Updating Wizard to include mixture of experts --- elm/db_wiz.py | 85 +-- elm/experts.py | 228 ++++++++ examples/db_wizard/retrieve_docs_general.py | 164 ++++++ .../run_db_wizard_app.py | 0 examples/db_wizard/run_experts_app.py | 61 ++ examples/energy_wizard/database_manual.txt | 3 + examples/energy_wizard/test_db_wizard.ipynb | 99 ---- .../energy_wizard/test_db_wizard_v2.ipynb | 519 ------------------ 8 files changed, 461 insertions(+), 698 deletions(-) create mode 100644 elm/experts.py create mode 100644 examples/db_wizard/retrieve_docs_general.py rename examples/{energy_wizard => db_wizard}/run_db_wizard_app.py (100%) create mode 100644 examples/db_wizard/run_experts_app.py create mode 100644 examples/energy_wizard/database_manual.txt delete mode 100644 examples/energy_wizard/test_db_wizard.ipynb delete mode 100644 examples/energy_wizard/test_db_wizard_v2.ipynb diff --git a/elm/db_wiz.py b/elm/db_wiz.py index 9919d79..0a5af9c 100644 --- a/elm/db_wiz.py +++ b/elm/db_wiz.py @@ -44,90 +44,14 @@ def __init__(self, connection_string, model=None, token_budget=3500, ref_col=Non self.connection = psycopg2.connect(self.connection_string) self.token_budget = token_budget - fpcache = './db_description.txt' + fpcache = './database_manual.txt' if os.path.exists(fpcache): with open(fpcache, 'r') as f: self.database_describe = f.read() else: - # Initializing database schema - self.database_schema = self.get_schema() - self.database_first_lines = self.get_lines() - self.database_unique_values = self.get_unique_values() - - self.database_describe = ('You have been given access to the database ' - 'schema {}.\n The first ten lines of the database are {}.\n ' - 'Each column of text contains the following unique ' - 'values {}.\n The table name is loads.lc_day_profile_demand_enduse.' - .format(self.database_schema, - self.database_first_lines, - self.database_unique_values)) - - with open(fpcache, 'w') as f: - f.write(self.database_describe) - - - ## Getting database Schema - def get_schema(self): - query = """ - SELECT table_name, column_name, data_type - FROM information_schema.columns - WHERE table_schema = 'loads' AND table_name = 'lc_day_profile_demand_enduse' - ORDER BY table_name, ordinal_position; - """ - - with self.connection.cursor() as cur: - cur.execute(query) - schema = {} - for table, col, dtype in cur.fetchall(): - if table not in schema: - schema[table] = [] - schema[table].append({"column": col, "type": dtype}) - - schema_json = json.dumps(schema) - return schema_json - - - def json_serial(self, obj): - """JSON serializer for objects not serializable by default json code""" - - if isinstance(obj, (datetime, date)): - return obj.isoformat() - raise TypeError ("Type %s not serializable" % type(obj)) - - ## Getting First 10 lines of database - def get_lines(self): - query = ''' - SELECT * - FROM loads.lc_day_profile_demand_enduse - LIMIT 10; - ''' - - with self.connection.cursor() as cursor: - cursor.execute(query) - first_lines = cursor.fetchall() - - first_lines_json = json.dumps(first_lines, default=self.json_serial) - return first_lines_json - - # Getting Unique values in non-float columns of the database - def get_unique_values(self): - schema = json.loads(self.database_schema) - - with self.connection.cursor() as cursor: - - structure_dict = {} - for table in schema: - for entry in schema[table]: - if entry['type'] == 'text': - column_name = entry['column'] - query = f'SELECT DISTINCT {column_name} FROM loads.{table}' - - cursor.execute(query) - structure_dict[entry['column']] = str(cursor.fetchall()) - - return json.dumps(structure_dict) + print('Error no expert database file') # Getting sql from a generic query def get_sql_for(self, query): @@ -137,6 +61,7 @@ def get_sql_for(self, query): e_query = ('{}\n\nPlease create a SQL query that will answer this ' 'user question: "{}"\n\n' 'Return all columns from the database. ' + 'All the tables are in the schema "loads"' 'Please only return the SQL query with no commentary or preface.' .format(self.database_describe, query)) out = super().chat(e_query, temperature=0) @@ -148,6 +73,7 @@ def run_sql(self, sql): based on the db connection (self.connection), returns dataframe response.""" query = sql + print(query) # Move Connection or cursor to init and test so that you aren't re-intializing # it with each instance. with self.connection.cursor() as cursor: @@ -175,7 +101,7 @@ def get_py_code(self, query, df): full_response = out #print(full_response) ## get python code from response - full_response = full_response[full_response.find('python')+6:] + full_response = full_response[full_response.find('```python')+9:] full_response = full_response[:full_response.find('```')] py = full_response return py @@ -186,7 +112,6 @@ def run_py_code(self, py, df): return plt except: print(py) - """Jordan to write code that takes LLM response and generates plots""" def chat(self, query, debug=True, diff --git a/elm/experts.py b/elm/experts.py new file mode 100644 index 0000000..1761f9b --- /dev/null +++ b/elm/experts.py @@ -0,0 +1,228 @@ +""" +ELM mixture of experts +""" +import streamlit as st +import os +import openai +from glob import glob +import pandas as pd +import sys +import copy +import numpy as np + + +from elm.base import ApiBase +from elm.wizard import EnergyWizard +from elm.db_wiz import DataBaseWizard + +model = 'gpt-4' + +# NREL-Azure endpoint. You can also use just the openai endpoint. +# NOTE: embedding values are different between OpenAI and Azure models! +openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") +openai.api_key = os.getenv("AZURE_OPENAI_KEY") +openai.api_type = 'azure' +openai.api_version = os.getenv('AZURE_OPENAI_VERSION') + +EnergyWizard.EMBEDDING_MODEL = 'text-embedding-ada-002-2' +EnergyWizard.EMBEDDING_URL = ('https://stratus-embeddings-south-central.' + 'openai.azure.com/openai/deployments/' + 'text-embedding-ada-002-2/embeddings?' + f'api-version={openai.api_version}') +EnergyWizard.URL = ('https://stratus-embeddings-south-central.' + 'openai.azure.com/openai/deployments/' + f'{model}/chat/completions?' + f'api-version={openai.api_version}') +EnergyWizard.HEADERS = {"Content-Type": "application/json", + "Authorization": f"Bearer {openai.api_key}", + "api-key": f"{openai.api_key}"} + +EnergyWizard.MODEL_ROLE = ('You are a energy research assistant. Use the ' + 'articles below to answer the question. If ' + 'articles do not provide enough information to ' + 'answer the question, say "I do not know."') +EnergyWizard.MODEL_INSTRUCTION = EnergyWizard.MODEL_ROLE + +DataBaseWizard.URL = (f'https://stratus-embeddings-south-central.openai.azure.com/' + f'openai/deployments/{model}/chat/' + f'completions?api-version={openai.api_version}') +DataBaseWizard.HEADERS = {"Content-Type": "application/json", + "Authorization": f"Bearer {openai.api_key}", + "api-key": f"{openai.api_key}", + } + +st.set_option('deprecation.showPyplotGlobalUse', False) + +@st.cache_data +def get_corpus(): + """Get the corpus of text data with embeddings.""" + corpus = sorted(glob('./embed/*.json')) + corpus = [pd.read_json(fp) for fp in corpus] + corpus = pd.concat(corpus, ignore_index=True) + + return corpus + + +@st.cache_resource +def get_wizard(model = model): + """Get the energy wizard object. + + Parameters + ---------- + model : str + State which model to use for the energy wizard. + + Returns + ------- + response : str + GPT output / answer. + wizard : EnergyWizard + Returns the energy wizard object for use in chat responses. + """ + + + # Getting Corpus of data. If no corpus throw error for user. + try: + corpus = get_corpus() + except Exception: + print("Error: Have you run 'retrieve_docs.py'?") + st.header("Error") + st.write("Error: Have you run 'retrieve_docs.py'?") + sys.exit(0) + + wizard = EnergyWizard(corpus, ref_col='ref', model=model) + return wizard + +class MixtureOfExperts(ApiBase): + """Interface to ask OpenAI LLMs about energy + research either from a database or report.""" + + """Parameters + ---------- + model : str + State which model to use for the energy wizard. + connection string : str + String used to connect to SQL databases. + + Returns + ------- + response : str + GPT output / answer. + """ + + MODEL_ROLE = ("You are an expert given a query. Which of the " + "following best describes the query? Please " + "answer with just the number and nothing else." + "1. This is a query best answered by a text-based report." + "2. This is a query best answered by pulling data from " + "a database and creating a figure.") + """High level model role, somewhat redundant to MODEL_INSTRUCTION""" + + def __init__(self, connection_string, model=None, token_budget=3500, ref_col=None): + self.wizard_db = DataBaseWizard(model = model, connection_string = connection_string) + self.wizard_chat = get_wizard() + self.model = model + super().__init__(model) + + def chat(self, query, + debug=True, + stream=True, + temperature=0, + convo=False, + token_budget=None, + new_info_threshold=0.7, + print_references=False, + return_chat_obj=False): + """Answers a query by doing a semantic search of relevant text with + embeddings and then sending engineered query to the LLM. + + Parameters + ---------- + query : str + Question being asked of EnergyWizard + debug : bool + Flag to return extra diagnostics on the engineered question. + stream : bool + Flag to print subsequent chunks of the response in a streaming + fashion + temperature : float + GPT model temperature, a measure of response entropy from 0 to 1. 0 + is more reliable and nearly deterministic; 1 will give the model + more creative freedom and may not return as factual of results. + convo : bool + Flag to perform semantic search with full conversation history + (True) or just the single query (False). Call EnergyWizard.clear() + to reset the chat history. + token_budget : int + Option to override the class init token budget. + new_info_threshold : float + New text added to the engineered query must contain at least this + much new information. This helps prevent (for example) the table of + contents being added multiple times. + print_references : bool + Flag to print references if EnergyWizard is initialized with a + valid ref_col. + return_chat_obj : bool + Flag to only return the ChatCompletion from OpenAI API. + + Returns + ------- + response : str + GPT output / answer. + query : str + If debug is True, the engineered query asked of GPT will also be + returned here + references : list + If debug is True, the list of references (strs) used in the + engineered prompt is returned here + """ + + messages = [{"role": "system", "content": self.MODEL_ROLE}, + {"role": "user", "content": query}] + response_message = '' + kwargs = dict(model=self.model, + messages=messages, + temperature=temperature, + stream=stream) + + response = self._client.chat.completions.create(**kwargs) + + print(response) + + if stream: + for chunk in response: + chunk_msg = chunk.choices[0].delta.content or "" + response_message += chunk_msg + print(chunk_msg, end='') + + else: + response_message = response["choices"][0]["message"]["content"] + + + message_placeholder = st.empty() + full_response = "" + + if '1' in response_message: + out = self.wizard_chat.chat(query, + debug=True, stream=True, token_budget=6000, + temperature=0.0, print_references=True, + convo=False, return_chat_obj=True) + + for response in out[0]: + full_response += response.choices[0].delta.content or "" + message_placeholder.markdown(full_response + "▌") + + + elif '2' in response_message: + out = self.wizard_db.chat(query, + debug=True, stream=True, token_budget=6000, + temperature=0.0, print_references=True, + convo=False, return_chat_obj=True) + + st.pyplot(fig = out, clear_figure = False) + + else: + response_message = 'Error cannot find data in report or database.' + + + return full_response \ No newline at end of file diff --git a/examples/db_wizard/retrieve_docs_general.py b/examples/db_wizard/retrieve_docs_general.py new file mode 100644 index 0000000..7aedeb9 --- /dev/null +++ b/examples/db_wizard/retrieve_docs_general.py @@ -0,0 +1,164 @@ +import os +import asyncio +import pandas as pd +import logging +import openai +import time +from glob import glob +from rex import init_logger + +from elm.pdf import PDFtoTXT +from elm.embed import ChunkAndEmbed +from elm.osti import OstiList + + +logger = logging.getLogger(__name__) +init_logger(__name__, log_level='DEBUG') +init_logger('elm', log_level='INFO') + + +# NREL-Azure endpoint. You can also use just the openai endpoint. +# NOTE: embedding values are different between OpenAI and Azure models! +openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") +openai.api_key = os.getenv("AZURE_OPENAI_KEY") +openai.api_type = 'azure' +openai.api_version = '2023-03-15-preview' + +ChunkAndEmbed.EMBEDDING_MODEL = 'text-embedding-ada-002-2' +ChunkAndEmbed.EMBEDDING_URL = ('https://stratus-embeddings-south-central.' + 'openai.azure.com/openai/deployments/' + 'text-embedding-ada-002-2/embeddings?' + f'api-version={openai.api_version}') +ChunkAndEmbed.HEADERS = {"Content-Type": "application/json", + "Authorization": f"Bearer {openai.api_key}", + "api-key": f"{openai.api_key}"} + +PDF_DIR = './pdfs/' +TXT_DIR = './txt/' +EMBED_DIR = './embed/' + +URL = ('https://www.osti.gov/api/v1/records?' + 'research_org=NREL' + '&sort=publication_date%20desc' + '&product_type=Technical%20Report' + '&has_fulltext=true' + '&publication_date_start=01/01/2023' + '&publication_date_end=12/31/2023') + + +if __name__ == '__main__': + os.makedirs(PDF_DIR, exist_ok=True) + os.makedirs(TXT_DIR, exist_ok=True) + os.makedirs(EMBED_DIR, exist_ok=True) + + #osti = OstiList(URL, n_pages=1) + #osti.download(PDF_DIR) + + #meta = osti.meta.copy() + #meta['osti_id'] = meta['osti_id'].astype(str) + #meta = meta.drop_duplicates(subset=['osti_id']) + #meta['fp'] = PDF_DIR + meta['fn'] + #meta.to_csv('./meta.csv', index=False) + + '''missing = [] + for i, row in meta.iterrows(): + if not os.path.exists(row['fp']): + missing.append(i) + meta = meta.drop(missing, axis=0)''' + + fns = os.listdir(PDF_DIR) + + for fn in fns: + if 'pdf' in fn: + print(fn) + fp = os.path.join(PDF_DIR, fn) + txt_fp = os.path.join(TXT_DIR, fn.replace('.pdf', '.txt')) + embed_fp = os.path.join(EMBED_DIR, fn.replace('.pdf', '.json')) + + assert fp.endswith('.pdf') + assert os.path.exists(fp) + + if os.path.exists(txt_fp): + with open(txt_fp, 'r') as f: + text = f.read() + else: + pdf_obj = PDFtoTXT(fp) + text = pdf_obj.clean_poppler(layout=True) + if pdf_obj.is_double_col(): + text = pdf_obj.clean_poppler(layout=False) + text = pdf_obj.clean_headers(char_thresh=0.6, page_thresh=0.8, + split_on='\n', + iheaders=[0, 1, 3, -3, -2, -1]) + with open(txt_fp, 'w') as f: + f.write(text) + logger.info(f'Saved: {txt_fp}') + + + if not os.path.exists(embed_fp): + #logger.info('Embedding {}/{}: "{}"' + # .format(i+1, len(meta), row['title'])) + #tag = f"Title: {row['title']}\nAuthors: {row['authors']}" + tag = f"Title: Fema \n Authors: FEMA" + obj = ChunkAndEmbed(text, tag=tag, tokens_per_chunk=500, overlap=1) + embeddings = asyncio.run(obj.run_async(rate_limit=3e4)) + if any(e is None for e in embeddings): + raise RuntimeError('Embeddings are None!') + else: + df = pd.DataFrame({'text': obj.text_chunks.chunks, + 'embedding': embeddings, + 'osti_id': 1}) + df.to_json(embed_fp, indent=2) + logger.info('Saved: {}'.format(embed_fp)) + time.sleep(5) + + ''' + for i, row in meta.iterrows(): + fp = os.path.join(PDF_DIR, row['fn']) + txt_fp = os.path.join(TXT_DIR, row['fn'].replace('.pdf', '.txt')) + embed_fp = os.path.join(EMBED_DIR, row['fn'].replace('.pdf', '.json')) + + assert fp.endswith('.pdf') + assert os.path.exists(fp) + + if os.path.exists(txt_fp): + with open(txt_fp, 'r') as f: + text = f.read() + else: + pdf_obj = PDFtoTXT(fp) + text = pdf_obj.clean_poppler(layout=True) + if pdf_obj.is_double_col(): + text = pdf_obj.clean_poppler(layout=False) + text = pdf_obj.clean_headers(char_thresh=0.6, page_thresh=0.8, + split_on='\n', + iheaders=[0, 1, 3, -3, -2, -1]) + with open(txt_fp, 'w') as f: + f.write(text) + logger.info(f'Saved: {txt_fp}') + + if not os.path.exists(embed_fp): + logger.info('Embedding {}/{}: "{}"' + .format(i+1, len(meta), row['title'])) + tag = f"Title: {row['title']}\nAuthors: {row['authors']}" + obj = ChunkAndEmbed(text, tag=tag, tokens_per_chunk=500, overlap=1) + embeddings = asyncio.run(obj.run_async(rate_limit=3e4)) + if any(e is None for e in embeddings): + raise RuntimeError('Embeddings are None!') + else: + df = pd.DataFrame({'text': obj.text_chunks.chunks, + 'embedding': embeddings, + 'osti_id': row['osti_id']}) + df.to_json(embed_fp, indent=2) + logger.info('Saved: {}'.format(embed_fp)) + time.sleep(5) + + bad = [] + fps = glob(EMBED_DIR + '*.json') + for fp in fps: + data = pd.read_json(fp) + if data['embedding'].isna().any(): + bad.append(fp) + assert not any(bad), f'Bad output: {bad}' + ''' + + + logger.info('Finished!') diff --git a/examples/energy_wizard/run_db_wizard_app.py b/examples/db_wizard/run_db_wizard_app.py similarity index 100% rename from examples/energy_wizard/run_db_wizard_app.py rename to examples/db_wizard/run_db_wizard_app.py diff --git a/examples/db_wizard/run_experts_app.py b/examples/db_wizard/run_experts_app.py new file mode 100644 index 0000000..b2b0eeb --- /dev/null +++ b/examples/db_wizard/run_experts_app.py @@ -0,0 +1,61 @@ +import streamlit as st +import os +import openai +from glob import glob +import pandas as pd +import sys + +#from elm import EnergyWizard +from elm.experts import MixtureOfExperts + +model = 'gpt-4' +# User defined connection string +conn_string = '' + +if __name__ == '__main__': + wizard = MixtureOfExperts(model = model, connection_string = conn_string) + + msg = """Multi-Modal Wizard Demonstration!\nI am a multi-modal AI demonstration. I have access to NREL technical reports regarding the LA100 study and access to several LA100 databases. If you ask me a question, I will attempt to answer it using the reports or the database. Below are some examples of queries that have been shown to work. + \n - Describe chapter 2 of the LA100 report. + \n - What are key findings of the LA100 report? + \n - What enduse consumes the most electricity? + \n - During the year 2020 which geographic regions consumed the most electricity? + """ + + st.title(msg) + + if "messages" not in st.session_state: + st.session_state.messages = [] + + for message in st.session_state.messages: + with st.chat_message(message["role"]): + st.markdown(message["content"]) + + msg = "Type your question here" + if prompt := st.chat_input(msg): + st.chat_message("user").markdown(prompt) + st.session_state.messages.append({"role": "user", "content": prompt}) + + with st.chat_message("assistant"): + + message_placeholder = st.empty() + full_response = "" + + out = wizard.chat(query = prompt, + debug=True, stream=True, token_budget=6000, + temperature=0.0, print_references=True, + convo=False, return_chat_obj=True) + #references = out[-1] + + #for response in out[0]: + # full_response += response.choices[0].delta.content or "" + # message_placeholder.markdown(full_response + "▌") + + message_placeholder.markdown(full_response) + + st.session_state.messages.append({"role": "assistant", + "content": full_response}) + + + + diff --git a/examples/energy_wizard/database_manual.txt b/examples/energy_wizard/database_manual.txt new file mode 100644 index 0000000..31b8f36 --- /dev/null +++ b/examples/energy_wizard/database_manual.txt @@ -0,0 +1,3 @@ +The table "blk_annual_demand" has six columns: "load_scenario", "year", "block_fips", "tract_fips", "geography_id", and "kwh". The "load_scenario", "year", "block_fips", and "tract_fips" columns are of type "text", while the "geography_id" column is of type "character varying". The "kwh" column is of type "double precision". The table contains data on annual electricity demand (in kilowatt-hours) for different geographic areas, identified by their block and tract FIPS codes, under different load scenarios. The load scenarios represent varying levels of grid loading including moderate, high, and stress in ascending order. The years covered span from 2020 to 2045 in 5 year increments. +The table "lc_annual_demand_enduse" has nine columns: "load_scenario", "year", "geography_id", "scenario_year", "load_center", "sector", "enduse", "kwh", and "kwh_w_dlosses". It appears to be a database of annual electricity demand broken down by load scenario, year, geography, scenario year, load center, sector, end use, and two different measures of electricity consumption (kwh and kwh_w_dlosses). +The table "lc_annual_gas_demand" has seven columns: "load_scenario" (text), "year" (text), "geography_id" (bigint), "scenario_year" (text), "load_center" (bigint), "sector" (text), and "btu" (double precision). It appears to be a record of annual gas demand for different load scenarios, years, geographies, scenario years, load centers, and sectors. The "btu" column likely represents the amount of gas demanded in British Thermal Units. diff --git a/examples/energy_wizard/test_db_wizard.ipynb b/examples/energy_wizard/test_db_wizard.ipynb deleted file mode 100644 index 000427e..0000000 --- a/examples/energy_wizard/test_db_wizard.ipynb +++ /dev/null @@ -1,99 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import streamlit as st\n", - "import os\n", - "import openai\n", - "from glob import glob\n", - "import pandas as pd\n", - "import sys\n", - "\n", - "#from elm import EnergyWizard\n", - "from elm.db_wiz import DataBaseWizard" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "model = 'gpt-4'\n", - "conn_string = 'postgresql://la100_admin:laa5SSf6KOC6k9xl@gds-cluster-1.cluster-ccklrxkcenui.us-west-2.rds.amazonaws.com:5432/la100-stage'\n", - "\n", - "openai.api_base = os.getenv(\"AZURE_OPENAI_ENDPOINT\") \n", - "openai.api_key = os.getenv(\"AZURE_OPENAI_KEY\") \n", - "openai.api_type = 'azure'\n", - "openai.api_version = '2023-03-15-preview' \n", - "\n", - "DataBaseWizard.URL = (f'https://stratus-embeddings-south-central.openai.azure.com/'\n", - " f'openai/deployments/{model}/chat/'\n", - " f'completions?api-version={openai.api_version}')\n", - "DataBaseWizard.HEADERS = {\"Content-Type\": \"application/json\",\n", - " \"Authorization\": f\"Bearer {openai.api_key}\",\n", - " \"api-key\": f\"{openai.api_key}\",\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "wizard = DataBaseWizard(model = model, connection_string = conn_string)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "wizard.df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "wizard.chat(query = 'Plot a scatter plot of the electricity load for the moderate load_scenario.')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "openai", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/energy_wizard/test_db_wizard_v2.ipynb b/examples/energy_wizard/test_db_wizard_v2.ipynb deleted file mode 100644 index 7f98f6a..0000000 --- a/examples/energy_wizard/test_db_wizard_v2.ipynb +++ /dev/null @@ -1,519 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import streamlit as st\n", - "import os\n", - "import openai\n", - "from glob import glob\n", - "import pandas as pd\n", - "import sys\n", - "\n", - "#from elm import EnergyWizard\n", - "from elm.db_wiz import DataBaseWizard" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "model = 'gpt-4'\n", - "conn_string = 'postgresql://la100_admin:laa5SSf6KOC6k9xl@gds-cluster-1.cluster-ccklrxkcenui.us-west-2.rds.amazonaws.com:5432/la100-stage'\n", - "\n", - "openai.api_base = os.getenv(\"AZURE_OPENAI_ENDPOINT\") \n", - "openai.api_key = os.getenv(\"AZURE_OPENAI_KEY\") \n", - "openai.api_type = 'azure'\n", - "openai.api_version = '2023-03-15-preview' \n", - "\n", - "DataBaseWizard.URL = (f'https://stratus-embeddings-south-central.openai.azure.com/'\n", - " f'openai/deployments/{model}/chat/'\n", - " f'completions?api-version={openai.api_version}')\n", - "DataBaseWizard.HEADERS = {\"Content-Type\": \"application/json\",\n", - " \"Authorization\": f\"Bearer {openai.api_key}\",\n", - " \"api-key\": f\"{openai.api_key}\",\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "wizard = DataBaseWizard(model = model, connection_string = conn_string)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "wizard.clear()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "query = '''Plot a time series of the electricity load for the moderate load_scenario, \n", - " for the lighting enduse, for the winter week_type, for the year 2030,\n", - " for the sector res, and for geography_id 1.\n", - " .'''" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "query = ''' Plot a time series of the winter residential heating load for the moderate scenario \n", - " in model year 2030 for geography 1.\n", - "\n", - " '''" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "query = ''' Plot a time series of the winter residential heating load for the moderate scenario \n", - " in model year 2030 for the first five load centers.\n", - " '''" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "#wizard.chat(query = query)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SELECT * FROM loads.lc_day_profile_demand_enduse\n", - "WHERE load_scenario = 'moderate'\n", - "AND year = '2030'\n", - "AND week_type = 'winter'\n", - "AND sector = 'res'\n", - "AND enduse = 'heating'\n", - "AND load_center BETWEEN 1 AND 5\n", - "ORDER BY timestamp;\n" - ] - } - ], - "source": [ - "sql = wizard.get_sql_for(query = query)\n", - "print(sql) " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
load_scenarioyeargeography_idscenario_yearload_centertimestamptimestamp_aliasweek_typeday_typehour_typesectorendusekwhkwh_w_dlosses
0moderate20301moderate_203012012-01-16 00:00:002030-01-14 08:00:00winterNoneNoneresheating287.805908310.830380
1moderate20305moderate_203052012-01-16 00:00:002030-01-14 08:00:00winterNoneNoneresheating346.962844374.719872
2moderate20302moderate_203022012-01-16 00:00:002030-01-14 08:00:00winterNoneNoneresheating145.527256157.169436
3moderate20303moderate_203032012-01-16 00:00:002030-01-14 08:00:00winterNoneNoneresheating21.31679723.022141
4moderate20304moderate_203042012-01-16 00:00:002030-01-14 08:00:00winterNoneNoneresheating436.453091471.369338
.............................................
835moderate20304moderate_203042012-01-22 23:00:002030-01-21 07:00:00winterNoneNoneresheating577.954109624.190438
836moderate20305moderate_203052012-01-22 23:00:002030-01-21 07:00:00winterNoneNoneresheating427.309328461.494075
837moderate20302moderate_203022012-01-22 23:00:002030-01-21 07:00:00winterNoneNoneresheating154.429319166.783664
838moderate20301moderate_203012012-01-22 23:00:002030-01-21 07:00:00winterNoneNoneresheating316.799064342.142989
839moderate20303moderate_203032012-01-22 23:00:002030-01-21 07:00:00winterNoneNoneresheating34.01159336.732520
\n", - "

840 rows × 14 columns

\n", - "
" - ], - "text/plain": [ - " load_scenario year geography_id scenario_year load_center \\\n", - "0 moderate 2030 1 moderate_2030 1 \n", - "1 moderate 2030 5 moderate_2030 5 \n", - "2 moderate 2030 2 moderate_2030 2 \n", - "3 moderate 2030 3 moderate_2030 3 \n", - "4 moderate 2030 4 moderate_2030 4 \n", - ".. ... ... ... ... ... \n", - "835 moderate 2030 4 moderate_2030 4 \n", - "836 moderate 2030 5 moderate_2030 5 \n", - "837 moderate 2030 2 moderate_2030 2 \n", - "838 moderate 2030 1 moderate_2030 1 \n", - "839 moderate 2030 3 moderate_2030 3 \n", - "\n", - " timestamp timestamp_alias week_type day_type hour_type \\\n", - "0 2012-01-16 00:00:00 2030-01-14 08:00:00 winter None None \n", - "1 2012-01-16 00:00:00 2030-01-14 08:00:00 winter None None \n", - "2 2012-01-16 00:00:00 2030-01-14 08:00:00 winter None None \n", - "3 2012-01-16 00:00:00 2030-01-14 08:00:00 winter None None \n", - "4 2012-01-16 00:00:00 2030-01-14 08:00:00 winter None None \n", - ".. ... ... ... ... ... \n", - "835 2012-01-22 23:00:00 2030-01-21 07:00:00 winter None None \n", - "836 2012-01-22 23:00:00 2030-01-21 07:00:00 winter None None \n", - "837 2012-01-22 23:00:00 2030-01-21 07:00:00 winter None None \n", - "838 2012-01-22 23:00:00 2030-01-21 07:00:00 winter None None \n", - "839 2012-01-22 23:00:00 2030-01-21 07:00:00 winter None None \n", - "\n", - " sector enduse kwh kwh_w_dlosses \n", - "0 res heating 287.805908 310.830380 \n", - "1 res heating 346.962844 374.719872 \n", - "2 res heating 145.527256 157.169436 \n", - "3 res heating 21.316797 23.022141 \n", - "4 res heating 436.453091 471.369338 \n", - ".. ... ... ... ... \n", - "835 res heating 577.954109 624.190438 \n", - "836 res heating 427.309328 461.494075 \n", - "837 res heating 154.429319 166.783664 \n", - "838 res heating 316.799064 342.142989 \n", - "839 res heating 34.011593 36.732520 \n", - "\n", - "[840 rows x 14 columns]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = wizard.run_sql(sql)\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"\\nimport matplotlib.pyplot as plt\\n\\n# Create a figure and axis\\nfig, ax = plt.subplots()\\n\\n# Iterate through the unique load centers\\nfor load_center in df['load_center'].unique():\\n # Filter the dataframe for the current load center\\n lc_data = df[df['load_center'] == load_center]\\n \\n # Plot the time series for the current load center\\n ax.plot(lc_data['timestamp'], lc_data['kwh_w_dlosses'], label=f'Load Center {load_center}')\\n\\n# Set the title and labels\\nax.set_title('Winter Residential Heating Load for Moderate Scenario in Model Year 2030')\\nax.set_xlabel('Timestamp')\\nax.set_ylabel('kWh with Distribution Losses')\\n\\n# Display the legend\\nax.legend()\\n\\n# Show the plot\\nplt.show()\\n\"" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "py = wizard.get_py_code(query = query, df = df)\n", - "py" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Create a figure and axis\n", - "fig, ax = plt.subplots()\n", - "\n", - "# Iterate through the unique load centers\n", - "for load_center in df['load_center'].unique():\n", - " # Filter the dataframe for the current load center\n", - " lc_data = df[df['load_center'] == load_center]\n", - " \n", - " # Plot the time series for the current load center\n", - " ax.plot(lc_data['timestamp'], lc_data['kwh_w_dlosses'], label=f'Load Center {load_center}')\n", - "\n", - "# Set the title and labels\n", - "ax.set_title('Winter Residential Heating Load for Moderate Scenario in Model Year 2030')\n", - "ax.set_xlabel('Timestamp')\n", - "ax.set_ylabel('kWh with Distribution Losses')\n", - "\n", - "# Display the legend\n", - "ax.legend()\n", - "\n", - "# Show the plot\n", - "plt.show()\n", - "\n" - ] - } - ], - "source": [ - "wizard.run_py_code(py, df)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "openai", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}