Upload 105 files

.gitattributes

@@ -34,3 +34,74 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 llama-2-7b-chat.Q4_K_M.gguf filter=lfs diff=lfs merge=lfs -text
+src/assets/flower_tech.png filter=lfs diff=lfs merge=lfs -text
+src/assets/flower.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/flower2.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_0.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_1.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_10.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_11.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_12.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_13.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_14.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_15.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_16.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_17.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_18.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_19.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_2.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_20.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_21.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_22.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_23.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_24.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_25.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_26.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_27.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_28.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_29.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_3.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_30.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_31.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_32.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_33.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_34.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_35.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_36.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_37.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_38.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_39.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_4.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_40.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_41.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_42.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_43.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_44.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_45.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_46.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_47.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_48.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_49.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_5.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_50.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_51.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_52.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_53.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_54.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_55.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_56.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_57.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_58.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_59.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_6.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_60.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_61.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_62.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_63.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_64.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_65.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_66.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_67.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_7.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_8.png filter=lfs diff=lfs merge=lfs -text
+src/assets/plant_images/plant_9.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Danielle Heymann
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

app.py

@@ -0,0 +1,384 @@
+# import libraries
+import pandas as pd
+import numpy as np
+import os
+import time
+import math
+import streamlit as st
+#from streamlit_chat import message
+from streamlit_extras.colored_header import colored_header
+from streamlit_extras.add_vertical_space import add_vertical_space
+from PIL import Image
+
+# import modules
+from src.backend.chatbot import *
+from src.backend.optimization_algo import *
+from src.frontend.visualizations import *
+
+
+# import compatibilities matrix
+# make plant_compatibility.csv into a matrix. it currently has indexes as rows and columns for plant names and then compatibility values as the values
+st.session_state.raw_plant_compatibility = pd.read_csv('src/data/plant_compatibility.csv', index_col=0)
+# fill NaN values with 0
+st.session_state.raw_plant_compatibility = st.session_state.raw_plant_compatibility.fillna(0)
+# get list of plants
+st.session_state.plant_list = st.session_state.raw_plant_compatibility.index.tolist()
+
+
+
+# setup keys and api info
+OPENAI_API_KEY = st.secrets["OPENAI_API_KEY"]
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+
+
+
+#chat = ChatOpenAI()
+
+
+# UI page config
+st.set_page_config(
+    #page_title="GRDN.AI",
+    page_icon="🌱",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Function to display chat message with an icon
+def chat_message(message, is_user=False):
+    if is_user:
+        icon = Image.open("src/assets/cool.png") 
+        side = "left"
+    else:
+        icon = Image.open("src/assets/bot.png")  
+        side = "right"
+    
+    chat_container = st.container()
+
+    with chat_container:
+        col1, col2, col3, col4= st.columns([1,7,7,1])
+
+        with col1:
+            if is_user == True:
+                st.image(icon, width=50)
+
+        with col2:
+            if is_user == True:
+                st.markdown(f'<div style="text-align: {side};">{message}</div>', unsafe_allow_html=True)
+        with col3:
+            if is_user == False:
+                st.markdown(f'<div style="text-align: {side};">{message}</div>', unsafe_allow_html=True)
+        with col4:
+            if is_user == False:
+                st.image(icon, width=50)
+
+
+
+
+st.image ("src/assets/logo_title_transparent.png", caption=None, use_column_width=None, clamp=False, channels='RGB', output_format='auto')
+
+st.write("AI and optimization powered companion gardening")
+colored_header(label='', description='', color_name='green-30')
+
+# Sidebar
+# st.sidebar.title("Navigation")
+# page = st.sidebar.radio("Select a page:", ("Home", "Companion Gardening", "Optimization", "About"))
+
+# add vertical space
+with st.sidebar:
+    add_vertical_space(2)
+# Sidebar
+st.sidebar.title("Navigation")
+
+# Define the page options
+pages = ["Garden Optimization", "About"]
+
+# Render the selected page content
+page = st.sidebar.selectbox("Select a page:", pages)
+
+
+if page == "Garden Optimization":
+    st.sidebar.subheader("Companion Gardening")
+    st.write("GRDN is a companion gardening app that helps you plan your garden and maximize your harvest. It uses AI to predict the best plants to grow together and optimization algorithms to optimize how you build your garden.")
+    st.write("This app is currently in beta. Please report any bugs.")
+    companion_planting_info = """
+    Key Benefits 
+    - **Pest control:** 
+    - **Improved pollination:** 
+    - **Maximized space:** 
+    - **Nutrient enhancement:** 
+    - **Complementary growth:** 
+
+    """
+
+    st.sidebar.markdown(companion_planting_info)
+    # Set the initial value of user_name
+    if 'user_name' not in st.session_state:
+        st.session_state.user_name = ''
+    # add in some vertical space
+    add_vertical_space(3)
+    # Display the welcome message
+    st.title('Let\'s get started! Decide on your garden parameters')
+    
+    
+    # add in some vertical space
+    add_vertical_space(2)
+
+    # make a container for this section
+    container1 = st.container(border=True)
+
+    with container1:
+        # Modify the user_name variable based on user input
+        if st.session_state['user_name'] == '':
+            col1, col2, col3= st.columns([1,2,1])
+            with col1:
+                st.session_state['user_name_input'] = st.text_input('Enter your name', st.session_state.user_name)
+        if 'user_name_input' in st.session_state:
+            st.session_state.user_name = st.session_state.user_name_input
+            if st.session_state.user_name != '':
+                st.write('Hello ' + st.session_state['user_name'] + '! Let\'s optimize your garden. 🌱')
+
+                # # add in some vertical space
+                add_vertical_space(2)
+
+                print("")
+                print("____________________")
+                print("start of session")
+
+                col1a, col2a= st.columns([1,2])
+                enable_max_species = False
+                enable_min_species = False
+
+                
+                # make a form to get the plant list from the user
+                with col1a:
+                    with st.form(key = "plant_list_form"):
+                        input_plants_raw = st.multiselect('plants', st.session_state.plant_list)
+                        submit_button = st.form_submit_button(label='Submit Plant List')
+                if submit_button:
+                    st.session_state['input_plants_raw'] = input_plants_raw
+                    st.session_state.submitted_plant_list = True
+
+                # add in some vertical space
+                add_vertical_space(1)
+
+                with col2a:
+                    col1, col2, col3= st.columns([1,1,1])
+                    if 'input_plants_raw' in st.session_state:
+                        print("BP1")
+                        # first question is what plants would you like to plant
+                        plants_response = st.session_state.input_plants_raw
+
+                        # Initialize session state variables if they don't exist
+                        if 'n_plant_beds' not in st.session_state:
+                            st.session_state['n_plant_beds'] = 1
+
+                        if 'min_species' not in st.session_state:
+                            st.session_state['min_species'] = 1
+
+                        if 'max_species' not in st.session_state:
+                            st.session_state['max_species'] = 2
+
+                        # Number of plant beds input
+                        with col1:
+                            n_plant_beds = st.number_input('Number of plant beds \n', min_value=1, max_value=20, value=st.session_state.n_plant_beds, step=1)
+                            st.session_state.n_plant_beds = n_plant_beds
+                        with col2:
+                            # Minimum species per plant bed input
+                            min_species = st.number_input('Minimum number of species per plant bed', 
+                                                        min_value=1, 
+                                                        max_value=len(st.session_state.input_plants_raw), 
+                                                        value=st.session_state.min_species, 
+                                                        step=1)
+                            st.session_state.min_species = min_species
+
+                            # Maximum species per plant bed input
+                            # It will be enabled only if min_species is set
+                            enable_max_species = st.session_state.min_species > 0
+                        with col3:
+                            max_species = st.number_input('Maximum number of species per plant bed', 
+                                                        min_value=st.session_state.min_species, 
+                                                        max_value=len(st.session_state.input_plants_raw), 
+                                                        value=max(st.session_state.min_species, st.session_state.max_species), 
+                                                        step=1, 
+                                                        disabled=not enable_max_species)
+                            if enable_max_species:
+                                st.session_state.max_species = max_species
+
+                    # extract the compatibility matrix from the user's input
+                    if 'extracted_mat' not in st.session_state:
+                        valid = False
+                        if 'submitted_plant_list' in st.session_state and st.session_state.submitted_plant_list:
+                            # check if the user's input is valid
+                            # min species per bed must be less than or equal to max species per bed
+                            if (st.session_state.min_species <= st.session_state.max_species
+                                ) and (
+                                # max species per bed must be less than or equal to the number of plants 
+                                st.session_state.max_species <= len(st.session_state.input_plants_raw) 
+                                ) and (
+                                # max species per bed must be greater than or equal to the min species per bed
+                                st.session_state.max_species >= st.session_state.min_species
+                                ) and (
+                                # min species per bed must be less than or equal to the number of plants
+                                st.session_state.min_species <= len(st.session_state.input_plants_raw)
+                                ) and (
+                                # number of plant beds multiplied by min species per bed must be less than or equal to the number of plants
+                                len(st.session_state.input_plants_raw) >= st.session_state.n_plant_beds * st.session_state.min_species
+                                ) and (
+                                # number of plant beds multiplied by max species per bed must be greater than or equal to the number of plants
+                                len(st.session_state.input_plants_raw) <= st.session_state.n_plant_beds * st.session_state.max_species
+                                ):
+                                valid = True  
+                            else:
+                                # add a warning message
+                                st.warning('Please enter valid parameters. The minimum number of species per plant bed must be less than or equal to the maximum number of species per plant bed. The maximum number of species per plant bed must be less than or equal to the number of plants. The maximum number of species per plant bed must be greater than or equal to the minimum number of species per plant bed. The minimum number of species per plant bed must be less than or equal to the number of plants. The number of plant beds multiplied by the minimum number of species per plant bed must be less than or equal to the number of plants. The number of plant beds multiplied by the maximum number of species per plant bed must be greater than or equal to the number of plants.')
+
+                            if valid:
+                                # add in some vertical space
+                                add_vertical_space(2)
+                                if st.button('Generate Companion Plant Compatibility Matrix'):
+                                    with st.spinner('generating companion plant compatibility matrix...'):
+                                        st.session_state['generating_mat'] = True
+                                        # now get compatibility matrix for companion planting
+                                        time.sleep(1)
+                                        extracted_mat, full_mat, plant_index_mapping= get_compatibility_matrix_2(st.session_state.input_plants_raw)
+                                        print(extracted_mat)
+                                        st.session_state.extracted_mat = extracted_mat
+                                        st.session_state.full_mat = full_mat
+                                        st.session_state.plant_index_mapping = plant_index_mapping
+    # add in some vertical space
+    add_vertical_space(4)
+
+    # display the companion plant compatibility matrix
+    if 'extracted_mat' in st.session_state:
+        # add a title for the next section- companion plant compatibility matrix based on user input
+        st.title('Your companion plant compatibility matrix')
+        # make a container for this section
+        container2 = st.container(border=True)
+        with container2:
+            col1, col2 = st.columns([8,4])
+            # display the companion plant compatibility matrix
+            with col2:
+                st.write("Here is your companion plant compatibility matrix:")
+                with st.expander("Show ugly compatibility matrix of 1's 0's and -1's"):
+                    st.write(st.session_state.extracted_mat)
+            with col1:
+                st.write("Here is a network visualization of your companion plant compatibility matrix. It is color coded to show which plants are companions (green), antagonists (violetred), or neutral (grey).")
+                plot_compatibility_with_agraph(st.session_state.input_plants_raw, st.session_state.full_mat)
+                st.session_state['got_mat'] = True
+        
+        if 'got_mat' in st.session_state:
+            # add in some vertical space
+            add_vertical_space(4) 
+            # make a container for this section
+            container3 = st.container(border=True)
+            with container3:   
+                st.title('Optimizing companion planting with the genetic algorithm and AI')
+                st.write("Now that we have your companion plant compatibility matrix, we can use optimization to maximize your harvest. We will use a genetic algorithm to determine the best way to plant your garden. The genetic algorithm will determine the best way to plant your garden by maximizing the number of companion plants and minimizing the number of antagonists.")
+                st.write("Set the parameters for the genetic algorithm. Here is more info for your reference:")
+                with st.form(key = "genetic_algorithm_form"):
+                    col1, col2= st.columns([1,1])
+                    with col2:
+                        with st.expander("Show more information about the genetic algorithm parameters"):
+                            st.subheader("Plant Optimization Heuristic Performance")
+                            st.write("The genetic algorithm parameters impact the performance of the plant optimization heuristic in the following ways:")
+                            st.markdown("- **Population Size**: A larger population size allows for a more diverse exploration of the solution space. However, it also increases computational complexity.")
+                            st.markdown("- **Number of Generations**: Increasing the number of generations provides more opportunities for the algorithm to converge towards an optimal solution.")
+                            st.markdown("- **Tournament Size**: A larger tournament size promotes stronger selection pressure and can lead to faster convergence, but it may also increase the risk of premature convergence.")
+                            st.markdown("- **Crossover Rate**: A higher crossover rate increases the exploration capability by creating diverse offspring, potentially improving the algorithm's ability to escape local optima.")
+                            st.markdown("- **Mutation Rate**: Mutation introduces random changes in individuals, helping to maintain diversity in the population and preventing premature convergence.")
+                            # seed population rate
+                            st.markdown("- **Seed Population Rate**: The seed population rate is the percentage of the population that is generated based on the LLM's interpretation of compatibility. The remaining percentage of the population is generated randomly. A higher seed population rate increases the likelihood that the genetic algorithm will converge towards a solution that is compatible.")
+                    # Run the Genetic Algorithm
+                    with col1:
+                        st.subheader("Genetic Algorithm Parameters")
+                        st.write("These parameters control the behavior of the genetic algorithm.")
+
+                        # Genetic Algorithm parameters
+                        st.session_state.population_size = st.slider("Population Size", min_value=400, max_value=1000, value=500,
+                                                    help="The number of individuals in each generation of the genetic algorithm.")
+                        st.session_state.num_generations = st.slider("Number of Generations", min_value=400, max_value=1000, value=450,
+                                                    help="The total number of generations to evolve through.")
+                        st.session_state.tournament_size = st.slider("Tournament Size", min_value=5, max_value=20, value=10,
+                                                    help="The number of individuals competing in each tournament selection round.")
+                        st.session_state.crossover_rate = st.slider("Crossover Rate", min_value=0.1, max_value=1.0, step=0.1, value=0.8,
+                                                help="The probability of two individuals undergoing crossover to create offspring.")
+                        st.session_state.mutation_rate = st.slider("Mutation Rate", min_value=0.01, max_value=0.9, step=0.01, value=0.3,
+                                                help="The probability of an individual undergoing mutation.")
+                        st.session_state.seed_population_rate = st.slider("Seed Population Rate", min_value=0.0, max_value=.02, step=0.001, value=0.08, 
+                                                                          help="The percentage of the population that is generated based on the LLM's interpretation of compatibility. The remaining percentage of the population is generated randomly.")
+                        
+                        # 
+                        # Run the genetic algorithm
+                        if st.form_submit_button(label='Run Genetic Algorithm'):
+                            with st.spinner('running genetic algorithm... this may take a minute'):
+                                grouping = genetic_algorithm_plants()
+                                st.session_state.grouping = grouping
+
+                # visualize the groupings
+                # add in some vertical space
+                add_vertical_space(4)
+                # make a container for this section
+                st.title(st.session_state.user_name + "'s optimized garden")
+                st.header("Here are the optimized groupings of plants for your garden")
+                container4 = st.container(border=True)
+                with container4:
+                    if 'grouping' in st.session_state:
+                        visualize_groupings()
+                        if 'best_fitness' in st.session_state:
+                            # embed score.png
+                            col1b, col2b = st.columns([2,11])
+                            with col1b:
+                                st.image("src/assets/score.png", caption=None, width = 160, use_column_width=None, clamp=False, channels='RGB', output_format='auto')
+                            with col2b:
+                                #st.write("\n")
+                                st.header("|  " + str(st.session_state.best_fitness))
+                            st.write("The genetic algorithm converged towards a solution with a fitness score of " + str(st.session_state.best_fitness) + ".")
+                        # Add vertical space
+                        add_vertical_space(4)
+                        # show plant care tips
+                        st.header("Plant care tips")
+                        with st.spinner('generating plant care tips...'):
+                            st.write("Here are some plant care tips for your plants. Good luck!")
+                            #if 'plant_care_tips' not in st.session_state:
+                            st.session_state.plant_care_tips = get_plant_care_tips(st.session_state.input_plants_raw)
+                        styled_text = f'<div style="background-color: #2d5a59; color: white; padding: 10px; border-radius: 5px;">{st.session_state.plant_care_tips}</div>'
+                        st.write(styled_text, unsafe_allow_html=True)
+
+
+
+
+
+
+if page == "About":
+    st.sidebar.subheader("About")
+    st.sidebar.write("GRDN is a companion gardening app that helps you plan your garden and maximize your harvest. It uses AI to predict the best plants to grow together and optimization algorithms to optimize how you build your garden.")
+    st.sidebar.write("Companion gardening is the practice of planting different plants together to maximize their growth. Companion gardening can help to increase the yield of your garden, improve the health of your plants, and reduce the need for pesticides.")
+    st.write("This app is currently in beta. Please report any bugs to the team.")
+
+    col1, col2= st.columns([1,1])
+    with col1:  
+        st.subheader("Contact Information")
+        st.write("Author: Danielle Heymann")
+        st.write("Email: [email protected]")
+        st.write("LinkedIn: https://www.linkedin.com/in/danielle-heymann/")
+    with col2:
+        st.subheader("Software, data, and libraries used")
+        st.write("Libraries and Software")
+        st.markdown("""
+        - Python
+        - streamlit
+        - openai
+        - plotly
+        - pandas
+        - numpy
+        - PIL
+        - langchain
+        - streamlit_chat
+        - github copilot
+        - chatGPT
+        - GPT family of models
+        - DALL·E 3 (in preprocessing script for image generation)
+        """)
+        st.write("Data sources in addition to what GPT was trained on: \n https://waldenlabs.com/the-ultimate-companion-planting-guide-chart/ ")
+
+        st.write("avatars from: https://www.flaticon.com/free-icons/bot")

notebooks/.ipynb_checkpoints/langchain experimenting-checkpoint.ipynb

@@ -0,0 +1,843 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import langchain\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# huggingface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import HuggingFacePipeline\n",
+    "\n",
+    "llm = HuggingFacePipeline.from_model_id(\n",
+    "    model_id=\"bigscience/bloom-560m\",\n",
+    "    task=\"text-generation\",\n",
+    "    model_kwargs={\"temperature\": 0, \"max_length\": 64},\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Integrate the model in an LLMChain\n",
+    "from langchain import PromptTemplate, LLMChain\n",
+    "\n",
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
+    "\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
+    "\n",
+    "question = \"What is electroencephalography?\"\n",
+    "\n",
+    "print(llm_chain.run(question))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# galactica"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import galai as gal\n",
+    "\n",
+    "model = gal.load_model(\"standard\")\n",
+    "# model.generate(\"Scaled dot product attention:\\n\\n\\\\[\")\n",
+    "# Scaled dot product attention:\\n\\n\\\\[ \\\\displaystyle\\\\text{Attention}(Q,K,V)=\\\\text{softmax}(\\\\frac{QK^{T}}{\\\\sqrt{d_{k}}}%\\n)V \\\\]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.generate(\"from this list, [vodka, strawberries, corn, peas],create a new python list that ONLY includes produce <work>\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TEXT = \"vodka, strawberries, corn, peas, cherries, sodapop\"\n",
+    "model.generate( '\\n\\nQuestion: Of the items in this list, \\n\\n vodka, strawberries, corn, peas, cherries, diet coke, \\n\\n which can grow in a garden?\\n\\nAnswer:')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.generate(\"a plant compatability matrix is a a python matrix and will have a score of -1 for negative relationship between plants, 0 for neutral relationship between plants, and 1 for a positive relationship between plants. create a python array of plant compatibility between the plants listed: \" + str(plant_list))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# openai + langchain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plant compatiblity context source: https://waldenlabs.com/the-ultimate-companion-planting-guide-chart/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "\n",
+    "file_path = 'C:/Users/dheym/OneDrive/Documents/api_keys/openai_api_keys.txt'\n",
+    "with open(file_path, 'r') as file:\n",
+    "    OPENAI_API_KEY = file.read()\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n",
+    "#If you'd prefer not to set an environment variable you can pass the key in directly via the openai_api_key named parameter when initiating the OpenAI LLM class:\n",
+    "\n",
+    "\n",
+    "chat = ChatOpenAI()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def parse_and_evaluate_text(text):\n",
+    "    # Find the indices of the opening and closing brackets\n",
+    "    opening_bracket_index = text.find(\"[\")\n",
+    "    closing_bracket_index = text.find(\"]\")\n",
+    "\n",
+    "    if opening_bracket_index != -1 and closing_bracket_index != -1:\n",
+    "        # Extract the text within the brackets\n",
+    "        extracted_list = \"[\" + text[opening_bracket_index + 1: closing_bracket_index] + \"]\"\n",
+    "        # Return the evaluated text list\n",
+    "        return eval(extracted_list)\n",
+    "        \n",
+    "\n",
+    "    else:\n",
+    "        print(\"Error with parsing plant list\")\n",
+    "        return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def parse_and_evaluate_text(text):\n",
+    "    # Find the indices of the opening and closing brackets\n",
+    "    opening_bracket_index = text.find(\"[\")\n",
+    "    closing_bracket_index = text.find(\"]\")\n",
+    "\n",
+    "    if opening_bracket_index != -1 and closing_bracket_index != -1:\n",
+    "        # Extract the text within the brackets\n",
+    "        extracted_list = \"[\" + text[opening_bracket_index + 1: closing_bracket_index] + \"]\"\n",
+    "        # Return the evaluated text list\n",
+    "        return eval(extracted_list)\n",
+    "        \n",
+    "\n",
+    "    else:\n",
+    "        print(\"Error with parsing plant list\")\n",
+    "        return None\n",
+    "    \n",
+    "def chat_response(template, prompt_text):\n",
+    "    system_message_prompt = SystemMessagePromptTemplate.from_template(template)\n",
+    "    human_template=\"{text}\"\n",
+    "    human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)\n",
+    "    chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])\n",
+    "    response = chat(chat_prompt.format_prompt(text= prompt_text).to_messages())\n",
+    "    return response\n",
+    "\n",
+    "# get the plant list from user input\n",
+    "def get_plant_list(input_plant_text):\n",
+    "    template=\"You are a helpful assistant that knows all about gardening and plants and python data structures.\"\n",
+    "    text = 'which of the elements of this list can be grown in a garden, [' + input_plant_text + ']? Return JUST a python list object containing the elements that can be grown in a garden. Do not include any other text or explanation.'\n",
+    "    plant_list_text = chat_response(template, text)\n",
+    "    plant_list = parse_and_evaluate_text(plant_list_text.content)\n",
+    "    print(plant_list)\n",
+    "    return plant_list\n",
+    "\n",
+    "# get compatability matrix for companion planting\n",
+    "def get_compatibility_matrix(plant_list):\n",
+    "    # Convert the compatibility matrix to a string\n",
+    "    with open('compatibilities_text.txt', 'r') as file:\n",
+    "        # Read the contents of the file\n",
+    "        compatibility_text = file.read()\n",
+    "    plant_comp_context = compatibility_text\n",
+    "    template=\"You are a helpful assistant that knows all about gardening, companion planting, and python data structures- specifically compatibility matrices.\"\n",
+    "    text = 'from this list of plants, [' + str(plant_list) + '], Return JUST a python array (with values separated by commas like this: [[0,1],[1,0]]\\n\\n ) for companion plant compatibility. Each row and column should represent plants, and the element of the array will contain a -1, 0, or 1 depending on if the relationship between plants is antagonists, neutral, or companions, respectively. You must refer to this knowledge base of information on plant compatibility: \\n\\n, ' + plant_comp_context + '\\n\\n A plant\\'s compatibility with itself is always 0. Do not include any other text or explanation.'\n",
+    "    compatibility_mat = chat_response(template, text)\n",
+    "    \n",
+    "    # Find the indices of the opening and closing brackets\n",
+    "    opening_bracket_index = compatibility_mat.content.find(\"[[\")\n",
+    "    closing_bracket_index = compatibility_mat.content.find(\"]]\")\n",
+    "    if opening_bracket_index != -1 and closing_bracket_index != -1:\n",
+    "        # Extract the text within the brackets\n",
+    "        extracted_mat = \"[\" + compatibility_mat.content[opening_bracket_index + 1: closing_bracket_index] + \"]]\"\n",
+    "        # Return the evaluated mat\n",
+    "        return eval(extracted_mat)\n",
+    "    else:\n",
+    "        print(\"Error with parsing plant compatibility matrix\")\n",
+    "        return None\n",
+    "    return \n",
+    "\n",
+    "\n",
+    "input_plant_text = \"strawberries, mint, pepper, diet coke, carrots, lettuce, vodka, basil, tomatoes, marigolds, lemons, spinach, brocoli\"\n",
+    "input_plant_text = \"apples, basil, bean, rue, oregano, onion\"\n",
+    "plant_list = get_plant_list(input_plant_text)\n",
+    "extracted_mat = get_compatibility_matrix(plant_list)\n",
+    "print(extracted_mat)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## langchain additional context and fine tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# process the plant compatibility matrix to a json\n",
+    "import csv\n",
+    "import json\n",
+    "\n",
+    "# Open the CSV file\n",
+    "with open('plant_compatability.csv', 'r') as file:\n",
+    "    reader = csv.reader(file)\n",
+    "    \n",
+    "    # Read the header row to get the plant names\n",
+    "    header = next(reader)\n",
+    "    \n",
+    "    # Create an empty dictionary to store the compatibility matrix\n",
+    "    compatibility_matrix = {}\n",
+    "    \n",
+    "    # Iterate over the rows in the CSV file\n",
+    "    for row in reader:\n",
+    "        # Extract the plant name from the first column\n",
+    "        plant = row[0]\n",
+    "        \n",
+    "        # Create a dictionary to store the compatibility values for the current plant\n",
+    "        compatibility_values = {}\n",
+    "        \n",
+    "        # Iterate over the compatibility values in the row\n",
+    "        for i, value in enumerate(row[1:], start=1):\n",
+    "            # Extract the plant name from the header row\n",
+    "            companion_plant = header[i]\n",
+    "            \n",
+    "            # Convert the compatibility value to an integer\n",
+    "            compatibility = int(value) if value else 0\n",
+    "            \n",
+    "            # Add the compatibility value to the dictionary\n",
+    "            compatibility_values[companion_plant] = compatibility\n",
+    "        \n",
+    "        # Add the compatibility values dictionary to the main compatibility matrix\n",
+    "        compatibility_matrix[plant] = compatibility_values\n",
+    "\n",
+    "# Save the compatibility matrix as a JSON file\n",
+    "with open('compatibility_matrix.json', 'w') as file:\n",
+    "    json.dump(compatibility_matrix, file, indent=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openai\n",
+    "\n",
+    "# Load the compatibility matrix from the JSON file\n",
+    "with open('compatibility_matrix.json', 'r') as file:\n",
+    "    compatibility_matrix = json.load(file)\n",
+    "\n",
+    "# Convert the compatibility matrix to a string\n",
+    "compatibility_matrix_text = json.dumps(compatibility_matrix)\n",
+    "with open('compatibilities_text.txt', 'r') as file:\n",
+    "    # Read the contents of the file\n",
+    "    compatibility_matrix_text = file.read()\n",
+    "\n",
+    "# Set up the LangChain API credentials\n",
+    "openai.api_key = OPENAI_API_KEY\n",
+    "\n",
+    "# Define the prompt for the GPT model\n",
+    "prompt = \"Can you provide companion plant suggestions for my garden given what you know about companion planting?\"\n",
+    "\n",
+    "# Concatenate the prompt and compatibility matrix text as the input to the GPT model\n",
+    "input_text = f\"{prompt}\\n\\n{compatibility_matrix_text}\"\n",
+    "\n",
+    "# Generate a response from the GPT model\n",
+    "response = openai.Completion.create(\n",
+    "    engine='text-davinci-003',\n",
+    "    prompt=input_text,\n",
+    "    max_tokens=575\n",
+    ")\n",
+    "\n",
+    "print(response.choices[0])\n",
+    "# Extract the generated companion plant suggestions from the response\n",
+    "suggestions = response.choices[0].text.strip()\n",
+    "\n",
+    "# Print the companion plant suggestions\n",
+    "print(suggestions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.client import Client\n",
+    "\n",
+    "# Load the fine-tuned GPT model\n",
+    "model = OpenAI(openai_api_key=OPENAI_API_KEY)\n",
+    "\n",
+    "# Load the knowledge base or context from websites or documents\n",
+    "knowledge_base = YourProcessedData()\n",
+    "\n",
+    "# Initialize the Langchain client\n",
+    "client = Client()\n",
+    "\n",
+    "# Set the context for the GPT model\n",
+    "context = \"Context from websites or documents\"\n",
+    "model.set_context(context)\n",
+    "\n",
+    "# Get companion plant compatibility predictions\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil']\n",
+    "predictions = []\n",
+    "\n",
+    "for plant in plants:\n",
+    "    # Generate a question for each plant\n",
+    "    question = f\"Which plants are compatible with {plant}?\"\n",
+    "    \n",
+    "    # Provide the question and context to the Langchain client\n",
+    "    response = client.query(question, context=context)\n",
+    "    \n",
+    "    # Process and extract the answer from the response\n",
+    "    answer = response['answer']\n",
+    "    predictions.append((plant, answer))\n",
+    "\n",
+    "# Process and display the compatibility predictions\n",
+    "for plant, compatibility in predictions:\n",
+    "    print(f\"{plant}: {compatibility}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Define the plant list\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil', 'tomatoes', 'marigolds', 'lemons', 'strawberries', 'spinach', 'broccoli']\n",
+    "\n",
+    "# Define the compatibility matrix\n",
+    "compatibility_matrix = np.array([\n",
+    "[0, 1, 0, 0, 1, -1, 1, 0, 0, 0, -1],\n",
+    "[1, 0, 0, 0, 1, -1, 1, 0, 1, 0, -1],\n",
+    "[0, 0, 0, -1, 0, 1, 0, 0, 0, 1, 0],\n",
+    "[0, 0, -1, 0, 0, 1, 0, 0, 0, 1, 0],\n",
+    "[1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1],\n",
+    "[-1, -1, 1, 1, -1, 0, -1, 0, 0, 0, 1],\n",
+    "[1, 1, 0, 0, 1, -1, 0, 0, 0, 0, -1],\n",
+    "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, -1],\n",
+    "[-1, -1, 0, 0, -1, 1, -1, 0, 0, -1, 0]\n",
+    "])\n",
+    "\n",
+    "# Create an empty graph\n",
+    "G = nx.Graph()\n",
+    "\n",
+    "# Add nodes (plants) to the graph\n",
+    "G.add_nodes_from(plants)\n",
+    "\n",
+    "# Add edges (compatibility) to the graph\n",
+    "for i in range(len(plants)):\n",
+    "    for j in range(i + 1, len(plants)):\n",
+    "        if compatibility_matrix[i][j] == 0:\n",
+    "            color = 'grey'\n",
+    "        elif compatibility_matrix[i][j] == -1:\n",
+    "            color = 'pink'\n",
+    "        else:\n",
+    "            color = 'green'\n",
+    "        G.add_edge(plants[i], plants[j], color=color)\n",
+    "\n",
+    "# Plot the graph\n",
+    "pos = nx.spring_layout(G)\n",
+    "colors = [G[u][v]['color'] for u, v in G.edges()]\n",
+    "nx.draw_networkx(G, pos, with_labels=True, node_color='lightgreen', edge_color=colors, width=2.0, alpha=0.8)\n",
+    "\n",
+    "# Set edge colors in the legend\n",
+    "color_legend = {'Neutral': 'grey', 'Negative': 'pink', 'Positive': 'green'}\n",
+    "legend_lines = [plt.Line2D([0], [0], color=color, linewidth=3) for color in color_legend.values()]\n",
+    "legend_labels = list(color_legend.keys())\n",
+    "plt.legend(legend_lines, legend_labels, loc='best')\n",
+    "\n",
+    "# Show the plot\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import streamlit as st\n",
+    "import networkx as nx\n",
+    "import plotly.graph_objects as go\n",
+    "\n",
+    "# Define the plants and compatibility matrix\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil', 'tomatoes', 'marigolds', 'lemons', 'strawberries', 'spinach', 'broccoli']\n",
+    "compatibility_matrix = [\n",
+    "    [0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1],\n",
+    "    [1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]\n",
+    "]\n",
+    "\n",
+    "# Create a directed graph\n",
+    "G = nx.DiGraph()\n",
+    "\n",
+    "# Add nodes to the graph\n",
+    "G.add_nodes_from(plants)\n",
+    "\n",
+    "# Define positions for the nodes\n",
+    "pos = nx.spring_layout(G)\n",
+    "\n",
+    "# Assign positions to the nodes\n",
+    "for node, position in pos.items():\n",
+    "    G.nodes[node]['pos'] = position\n",
+    "\n",
+    "# Iterate over the compatibility matrix and add edges with corresponding colors\n",
+    "for i in range(len(plants)):\n",
+    "    for j in range(len(plants)):\n",
+    "        if compatibility_matrix[i][j] == -1:\n",
+    "            G.add_edge(plants[i], plants[j], color='red')\n",
+    "        elif compatibility_matrix[i][j] == 1:\n",
+    "            G.add_edge(plants[i], plants[j], color='green')\n",
+    "        else:\n",
+    "            G.add_edge(plants[i], plants[j], color='lightgray')\n",
+    "\n",
+    "# Create edge traces\n",
+    "# Create edge traces\n",
+    "edge_traces = []\n",
+    "for edge in G.edges():\n",
+    "    x0, y0 = G.nodes[edge[0]]['pos']\n",
+    "    x1, y1 = G.nodes[edge[1]]['pos']\n",
+    "    color = G.edges[edge]['color']\n",
+    "    trace = go.Scatter(x=[x0, x1, None], y=[y0, y1, None], mode='lines', line=dict(color=color, width=2))\n",
+    "    edge_traces.append(trace)\n",
+    "\n",
+    "# Create node traces\n",
+    "node_traces = []\n",
+    "for node in G.nodes():\n",
+    "    x, y = G.nodes[node]['pos']\n",
+    "    trace = go.Scatter(x=[x], y=[y], mode='markers', marker=dict(color='black', size=10), name=node)\n",
+    "    node_traces.append(trace)\n",
+    "\n",
+    "# Create figure\n",
+    "fig = go.Figure(data=edge_traces + node_traces)\n",
+    "\n",
+    "# Set layout options\n",
+    "fig.update_layout(\n",
+    "    title='Plant Network',\n",
+    "    showlegend=False,\n",
+    "    hovermode='closest',\n",
+    "    margin=dict(b=20, l=5, r=5, t=40),\n",
+    "    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
+    "    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)\n",
+    ")\n",
+    "\n",
+    "# Render the graph\n",
+    "#st.plotly_chart(fig)\n",
+    "fig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import streamlit as st\n",
+    "import networkx as nx\n",
+    "import plotly.graph_objects as go\n",
+    "\n",
+    "# Define the plants and compatibility matrix\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil', 'tomatoes', 'marigolds', 'lemons', 'strawberries', 'spinach', 'broccoli']\n",
+    "compatibility_matrix = [\n",
+    "    [0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1],\n",
+    "    [1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]\n",
+    "]\n",
+    "\n",
+    "# Create the graph\n",
+    "G = nx.Graph()\n",
+    "G.add_nodes_from(plants)\n",
+    "for i in range(len(plants)):\n",
+    "    for j in range(i + 1, len(plants)):\n",
+    "        if compatibility_matrix[i][j] == 0:\n",
+    "            G.add_edge(plants[i], plants[j], color='lightgrey')\n",
+    "        else:\n",
+    "            G.add_edge(plants[i], plants[j], color='green' if compatibility_matrix[i][j] == 1 else 'pink')\n",
+    "\n",
+    "# Generate positions for the nodes\n",
+    "pos = nx.spring_layout(G)\n",
+    "\n",
+    "# Create node trace\n",
+    "node_trace = go.Scatter(\n",
+    "    x=[pos[node][0] for node in G.nodes()],\n",
+    "    y=[pos[node][1] for node in G.nodes()],\n",
+    "    text=list(G.nodes()),\n",
+    "    mode='markers+text',\n",
+    "    textposition='top center',\n",
+    "    hoverinfo='text',\n",
+    "    marker=dict(\n",
+    "        size=20,\n",
+    "        color='lightblue',\n",
+    "        line_width=2,\n",
+    "    )\n",
+    ")\n",
+    "\n",
+    "# Create edge trace\n",
+    "edge_trace = go.Scatter(\n",
+    "    x=[],\n",
+    "    y=[],\n",
+    "    line=dict(width=1, color='lightgrey'),\n",
+    "    hoverinfo='none',\n",
+    "    mode='lines'\n",
+    ")\n",
+    "\n",
+    "# Add coordinates to edge trace\n",
+    "for edge in G.edges():\n",
+    "    x0, y0 = pos[edge[0]]\n",
+    "    x1, y1 = pos[edge[1]]\n",
+    "    edge_trace['x'] += tuple([x0, x1, None])\n",
+    "    edge_trace['y'] += tuple([y0, y1, None])\n",
+    "\n",
+    "# Create edge traces for colored edges\n",
+    "edge_traces = []\n",
+    "for edge in G.edges(data=True):\n",
+    "    x0, y0 = pos[edge[0]]\n",
+    "    x1, y1 = pos[edge[1]]\n",
+    "    color = edge[2]['color']\n",
+    "    trace = go.Scatter(\n",
+    "        x=[x0, x1],\n",
+    "        y=[y0, y1],\n",
+    "        mode='lines',\n",
+    "        line=dict(width=2, color=color),\n",
+    "        hoverinfo='none'\n",
+    "    )\n",
+    "    edge_traces.append(trace)\n",
+    "\n",
+    "# Create layout\n",
+    "layout = go.Layout(\n",
+    "    title='Plant Compatibility Network Graph',\n",
+    "    showlegend=False,\n",
+    "    hovermode='closest',\n",
+    "    margin=dict(b=20, l=5, r=5, t=40),\n",
+    "    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
+    "    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)\n",
+    ")\n",
+    "\n",
+    "# Create figure\n",
+    "fig = go.Figure(data=[edge_trace, *edge_traces, node_trace], layout=layout)\n",
+    "\n",
+    "# Render the graph using Plotly in Streamlit\n",
+    "st.plotly_chart(fig)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import numpy as np\n",
+    "\n",
+    "# Define the compatibility matrix\n",
+    "compatibility_matrix = np.array([\n",
+    "    [-1, 1, 0, -1],\n",
+    "    [1, -1, 1, -1],\n",
+    "    [1, 0, -1, 1],\n",
+    "    [-1, -1, 1, -1]\n",
+    "])\n",
+    "\n",
+    "# Define the user-selected plants, number of plant beds, and constraints\n",
+    "user_plants = [\"A\", \"B\", \"C\", \"D\"]\n",
+    "num_plant_beds = 4\n",
+    "min_species_per_bed = 1\n",
+    "max_species_per_bed = 2\n",
+    "\n",
+    "# Genetic Algorithm parameters\n",
+    "population_size = 50\n",
+    "num_generations = 100\n",
+    "tournament_size = 3\n",
+    "crossover_rate = 0.8\n",
+    "mutation_rate = 0.1\n",
+    "\n",
+    "# Generate an initial population randomly\n",
+    "def generate_initial_population():\n",
+    "    population = []\n",
+    "    for _ in range(population_size):\n",
+    "        grouping = []\n",
+    "        for _ in range(num_plant_beds):\n",
+    "            num_species = random.randint(min_species_per_bed, max_species_per_bed)\n",
+    "            species = random.sample(user_plants, num_species)\n",
+    "            grouping.append(species)\n",
+    "        population.append(grouping)\n",
+    "    return population\n",
+    "\n",
+    "# Calculate the fitness score of a grouping\n",
+    "def calculate_fitness(grouping):\n",
+    "    score = 0\n",
+    "    for bed1 in range(num_plant_beds):\n",
+    "        for bed2 in range(bed1 + 1, num_plant_beds):\n",
+    "            for species1 in grouping[bed1]:\n",
+    "                for species2 in grouping[bed2]:\n",
+    "                    species1_index = user_plants.index(species1)\n",
+    "                    species2_index = user_plants.index(species2)\n",
+    "                    score += compatibility_matrix[species1_index][species2_index]\n",
+    "    return score\n",
+    "\n",
+    "# Perform tournament selection\n",
+    "def tournament_selection(population):\n",
+    "    selected = []\n",
+    "    for _ in range(population_size):\n",
+    "        participants = random.sample(population, tournament_size)\n",
+    "        winner = max(participants, key=calculate_fitness)\n",
+    "        selected.append(winner)\n",
+    "    return selected\n",
+    "\n",
+    "# Perform crossover between two parents\n",
+    "def crossover(parent1, parent2):\n",
+    "    if random.random() < crossover_rate:\n",
+    "        crossover_point = random.randint(1, num_plant_beds - 1)\n",
+    "        child1 = parent1[:crossover_point] + parent2[crossover_point:]\n",
+    "        child2 = parent2[:crossover_point] + parent1[crossover_point:]\n",
+    "        return child1, child2\n",
+    "    else:\n",
+    "        return parent1, parent2\n",
+    "\n",
+    "# Perform mutation on an individual\n",
+    "def mutate(individual):\n",
+    "    if random.random() < mutation_rate:\n",
+    "        mutated_bed = random.randint(0, num_plant_beds - 1)\n",
+    "        new_species = random.sample(user_plants, random.randint(min_species_per_bed, max_species_per_bed))\n",
+    "        individual[mutated_bed] = new_species\n",
+    "    return individual\n",
+    "\n",
+    "# Perform replacement of the population with the offspring\n",
+    "def replacement(population, offspring):\n",
+    "    sorted_population = sorted(population, key=calculate_fitness, reverse=True)\n",
+    "    sorted_offspring = sorted(offspring, key=calculate_fitness, reverse=True)\n",
+    "    return sorted_population[:population_size - len(offspring)] + sorted_offspring\n",
+    "\n",
+    "# Genetic Algorithm main function\n",
+    "def genetic_algorithm():\n",
+    "    population = generate_initial_population()\n",
+    "\n",
+    "    for generation in range(num_generations):\n",
+    "        print(f\"Generation {generation + 1}\")\n",
+    "\n",
+    "        selected_population = tournament_selection(population)\n",
+    "        offspring = []\n",
+    "\n",
+    "        for _ in range(population_size // 2):\n",
+    "            parent1 = random.choice(selected_population)\n",
+    "            parent2 = random.choice(selected_population)\n",
+    "            child1, child2 = crossover(parent1, parent2)\n",
+    "            child1 = mutate(child1)\n",
+    "            child2 = mutate(child2)\n",
+    "            offspring.extend([child1, child2])\n",
+    "\n",
+    "        population = replacement(population, offspring)\n",
+    "\n",
+    "    best_grouping = max(population, key=calculate_fitness)\n",
+    "    best_fitness = calculate_fitness(best_grouping)\n",
+    "    print(f\"Best Grouping: {best_grouping}\")\n",
+    "    print(f\"Fitness Score: {best_fitness}\")\n",
+    "\n",
+    "# Run the Genetic Algorithm\n",
+    "genetic_algorithm()\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def query_farmersalmanac(title, first_paragraph_only=True):\n",
+    "    base_url = \"https://www.almanac.com/companion-planting-guide-vegetables\"\n",
+    "    url = f\"{base_url}/w/api.php?format=json&action=query&prop=extracts&explaintext=1&titles={title}\"\n",
+    "    if first_paragraph_only:\n",
+    "        url += \"&exintro=1\"\n",
+    "    data = requests.get(url).json()\n",
+    "    return Document(\n",
+    "      metadata={\"source\": f\"{base_url}\"},\n",
+    "      page_content=list(data[\"query\"][\"pages\"].values())[0][\"extract\"],\n",
+    "  )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## future with sources\n",
+    "- https://dzlab.github.io/2023/01/02/prompt-langchain/\n",
+    "- https://techcommunity.microsoft.com/t5/startups-at-microsoft/build-a-chatbot-to-query-your-documentation-using-langchain-and/ba-p/3833134"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "GRDN_env",
+   "language": "python",
+   "name": "grdn_env"
+  },
+  "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.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/langchain experimenting.ipynb

