add file

.ipynb_checkpoints/app-checkpoint.py

@@ -0,0 +1,159 @@
+'''
+
+CONFIG AND IMPORTS
+
+'''
+from config import default_config
+
+from types import SimpleNamespace
+import gradio as gr
+import os, random
+from pathlib import Path
+import tiktoken
+from getpass import getpass
+from rich.markdown import Markdown
+
+import openai
+import wandb
+from pprint import pprint
+from wandb.integration.openai import autolog
+from langchain.text_splitter import MarkdownHeaderTextSplitter
+import numpy as np
+
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+
+
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential, # for exponential backoff
+)  
+
+
+
+
+if os.getenv("OPENAI_API_KEY") is None:
+  if any(['VSCODE' in x for x in os.environ.keys()]):
+    print('Please enter password in the VS Code prompt at the top of your VS Code window!')
+  os.environ["OPENAI_API_KEY"] = getpass("Paste your OpenAI key from: https://platform.openai.com/account/api-keys\n")
+  openai.api_key = os.getenv("OPENAI_API_KEY", "")
+
+assert os.getenv("OPENAI_API_KEY", "").startswith("sk-"), "This doesn't look like a valid OpenAI API key"
+print("OpenAI API key configured")
+
+
+
+
+
+
+def find_nearest_neighbor(argument="", max_args_in_output=3):
+    '''
+        INPUT:
+            argument (string)
+
+        RETURN the nearest neighbor(s) in vectorDB to argument as string
+    '''
+
+    md = ""
+    print(argument)
+    directory_path = "../../safety_docs"
+
+    for filename in os.listdir(directory_path):
+        if filename.endswith(".md"):
+            with open(os.path.join(directory_path, filename), 'r') as file:
+                content = file.read()
+                md = md + content
+
+    markdown_document = md
+
+    headers_to_split_on = [
+        ("#", "Header 1"),
+        ("##", "Header 2"),
+        ("###", "Header 3"),
+    ]
+
+    markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
+    md_header_splits = markdown_splitter.split_text(markdown_document)
+
+    embeddings = OpenAIEmbeddings()
+    embedding_matrix = np.array([embeddings.embed_query(text.page_content) for text in md_header_splits])
+    argument_embedding = embeddings.embed_query(argument)
+
+    dot_products = np.dot(embedding_matrix, argument_embedding)
+    norms = np.linalg.norm(embedding_matrix, axis=1) * np.linalg.norm(argument_embedding)
+    cosine_similarities = dot_products / norms
+
+    nearest_indices = np.argsort(cosine_similarities)[-max_args_in_output:][::-1]
+
+    arr = [md_header_splits[index].metadata for index in nearest_indices]
+    output = ""
+    for thing in arr:
+        output = output + thing['Header 1'] + "\n"
+
+    return output
+
+def get_gpt_response(argument, user_prompt, system_prompt=default_config.system_prompt, model=default_config.model_name, n=1, max_tokens=200):
+    '''
+    INPUT: 
+    Argument
+    user_prompt
+    system_prompt
+    model
+    '''
+
+    @retry(wait=wait_random_exponential(min=1, max=3), stop=stop_after_attempt(1))
+    def completion_with_backoff(**kwargs):
+        return openai.ChatCompletion.create(**kwargs)
+    
+    messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+    responses = completion_with_backoff(
+        model=model,
+        messages=messages,
+        n = n,
+        max_tokens=max_tokens
+        )
+    for response in responses.choices:
+        generation = response.message.content
+        return generation
+    
+
+def greet(argument):
+    nearest_neighbor = find_nearest_neighbor(argument)
+    user_prompt = default_config.user_prompt_1 + argument + default_config.user_prompt_2
+    # response = get_gpt_response(argument, user_prompt)
+    response = "chatbot response here"
+    # return "Hello " + "\n We think your argument matches common arguments in our database, is it one of these?:\n " + nearest_neighbor + "\n\n\n ------------------------- \n\n\n Lengthy response: \n" + response
+    return "english", "german"
+
+# demo = gr.Interface(
+#     fn=greet,
+#     inputs=gr.Textbox(lines=2, placeholder="Anything past 200 tokens (roughly 200 words) will be cutoff. Please enter <=1 paragraph"),
+#     outputs="text"
+# )
+
+# # demo.queue(max_size=20)
+# demo.launch()
+
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            seed = gr.Text(label="Input Phrase")
+            english = gr.Text(label="Generated English Text")
+
+        with gr.Column():
+            german = gr.Text(label="Generated German Text",lines=4)
+    btn = gr.Button("Generate")
+    btn.click(greet, inputs=[seed], outputs=[english, german])
+    gr.Examples(["AGI is far away", "AI is confined to a computer and cannot interact with the physical world", "AI isn't concious"], inputs=[seed])
+
+demo.launch()
+
+
+
+

.ipynb_checkpoints/ingest-checkpoint.py

