Skip to content

Commit 0825a62

Browse files
jezsadlerjezsadler
committed
Squashed commit of the following:
commit 321a2e2 Author: Jiří Němeček <[email protected]> Date: Sat Aug 24 19:15:47 2024 +0200 Fixing 404 errors of links to notebooks in the documentation (cog-imperial#143) I assume that the notebooks have been moved, but the documentation links did not reflect that **Legal Acknowledgement**\ By contributing to this software project, I agree my contributions are submitted under the BSD license. I represent I am authorized to make the contributions and grant the license. If my employer has rights to intellectual property that includes these contributions, I represent that I have received permission to make contributions and grant the required license on behalf of that employer. commit caebfc4 Author: Andrew Lee <[email protected]> Date: Thu Aug 22 13:28:24 2024 -0400 Replace _BlockData with BlockData (cog-imperial#144) Pyomo recently made ComponentData classes public (Pyomo/pyomo#3221) which will be part of the upcoming release. Currently, this causes the following error to occur in OMLT: ``` TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases ``` The Pyomo team is working to try to address this issue, however OMLT should update its code to address this as otherwise deprecation warnings will be emitted when using the old class names. The fix is to replace all instances of `_BlockData` with `BlockData` (just removing the underscore) - this applies to any other instance of Pyomo component data objects as well (although I could only find 2 instances of these in the OMLT code). **Legal Acknowledgement**\ By contributing to this software project, I agree my contributions are submitted under the BSD license. I represent I am authorized to make the contributions and grant the license. If my employer has rights to intellectual property that includes these contributions, I represent that I have received permission to make contributions and grant the required license on behalf of that employer. Co-authored-by: jalving <[email protected]> commit c6d274f Author: Emma Johnson <[email protected]> Date: Thu Aug 22 10:56:10 2024 -0400 Add tolerance to enforce strict inequalities in linear tree formulations (cog-imperial#163) This PR adds a tolerance at which to enforce ``strict'' inequalities in linear model trees: That is, the right branch will require that the feature value be greater than or equal to the bound plus this tolerance (epsilon). This means that users can tune epsilon in order to ensure that the MIP solution will match the tree prediction. Additionally, the PR simplifies the implementation of the hybrid bigm linear tree formulation by using two modern pyomo.gdp transformations. This does mean that the linear tree formulations will rely on pyomo>=6.7.1 though, if that's okay. **Legal Acknowledgement**\ By contributing to this software project, I agree my contributions are submitted under the BSD license. I represent I am authorized to make the contributions and grant the license. If my employer has rights to intellectual property that includes these contributions, I represent that I have received permission to make contributions and grant the required license on behalf of that employer. --------- Co-authored-by: Emma Johnson <[email protected]> commit d43643a Author: Lukas Turcani <[email protected]> Date: Tue Aug 20 23:53:51 2024 +0100 Clean up package boilerplate (cog-imperial#149) This PR does a couple of things to clean up the boilerplate related to packaging OMLT, see sections below for detailed explanations of the changes. * Remove `setup.cfg` , `setup.py`, `docs/requirements.txt`, `tox.ini` in favour of `pyproject.toml`. * Place `conda` requirements into `environment.yml` * Create new workflows `tests.yml` and `publish_release.yml` * Add quality checks using `ruff`, `mypy`, `doctest` * Use `just` for developer experience * Updated the `Development` section of `README` to talk about `just` * Clean up `conf.py` * Move `pull_request_template.md` * Allow publishing of package to pypi by pushing a new version tag # Other comments * consider internal package structure * force squash merge of PRs - this keeps git history for the `main` branch nice and clean # Using `pyproject.toml` `pyrpoject.toml` is the simplest way to provide package metadata for a Python package. It is easy to read and also provides sections for configurating tools such as `pytest`, `ruff` and `mypy` all in one place. It works seamlessly with the modern Python ecosystem. I set up `pyproject.toml` to automactically detect the version of the code from git tags. No need to duplicate version numbers across the repo. Just add a new tag and everything will be updated. In addition, when a new git tag is pushed to the GitHub repo, the new `publish_release` workflow will be triggered and a new PYPI version released. (See more on this below). I also set it up so that the version is automatically added to a file called `src/omlt/_version.py` which holds the `__version__` variable. this file is autogenerated and therefore added to `.gitignore`. The `__version__` veriable is then re-exported in `src/omlt/__init__.py` so that our users have access to it. I tried to perserve all the information stored in the `setup.cfg` and other deleted files -- let me know if there is something i missed! ## Optional dependencies The `pyproject.toml` file allows the creation of optional dependencies. For example, our users can install ```bash pip install omlt[keras] # or pip install omlt[torch] # or pip install omlt[linear-tree,keras-gpu] ``` Ofc any combination of optional dependencies is valid too. This allows our users to install the dependencies specific to their use case. Note that: * I made `onnx` and `onnxruntime` a required dependency because from my understanding it is almost always used * I added an optinoal dependency set called `dev` which developers can use to install all developer tools and all dependencies -- you need this to run all the tests for example * There is also `dev-gpu` which installs the GPU version of tensorflow in case the developer has a GPU The available optional dependencies are: * `linear-tree`, installs the linear tree dependency * `keras`, installs tensorflow and keras * `keras-gpu`, installs tensorflow for the gpu and keras * `torch`, installs torch and torch geometric * `dev-tools` - this is not to be used directly but allows easy re-use of dev tools in other optional dependencies, namely dev and dev-gpu * `docs` - installs dependencies required to compile docs * `dev` - dependecies needed for developing the project, such tooling * `dev-gpu` - same as dev but installed with gpu support Our documentation probably needs to be updated to tell users they wanna install omlt with some combination of `linear-tree`, `keras`, `keras-gpu`, `torch` optional dependencies depending on what features of the package they are using # Quality checks with `ruff`, `mypy` and `doctest` I've enabled `ruff`, `mypy` and `doctest`. Currently there are no doctests, but its good to have it set up so that it runs in case any are added in the future. Both `ruff` and `mypy` are failing because there are a number of things which need to fixed. For both `ruff` and `mypy` I have disabled some checks which it would be good to enable eventually but are probably a fair amount of work to fix -- these have comments in `pyproject.toml`. The remaining failing checks are ones which I would reccomend fixing ASAP. There's two approaches, merge now and fix these errors later. Or keep a separate branch where these are incrementally fixed. Up to you to decide what you prefer. I told ruff to check for `google` style docstrings. I think these are the best because they have good readbility and work the best with type hints in my opinion. # Using `just` instead of `tox` https://github.com/casey/just is a simple command runner. It allows the developers to define and re-use common operations, for example I can define a `check` recipe and then run ```bash just check ``` in my command line and it will run all the tests. The beauty of this is that `just` is extremely simple. If you read the file its basically a sequence of bash instructions for each recipe. This makes the `recipes` really transparent, and easy to understand, and works as code-as-documentation. Users can just read the recipe and run the commands one by one to get the same effect without having `just` installed. There is no magic which helps with debugging issues. It's also language agnostic. `just` comes as a small stand-alone binary, which makes it a very non-intrusive tool to have on your computer that does not need any dependencies. The downside is that it does not provide automatic management for Python environments, which I belive tox does provide. The other side of this is that we allow developers to use their favorite tools for managing venvs rather than proscribing certain tools for this repo. (the difference with `just` being that it is essentially optional tool and also serving as documentation) I may be overly opinionated on this one, so feel free to push back. # Cleaning up `docs/conf.py` I removed a bunch of the commented out code. This makes it easier to see what the configuration is and also prevents the commented out options from becoming out of date when a new release of sphinx is made. # Moving `pull_request_template.md` I moved this into the `.github` folder because it is GitHub configuration. Very optional, but makes more sense to me. # `readthedocs` automated action this guide https://docs.readthedocs.io/en/stable/guides/pull-requests.html shows how to set it up. requires admin permissions on readthedocs -- can jump on a call to help with this # publishing with to `PYPI` with a git tag for this an API key for PYPI needs to be created and added to the repos secrets -- can jump on a call to help with this # consider `_internal` package structure One way to make it easier to manage private vs public code in a repository is to create an `_internal` folder where all the code goes. This way all code can be shared easily and moved between modules and its by default private, so changes to internal code does not break users. Public modules then just re-export code in the `_internal` submodules. You can see an example of this structure here https://github.com/lukasturcani/stk. Not a huge issue but I find it very helpful for managing what things are actually exposed to users the code-base grows. **Legal Acknowledgement**\ By contributing to this software project, I agree my contributions are submitted under the BSD license. I represent I am authorized to make the contributions and grant the license. If my employer has rights to intellectual property that includes these contributions, I represent that I have received permission to make contributions and grant the required license on behalf of that employer. --------- Co-authored-by: Jeremy Sadler <[email protected]>
1 parent 95670fb commit 0825a62

40 files changed

+1155
-957
lines changed

‎.coveragerc

-28
This file was deleted.

‎docs/api_doc/omlt.block.rst

+1-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ OMLT Block
88
:show-inheritance:
99

1010
.. note::
11-
`OmltBlock` is the name used to declare the custom Pyomo block which is exposed to the user. The block functionality is given by `OmltBlockData` which inherits from Pyomo `_BlockData`.
11+
`OmltBlock` is the name used to declare the custom Pyomo block which is exposed to the user. The block functionality is given by `OmltBlockData` which inherits from Pyomo `BlockData`.
1212

1313
.. autoclass:: omlt.block.OmltBlockData
1414
:members:

‎docs/notebooks.rst

+2-2
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ The first set of notebooks demonstrates the basic mechanics of OMLT and shows ho
1414

1515
* `index_handling.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/neuralnet/index_handling.ipynb>`_ shows how to use `IndexMapper` to handle the mappings between indexes.
1616

17-
* `bo_with_trees.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/bo_with_trees.ipynb>`_ incorporates gradient-boosted trees into a Bayesian optimization loop to optimize the Rosenbrock function.
17+
* `bo_with_trees.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/trees/bo_with_trees.ipynb>`_ incorporates gradient-boosted trees into a Bayesian optimization loop to optimize the Rosenbrock function.
1818

1919
* `linear_tree_formulations.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/trees/linear_tree_formulations.ipynb>`_ showcases the different linear model decision tree formulations available in OMLT.
2020

@@ -24,7 +24,7 @@ The second set of notebooks gives application-specific examples:
2424

2525
* `mnist_example_convolutional.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/neuralnet/mnist_example_convolutional.ipynb>`_ trains a convolutional neural network on MNIST and uses OMLT to find adversarial examples.
2626

27-
* `graph_neural_network_formulation.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/graph_neural_network_formulation.ipynb>`_ transforms graph neural networks into OMLT and builds formulation to solve optimization problems.
27+
* `graph_neural_network_formulation.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/neuralnet/graph_neural_network_formulation.ipynb>`_ transforms graph neural networks into OMLT and builds formulation to solve optimization problems.
2828

2929
* `auto-thermal-reformer.ipynb <https://github.com/cog-imperial/OMLT/blob/main/docs/notebooks/neuralnet/auto-thermal-reformer.ipynb>`_ develops a neural network surrogate (using sigmoid activations) with data from a process model built using `IDAES-PSE <https://github.com/IDAES/idaes-pse>`_.
3030

‎docs/notebooks/data/build_sin_quadratic_csv.py

+1-3
Original file line numberDiff line numberDiff line change
@@ -9,9 +9,7 @@
99
rng = np.random.default_rng()
1010
sin_quads = pd.DataFrame(x, columns=["x"])
1111
sin_quads["y"] = (
12-
np.sin(w * x)
13-
+ x**2
14-
+ np.array([rng.uniform() * 0.1 for _ in range(n_samples)])
12+
np.sin(w * x) + x**2 + np.array([rng.uniform() * 0.1 for _ in range(n_samples)])
1513
)
1614

1715
plt.plot(sin_quads["x"], sin_quads["y"])

‎docs/notebooks/neuralnet/auto-thermal-reformer-relu.ipynb

+68-40
Original file line numberDiff line numberDiff line change
@@ -78,19 +78,20 @@
7878
],
7979
"source": [
8080
"import os\n",
81-
"os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # suppress CUDA warnings from tensorflow\n",
81+
"\n",
82+
"os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\" # suppress CUDA warnings from tensorflow\n",
8283
"\n",
8384
"# import the necessary packages\n",
84-
"from omlt import OmltBlock, OffsetScaling\n",
85-
"from omlt.io.keras import load_keras_sequential\n",
86-
"from omlt.neuralnet import ReluBigMFormulation\n",
87-
"import pyomo.environ as pyo\n",
8885
"import pandas as pd\n",
89-
"import tensorflow.keras as keras\n",
90-
"from tensorflow.keras.models import Sequential\n",
86+
"import pyomo.environ as pyo\n",
87+
"from tensorflow import keras\n",
9188
"from tensorflow.keras.layers import Dense\n",
89+
"from tensorflow.keras.models import Sequential\n",
9290
"from tensorflow.keras.optimizers import Adam\n",
93-
"from tensorflow.keras.callbacks import ModelCheckpoint"
91+
"\n",
92+
"from omlt import OffsetScaling, OmltBlock\n",
93+
"from omlt.io.keras import load_keras_sequential\n",
94+
"from omlt.neuralnet import ReluBigMFormulation"
9495
]
9596
},
9697
{
@@ -151,10 +152,23 @@
151152
],
152153
"source": [
153154
"# read in our csv data\n",
154-
"columns = ['Bypass Fraction', 'NG Steam Ratio', 'Steam Flow',\n",
155-
" 'Reformer Duty','AR', 'C2H6', 'C3H8', 'C4H10',\n",
156-
" 'CH4', 'CO', 'CO2', 'H2', 'H2O', 'N2']\n",
157-
"df = pd.read_csv('../data/reformer.csv', usecols=columns)\n",
155+
"columns = [\n",
156+
" \"Bypass Fraction\",\n",
157+
" \"NG Steam Ratio\",\n",
158+
" \"Steam Flow\",\n",
159+
" \"Reformer Duty\",\n",
160+
" \"AR\",\n",
161+
" \"C2H6\",\n",
162+
" \"C3H8\",\n",
163+
" \"C4H10\",\n",
164+
" \"CH4\",\n",
165+
" \"CO\",\n",
166+
" \"CO2\",\n",
167+
" \"H2\",\n",
168+
" \"H2O\",\n",
169+
" \"N2\",\n",
170+
"]\n",
171+
"df = pd.read_csv(\"../data/reformer.csv\", usecols=columns)\n",
158172
"print(df)"
159173
]
160174
},
@@ -169,9 +183,21 @@
169183
"outputs": [],
170184
"source": [
171185
"# separate the data into inputs and outputs\n",
172-
"inputs = ['Bypass Fraction', 'NG Steam Ratio']\n",
173-
"outputs = [ 'Steam Flow', 'Reformer Duty','AR', 'C2H6', 'C3H8', 'C4H10',\n",
174-
" 'CH4', 'CO', 'CO2', 'H2', 'H2O', 'N2']\n",
186+
"inputs = [\"Bypass Fraction\", \"NG Steam Ratio\"]\n",
187+
"outputs = [\n",
188+
" \"Steam Flow\",\n",
189+
" \"Reformer Duty\",\n",
190+
" \"AR\",\n",
191+
" \"C2H6\",\n",
192+
" \"C3H8\",\n",
193+
" \"C4H10\",\n",
194+
" \"CH4\",\n",
195+
" \"CO\",\n",
196+
" \"CO2\",\n",
197+
" \"H2\",\n",
198+
" \"H2O\",\n",
199+
" \"N2\",\n",
200+
"]\n",
175201
"dfin = df[inputs]\n",
176202
"dfout = df[outputs]"
177203
]
@@ -198,8 +224,8 @@
198224
"\n",
199225
"# capture the minimum and maximum values of the scaled inputs\n",
200226
"# so we don't use the model outside the valid range\n",
201-
"scaled_lb = dfin.min()[inputs].values\n",
202-
"scaled_ub = dfin.max()[inputs].values"
227+
"scaled_lb = dfin.min()[inputs].to_numpy()\n",
228+
"scaled_ub = dfin.max()[inputs].to_numpy()"
203229
]
204230
},
205231
{
@@ -222,13 +248,13 @@
222248
],
223249
"source": [
224250
"# create our Keras Sequential model\n",
225-
"nn = Sequential(name='reformer_relu_4_20')\n",
226-
"nn.add(Dense(units=10, input_dim=len(inputs), activation='relu'))\n",
227-
"nn.add(Dense(units=10, activation='relu'))\n",
228-
"nn.add(Dense(units=10, activation='relu'))\n",
229-
"nn.add(Dense(units=10, activation='relu'))\n",
251+
"nn = Sequential(name=\"reformer_relu_4_20\")\n",
252+
"nn.add(Dense(units=10, input_dim=len(inputs), activation=\"relu\"))\n",
253+
"nn.add(Dense(units=10, activation=\"relu\"))\n",
254+
"nn.add(Dense(units=10, activation=\"relu\"))\n",
255+
"nn.add(Dense(units=10, activation=\"relu\"))\n",
230256
"nn.add(Dense(units=len(outputs)))\n",
231-
"nn.compile(optimizer=Adam(), loss='mse')"
257+
"nn.compile(optimizer=Adam(), loss=\"mse\")"
232258
]
233259
},
234260
{
@@ -449,8 +475,8 @@
449475
],
450476
"source": [
451477
"# train our model\n",
452-
"x = dfin.values\n",
453-
"y = dfout.values\n",
478+
"x = dfin.to_numpy()\n",
479+
"y = dfout.to_numpy()\n",
454480
"\n",
455481
"history = nn.fit(x, y, epochs=100)"
456482
]
@@ -468,7 +494,7 @@
468494
"# save the model to disk\n",
469495
"# While not technically necessary, this shows how we can load a previously saved model into\n",
470496
"# our optimization formulation)\n",
471-
"nn.save('reformer_nn_relu.keras')"
497+
"nn.save(\"reformer_nn_relu.keras\")"
472498
]
473499
},
474500
{
@@ -522,22 +548,24 @@
522548
"outputs": [],
523549
"source": [
524550
"# load the Keras model\n",
525-
"nn_reformer = keras.models.load_model('reformer_nn_relu.keras', compile=False)\n",
551+
"nn_reformer = keras.models.load_model(\"reformer_nn_relu.keras\", compile=False)\n",
526552
"\n",
527553
"# Note: The neural network is in the scaled space. We want access to the\n",
528554
"# variables in the unscaled space. Therefore, we need to tell OMLT about the\n",
529555
"# scaling factors\n",
530556
"scaler = OffsetScaling(\n",
531-
" offset_inputs={i: x_offset[inputs[i]] for i in range(len(inputs))},\n",
532-
" factor_inputs={i: x_factor[inputs[i]] for i in range(len(inputs))},\n",
533-
" offset_outputs={i: y_offset[outputs[i]] for i in range(len(outputs))},\n",
534-
" factor_outputs={i: y_factor[outputs[i]] for i in range(len(outputs))}\n",
535-
" )\n",
557+
" offset_inputs={i: x_offset[inputs[i]] for i in range(len(inputs))},\n",
558+
" factor_inputs={i: x_factor[inputs[i]] for i in range(len(inputs))},\n",
559+
" offset_outputs={i: y_offset[outputs[i]] for i in range(len(outputs))},\n",
560+
" factor_outputs={i: y_factor[outputs[i]] for i in range(len(outputs))},\n",
561+
")\n",
536562
"\n",
537563
"scaled_input_bounds = {i: (scaled_lb[i], scaled_ub[i]) for i in range(len(inputs))}\n",
538564
"\n",
539565
"# create a network definition from the Keras model\n",
540-
"net = load_keras_sequential(nn_reformer, scaling_object=scaler, scaled_input_bounds=scaled_input_bounds)\n",
566+
"net = load_keras_sequential(\n",
567+
" nn_reformer, scaling_object=scaler, scaled_input_bounds=scaled_input_bounds\n",
568+
")\n",
541569
"\n",
542570
"# create the variables and constraints for the neural network in Pyomo\n",
543571
"m.reformer.build_formulation(ReluBigMFormulation(net))"
@@ -554,8 +582,8 @@
554582
"outputs": [],
555583
"source": [
556584
"# now add the objective and the constraints\n",
557-
"h2_idx = outputs.index('H2')\n",
558-
"n2_idx = outputs.index('N2')\n",
585+
"h2_idx = outputs.index(\"H2\")\n",
586+
"n2_idx = outputs.index(\"N2\")\n",
559587
"m.obj = pyo.Objective(expr=m.reformer.outputs[h2_idx], sense=pyo.maximize)\n",
560588
"m.con = pyo.Constraint(expr=m.reformer.outputs[n2_idx] <= 0.34)"
561589
]
@@ -571,7 +599,7 @@
571599
"outputs": [],
572600
"source": [
573601
"# now solve the optimization problem (this may take some time)\n",
574-
"solver = pyo.SolverFactory('cbc')\n",
602+
"solver = pyo.SolverFactory(\"cbc\")\n",
575603
"status = solver.solve(m, tee=False)"
576604
]
577605
},
@@ -596,10 +624,10 @@
596624
}
597625
],
598626
"source": [
599-
"print('Bypass Fraction:', pyo.value(m.reformer.inputs[0]))\n",
600-
"print('NG Steam Ratio:', pyo.value(m.reformer.inputs[1]))\n",
601-
"print('H2 Concentration:', pyo.value(m.reformer.outputs[h2_idx]))\n",
602-
"print('N2 Concentration:', pyo.value(m.reformer.outputs[n2_idx]))"
627+
"print(\"Bypass Fraction:\", pyo.value(m.reformer.inputs[0]))\n",
628+
"print(\"NG Steam Ratio:\", pyo.value(m.reformer.inputs[1]))\n",
629+
"print(\"H2 Concentration:\", pyo.value(m.reformer.outputs[h2_idx]))\n",
630+
"print(\"N2 Concentration:\", pyo.value(m.reformer.outputs[n2_idx]))"
603631
]
604632
}
605633
],

0 commit comments

Comments
 (0)