diff --git a/06_CodeGeneration/00_code_generatation_w_bedrock.ipynb b/06_CodeGeneration/00_code_generatation_w_bedrock.ipynb index f3de3465..2a0cf1e6 100644 --- a/06_CodeGeneration/00_code_generatation_w_bedrock.ipynb +++ b/06_CodeGeneration/00_code_generatation_w_bedrock.ipynb @@ -93,24 +93,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "776fd083", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Create new client\n", - " Using region: us-east-1\n", - " Using profile: fine-tuning-bedrock\n", - "boto3 Bedrock client successfully created!\n", - "bedrock(https://bedrock.us-east-1.amazonaws.com)\n" - ] - } - ], + "outputs": [], "source": [ "import json\n", "import os\n", @@ -159,18 +147,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "89a0ad24", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "sales.csv has been created!\n" - ] - } - ], + "outputs": [], "source": [ "# create sales.csv file\n", "import csv\n", @@ -289,62 +269,10 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "016a118a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Here is the Python code to analyze sales data from a CSV file:\n", - "\n", - "```python\n", - "import csv\n", - "from collections import defaultdict\n", - "import matplotlib.pyplot as plt\n", - "\n", - "revenue = 0\n", - "monthly_revenue = defaultdict(int)\n", - "product_revenue = defaultdict(int)\n", - "max_revenue = 0\n", - "max_revenue_date = ''\n", - "max_revenue_product = ''\n", - "\n", - "with open('sales.csv') as f:\n", - " reader = csv.reader(f)\n", - " next(reader)\n", - " for row in reader:\n", - " date = row[0]\n", - " product = row[1]\n", - " price = float(row[2])\n", - " units = int(row[3])\n", - "\n", - " revenue += price * units\n", - " product_revenue[product] += price * units\n", - " monthly_revenue[date[:7]] += price * units\n", - "\n", - " if revenue > max_revenue:\n", - " max_revenue = revenue\n", - " max_revenue_date = date\n", - " max_revenue_product = product\n", - "\n", - "months = list(monthly_revenue.keys())\n", - "values = list(monthly_revenue.values())\n", - "\n", - "plt.bar(months, values)\n", - "plt.xlabel('Month')\n", - "plt.ylabel('Revenue')\n", - "plt.title('Monthly Revenue')\n", - "plt.show()\n", - "\n", - "print('Total Revenue:', revenue)\n", - "print('Product with max revenue:', max_revenue_product)\n", - "print('Date with max revenue:', max_revenue_date)\n", - "```\n" - ] - } - ], + "outputs": [], "source": [ "modelId = 'anthropic.claude-v2' # change this to use a different version from the model provider\n", "accept = 'application/json'\n", @@ -366,30 +294,10 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "77d9b428", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total Revenue: 35490.0\n", - "Product with max revenue: P002\n", - "Date with max revenue: 2023-05-25\n" - ] - } - ], + "outputs": [], "source": [ "# Sample Generated Python Code ( Generated with Amazon Bedrock in previous step)\n", "\n", diff --git a/06_CodeGeneration/01_sql_query_generate_w_bedrock.ipynb b/06_CodeGeneration/01_sql_query_generate_w_bedrock.ipynb index ae1bebff..7edf9a99 100644 --- a/06_CodeGeneration/01_sql_query_generate_w_bedrock.ipynb +++ b/06_CodeGeneration/01_sql_query_generate_w_bedrock.ipynb @@ -193,49 +193,12 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "id": "ecaceef1-0f7f-4ae5-8007-ff7c25335251", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Here are the SQL queries to answer the questions:\n", - "\n", - "1. Identify the top 5 best selling products by total sales for the year 2023:\n", - "\n", - "```sql\n", - "SELECT product_id, SUM(price * units_sold) AS total_sales\n", - "FROM sales_data\n", - "WHERE date BETWEEN '2023-01-01' AND '2023-12-31'\n", - "GROUP BY product_id\n", - "ORDER BY total_sales DESC\n", - "LIMIT 5;\n", - "```\n", - "\n", - "2. Calculate the monthly average sales for the year 2023:\n", - "\n", - "```sql\n", - "SELECT\n", - " DATE_FORMAT(date, '%Y-%m') AS month,\n", - " AVG(price * units_sold) AS avg_monthly_sales\n", - "FROM sales_data\n", - "WHERE date BETWEEN '2023-01-01' AND '2023-12-31'\n", - "GROUP BY month\n", - "ORDER BY month;\n", - "```\n", - "\n", - "The first query groups the sales data by product_id, sums the total sales for each product, filters\n", - "for 2023 data only, orders by the total sales in descending order and limits to the top 5 results.\n", - "\n", - "The second query extracts the month from the date, calculates the average monthly sales by\n", - "aggregating on the month and ordering the results chronologically.\n" - ] - } - ], + "outputs": [], "source": [ "modelId = 'anthropic.claude-v2' # change this to use a different version from the model provider\n", "accept = 'application/json'\n", @@ -337,42 +300,10 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "id": "5c45f4fc", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Here is a SQL query to fetch patients who were prescribed more than 5 medications on 2023-04-01:\n", - "\n", - "```sql\n", - "SELECT p.FirstName, p.LastName\n", - "FROM Patients p\n", - "JOIN Prescriptions pre ON p.PatientID = pre.PatientID\n", - "JOIN PrescriptionDetails pd ON pre.PrescriptionID = pd.PrescriptionID\n", - "WHERE pre.DateIssued = '2023-04-01'\n", - "GROUP BY p.PatientID\n", - "HAVING COUNT(DISTINCT pd.MedicationID) > 5;\n", - "```\n", - "\n", - "The key steps are:\n", - "\n", - "1. Join the Patients, Prescriptions and PrescriptionDetails tables to connect patients with their\n", - "prescriptions and medication details.\n", - "\n", - "2. Filter to only prescriptions issued on 2023-04-01.\n", - "\n", - "3. Group by PatientID and count the distinct MedicationIDs per patient.\n", - "\n", - "4. Use HAVING to only keep patients with more than 5 distinct medications.\n", - "\n", - "This will return all patients who had prescriptions for more than 5 different medications on the\n", - "given date.\n" - ] - } - ], + "outputs": [], "source": [ "modelId = 'anthropic.claude-v2' # change this to use a different version from the model provider\n", "accept = 'application/json'\n", diff --git a/06_CodeGeneration/02_code_interpret_w_langchain.ipynb b/06_CodeGeneration/02_code_interpret_w_langchain.ipynb index b4780973..202353e1 100644 --- a/06_CodeGeneration/02_code_interpret_w_langchain.ipynb +++ b/06_CodeGeneration/02_code_interpret_w_langchain.ipynb @@ -296,56 +296,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "c1064c57-27a4-48c5-911b-e4f1dfeff122", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Overall, the code follows good OOP design principles and uses inheritance appropriately. The Vehicle\n", - "base class contains common data members and methods, while Truck and Car derive from it and add\n", - "specific details.\n", - "\n", - "Some positives:\n", - "\n", - "- Uses protected inheritance correctly to allow derived classes access to base class members.\n", - "\n", - "- Uses virtual methods like displayDetails() to enable polymorphic behavior.\n", - "\n", - "- Uses smart pointers (unique_ptr) instead of raw pointers to manage memory and avoid leaks.\n", - "\n", - "- Uses override specifier to explicitly indicate overridden methods.\n", - "\n", - "- Uses a vector to store heterogeneous objects through a common base pointer.\n", - "\n", - "- Checks for maintenance due based on miles traveled.\n", - "\n", - "- No major red flags or bad practices noted.\n", - "\n", - "Some things that could be improved:\n", - "\n", - "- The base Vehicle class could use pure virtual methods instead of a mix of virtual and pure virtual\n", - "methods.\n", - "\n", - "- The Vehicle constructor initializes data members - should consider using member initializer list\n", - "instead.\n", - "\n", - "- Unique pointers could be used instead of raw pointers for automatic memory management.\n", - "\n", - "- The displayDetails() method could be renamed to something more specific like printDetails().\n", - "\n", - "- Comments could be added to explain parts of logic/flow.\n", - "\n", - "Overall the code is well written, follows OOP principles and does not have any major issues. Just a\n", - "few minor improvements/enhancements possible.\n" - ] - } - ], + "outputs": [], "source": [ "response = textgen_llm(prompt)\n", "\n", diff --git a/06_CodeGeneration/03_code_translate_w_langchain.ipynb b/06_CodeGeneration/03_code_translate_w_langchain.ipynb index 4bc25c03..c8300e08 100644 --- a/06_CodeGeneration/03_code_translate_w_langchain.ipynb +++ b/06_CodeGeneration/03_code_translate_w_langchain.ipynb @@ -295,113 +295,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "c1064c57-27a4-48c5-911b-e4f1dfeff122", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "```java\n", - "import java.util.ArrayList;\n", - "\n", - "class Vehicle {\n", - " protected String registrationNumber;\n", - " protected int milesTraveled;\n", - " protected int lastMaintenanceMile;\n", - "\n", - " public Vehicle(String regNum) {\n", - " this.registrationNumber = regNum;\n", - " this.milesTraveled = 0;\n", - " this.lastMaintenanceMile = 0;\n", - " }\n", - "\n", - " public void addMiles(int miles) {\n", - " this.milesTraveled += miles;\n", - " }\n", - "\n", - " public void performMaintenance() {\n", - " this.lastMaintenanceMile = this.milesTraveled;\n", - " System.out.println(\"Maintenance performed for vehicle: \" + this.registrationNumber);\n", - " }\n", - "\n", - " public void checkMaintenanceDue() {\n", - " if ((this.milesTraveled - this.lastMaintenanceMile) > 10000) {\n", - " System.out.println(\"Vehicle: \" + this.registrationNumber + \" needs maintenance!\");\n", - " } else {\n", - " System.out.println(\"No maintenance required for vehicle: \" + this.registrationNumber);\n", - " }\n", - " }\n", - "\n", - " public void displayDetails() {\n", - " // Implemented in subclasses\n", - " }\n", - "}\n", - "\n", - "class Truck extends Vehicle {\n", - " private int capacityInTons;\n", - "\n", - " public Truck(String regNum, int capacity) {\n", - " super(regNum);\n", - " this.capacityInTons = capacity;\n", - " }\n", - "\n", - " @Override\n", - " public void displayDetails() {\n", - " System.out.println(\"Truck with Registration Number: \" + this.registrationNumber + \",\n", - "Capacity: \" + this.capacityInTons + \" tons.\");\n", - " }\n", - "}\n", - "\n", - "class Car extends Vehicle {\n", - " private String model;\n", - "\n", - " public Car(String regNum, String carModel) {\n", - " super(regNum);\n", - " this.model = carModel;\n", - " }\n", - "\n", - " @Override\n", - " public void displayDetails() {\n", - " System.out.println(\"Car with Registration Number: \" + this.registrationNumber + \", Model: \"\n", - "+ this.model + \".\");\n", - " }\n", - "}\n", - "\n", - "public class Main {\n", - " public static void main(String[] args) {\n", - " ArrayList fleet = new ArrayList<>();\n", - "\n", - " fleet.add(new Truck(\"XYZ1234\", 20));\n", - " fleet.add(new Car(\"ABC9876\", \"Sedan\"));\n", - "\n", - " for (Vehicle vehicle : fleet) {\n", - " vehicle.displayDetails();\n", - " vehicle.addMiles(10500);\n", - " vehicle.checkMaintenanceDue();\n", - " vehicle.performMaintenance();\n", - " vehicle.checkMaintenanceDue();\n", - " }\n", - " }\n", - "}\n", - "```\n", - "\n", - "Key points:\n", - "\n", - "- Used ArrayList instead of raw vectors\n", - "- Overrode methods using @Override annotation\n", - "- Used access modifiers properly (private, public)\n", - "- Followed naming conventions and formatting standards\n", - "- Implemented polymorphic behavior using abstract class and subclasses\n", - "\n", - "Let me know if you have any other questions!\n" - ] - } - ], + "outputs": [], "source": [ "response = textgen_llm(prompt)\n", "\n",