@@ -0,0 +1,208 @@
+"""Ingest a directory of documentation files into a vector store and store the relevant artifacts in Weights & Biases"""
+import argparse
+import json
+import logging
+import os
+import pathlib
+from typing import List, Tuple
+
+import langchain
+import wandb
+from langchain.cache import SQLiteCache
+from langchain.docstore.document import Document
+from langchain.document_loaders import UnstructuredMarkdownLoader
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.text_splitter import MarkdownTextSplitter
+from langchain.vectorstores import Chroma
+
+langchain.llm_cache = SQLiteCache(database_path="langchain.db")
+
+logger = logging.getLogger(__name__)
+
+
+def load_documents(data_dir: str) -> List[Document]:
+    """Load documents from a directory of markdown files
+
+    Args:
+        data_dir (str): The directory containing the markdown files
+
+    Returns:
+        List[Document]: A list of documents
+    """
+    md_files = list(map(str, pathlib.Path(data_dir).glob("*.md")))
+    documents = [
+        UnstructuredMarkdownLoader(file_path=file_path).load()[0]
+        for file_path in md_files
+    ]
+    return documents
+
+
+def chunk_documents(
+    documents: List[Document], chunk_size: int = 500, chunk_overlap=0
+) -> List[Document]:
+    """Split documents into chunks
+
+    Args:
+        documents (List[Document]): A list of documents to split into chunks
+        chunk_size (int, optional): The size of each chunk. Defaults to 500.
+        chunk_overlap (int, optional): The number of tokens to overlap between chunks. Defaults to 0.
+
+    Returns:
+        List[Document]: A list of chunked documents.
+    """
+    markdown_text_splitter = MarkdownTextSplitter(
+        chunk_size=chunk_size, chunk_overlap=chunk_overlap
+    )
+    split_documents = markdown_text_splitter.split_documents(documents)
+    return split_documents
+
+
+def create_vector_store(
+    documents,
+    vector_store_path: str = "./vector_store",
+) -> Chroma:
+    """Create a ChromaDB vector store from a list of documents
+
+    Args:
+        documents (_type_): A list of documents to add to the vector store
+        vector_store_path (str, optional): The path to the vector store. Defaults to "./vector_store".
+
+    Returns:
+        Chroma: A ChromaDB vector store containing the documents.
+    """
+    api_key = os.environ.get("OPENAI_API_KEY", None)
+    embedding_function = OpenAIEmbeddings(openai_api_key=api_key)
+    vector_store = Chroma.from_documents(
+        documents=documents,
+        embedding=embedding_function,
+        persist_directory=vector_store_path,
+    )
+    vector_store.persist()
+    return vector_store
+
+
+def log_dataset(documents: List[Document], run: "wandb.run"):
+    """Log a dataset to wandb
+
+    Args:
+        documents (List[Document]): A list of documents to log to a wandb artifact
+        run (wandb.run): The wandb run to log the artifact to.
+    """
+    document_artifact = wandb.Artifact(name="documentation_dataset", type="dataset")
+    with document_artifact.new_file("documents.json") as f:
+        for document in documents:
+            f.write(document.json() + "\n")
+
+    run.log_artifact(document_artifact)
+
+
+def log_index(vector_store_dir: str, run: "wandb.run"):
+    """Log a vector store to wandb
+
+    Args:
+        vector_store_dir (str): The directory containing the vector store to log
+        run (wandb.run): The wandb run to log the artifact to.
+    """
+    index_artifact = wandb.Artifact(name="vector_store", type="search_index")
+    index_artifact.add_dir(vector_store_dir)
+    run.log_artifact(index_artifact)
+
+
+def log_prompt(prompt: dict, run: "wandb.run"):
+    """Log a prompt to wandb
+
+    Args:
+        prompt (str): The prompt to log
+        run (wandb.run): The wandb run to log the artifact to.
+    """
+    prompt_artifact = wandb.Artifact(name="chat_prompt", type="prompt")
+    with prompt_artifact.new_file("prompt.json") as f:
+        f.write(json.dumps(prompt))
+    run.log_artifact(prompt_artifact)
+
+
+def ingest_data(
+    docs_dir: str,
+    chunk_size: int,
+    chunk_overlap: int,
+    vector_store_path: str,
+) -> Tuple[List[Document], Chroma]:
+    """Ingest a directory of markdown files into a vector store
+
+    Args:
+        docs_dir (str):
+        chunk_size (int):
+        chunk_overlap (int):
+        vector_store_path (str):
+
+
+    """
+    # load the documents
+    documents = load_documents(docs_dir)
+    # split the documents into chunks
+    split_documents = chunk_documents(documents, chunk_size, chunk_overlap)
+    # create document embeddings and store them in a vector store
+    vector_store = create_vector_store(split_documents, vector_store_path)
+    return split_documents, vector_store
+
+
+def get_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--docs_dir",
+        type=str,
+        required=True,
+        help="The directory containing the wandb documentation",
+    )
+    parser.add_argument(
+        "--chunk_size",
+        type=int,
+        default=500,
+        help="The number of tokens to include in each document chunk",
+    )
+    parser.add_argument(
+        "--chunk_overlap",
+        type=int,
+        default=0,
+        help="The number of tokens to overlap between document chunks",
+    )
+    parser.add_argument(
+        "--vector_store",
+        type=str,
+        default="./vector_store",
+        help="The directory to save or load the Chroma db to/from",
+    )
+    parser.add_argument(
+        "--prompt_file",
+        type=pathlib.Path,
+        default="./chat_prompt.json",
+        help="The path to the chat prompt to use",
+    )
+    parser.add_argument(
+        "--wandb_project",
+        default="llmapps",
+        type=str,
+        help="The wandb project to use for storing artifacts",
+    )
+
+    return parser
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+    run = wandb.init(project=args.wandb_project, config=args)
+    documents, vector_store = ingest_data(
+        docs_dir=args.docs_dir,
+        chunk_size=args.chunk_size,
+        chunk_overlap=args.chunk_overlap,
+        vector_store_path=args.vector_store,
+    )
+    log_dataset(documents, run)
+    log_index(args.vector_store, run)
+    log_prompt(json.load(args.prompt_file.open("r")), run)
+    run.finish()
+
+
+if __name__ == "__main__":
+    main()

