{ "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 \")" ] }, { "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 }