@@ -0,0 +1,843 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import langchain\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# huggingface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import HuggingFacePipeline\n",
+    "\n",
+    "llm = HuggingFacePipeline.from_model_id(\n",
+    "    model_id=\"bigscience/bloom-560m\",\n",
+    "    task=\"text-generation\",\n",
+    "    model_kwargs={\"temperature\": 0, \"max_length\": 64},\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Integrate the model in an LLMChain\n",
+    "from langchain import PromptTemplate, LLMChain\n",
+    "\n",
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
+    "\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
+    "\n",
+    "question = \"What is electroencephalography?\"\n",
+    "\n",
+    "print(llm_chain.run(question))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# galactica"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import galai as gal\n",
+    "\n",
+    "model = gal.load_model(\"standard\")\n",
+    "# model.generate(\"Scaled dot product attention:\\n\\n\\\\[\")\n",
+    "# Scaled dot product attention:\\n\\n\\\\[ \\\\displaystyle\\\\text{Attention}(Q,K,V)=\\\\text{softmax}(\\\\frac{QK^{T}}{\\\\sqrt{d_{k}}}%\\n)V \\\\]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.generate(\"from this list, [vodka, strawberries, corn, peas],create a new python list that ONLY includes produce <work>\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TEXT = \"vodka, strawberries, corn, peas, cherries, sodapop\"\n",
+    "model.generate( '\\n\\nQuestion: Of the items in this list, \\n\\n vodka, strawberries, corn, peas, cherries, diet coke, \\n\\n which can grow in a garden?\\n\\nAnswer:')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.generate(\"a plant compatability matrix is a a python matrix and will have a score of -1 for negative relationship between plants, 0 for neutral relationship between plants, and 1 for a positive relationship between plants. create a python array of plant compatibility between the plants listed: \" + str(plant_list))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# openai + langchain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plant compatiblity context source: https://waldenlabs.com/the-ultimate-companion-planting-guide-chart/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "\n",
+    "file_path = 'C:/Users/dheym/OneDrive/Documents/api_keys/openai_api_keys.txt'\n",
+    "with open(file_path, 'r') as file:\n",
+    "    OPENAI_API_KEY = file.read()\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n",
+    "#If you'd prefer not to set an environment variable you can pass the key in directly via the openai_api_key named parameter when initiating the OpenAI LLM class:\n",
+    "\n",
+    "\n",
+    "chat = ChatOpenAI()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def parse_and_evaluate_text(text):\n",
+    "    # Find the indices of the opening and closing brackets\n",
+    "    opening_bracket_index = text.find(\"[\")\n",
+    "    closing_bracket_index = text.find(\"]\")\n",
+    "\n",
+    "    if opening_bracket_index != -1 and closing_bracket_index != -1:\n",
+    "        # Extract the text within the brackets\n",
+    "        extracted_list = \"[\" + text[opening_bracket_index + 1: closing_bracket_index] + \"]\"\n",
+    "        # Return the evaluated text list\n",
+    "        return eval(extracted_list)\n",
+    "        \n",
+    "\n",
+    "    else:\n",
+    "        print(\"Error with parsing plant list\")\n",
+    "        return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def parse_and_evaluate_text(text):\n",
+    "    # Find the indices of the opening and closing brackets\n",
+    "    opening_bracket_index = text.find(\"[\")\n",
+    "    closing_bracket_index = text.find(\"]\")\n",
+    "\n",
+    "    if opening_bracket_index != -1 and closing_bracket_index != -1:\n",
+    "        # Extract the text within the brackets\n",
+    "        extracted_list = \"[\" + text[opening_bracket_index + 1: closing_bracket_index] + \"]\"\n",
+    "        # Return the evaluated text list\n",
+    "        return eval(extracted_list)\n",
+    "        \n",
+    "\n",
+    "    else:\n",
+    "        print(\"Error with parsing plant list\")\n",
+    "        return None\n",
+    "    \n",
+    "def chat_response(template, prompt_text):\n",
+    "    system_message_prompt = SystemMessagePromptTemplate.from_template(template)\n",
+    "    human_template=\"{text}\"\n",
+    "    human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)\n",
+    "    chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])\n",
+    "    response = chat(chat_prompt.format_prompt(text= prompt_text).to_messages())\n",
+    "    return response\n",
+    "\n",
+    "# get the plant list from user input\n",
+    "def get_plant_list(input_plant_text):\n",
+    "    template=\"You are a helpful assistant that knows all about gardening and plants and python data structures.\"\n",
+    "    text = 'which of the elements of this list can be grown in a garden, [' + input_plant_text + ']? Return JUST a python list object containing the elements that can be grown in a garden. Do not include any other text or explanation.'\n",
+    "    plant_list_text = chat_response(template, text)\n",
+    "    plant_list = parse_and_evaluate_text(plant_list_text.content)\n",
+    "    print(plant_list)\n",
+    "    return plant_list\n",
+    "\n",
+    "# get compatability matrix for companion planting\n",
+    "def get_compatibility_matrix(plant_list):\n",
+    "    # Convert the compatibility matrix to a string\n",
+    "    with open('compatibilities_text.txt', 'r') as file:\n",
+    "        # Read the contents of the file\n",
+    "        compatibility_text = file.read()\n",
+    "    plant_comp_context = compatibility_text\n",
+    "    template=\"You are a helpful assistant that knows all about gardening, companion planting, and python data structures- specifically compatibility matrices.\"\n",
+    "    text = 'from this list of plants, [' + str(plant_list) + '], Return JUST a python array (with values separated by commas like this: [[0,1],[1,0]]\\n\\n ) for companion plant compatibility. Each row and column should represent plants, and the element of the array will contain a -1, 0, or 1 depending on if the relationship between plants is antagonists, neutral, or companions, respectively. You must refer to this knowledge base of information on plant compatibility: \\n\\n, ' + plant_comp_context + '\\n\\n A plant\\'s compatibility with itself is always 0. Do not include any other text or explanation.'\n",
+    "    compatibility_mat = chat_response(template, text)\n",
+    "    \n",
+    "    # Find the indices of the opening and closing brackets\n",
+    "    opening_bracket_index = compatibility_mat.content.find(\"[[\")\n",
+    "    closing_bracket_index = compatibility_mat.content.find(\"]]\")\n",
+    "    if opening_bracket_index != -1 and closing_bracket_index != -1:\n",
+    "        # Extract the text within the brackets\n",
+    "        extracted_mat = \"[\" + compatibility_mat.content[opening_bracket_index + 1: closing_bracket_index] + \"]]\"\n",
+    "        # Return the evaluated mat\n",
+    "        return eval(extracted_mat)\n",
+    "    else:\n",
+    "        print(\"Error with parsing plant compatibility matrix\")\n",
+    "        return None\n",
+    "    return \n",
+    "\n",
+    "\n",
+    "input_plant_text = \"strawberries, mint, pepper, diet coke, carrots, lettuce, vodka, basil, tomatoes, marigolds, lemons, spinach, brocoli\"\n",
+    "input_plant_text = \"apples, basil, bean, rue, oregano, onion\"\n",
+    "plant_list = get_plant_list(input_plant_text)\n",
+    "extracted_mat = get_compatibility_matrix(plant_list)\n",
+    "print(extracted_mat)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## langchain additional context and fine tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# process the plant compatibility matrix to a json\n",
+    "import csv\n",
+    "import json\n",
+    "\n",
+    "# Open the CSV file\n",
+    "with open('plant_compatability.csv', 'r') as file:\n",
+    "    reader = csv.reader(file)\n",
+    "    \n",
+    "    # Read the header row to get the plant names\n",
+    "    header = next(reader)\n",
+    "    \n",
+    "    # Create an empty dictionary to store the compatibility matrix\n",
+    "    compatibility_matrix = {}\n",
+    "    \n",
+    "    # Iterate over the rows in the CSV file\n",
+    "    for row in reader:\n",
+    "        # Extract the plant name from the first column\n",
+    "        plant = row[0]\n",
+    "        \n",
+    "        # Create a dictionary to store the compatibility values for the current plant\n",
+    "        compatibility_values = {}\n",
+    "        \n",
+    "        # Iterate over the compatibility values in the row\n",
+    "        for i, value in enumerate(row[1:], start=1):\n",
+    "            # Extract the plant name from the header row\n",
+    "            companion_plant = header[i]\n",
+    "            \n",
+    "            # Convert the compatibility value to an integer\n",
+    "            compatibility = int(value) if value else 0\n",
+    "            \n",
+    "            # Add the compatibility value to the dictionary\n",
+    "            compatibility_values[companion_plant] = compatibility\n",
+    "        \n",
+    "        # Add the compatibility values dictionary to the main compatibility matrix\n",
+    "        compatibility_matrix[plant] = compatibility_values\n",
+    "\n",
+    "# Save the compatibility matrix as a JSON file\n",
+    "with open('compatibility_matrix.json', 'w') as file:\n",
+    "    json.dump(compatibility_matrix, file, indent=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openai\n",
+    "\n",
+    "# Load the compatibility matrix from the JSON file\n",
+    "with open('compatibility_matrix.json', 'r') as file:\n",
+    "    compatibility_matrix = json.load(file)\n",
+    "\n",
+    "# Convert the compatibility matrix to a string\n",
+    "compatibility_matrix_text = json.dumps(compatibility_matrix)\n",
+    "with open('compatibilities_text.txt', 'r') as file:\n",
+    "    # Read the contents of the file\n",
+    "    compatibility_matrix_text = file.read()\n",
+    "\n",
+    "# Set up the LangChain API credentials\n",
+    "openai.api_key = OPENAI_API_KEY\n",
+    "\n",
+    "# Define the prompt for the GPT model\n",
+    "prompt = \"Can you provide companion plant suggestions for my garden given what you know about companion planting?\"\n",
+    "\n",
+    "# Concatenate the prompt and compatibility matrix text as the input to the GPT model\n",
+    "input_text = f\"{prompt}\\n\\n{compatibility_matrix_text}\"\n",
+    "\n",
+    "# Generate a response from the GPT model\n",
+    "response = openai.Completion.create(\n",
+    "    engine='text-davinci-003',\n",
+    "    prompt=input_text,\n",
+    "    max_tokens=575\n",
+    ")\n",
+    "\n",
+    "print(response.choices[0])\n",
+    "# Extract the generated companion plant suggestions from the response\n",
+    "suggestions = response.choices[0].text.strip()\n",
+    "\n",
+    "# Print the companion plant suggestions\n",
+    "print(suggestions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.client import Client\n",
+    "\n",
+    "# Load the fine-tuned GPT model\n",
+    "model = OpenAI(openai_api_key=OPENAI_API_KEY)\n",
+    "\n",
+    "# Load the knowledge base or context from websites or documents\n",
+    "knowledge_base = YourProcessedData()\n",
+    "\n",
+    "# Initialize the Langchain client\n",
+    "client = Client()\n",
+    "\n",
+    "# Set the context for the GPT model\n",
+    "context = \"Context from websites or documents\"\n",
+    "model.set_context(context)\n",
+    "\n",
+    "# Get companion plant compatibility predictions\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil']\n",
+    "predictions = []\n",
+    "\n",
+    "for plant in plants:\n",
+    "    # Generate a question for each plant\n",
+    "    question = f\"Which plants are compatible with {plant}?\"\n",
+    "    \n",
+    "    # Provide the question and context to the Langchain client\n",
+    "    response = client.query(question, context=context)\n",
+    "    \n",
+    "    # Process and extract the answer from the response\n",
+    "    answer = response['answer']\n",
+    "    predictions.append((plant, answer))\n",
+    "\n",
+    "# Process and display the compatibility predictions\n",
+    "for plant, compatibility in predictions:\n",
+    "    print(f\"{plant}: {compatibility}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Define the plant list\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil', 'tomatoes', 'marigolds', 'lemons', 'strawberries', 'spinach', 'broccoli']\n",
+    "\n",
+    "# Define the compatibility matrix\n",
+    "compatibility_matrix = np.array([\n",
+    "[0, 1, 0, 0, 1, -1, 1, 0, 0, 0, -1],\n",
+    "[1, 0, 0, 0, 1, -1, 1, 0, 1, 0, -1],\n",
+    "[0, 0, 0, -1, 0, 1, 0, 0, 0, 1, 0],\n",
+    "[0, 0, -1, 0, 0, 1, 0, 0, 0, 1, 0],\n",
+    "[1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1],\n",
+    "[-1, -1, 1, 1, -1, 0, -1, 0, 0, 0, 1],\n",
+    "[1, 1, 0, 0, 1, -1, 0, 0, 0, 0, -1],\n",
+    "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, -1],\n",
+    "[-1, -1, 0, 0, -1, 1, -1, 0, 0, -1, 0]\n",
+    "])\n",
+    "\n",
+    "# Create an empty graph\n",
+    "G = nx.Graph()\n",
+    "\n",
+    "# Add nodes (plants) to the graph\n",
+    "G.add_nodes_from(plants)\n",
+    "\n",
+    "# Add edges (compatibility) to the graph\n",
+    "for i in range(len(plants)):\n",
+    "    for j in range(i + 1, len(plants)):\n",
+    "        if compatibility_matrix[i][j] == 0:\n",
+    "            color = 'grey'\n",
+    "        elif compatibility_matrix[i][j] == -1:\n",
+    "            color = 'pink'\n",
+    "        else:\n",
+    "            color = 'green'\n",
+    "        G.add_edge(plants[i], plants[j], color=color)\n",
+    "\n",
+    "# Plot the graph\n",
+    "pos = nx.spring_layout(G)\n",
+    "colors = [G[u][v]['color'] for u, v in G.edges()]\n",
+    "nx.draw_networkx(G, pos, with_labels=True, node_color='lightgreen', edge_color=colors, width=2.0, alpha=0.8)\n",
+    "\n",
+    "# Set edge colors in the legend\n",
+    "color_legend = {'Neutral': 'grey', 'Negative': 'pink', 'Positive': 'green'}\n",
+    "legend_lines = [plt.Line2D([0], [0], color=color, linewidth=3) for color in color_legend.values()]\n",
+    "legend_labels = list(color_legend.keys())\n",
+    "plt.legend(legend_lines, legend_labels, loc='best')\n",
+    "\n",
+    "# Show the plot\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import streamlit as st\n",
+    "import networkx as nx\n",
+    "import plotly.graph_objects as go\n",
+    "\n",
+    "# Define the plants and compatibility matrix\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil', 'tomatoes', 'marigolds', 'lemons', 'strawberries', 'spinach', 'broccoli']\n",
+    "compatibility_matrix = [\n",
+    "    [0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1],\n",
+    "    [1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]\n",
+    "]\n",
+    "\n",
+    "# Create a directed graph\n",
+    "G = nx.DiGraph()\n",
+    "\n",
+    "# Add nodes to the graph\n",
+    "G.add_nodes_from(plants)\n",
+    "\n",
+    "# Define positions for the nodes\n",
+    "pos = nx.spring_layout(G)\n",
+    "\n",
+    "# Assign positions to the nodes\n",
+    "for node, position in pos.items():\n",
+    "    G.nodes[node]['pos'] = position\n",
+    "\n",
+    "# Iterate over the compatibility matrix and add edges with corresponding colors\n",
+    "for i in range(len(plants)):\n",
+    "    for j in range(len(plants)):\n",
+    "        if compatibility_matrix[i][j] == -1:\n",
+    "            G.add_edge(plants[i], plants[j], color='red')\n",
+    "        elif compatibility_matrix[i][j] == 1:\n",
+    "            G.add_edge(plants[i], plants[j], color='green')\n",
+    "        else:\n",
+    "            G.add_edge(plants[i], plants[j], color='lightgray')\n",
+    "\n",
+    "# Create edge traces\n",
+    "# Create edge traces\n",
+    "edge_traces = []\n",
+    "for edge in G.edges():\n",
+    "    x0, y0 = G.nodes[edge[0]]['pos']\n",
+    "    x1, y1 = G.nodes[edge[1]]['pos']\n",
+    "    color = G.edges[edge]['color']\n",
+    "    trace = go.Scatter(x=[x0, x1, None], y=[y0, y1, None], mode='lines', line=dict(color=color, width=2))\n",
+    "    edge_traces.append(trace)\n",
+    "\n",
+    "# Create node traces\n",
+    "node_traces = []\n",
+    "for node in G.nodes():\n",
+    "    x, y = G.nodes[node]['pos']\n",
+    "    trace = go.Scatter(x=[x], y=[y], mode='markers', marker=dict(color='black', size=10), name=node)\n",
+    "    node_traces.append(trace)\n",
+    "\n",
+    "# Create figure\n",
+    "fig = go.Figure(data=edge_traces + node_traces)\n",
+    "\n",
+    "# Set layout options\n",
+    "fig.update_layout(\n",
+    "    title='Plant Network',\n",
+    "    showlegend=False,\n",
+    "    hovermode='closest',\n",
+    "    margin=dict(b=20, l=5, r=5, t=40),\n",
+    "    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
+    "    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)\n",
+    ")\n",
+    "\n",
+    "# Render the graph\n",
+    "#st.plotly_chart(fig)\n",
+    "fig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import streamlit as st\n",
+    "import networkx as nx\n",
+    "import plotly.graph_objects as go\n",
+    "\n",
+    "# Define the plants and compatibility matrix\n",
+    "plants = ['strawberries', 'mint', 'carrots', 'lettuce', 'basil', 'tomatoes', 'marigolds', 'lemons', 'strawberries', 'spinach', 'broccoli']\n",
+    "compatibility_matrix = [\n",
+    "    [0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1],\n",
+    "    [1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "    [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1],\n",
+    "    [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n",
+    "    [1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]\n",
+    "]\n",
+    "\n",
+    "# Create the graph\n",
+    "G = nx.Graph()\n",
+    "G.add_nodes_from(plants)\n",
+    "for i in range(len(plants)):\n",
+    "    for j in range(i + 1, len(plants)):\n",
+    "        if compatibility_matrix[i][j] == 0:\n",
+    "            G.add_edge(plants[i], plants[j], color='lightgrey')\n",
+    "        else:\n",
+    "            G.add_edge(plants[i], plants[j], color='green' if compatibility_matrix[i][j] == 1 else 'pink')\n",
+    "\n",
+    "# Generate positions for the nodes\n",
+    "pos = nx.spring_layout(G)\n",
+    "\n",
+    "# Create node trace\n",
+    "node_trace = go.Scatter(\n",
+    "    x=[pos[node][0] for node in G.nodes()],\n",
+    "    y=[pos[node][1] for node in G.nodes()],\n",
+    "    text=list(G.nodes()),\n",
+    "    mode='markers+text',\n",
+    "    textposition='top center',\n",
+    "    hoverinfo='text',\n",
+    "    marker=dict(\n",
+    "        size=20,\n",
+    "        color='lightblue',\n",
+    "        line_width=2,\n",
+    "    )\n",
+    ")\n",
+    "\n",
+    "# Create edge trace\n",
+    "edge_trace = go.Scatter(\n",
+    "    x=[],\n",
+    "    y=[],\n",
+    "    line=dict(width=1, color='lightgrey'),\n",
+    "    hoverinfo='none',\n",
+    "    mode='lines'\n",
+    ")\n",
+    "\n",
+    "# Add coordinates to edge trace\n",
+    "for edge in G.edges():\n",
+    "    x0, y0 = pos[edge[0]]\n",
+    "    x1, y1 = pos[edge[1]]\n",
+    "    edge_trace['x'] += tuple([x0, x1, None])\n",
+    "    edge_trace['y'] += tuple([y0, y1, None])\n",
+    "\n",
+    "# Create edge traces for colored edges\n",
+    "edge_traces = []\n",
+    "for edge in G.edges(data=True):\n",
+    "    x0, y0 = pos[edge[0]]\n",
+    "    x1, y1 = pos[edge[1]]\n",
+    "    color = edge[2]['color']\n",
+    "    trace = go.Scatter(\n",
+    "        x=[x0, x1],\n",
+    "        y=[y0, y1],\n",
+    "        mode='lines',\n",
+    "        line=dict(width=2, color=color),\n",
+    "        hoverinfo='none'\n",
+    "    )\n",
+    "    edge_traces.append(trace)\n",
+    "\n",
+    "# Create layout\n",
+    "layout = go.Layout(\n",
+    "    title='Plant Compatibility Network Graph',\n",
+    "    showlegend=False,\n",
+    "    hovermode='closest',\n",
+    "    margin=dict(b=20, l=5, r=5, t=40),\n",
+    "    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
+    "    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)\n",
+    ")\n",
+    "\n",
+    "# Create figure\n",
+    "fig = go.Figure(data=[edge_trace, *edge_traces, node_trace], layout=layout)\n",
+    "\n",
+    "# Render the graph using Plotly in Streamlit\n",
+    "st.plotly_chart(fig)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import numpy as np\n",
+    "\n",
+    "# Define the compatibility matrix\n",
+    "compatibility_matrix = np.array([\n",
+    "    [-1, 1, 0, -1],\n",
+    "    [1, -1, 1, -1],\n",
+    "    [1, 0, -1, 1],\n",
+    "    [-1, -1, 1, -1]\n",
+    "])\n",
+    "\n",
+    "# Define the user-selected plants, number of plant beds, and constraints\n",
+    "user_plants = [\"A\", \"B\", \"C\", \"D\"]\n",
+    "num_plant_beds = 4\n",
+    "min_species_per_bed = 1\n",
+    "max_species_per_bed = 2\n",
+    "\n",
+    "# Genetic Algorithm parameters\n",
+    "population_size = 50\n",
+    "num_generations = 100\n",
+    "tournament_size = 3\n",
+    "crossover_rate = 0.8\n",
+    "mutation_rate = 0.1\n",
+    "\n",
+    "# Generate an initial population randomly\n",
+    "def generate_initial_population():\n",
+    "    population = []\n",
+    "    for _ in range(population_size):\n",
+    "        grouping = []\n",
+    "        for _ in range(num_plant_beds):\n",
+    "            num_species = random.randint(min_species_per_bed, max_species_per_bed)\n",
+    "            species = random.sample(user_plants, num_species)\n",
+    "            grouping.append(species)\n",
+    "        population.append(grouping)\n",
+    "    return population\n",
+    "\n",
+    "# Calculate the fitness score of a grouping\n",
+    "def calculate_fitness(grouping):\n",
+    "    score = 0\n",
+    "    for bed1 in range(num_plant_beds):\n",
+    "        for bed2 in range(bed1 + 1, num_plant_beds):\n",
+    "            for species1 in grouping[bed1]:\n",
+    "                for species2 in grouping[bed2]:\n",
+    "                    species1_index = user_plants.index(species1)\n",
+    "                    species2_index = user_plants.index(species2)\n",
+    "                    score += compatibility_matrix[species1_index][species2_index]\n",
+    "    return score\n",
+    "\n",
+    "# Perform tournament selection\n",
+    "def tournament_selection(population):\n",
+    "    selected = []\n",
+    "    for _ in range(population_size):\n",
+    "        participants = random.sample(population, tournament_size)\n",
+    "        winner = max(participants, key=calculate_fitness)\n",
+    "        selected.append(winner)\n",
+    "    return selected\n",
+    "\n",
+    "# Perform crossover between two parents\n",
+    "def crossover(parent1, parent2):\n",
+    "    if random.random() < crossover_rate:\n",
+    "        crossover_point = random.randint(1, num_plant_beds - 1)\n",
+    "        child1 = parent1[:crossover_point] + parent2[crossover_point:]\n",
+    "        child2 = parent2[:crossover_point] + parent1[crossover_point:]\n",
+    "        return child1, child2\n",
+    "    else:\n",
+    "        return parent1, parent2\n",
+    "\n",
+    "# Perform mutation on an individual\n",
+    "def mutate(individual):\n",
+    "    if random.random() < mutation_rate:\n",
+    "        mutated_bed = random.randint(0, num_plant_beds - 1)\n",
+    "        new_species = random.sample(user_plants, random.randint(min_species_per_bed, max_species_per_bed))\n",
+    "        individual[mutated_bed] = new_species\n",
+    "    return individual\n",
+    "\n",
+    "# Perform replacement of the population with the offspring\n",
+    "def replacement(population, offspring):\n",
+    "    sorted_population = sorted(population, key=calculate_fitness, reverse=True)\n",
+    "    sorted_offspring = sorted(offspring, key=calculate_fitness, reverse=True)\n",
+    "    return sorted_population[:population_size - len(offspring)] + sorted_offspring\n",
+    "\n",
+    "# Genetic Algorithm main function\n",
+    "def genetic_algorithm():\n",
+    "    population = generate_initial_population()\n",
+    "\n",
+    "    for generation in range(num_generations):\n",
+    "        print(f\"Generation {generation + 1}\")\n",
+    "\n",
+    "        selected_population = tournament_selection(population)\n",
+    "        offspring = []\n",
+    "\n",
+    "        for _ in range(population_size // 2):\n",
+    "            parent1 = random.choice(selected_population)\n",
+    "            parent2 = random.choice(selected_population)\n",
+    "            child1, child2 = crossover(parent1, parent2)\n",
+    "            child1 = mutate(child1)\n",
+    "            child2 = mutate(child2)\n",
+    "            offspring.extend([child1, child2])\n",
+    "\n",
+    "        population = replacement(population, offspring)\n",
+    "\n",
+    "    best_grouping = max(population, key=calculate_fitness)\n",
+    "    best_fitness = calculate_fitness(best_grouping)\n",
+    "    print(f\"Best Grouping: {best_grouping}\")\n",
+    "    print(f\"Fitness Score: {best_fitness}\")\n",
+    "\n",
+    "# Run the Genetic Algorithm\n",
+    "genetic_algorithm()\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def query_farmersalmanac(title, first_paragraph_only=True):\n",
+    "    base_url = \"https://www.almanac.com/companion-planting-guide-vegetables\"\n",
+    "    url = f\"{base_url}/w/api.php?format=json&action=query&prop=extracts&explaintext=1&titles={title}\"\n",
+    "    if first_paragraph_only:\n",
+    "        url += \"&exintro=1\"\n",
+    "    data = requests.get(url).json()\n",
+    "    return Document(\n",
+    "      metadata={\"source\": f\"{base_url}\"},\n",
+    "      page_content=list(data[\"query\"][\"pages\"].values())[0][\"extract\"],\n",
+    "  )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## future with sources\n",
+    "- https://dzlab.github.io/2023/01/02/prompt-langchain/\n",
+    "- https://techcommunity.microsoft.com/t5/startups-at-microsoft/build-a-chatbot-to-query-your-documentation-using-langchain-and/ba-p/3833134"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "GRDN_env",
+   "language": "python",
+   "name": "grdn_env"
+  },
+  "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.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/llamaindex_llama2_test.ipynb