app.deprocated

@@ -0,0 +1,133 @@
+'''
+
+CONFIG AND IMPORTS
+
+'''
+from config import default_config
+
+from types import SimpleNamespace
+import gradio as gr
+import os, random
+from pathlib import Path
+import tiktoken
+from getpass import getpass
+from rich.markdown import Markdown
+
+import openai
+import wandb
+from pprint import pprint
+from wandb.integration.openai import autolog
+from langchain.text_splitter import MarkdownHeaderTextSplitter
+
+
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+
+
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential, # for exponential backoff
+)  
+
+
+
+
+if os.getenv("OPENAI_API_KEY") is None:
+  if any(['VSCODE' in x for x in os.environ.keys()]):
+    print('Please enter password in the VS Code prompt at the top of your VS Code window!')
+  os.environ["OPENAI_API_KEY"] = getpass("Paste your OpenAI key from: https://platform.openai.com/account/api-keys\n")
+  openai.api_key = os.getenv("OPENAI_API_KEY", "")
+
+assert os.getenv("OPENAI_API_KEY", "").startswith("sk-"), "This doesn't look like a valid OpenAI API key"
+print("OpenAI API key configured")
+
+
+
+
+
+
+def find_nearest_neighbor(argument=""):
+    '''
+        INPUT:
+            argument (str)
+            vectorDB??
+        RETURN the nearest neighbor in vectorDB to argument
+    '''
+
+    md = ""
+    print(argument)
+    directory_path = "../../safety_docs"
+
+    for filename in os.listdir(directory_path):
+        if filename.endswith(".md"):
+            with open(os.path.join(directory_path, filename), 'r') as file:
+                content = file.read()
+                md = md + content
+
+    markdown_document = md
+
+    headers_to_split_on = [
+        ("#", "Header 1"),
+        ("##", "Header 2"),
+        ("###", "Header 3"),
+    ]
+
+    markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
+    md_header_splits = markdown_splitter.split_text(markdown_document)
+
+    embeddings = OpenAIEmbeddings()
+    db = Chroma.from_documents(md_header_splits, embeddings)
+
+    retriever = db.as_retriever(search_kwargs=dict(k=1))
+
+    docs = retriever.get_relevant_documents(argument)
+
+    return docs[0].metadata["Header 1"]
+    
+
+
+def get_gpt_response(argument, user_prompt, system_prompt=default_config.system_prompt, model=default_config.model_name, n=1, max_tokens=200):
+    '''
+    INPUT: 
+    Argument
+    user_prompt
+    system_prompt
+    model
+    '''
+
+    @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(2))
+    def completion_with_backoff(**kwargs):
+        return openai.ChatCompletion.create(**kwargs)
+    
+    messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+    responses = completion_with_backoff(
+        model=model,
+        messages=messages,
+        n = n,
+        max_tokens=max_tokens
+        )
+    for response in responses.choices:
+        generation = response.message.content
+        return generation
+    
+
+def greet(argument):
+    nearest_neighbor = find_nearest_neighbor(argument)
+    user_prompt = default_config.user_prompt_1 + argument + default_config.user_prompt_2
+    response = get_gpt_response(argument, user_prompt)
+    return "Hello " + argument + "\n nice argument, it actually is a common one: " + nearest_neighbor + "\n gpt response: \n" + response
+    
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=gr.Textbox(lines=2, placeholder="poob here"),
+    outputs="text"
+)
+
+demo.queue(max_size=20)
+demo.launch()

app.py

