dro 0.2.0__py3-none-any.whl

docs-code/conf.py

@@ -0,0 +1,121 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+import sys
+import os
+sys.path.insert(0, os.path.abspath('../dro/src'))  
+print(sys.path)
+
+project = 'dro'
+copyright = '2025, Jiashuo Liu, Tianyu Wang, Peng Cui, Hongseok Namkoong, Jose Blanchet'
+author = 'Jiashuo Liu, Tianyu Wang, Peng Cui, Hongseok Namkoong, Jose Blanchet'
+release = '0.1.1'
+
+# html_static_path = ['../docs']
+html_baseurl = 'https://namkoong-lab.github.io/dro/' 
+
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.intersphinx',
+    'sphinx_autodoc_typehints',
+    'sphinx.ext.mathjax',
+    "myst_parser",
+    'nbsphinx',
+    'sphinx_copybutton' 
+]
+
+autodoc_type_aliases = {
+    'NDArray': 'numpy.ndarray',
+    "Expression": "cvxpy.expressions.expression.Expression",
+    'Tensor': 'torch.Tensor',
+    # 'Module': 'torch.nn.Module'
+}
+
+autodoc_default_options = {
+    "no-autoparams": True
+}
+
+intersphinx_mapping = {
+    'numpy': ('https://numpy.org/doc/stable/', None),
+    'torch': ('https://pytorch.org/docs/stable/', None),
+    'python': ('https://docs.python.org/3', None)
+}
+
+source_suffix = {
+    ".rst": "restructuredtext",
+    ".md": "markdown",
+}
+
+autodoc_typehints = "description" 
+
+# html_theme = 'sphinx_rtd_theme'
+# html_theme_options = {
+    # 'navigation_depth': 4,
+    # 'collapse_navigation': False
+# }
+
+
+html_theme = 'piccolo_theme'
+html_theme_options = {
+    "source_url": 'https://github.com/namkoong-lab/dro',
+    "source_icon": "github",
+    "globaltoc_collapse": False,
+    "banner_text": 'A GIFT to the whole DRO community!',
+    "banner_hiding": "temporal",
+    # "canonical_url": "", 
+    # "analytics_id": "",
+}
+
+
+autodoc_default_options = {
+    'member-order': 'bysource',
+    'undoc-members': True,
+    'show-inheritance': True,
+    "private-members": False 
+}
+
+myst_enable_extensions = [
+    "dollarmath",   
+    "colon_fence",  
+    "html_image",   
+    "linkify",      
+]
+
+nbsphinx_execute = 'auto'
+nbsphinx_kernel_name = 'python3'
+nbsphinx_timeout = 600
+nbsphinx_prompt_width = "0"
+nbsphinx_include_pattern = [] 
+
+
+autoclass_content = 'both'  
+
+# add_module_names = False
+
+nitpicky = True
+nitpick_ignore = [
+    ("py:class", "torch.device"),
+    ("py:class", "torch.nn.Module"),
+    ("py:class", "nn.Module"),
+    ("py:class", "Module"),
+    ("py:exc", "LinAlgError"),
+    ('py:exc', 'MOTDROError'),
+    ('py:exc', 'KLDROError'),
+    ('py:exc', 'Chi2DROError'),
+    ('py:exc', 'BayesianDROError'),
+    ('py:exc', 'MMDDROError'),
+    ('py:exc', 'KLDROError'),
+    ('py:exc', 'ConditionalCVaRDROError'),
+    ('py:exc', 'HRDROError'),
+    ('py:exc', 'MarginalCVaRDROError'),
+    ('py:exc', 'ORWDROError'),
+    ('py:exc', 'SinkhornDROError'),
+    ('py:exc', 'TVDROError'),
+    ('py:exc', 'WassersteinDROError'),
+    ('py:exc', 'DROError'),
+    ('py:exc', 'CVaRDROError'),
+    ('py:exc', 'LinearModel')
+]

dro/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.2.0"
+__author__ = 'DRO developers.'
+__credits__ = "Tsinghua University, Columbia University, and Stanford University"
+
+
+from .src import * 

dro/src/__init__.py

@@ -0,0 +1,3 @@
+from .data import * 
+from .linear_model import * 
+from .neural_model import *  

dro/src/data/__init__.py