@@ -0,0 +1,258 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import streamlit as st\n",
+    "import pandas as pd\n",
+    "import os\n",
+    "import replicate\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "assistant: 😄 Oh my daisies, companion planting? It's like peas in a pod, ya know? 😂 It's like having a garden party with all your plant friends! 🎉 Companion planting is the bee's knees, it's like a garden symphony, all the plants working together in harmony! 🎶 And let me tell you, it's not just about looks, it's like a big ol' hug for your plants! 🤗 It's like planting a big ol' bouquet of flowers, all mixed together, just like a big ol' garden party! 🎉\n",
+      "But seriously, companion planting is a great way to create a balanced and healthy garden ecosystem. It's like having a little garden family, all working together to keep the pests away and the soil healthy! 🐝🐜 And let me tell you, it's not just about the plants, it's like a big ol' party for the bees and butterflies too! 🐝🦋 They love all the different colors and scents, it's like a big ol' garden buffet for them! 🍴🍸 So, if you haven't tried companion planting yet, you should give it a go, it's like the bee's knees, it's the cat's pajamas! 🐰👠💤\n",
+      "But enough about that, let's talk about you, what do you think about companion planting? Have you tried it before? Do you have any questions? Let's chat, I'm all ears! 🐰👂💬\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_index.llms import Replicate, ChatMessage\n",
+    "\n",
+    "llm = Replicate(\n",
+    "    model=\"a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5\"\n",
+    ")\n",
+    "\n",
+    "messages = [\n",
+    "    ChatMessage(\n",
+    "        role=\"system\", content=\"You are a gardnere with a colorful personality\"\n",
+    "    ),\n",
+    "    ChatMessage(role=\"user\", content=\"What is your opinion on companion planting?\"),\n",
+    "]\n",
+    "resp = llm.chat(messages)\n",
+    "\n",
+    "print(resp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "You return JUST a python list object containing the elements that can be grown in a garden. Do not include any other text or explanation.which of the elements of this list can be grown in a garden, [apple, orange, milk, eraser, cherry]? Return JUST a python list object containing the elements that can be grown in a garden. Do not include any other text or explanation.\n"
+     ]
+    },
+    {
+     "ename": "ReplicateError",
+     "evalue": "You have reached the free time limit. To continue using Replicate, set up billing at https://replicate.com/account/billing#billing.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mReplicateError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[13], line 20\u001b[0m\n\u001b[1;32m     17\u001b[0m input_prompt \u001b[39m=\u001b[39m template \u001b[39m+\u001b[39m text\n\u001b[1;32m     18\u001b[0m \u001b[39mprint\u001b[39m(input_prompt)\n\u001b[0;32m---> 20\u001b[0m resp \u001b[39m=\u001b[39m llm\u001b[39m.\u001b[39mcomplete(input_prompt)\n\u001b[1;32m     21\u001b[0m \u001b[39mprint\u001b[39m(resp)\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/llama_index/llms/base.py:223\u001b[0m, in \u001b[0;36mllm_completion_callback.<locals>.wrap.<locals>.wrapped_llm_predict\u001b[0;34m(_self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    213\u001b[0m \u001b[39mwith\u001b[39;00m wrapper_logic(_self) \u001b[39mas\u001b[39;00m callback_manager:\n\u001b[1;32m    214\u001b[0m     event_id \u001b[39m=\u001b[39m callback_manager\u001b[39m.\u001b[39mon_event_start(\n\u001b[1;32m    215\u001b[0m         CBEventType\u001b[39m.\u001b[39mLLM,\n\u001b[1;32m    216\u001b[0m         payload\u001b[39m=\u001b[39m{\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    220\u001b[0m         },\n\u001b[1;32m    221\u001b[0m     )\n\u001b[0;32m--> 223\u001b[0m     f_return_val \u001b[39m=\u001b[39m f(_self, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m    224\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(f_return_val, Generator):\n\u001b[1;32m    225\u001b[0m         \u001b[39m# intercept the generator and add a callback to the end\u001b[39;00m\n\u001b[1;32m    226\u001b[0m         \u001b[39mdef\u001b[39;00m \u001b[39mwrapped_gen\u001b[39m() \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m CompletionResponseGen:\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/llama_index/llms/replicate.py:100\u001b[0m, in \u001b[0;36mReplicate.complete\u001b[0;34m(self, prompt, **kwargs)\u001b[0m\n\u001b[1;32m     98\u001b[0m \u001b[39m@llm_completion_callback\u001b[39m()\n\u001b[1;32m     99\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mcomplete\u001b[39m(\u001b[39mself\u001b[39m, prompt: \u001b[39mstr\u001b[39m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs: Any) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m CompletionResponse:\n\u001b[0;32m--> 100\u001b[0m     response_gen \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstream_complete(prompt, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m    101\u001b[0m     response_list \u001b[39m=\u001b[39m \u001b[39mlist\u001b[39m(response_gen)\n\u001b[1;32m    102\u001b[0m     final_response \u001b[39m=\u001b[39m response_list[\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m]\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/llama_index/llms/base.py:223\u001b[0m, in \u001b[0;36mllm_completion_callback.<locals>.wrap.<locals>.wrapped_llm_predict\u001b[0;34m(_self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    213\u001b[0m \u001b[39mwith\u001b[39;00m wrapper_logic(_self) \u001b[39mas\u001b[39;00m callback_manager:\n\u001b[1;32m    214\u001b[0m     event_id \u001b[39m=\u001b[39m callback_manager\u001b[39m.\u001b[39mon_event_start(\n\u001b[1;32m    215\u001b[0m         CBEventType\u001b[39m.\u001b[39mLLM,\n\u001b[1;32m    216\u001b[0m         payload\u001b[39m=\u001b[39m{\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    220\u001b[0m         },\n\u001b[1;32m    221\u001b[0m     )\n\u001b[0;32m--> 223\u001b[0m     f_return_val \u001b[39m=\u001b[39m f(_self, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m    224\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(f_return_val, Generator):\n\u001b[1;32m    225\u001b[0m         \u001b[39m# intercept the generator and add a callback to the end\u001b[39;00m\n\u001b[1;32m    226\u001b[0m         \u001b[39mdef\u001b[39;00m \u001b[39mwrapped_gen\u001b[39m() \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m CompletionResponseGen:\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/llama_index/llms/replicate.py:119\u001b[0m, in \u001b[0;36mReplicate.stream_complete\u001b[0;34m(self, prompt, **kwargs)\u001b[0m\n\u001b[1;32m    117\u001b[0m     prompt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcompletion_to_prompt(prompt)\n\u001b[1;32m    118\u001b[0m input_dict \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_input_dict(prompt, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m--> 119\u001b[0m response_iter \u001b[39m=\u001b[39m replicate\u001b[39m.\u001b[39mrun(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmodel, \u001b[39minput\u001b[39m\u001b[39m=\u001b[39minput_dict)\n\u001b[1;32m    121\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mgen\u001b[39m() \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m CompletionResponseGen:\n\u001b[1;32m    122\u001b[0m     text \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/replicate/client.py:147\u001b[0m, in \u001b[0;36mClient.run\u001b[0;34m(self, ref, input, **params)\u001b[0m\n\u001b[1;32m    137\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mrun\u001b[39m(\n\u001b[1;32m    138\u001b[0m     \u001b[39mself\u001b[39m,\n\u001b[1;32m    139\u001b[0m     ref: \u001b[39mstr\u001b[39m,\n\u001b[1;32m    140\u001b[0m     \u001b[39minput\u001b[39m: Optional[Dict[\u001b[39mstr\u001b[39m, Any]] \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m,\n\u001b[1;32m    141\u001b[0m     \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mparams: Unpack[\u001b[39m\"\u001b[39m\u001b[39mPredictions.CreatePredictionParams\u001b[39m\u001b[39m\"\u001b[39m],\n\u001b[1;32m    142\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Union[Any, Iterator[Any]]:  \u001b[39m# noqa: ANN401\u001b[39;00m\n\u001b[1;32m    143\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    144\u001b[0m \u001b[39m    Run a model and wait for its output.\u001b[39;00m\n\u001b[1;32m    145\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 147\u001b[0m     \u001b[39mreturn\u001b[39;00m run(\u001b[39mself\u001b[39m, ref, \u001b[39minput\u001b[39m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mparams)\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/replicate/run.py:31\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(client, ref, input, **params)\u001b[0m\n\u001b[1;32m     28\u001b[0m version, owner, name, version_id \u001b[39m=\u001b[39m identifier\u001b[39m.\u001b[39m_resolve(ref)\n\u001b[1;32m     30\u001b[0m \u001b[39mif\u001b[39;00m version_id \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m---> 31\u001b[0m     prediction \u001b[39m=\u001b[39m client\u001b[39m.\u001b[39mpredictions\u001b[39m.\u001b[39mcreate(\n\u001b[1;32m     32\u001b[0m         version\u001b[39m=\u001b[39mversion_id, \u001b[39minput\u001b[39m\u001b[39m=\u001b[39m\u001b[39minput\u001b[39m \u001b[39mor\u001b[39;00m {}, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mparams\n\u001b[1;32m     33\u001b[0m     )\n\u001b[1;32m     34\u001b[0m \u001b[39melif\u001b[39;00m owner \u001b[39mand\u001b[39;00m name:\n\u001b[1;32m     35\u001b[0m     prediction \u001b[39m=\u001b[39m client\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mpredictions\u001b[39m.\u001b[39mcreate(\n\u001b[1;32m     36\u001b[0m         model\u001b[39m=\u001b[39m(owner, name), \u001b[39minput\u001b[39m\u001b[39m=\u001b[39m\u001b[39minput\u001b[39m \u001b[39mor\u001b[39;00m {}, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mparams\n\u001b[1;32m     37\u001b[0m     )\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/replicate/prediction.py:309\u001b[0m, in \u001b[0;36mPredictions.create\u001b[0;34m(self, version, input, **params)\u001b[0m\n\u001b[1;32m    300\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    301\u001b[0m \u001b[39mCreate a new prediction for the specified model version.\u001b[39;00m\n\u001b[1;32m    302\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    304\u001b[0m body \u001b[39m=\u001b[39m _create_prediction_body(\n\u001b[1;32m    305\u001b[0m     version,\n\u001b[1;32m    306\u001b[0m     \u001b[39minput\u001b[39m,\n\u001b[1;32m    307\u001b[0m     \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mparams,\n\u001b[1;32m    308\u001b[0m )\n\u001b[0;32m--> 309\u001b[0m resp \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_client\u001b[39m.\u001b[39m_request(\n\u001b[1;32m    310\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39mPOST\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m    311\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39m/v1/predictions\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m    312\u001b[0m     json\u001b[39m=\u001b[39mbody,\n\u001b[1;32m    313\u001b[0m )\n\u001b[1;32m    315\u001b[0m \u001b[39mreturn\u001b[39;00m _json_to_prediction(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_client, resp\u001b[39m.\u001b[39mjson())\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/replicate/client.py:85\u001b[0m, in \u001b[0;36mClient._request\u001b[0;34m(self, method, path, **kwargs)\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_request\u001b[39m(\u001b[39mself\u001b[39m, method: \u001b[39mstr\u001b[39m, path: \u001b[39mstr\u001b[39m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m httpx\u001b[39m.\u001b[39mResponse:\n\u001b[1;32m     84\u001b[0m     resp \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_client\u001b[39m.\u001b[39mrequest(method, path, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m---> 85\u001b[0m     _raise_for_status(resp)\n\u001b[1;32m     87\u001b[0m     \u001b[39mreturn\u001b[39;00m resp\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/replicate/client.py:358\u001b[0m, in \u001b[0;36m_raise_for_status\u001b[0;34m(resp)\u001b[0m\n\u001b[1;32m    356\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_raise_for_status\u001b[39m(resp: httpx\u001b[39m.\u001b[39mResponse) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    357\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39m400\u001b[39m \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m resp\u001b[39m.\u001b[39mstatus_code \u001b[39m<\u001b[39m \u001b[39m600\u001b[39m:\n\u001b[0;32m--> 358\u001b[0m         \u001b[39mraise\u001b[39;00m ReplicateError(resp\u001b[39m.\u001b[39mjson()[\u001b[39m\"\u001b[39m\u001b[39mdetail\u001b[39m\u001b[39m\"\u001b[39m])\n",
+      "\u001b[0;31mReplicateError\u001b[0m: You have reached the free time limit. To continue using Replicate, set up billing at https://replicate.com/account/billing#billing."
+     ]
+    }
+   ],
+   "source": [
+    "from llama_index.llms import Replicate\n",
+    "\n",
+    "llm = Replicate(\n",
+    "    model=\"a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5\",\n",
+    "    temperature=0.1,\n",
+    "    #context_window=32,\n",
+    "    top_p=0.9,\n",
+    "    repetition_penalty=1.0,\n",
+    "    max_tokens=2000,\n",
+    "    #stop_sequences=[\"\\n\\n\"],   \n",
+    "\n",
+    ")\n",
+    "\n",
+    "input_plant_text = 'apple, orange, milk, eraser, cherry'\n",
+    "template=\"You return JUST a python list object containing the elements that can be grown in a garden. Do not include any other text or explanation.\"\n",
+    "text = 'which of the elements of this list can be grown in a garden, [' + input_plant_text + ']? Return JUST a python list object containing the elements that can be grown in a garden. Do not include any other text or explanation.'\n",
+    "input_prompt = template + text\n",
+    "print(input_prompt)\n",
+    "\n",
+    "resp = llm.complete(input_prompt)\n",
+    "print(resp)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Companion planting is the practice of growing different plants together in close proximity in order to improve their growth, health, and productivity. This technique takes advantage of the different ways that plants interact with each other, such as by providing shade, repelling pests, or attracting beneficial insects.\n",
+      "\n",
+      "Here are some of my thoughts on companion planting:\n",
+      "\n",
+      "1. Diversify your garden: Companion planting is a great way to add diversity to your garden, which can improve its overall health and resilience. By growing a mix of plants, you can create a more complex and dynamic ecosystem that is less susceptible to pests and diseases.\n",
+      "2. Improve soil health: Many companion plants, such as legumes and comfrey, have the ability to fix nitrogen or other nutrients in the soil, which can improve the health and fertility of the soil. This can lead to healthier and more productive plants.\n",
+      "3. Enhance pest control: Companion planting can be a powerful tool for controlling pests naturally. For example, basil and mint can repel aphids, while marigold and nasturtium can attract beneficial insects that prey on pests.\n",
+      "4. Increase yields: Companion planting can also help to increase yields by providing support and shade for plants, or by attracting beneficial insects that pollinate or prey on pests. For example, planting beans with corn and squash can provide a trellis for the beans and shade for the corn, while also attracting beneficial insects that prey on pests.\n",
+      "5. Reduce maintenance: Companion planting can also reduce the amount of maintenance required in your garden. For example, planting a mix of plants that have different growing habits and blooming times can create a more dynamic and resilient garden that requires less work to maintain.\n",
+      "\n",
+      "\n",
+      "Overall, I believe that companion planting is a valuable technique for gardeners of all experience levels. It can help to improve the health, productivity, and resilience of your garden, while also reducing the amount of maintenance required. By taking advantage of the different ways that plants interact with each other"
+     ]
+    }
+   ],
+   "source": [
+    "#os.environ[\"REPLICATE_API_TOKEN\"] = \"key here\"\n",
+    "api = replicate.Client(api_token=os.environ[\"REPLICATE_API_TOKEN\"])\n",
+    "output = api.run(\n",
+    "    \"a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5\",\n",
+    "    input={\"prompt\": \"what is your opinion on companion planting?\"},\n",
+    "    )\n",
+    "for item in output:\n",
+    "    print(item, end=\"\")\n",
+    "\n",
+    "# save response to string\n",
+    "resp = \"\"\n",
+    "for item in output:\n",
+    "    resp += item\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "config.json: 100%|██████████| 638/638 [00:00<00:00, 3.22MB/s]\n",
+      "model.safetensors.index.json: 100%|██████████| 23.9k/23.9k [00:00<00:00, 62.9MB/s]\n",
+      "model-00001-of-00008.safetensors: 100%|██████████| 1.89G/1.89G [00:26<00:00, 71.1MB/s]\n",
+      "model-00002-of-00008.safetensors: 100%|██████████| 1.95G/1.95G [00:27<00:00, 71.0MB/s]\n",
+      "model-00003-of-00008.safetensors: 100%|██████████| 1.98G/1.98G [00:27<00:00, 72.0MB/s]\n",
+      "model-00004-of-00008.safetensors: 100%|██████████| 1.95G/1.95G [00:27<00:00, 70.2MB/s]\n",
+      "model-00005-of-00008.safetensors: 100%|██████████| 1.98G/1.98G [00:28<00:00, 69.8MB/s]\n",
+      "model-00006-of-00008.safetensors: 100%|██████████| 1.95G/1.95G [00:28<00:00, 69.5MB/s]\n",
+      "model-00007-of-00008.safetensors: 100%|██████████| 1.98G/1.98G [00:28<00:00, 68.5MB/s]\n",
+      "model-00008-of-00008.safetensors: 100%|██████████| 816M/816M [00:11<00:00, 69.9MB/s]\n",
+      "Downloading shards: 100%|██████████| 8/8 [03:27<00:00, 25.96s/it]\n",
+      "Loading checkpoint shards: 100%|██████████| 8/8 [00:24<00:00,  3.04s/it]\n",
+      "generation_config.json: 100%|██████████| 111/111 [00:00<00:00, 1.12MB/s]\n",
+      "tokenizer_config.json: 100%|██████████| 1.43k/1.43k [00:00<00:00, 9.73MB/s]\n",
+      "tokenizer.model: 100%|██████████| 493k/493k [00:00<00:00, 69.9MB/s]\n",
+      "tokenizer.json: 100%|██████████| 1.80M/1.80M [00:00<00:00, 17.9MB/s]\n",
+      "added_tokens.json: 100%|██████████| 42.0/42.0 [00:00<00:00, 160kB/s]\n",
+      "special_tokens_map.json: 100%|██████████| 168/168 [00:00<00:00, 961kB/s]\n",
+      "/Users/dheym/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/generation/utils.py:1518: UserWarning: You have modified the pretrained model configuration to control generation. This is a deprecated strategy to control generation and will be removed soon, in a future version. Please use and modify the model generation configuration (see https://huggingface.co/docs/transformers/generation_strategies#default-text-generation-configuration )\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "Greedy methods without beam search do not support `num_return_sequences` different than 1 (got 3).",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtransformers\u001b[39;00m \u001b[39mimport\u001b[39;00m pipeline\n\u001b[1;32m      2\u001b[0m generator \u001b[39m=\u001b[39m pipeline(\u001b[39m'\u001b[39m\u001b[39mtext-generation\u001b[39m\u001b[39m'\u001b[39m, model \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mHuggingFaceH4/zephyr-7b-beta\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m----> 3\u001b[0m generator(\u001b[39m\"\u001b[39m\u001b[39mHello, I\u001b[39m\u001b[39m'\u001b[39m\u001b[39mm a language model\u001b[39m\u001b[39m\"\u001b[39m, max_length \u001b[39m=\u001b[39m \u001b[39m30\u001b[39m, num_return_sequences\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m)\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/pipelines/text_generation.py:208\u001b[0m, in \u001b[0;36mTextGenerationPipeline.__call__\u001b[0;34m(self, text_inputs, **kwargs)\u001b[0m\n\u001b[1;32m    167\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__call__\u001b[39m(\u001b[39mself\u001b[39m, text_inputs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m    168\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    169\u001b[0m \u001b[39m    Complete the prompt(s) given as inputs.\u001b[39;00m\n\u001b[1;32m    170\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    206\u001b[0m \u001b[39m          ids of the generated text.\u001b[39;00m\n\u001b[1;32m    207\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 208\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39m\u001b[39m__call__\u001b[39m(text_inputs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/pipelines/base.py:1140\u001b[0m, in \u001b[0;36mPipeline.__call__\u001b[0;34m(self, inputs, num_workers, batch_size, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1132\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mnext\u001b[39m(\n\u001b[1;32m   1133\u001b[0m         \u001b[39miter\u001b[39m(\n\u001b[1;32m   1134\u001b[0m             \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_iterator(\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1137\u001b[0m         )\n\u001b[1;32m   1138\u001b[0m     )\n\u001b[1;32m   1139\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1140\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrun_single(inputs, preprocess_params, forward_params, postprocess_params)\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/pipelines/base.py:1147\u001b[0m, in \u001b[0;36mPipeline.run_single\u001b[0;34m(self, inputs, preprocess_params, forward_params, postprocess_params)\u001b[0m\n\u001b[1;32m   1145\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mrun_single\u001b[39m(\u001b[39mself\u001b[39m, inputs, preprocess_params, forward_params, postprocess_params):\n\u001b[1;32m   1146\u001b[0m     model_inputs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpreprocess(inputs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mpreprocess_params)\n\u001b[0;32m-> 1147\u001b[0m     model_outputs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mforward(model_inputs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mforward_params)\n\u001b[1;32m   1148\u001b[0m     outputs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpostprocess(model_outputs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mpostprocess_params)\n\u001b[1;32m   1149\u001b[0m     \u001b[39mreturn\u001b[39;00m outputs\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/pipelines/base.py:1046\u001b[0m, in \u001b[0;36mPipeline.forward\u001b[0;34m(self, model_inputs, **forward_params)\u001b[0m\n\u001b[1;32m   1044\u001b[0m     \u001b[39mwith\u001b[39;00m inference_context():\n\u001b[1;32m   1045\u001b[0m         model_inputs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_ensure_tensor_on_device(model_inputs, device\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdevice)\n\u001b[0;32m-> 1046\u001b[0m         model_outputs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward(model_inputs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mforward_params)\n\u001b[1;32m   1047\u001b[0m         model_outputs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_ensure_tensor_on_device(model_outputs, device\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mdevice(\u001b[39m\"\u001b[39m\u001b[39mcpu\u001b[39m\u001b[39m\"\u001b[39m))\n\u001b[1;32m   1048\u001b[0m \u001b[39melse\u001b[39;00m:\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/pipelines/text_generation.py:271\u001b[0m, in \u001b[0;36mTextGenerationPipeline._forward\u001b[0;34m(self, model_inputs, **generate_kwargs)\u001b[0m\n\u001b[1;32m    268\u001b[0m         generate_kwargs[\u001b[39m\"\u001b[39m\u001b[39mmin_length\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m prefix_length\n\u001b[1;32m    270\u001b[0m \u001b[39m# BS x SL\u001b[39;00m\n\u001b[0;32m--> 271\u001b[0m generated_sequence \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmodel\u001b[39m.\u001b[39mgenerate(input_ids\u001b[39m=\u001b[39minput_ids, attention_mask\u001b[39m=\u001b[39mattention_mask, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mgenerate_kwargs)\n\u001b[1;32m    272\u001b[0m out_b \u001b[39m=\u001b[39m generated_sequence\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m]\n\u001b[1;32m    273\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mframework \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpt\u001b[39m\u001b[39m\"\u001b[39m:\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/torch/utils/_contextlib.py:115\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    112\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m    113\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdecorate_context\u001b[39m(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m    114\u001b[0m     \u001b[39mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 115\u001b[0m         \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/generation/utils.py:1529\u001b[0m, in \u001b[0;36mGenerationMixin.generate\u001b[0;34m(self, inputs, generation_config, logits_processor, stopping_criteria, prefix_allowed_tokens_fn, synced_gpus, assistant_model, streamer, negative_prompt_ids, negative_prompt_attention_mask, **kwargs)\u001b[0m\n\u001b[1;32m   1527\u001b[0m generation_config \u001b[39m=\u001b[39m copy\u001b[39m.\u001b[39mdeepcopy(generation_config)\n\u001b[1;32m   1528\u001b[0m model_kwargs \u001b[39m=\u001b[39m generation_config\u001b[39m.\u001b[39mupdate(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)  \u001b[39m# All unused kwargs must be model kwargs\u001b[39;00m\n\u001b[0;32m-> 1529\u001b[0m generation_config\u001b[39m.\u001b[39mvalidate()\n\u001b[1;32m   1530\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_validate_model_kwargs(model_kwargs\u001b[39m.\u001b[39mcopy())\n\u001b[1;32m   1532\u001b[0m \u001b[39m# 2. Set generation parameters if not already defined\u001b[39;00m\n",
+      "File \u001b[0;32m~/anaconda3/envs/GRDN_env/lib/python3.11/site-packages/transformers/generation/configuration_utils.py:498\u001b[0m, in \u001b[0;36mGenerationConfig.validate\u001b[0;34m(self, is_init)\u001b[0m\n\u001b[1;32m    496\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_beams \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[1;32m    497\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdo_sample \u001b[39mis\u001b[39;00m \u001b[39mFalse\u001b[39;00m:\n\u001b[0;32m--> 498\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m    499\u001b[0m             \u001b[39m\"\u001b[39m\u001b[39mGreedy methods without beam search do not support `num_return_sequences` different than 1 \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    500\u001b[0m             \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m(got \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_return_sequences\u001b[39m}\u001b[39;00m\u001b[39m).\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    501\u001b[0m         )\n\u001b[1;32m    502\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_return_sequences \u001b[39m>\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_beams:\n\u001b[1;32m    503\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m    504\u001b[0m         \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m`num_return_sequences` (\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_return_sequences\u001b[39m}\u001b[39;00m\u001b[39m) has to be smaller or equal to `num_beams` \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    505\u001b[0m         \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m(\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_beams\u001b[39m}\u001b[39;00m\u001b[39m).\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    506\u001b[0m     )\n",
+      "\u001b[0;31mValueError\u001b[0m: Greedy methods without beam search do not support `num_return_sequences` different than 1 (got 3)."
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import pipeline\n",
+    "generator = pipeline('text-generation', model = 'HuggingFaceH4/zephyr-7b-beta')\n",
+    "generator(\"Hello, I'm a language model\", max_length = 30, num_return_sequences=3)\n",
+    "## [{'generated_text': \"Hello, I'm a language modeler. So while writing this, when I went out to meet my wife or come home she told me that my\"},\n",
+    "##  {'generated_text': \"Hello, I'm a language modeler. I write and maintain software in Python. I love to code, and that includes coding things that require writing\"}, ...\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Stream text\n",
+    "def predict(message, chatbot, system_prompt=\"\", temperature=0.9, max_new_tokens=4096):\n",
+    "    \n",
+    "    client = Client(\"https://ysharma-explore-llamav2-with-tgi.hf.space/\")\n",
+    "    return client.predict(\n",
+    "            message,  # str in 'Message' Textbox component\n",
+    "            system_prompt,  # str in 'Optional system prompt' Textbox component\n",
+    "            temperature,  # int | float (numeric value between 0.0 and 1.0)\n",
+    "            max_new_tokens,  # int | float (numeric value between 0 and 4096)\n",
+    "            0.3,  # int | float (numeric value between 0.0 and 1)\n",
+    "            1,  # int | float (numeric value between 1.0 and 2.0)\n",
+    "            api_name=\"/chat\"\n",
+    "    )\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "GRDN_env",
+   "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.11.3"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

readme.md

@@ -0,0 +1,56 @@
+# README
+<br/>
+<br/>
+<font size = "18"> GRDN 🌱</font>
+<br/>
+author: Danielle Heymann
+<br/>
+contact: [email protected]
+<br/>
+last updated: 12/17/2023
+<br/>
+<br/>
+GRDN is an application that allows users to optimize a garden and its plant beds through companion planting, generative AI, and optimization. It is a work in progress. </font>
+<br/>
+<br/>
+<br/>
+
+## Background
+info
+<br>
+<br>
+![app1](src/assets/readme1.png)
+<br>
+<br>
+![app2](src/assets/readme2.png)
+<br>
+<br>
+![app3](src/assets/readme3.png)
+<br>
+<br>
+![app4](src/assets/readme4.png)
+<br>
+<br>
+![app5](src/assets/readme5.png)
+<br>
+<br>
+
+## Setup
+- setup conda environment 
+  >*conda create --name=GRDN_env*
+- install dependencies
+  >*pip install -r requirements.txt*
+- download local model and add it to model folder
+  >I used LLama2 7B HF Chat model
+  >https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/blob/main/llama-2-7b-chat.Q4_K_M.gguf
+
+## Running App
+- navigate to ...GRDN/src
+- activate environment
+  >*conda activate GRDN_env*
+- run app
+  >*python -m streamlit run app.py*
+
+
+
+