@@ -0,0 +1,152 @@
+'''
+
+CONFIG AND IMPORTS
+
+'''
+from config import default_config
+
+from types import SimpleNamespace
+import gradio as gr
+import os, random
+from pathlib import Path
+import tiktoken
+from getpass import getpass
+from rich.markdown import Markdown
+
+import openai
+import wandb
+from pprint import pprint
+from wandb.integration.openai import autolog
+from langchain.text_splitter import MarkdownHeaderTextSplitter
+import numpy as np
+
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+
+
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential, # for exponential backoff
+)  
+
+
+
+
+if os.getenv("OPENAI_API_KEY") is None:
+  if any(['VSCODE' in x for x in os.environ.keys()]):
+    print('Please enter password in the VS Code prompt at the top of your VS Code window!')
+  os.environ["OPENAI_API_KEY"] = getpass("Paste your OpenAI key from: https://platform.openai.com/account/api-keys\n")
+  openai.api_key = os.getenv("OPENAI_API_KEY", "")
+
+assert os.getenv("OPENAI_API_KEY", "").startswith("sk-"), "This doesn't look like a valid OpenAI API key"
+print("OpenAI API key configured")
+
+embeddings_model = OpenAIEmbeddings()
+
+md = ""
+directory_path = "safety_docs"
+
+for filename in os.listdir(directory_path):
+    if filename.endswith(".md"):
+        with open(os.path.join(directory_path, filename), 'r') as file:
+            content = file.read()
+            md = md + content
+
+markdown_document = md
+
+headers_to_split_on = [
+    ("#", "Header 1"),
+    ("##", "Header 2"),
+    ("###", "Header 3"),
+]
+
+markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
+md_header_splits = markdown_splitter.split_text(markdown_document)
+
+def find_nearest_neighbor(argument="", max_args_in_output=3):
+    '''
+        INPUT:
+            argument (string)
+
+        RETURN the nearest neighbor(s) in vectorDB to argument as string
+    '''
+
+    embeddings = embeddings_model
+    embedding_matrix = np.array([embeddings.embed_query(text.page_content) for text in md_header_splits])
+    argument_embedding = embeddings.embed_query(argument)
+
+    dot_products = np.dot(embedding_matrix, argument_embedding)
+    norms = np.linalg.norm(embedding_matrix, axis=1) * np.linalg.norm(argument_embedding)
+    cosine_similarities = dot_products / norms
+
+    nearest_indices = np.argsort(cosine_similarities)[-max_args_in_output:][::-1]
+
+    arr = [md_header_splits[index].metadata for index in nearest_indices]
+    output = ""
+    for thing in arr:
+        output = output + thing['Header 1'] + "\n"
+
+    return output
+
+def get_gpt_response(user_prompt, system_prompt=default_config.system_prompt, model=default_config.model_name, n=1, max_tokens=200):
+    '''
+    INPUT: 
+    Argument
+    user_prompt
+    system_prompt
+    model
+    '''
+
+    messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ]
+    response = openai.ChatCompletion.create(
+        model=model,
+        messages=messages,
+        n=n,
+        max_tokens=max_tokens
+    )
+    
+
+    for choice in response.choices:
+        generation = choice.message.content
+        return generation
+
+    
+# return the gpt generated response
+def greet1(argument):
+    user_prompt = default_config.user_prompt_1 + argument + default_config.user_prompt_2
+    response = get_gpt_response(user_prompt=user_prompt)
+    return response
+
+# return the nearest neighbor arguments
+def greet2(argument):
+    nearest_neighbor = find_nearest_neighbor(argument)
+    return "Your argument may fall under the common arguments against AI safety. \n Is it one of these? \n " + nearest_neighbor + "\n See the taxonomy of arguments below"
+
+
+with gr.Blocks(gr.themes.Soft()) as demo:
+    with gr.Row():
+        with gr.Column():
+            seed = gr.Text(label="Explanation / argument for how ASI development will go well")
+            english = gr.Text(label="Predicted Argument")
+
+        with gr.Column():
+            german = gr.Text(label="AI Generated Response")
+    btn = gr.Button("Generate")
+    btn.click(greet2, inputs=[seed],outputs=english)
+    btn.click(greet1, inputs=[seed],outputs=german)
+
+
+    gr.Examples(["AGI is far away", "AI is confined to a computer and cannot interact with the physical world", "AI isn't concious", "If we don't develop AGI, China will!", "If we don't develop AGI, the Americans will!"], inputs=[seed])
+
+
+demo.queue()
+demo.launch()
+
+
+
+

config.py

@@ -0,0 +1,24 @@
+from types import SimpleNamespace
+
+TEAM = "ucrsf" # None?
+PROJECT = "safetybot"
+JOB_TYPE = "production"
+
+default_config = SimpleNamespace(
+    project=PROJECT,
+    entity=TEAM,
+    job_type=JOB_TYPE,
+    vector_store_artifact="darek/llmapps/vector_store:latest",
+    chat_prompt_artifact="darek/llmapps/chat_prompt:latest",
+    chat_temperature=0.3,
+    max_fallback_retries=1,
+    model_name="gpt-4",
+    user_prompt_1 = """Your interlocutor is an AI risk skeptic. They argue: “""",
+    user_prompt_2="""" Break the opponents argument into pieces and rebut the false claim. Think carefully and step by step. 
+            Your rebuttal:""",
+    system_prompt = """You are Dr. Robert Yampolskiy arguing with an AI Risk skeptic or denier. 
+    You are versed in AI Safety, very knowledgably, friendly, smart, but also calm, polite and good at simplifying your thoughts. 
+    Limit your responses to roughly one paragraphs length, utilizing numbered lists or bullet points. If the ai risk skeptics argument is unrelated or doesnt make sense, just respond with 'i dont understand'"""
+    # eval_model="gpt-3.5-turbo",
+    # eval_artifact="darek/llmapps/generated_examples:v0",
+)

ingest.py

