# Strategic Machine Learning Library
Welcome to the **Strategic Machine Learning Library**! This library provides tools and frameworks for modeling, training, and evaluating machine learning models in strategic settings where agents may manipulate their features.
## Table of Contents
- [Introduction](#introduction)
- [Installation](#installation)
- [Getting Started](#getting-started)
- [Key Concepts](#key-concepts)
- [Library Components](#library-components)
- [Models](#models)
- [Deltas (Strategic Behavior)](#deltas-strategic-behavior)
- [Cost Functions](#cost-functions)
- [Regularization Methods](#regularization-methods)
- [Loss Functions](#loss-functions)
- [Model suit](#model-suit)
- [Hyperparameter Optimization](#hyperparameter-optimization)
- [License](#license)
## Introduction
In many real-world scenarios, individuals (agents) may alter their observable features to receive better outcomes from predictive models (e.g., loan approvals, college admissions). This phenomenon is known as **strategic behavior**. This library also support an **advasieral user**, which is a user that tries to manipulate the model to give a wrong prediction.
The Strategic Machine Learning Library provides a comprehensive framework to model such strategic interactions between agents and predictive models. It allows you to:
- Build models that anticipate strategic behavior.
- Define and use various cost functions representing the effort or cost for agents to change their features.
- Implement strategic regularization techniques to encourage desirable outcomes.
- Train and evaluate models in settings where agents act strategically.
## Installation
To install the library, you can clone the repository and install the required packages:
```bash
git clone https://github.com/orimintz21/strategic_ml.git
cd strategic_ml
pip install -r requirements.txt
```
Alternatively, if the library is available on PyPI, you can install it via pip:
```bash
pip install strategic-ml
```
## Getting Started
Here's a simple example to get you started with training a strategic classification model:
```python
import torch
from torch.utils.data import DataLoader, TensorDataset
import strategic_ml as sml
# Define the model
model = sml.LinearModel(in_features=IN_FEATURES)
# Define the cost function
cost_fn = sml.CostNormL2(dim=1)
# Define the strategic delta
delta = sml.LinearStrategicDelta(strategic_model=model, cost=cost_fn, cost_weight=1.0)
# Define the loss function
loss_fn = sml.loss_functions.StrategicHingeLoss(model=model, delta=delta)
# Set up training parameters
training_params = {
"optimizer_class": torch.optim.SGD,
"optimizer_params": {"lr": 0.01},
}
# Initialize the ModelSuit
model_suit = sml.ModelSuit(
model=model,
delta=delta,
loss_fn=loss_fn,
train_loader=train_loader,
validation_loader=validation_loader,
test_loader=test_loader,
training_params=training_params,
# you can add test_delta if you want to test the model using diffrent delta than
# what you have trained on
)
# Train the model
trainer = sml.Trainer(max_epochs=10)
trainer.fit(model_suit)
# model_suit.train_delta_for_test() # Add that if you use non-linear delta for testing
output = trainer.test(model_suit)
```
## Key Concepts
### Strategic Classification
**Strategic classification** considers scenarios where agents can manipulate their features to receive favorable predictions. Traditional machine learning models may become less effective if they do not account for such behavior.
### Modeling Strategic Behavior
The library models strategic behavior using **strategic deltas** (`delta`), which represent the changes agents make to their features. The cost of these changes is quantified using **cost functions**, and models can be regularized to promote or discourage certain strategic behaviors.
## Library Components
### Models
#### `LinearModel`
A simple linear model suitable for binary classification tasks:
```python
from strategic_ml.models import LinearModel
model = LinearModel(in_features=10)
```
#### Linear Regularizations
We also added regulation that are specific to the linear model, for example:
- **L1 Regularization** (`LinearL1Regularization`): Encourages sparsity in the model weights.
- **L2 Regularization** (`LinearL2Regularization`): Penalizes large weights to prevent overfitting.
```python
from strategic_ml.regularization import LinearL1Regularization, LinearL2Regularization
l1_reg = LinearL1Regularization(lambda_=0.01)
l2_reg = LinearL2Regularization(lambda_=0.01)
```
You are welcome to add more regularizations to the library.
### Deltas (Strategic Behavior)
Deltas represent the strategic modifications agents make to their features.
There are two basic type of delta, 'linear delta' and 'non-linear delta'.
The 'linear delta' assumes that the model is linear and the cost is L2 norm.
By making those assumptions, the delta can be calculated by a closed form solution and therefore is faster to compute. If you can't make those assumptions, you can use the 'non-linear delta' which is more general and can be used with any model and cost function. This delta is calculated using gradient descent.
There is also the IdentityDelta, which is used when the agents don't change their features (i.e., we are in a non-strategic scenario). We have implemented strategic and adversarial deltas for both linear and non-linear deltas.
You can add more deltas by inheriting from the appropriate class. Example:
#### `LinearStrategicDelta`
Assumes agents make linear adjustments to their features:
```python
from strategic_ml.gsc import LinearStrategicDelta
delta = LinearStrategicDelta(
strategic_model=model,
cost=cost_fn,
cost_weight=1.0,
)
```
### Cost Functions
Cost functions quantify the effort or cost for agents to change their features.
For example:
#### `CostNormL2`
Computes the L2 norm (Euclidean distance) between the original and modified features:
```python
from strategic_ml.cost_functions import CostNormL2
cost_fn = CostNormL2(dim=1)
```
### Regularization Methods
Regularization methods encourage or discourage certain strategic behaviors.
#### Strategic Regularizations
- **Social Burden**: Minimizes the total effort required by positively labeled agents.
- **Recourse**: Measures the ability of negatively labeled agents to achieve positive outcomes.
- **Expected Utility**: Maximizes the expected utility of strategic agents.
### Loss Functions
Loss functions define the optimization objective during training.
#### `StrategicHingeLoss`
A modified hinge loss that accounts for strategic behavior:
```python
from strategic_ml.loss_functions import StrategicHingeLoss
loss_fn = StrategicHingeLoss(model=model, delta=delta)
```
## Model Suit
The `ModelSuit` class serves as a comprehensive module that encapsulates the model, strategic behavior (delta), loss functions, regularization methods, and training configurations. It streamlines the training, validation, and testing processes by integrating all necessary components and it is implemented using lightning torch.
### **Why Use ModelSuit?**
- **Simplifies Training Workflow**: By encapsulating all components, `ModelSuit` reduces boilerplate code and potential errors.
- **Strategic Integration**: Automatically handles strategic behavior during training and evaluation.
- **Flexibility**: Supports various models, deltas, cost functions, and regularization methods.
- **Leverages PyTorch Lightning**: Benefits from advanced features like automatic batching, GPU acceleration, and logging.
### **Usage**
```python
from strategic_ml import (
LinearModel,
LinearStrategicDelta,
CostNormL2,
StrategicHingeLoss,
LinearL1Regularization,
ModelSuit
)
# Define the components
model = LinearModel(in_features=10)
cost_fn = CostNormL2(dim=1)
delta = LinearStrategicDelta(strategic_model=model, cost=cost_fn, cost_weight=1.0)
test_delta = LinearStrategicDelta(strategic_model=model, cost=cost_fn, cost_weight=1.5)
loss_fn = StrategicHingeLoss(model=model, delta=delta)
l1_reg = LinearL1Regularization(lambda_=0.01)
training_params = {
"optimizer_class": optim.SGD,
"optimizer_params": {"lr": 0.01},
}
# Initialize the ModelSuit
model_suit = ModelSuit(
model=model,
delta=delta,
test_delta=test_delta,
loss_fn=loss_fn,
train_loader=train_loader,
validation_loader=val_loader,
test_loader=test_loader,
training_params=training_params,
linear_regularization=[l1_reg],
)
# Train the model using PyTorch Lightning's Trainer
from pytorch_lightning import Trainer
trainer = Trainer(max_epochs=10)
trainer.fit(model_suit)
output = trainer.test(model_suit)
```
### **Key Parameters**
- **model**: The predictive model (e.g., `LinearModel`).
- **delta**: The strategic delta modeling agents' behavior.
- **loss_fn**: The loss function used for optimization.
- **regularization**: (Optional) Strategic regularization methods.
- **linear_regularization**: (Optional) Linear regularization methods (e.g., L1, L2).
- **training_params**: Dictionary containing optimizer and scheduler configurations.
### **Advanced Features**
- **Device Compatibility**: Works seamlessly on CPU and GPU.
- **Logging and Metrics**: Integrates with PyTorch Lightning's logging for tracking training progress.
- **Strategic Evaluation**: Automatically accounts for strategic behavior during validation and testing.
## Hyperparameter Optimization
You can use **Optuna** for hyperparameter optimization to find the best settings for your model.
```python
import optuna
from optuna.integration import PyTorchLightningPruningCallback
from pytorch_lightning import Trainer
def objective(trial):
# Define hyperparameters to tune
lr = trial.suggest_float("lr", 1e-5, 1e-1, log=True)
batch_size = trial.suggest_int("batch_size", 16, 256)
epochs = trial.suggest_int("epochs", 10, 100)
# Set up data loaders with the suggested batch size
train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
# Define the model, loss function, and optimizer with suggested parameters
model = LinearModel(in_features=10)
loss_fn = StrategicHingeLoss(model=model, delta=delta)
training_params = {
"optimizer_class": optim.SGD,
"optimizer_params": {"lr": lr},
}
# Initialize ModelSuit
model_suit = ModelSuit(
model=model,
delta=delta,
loss_fn=loss_fn,
train_loader=train_loader,
validation_loader=val_loader,
test_loader=test_loader,
training_params=training_params,
)
# Set up the trainer with Optuna's pruning callback
trainer = Trainer(
max_epochs=epochs,
callbacks=[PyTorchLightningPruningCallback(trial, monitor="val_loss_epoch")],
)
# Train the model
trainer.fit(model_suit)
# Return the validation loss
return trainer.callback_metrics["val_loss_epoch"].item()
# Create an Optuna study and optimize
study = optuna.create_study(direction="minimize")
study.optimize(objective, n_trials=50)
```
## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
---
Thank you for using the Strategic Machine Learning Library! We hope it aids in your research and applications.
Raw data
{
"_id": null,
"home_page": "https://github.com/orimintz21/strategic_ml",
"name": "strategic-ml",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.6",
"maintainer_email": null,
"keywords": null,
"author": "Your Name",
"author_email": "orimintz21@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/3a/ff/30eef30c29124d6bc82deed66ab068f288e908dd40dccb1980d7a331575a/strategic_ml-0.1.0.tar.gz",
"platform": null,
"description": "# Strategic Machine Learning Library\n\nWelcome to the **Strategic Machine Learning Library**! This library provides tools and frameworks for modeling, training, and evaluating machine learning models in strategic settings where agents may manipulate their features.\n\n## Table of Contents\n\n- [Introduction](#introduction)\n- [Installation](#installation)\n- [Getting Started](#getting-started)\n- [Key Concepts](#key-concepts)\n- [Library Components](#library-components)\n - [Models](#models)\n - [Deltas (Strategic Behavior)](#deltas-strategic-behavior)\n - [Cost Functions](#cost-functions)\n - [Regularization Methods](#regularization-methods)\n - [Loss Functions](#loss-functions)\n - [Model suit](#model-suit)\n- [Hyperparameter Optimization](#hyperparameter-optimization)\n- [License](#license)\n\n## Introduction\n\nIn many real-world scenarios, individuals (agents) may alter their observable features to receive better outcomes from predictive models (e.g., loan approvals, college admissions). This phenomenon is known as **strategic behavior**. This library also support an **advasieral user**, which is a user that tries to manipulate the model to give a wrong prediction.\n\nThe Strategic Machine Learning Library provides a comprehensive framework to model such strategic interactions between agents and predictive models. It allows you to:\n\n- Build models that anticipate strategic behavior.\n- Define and use various cost functions representing the effort or cost for agents to change their features.\n- Implement strategic regularization techniques to encourage desirable outcomes.\n- Train and evaluate models in settings where agents act strategically.\n\n## Installation\n\nTo install the library, you can clone the repository and install the required packages:\n\n```bash\ngit clone https://github.com/orimintz21/strategic_ml.git\ncd strategic_ml\npip install -r requirements.txt\n```\n\nAlternatively, if the library is available on PyPI, you can install it via pip:\n\n```bash\npip install strategic-ml\n```\n\n## Getting Started\n\nHere's a simple example to get you started with training a strategic classification model:\n\n```python\nimport torch\nfrom torch.utils.data import DataLoader, TensorDataset\nimport strategic_ml as sml\n\n# Define the model\nmodel = sml.LinearModel(in_features=IN_FEATURES)\n\n# Define the cost function\ncost_fn = sml.CostNormL2(dim=1)\n\n# Define the strategic delta\ndelta = sml.LinearStrategicDelta(strategic_model=model, cost=cost_fn, cost_weight=1.0)\n\n# Define the loss function\nloss_fn = sml.loss_functions.StrategicHingeLoss(model=model, delta=delta)\n\n# Set up training parameters\ntraining_params = {\n \"optimizer_class\": torch.optim.SGD,\n \"optimizer_params\": {\"lr\": 0.01},\n}\n\n# Initialize the ModelSuit\nmodel_suit = sml.ModelSuit(\n model=model,\n delta=delta,\n loss_fn=loss_fn,\n train_loader=train_loader,\n validation_loader=validation_loader,\n test_loader=test_loader,\n training_params=training_params,\n # you can add test_delta if you want to test the model using diffrent delta than\n # what you have trained on\n)\n\n# Train the model\ntrainer = sml.Trainer(max_epochs=10)\ntrainer.fit(model_suit)\n# model_suit.train_delta_for_test() # Add that if you use non-linear delta for testing\noutput = trainer.test(model_suit)\n```\n\n## Key Concepts\n\n### Strategic Classification\n\n**Strategic classification** considers scenarios where agents can manipulate their features to receive favorable predictions. Traditional machine learning models may become less effective if they do not account for such behavior.\n\n### Modeling Strategic Behavior\n\nThe library models strategic behavior using **strategic deltas** (`delta`), which represent the changes agents make to their features. The cost of these changes is quantified using **cost functions**, and models can be regularized to promote or discourage certain strategic behaviors.\n\n## Library Components\n\n### Models\n\n#### `LinearModel`\n\nA simple linear model suitable for binary classification tasks:\n\n```python\nfrom strategic_ml.models import LinearModel\n\nmodel = LinearModel(in_features=10)\n```\n#### Linear Regularizations\nWe also added regulation that are specific to the linear model, for example:\n\n- **L1 Regularization** (`LinearL1Regularization`): Encourages sparsity in the model weights.\n- **L2 Regularization** (`LinearL2Regularization`): Penalizes large weights to prevent overfitting.\n\n```python\nfrom strategic_ml.regularization import LinearL1Regularization, LinearL2Regularization\n\nl1_reg = LinearL1Regularization(lambda_=0.01)\nl2_reg = LinearL2Regularization(lambda_=0.01)\n```\nYou are welcome to add more regularizations to the library.\n\n\n### Deltas (Strategic Behavior)\n\nDeltas represent the strategic modifications agents make to their features.\nThere are two basic type of delta, 'linear delta' and 'non-linear delta'. \nThe 'linear delta' assumes that the model is linear and the cost is L2 norm.\nBy making those assumptions, the delta can be calculated by a closed form solution and therefore is faster to compute. If you can't make those assumptions, you can use the 'non-linear delta' which is more general and can be used with any model and cost function. This delta is calculated using gradient descent. \nThere is also the IdentityDelta, which is used when the agents don't change their features (i.e., we are in a non-strategic scenario). We have implemented strategic and adversarial deltas for both linear and non-linear deltas.\nYou can add more deltas by inheriting from the appropriate class. Example:\n\n#### `LinearStrategicDelta`\n\nAssumes agents make linear adjustments to their features:\n\n```python\nfrom strategic_ml.gsc import LinearStrategicDelta\n\ndelta = LinearStrategicDelta(\n strategic_model=model,\n cost=cost_fn,\n cost_weight=1.0,\n)\n```\n\n### Cost Functions\n\nCost functions quantify the effort or cost for agents to change their features.\nFor example:\n\n#### `CostNormL2`\n\nComputes the L2 norm (Euclidean distance) between the original and modified features:\n\n```python\nfrom strategic_ml.cost_functions import CostNormL2\n\ncost_fn = CostNormL2(dim=1)\n```\n\n\n### Regularization Methods\n\nRegularization methods encourage or discourage certain strategic behaviors.\n\n#### Strategic Regularizations\n\n- **Social Burden**: Minimizes the total effort required by positively labeled agents.\n- **Recourse**: Measures the ability of negatively labeled agents to achieve positive outcomes.\n- **Expected Utility**: Maximizes the expected utility of strategic agents.\n\n\n### Loss Functions\n\nLoss functions define the optimization objective during training.\n\n#### `StrategicHingeLoss`\n\nA modified hinge loss that accounts for strategic behavior:\n\n```python\nfrom strategic_ml.loss_functions import StrategicHingeLoss\n\nloss_fn = StrategicHingeLoss(model=model, delta=delta)\n```\n## Model Suit\n\nThe `ModelSuit` class serves as a comprehensive module that encapsulates the model, strategic behavior (delta), loss functions, regularization methods, and training configurations. It streamlines the training, validation, and testing processes by integrating all necessary components and it is implemented using lightning torch.\n\n### **Why Use ModelSuit?**\n\n- **Simplifies Training Workflow**: By encapsulating all components, `ModelSuit` reduces boilerplate code and potential errors.\n- **Strategic Integration**: Automatically handles strategic behavior during training and evaluation.\n- **Flexibility**: Supports various models, deltas, cost functions, and regularization methods.\n- **Leverages PyTorch Lightning**: Benefits from advanced features like automatic batching, GPU acceleration, and logging.\n\n### **Usage**\n\n```python\nfrom strategic_ml import (\n LinearModel,\n LinearStrategicDelta,\n CostNormL2,\n StrategicHingeLoss,\n LinearL1Regularization,\n ModelSuit\n)\n\n# Define the components\nmodel = LinearModel(in_features=10)\ncost_fn = CostNormL2(dim=1)\ndelta = LinearStrategicDelta(strategic_model=model, cost=cost_fn, cost_weight=1.0)\ntest_delta = LinearStrategicDelta(strategic_model=model, cost=cost_fn, cost_weight=1.5)\nloss_fn = StrategicHingeLoss(model=model, delta=delta)\nl1_reg = LinearL1Regularization(lambda_=0.01)\n\ntraining_params = {\n \"optimizer_class\": optim.SGD,\n \"optimizer_params\": {\"lr\": 0.01},\n}\n\n# Initialize the ModelSuit\nmodel_suit = ModelSuit(\n model=model,\n delta=delta,\n test_delta=test_delta,\n loss_fn=loss_fn,\n train_loader=train_loader,\n validation_loader=val_loader,\n test_loader=test_loader,\n training_params=training_params,\n linear_regularization=[l1_reg],\n)\n\n# Train the model using PyTorch Lightning's Trainer\nfrom pytorch_lightning import Trainer\n\ntrainer = Trainer(max_epochs=10)\ntrainer.fit(model_suit)\noutput = trainer.test(model_suit)\n```\n\n### **Key Parameters**\n\n- **model**: The predictive model (e.g., `LinearModel`).\n- **delta**: The strategic delta modeling agents' behavior.\n- **loss_fn**: The loss function used for optimization.\n- **regularization**: (Optional) Strategic regularization methods.\n- **linear_regularization**: (Optional) Linear regularization methods (e.g., L1, L2).\n- **training_params**: Dictionary containing optimizer and scheduler configurations.\n\n### **Advanced Features**\n\n- **Device Compatibility**: Works seamlessly on CPU and GPU.\n- **Logging and Metrics**: Integrates with PyTorch Lightning's logging for tracking training progress.\n- **Strategic Evaluation**: Automatically accounts for strategic behavior during validation and testing.\n## Hyperparameter Optimization\n\nYou can use **Optuna** for hyperparameter optimization to find the best settings for your model.\n\n```python\nimport optuna\nfrom optuna.integration import PyTorchLightningPruningCallback\nfrom pytorch_lightning import Trainer\n\ndef objective(trial):\n # Define hyperparameters to tune\n lr = trial.suggest_float(\"lr\", 1e-5, 1e-1, log=True)\n batch_size = trial.suggest_int(\"batch_size\", 16, 256)\n epochs = trial.suggest_int(\"epochs\", 10, 100)\n \n # Set up data loaders with the suggested batch size\n train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n val_loader = DataLoader(dataset, batch_size=batch_size, shuffle=False)\n \n # Define the model, loss function, and optimizer with suggested parameters\n model = LinearModel(in_features=10)\n loss_fn = StrategicHingeLoss(model=model, delta=delta)\n training_params = {\n \"optimizer_class\": optim.SGD,\n \"optimizer_params\": {\"lr\": lr},\n }\n \n # Initialize ModelSuit\n model_suit = ModelSuit(\n model=model,\n delta=delta,\n loss_fn=loss_fn,\n train_loader=train_loader,\n validation_loader=val_loader,\n test_loader=test_loader,\n training_params=training_params,\n )\n \n # Set up the trainer with Optuna's pruning callback\n trainer = Trainer(\n max_epochs=epochs,\n callbacks=[PyTorchLightningPruningCallback(trial, monitor=\"val_loss_epoch\")],\n )\n \n # Train the model\n trainer.fit(model_suit)\n \n # Return the validation loss\n return trainer.callback_metrics[\"val_loss_epoch\"].item()\n\n# Create an Optuna study and optimize\nstudy = optuna.create_study(direction=\"minimize\")\nstudy.optimize(objective, n_trials=50)\n```\n\n## License\n\nThis project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.\n\n---\n\nThank you for using the Strategic Machine Learning Library! We hope it aids in your research and applications.\n",
"bugtrack_url": null,
"license": null,
"summary": "A comprehensive library for strategic machine learning models",
"version": "0.1.0",
"project_urls": {
"Bug Tracker": "https://github.com/orimintz21/strategic_ml/issues",
"Documentation": "https://github.com/orimintz21/strategic_ml#readme",
"Homepage": "https://github.com/orimintz21/strategic_ml",
"Source Code": "https://github.com/orimintz21/strategic_ml"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "87df4127886d78944d7f21cc7feb217796e074f6ce7bbb7e10eeed34e164479c",
"md5": "dd13e923bbd734416aca7076c5b6cf24",
"sha256": "9c5672caa19d3e3f9f39a048ba33ab5d203ed1cf7044220867eb32e84311c1cb"
},
"downloads": -1,
"filename": "strategic_ml-0.1.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "dd13e923bbd734416aca7076c5b6cf24",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.6",
"size": 40787,
"upload_time": "2024-10-11T09:03:38",
"upload_time_iso_8601": "2024-10-11T09:03:38.012302Z",
"url": "https://files.pythonhosted.org/packages/87/df/4127886d78944d7f21cc7feb217796e074f6ce7bbb7e10eeed34e164479c/strategic_ml-0.1.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "3aff30eef30c29124d6bc82deed66ab068f288e908dd40dccb1980d7a331575a",
"md5": "849292448b23c4c583404232d9c847c5",
"sha256": "0ab0dccf9850a17aadd44255e5ecb0786c1ca1d8a5fb1d72cd5a612af714bed7"
},
"downloads": -1,
"filename": "strategic_ml-0.1.0.tar.gz",
"has_sig": false,
"md5_digest": "849292448b23c4c583404232d9c847c5",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.6",
"size": 32134,
"upload_time": "2024-10-11T09:03:40",
"upload_time_iso_8601": "2024-10-11T09:03:40.483379Z",
"url": "https://files.pythonhosted.org/packages/3a/ff/30eef30c29124d6bc82deed66ab068f288e908dd40dccb1980d7a331575a/strategic_ml-0.1.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-10-11 09:03:40",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "orimintz21",
"github_project": "strategic_ml",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [],
"test_requirements": [],
"lcname": "strategic-ml"
}
JSON