@@ -0,0 +1,2 @@
+from .dataloader_classification import classification_basic, classification_DN21, classification_SNVD20, classification_LWLC
+from .dataloader_regression import regression_basic, regression_DN20_1, regression_DN20_2, regression_DN20_3, regression_LWLC

dro/src/data/dataloader_classification.py

@@ -0,0 +1,154 @@
+import numpy as np 
+from dro.src.data.draw_utils import draw_classification
+
+def classification_basic(d=2, k=2, num_samples=500, radius=5.0, seed=42, visualize=False, save_dir= None):
+    """
+    Basic classification setting.
+
+    Parameters:
+    - d (int): The dimension of covariates
+    - k (int): The number of classes
+    - num_samples (int): The number of samples
+    - radius (float): The radius of the ball to sample the class center
+    - seed (int): Random seed.
+    - visualize (bool): Whether to visualize the data
+    - save_dir (str): The save path of the visualization figure, if set None, we just visualize instead of storing it.
+
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+    np.random.seed(seed)
+    samples_per_class = num_samples // k 
+    X, y = [], []
+
+    centers = np.random.randn(k, d)
+    centers /= np.linalg.norm(centers, axis=1, keepdims=True) 
+    centers *= radius
+
+    for i, center in enumerate(centers):
+        class_points = np.random.randn(samples_per_class, d) + center 
+        X.append(class_points)
+        y.append(np.full(samples_per_class, 2 * i - 1)) 
+    
+    X = np.vstack(X)
+    y = np.hstack(y)
+
+    if visualize:
+        draw_classification(X, y, save_dir)
+
+    return X, y
+
+
+def classification_DN21(d, flip_ratio=0.1, num_samples=100, seed=42, visualize=False, save_dir="./visualization.png"):
+    """
+    Following Section 3.1.1 of "Learning Models with Uniform Performance via Distributionally Robust Optimization"
+    link: https://arxiv.org/pdf/1810.08750
+    
+    Parameters:
+    - d (int): The dimension of covariates
+    - flip_ratio (fload): The ratio of labels to be flipped
+    - num_samples (int): The number of samples
+    - seed (int): Random seed.
+    - visualize (bool): Whether to visualize the data
+    - save_dir (str): The save path of the visualization figure
+
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y_noisy (numpy.ndarray): A numpy array containing the generated target data
+    """
+
+    np.random.seed(seed)
+
+    X = np.random.randn(num_samples, d)
+
+    theta_star = np.random.randn(d)
+    theta_star /= np.linalg.norm(theta_star)
+
+    y_clean = np.sign(X @ theta_star)
+
+    flip_mask = np.random.rand(num_samples) < flip_ratio
+    y_noisy = np.where(flip_mask, -y_clean, y_clean)
+
+    if visualize:
+        draw_classification(X, y_noisy, save_dir)
+
+    return X, y_noisy
+
+
+def classification_SNVD20(num_samples=500, seed=42, visualize=False, save_dir="./visualization.png"):
+    """
+    Following Section 5.1 of "Certifying Some Distributional Robustness with Principled Adversarial Training"
+    link: https://arxiv.org/pdf/1710.10571
+
+    Parameters:
+    - num_samples (int): The number of samples
+    - seed (int): Random seed.
+    - visualize (bool): Whether to visualize the data
+    - save_dir (str): The save path of the visualization figure
+
+    Returns:
+    - X_filtered (numpy.ndarray): A numpy array containing the generated covariate data
+    - y_filtered (numpy.ndarray): A numpy array containing the generated target data
+    """
+    
+    np.random.seed(seed)
+    X = np.random.randn(num_samples, 2)
+    norms = np.linalg.norm(X, axis=1)
+    y = np.sign(norms-np.sqrt(2))
+    lower_bound = np.sqrt(2) / 1.3
+    upper_bound = 1.3 * np.sqrt(2)
+    mask = (norms < lower_bound) | (norms > upper_bound) 
+
+    X_filtered = X[mask]
+    y_filtered = y[mask]
+
+    if visualize:
+        draw_classification(X_filtered, y_filtered, save_dir)
+
+    return X_filtered, y_filtered
+
+
+def classification_LWLC(num_samples=10000, d=5, bias=0.5, scramble=True, sigma_s=3.0, sigma_v=0.3, high_dimension=300, seed=42, visualize=False, save_dir="./visualization.png"):
+    """
+    Following Section 4.1 (Classification) of "Distributionally Robust Optimization with Data Geometry"
+    link: https://proceedings.neurips.cc/paper_files/paper/2022/file/da535999561b932f56efdd559498282e-Paper-Conference.pdf
+
+    Parameters:
+    - num_samples (int): The number of samples
+    - d (int): The dimension of feature S and V
+    - bias (float): The bias ratio in (0,1)
+    - scramble (bool): Whether to mix the features S and V
+    - sigma_s (float): The variance of the Guassian distribution to sample the feature S
+    - sigma_v (float): The variance of the Guassian distribution to sample the feature V
+    - high_dimension (int): The final dimension of X
+    - seed (int): Random seed.
+    - visualize (bool): Whether to visualize the data
+    - save_dir (str): The save path of the visualization figure
+
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated (high-dimensional) covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+    from scipy.stats import ortho_group
+    S = np.float32(ortho_group.rvs(size=1, dim=high_dimension, random_state=1))
+
+    np.random.seed(seed)
+    y = np.random.choice([1, -1], size=(num_samples, 1))
+    X = np.random.randn(num_samples, d * 2)
+    
+    X[:, :d] *= sigma_s
+    X[:, d:] *= sigma_v
+    flip = np.random.choice([1, -1], size=(num_samples, 1), p=[bias, 1. - bias]) * y
+    X[:, :d] += y
+    X[:, d:] += flip
+    if scramble:
+        X = np.tile(X,(1,high_dimension//(2*d)))
+        X = np.matmul(X, S)
+
+    if visualize:
+        draw_classification(X, y, save_dir)
+
+    return X, y
+
+

dro/src/data/dataloader_regression.py

@@ -0,0 +1,177 @@
+import numpy as np 
+from sklearn.datasets import make_regression
+from ucimlrepo import fetch_ucirepo   
+import pandas as pd 
+
+def regression_basic(num_samples=100, d=1, noise=0.1, seed=42):
+    """
+    Basic regression setting.
+
+    Parameters:
+    - num_samples (int): The number of samples
+    - d (int): The dimension of covariates
+    - noise (float): The variance of the noise term
+    - seed (int): Random seed.
+    
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+     
+    X, y = make_regression(n_samples=num_samples, n_features=d, noise=noise, random_state=seed)
+    return X, y
+
+
+def regression_DN20_1(num_samples, d=5, noise=0.01, seed=42):
+    """
+    Following Section 3.1.2 of "Learning Models with Uniform Performance via Distributionally Robust Optimization"
+    link: https://arxiv.org/pdf/1810.08750
+
+    Parameters:
+    - num_samples (int): The number of samples
+    - d (int): The dimension of covariates
+    - noise (float): The variance of the noise term
+    - seed (int): Random seed.
+    
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+    np.random.seed(seed)
+
+    X = np.random.randn(num_samples, d)
+    eps = np.random.randn(num_samples)*noise
+    theta_star = np.random.randn(d)
+    theta_star /= np.linalg.norm(theta_star)
+
+    y = X @ theta_star+eps 
+    y_noisy = np.where(X[:,0]>1.645, y+X[:,0], y)
+
+    return X, y_noisy
+
+
+def regression_DN20_2(num_samples, prob=0.1, noise=0.01, seed=42):
+    """
+    Following Section 3.1.3 of "Learning Models with Uniform Performance via Distributionally Robust Optimization"
+    link: https://arxiv.org/pdf/1810.08750
+
+    Parameters:
+    - num_samples (int): The number of samples
+    - prob (float): the minority group ratio in (0,1)
+    - noise (float): The variance of the noise term
+    - seed (int): Random seed.
+    
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+
+    np.random.seed(seed)
+    X = np.random.randn(num_samples, 2)
+    theta_star1 = np.array([1.0, 0.1]).T
+    theta_star2 = np.array([1.0, 1.0]).T
+    
+    eps = np.random.randn(num_samples)*noise
+    G = np.random.uniform(low=0, high=1, size=num_samples)
+    y = np.where(G<prob, X@theta_star1+eps, X@theta_star2+eps)
+
+    return X, y
+
+def regression_DN20_3(save_dir="./data/", download=True):
+    """
+    Following Section 3.3 of "Learning Models with Uniform Performance via Distributionally Robust Optimization"
+    link: https://arxiv.org/pdf/1810.08750
+
+    Data is from UCI repository: https://archive.ics.uci.edu/dataset/183/communities+and+crime
+
+    Parameters:
+    - save_dir (str): The path to save the data
+    - download (bool): Whether to download the data. If not, will load the data according to the save_dir
+    
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+    if download:
+        communities_and_crime = fetch_ucirepo(id=183) 
+        X = communities_and_crime.data.features 
+        y = communities_and_crime.data.targets 
+        X = X.drop(columns=['communityname'])
+        X_values = X.apply(pd.to_numeric, errors='coerce')
+        X_filled = X_values.apply(lambda col: col.fillna(col.mean()) if col.dtype in ['float64', 'int64'] else col, axis=0)
+        X_values = X_filled.to_numpy()
+        y = y.to_numpy()
+        np.savez(f'{save_dir}crime.npz', X=X_values, y=y)
+    else:
+        try:
+            data = np.load(f'{save_dir}crime.npz')
+            X = data["X"]
+            y = data["y"]
+        except Exception as e :
+            print(e)
+            print("Please set download=True and retry!")
+    return X, y
+
+def regression_LWLC(n1=100000, n2=1000, ps=5, pvb=1, pv=4, r=1.7, scramble=False):
+    """
+    Following Section 4.1 (Regression) of "Distributionally Robust Optimization with Data Geometry"
+    link: https://proceedings.neurips.cc/paper_files/paper/2022/file/da535999561b932f56efdd559498282e-Paper-Conference.pdf
+
+    n1: total number of samples in the pool
+    n2: number of samples required
+    r: controls the spurious correlation between pvb and y
+    scramble: whether to mix S and V
+
+    Parameters:
+    - n1 (int): The total number of samples in the pool
+    - n2 (int): The number of samples required
+    - ps (int): The dimension of feature S
+    - pvb (int): The dimension of feature Vb
+    - pv (int): The dimension of other features in V (except for Vb)
+    - r (float): The adjustment parameter to control the spurious correlation with |r|>1. Higher |r| denotes stronger spurious correlation, and sign(r) controls the direction of spurious correlation
+    - scramble (bool): Whether to mix the features S and V.
+    
+    Returns:
+    - X (numpy.ndarray): A numpy array containing the generated covariate data
+    - y (numpy.ndarray): A numpy array containing the generated target data
+    """
+    
+    S = np.random.normal(0, 2, [n1, ps])
+
+    Z = np.random.normal(0, 1, [n1, ps + 1])
+    for i in range(ps):
+        S[:, i:i + 1] = 0.8 * Z[:, i:i + 1] + 0.2 * Z[:, i + 1:i + 2]
+
+    beta = np.zeros((ps, 1))
+    for i in range(ps):
+        beta[i] = (-1) ** i * (i % 3 + 1) * 1.0
+
+    noise = np.random.normal(0, 0.5, [n1, 1])
+
+    Y = np.dot(S, beta) + noise + 0.1 * S[:, 0:1] * S[:, 1:2] * S[:, 2:3]
+    V = np.random.normal(Y, 2, [n1, pvb + pv])
+    V[:, :pv] = np.random.normal(0, 2, [n1, pv])
+    index_pre = np.ones([n1, 1], dtype=bool)
+    for i in range(pvb):
+        D = np.abs(V[:, pv + i:pv + i + 1] * np.sign(r) - Y)
+        pro = np.power(np.abs(r), -D * 5)
+        selection_bias = np.random.random([n1, 1])
+        index_pre = index_pre & (
+                    selection_bias < pro)
+    index = np.where(index_pre == True)
+    S_re = S[index[0], :]
+    V_re = V[index[0], :]
+    Y_re = Y[index[0]]
+    n, _ = S_re.shape
+    index_s = np.random.permutation(n)
+
+    X_re = np.hstack((S_re, V_re))
+    
+    X = X_re[index_s[0:n2], :]
+    y = Y_re[index_s[0:n2], :]
+
+    from scipy.stats import ortho_group
+    S = np.float32(ortho_group.rvs(size=1, dim=X.shape[1], random_state=1))
+    if scramble:
+        X = np.matmul(X, S)
+    return X, y

dro/src/data/draw_utils.py

@@ -0,0 +1,40 @@
+import matplotlib.pyplot as plt 
+from sklearn.decomposition import PCA
+import numpy as np 
+
+class VisualizationError(Exception):
+    """Base exception class for errors in the visualization.
+    """
+    pass
+
+def draw_classification(X, y, save_dir = None, title = None, weight = None, scale = 20):
+    """
+    two dimensional projection of classification data (X, y)
+    """
+    if weight is None:
+        weight = np.ones(X.shape[0])
+    else:
+        weight = weight * X.shape[0]
+
+    if X.shape[1]>2:
+        pca = PCA(n_components=2)
+        X_2D = pca.fit_transform(X)
+    else:
+        X_2D = X
+    if X.shape[1] == 1:
+        raise VisualizationError()
+    
+    plt.figure(figsize=(8, 6))
+    plt.scatter(X_2D[:, 0], X_2D[:, 1], s = weight * scale, c = y, cmap=plt.cm.jet, edgecolors="k", alpha=0.7)
+    plt.xlabel("Principal Component 1")
+    plt.ylabel("Principal Component 2")
+    if title is None:
+        plt.title("Data Visualization")
+    else:
+        plt.title(title)
+
+    plt.colorbar(label="Class Label")
+    if save_dir is None:
+        plt.show()
+    else:
+        plt.savefig(save_dir)

dro/src/data/info.py

@@ -0,0 +1,126 @@
+def list_functions():
+    functions_metadata = [
+        {
+            'name': 'classification_basic',
+            'description': 'Generate basic classification data where each class is sampled from a different center, with the data points spread radially from the center.',
+            'parameters': [
+                ('d', 'int', 'Dimension of the covariates (default: 2)'),
+                ('k', 'int', 'Number of classes (default: 2)'),
+                ('num_samples', 'int', 'Total number of samples (default: 500)'),
+                ('radius', 'float', 'Radius of the ball to sample the class center (default: 5.0)'),
+                ('seed', 'int', 'Random seed (default: 42)'),
+                ('visualize', 'bool', 'Whether to visualize the data (default: False)'),
+                ('save_dir', 'str', 'The save path of the visualization figure (default: "./visualization.png")')
+            ],
+            'returns': 'X and y as numpy arrays, where X is the covariate data and y is the target data'
+        },
+        {
+            'name': 'classification_DN21',
+            'description': 'Generate classification data using a linear decision boundary with label flipping as per the DN21 setting from the paper "Learning Models with Uniform Performance via Distributionally Robust Optimization".',
+            'parameters': [
+                ('d', 'int', 'Dimension of the covariates'),
+                ('flip_ratio', 'float', 'The ratio of labels to be flipped (default: 0.1)'),
+                ('num_samples', 'int', 'Total number of samples (default: 100)'),
+                ('seed', 'int', 'Random seed (default: 42)'),
+                ('visualize', 'bool', 'Whether to visualize the data (default: False)'),
+                ('save_dir', 'str', 'The save path of the visualization figure (default: "./visualization.png")')
+            ],
+            'returns': 'X (covariate data) and y_noisy (target data with noise from flipped labels) as numpy arrays'
+        },
+        {
+            'name': 'classification_SNVD20',
+            'description': 'Generate classification data by applying a filter based on the Euclidean norm of points sampled from a 2D normal distribution, with additional filtering as per the SNVD20 setting from the paper "Certifying Some Distributional Robustness with Principled Adversarial Training".',
+            'parameters': [
+                ('num_samples', 'int', 'Total number of samples (default: 500)'),
+                ('seed', 'int', 'Random seed (default: 42)'),
+                ('visualize', 'bool', 'Whether to visualize the data (default: False)'),
+                ('save_dir', 'str', 'The save path of the visualization figure (default: "./visualization.png")')
+            ],
+            'returns': 'X_filtered (filtered covariate data) and y_filtered (filtered target data) as numpy arrays'
+        },
+        {
+            'name': 'classification_LWLC',
+            'description': 'Generate high-dimensional classification data with features scrambled and a Gaussian distribution applied to the feature set, based on the LWLC model from the paper "Distributionally Robust Optimization with Data Geometry".',
+            'parameters': [
+                ('num_samples', 'int', 'Total number of samples (default: 10000)'),
+                ('d', 'int', 'Dimension of feature sets S and V (default: 5)'),
+                ('bias', 'float', 'Bias ratio for class labels (default: 0.5)'),
+                ('scramble', 'bool', 'Whether to scramble features (default: True)'),
+                ('sigma_s', 'float', 'Variance of the Gaussian distribution for feature S (default: 3.0)'),
+                ('sigma_v', 'float', 'Variance of the Gaussian distribution for feature V (default: 0.3)'),
+                ('high_dimension', 'int', 'The final dimension of X (default: 300)'),
+                ('seed', 'int', 'Random seed (default: 42)'),
+                ('visualize', 'bool', 'Whether to visualize the data (default: False)'),
+                ('save_dir', 'str', 'The save path of the visualization figure (default: "./visualization.png")')
+            ],
+            'returns': 'X (high-dimensional covariate data) and y (target data) as numpy arrays'
+        },
+        {
+            'name': 'regression_basic',
+            'description': 'Generates a basic regression dataset with a specified number of samples and dimensions, with Gaussian noise added to the target variable.',
+            'parameters': [
+                ('num_samples', 'int', 'The number of samples'),
+                ('d', 'int', 'The dimension of covariates'),
+                ('noise', 'float', 'The variance of the noise term'),
+                ('seed', 'int', 'Random seed')
+            ],
+            'returns': 'X (numpy.ndarray), y (numpy.ndarray): The generated covariate and target data'
+        },
+        {
+            'name': 'regression_DN20_1',
+            'description': 'Generates a regression dataset following Section 3.1.2 of "Learning Models with Uniform Performance via Distributionally Robust Optimization", where the target variable has Gaussian noise and a noisy label is added based on the value of the first covariate.',
+            'parameters': [
+                ('num_samples', 'int', 'The number of samples'),
+                ('d', 'int', 'The dimension of covariates'),
+                ('noise', 'float', 'The variance of the noise term'),
+                ('seed', 'int', 'Random seed')
+            ],
+            'returns': 'X (numpy.ndarray), y_noisy (numpy.ndarray): The generated covariate and noisy target data'
+        },
+        {
+            'name': 'regression_DN20_2',
+            'description': 'Generates a regression dataset following Section 3.1.3 of "Learning Models with Uniform Performance via Distributionally Robust Optimization", with two different linear models based on a minority group ratio and Gaussian noise.',
+            'parameters': [
+                ('num_samples', 'int', 'The number of samples'),
+                ('prob', 'float', 'The minority group ratio'),
+                ('noise', 'float', 'The variance of the noise term'),
+                ('seed', 'int', 'Random seed')
+            ],
+            'returns': 'X (numpy.ndarray), y (numpy.ndarray): The generated covariate and target data'
+        },
+        {
+            'name': 'regression_DN20_3',
+            'description': 'Generates a regression dataset based on the UCI Communities and Crime dataset, as described in Section 3.3 of "Learning Models with Uniform Performance via Distributionally Robust Optimization", with options to download or load the data.',
+            'parameters': [
+                ('save_dir', 'str', 'The path to save the data'),
+                ('download', 'bool', 'Whether to download the data or load from the saved directory')
+            ],
+            'returns': 'X (numpy.ndarray), y (numpy.ndarray): The generated covariate and target data'
+        },
+        {
+            'name': 'regression_LWLC',
+            'description': 'Generates a regression dataset with controlled spurious correlation, following Section 4.1 of "Distributionally Robust Optimization with Data Geometry", with options to scramble features and control spurious correlations.',
+            'parameters': [
+                ('n1', 'int', 'The total number of samples in the pool'),
+                ('n2', 'int', 'The number of samples required'),
+                ('ps', 'int', 'The dimension of feature S'),
+                ('pvb', 'int', 'The dimension of feature Vb'),
+                ('pv', 'int', 'The dimension of other features in V (except for Vb)'),
+                ('r', 'float', 'The adjustment parameter controlling spurious correlation'),
+                ('scramble', 'bool', 'Whether to mix S and V')
+            ],
+            'returns': 'X (numpy.ndarray), y (numpy.ndarray): The generated covariate and target data'
+        }
+    ]
+    
+    for idx, func in enumerate(functions_metadata):
+        print(f"Data Generation Mechanism {idx+1}: {func['name']}")
+        print(f"  Description: {func['description']}")
+        print(f"  Parameters:")
+        for param in func['parameters']:
+            print(f"    - {param[0]} ({param[1]}): {param[2]}")
+        print(f"  Returns: {func['returns']}\n")
+
+
+if __name__ == "__main__":
+    list_functions()