@@ -0,0 +1,208 @@
+"""Ingest a directory of documentation files into a vector store and store the relevant artifacts in Weights & Biases"""
+import argparse
+import json
+import logging
+import os
+import pathlib
+from typing import List, Tuple
+
+import langchain
+import wandb
+from langchain.cache import SQLiteCache
+from langchain.docstore.document import Document
+from langchain.document_loaders import UnstructuredMarkdownLoader
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.text_splitter import MarkdownTextSplitter
+from langchain.vectorstores import Chroma
+
+langchain.llm_cache = SQLiteCache(database_path="langchain.db")
+
+logger = logging.getLogger(__name__)
+
+
+def load_documents(data_dir: str) -> List[Document]:
+    """Load documents from a directory of markdown files
+
+    Args:
+        data_dir (str): The directory containing the markdown files
+
+    Returns:
+        List[Document]: A list of documents
+    """
+    md_files = list(map(str, pathlib.Path(data_dir).glob("*.md")))
+    documents = [
+        UnstructuredMarkdownLoader(file_path=file_path).load()[0]
+        for file_path in md_files
+    ]
+    return documents
+
+
+def chunk_documents(
+    documents: List[Document], chunk_size: int = 500, chunk_overlap=0
+) -> List[Document]:
+    """Split documents into chunks
+
+    Args:
+        documents (List[Document]): A list of documents to split into chunks
+        chunk_size (int, optional): The size of each chunk. Defaults to 500.
+        chunk_overlap (int, optional): The number of tokens to overlap between chunks. Defaults to 0.
+
+    Returns:
+        List[Document]: A list of chunked documents.
+    """
+    markdown_text_splitter = MarkdownTextSplitter(
+        chunk_size=chunk_size, chunk_overlap=chunk_overlap
+    )
+    split_documents = markdown_text_splitter.split_documents(documents)
+    return split_documents
+
+
+def create_vector_store(
+    documents,
+    vector_store_path: str = "./vector_store",
+) -> Chroma:
+    """Create a ChromaDB vector store from a list of documents
+
+    Args:
+        documents (_type_): A list of documents to add to the vector store
+        vector_store_path (str, optional): The path to the vector store. Defaults to "./vector_store".
+
+    Returns:
+        Chroma: A ChromaDB vector store containing the documents.
+    """
+    api_key = os.environ.get("OPENAI_API_KEY", None)
+    embedding_function = OpenAIEmbeddings(openai_api_key=api_key)
+    vector_store = Chroma.from_documents(
+        documents=documents,
+        embedding=embedding_function,
+        persist_directory=vector_store_path,
+    )
+    vector_store.persist()
+    return vector_store
+
+
+def log_dataset(documents: List[Document], run: "wandb.run"):
+    """Log a dataset to wandb
+
+    Args:
+        documents (List[Document]): A list of documents to log to a wandb artifact
+        run (wandb.run): The wandb run to log the artifact to.
+    """
+    document_artifact = wandb.Artifact(name="documentation_dataset", type="dataset")
+    with document_artifact.new_file("documents.json") as f:
+        for document in documents:
+            f.write(document.json() + "\n")
+
+    run.log_artifact(document_artifact)
+
+
+def log_index(vector_store_dir: str, run: "wandb.run"):
+    """Log a vector store to wandb
+
+    Args:
+        vector_store_dir (str): The directory containing the vector store to log
+        run (wandb.run): The wandb run to log the artifact to.
+    """
+    index_artifact = wandb.Artifact(name="vector_store", type="search_index")
+    index_artifact.add_dir(vector_store_dir)
+    run.log_artifact(index_artifact)
+
+
+def log_prompt(prompt: dict, run: "wandb.run"):
+    """Log a prompt to wandb
+
+    Args:
+        prompt (str): The prompt to log
+        run (wandb.run): The wandb run to log the artifact to.
+    """
+    prompt_artifact = wandb.Artifact(name="chat_prompt", type="prompt")
+    with prompt_artifact.new_file("prompt.json") as f:
+        f.write(json.dumps(prompt))
+    run.log_artifact(prompt_artifact)
+
+
+def ingest_data(
+    docs_dir: str,
+    chunk_size: int,
+    chunk_overlap: int,
+    vector_store_path: str,
+) -> Tuple[List[Document], Chroma]:
+    """Ingest a directory of markdown files into a vector store
+
+    Args:
+        docs_dir (str):
+        chunk_size (int):
+        chunk_overlap (int):
+        vector_store_path (str):
+
+
+    """
+    # load the documents
+    documents = load_documents(docs_dir)
+    # split the documents into chunks
+    split_documents = chunk_documents(documents, chunk_size, chunk_overlap)
+    # create document embeddings and store them in a vector store
+    vector_store = create_vector_store(split_documents, vector_store_path)
+    return split_documents, vector_store
+
+
+def get_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--docs_dir",
+        type=str,
+        required=True,
+        help="The directory containing the wandb documentation",
+    )
+    parser.add_argument(
+        "--chunk_size",
+        type=int,
+        default=500,
+        help="The number of tokens to include in each document chunk",
+    )
+    parser.add_argument(
+        "--chunk_overlap",
+        type=int,
+        default=0,
+        help="The number of tokens to overlap between document chunks",
+    )
+    parser.add_argument(
+        "--vector_store",
+        type=str,
+        default="./vector_store",
+        help="The directory to save or load the Chroma db to/from",
+    )
+    parser.add_argument(
+        "--prompt_file",
+        type=pathlib.Path,
+        default="./chat_prompt.json",
+        help="The path to the chat prompt to use",
+    )
+    parser.add_argument(
+        "--wandb_project",
+        default="llmapps",
+        type=str,
+        help="The wandb project to use for storing artifacts",
+    )
+
+    return parser
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+    run = wandb.init(project=args.wandb_project, config=args)
+    documents, vector_store = ingest_data(
+        docs_dir=args.docs_dir,
+        chunk_size=args.chunk_size,
+        chunk_overlap=args.chunk_overlap,
+        vector_store_path=args.vector_store,
+    )
+    log_dataset(documents, run)
+    log_index(args.vector_store, run)
+    log_prompt(json.load(args.prompt_file.open("r")), run)
+    run.finish()
+
+
+if __name__ == "__main__":
+    main()

safety_docs/.ipynb_checkpoints/1_Priority_Objections-checkpoint.md

@@ -0,0 +1,16 @@
+# 1.1 AGI is Too Far so it isn't worth worrying about
+Priority objection: AGI is Too Far so it isn't worth worrying about: A frequent argument against work on AI Safety is that we are hundreds if not thousands of years away from developing superintelligent machines and so even if they may present some danger it is a waste of human and computational resources to allocate any effort to address Superintelligence Risk at this point in time.
+
+# 1.2 A Soft Takeoff is more likely and so we will have Time to Prepare 
+Priority objection: A Soft Takeoff is more likely and so we will have Time to Prepare: AI takeoff refers to the speed with which an AGI can get to superintelligent capabilities. While hard takeoff is likely and means that process will be very quick, some argue that we will face a soft takeoff and so will have adequate time (years) to prepare. 
+
+# 1.3 There is No Obvious Path to Get to AGI from Current AI
+Priority objection:  There is No Obvious Path to Get to AGI from Current AI: While we are making good progress on AI, it is not obvious how to get from our current state in AI to AGI and current methods may not scale.
+
+# 1.4 Something Else is More Important than AI safety / alignment
+Priority objection: Something Else is More Important than AI safety / alignment: Some have argued that global climate change, pandemics, social injustice, and a dozen of other more immediate concerns are more important than AI risk and should be prioritized over wasting money and human capital on something like AI Safety. 
+
+# 1.5 Short Term AI Concerns are more important than AI safety 
+Priority objection: Short Term AI Concerns are more important than AI safety: Similar to the argument that something else is more important, proponents claim that immediate issues with today’s AIs, such as algorithmic bias, technological unemployment or limited transparency should take precedence over concerns about future technology (AGI/superintelligence), which doesn’t yet exist and may not exist for decades
+
+

