diff --git a/examples/o1-and-gpt-4-js/app.ts b/examples/o1-and-gpt-4-js/app.ts index b6745fd..f138f15 100644 --- a/examples/o1-and-gpt-4-js/app.ts +++ b/examples/o1-and-gpt-4-js/app.ts @@ -116,7 +116,8 @@ async function chat( // First, get the plan from o1-mini try { const responseO1 = await openai.chat.completions.create({ - model: "o1-mini", // Assuming this model is accessible + model: "o3-mini", // Choose different model by uncommenting + //model: "o1-mini", messages: [ { role: "user", content: O1_PROMPT }, { role: "user", content: userMessage }, diff --git a/examples/o1-and-gpt-4-js/result.png b/examples/o1-and-gpt-4-js/result.png index 6093d78..7470617 100644 Binary files a/examples/o1-and-gpt-4-js/result.png and b/examples/o1-and-gpt-4-js/result.png differ diff --git a/examples/o1-and-gpt-4-python/o1.ipynb b/examples/o1-and-gpt-4-python/o1.ipynb index 07037d2..1308abe 100644 --- a/examples/o1-and-gpt-4-python/o1.ipynb +++ b/examples/o1-and-gpt-4-python/o1.ipynb @@ -47,7 +47,7 @@ "Requirement already satisfied: pydantic-core==2.23.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3,>=1.9.0->openai) (2.23.3)\n", "Requirement already satisfied: six>=1.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from python-dateutil>=2.8.2->e2b<2.0.0,>=1.0.0->e2b_code_interpreter==1.0.0) (1.16.0)\n", "\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.3.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] @@ -154,7 +154,8 @@ "\n", " # First we get the plan from o1\n", " response_o1 = client.chat.completions.create(\n", - " model=\"o1-mini\",\n", + " model=\"o3-mini\", # Choose different model by uncommenting\n", + " # model=\"o1-mini\",\n", " messages=[\n", " {\"role\": \"user\", \"content\": O1_PROMPT},\n", " {\"role\": \"user\", \"content\": user_message}\n", @@ -244,131 +245,111 @@ "==================================================\n", "> LLM-generated code:\n", "# Install necessary packages\n", - "!pip install pandas numpy scikit-learn matplotlib\n", + "!pip install pandas scikit-learn matplotlib seaborn\n", "\n", "# Import libraries\n", "import pandas as pd\n", "import numpy as np\n", - "from sklearn.model_selection import train_test_split, learning_curve\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "from sklearn.metrics import accuracy_score, classification_report\n", "import matplotlib.pyplot as plt\n", - "\n", - "# Load training data\n", - "train_data = pd.read_csv('/home/user/train.csv')\n", - "\n", - "# Data cleaning\n", - "# Fill missing Age with median\n", - "train_data['Age'].fillna(train_data['Age'].median(), inplace=True)\n", - "\n", - "# Fill missing Embarked with mode\n", - "train_data['Embarked'].fillna(train_data['Embarked'].mode()[0], inplace=True)\n", - "\n", - "# Drop Cabin column\n", - "train_data.drop('Cabin', axis=1, inplace=True)\n", - "\n", - "# Drop unnecessary columns\n", - "train_data.drop(['PassengerId', 'Name', 'Ticket'], axis=1, inplace=True)\n", - "\n", - "# Encode categorical variables\n", - "train_data['Sex'] = train_data['Sex'].map({'male': 0, 'female': 1})\n", - "\n", - "# One-hot encode Embarked\n", - "train_data = pd.get_dummies(train_data, columns=['Embarked'], drop_first=True)\n", - "\n", - "# Split data into features and target\n", - "X = train_data.drop('Survived', axis=1)\n", - "y = train_data['Survived']\n", - "\n", - "# Split into training and validation sets\n", - "X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "\n", - "# Train Decision Tree Classifier\n", + "import seaborn as sns\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.model_selection import learning_curve, train_test_split\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "# Set a style for seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "\n", + "# Define a preprocessing function for both training and test data\n", + "def preprocess_data(df, is_train=True):\n", + " drop_cols = ['PassengerId', 'Name', 'Ticket', 'Cabin']\n", + " if not is_train:\n", + " ids = df['PassengerId']\n", + " df = df.drop(['Name', 'Ticket', 'Cabin'], axis=1)\n", + " else:\n", + " df = df.drop(drop_cols, axis=1)\n", + " \n", + " df['Age'] = df['Age'].fillna(df['Age'].median())\n", + " if 'Fare' in df.columns:\n", + " df['Fare'] = df['Fare'].fillna(df['Fare'].median())\n", + " if 'Embarked' in df.columns:\n", + " df['Embarked'] = df['Embarked'].fillna(df['Embarked'].mode()[0])\n", + " \n", + " df = pd.get_dummies(df, columns=['Sex', 'Embarked'], drop_first=True)\n", + " \n", + " if is_train:\n", + " y = df['Survived']\n", + " X = df.drop('Survived', axis=1)\n", + " return X, y\n", + " else:\n", + " return df, ids\n", + "\n", + "# Load the data (please adjust paths accordingly)\n", + "train_df = pd.read_csv('train.csv', delimiter=',') # Change path as needed\n", + "test_df = pd.read_csv('test.csv', delimiter=',') # Change path as needed\n", + "\n", + "# Preprocess the training data\n", + "X, y = preprocess_data(train_df, is_train=True)\n", + "\n", + "# Initialize the Decision Tree Classifier and compute the learning curve\n", "clf = DecisionTreeClassifier(random_state=42)\n", - "clf.fit(X_train, y_train)\n", - "\n", - "# Predict on validation set\n", - "y_pred = clf.predict(X_val)\n", - "\n", - "# Evaluate\n", - "accuracy = accuracy_score(y_val, y_pred)\n", - "print(f'Validation Accuracy: {accuracy:.2f}')\n", - "print(classification_report(y_val, y_pred))\n", "\n", - "# Plot learning curve\n", - "train_sizes, train_scores, test_scores = learning_curve(\n", - " clf, X, y, cv=5, scoring='accuracy', n_jobs=-1,\n", - " train_sizes=np.linspace(0.1, 1.0, 10)\n", + "train_sizes, train_scores, validation_scores = learning_curve(\n", + " estimator=clf,\n", + " X=X,\n", + " y=y,\n", + " train_sizes=np.linspace(0.1, 1.0, 10),\n", + " cv=5,\n", + " scoring='accuracy',\n", + " shuffle=True,\n", + " random_state=42\n", ")\n", "\n", - "train_scores_mean = train_scores.mean(axis=1)\n", - "test_scores_mean = test_scores.mean(axis=1)\n", - "\n", - "plt.figure(figsize=(8, 6))\n", - "plt.plot(train_sizes, train_scores_mean, 'o-', color='r', label='Training score')\n", - "plt.plot(train_sizes, test_scores_mean, 'o-', color='g', label='Cross-validation score')\n", - "plt.title('Learning Curve for Decision Tree Classifier')\n", - "plt.xlabel('Training examples')\n", - "plt.ylabel('Score')\n", - "plt.legend(loc='best')\n", + "train_mean = np.mean(train_scores, axis=1)\n", + "train_std = np.std(train_scores, axis=1)\n", + "validation_mean = np.mean(validation_scores, axis=1)\n", + "validation_std = np.std(validation_scores, axis=1)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(train_sizes, train_mean, 'o-', color=\"r\", label=\"Training score\")\n", + "plt.plot(train_sizes, validation_mean, 'o-', color=\"g\", label=\"Cross-validation score\")\n", + "plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\"r\", alpha=0.1)\n", + "plt.fill_between(train_sizes, validation_mean - validation_std, validation_mean + validation_std, color=\"g\", alpha=0.1)\n", + "plt.title(\"Learning Curve for Decision Tree Classifier\")\n", + "plt.xlabel(\"Training Set Size\")\n", + "plt.ylabel(\"Accuracy Score\")\n", + "plt.legend(loc=\"best\")\n", + "plt.grid(True)\n", "plt.show()\n", "\n", - "# Load test data\n", - "test_data = pd.read_csv('/home/user/test.csv')\n", - "\n", - "# Fill missing Age with median\n", - "test_data['Age'].fillna(test_data['Age'].median(), inplace=True)\n", - "\n", - "# Fill missing Fare with median\n", - "test_data['Fare'].fillna(test_data['Fare'].median(), inplace=True)\n", - "\n", - "# Fill missing Embarked with mode\n", - "test_data['Embarked'].fillna(test_data['Embarked'].mode()[0], inplace=True)\n", + "# Fit the model on the entire training dataset\n", + "clf.fit(X, y)\n", "\n", - "# Drop Cabin column\n", - "test_data.drop('Cabin', axis=1, inplace=True)\n", + "# Preprocess the test data and run predictions\n", + "X_test, test_ids = preprocess_data(test_df, is_train=False)\n", + "predictions = clf.predict(X_test)\n", "\n", - "# Drop unnecessary columns\n", - "test_data.drop(['PassengerId', 'Name', 'Ticket'], axis=1, inplace=True)\n", - "\n", - "# Encode categorical variables\n", - "test_data['Sex'] = test_data['Sex'].map({'male': 0, 'female': 1})\n", - "\n", - "# One-hot encode Embarked\n", - "test_data = pd.get_dummies(test_data, columns=['Embarked'], drop_first=True)\n", - "\n", - "# Ensure same columns as training data\n", - "for col in X.columns:\n", - " if col not in test_data.columns:\n", - " test_data[col] = 0\n", - "test_data = test_data[X.columns]\n", - "\n", - "# Predict on test data\n", - "test_predictions = clf.predict(test_data)\n", - "\n", - "# Prepare a DataFrame with PassengerId and Survival\n", - "passenger_ids = pd.read_csv('/home/user/test.csv')['PassengerId']\n", - "output = pd.DataFrame({'PassengerId': passenger_ids, 'Survived': test_predictions})\n", - "\n", - "print(output)\n", + "# Print the predictions along with PassengerId\n", + "results = pd.DataFrame({'PassengerId': test_ids, 'Survived': predictions})\n", + "print(results)\n", "Running code interpreter...\n", "[Code Interpreter] Requirement already satisfied: pandas in /usr/local/lib/python3.10/site-packages (1.5.3)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.10/site-packages (1.26.4)\n", "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/site-packages (1.4.1.post1)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/site-packages (3.9.2)\n", + "Requirement already satisfied: seaborn in /usr/local/lib/python3.10/site-packages (0.13.2)\n", "\n", "[Code Interpreter] Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/site-packages (from pandas) (2024.1)\n", + "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/site-packages (from pandas) (1.26.4)\n", "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/site-packages (from pandas) (2.9.0.post0)\n", + "\n", + "[Code Interpreter] Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (3.5.0)\n", "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (1.12.0)\n", "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (1.3.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (3.5.0)\n", - "\n", - "[Code Interpreter] Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/site-packages (from matplotlib) (4.55.4)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (1.4.8)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/site-packages (from matplotlib) (0.12.1)\n", "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/site-packages (from matplotlib) (24.2)\n", "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (3.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/site-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/site-packages (from matplotlib) (4.55.4)\n", "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (1.3.1)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (1.4.8)\n", "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/site-packages (from matplotlib) (9.5.0)\n", "\n", "[Code Interpreter] Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/site-packages (from python-dateutil>=2.8.1->pandas) (1.17.0)\n", @@ -376,47 +357,22 @@ "[Code Interpreter] \u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", "\u001b[0m\n", "[Code Interpreter] \n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.3.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", "\n", - "[Code Interpreter] Validation Accuracy: 0.79\n", - " precision recall f1-score support\n", - "\n", - " 0 0.82 0.82 0.82 105\n", - " 1 0.74 0.74 0.74 74\n", - "\n", - " accuracy 0.79 179\n", - " macro avg 0.78 0.78 0.78 179\n", - "weighted avg 0.79 0.79 0.79 179\n", - "\n", - "\n", - "[Code Interpreter] PassengerId Survived\n", - "0 892 0\n", - "1 893 1\n", - "2 894 1\n", - "3 895 1\n", - "4 896 1\n", - ".. ... ...\n", - "413 1305 0\n", - "414 1306 1\n", - "415 1307 0\n", - "416 1308 0\n", - "417 1309 0\n", - "\n", - "[418 rows x 2 columns]\n", - "\n" + "[Code Interpreter ERROR] ExecutionError(name='ValueError', value='The feature names should match those that were passed during fit.\\nFeature names unseen at fit time:\\n- PassengerId\\n', traceback='---------------------------------------------------------------------------ValueError Traceback (most recent call last)Cell In[1], line 84\\n 82 # Preprocess the test data and run predictions\\n 83 X_test, test_ids = preprocess_data(test_df, is_train=False)\\n---> 84 predictions = clf.predict(X_test)\\n 86 # Print the predictions along with PassengerId\\n 87 results = pd.DataFrame({\\'PassengerId\\': test_ids, \\'Survived\\': predictions})\\nFile /usr/local/lib/python3.10/site-packages/sklearn/tree/_classes.py:529, in BaseDecisionTree.predict(self, X, check_input)\\n 506 \"\"\"Predict class or regression value for X.\\n 507 \\n 508 For a classification model, the predicted class for each sample in X is\\n (...)\\n 526 The predicted classes, or the predict values.\\n 527 \"\"\"\\n 528 check_is_fitted(self)\\n--> 529 X = self._validate_X_predict(X, check_input)\\n 530 proba = self.tree_.predict(X)\\n 531 n_samples = X.shape[0]\\nFile /usr/local/lib/python3.10/site-packages/sklearn/tree/_classes.py:489, in BaseDecisionTree._validate_X_predict(self, X, check_input)\\n 487 else:\\n 488 force_all_finite = True\\n--> 489 X = self._validate_data(\\n 490 X,\\n 491 dtype=DTYPE,\\n 492 accept_sparse=\"csr\",\\n 493 reset=False,\\n 494 force_all_finite=force_all_finite,\\n 495 )\\n 496 if issparse(X) and (\\n 497 X.indices.dtype != np.intc or X.indptr.dtype != np.intc\\n 498 ):\\n 499 raise ValueError(\"No support for np.int64 index based sparse matrices\")\\nFile /usr/local/lib/python3.10/site-packages/sklearn/base.py:608, in BaseEstimator._validate_data(self, X, y, reset, validate_separately, cast_to_ndarray, **check_params)\\n 537 def _validate_data(\\n 538 self,\\n 539 X=\"no_validation\",\\n (...)\\n 544 **check_params,\\n 545 ):\\n 546 \"\"\"Validate input data and set or check the `n_features_in_` attribute.\\n 547 \\n 548 Parameters\\n (...)\\n 606 validated.\\n 607 \"\"\"\\n--> 608 self._check_feature_names(X, reset=reset)\\n 610 if y is None and self._get_tags()[\"requires_y\"]:\\n 611 raise ValueError(\\n 612 f\"This {self.__class__.__name__} estimator \"\\n 613 \"requires y to be passed, but the target y is None.\"\\n 614 )\\nFile /usr/local/lib/python3.10/site-packages/sklearn/base.py:535, in BaseEstimator._check_feature_names(self, X, reset)\\n 530 if not missing_names and not unexpected_names:\\n 531 message += (\\n 532 \"Feature names must be in the same order as they were in fit.\\\\n\"\\n 533 )\\n--> 535 raise ValueError(message)\\nValueError: The feature names should match those that were passed during fit.\\nFeature names unseen at fit time:\\n- PassengerId\\n')\n" ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "Result(
)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" + "ename": "Exception", + "evalue": "No code interpreter results", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[7], line 14\u001b[0m\n\u001b[1;32m 12\u001b[0m first_result \u001b[38;5;241m=\u001b[39m code_results[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 14\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo code interpreter results\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 16\u001b[0m first_result\n", + "\u001b[0;31mException\u001b[0m: No code interpreter results" + ] } ], "source": [ diff --git a/examples/o1-js/.env.template b/examples/openai-js/.env.template similarity index 100% rename from examples/o1-js/.env.template rename to examples/openai-js/.env.template diff --git a/examples/o1-js/.gitignore b/examples/openai-js/.gitignore similarity index 100% rename from examples/o1-js/.gitignore rename to examples/openai-js/.gitignore diff --git a/examples/o1-js/README.md b/examples/openai-js/README.md similarity index 100% rename from examples/o1-js/README.md rename to examples/openai-js/README.md diff --git a/examples/o1-js/app.ts b/examples/openai-js/app.ts similarity index 96% rename from examples/o1-js/app.ts rename to examples/openai-js/app.ts index 5106cfc..cf960e5 100644 --- a/examples/o1-js/app.ts +++ b/examples/openai-js/app.ts @@ -6,7 +6,8 @@ import * as dotenv from 'dotenv' dotenv.config() -const MODEL_NAME = 'o1' +const MODEL_NAME = 'o3-mini' // Choose different model by uncommenting. You can choose from models with function-calling support, such as o1 or o3-mini. +// const MODEL_NAME = 'o1' const SYSTEM_PROMPT = ` ## your job & context diff --git a/examples/o1-js/city_temperature.csv b/examples/openai-js/city_temperature.csv similarity index 100% rename from examples/o1-js/city_temperature.csv rename to examples/openai-js/city_temperature.csv diff --git a/examples/o1-js/package-lock.json b/examples/openai-js/package-lock.json similarity index 100% rename from examples/o1-js/package-lock.json rename to examples/openai-js/package-lock.json diff --git a/examples/o1-js/package.json b/examples/openai-js/package.json similarity index 100% rename from examples/o1-js/package.json rename to examples/openai-js/package.json diff --git a/examples/o1-js/temperature_analysis.png b/examples/openai-js/temperature_analysis.png similarity index 100% rename from examples/o1-js/temperature_analysis.png rename to examples/openai-js/temperature_analysis.png diff --git a/examples/o1-python/.gitignore b/examples/openai-python/.gitignore similarity index 100% rename from examples/o1-python/.gitignore rename to examples/openai-python/.gitignore diff --git a/examples/o1-python/city_temperature.csv b/examples/openai-python/city_temperature.csv similarity index 100% rename from examples/o1-python/city_temperature.csv rename to examples/openai-python/city_temperature.csv diff --git a/examples/o1-python/o1.ipynb b/examples/openai-python/openai.ipynb similarity index 98% rename from examples/o1-python/o1.ipynb rename to examples/openai-python/openai.ipynb index 5efe91a..e719374 100644 --- a/examples/o1-python/o1.ipynb +++ b/examples/openai-python/openai.ipynb @@ -4,8 +4,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Code Interpreting with o1 by OpenAI\n", - "This example uses the E2B's [Code Interpreter](https://github.com/e2b-dev/code-interpreter) as a tool for o1. " + "# Code Interpreting with OpenAi models\n", + "This example uses the E2B's [Code Interpreter](https://github.com/e2b-dev/code-interpreter) as a tool for OpenAI's model. You can choose from models with function-calling support, such as o1 or o3-mini." ] }, { @@ -167,7 +167,8 @@ " \n", " print('Waiting for the LLM to respond...')\n", " completion = client.chat.completions.create(\n", - " model=\"o1\",\n", + " model=\"o3\", #Choose different model by uncommenting\n", + " # model=\"o1\",\n", " messages=[\n", " {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n", " {\"role\": \"user\", \"content\": user_message}\n", diff --git a/examples/o1-python/temperature_analysis.png b/examples/openai-python/temperature_analysis.png similarity index 100% rename from examples/o1-python/temperature_analysis.png rename to examples/openai-python/temperature_analysis.png