├── .github └── workflows │ ├── python-package-cd.yml │ └── python-package-ci.yml ├── .gitignore ├── LICENSE ├── README.md ├── examples └── basic_demo.ipynb ├── noxfile.py ├── pyproject.toml ├── src └── llm_regression │ ├── __init__.py │ ├── models.py │ ├── py.typed │ └── utils.py └── tests ├── test_models.py └── test_utils.py /.github/workflows/python-package-cd.yml: -------------------------------------------------------------------------------- 1 | name: Deploy Python package 2 | 3 | on: 4 | release: 5 | types: [published] 6 | 7 | jobs: 8 | build-and-deploy: 9 | runs-on: ubuntu-latest 10 | strategy: 11 | fail-fast: false 12 | matrix: 13 | python-version: ["3.12"] 14 | steps: 15 | - uses: actions/checkout@v3 16 | - name: Set up Python ${{ matrix.python-version }} 17 | uses: actions/setup-python@v3 18 | with: 19 | python-version: ${{ matrix.python-version }} 20 | - name: Install Nox 21 | run: | 22 | python -m pip install --upgrade pip 23 | python -m pip install --upgrade setuptools 24 | python -m pip install "nox==2023.4.22" 25 | - name: Build wheel and push to PyPI 26 | env: 27 | PYPI_USR: ${{ secrets.PYPI_USR }} 28 | PYPI_PWD: ${{ secrets.PYPI_PWD }} 29 | run: | 30 | nox -s build_and_deploy 31 | -------------------------------------------------------------------------------- /.github/workflows/python-package-ci.yml: -------------------------------------------------------------------------------- 1 | name: Python package 2 | 3 | on: 4 | pull_request: 5 | branches: [ "main" ] 6 | 7 | jobs: 8 | test: 9 | runs-on: ubuntu-latest 10 | strategy: 11 | fail-fast: false 12 | matrix: 13 | python-version: ["3.12"] 14 | steps: 15 | - uses: actions/checkout@v3 16 | - name: Set up Python ${{ matrix.python-version }} 17 | uses: actions/setup-python@v3 18 | with: 19 | python-version: ${{ matrix.python-version }} 20 | - name: Install Nox 21 | run: | 22 | python -m pip install --upgrade pip 23 | python -m pip install --upgrade setuptools 24 | python -m pip install "nox==2023.4.22" 25 | - name: Run code formatting checks 26 | run: | 27 | nox -s check_code_formatting-${{ matrix.python-version }} 28 | - name: Run static type checking 29 | run: | 30 | nox -s check_types-${{ matrix.python-version }} 31 | - name: Run tests 32 | run: | 33 | nox -s run_tests-${{ matrix.python-version }} 34 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Misc 2 | TODO.md 3 | .vscode/ 4 | 5 | # Byte-compiled / optimized / DLL files 6 | __pycache__/ 7 | *.py[cod] 8 | *$py.class 9 | 10 | # C extensions 11 | *.so 12 | 13 | # Distribution / packaging 14 | .Python 15 | build/ 16 | develop-eggs/ 17 | dist/ 18 | downloads/ 19 | eggs/ 20 | .eggs/ 21 | lib/ 22 | lib64/ 23 | parts/ 24 | sdist/ 25 | var/ 26 | wheels/ 27 | share/python-wheels/ 28 | *.egg-info/ 29 | .installed.cfg 30 | *.egg 31 | MANIFEST 32 | 33 | # PyInstaller 34 | # Usually these files are written by a python script from a template 35 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 36 | *.manifest 37 | *.spec 38 | 39 | # Installer logs 40 | pip-log.txt 41 | pip-delete-this-directory.txt 42 | 43 | # Unit test / coverage reports 44 | htmlcov/ 45 | .tox/ 46 | .nox/ 47 | .coverage 48 | .coverage.* 49 | .cache 50 | nosetests.xml 51 | coverage.xml 52 | *.cover 53 | *.py,cover 54 | .hypothesis/ 55 | .pytest_cache/ 56 | .ruff_cache 57 | cover/ 58 | 59 | # Translations 60 | *.mo 61 | *.pot 62 | 63 | # Django stuff: 64 | *.log 65 | local_settings.py 66 | db.sqlite3 67 | db.sqlite3-journal 68 | 69 | # Flask stuff: 70 | instance/ 71 | .webassets-cache 72 | 73 | # Scrapy stuff: 74 | .scrapy 75 | 76 | # Sphinx documentation 77 | docs/_build/ 78 | 79 | # PyBuilder 80 | .pybuilder/ 81 | target/ 82 | 83 | # Jupyter Notebook 84 | .ipynb_checkpoints 85 | 86 | # IPython 87 | profile_default/ 88 | ipython_config.py 89 | 90 | # pyenv 91 | # For a library or package, you might want to ignore these files since the code is 92 | # intended to run in multiple environments; otherwise, check them in: 93 | # .python-version 94 | 95 | # pipenv 96 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 97 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 98 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 99 | # install all needed dependencies. 100 | #Pipfile.lock 101 | 102 | # poetry 103 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 104 | # This is especially recommended for binary packages to ensure reproducibility, and is more 105 | # commonly ignored for libraries. 106 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 107 | #poetry.lock 108 | 109 | # pdm 110 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 111 | #pdm.lock 112 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 113 | # in version control. 114 | # https://pdm.fming.dev/#use-with-ide 115 | .pdm.toml 116 | 117 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 118 | __pypackages__/ 119 | 120 | # Celery stuff 121 | celerybeat-schedule 122 | celerybeat.pid 123 | 124 | # SageMath parsed files 125 | *.sage.py 126 | 127 | # Environments 128 | .env 129 | .venv 130 | env/ 131 | venv/ 132 | ENV/ 133 | env.bak/ 134 | venv.bak/ 135 | 136 | # Spyder project settings 137 | .spyderproject 138 | .spyproject 139 | 140 | # Rope project settings 141 | .ropeproject 142 | 143 | # mkdocs documentation 144 | /site 145 | 146 | # mypy 147 | .mypy_cache/ 148 | .dmypy.json 149 | dmypy.json 150 | 151 | # Pyre type checker 152 | .pyre/ 153 | 154 | # pytype static type analyzer 155 | .pytype/ 156 | 157 | # Cython debug symbols 158 | cython_debug/ 159 | 160 | # PyCharm 161 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 162 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 163 | # and can be added to the global gitignore or merged into this file. For a more nuclear 164 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 165 | #.idea/ 166 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2024 Alex Ioannides 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Regression using LLMs 2 | 3 | The llm-regression package demonstrates how LLMs can be used to solve classical regression problems, and exposes these capabilities for you to experiment with. Example: 4 | 5 | ```python 6 | from llm_regression import OpenAiRegressor 7 | 8 | llm_regressor = OpenAiRegressor(model="gpt-3.5-turbo") 9 | llm_regressor.fit(X_train, y_train) 10 | y_pred = llm_regressor.predict(X_test) 11 | ``` 12 | 13 | This work was motivated by the paper, 14 | 15 | ["_From Words to Numbers: You LLM is Secretly a Capable Regressor_", by Vacareanu et al. (2024)](https://arxiv.org/abs/2404.07544). 16 | 17 | Which is well worth a read! 18 | 19 | ## Installing 20 | 21 | You can install the llm_regression package, together with the dependencies required to run the example notebooks, directly from this repo, 22 | 23 | ```text 24 | pip install -U pip 25 | pip install "llm-regression[examples] @ git+https://github.com/AlexIoannides/llm-regression.git" 26 | ``` 27 | 28 | ## Examples 29 | 30 | Checkout the [basic_demo notebook](https://github.com/AlexIoannides/llm-regression/tree/main/examples/basic_demo.ipynb). 31 | 32 | ## Developer Setup 33 | 34 | If you want to modify or extend the work in this repo, then the information in this section is for you. 35 | 36 | ### Install Developer Tools 37 | 38 | Install the package as an [editable dependency](https://setuptools.pypa.io/en/latest/userguide/development_mode.html), together with all the developer tools required to format code, check types and run tests: 39 | 40 | ```text 41 | pip install -e ".[dev]" 42 | ``` 43 | 44 | ### Developer Task Execution with Nox 45 | 46 | We use [Nox](https://nox.thea.codes/en/stable/) for scripting developer tasks, such as formatting code, checking types and running tests. These tasks are defined in `noxfile.py`, a list of which can be returned on the command line, 47 | 48 | ```text 49 | $ nox --list 50 | 51 | Sessions defined in /Users/.../noxfile.py: 52 | 53 | * run_tests-3.12 -> Run unit tests. 54 | - format_code-3.12 -> Lint code and re-format where necessary. 55 | * check_code_formatting-3.12 -> Check code for formatting errors. 56 | * check_types-3.12 -> Run static type checking. 57 | - build_and_deploy-3.12 -> Build wheel and deploy to PyPI. 58 | 59 | sessions marked with * are selected, sessions marked with - are skipped. 60 | ``` 61 | 62 | Single tasks can be executed easily - e.g., 63 | 64 | ```text 65 | $ nox -s run_tests 66 | 67 | nox > Running session run_tests-3.12 68 | nox > Creating virtual environment (virtualenv) using python3.12 in .nox/run_tests-3-10 69 | nox > python -m pip install '.[dev]' 70 | nox > pytest 71 | ======================================== test session starts ======================================== 72 | platform darwin -- Python 3.12.2, pytest-7.4.2, pluggy-1.3.0 73 | rootdir: /Users/.../llm_regression 74 | configfile: pyproject.toml 75 | testpaths: tests 76 | collected 1 item 77 | 78 | tests/test_hello_world.py [100%] 79 | 80 | ========================================== 1 passed in 0.00s ========================================= 81 | nox > Session run_tests-3.12 was successful. 82 | ``` 83 | 84 | ### CI/CD 85 | 86 | This repo comes configured to run two [GitHub Actions](https://docs.github.com/en/actions) workflows: 87 | 88 | - **Test Python Package (CI)**, defined in `.github/workflows/python-package-ci.yml` 89 | - **Deploy Python Package (CD)**, defined in `.github/workflows/python-package-cd.yml` 90 | 91 | The CI workflow has been configured to run whenever a pull request to the `main` branch is created. The CD workflow has been configured to run whenever a [release](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository) is created on GitHub. 92 | -------------------------------------------------------------------------------- /examples/basic_demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Getting LLMs to Perform Regression\n", 8 | "\n", 9 | "This notebook explores the claim that LLMs can perform regression when training data is included as in-context examples - i.e., when labelled feature data is included in the prompt sent to the model. The paper that motivated this work is,\n", 10 | "\n", 11 | "[\"_From Words to Numbers: You LLM is Secretly a Capable Regressor_\", by Vacareanu et al. (2024)](https://arxiv.org/abs/2404.07544).\n", 12 | "\n", 13 | "We've focused exclusively on OpenAI LLMs (accessed via API), and wrapped all of the code into single class, `OpenAiRegressor`. This implements the Scikit-Learn [BaseEstimator](https://arxiv.org/abs/2404.07544) interface - i.e., the class has `fit` and `predict` methods with the same signature as those found in Scikit-Learn models. You can find the source code in `src/llm_regression/models.py` and/or install the package and import it directly, as we've done below.\n", 14 | "\n", 15 | "## Configuring OpenAI API Keys\n", 16 | "\n", 17 | "If you want to try this code for yourself, then you'll need an OpenAI API key. Can be set as an environment variable - e.g.,\n", 18 | "\n", 19 | "```python\n", 20 | "import os\n", 21 | "\n", 22 | "os.environ[\"OPENAI_API_KEY\"] = \"your-open-api-key\"\n", 23 | "```\n", 24 | "\n", 25 | "Alternatively, you can add the environment variable to a `.env` file in your working directory and `OpenAiRegressor` will pick it up for there (make sure to keep this file out of source control),\n", 26 | "\n", 27 | "```\n", 28 | "touch .env\n", 29 | "\"OPENAI_API_KEY=your-open-api-key\" >> .env\n", 30 | "```\n", 31 | "\n", 32 | "## How do we get LLMs to Perform Regression?\n", 33 | "\n", 34 | "By sending them prompts that includes labelled feature data and then asking the model to provide a missing input - e.g.,\n", 35 | "\n", 36 | "```text\n", 37 | "Your task is to provide your best estimate for ”Output”. Please provide that\n", 38 | "and only that, without any additional text.\n", 39 | "\n", 40 | "Feature 0: -0.8333688059494058\n", 41 | "Output: -0.6929185295193974\n", 42 | "\n", 43 | "Feature 0: -0.3356073681186462\n", 44 | "Output: -0.24922638778859663\n", 45 | "\n", 46 | "...\n", 47 | "\n", 48 | "Feature 0: 0.5336073681182466\n", 49 | "Output:\n", 50 | "```\n", 51 | "\n", 52 | "This prompt format is taken directly from Vacareanu et al's paper." 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "## Imports & Configuration\n", 60 | "\n", 61 | "If you've cloned this repo you install the required dependencies using,\n", 62 | "\n", 63 | "```text\n", 64 | "pip install \".[examples]\"\n", 65 | "```\n", 66 | "\n", 67 | "Alternatively, you can install everything you need directly from GitHub,\n", 68 | "\n", 69 | "```text\n", 70 | "pip install \"llm-regression[examples] @ git+https://github.com/AlexIoannides/llm-regression.git\"\n", 71 | "```" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 1, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "import pandas as pd\n", 81 | "import seaborn as sns\n", 82 | "from llm_regression import OpenAiRegressor, make_univariate_linear_test_data\n", 83 | "from sklearn.linear_model import LinearRegression\n", 84 | "from sklearn.metrics import mean_absolute_error, r2_score\n", 85 | "from sklearn.model_selection import train_test_split\n", 86 | "\n", 87 | "sns.set_theme()" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "## Make Regression Data\n", 95 | "\n", 96 | "To keep this example simple we're going to generate univariate regression data by sampling from the following model,\n", 97 | "\n", 98 | "$\n", 99 | "\\tilde{y} = \\rho \\cdot \\tilde{x} + \\sqrt{1 - \\rho^2} * \\tilde{\\epsilon}\n", 100 | "$\n", 101 | "\n", 102 | "Where both $\\tilde{y}$ and $\\tilde{\\epsilon}$ are drawn from the standardised Normal distribution. This model has the property that $\\rho$ determines the correlation between $\\tilde{y}$ and $\\tilde{\\epsilon}$, and that the variance of $\\tilde{y}$ will also be 1 (like that for $\\tilde{x}$).\n", 103 | "\n", 104 | "We will restrict ourselves to 500 samples so that we don't breach GPT-3.5-Turbo's context window of 16k tokens." 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 2, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "image/png": "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", 115 | "text/plain": [ 116 | "
" 117 | ] 118 | }, 119 | "metadata": {}, 120 | "output_type": "display_data" 121 | } 122 | ], 123 | "source": [ 124 | "n_samples = 500\n", 125 | "dataset = make_univariate_linear_test_data(n_samples, rho=0.9)\n", 126 | "train_data, test_data = train_test_split(dataset, test_size=0.05, random_state=42)\n", 127 | "\n", 128 | "_ = sns.lmplot(train_data, x=\"x\", y=\"y\")" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "## Establish Baseline Results with OLS Regression\n", 136 | "\n", 137 | "We need something 'sensible' to compare the LLM regressor to. We use Scikit-Learn's `LinearRegression` class - a reference implementation of Ordinary Least Squares (OLS) regression." 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 3, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "name": "stdout", 147 | "output_type": "stream", 148 | "text": [ 149 | "mean_abs_error = 0.338\n", 150 | "r_squared = 0.819\n" 151 | ] 152 | } 153 | ], 154 | "source": [ 155 | "ols_regressor = LinearRegression()\n", 156 | "ols_regressor.fit(train_data[[\"x\"]], train_data[[\"y\"]])\n", 157 | "y_pred_ols = ols_regressor.predict(test_data[[\"x\"]])\n", 158 | "\n", 159 | "ols_results = (\n", 160 | " test_data.copy()\n", 161 | " .reset_index(drop=True)\n", 162 | " .assign(y_pred=y_pred_ols)\n", 163 | ")\n", 164 | "\n", 165 | "mean_abs_err_ols = mean_absolute_error(ols_results[\"y\"], ols_results[\"y_pred\"])\n", 166 | "r_squared_ols = r2_score(ols_results[\"y\"], ols_results[\"y_pred\"])\n", 167 | "\n", 168 | "print(f\"mean_abs_error = {mean_abs_err_ols:.3f}\")\n", 169 | "print(f\"r_squared = {r_squared_ols:.3f}\")" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "## Results using GPT-3.5-Turbo\n", 177 | "\n", 178 | "A reassuringly expensive (and slow) regression..." 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 4, 184 | "metadata": {}, 185 | "outputs": [ 186 | { 187 | "name": "stderr", 188 | "output_type": "stream", 189 | "text": [ 190 | "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [02:24<00:00, 5.77s/it]" 191 | ] 192 | }, 193 | { 194 | "name": "stdout", 195 | "output_type": "stream", 196 | "text": [ 197 | "mean_abs_error = 0.34449656403978396\n", 198 | "r_squared = 0.7956923855240899\n" 199 | ] 200 | }, 201 | { 202 | "name": "stderr", 203 | "output_type": "stream", 204 | "text": [ 205 | "\n" 206 | ] 207 | } 208 | ], 209 | "source": [ 210 | "gpt35_regressor = OpenAiRegressor(model=\"gpt-3.5-turbo\")\n", 211 | "gpt35_regressor.fit(train_data[[\"x\"]], train_data[[\"y\"]]) # -> add in-context examples to prompt\n", 212 | "y_pred_gpt35 = gpt35_regressor.predict(test_data[[\"x\"]])\n", 213 | "\n", 214 | "gpt35_results = (\n", 215 | " test_data.copy()\n", 216 | " .assign(y_pred=y_pred_gpt35)\n", 217 | " .reset_index(drop=True)\n", 218 | ")\n", 219 | "\n", 220 | "mean_abs_err_gpt35 = mean_absolute_error(gpt35_results[\"y\"], gpt35_results[\"y_pred\"])\n", 221 | "r_squared_gpt35 = r2_score(gpt35_results[\"y\"], gpt35_results[\"y_pred\"])\n", 222 | "\n", 223 | "print(f\"mean_abs_error = {mean_abs_err_gpt35}\")\n", 224 | "print(f\"r_squared = {r_squared_gpt35}\")" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": {}, 230 | "source": [ 231 | "Comparable with OLS regression!" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "## Results using GPT-4o\n", 239 | "\n", 240 | "Like wheeling out a Ferrari to pop to the shops in heavy traffic..." 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 5, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "name": "stderr", 250 | "output_type": "stream", 251 | "text": [ 252 | "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [05:16<00:00, 12.68s/it]" 253 | ] 254 | }, 255 | { 256 | "name": "stdout", 257 | "output_type": "stream", 258 | "text": [ 259 | "mean_abs_error = 0.34576103704931194\n", 260 | "r_squared = 0.8005441443484316\n" 261 | ] 262 | }, 263 | { 264 | "name": "stderr", 265 | "output_type": "stream", 266 | "text": [ 267 | "\n" 268 | ] 269 | } 270 | ], 271 | "source": [ 272 | "gpt4o_regressor = OpenAiRegressor(model=\"gpt-4o\")\n", 273 | "gpt4o_regressor.fit(train_data[[\"x\"]], train_data[[\"y\"]]) # -> add in-context examples to prompt\n", 274 | "y_pred_gpt4o = gpt4o_regressor.predict(test_data[[\"x\"]])\n", 275 | "\n", 276 | "gpt4o_results = (\n", 277 | " test_data.copy()\n", 278 | " .assign(y_pred=y_pred_gpt4o)\n", 279 | " .reset_index(drop=True)\n", 280 | ")\n", 281 | "\n", 282 | "mean_abs_err_gpt4o = mean_absolute_error(gpt4o_results[\"y\"], gpt4o_results[\"y_pred\"])\n", 283 | "r_squared_gpt4o = r2_score(gpt4o_results[\"y\"], gpt4o_results[\"y_pred\"])\n", 284 | "\n", 285 | "print(f\"mean_abs_error = {mean_abs_err_gpt4o}\")\n", 286 | "print(f\"r_squared = {r_squared_gpt4o}\")" 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "Even better, although I'm not sure it was worth the extra £ or time (or environmental impact...). If we were exploiting the larger context windown that comes with GPT-4o, then maybe we could justify using it." 294 | ] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": {}, 299 | "source": [ 300 | "## Comparing Results\n", 301 | "\n", 302 | "Let's take a look at 'predicted vs. actual' for OLS regression and GPT-4o (to make sure there's nothing odd going on)." 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 6, 308 | "metadata": {}, 309 | "outputs": [ 310 | { 311 | "data": { 312 | "image/png": "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", 313 | "text/plain": [ 314 | "
" 315 | ] 316 | }, 317 | "metadata": {}, 318 | "output_type": "display_data" 319 | } 320 | ], 321 | "source": [ 322 | "combined_results = pd.concat(\n", 323 | " [ols_results.assign(model=\"OLS\"), gpt4o_results.assign(model=\"GPT-4o\")]\n", 324 | ")\n", 325 | "\n", 326 | "_ = sns.lmplot(combined_results, x=\"y\", y=\"y_pred\", hue=\"model\")" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "The two models produce comparable results, with GPT-4o 'a bit off' on a couple of predictions, which is probably what is driving the difference in performance metrics." 334 | ] 335 | } 336 | ], 337 | "metadata": { 338 | "kernelspec": { 339 | "display_name": "Python 3 (ipykernel)", 340 | "language": "python", 341 | "name": "python3" 342 | }, 343 | "language_info": { 344 | "codemirror_mode": { 345 | "name": "ipython", 346 | "version": 3 347 | }, 348 | "file_extension": ".py", 349 | "mimetype": "text/x-python", 350 | "name": "python", 351 | "nbconvert_exporter": "python", 352 | "pygments_lexer": "ipython3", 353 | "version": "3.12.2" 354 | } 355 | }, 356 | "nbformat": 4, 357 | "nbformat_minor": 4 358 | } 359 | -------------------------------------------------------------------------------- /noxfile.py: -------------------------------------------------------------------------------- 1 | """Developer task automation.""" 2 | import os 3 | 4 | import nox 5 | 6 | nox.options.sessions = [ 7 | "check_code_formatting", 8 | "check_types", 9 | "run_tests", 10 | ] 11 | 12 | PYTHON = ["3.12"] 13 | 14 | 15 | @nox.session(python=PYTHON, reuse_venv=True) 16 | def run_tests(session: nox.Session): 17 | """Run unit tests.""" 18 | session.install(".[dev]") 19 | pytest_args = session.posargs if session.posargs else [] 20 | session.run("pytest", *pytest_args) 21 | 22 | 23 | @nox.session(python=PYTHON, reuse_venv=True) 24 | def format_code(session: nox.Session): 25 | """Lint code and re-format where necessary.""" 26 | session.install(".[dev]") 27 | session.run("black", "--config=pyproject.toml", ".") 28 | session.run("ruff", "check", ".", "--config=pyproject.toml", "--fix") 29 | 30 | 31 | @nox.session(python=PYTHON, reuse_venv=True) 32 | def check_code_formatting(session: nox.Session): 33 | """Check code for formatting errors.""" 34 | session.install(".[dev]") 35 | session.run("black", "--config=pyproject.toml", "--check", ".") 36 | session.run("ruff", "check", ".", "--config=pyproject.toml") 37 | 38 | 39 | @nox.session(python=PYTHON, reuse_venv=True) 40 | def check_types(session: nox.Session): 41 | """Run static type checking.""" 42 | session.install(".[dev]") 43 | session.run("mypy") 44 | 45 | 46 | @nox.session(python=PYTHON, reuse_venv=True) 47 | def build_and_deploy(session: nox.Session): 48 | """Build wheel and deploy to PyPI.""" 49 | try: 50 | from dotenv import load_dotenv 51 | 52 | load_dotenv() 53 | except ModuleNotFoundError: 54 | session.warn("Expecting PYPI_USR and PYPI_PWD in local environment variables.") 55 | 56 | try: 57 | PYPI_USR = os.environ["PYPI_USR"] 58 | PYPI_PWD = os.environ["PYPI_PWD"] 59 | except KeyError as e: 60 | session.error(f"{str(e)} not found in local environment variables.") 61 | session.install(".[deploy]") 62 | session.run("rm", "-rf", "dist") 63 | session.run("python", "-m", "build") 64 | session.run("twine", "upload", "dist/*", "-u", PYPI_USR, "-p", PYPI_PWD) 65 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [project] 2 | name = "llm-regression" 3 | version = "0.1.0.dev0" 4 | description = "The llm-regression Python package." 5 | readme = "README.md" 6 | authors = [ 7 | { name="Alex Ioannides", email="alex@bodywork.com" }, 8 | ] 9 | dependencies = [ 10 | "openai==1.30.*", 11 | "numpy==1.26.*", 12 | "pandas==2.2.*", 13 | "python-dotenv==1.0.*", 14 | "scikit-learn==1.4.*", 15 | "tqdm==4.66.*", 16 | ] 17 | 18 | [project.optional-dependencies] 19 | examples = [ 20 | "pandas==2.2.2", 21 | "scikit-learn==1.4.2", 22 | "seaborn==0.13.2", 23 | ] 24 | dev = [ 25 | "black==23.9.1", 26 | "python-dotenv>=1.0.0", 27 | "icecream", 28 | "ipython", 29 | "mypy==1.5.1", 30 | "nox==2023.4.22", 31 | "pandas-stubs==2.2.2.240514", 32 | "pytest==7.4.2", 33 | "ruff==0.0.290", 34 | "types-pytz==2024.1.0.20240417", 35 | "types-tqdm==4.66.0.20240417", 36 | ] 37 | deploy = [ 38 | "build>=1.0.0", 39 | "pip>=23.2.0", 40 | "setuptools>=68.0.0", 41 | "twine>=4.0.0", 42 | "wheel>=0.41.0", 43 | ] 44 | 45 | [project.urls] 46 | "Homepage" = "https://github.com/AlexIoannides/llm-regression" 47 | "Bug Tracker" = "https://github.com/AlexIoannides/llm-regression/issues" 48 | 49 | [build-system] 50 | requires = ["setuptools>=68.0"] 51 | build-backend = "setuptools.build_meta" 52 | 53 | [tool.setuptools] 54 | include-package-data = true 55 | 56 | [tool.setuptools.packages.find] 57 | where = ["src"] 58 | 59 | [tool.black] 60 | line-length = 88 61 | 62 | [tool.ruff] 63 | src = ["src"] 64 | target-version = "py310" 65 | line-length = 88 66 | select = [ 67 | "D", # pydocstyle 68 | "E", # pycodestyle errors 69 | "F", # pyflakes 70 | "I", # isort 71 | "UP", # pyupgrade 72 | "W", # pycodestyle warnings 73 | ] 74 | ignore = [ 75 | "D203", # fix pydocstyle warning 76 | "D213", # fix pydocstyle warning 77 | ] 78 | 79 | [tool.ruff.per-file-ignores] 80 | "tests/*" = [ 81 | "D103", 82 | ] 83 | 84 | [tool.pytest.ini_options] 85 | testpaths = ["tests"] 86 | 87 | [tool.mypy] 88 | python_version = "3.12" 89 | files = [ 90 | "src", 91 | "tests", 92 | "noxfile.py", 93 | ] 94 | 95 | [[tool.mypy.overrides]] 96 | module = [ 97 | "sklearn.*", 98 | ] 99 | ignore_missing_imports = true 100 | -------------------------------------------------------------------------------- /src/llm_regression/__init__.py: -------------------------------------------------------------------------------- 1 | """The llm_regression package.""" 2 | from .models import OpenAiRegressor 3 | from .utils import make_univariate_linear_test_data 4 | 5 | __all__ = [ 6 | "OpenAiRegressor", 7 | "make_univariate_linear_test_data", 8 | ] 9 | -------------------------------------------------------------------------------- /src/llm_regression/models.py: -------------------------------------------------------------------------------- 1 | """Regression modelling using LLMs.""" 2 | from __future__ import annotations 3 | 4 | import re 5 | from logging import getLogger 6 | from typing import Literal 7 | 8 | import numpy as np 9 | from dotenv import load_dotenv 10 | from numpy import ndarray 11 | from openai import OpenAI 12 | from pandas import DataFrame 13 | from tqdm import tqdm 14 | 15 | OpenAiModel = Literal["gpt-3.5-turbo", "gpt-4o", "gpt-4-turbo", "gpt-4"] 16 | 17 | log = getLogger("OpenAIRegressionLogger") 18 | 19 | 20 | class OpenAiRegressor: 21 | """Generic regression using Open AI LLMs.""" 22 | 23 | def __init__(self, model: OpenAiModel = "gpt-3.5-turbo", seed: int = 42): 24 | """Initialise object. 25 | 26 | Args: 27 | ---- 28 | model: Open AI model to use. Defaults to "gpt-3.5-turbo". 29 | seed: Random seed to use with OpenAI model. Defaults to 42 30 | """ 31 | load_dotenv() # load OPEN_API_KEY from .env file (if present) 32 | self._client = OpenAI() 33 | self._model = model 34 | self._model_seed = seed 35 | self._prompt_instruction = ( 36 | "Your task is to provide your best estimate for ”Output”. Please provide " 37 | "that and only that, without any additional text." 38 | ) 39 | self._prompt_train_data: str = "" 40 | 41 | def __repr__(self) -> str: 42 | """Create string representation.""" 43 | return f"OpenAiRegressor(model={self._model})" 44 | 45 | def fit(self, X: DataFrame | ndarray, y: DataFrame | ndarray) -> OpenAiRegressor: 46 | """Create a prompt based on training data to use when predicting with an LLM. 47 | 48 | Args: 49 | ---- 50 | X: Feature data. 51 | y: Labels. 52 | 53 | Raises: 54 | ------ 55 | ValueError: If the dimensions of X or y are invalid and/or inconsistent with 56 | one another. 57 | 58 | Returns: 59 | ------- 60 | The OpenAiRegressor object. 61 | """ 62 | if X.ndim < 2: 63 | raise ValueError("X.ndim must be >= 2") 64 | if y.ndim < 2: 65 | raise ValueError("y.ndim must be == 2") 66 | if len(X) != len(y): 67 | raise ValueError("len(y) != len(X)") 68 | 69 | _X = X.tolist() if isinstance(X, ndarray) else X.values.tolist() 70 | _y = y.tolist() if isinstance(y, ndarray) else y.values.tolist() 71 | 72 | self._prompt_train_data = "\n\n".join( 73 | [self._format_data_row(row, _y[n_row]) for n_row, row in enumerate(_X)] 74 | ) 75 | 76 | return self 77 | 78 | def predict(self, X: DataFrame | ndarray, logging: bool = True) -> ndarray: 79 | """Predict labels using model and feature data. 80 | 81 | Any prediction failures will return `numpy.nan` - prediction won't be halted, 82 | given the expense of querying LLMs. 83 | 84 | Args: 85 | ---- 86 | X: Feature data to use for predictions. 87 | logging: Enable logging. Default to True. 88 | 89 | Raises: 90 | ------ 91 | RuntimeError: If `.fit` has not been called. 92 | 93 | Returns: 94 | ------- 95 | Model predictions 96 | """ 97 | if not self._prompt_train_data: 98 | raise RuntimeError("please fit model before trying to generate predictions") 99 | 100 | _X = X if isinstance(X, ndarray) else X.values 101 | y_pred: list[float] = [] 102 | 103 | for n, row in tqdm(enumerate(_X), total=len(_X)): 104 | try: 105 | prediction_prompt = self._compose_prediction_prompt( 106 | self._prompt_instruction, 107 | self._prompt_train_data, 108 | self._format_data_row(row), 109 | ) 110 | llm_response = self._client.chat.completions.create( 111 | model=self._model, 112 | messages=[{"role": "user", "content": prediction_prompt}], 113 | temperature=0, 114 | response_format={"type": "text"}, 115 | seed=self._model_seed, 116 | ) 117 | llm_generation = llm_response.choices[0].message.content 118 | if llm_generation: 119 | y_pred += [self._parse_model_output(llm_generation)] 120 | else: 121 | y_pred += [np.nan] 122 | except Exception as e: 123 | if logging: 124 | log.warning(f"LLM error for test data row #{n} - {str(e)}") 125 | y_pred += [np.nan] 126 | 127 | return np.array(y_pred).reshape(-1, 1) 128 | 129 | @staticmethod 130 | def _compose_prediction_prompt( 131 | instruction: str, train_data: str, test_data: str 132 | ) -> str: 133 | """Compose full prompt from constituent parts.""" 134 | return instruction + "\n" + train_data + "\n\n" + test_data 135 | 136 | @staticmethod 137 | def _format_data_row(x_row: ndarray, y_row: ndarray | None = None) -> str: 138 | """Format a data row for inclusion in model prompt.""" 139 | output = y_row[0] if y_row else "" 140 | prompt_data = "\n".join( 141 | [f"Feature {n}: {x}" for n, x in enumerate(x_row)] + [f"Output: {output}"] 142 | ) 143 | return prompt_data 144 | 145 | @staticmethod 146 | def _parse_model_output(output: str) -> float: 147 | """Parse the models's output.""" 148 | result = re.findall(r"-?\d+\.?\d*", output)[0] 149 | return float(result) 150 | -------------------------------------------------------------------------------- /src/llm_regression/py.typed: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlexIoannides/llm-regression/631c8ff3ba4e0675a8c40a770223b0cd9b04aa1b/src/llm_regression/py.typed -------------------------------------------------------------------------------- /src/llm_regression/utils.py: -------------------------------------------------------------------------------- 1 | """Helpful functions.""" 2 | from numpy import sqrt 3 | from numpy.random import default_rng 4 | from pandas import DataFrame 5 | 6 | 7 | def make_univariate_linear_test_data( 8 | n_samples: int = 1000, *, rho: float = 0.75, seed: int = 42 9 | ) -> DataFrame: 10 | """Simulate a y = rho * x + sqrt(1 - rho ** 2) * epsilon. 11 | 12 | This paradign ensures that the standard deviation of x and y is always 1, and that 13 | x has correlation with y given by rho. 14 | 15 | Args: 16 | ---- 17 | n_samples: Number of samples to generate. Defaults to 1000. 18 | rho: Rho coeffcient (correlation coefficient). Defaults to 0.75. 19 | seed: Random seed. Defaults to 42. 20 | 21 | Returns: 22 | ------- 23 | Dataframe of test data. 24 | """ 25 | if not (rho >= 0 and rho <= 1): 26 | raise ValueError(f"rho = {rho} - must in [0, 1]") 27 | rng = default_rng(seed) 28 | x = rng.standard_normal(n_samples) 29 | epsilon = rng.standard_normal(n_samples) 30 | y = rho * x + sqrt(1 - rho * rho) * epsilon 31 | return DataFrame({"x": x, "y": y}) 32 | -------------------------------------------------------------------------------- /tests/test_models.py: -------------------------------------------------------------------------------- 1 | """Tests for LLM regression modelling.""" 2 | from re import escape 3 | from unittest.mock import DEFAULT, Mock, patch 4 | 5 | from numpy import array, nan 6 | from numpy.testing import assert_array_equal 7 | from pandas import DataFrame 8 | from pytest import LogCaptureFixture, raises 9 | 10 | from llm_regression import OpenAiRegressor 11 | 12 | 13 | def test_OpeanAiRegressor__repr__(): 14 | with patch.multiple("llm_regression.models", load_dotenv=Mock, OpenAI=Mock): 15 | model = OpenAiRegressor() 16 | assert repr(model) == "OpenAiRegressor(model=gpt-3.5-turbo)" 17 | 18 | 19 | def test_OpeanAiRegressor_fit_makes_prompt_train_data_pandas_dataframe(): 20 | with patch.multiple("llm_regression.models", load_dotenv=Mock, OpenAI=Mock): 21 | train_data = DataFrame({"x0": [1.0, -0.1], "x1": [0.1, -1.0], "y": [1.0, 2.0]}) 22 | X = train_data[["x0", "x1"]] 23 | y = train_data[["y"]] 24 | 25 | model = OpenAiRegressor() 26 | 27 | expected_prompt = ( 28 | "Feature 0: 1.0\nFeature 1: 0.1\nOutput: 1.0\n\n" 29 | "Feature 0: -0.1\nFeature 1: -1.0\nOutput: 2.0" 30 | ) 31 | 32 | assert model.fit(X, y)._prompt_train_data == expected_prompt 33 | 34 | 35 | def test_OpeanAiRegressor_fit_makes_prompt_train_data_numpy_array(): 36 | with patch.multiple("llm_regression.models", load_dotenv=Mock, OpenAI=Mock): 37 | X = array([[1.0, 0.1], [-0.1, -1.0]]) 38 | y = array([[1.0], [2.0]]) 39 | model = OpenAiRegressor() 40 | 41 | expected_prompt = ( 42 | "Feature 0: 1.0\nFeature 1: 0.1\nOutput: 1.0\n\n" 43 | "Feature 0: -0.1\nFeature 1: -1.0\nOutput: 2.0" 44 | ) 45 | 46 | assert model.fit(X, y)._prompt_train_data == expected_prompt 47 | 48 | 49 | def test_OpeanAiRegressor_fit_raises_errors_on_inconsistent_inputs(): 50 | with patch.multiple("llm_regression.models", load_dotenv=Mock, OpenAI=Mock): 51 | model = OpenAiRegressor() 52 | 53 | with raises(ValueError, match=escape("X.ndim must be >= 2")): 54 | model.fit(array([1.0, 0.1, -0.1, -1.0]), array([[1.0], [2.0]])) 55 | 56 | with raises(ValueError, match=escape("y.ndim must be == 2")): 57 | model.fit(array([[1.0, 0.1], [-0.1, -1.0]]), array([1.0, 2.0])) 58 | 59 | with raises(ValueError, match=escape("len(y) != len(X)")): 60 | model.fit(array([[1.0, 0.1], [-0.1, -1.0]]), array([[1.0]])) 61 | 62 | 63 | def test_OpenAiRegressor_predict_returns_predictions(): 64 | def make_mock_api_response(content: str | None) -> Mock: 65 | mock_response = Mock() 66 | mock_response.choices = [Mock()] 67 | mock_response.choices[0].message.content = content 68 | return mock_response 69 | 70 | with patch.multiple( 71 | "llm_regression.models", load_dotenv=DEFAULT, OpenAI=DEFAULT 72 | ) as mock_objs: 73 | mock_client = mock_objs["OpenAI"].return_value 74 | mock_client.chat.completions.create.side_effect = [ 75 | make_mock_api_response("Output: 1.0"), 76 | make_mock_api_response("Output: -1.0"), 77 | make_mock_api_response(None), 78 | ] 79 | model = OpenAiRegressor() 80 | model._prompt_train_data = "Predict some stuff." 81 | y_pred = model.predict(array([[1.0], [0.1], [0.0]])) 82 | assert_array_equal(y_pred, array([[1.0], [-1.0], [nan]])) 83 | 84 | 85 | def test_OpenAiRegressor_predict_handles_response_errors(): 86 | with patch.multiple( 87 | "llm_regression.models", load_dotenv=DEFAULT, OpenAI=DEFAULT 88 | ) as mock_objs: 89 | mock_client = mock_objs["OpenAI"].return_value 90 | mock_client.chat.completions.create.side_effect = [Exception, Exception] 91 | model = OpenAiRegressor() 92 | model._prompt_train_data = "Predict some stuff." 93 | y_pred = model.predict(array([[1.0], [0.1]])) 94 | assert_array_equal(y_pred, array([[nan], [nan]])) 95 | 96 | 97 | def test_OpenAiRegressor_predict_logs_errors(caplog: LogCaptureFixture): 98 | with patch.multiple( 99 | "llm_regression.models", load_dotenv=DEFAULT, OpenAI=DEFAULT 100 | ) as mock_objs: 101 | mock_client = mock_objs["OpenAI"].return_value 102 | mock_client.chat.completions.create.side_effect = Exception("foo") 103 | model = OpenAiRegressor() 104 | model._prompt_train_data = "Predict some stuff." 105 | model.predict(array([[1.0]])) 106 | 107 | log_record_one = caplog.records[0] 108 | assert len(caplog.records) == 1 109 | assert log_record_one.levelname == "WARNING" 110 | assert log_record_one.message == "LLM error for test data row #0 - foo" 111 | 112 | # make sure we can switch logging off 113 | model.predict(array([[1.0]]), logging=False) 114 | assert len(caplog.records) == 1 115 | 116 | 117 | def test_OpeanAiRegressor_compose_prediction_prompt(): 118 | assert OpenAiRegressor._compose_prediction_prompt("a", "b", "c") == "a\nb\n\nc" 119 | 120 | 121 | def test_OpeanAiRegressor_format_data_row(): 122 | assert OpenAiRegressor._format_data_row([1.0]) == "Feature 0: 1.0\nOutput: " 123 | assert ( 124 | OpenAiRegressor._format_data_row([1.0, -0.1]) 125 | == "Feature 0: 1.0\nFeature 1: -0.1\nOutput: " 126 | ) # noqa 127 | assert ( 128 | OpenAiRegressor._format_data_row([1.0], [0.1]) == "Feature 0: 1.0\nOutput: 0.1" 129 | ) # noqa 130 | 131 | 132 | def test_OpenAiRegressor_parse_model_output(): 133 | assert OpenAiRegressor._parse_model_output("\nOutput: 0.101") == 0.101 134 | assert OpenAiRegressor._parse_model_output("Output: -1.101") == -1.101 135 | assert OpenAiRegressor._parse_model_output("Output: 1") == 1.0 136 | -------------------------------------------------------------------------------- /tests/test_utils.py: -------------------------------------------------------------------------------- 1 | """Tests for utlity code.""" 2 | from numpy import corrcoef 3 | from pytest import approx 4 | 5 | from llm_regression import make_univariate_linear_test_data 6 | 7 | 8 | def test_make_univariate_linear_test_data(): 9 | corr_coeff = 0.8 10 | dataset = make_univariate_linear_test_data(100000, rho=corr_coeff) 11 | assert "x" in dataset.columns 12 | assert "y" in dataset.columns 13 | assert dataset["x"].mean() == approx(0.0, abs=0.01) 14 | assert dataset["x"].std() == approx(1.0, abs=0.01) 15 | assert dataset["y"].mean() == approx(0.0, abs=0.01) 16 | assert dataset["y"].std() == approx(1.0, abs=0.01) 17 | assert corrcoef(dataset["x"], dataset["y"])[0][1] == approx(corr_coeff, abs=0.01) 18 | --------------------------------------------------------------------------------