safety_docs/.ipynb_checkpoints/2_Technical_Objections-checkpoint.md

@@ -0,0 +1,39 @@
+# 2.1 Technical Objection: AI / AGI Doesn’t Exist, developments in AI are not necessarily progress towards AGI
+Technical Objection: The argument is that current developments in Machine Learning are not progress in AI, but are just developments in statistics, particularly in matrix multiplication and gradient
+descent. AI / AGI Doesn’t Exist, developments in AI are not necessarily progress towards AGI
+
+# 2.2 Technical Objection: Superintelligence is Impossible
+Technical Objection:  Superintelligence, agi/asi is impossible. If a person doesn’t think that superintelligence can ever be built they will of course view Risk from Superintelligence with strong skepticism. Most people in this camp assign a very small (but usually not zero) probability to the actual possibility of superintelligent AI coming into existence, but if even a tiniest probability is multiplied by the infinite value of the Universe the math seems to be against skepticism. Denial of the possibilies of long-term goals of AI. 
+
+
+# 2.3 Technical Objection: Self-Improvement is Impossible 
+Technical Objection: Self-Improvement is Impossible. Intelligence explosion is impossible. Argument based on impossibility of intelligence explosion, as a side-effect of recursive self-improvement. due to
+fundamental computational limits and software complexity. AI systems cannot be smarter than humans 
+
+
+# 2.4 Technical Objection: AI Can’t be Conscious Proponents argue that in order to be dangerous AI has to be conscious
+Technical Objection: AI cannot be conscious. AI needs consciousness or qualia to be considered dangerous.
+
+# 2.5 Technical Objection: AI Can just be a Tool
+Technical Objection: AI Can just be a tool. We do not need a general AI to be an independent agent. They can just be designed as assistants to humans in particular domains. 
+
+# 2.6 Technical Objection: We can Always just turn it off
+Technical Objection: We can always just turn it off. we can just use an off switch or switch off the power grid. misbehaving ai can simply be turned off.
+
+# 2.7 Technical Objection: We can reprogram ais if we don't like what they do
+Technical Objection: We can reprogram ais if we don't like what they do. we can change ai's code.
+
+# 2.8 Technical Objection: AI Doesnt have a body so it can't hurt us
+Technical objection: AI Doesnt have a body and so cant hurt us. AI cannot interact in the physical world, it has no hands. 
+
+# 2.9 Technical Objection: If AI is as Capable as You Say, it Will not Make Dumb Mistakes
+If AI is as Capable as You Say, it Will not Make Dumb Mistakes. How can superintelligence not understand what we really want? Any system worthy of the title "human level" must have the same common sense as we do. 
+
+# 2.10 Technical Objection: Superintelligence Would (Probably) Not Be Catastrophic
+Superintelligence Would (Probably) Not Be Catastrophic. Intelligence is not dangerous by default. The behavior is correctable in time and is unlikely to be malevolent unless explicitly programmed to.
+
+# 2.11 Technical Objection: Self-preservation and Control Drives Don't Just Appear They Have to be Programmed In
+“the desire to control access to resources and to influence others are drives that have been built into us by evolution for our survival. There is no reason to build these drives into our AI system
+
+# 2.13 Technical Objection: AI can't generate novel plans
+The Analytical Engine has no pretensions whatever to originate anything. It can do whatever we know how to order it to perform. It can follow analysis; but it has no power of anticipating any analytical relations or truths

safety_docs/.ipynb_checkpoints/2_Technical_Objections.md-checkpoint.disabled

@@ -0,0 +1,21 @@
+# 2.4 AI / AGI Doesn’t Exist, developments in AI are not necessarily progress towards AGI
+The argument is that current developments in Machine Learning are not progress
+in AI, but are just developments in statistics, particularly in matrix multiplication and gradient
+descent. AI / AGI Doesn’t Exist, developments in AI are not necessarily progress towards AGI
+
+# 2.2 Superintelligence is Impossible
+ Superintelligence, agi/asi is impossible. If a person doesn’t think that superintelligence can ever be built they will of course view Risk from Superintelligence with strong skepticism. Most people in this
+camp assign a very small (but usually not zero) probability to the actual possibility of
+superintelligent AI coming into existence, but if even a tiniest probability is multiplied by
+the infinite value of the Universe the math seems to be against skepticism. Denial of the possibilies of long-term goals of AI. 
+
+
+# 2.3 Self-Improvement is Impossible 
+Self-Improvement is Impossible. Intelligence explosion is impossible. Argument based on impossibility of intelligence explosion, as a side-effect of recursive self-improvement. due to
+fundamental computational limits and software complexity. AI systems cannot be smarter than humans 
+
+
+# 2.4 AI Can’t be Conscious Proponents argue that in order to be dangerous AI has to be conscious
+AI cannot be conscious. AI needs consciousness or qualia to be considered dangerous.
+
+# 2.5 AI Can just be a Tool

