A Robust ML toolbox
Project description
CI | ||
---|---|---|
Style | ||
Documentation |
SkWDRO - Wasserstein Distributionally Robust Optimization for Machine Learning
Model robustification with thin Pytorch and Scikit-learn interface
You can make pigs fly, [Kolter&Madry, 2018]
skwdro
is a Python package that offers WDRO versions for a large range of estimators, either by extending scikit-learn
estimator or by providing a wrapper for pytorch
modules.
Have a look at skwdro
documentation!
Getting started with skwdro
Installation
Development mode with hatch
First install hatch
and clone the archive. In the root folder, make shell
gives you an interactive shell in the correct environment and make test
runs the tests (it can be launched from both an interactive shell and a normal shell).
make reset_env
removes installed environments (useful in case of troubles).
With pip
skwdro
will be available on PyPi soon, for now only the development mode is available.
First steps with skwdro
scikit-learn
interface
Robust estimators from skwdro
can be used as drop-in replacements for scikit-learn
estimators (they actually inherit from scikit-learn
estimators and classifier classes.). skwdro
provides robust estimators for standard problems such as linear regression or logistic regression. LinearRegression
from skwdro.linear_model
is a robust version of LinearRegression
from scikit-learn
and be used in the same way. The only difference is that now an uncertainty radius rho
is required.
We assume that we are given X_train
of shape (n_train, n_features)
and y_train
of shape (n_train,)
as training data and X_test
of shape (n_test, n_features)
as test data.
from skwdro.linear_model import LinearRegression
# Uncertainty radius
rho = 0.1
# Fit the model
robust_model = LinearRegression(rho=rho)
robust_model.fit(X_train, y_train)
# Predict the target values
y_pred = robust_model.predict(X_test)
You can refer to the documentation to explore the list of skwdro
's already-made estimators.
pytorch
interface
Didn't find a estimator that suits you? You can compose your own using the pytorch
interface: it allows more flexibility, custom models and optimizers.
Assume now that the data is given as a dataloader train_loader
.
import torch
import torch.nn as nn
import torch.optim as optim
from skwdro.torch import robustify
# Uncertainty radius
rho = 0.1
# Define the model
model = nn.Linear(n_features, 1)
# Define the loss function
loss_fn = nn.MSELoss()
# Define a sample batch for initialization
sample_batch_x, sample_batch_y = next(iter(train_loader))
# Robust loss
robust_loss = robustify(loss_fn, model, rho, sample_batch_x, sample_batch_y)
# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.01)
# Training loop
for epoch in range(100):
for batch_x, batch_y in train_loader:
optimizer.zero_grad()
loss = robust_loss(batch_x, batch_y)
loss.backward()
optimizer.step()
You will find detailed description on how to robustify
modules in the documentation.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for skwdro-1.0.1-py2.py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | ee6dc4419c08cff23637448d0cabc8cc84355fc1891b7626047bf9853ce13a1e |
|
MD5 | 8e2cc80665d2330c23638687b8a7e5cd |
|
BLAKE2b-256 | f618d0903a3c4b02a831c0a2a3fbe7cfd14c68a8188f685cf4b0556caf4b158d |