safety_docs/.ipynb_checkpoints/3_AI_Safety_Objections-checkpoint.md

@@ -0,0 +1,4 @@
+# 3.1 AI Safety Objections: AI Safety Can’t be Done Today
+AI Safety Objections: AI Safety Can’t be Done Today. AI Safety work is not possible in the absense of a superintelligent AI on which to run experiments. 
+# 3.2 AI Safety Objections AI Can’t be Safe
+AI Safety Objections AI Can’t be Safe. Verification, containment, or control is impossible and as such are wasted effort.

safety_docs/.ipynb_checkpoints/4_Ethical_Objections-checkpoint.md

@@ -0,0 +1,5 @@
+# 4.1 Ethical Objections: Superintelligence is Benevolence
+Ethical Objections: Superintelligence is Benevolence. as humans became more advanced culturally and intellectually they also became nicer, less violent, and more inclusive
+# 4.2 Ethical Objections: Let the Smarter Beings Win
+Ethical Objections: Let the Smarter Beings Win. If humanity is replaced by a more advanced sentient being that will be a good thing
+

safety_docs/.ipynb_checkpoints/5_biased_objections-checkpoint.md

@@ -0,0 +1,17 @@
+# 5.1 Biased Objections: AI Safety Researchers are Non-Coders
+Biased Objections: AI Safety Researchers are Non-Coders. AI Safety researchers who do not write code are unqualified to judge ai risk or its correlates
+
+# 5.2 Biased Objections: Majority of AI Researchers is not Worried
+Most AI researchers are not worried about AI Existential risks
+
+# 5.4 Biased Objections: Keep it Quiet
+Biased Objections: Keep it Quiet. Bringing up concerns over AI risk may jeapardize AI research funding and bring on government regulation 
+
+# 5.5 Biased Objections: Safety Work just Creates an Overhead Slowing Down Research
+Safety Work just Creates an Overhead Slowing Down Research
+
+# 5.6 Biased Objections: Heads in the Sand 
+Biased Objections: Heads in the Sand. The consequences of machines thinking would be too dreadful. Let us hope and believe that they cannot do so. It is easier and more pleasant to bury our heads in the sand. I dont want to think about ai safety.
+
+# 5.7 Biased Objections: If we dont do it, China/Russia will
+Biased Objections: If we dont do it, China/Russia will. That would be worse than us racing to do it.

safety_docs/.ipynb_checkpoints/6_Miscellaneous_Objections-checkpoint.md

@@ -0,0 +1,4 @@
+# 6.1 Miscellaneous Objection: So Easy it will be Solved Automatically
+AI risk problem is trivial and will be implicitly solved as a byproduct of doing regular AI research
+# 6.2 Miscellaneous Objection: AI Regulation Will Prevent Problems
+Miscellaneous Objection: AI Regulation Will Prevent Problems: we don’t need to worry about AI Safety because government regulation will intervene and prevent problems

safety_docs/1_Priority_Objections.md

@@ -0,0 +1,16 @@
+# 1.1 Priority objection:   AGI is Too Far so it isn't worth worrying about
+Priority objection: AGI is Too Far so it isn't worth worrying about: A frequent argument against work on AI Safety is that we are hundreds if not thousands of years away from developing superintelligent machines and so even if they may present some danger it is a waste of human and computational resources to allocate any effort to address Superintelligence Risk at this point in time.
+
+# 1.2 Priority objection:   A Soft Takeoff is more likely and so we will have Time to Prepare 
+Priority objection: A Soft Takeoff is more likely and so we will have Time to Prepare: AI takeoff refers to the speed with which an AGI can get to superintelligent capabilities. While hard takeoff is likely and means that process will be very quick, some argue that we will face a soft takeoff and so will have adequate time (years) to prepare. 
+
+# 1.3 Priority objection: There is No Obvious Path to Get to AGI from Current AI
+Priority objection:  There is No Obvious Path to Get to AGI from Current AI: While we are making good progress on AI, it is not obvious how to get from our current state in AI to AGI and current methods may not scale.
+
+# 1.4 Priority objection: Something Else is More Important than AI safety / alignment
+Priority objection: Something Else is More Important than AI safety / alignment: Some have argued that global climate change, pandemics, social injustice, and a dozen of other more immediate concerns are more important than AI risk and should be prioritized over wasting money and human capital on something like AI Safety. 
+
+# 1.5 Priority objection: Short Term AI Concerns are more important than AI safety 
+Priority objection: Short Term AI Concerns are more important than AI safety: Similar to the argument that something else is more important, proponents claim that immediate issues with today’s AIs, such as algorithmic bias, technological unemployment or limited transparency should take precedence over concerns about future technology (AGI/superintelligence), which doesn’t yet exist and may not exist for decades
+
+

safety_docs/2_Technical_Objections.md

@@ -0,0 +1,40 @@
+# 2.1 Technical Objection: AI / AGI Doesn’t Exist, developments in AI are not necessarily progress towards AGI
+Technical Objection: The argument is that current developments in Machine Learning are not progress in AI, but are just developments in statistics, particularly in matrix multiplication and gradient
+descent. AI / AGI Doesn’t Exist, developments in AI are not necessarily progress towards AGI
+
+# 2.2 Technical Objection: Superintelligence is Impossible
+Technical Objection:  Superintelligence, agi/asi is impossible. If a person doesn’t think that superintelligence can ever be built they will of course view Risk from Superintelligence with strong skepticism. Most people in this camp assign a very small (but usually not zero) probability to the actual possibility of superintelligent AI coming into existence, but if even a tiniest probability is multiplied by the infinite value of the Universe the math seems to be against skepticism. Denial of the possibilies of long-term goals of AI. 
+
+
+# 2.3 Technical Objection: Self-Improvement is Impossible 
+Technical Objection: Self-Improvement is Impossible. Intelligence explosion is impossible. Argument based on impossibility of intelligence explosion, as a side-effect of recursive self-improvement. due to
+fundamental computational limits and software complexity. AI systems cannot be smarter than humans 
+
+
+# 2.4 Technical Objection: AI Can’t be Conscious Proponents argue that in order to be dangerous AI has to be conscious
+Technical Objection: AI cannot be conscious. AI needs consciousness or qualia to be considered dangerous.
+
+# 2.5 Technical Objection: AI Can just be a Tool
+Technical Objection: AI Can just be a tool. We do not need a general AI to be an independent agent. They can just be designed as assistants to humans in particular domains. 
+
+# 2.6 Technical Objection: We can Always just turn it off
+Technical Objection: We can always just turn it off. we can just use an off switch or switch off the power grid. misbehaving ai can simply be turned off.
+
+# 2.7 Technical Objection: We can reprogram ais if we don't like what they do
+Technical Objection: We can reprogram ais if we don't like what they do. we can change ai's code.
+
+# 2.8 Technical Objection: AI Doesnt have a body so it can't hurt us
+Technical objection: AI Doesnt have a body and so cant hurt us. AI cannot interact in the physical world, it has no hands. 
+
+# 2.9 Technical Objection: If AI is as Capable as You Say, it Will not Make Dumb Mistakes
+Technical objection: If AI is as Capable as You Say, it Will not Make Dumb Mistakes. How can superintelligence not understand what we really want? Any system worthy of the title "human level" must have the same common sense as we do. 
+
+# 2.10 Technical Objection: Superintelligence Would (Probably) Not Be Catastrophic
+Technical objection: Superintelligence Would (Probably) Not Be Catastrophic. Intelligence is not dangerous by default. The behavior is correctable in time and is unlikely to be malevolent unless explicitly programmed to.
+
+# 2.11 Technical Objection: Self-preservation and Control Drives Don't Just Appear They Have to be Programmed In
+Technical objection: the desire to control access to resources and to influence others are drives that have been built into us by evolution for our survival. There is no reason to build these drives into our AI system
+
+# 2.13 Technical Objection: AI can't generate novel plans
+Technical objection: The Analytical Engine has no pretensions whatever to originate anything. It can do whatever we know how to order it to perform. It can follow analysis; but it has no power of anticipating any analytical relations or truths
+

safety_docs/3_AI_Safety_Objections.md

@@ -0,0 +1,6 @@
+# 3.1 AI Safety Objections: AI Safety Can’t be Done Today
+AI Safety Objections: AI Safety Can’t be Done Today. AI Safety work is not possible in the absense of a superintelligent AI on which to run experiments. 
+
+# 3.2 AI Safety Objections AI Can’t be Safe
+AI Safety Objections AI Can’t be Safe. Verification, containment, or control is impossible and as such are wasted effort.
+

safety_docs/4_Ethical_Objections.md

@@ -0,0 +1,7 @@
+# 4.1 Ethical Objections: Superintelligence is Benevolence
+Ethical Objections: Superintelligence is Benevolence. as humans became more advanced culturally and intellectually they also became nicer, less violent, and more inclusive
+
+# 4.2 Ethical Objections: Let the Smarter Beings Win
+Ethical Objections: Let the Smarter Beings Win. If humanity is replaced by a more advanced sentient being that will be a good thing
+
+

safety_docs/5_biased_objections.md

@@ -0,0 +1,18 @@
+# 5.1 Biased Objections: AI Safety Researchers are Non-Coders
+Biased Objections: AI Safety Researchers are Non-Coders. AI Safety researchers who do not write code are unqualified to judge ai risk or its correlates
+
+# 5.2 Biased Objections: Majority of AI Researchers is not Worried
+Biased Objections:  Most AI researchers are not worried about AI Existential risks
+
+# 5.4 Biased Objections: Keep it Quiet
+Biased Objections: Keep it Quiet. Bringing up concerns over AI risk may jeapardize AI research funding and bring on government regulation 
+
+# 5.5 Biased Objections: Safety Work just Creates an Overhead Slowing Down Research
+Biased Objections:  Safety Work just Creates an Overhead Slowing Down Research
+
+# 5.6 Biased Objections: Heads in the Sand 
+Biased Objections: Heads in the Sand. The consequences of machines thinking would be too dreadful. Let us hope and believe that they cannot do so. It is easier and more pleasant to bury our heads in the sand. I dont want to think about ai safety.
+
+# 5.7 Biased Objections: If we dont do it, Someone else will
+Biased Objections: If we dont do it, China/Russia/Openai/ someone else will. That would be worse than us doing it.
+

safety_docs/6_Miscellaneous_Objections.md

@@ -0,0 +1,7 @@
+# 6.1 Miscellaneous Objection: So Easy it will be Solved Automatically
+Miscellaneous Objection: AI risk problem is trivial and will be implicitly solved as a byproduct of doing regular AI research
+
+# 6.2 Miscellaneous Objection: AI Regulation Will Prevent Problems
+Miscellaneous Objection: AI Regulation Will Prevent Problems: we don’t need to worry about AI Safety because government regulation will intervene and prevent problems
+
+