sciml 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

sciml/__init__.py

@@ -1,2 +1,2 @@
 # coding: utf-8
-__all__ = ["utils", "pipelines", "models"]
+__all__ = ["pipelines", "models", "metrics", "regress2", "ccc"]

sciml/ccc.py

@@ -0,0 +1,36 @@
+# https://rowannicholls.github.io/python/statistics/agreement/correlation_coefficients.html#lins-concordance-correlation-coefficient-ccc
+# Lin LIK (1989). “A concordance correlation coefficient to evaluate reproducibility”. Biometrics. 45 (1):255-268.
+import numpy as np
+import pandas as pd
+
+def concordance_correlation_coefficient(y_true, y_pred):
+    """Concordance correlation coefficient."""
+    # Remove NaNs
+    df = pd.DataFrame({
+        'y_true': y_true,
+        'y_pred': y_pred
+    })
+    df = df.dropna()
+    y_true = df['y_true']
+    y_pred = df['y_pred']
+    # Pearson product-moment correlation coefficients
+    cor = np.corrcoef(y_true, y_pred)[0][1]
+    # Mean
+    mean_true = np.mean(y_true)
+    mean_pred = np.mean(y_pred)
+    # Variance
+    var_true = np.var(y_true)
+    var_pred = np.var(y_pred)
+    # Standard deviation
+    sd_true = np.std(y_true)
+    sd_pred = np.std(y_pred)
+    # Calculate CCC
+    numerator = 2 * cor * sd_true * sd_pred
+    denominator = var_true + var_pred + (mean_true - mean_pred)**2
+    return numerator / denominator
+
+
+# y_true = [3, -0.5, 2, 7, np.NaN]
+# y_pred = [2.5, 0.0, 2, 8, 3]
+# ccc = concordance_correlation_coefficient(y_true, y_pred)
+# print(ccc)

sciml/metrics.py

@@ -0,0 +1,123 @@
+import numpy as np
+import pandas as pd
+from scipy import stats
+from sklearn.metrics import explained_variance_score, max_error, mean_absolute_error, mean_squared_error, mean_squared_log_error, median_absolute_error, r2_score, mean_poisson_deviance, mean_gamma_deviance, mean_tweedie_deviance
+
+def stats_summary(df):
+    min_ = df.min().to_frame().T
+    Q1 = df.quantile(0.25).to_frame().T
+    median_ = df.quantile(0.5).to_frame().T
+    mean_ = df.mean().to_frame().T
+    Q3 = df.quantile(0.75).to_frame().T
+    max_ = df.max().to_frame().T
+    df_stats = pd.concat([min_, Q1, median_, mean_, Q3, max_])
+    df_stats.index = ["Min", "Q1", "Median", "Mean", "Q3", "Max"]
+    return df_stats
+
+def stats_measures(x, y, return_dict = False):
+    slope, intercept, rvalue, pvalue, stderr = stats.linregress(x, y)
+    mse = mean_squared_error(x, y)
+    r2 = rvalue ** 2
+    rmse = np.sqrt(mse)
+    mbe = (y - x).mean()
+    if return_dict:
+        return {
+            "R2": r2,
+            "SLOPE": slope,
+            "RMSE": rmse,
+            "MBE": mbe
+        }
+    else:
+        return [r2, slope, rmse, mbe]
+
+def stats_measures_full(x, y):
+    # from sklearn.metrics import mean_absolute_percentage_error
+    slope, intercept, rvalue, pvalue, stderr = stats.linregress(x, y)
+    mse = mean_squared_error(x, y)
+    r2 = rvalue ** 2
+    rmse = np.sqrt(mse)
+    mbe = (y - x).mean()
+    # ----------------------------------------------------------------
+    pearsonr = stats.pearsonr(x, y)
+    evs = explained_variance_score(x, y)
+    me = max_error(x, y)
+    mae = mean_absolute_error(x, y)
+    msle = mean_squared_log_error(x, y)
+    meae = median_absolute_error(x, y)
+    r2_score = r2_score(x, y)
+    mpd = mean_poisson_deviance(x, y)
+    mgd = mean_gamma_deviance(x, y)
+    mtd = mean_tweedie_deviance(x, y)
+    return {
+        "R2": r2,
+        "SLOPE": slope,
+        "RMSE": rmse,
+        "MBE": mbe,
+        "INTERCEPT": intercept,
+        "PVALUE": pvalue,
+        "STDERR": stderr,
+        "PEARSON": pearsonr,
+        "EXPLAINED_VARIANCE": evs,
+        "MAXERR": me,
+        "MAE": mae,
+        "MSLE": msle,
+        "MEDIAN_AE": meae,
+        "R2_SCORE": r2_score,
+        "MPD": mpd,
+        "MGD": mgd,
+        "MTD": mtd
+    }
+
+def stats_measures_df(df, name1, name2, return_dict = False):
+    slope, intercept, rvalue, pvalue, stderr = stats.linregress(df[name1], df[name2])
+    mse = mean_squared_error(df[name1], df[name2])
+    r2 = rvalue ** 2
+    rmse = np.sqrt(mse)
+    mbe = (df[name2] - df[name1]).mean()
+    if return_dict:
+        return {
+            "R2": r2,
+            "SLOPE": slope,
+            "RMSE": rmse,
+            "MBE": mbe
+        }
+    else:
+        return [r2, slope, rmse, mbe]
+    
+
+
+def get_r2(x, y):
+    try:
+        x_bar = x.mean()
+    except:
+        x_bar = np.mean(x)
+
+    r2 = 1 - np.sum((x - y)**2) / np.sum((x - x_bar)**2)
+    return r2
+
+def get_rmse(observations, estimates):
+    return np.sqrt(((estimates - observations) ** 2).mean())
+
+def calculate_R2(y_true, y_pred):
+    """
+    Calculate the R^2 (coefficient of determination).
+
+    Args:
+        y_true (array-like): Actual values of the dependent variable.
+        y_pred (array-like): Predicted values of the dependent variable.
+
+    Returns:
+        float: The R^2 value.
+    """
+    y_true = np.array(y_true)
+    y_pred = np.array(y_pred)
+
+    # Residual sum of squares
+    ss_res = np.sum((y_true - y_pred) ** 2)
+
+    # Total sum of squares
+    ss_tot = np.sum((y_true - np.mean(y_true)) ** 2)
+
+    # R^2 calculation
+    R2 = 1 - (ss_res / ss_tot)
+    return R2

sciml/models.py

@@ -223,13 +223,12 @@ class SmartForest:
 
 """
 # ============================== Test Example ==============================
+import warnings
+import numpy as np
 from sklearn.datasets import load_diabetes
 from sklearn.datasets import fetch_california_housing
 from sklearn.model_selection import train_test_split
-
-
-
-warnings.simplefilter('ignore')
+from sklearn.metrics import mean_squared_error
 
 # X, y = load_diabetes(return_X_y=True) # Using diabetes dataset
 X, y = fetch_california_housing(return_X_y=True) # Using house price dataset
@@ -274,4 +273,524 @@ print("\nFinal RMSE:", rmse)
 # Output best model and RMSE
 best_model, best_rmse = regr.get_best_model()
 print("\nBest validation RMSE:", best_rmse)
-"""
+"""
+
+# ============================================================================================================================================================
+
+import numpy as np
+import copy
+import itertools
+from scipy import ndimage
+from xgboost import XGBRegressor
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import train_test_split
+
+class SmartForest4D:
+    """
+    SmartForest4D is an ensemble learning model designed to handle complex 4D input data 
+    (samples, time, spatial, features). It integrates ideas from gradient-boosted decision trees 
+    (XGBoost) with LSTM-style forget gates and spatial max pooling.
+
+    The model builds layers of regressors, each layer taking the previous output as part of its 
+    input (deep forest style). A forget gate mechanism is applied along the time dimension to 
+    emphasize recent temporal information. Spatial max pooling is used to reduce dimensionality 
+    across spatial units before flattening and feeding into the regressors.
+
+    Parameters:
+    -----------
+    n_estimators_per_layer : int
+        Number of XGBoost regressors per layer.
+
+    max_layers : int
+        Maximum number of layers in the deep forest.
+
+    early_stopping_rounds : int
+        Number of rounds without improvement on the validation set before early stopping.
+
+    param_grid : dict
+        Dictionary of hyperparameter lists to search over for XGBoost.
+
+    use_gpu : bool
+        Whether to use GPU for training XGBoost models.
+
+    gpu_id : int
+        GPU device ID to use if use_gpu is True.
+
+    kernel: np.ndarray
+        Convolutional kernel for spatial processing.
+        # ===============================
+        # 0. Do nothing
+        # ===============================
+
+        identity_kernel = np.array([
+            [0, 0, 0],
+            [0, 1, 0],
+            [0, 0, 0]
+        ])
+
+        # ===============================
+        # 1. Sobel Edge Detection Kernels
+        # ===============================
+
+        sobel_x = np.array([
+            [-1, 0, 1],
+            [-2, 0, 2],
+            [-1, 0, 1]
+        ])
+
+        sobel_y = np.array([
+            [-1, -2, -1],
+            [ 0,  0,  0],
+            [ 1,  2,  1]
+        ])
+
+        # ===============================
+        # 2. Gaussian Blur Kernel (3x3)
+        # ===============================
+        gaussian_kernel = (1/16) * np.array([
+            [1, 2, 1],
+            [2, 4, 2],
+            [1, 2, 1]
+        ])
+
+        # ===============================
+        # 3. Morphological Structuring Element (3x3 cross)
+        # Used in binary dilation/erosion
+        # ===============================
+        morph_kernel = np.array([
+            [0, 1, 0],
+            [1, 1, 1],
+            [0, 1, 0]
+        ])
+
+        # ===============================
+        # 4. Sharpening Kernel
+        # Enhances edges and contrast
+        # ===============================
+        sharpen_kernel = np.array([
+            [ 0, -1,  0],
+            [-1,  5, -1],
+            [ 0, -1,  0]
+        ])
+
+        # ===============================
+        # 5. Embossing Kernel
+        # Creates a 3D-like shadowed effect
+        # ===============================
+        emboss_kernel = np.array([
+            [-2, -1,  0],
+            [-1,  1,  1],
+            [ 0,  1,  2]
+        ])
+
+    spatial_h : int
+        The height of the 2D grid for the flattened spatial dimension.
+
+    spatial_w : int
+        The width of the 2D grid for the flattened spatial dimension.
+    
+    forget_factor : float
+        Exponential decay rate applied along the time axis. Higher values mean stronger forgetting.
+
+    verbose : int
+        Verbosity level for training output.
+
+    Attributes:
+    -----------
+    layers : list
+        List of trained layers, each containing a list of regressors.
+
+    best_model : list
+        The set of layers corresponding to the best validation RMSE seen during training.
+
+    best_rmse : float
+        The lowest RMSE achieved on the validation set.
+
+    Methods:
+    --------
+    fit(X, y, X_val=None, y_val=None):
+        Train the SmartForest4D model on the given 4D input data.
+
+    predict(X):
+        Predict targets for new 4D input data using the trained model.
+
+    get_best_model():
+        Return the best set of layers and corresponding RMSE.
+
+    Notes:
+    ------
+    - The product of spatial_h and spatial_w must equal spatial_size (spatial_h * spatial_w = spatial_size).
+
+    Example:
+    --------
+    >>> model = SmartForest4D(n_estimators_per_layer=5, max_layers=10, early_stopping_rounds=3, forget_factor=0.3, verbose=1)
+    >>> model.fit(X_train, y_train, X_val, y_val)
+    >>> y_pred = model.predict(X_val)
+    >>> best_model, best_rmse = model.get_best_model()
+    """
+    def __init__(self, n_estimators_per_layer=5, max_layers=10, early_stopping_rounds=3, param_grid=None,
+                 use_gpu=False, gpu_id=0, kernel = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]), spatial_h=None, spatial_w=None,
+                 forget_factor=0.0, verbose=1):
+        self.n_estimators_per_layer = n_estimators_per_layer
+        self.max_layers = max_layers
+        self.early_stopping_rounds = early_stopping_rounds
+        self.param_grid = param_grid or {
+            "objective": ["reg:squarederror"],
+            "random_state": [42],
+            'n_estimators': [100],
+            'max_depth': [6],
+            'min_child_weight': [4],
+            'subsample': [0.8],
+            'colsample_bytree': [0.8],
+            'gamma': [0],
+            'reg_alpha': [0],
+            'reg_lambda': [1],
+            'learning_rate': [0.05],
+        }
+        self.use_gpu = use_gpu
+        self.gpu_id = gpu_id
+        self.kernel = kernel
+        self.spatial_h = spatial_h
+        self.spatial_w = spatial_w
+        self.forget_factor = forget_factor
+        self.layers = []
+        self.best_model = None
+        self.best_rmse = float("inf")
+        self.verbose = verbose
+        if (self.spatial_h is None) or (self.spatial_w is None): 
+            raise ValueError("Please specify spatial_h and spatial_w")
+
+    def _get_param_combinations(self):
+        keys, values = zip(*self.param_grid.items())
+        return [dict(zip(keys, v)) for v in itertools.product(*values)]
+
+    def _prepare_input(self, X, y=None, apply_forget=False, layer_index=0):
+        # Ensure 4D: (samples, time, spatial, features)
+        if X.ndim == 2:
+            X = X[:, np.newaxis, np.newaxis, :]
+        elif X.ndim == 3:
+            X = X[:, :, np.newaxis, :]
+        elif X.ndim == 4:
+            pass
+        else:
+            raise ValueError("Input must be 2D, 3D, or 4D.")
+
+        n_samples, n_time, n_spatial, n_features = X.shape
+
+        if apply_forget and self.forget_factor > 0:
+            decay = np.exp(-self.forget_factor * np.arange(n_time))[::-1]
+            decay = decay / decay.sum()
+            decay = decay.reshape(1, n_time, 1, 1)
+            X = X * decay
+
+        # Apply convolutional kernels:
+        if n_spatial != 1:
+            if self.spatial_h * self.spatial_w != n_spatial: raise ValueError("spatial_h * spatial_w != n_spatial")
+            X_out = np.zeros_like(X)
+            for sample in range(X.shape[0]):
+                for t in range(X.shape[1]):
+                    for f in range(X.shape[3]):
+                        spatial_2d = X[sample, t, :, f].reshape(self.spatial_h, self.spatial_w)
+                        # Apply 2D convolution
+                        filtered = ndimage.convolve(spatial_2d, self.kernel, mode='constant', cval=0.0)
+                        # Flatten back to (20,) and store
+                        X_out[sample, t, :, f] = filtered.reshape(n_spatial)
+            X = X_out; del(X_out)
+        # Max pooling over spatial dim
+        X_pooled = X.max(axis=2)  # (samples, time, features)
+        X_flattened = X_pooled.reshape(n_samples, -1)  # (samples, time * features)
+        return X_flattened
+
+    def _fit_layer(self, X, y, X_val=None, y_val=None, layer_index=0):
+        layer = []
+        layer_outputs = []
+        param_combos = self._get_param_combinations()
+
+        for i in range(self.n_estimators_per_layer):
+            best_rmse = float('inf')
+            best_model = None
+
+            for params in param_combos:
+                if self.use_gpu:
+                    params['tree_method'] = 'hist'
+                    params['device'] = 'cuda'
+
+                params = params.copy()
+                params['random_state'] = i
+
+                model = XGBRegressor(**params)
+                model.fit(X, y)
+
+                if X_val is not None:
+                    preds_val = model.predict(X_val)
+                    rmse = np.sqrt(mean_squared_error(y_val, preds_val))
+                    if rmse < best_rmse:
+                        best_rmse = rmse
+                        best_model = model
+                else:
+                    best_model = model
+
+            preds = best_model.predict(X).reshape(-1, 1)
+            layer.append(best_model)
+            layer_outputs.append(preds)
+
+        output = np.hstack(layer_outputs)
+        return layer, output
+
+    def fit(self, X, y, X_val=None, y_val=None):
+        y = y.ravel()
+        X_current = self._prepare_input(X, apply_forget=True)
+        X_val_current = self._prepare_input(X_val, apply_forget=True) if X_val is not None else None
+
+        no_improve_rounds = 0
+
+        for layer_index in range(self.max_layers):
+            if self.verbose:
+                print(f"Training Layer {layer_index + 1}")
+
+            layer, output = self._fit_layer(X_current, y, X_val_current, y_val, layer_index)
+            self.layers.append(layer)
+            X_current = np.hstack([X_current, output])
+
+            if X_val is not None:
+                val_outputs = []
+                for reg in layer:
+                    n_features = reg.n_features_in_
+                    preds = reg.predict(X_val_current[:, :n_features]).reshape(-1, 1)
+                    val_outputs.append(preds)
+                val_output = np.hstack(val_outputs)
+                X_val_current = np.hstack([X_val_current, val_output])
+
+                y_pred = self.predict(X_val)
+                rmse = np.sqrt(mean_squared_error(y_val, y_pred))
+                if self.verbose:
+                    print(f"Validation RMSE: {rmse:.4f}")
+
+                if rmse < self.best_rmse:
+                    self.best_rmse = rmse
+                    self.best_model = copy.deepcopy(self.layers)
+                    no_improve_rounds = 0
+                    if self.verbose:
+                        print(f"✅ New best RMSE: {self.best_rmse:.4f}")
+                else:
+                    no_improve_rounds += 1
+                    if no_improve_rounds >= self.early_stopping_rounds:
+                        if self.verbose:
+                            print("Early stopping triggered.")
+                        break
+
+    def predict(self, X):
+        X_current = self._prepare_input(X, apply_forget=True)
+
+        for layer in self.layers:
+            layer_outputs = []
+            for reg in layer:
+                n_features = reg.n_features_in_
+                preds = reg.predict(X_current[:, :n_features]).reshape(-1, 1)
+                layer_outputs.append(preds)
+            output = np.hstack(layer_outputs)
+            X_current = np.hstack([X_current, output])
+
+        final_outputs = []
+        for reg in self.layers[-1]:
+            n_features = reg.n_features_in_
+            final_outputs.append(reg.predict(X_current[:, :n_features]).reshape(-1, 1))
+        return np.mean(np.hstack(final_outputs), axis=1)
+
+    def get_best_model(self):
+        return self.best_model, self.best_rmse
+
+"""
+# ============================== Test Example ==============================
+import numpy as np
+import copy
+import itertools
+from scipy import ndimage
+from xgboost import XGBRegressor
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import train_test_split
+
+# Generate synthetic 4D data: (samples, time, spatial, features)
+# time order is like [t (today), t - 1 (yesterday), t -2, ...]
+n_samples = 200
+n_time = 5
+n_spatial = 4
+n_features = 5
+
+np.random.seed(42)
+X = np.random.rand(n_samples, n_time, n_spatial, n_features)
+y = X[:, :3, :2, :4].mean(axis=(1, 2, 3)) + 0.1 * np.random.randn(n_samples)
+y = y.ravel()
+
+# Split
+X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Train model
+model = SmartForest4D(
+    n_estimators_per_layer=5,
+    max_layers=20,
+    early_stopping_rounds=5,
+    spatial_h = 2, 
+    spatial_w = 2,
+    forget_factor=0.1,
+    verbose=1
+)
+model.fit(X_train, y_train, X_val, y_val)
+
+# Predict
+y_pred = model.predict(X_val)
+rmse = np.sqrt(mean_squared_error(y_val, y_pred))
+print("\n✅ Final RMSE on validation set:", rmse)
+
+
+# Output best model and RMSE
+best_model, best_rmse = model.get_best_model()
+print("\nBest validation RMSE:", best_rmse)
+"""
+
+# ============================================================================================================================================================
+# Function mode
+
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.models import load_model
+
+def srcnn(learning_rate=0.001):
+    """
+    Builds and compiles a Super-Resolution Convolutional Neural Network (SRCNN) model 
+    that fuses features from both low-resolution and high-resolution images.
+
+    This model uses two parallel input streams:
+    - A low-resolution input which undergoes upscaling through convolutional layers.
+    - A high-resolution input from which texture features are extracted and fused with the low-resolution stream.
+
+    Args:
+        save_path (str, optional): Path to save the compiled model. If None, the model is not saved.
+        learning_rate (float): Learning rate for the Adam optimizer.
+
+    Returns:
+        keras.Model: A compiled Keras model ready for training.
+    """
+    # Input layers
+    lowres_input = layers.Input(shape=(None, None, 1))  # Low-resolution input
+    highres_input = layers.Input(shape=(None, None, 1))  # High-resolution image
+
+    # Feature extraction from high-resolution image
+    highres_features = layers.Conv2D(64, (3, 3), activation="relu", padding="same")(highres_input)
+    highres_features = layers.Conv2D(128, (3, 3), activation="relu", padding="same")(highres_features)
+
+    # Processing low-resoltuion input
+    x = layers.Conv2D(64, (3, 3), activation="relu", padding="same")(lowres_input)
+    x = layers.Conv2D(128, (3, 3), activation="relu", padding="same")(x)
+
+    # Fusion of high-resolution image textures
+    fusion = layers.Concatenate()([x, highres_features])
+    fusion = layers.Conv2D(128, (3, 3), activation="relu", padding="same")(fusion)
+    fusion = layers.Conv2D(64, (3, 3), activation="relu", padding="same")(fusion)
+
+    # Output
+    output = layers.Conv2D(1, (3, 3), activation="sigmoid", padding="same")(fusion)
+
+    model = keras.Model(inputs=[lowres_input, highres_input], outputs=output)
+    model.compile(optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss="mse")
+
+    return model
+
+def print_model(model):
+    return model.summary()
+
+def train(lowres_data, highres_data, epochs=100, batch_size=1, verbose=1, save_path=None):
+    model = srcnn()
+    # Train SRCNN
+    model.fit([modis_data_1, s2_data], s2_data, epochs=epochs, batch_size=batch_size, verbose=verbose)
+    # Save the complete model
+    # Recommended in newer versions of Keras (TensorFlow 2.11+): e.g., 'texture_fusion_model.keras'
+    if save_path: model.save(save_path)
+
+def apply(model, lowres_data_app, highres_data):
+    super_resolved = model.predict([lowres_data_app, highres_data]).squeeze() 
+    super_resolved = xr.DataArray(
+        super_resolved, 
+        dims = ("latitude", "longitude"), 
+        coords={"latitude": highres_data.latitude, "longitude": highres_data.longitude}, 
+        name="super_res"
+    )
+    return super_resolved
+
+def load_model(save_path):
+    model = load_model('texture_fusion_model.keras') 
+
+# ------------------------------------------------------------------------------------------------------------------------------------------------------------
+# Class mode
+
+import numpy as np
+import xarray as xr
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.callbacks import EarlyStopping
+
+class TextureFusionSRCNN:
+    def __init__(self, learning_rate=0.001):
+        self.learning_rate = learning_rate
+        self.model = self._build_model()
+
+    def _build_model(self):
+        # Input layers
+        lowres_input = layers.Input(shape=(None, None, 1))  # Low-resolution input
+        highres_input = layers.Input(shape=(None, None, 1))  # High-resolution image
+
+        # Feature extraction from high-resolution image
+        highres_features = layers.Conv2D(64, (3, 3), activation="relu", padding="same")(highres_input)
+        highres_features = layers.Conv2D(128, (3, 3), activation="relu", padding="same")(highres_features)
+
+        # Processing low-resolution input
+        x = layers.Conv2D(64, (3, 3), activation="relu", padding="same")(lowres_input)
+        x = layers.Conv2D(128, (3, 3), activation="relu", padding="same")(x)
+
+        # Fusion of high-resolution image textures
+        fusion = layers.Concatenate()([x, highres_features])
+        fusion = layers.Conv2D(128, (3, 3), activation="relu", padding="same")(fusion)
+        fusion = layers.Conv2D(64, (3, 3), activation="relu", padding="same")(fusion)
+
+        # Output
+        output = layers.Conv2D(1, (3, 3), activation="sigmoid", padding="same")(fusion)
+
+        model = keras.Model(inputs=[lowres_input, highres_input], outputs=output)
+        model.compile(optimizer=keras.optimizers.Adam(learning_rate=self.learning_rate), loss="mse")
+
+        return model
+
+    def summary(self):
+        return self.model.summary()
+
+    def train(self, lowres_data, highres_data, epochs=100, batch_size=1, verbose=1, save_path=None):
+        early_stop = EarlyStopping(
+            monitor='loss',       # You can change to 'val_loss' if you add validation
+            patience=10,          # Number of epochs with no improvement after which training will be stopped
+            restore_best_weights=True
+        )
+
+        self.model.fit(
+            [lowres_data, highres_data], highres_data,
+            epochs=epochs,
+            batch_size=batch_size,
+            verbose=verbose,
+            callbacks=[early_stop]
+        )
+
+        if save_path:
+            self.model.save(save_path)
+
+    def apply(self, lowres_data_app, highres_data):
+        super_resolved = self.model.predict([lowres_data_app, highres_data]).squeeze()
+        return super_resolved
+
+    @staticmethod
+    def load(save_path):
+        model = keras.models.load_model(save_path)
+        instance = TextureFusionSRCNN()
+        instance.model = model
+        return instance
+

sciml/pipelines.py

@@ -155,7 +155,7 @@ try:
     from tensorflow.keras import models
     # from keras.layers import Dropout
     from keras.callbacks import EarlyStopping
-    from scitbx.stutils import *
+    from scitbx.utils import *
 except Exception as e:
     print(e)
 
@@ -173,263 +173,54 @@ def train_lstm(X_train, y_train, nfeature, ntime, verbose = 2, epochs = 200, bat
     model.fit(X_train, y_train, epochs = epochs, batch_size = batch_size, verbose=verbose)
     return model
 
-
-'''
-# ========================================================================================================
-import numpy as np
-from xgboost import XGBRegressor
-from sklearn.metrics import mean_squared_error
-
-class XGBoostDeepForestRegressor:
-    def __init__(self, n_estimators_per_layer=2, max_layers=20, early_stopping_rounds=2):
-        self.n_estimators_per_layer = n_estimators_per_layer
-        self.max_layers = max_layers
-        self.early_stopping_rounds = early_stopping_rounds
-        self.layers = []
-
-    def _fit_layer(self, X, y):
-        layer = []
-        layer_outputs = []
-        for _ in range(self.n_estimators_per_layer):
-            reg = XGBRegressor()
-            reg.fit(X, y)
-            preds = reg.predict(X).reshape(-1, 1)
-            layer.append(reg)
-            layer_outputs.append(preds)
-        output = np.hstack(layer_outputs)
-        return layer, output
-
-    def fit(self, X, y, X_val=None, y_val=None):
-        X_current = X.copy()
-        best_rmse = float("inf")
-        no_improve_rounds = 0
-
-        for layer_index in range(self.max_layers):
-            print(f"Training Layer {layer_index + 1}")
-            layer, output = self._fit_layer(X_current, y)
-            self.layers.append(layer)
-            X_current = np.hstack([X_current, output])
-
-            if X_val is not None:
-                y_pred = self.predict(X_val)
-                # rmse = mean_squared_error(y_val, y_pred, squared=False)
-                rmse = np.sqrt(mean_squared_error(y_val, y_pred))
-                print(f"Validation RMSE: {rmse:.4f}")
-
-                if rmse < best_rmse:
-                    best_rmse = rmse
-                    no_improve_rounds = 0
-                else:
-                    no_improve_rounds += 1
-                    if no_improve_rounds >= self.early_stopping_rounds:
-                        print("Early stopping triggered.")
-                        break
-
-    def predict(self, X):
-        X_current = X.copy()
-        for layer in self.layers:
-            layer_outputs = []
-            for reg in layer:
-                n_features = reg.n_features_in_
-                preds = reg.predict(X_current[:, :n_features]).reshape(-1, 1)
-                layer_outputs.append(preds)
-            output = np.hstack(layer_outputs)
-            X_current = np.hstack([X_current, output])
-
-        # Final prediction = average of last layer regressors
-        final_outputs = []
-        for reg in self.layers[-1]:
-            n_features = reg.n_features_in_
-            final_outputs.append(reg.predict(X_current[:, :n_features]).reshape(-1, 1))
-        return np.mean(np.hstack(final_outputs), axis=1)
-
-
-from sklearn.datasets import load_diabetes
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import mean_squared_error
-
-X, y = load_diabetes(return_X_y=True)
-X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=42)
-
-df_reg = XGBoostDeepForestRegressor(n_estimators_per_layer=2, max_layers=5)
-df_reg.fit(X_train, y_train, X_val, y_val)
-
-y_pred = df_reg.predict(X_val)
-# rmse = mean_squared_error(y_val, y_pred, squared=False)
-rmse = np.sqrt(mean_squared_error(y_val, y_pred))
-print("Final RMSE:", rmse)
-
-# ----------------------------------------------------------------------------------------------------
-
+# ===============================================================================================================================
+# Training utils
 import numpy as np
-from xgboost import XGBRegressor
-from sklearn.metrics import mean_squared_error
-import itertools
-
-class XGBoostDeepForestRegressor:
-    def __init__(self, n_estimators_per_layer=2, max_layers=20, early_stopping_rounds=2, param_grid=None, use_gpu=True, gpu_id=0):
-        self.n_estimators_per_layer = n_estimators_per_layer
-        self.max_layers = max_layers
-        self.early_stopping_rounds = early_stopping_rounds
-        self.param_grid = param_grid or {
-            'max_depth': [3],
-            'learning_rate': [0.1],
-            'n_estimators': [100]
-        }
-        self.use_gpu = use_gpu
-        self.gpu_id = gpu_id
-        self.layers = []
-
-    def _get_param_combinations(self):
-        keys, values = zip(*self.param_grid.items())
-        return [dict(zip(keys, v)) for v in itertools.product(*values)]
-
-    def _fit_layer(self, X, y, X_val=None, y_val=None):
-        layer = []
-        layer_outputs = []
-        param_combos = self._get_param_combinations()
-
-        for i in range(self.n_estimators_per_layer):
-            best_rmse = float('inf')
-            best_model = None
-
-            for params in param_combos:
-                # Set GPU support parameters in XGBRegressor
-                if self.use_gpu:
-                    params['tree_method'] = 'hist'  # Use hist method
-                    params['device'] = 'cuda'  # Enable CUDA for GPU
-
-                model = XGBRegressor(**params)
-                model.fit(X, y)
-
-                if X_val is not None:
-                    preds_val = model.predict(X_val)
-                    rmse = np.sqrt(mean_squared_error(y_val, preds_val))
-                    if rmse < best_rmse:
-                        best_rmse = rmse
-                        best_model = model
-                else:
-                    best_model = model
-
-            final_model = best_model
-            preds = final_model.predict(X).reshape(-1, 1)
-            layer.append(final_model)
-            layer_outputs.append(preds)
-
-        output = np.hstack(layer_outputs)
-        return layer, output
-
-    def fit(self, X, y, X_val=None, y_val=None):
-        X_current = X.copy()
-        X_val_current = X_val.copy() if X_val is not None else None
-
-        best_rmse = float("inf")
-        no_improve_rounds = 0
-
-        for layer_index in range(self.max_layers):
-            print(f"Training Layer {layer_index + 1}")
-            layer, output = self._fit_layer(X_current, y, X_val_current, y_val)
-            self.layers.append(layer)
-            X_current = np.hstack([X_current, output])
-
-            if X_val is not None:
-                val_outputs = []
-                for reg in layer:
-                    n_features = reg.n_features_in_
-                    preds = reg.predict(X_val_current[:, :n_features]).reshape(-1, 1)
-                    val_outputs.append(preds)
-                val_output = np.hstack(val_outputs)
-                X_val_current = np.hstack([X_val_current, val_output])
-
-                y_pred = self.predict(X_val)
-                rmse = np.sqrt(mean_squared_error(y_val, y_pred))
-                print(f"Validation RMSE: {rmse:.4f}")
-
-                if rmse < best_rmse:
-                    best_rmse = rmse
-                    no_improve_rounds = 0
-                else:
-                    no_improve_rounds += 1
-                    if no_improve_rounds >= self.early_stopping_rounds:
-                        print("Early stopping triggered.")
-                        break
-
-    def predict(self, X):
-        X_current = X.copy()
-        for layer in self.layers:
-            layer_outputs = []
-            for reg in layer:
-                n_features = reg.n_features_in_
-                preds = reg.predict(X_current[:, :n_features]).reshape(-1, 1)
-                layer_outputs.append(preds)
-            output = np.hstack(layer_outputs)
-            X_current = np.hstack([X_current, output])
-
-        final_outputs = []
-        for reg in self.layers[-1]:
-            n_features = reg.n_features_in_
-            final_outputs.append(reg.predict(X_current[:, :n_features]).reshape(-1, 1))
-        return np.mean(np.hstack(final_outputs), axis=1)
-
-
-from sklearn.datasets import load_diabetes
+import pandas as pd
+from sklearn.model_selection import ShuffleSplit
 from sklearn.model_selection import train_test_split
-from sklearn.metrics import mean_squared_error
-
-# Load dataset
-X, y = load_diabetes(return_X_y=True)
-X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=42)
-
-# Hyperparameter grid
-param_grid = {
-    'max_depth': [3, 4],
-    'learning_rate': [0.1, 0.05],
-    'n_estimators': [50, 100]
-}
-
-# Create and fit the model with GPU enabled
-df_reg = XGBoostDeepForestRegressor(
-    n_estimators_per_layer=2,
-    max_layers=5,
-    early_stopping_rounds=2,
-    param_grid=param_grid,
-    use_gpu=True,  # Enable GPU acceleration
-    gpu_id=0  # Default to the first GPU
-)
-
-df_reg.fit(X_train, y_train, X_val, y_val)
-
-# Final evaluation
-y_pred = df_reg.predict(X_val)
-rmse = np.sqrt(mean_squared_error(y_val, y_pred))
-print("Final RMSE:", rmse)
-
-# ----------------------------------------------------------------------------------------------------
-
-xgb_params = {
-    "objective": "reg:squarederror",
-    "random_state": 0,
-    'seed': 0,
-    'n_estimators': 100,
-    'max_depth': 6, 
-    'min_child_weight': 4, 
-    'subsample': 0.8, 
-    'colsample_bytree': 0.8, 
-    'gamma': 0, 
-    'reg_alpha': 0, 
-    'reg_lambda': 1,
-    'learning_rate': 0.05, 
-}
 
-from xgboost import XGBRegressor
-regr = XGBRegressor(**xgb_params)
-
-regr.fit(X_train, y_train)
-y_pred = regr.predict(X_val)
-
-
-from scipy import stats
+# randomly select sites
+def random_select(ds, count, num, random_state = 0):
+    np.random.seed(random_state)
+    idxs = np.random.choice(np.delete(np.arange(len(ds)), count), num, replace = False)
+    return np.sort(idxs)
+
+def split(Xs, ys, return_index = False, test_size = 0.33, random_state = 42):
+    if return_index:
+        sss = ShuffleSplit(n_splits=1, test_size = test_size, random_state = random_state)
+        sss.get_n_splits(Xs, ys)
+        train_index, test_index = next(sss.split(Xs, ys)) 
+        return (train_index, test_index)
+    else:
+        X_train, X_test, y_train, y_test = train_test_split(
+            Xs, ys, 
+            test_size = test_size, 
+            random_state = random_state
+        )
+        return (X_train, X_test, y_train, y_test)
+    
+def split_cut(Xs, ys, test_ratio = 0.33):
+    """
+    Split the timeseries into before and after halves
+    """
+    assert ys.ndim == 2, 'ys must be 2D!'
+    assert len(Xs) == len(ys), 'Xs and ys should be equally long!'
+    assert type(Xs) == type(ys), 'Xs and ys should be the same data type!'
+    if not type(Xs) in [pd.core.frame.DataFrame, np.ndarray]: raise Exception('Only accept numpy ndarray or pandas dataframe')
+    anchor = int(np.floor(len(ys) * (1 - test_ratio)))
+
+    if type(Xs) == pd.core.frame.DataFrame:
+        X_train = Xs.iloc[0: anchor, :]
+        X_test = Xs.iloc[anchor::, :]
+        y_train = ys.iloc[0: anchor, :]
+        y_test = ys.iloc[anchor::, :]
+    else:
+        X_train = Xs[0: anchor, :]
+        X_test = Xs[anchor::, :]
+        y_train = ys[0: anchor, :]
+        y_test = ys[anchor::, :]
 
-stats.linregress(y_val, y_pred)
+    assert len(X_train) + len(X_test) == len(Xs), 'The sum of train and test lengths must equal to Xs/ys!'
 
-'''
+    return (X_train, X_test, y_train, y_test)

sciml/regress2.py

@@ -0,0 +1,217 @@
+# Model type I and II regression, including RMA (reduced major axis regression)
+
+"""
+Credit: UMaine MISC Lab; emmanuel.boss@maine.edu
+http://misclab.umeoce.maine.edu/
+https://github.com/OceanOptics
+------------------------------------------------------------------------------
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import statsmodels.api as sm
+import numpy as np
+
+
+def regress2(_x, _y, _method_type_1 = "ordinary least square",
+             _method_type_2 = "reduced major axis",
+             _weight_x = [], _weight_y = [], _need_intercept = True):
+    # Regression Type II based on statsmodels
+    # Type II regressions are recommended if there is variability on both x and y
+    # It's computing the linear regression type I for (x,y) and (y,x)
+    # and then average relationship with one of the type II methods
+    #
+    # INPUT:
+    #   _x <np.array>
+    #   _y <np.array>
+    #   _method_type_1 <str> method to use for regression type I:
+    #     ordinary least square or OLS <default>
+    #     weighted least square or WLS
+    #     robust linear model or RLM
+    #   _method_type_2 <str> method to use for regression type II:
+    #     major axis
+    #     reduced major axis <default> (also known as geometric mean)
+    #     arithmetic mean
+    #   _need_intercept <bool>
+    #     True <default> add a constant to relation (y = a x + b)
+    #     False force relation by 0 (y = a x)
+    #   _weight_x <np.array> containing the weigth of x
+    #   _weigth_y <np.array> containing the weigth of y
+    #
+    # OUTPUT:
+    #   slope
+    #   intercept
+    #   r
+    #   std_slope
+    #   std_intercept
+    #   predict
+    #
+    # REQUIRE:
+    #   numpy
+    #   statsmodels
+    #
+    # The code is based on the matlab function of MBARI.
+    # AUTHOR: Nils Haentjens
+    # REFERENCE: https://www.mbari.org/products/research-software/matlab-scripts-linear-regressions/
+
+    # Check input
+    if _method_type_2 != "reduced major axis" and _method_type_1 != "ordinary least square":
+        raise ValueError("'" + _method_type_2 + "' only supports '" + _method_type_1 + "' method as type 1.")
+
+    # Set x, y depending on intercept requirement
+    if _need_intercept:
+        x_intercept = sm.add_constant(_x)
+        y_intercept = sm.add_constant(_y)
+
+    # Compute Regression Type I (if type II requires it)
+    if (_method_type_2 == "reduced major axis" or
+        _method_type_2 == "geometric mean"):
+        if _method_type_1 == "OLS" or _method_type_1 == "ordinary least square":
+            if _need_intercept:
+                [intercept_a, slope_a] = sm.OLS(_y, x_intercept).fit().params
+                [intercept_b, slope_b] = sm.OLS(_x, y_intercept).fit().params
+            else:
+                slope_a = sm.OLS(_y, _x).fit().params
+                slope_b = sm.OLS(_x, _y).fit().params
+        elif _method_type_1 == "WLS" or _method_type_1 == "weighted least square":
+            if _need_intercept:
+                [intercept_a, slope_a] = sm.WLS(
+                    _y, x_intercept, weights=1. / _weight_y).fit().params
+                [intercept_b, slope_b] = sm.WLS(
+                    _x, y_intercept, weights=1. / _weight_x).fit().params
+            else:
+                slope_a = sm.WLS(_y, _x, weights=1. / _weight_y).fit().params
+                slope_b = sm.WLS(_x, _y, weights=1. / _weight_x).fit().params
+        elif _method_type_1 == "RLM" or _method_type_1 == "robust linear model":
+            if _need_intercept:
+                [intercept_a, slope_a] = sm.RLM(_y, x_intercept).fit().params
+                [intercept_b, slope_b] = sm.RLM(_x, y_intercept).fit().params
+            else:
+                slope_a = sm.RLM(_y, _x).fit().params
+                slope_b = sm.RLM(_x, _y).fit().params
+        else:
+            raise ValueError("Invalid literal for _method_type_1: " + _method_type_1)
+
+    # Compute Regression Type II
+    if (_method_type_2 == "reduced major axis" or
+        _method_type_2 == "geometric mean"):
+        # Transpose coefficients
+        if _need_intercept:
+            intercept_b = -intercept_b / slope_b
+        slope_b = 1 / slope_b
+        # Check if correlated in same direction
+        if np.sign(slope_a) != np.sign(slope_b):
+            raise RuntimeError('Type I regressions of opposite sign.')
+        # Compute Reduced Major Axis Slope
+        slope = np.sign(slope_a) * np.sqrt(slope_a * slope_b)
+        if _need_intercept:
+            # Compute Intercept (use mean for least square)
+            if _method_type_1 == "OLS" or _method_type_1 == "ordinary least square":
+                intercept = np.mean(_y) - slope * np.mean(_x)
+            else:
+                intercept = np.median(_y) - slope * np.median(_x)
+        else:
+            intercept = 0
+        # Compute r
+        r = np.sign(slope_a) * np.sqrt(slope_a / slope_b)
+        # Compute predicted values
+        predict = slope * _x + intercept
+        # Compute standard deviation of the slope and the intercept
+        n = len(_x)
+        diff = _y - predict
+        Sx2 = np.sum(np.multiply(_x, _x))
+        den = n * Sx2 - np.sum(_x) ** 2
+        s2 = np.sum(np.multiply(diff, diff)) / (n - 2)
+        std_slope = np.sqrt(n * s2 / den)
+        if _need_intercept:
+            std_intercept = np.sqrt(Sx2 * s2 / den)
+        else:
+            std_intercept = 0
+    elif (_method_type_2 == "Pearson's major axis" or
+          _method_type_2 == "major axis"):
+        if not _need_intercept:
+            raise ValueError("Invalid value for _need_intercept: " + str(_need_intercept))
+        xm = np.mean(_x)
+        ym = np.mean(_y)
+        xp = _x - xm
+        yp = _y - ym
+        sumx2 = np.sum(np.multiply(xp, xp))
+        sumy2 = np.sum(np.multiply(yp, yp))
+        sumxy = np.sum(np.multiply(xp, yp))
+        slope = ((sumy2 - sumx2 + np.sqrt((sumy2 - sumx2)**2 + 4 * sumxy**2)) /
+                 (2 * sumxy))
+        intercept = ym - slope * xm
+        # Compute r
+        r = sumxy / np.sqrt(sumx2 * sumy2)
+        # Compute standard deviation of the slope and the intercept
+        n = len(_x)
+        std_slope = (slope / r) * np.sqrt((1 - r ** 2) / n)
+        sigx = np.sqrt(sumx2 / (n - 1))
+        sigy = np.sqrt(sumy2 / (n - 1))
+        std_i1 = (sigy - sigx * slope) ** 2
+        std_i2 = (2 * sigx * sigy) + ((xm ** 2 * slope * (1 + r)) / r ** 2)
+        std_intercept = np.sqrt((std_i1 + ((1 - r) * slope * std_i2)) / n)
+        # Compute predicted values
+        predict = slope * _x + intercept
+    elif _method_type_2 == "arithmetic mean":
+        if not _need_intercept:
+            raise ValueError("Invalid value for _need_intercept: " + str(_need_intercept))
+        n = len(_x)
+        sg = np.floor(n / 2)
+        # Sort x and y in order of x
+        sorted_index = sorted(range(len(_x)), key=lambda i: _x[i])
+        x_w = np.array([_x[i] for i in sorted_index])
+        y_w = np.array([_y[i] for i in sorted_index])
+        x1 = x_w[1:sg + 1]
+        x2 = x_w[sg:n]
+        y1 = y_w[1:sg + 1]
+        y2 = y_w[sg:n]
+        x1m = np.mean(x1)
+        x2m = np.mean(x2)
+        y1m = np.mean(y1)
+        y2m = np.mean(y2)
+        xm = (x1m + x2m) / 2
+        ym = (y1m + y2m) / 2
+        slope = (x2m - x1m) / (y2m - y1m)
+        intercept = ym - xm * slope
+        # r (to verify)
+        r = []
+        # Compute predicted values
+        predict = slope * _x + intercept
+        # Compute standard deviation of the slope and the intercept
+        std_slope = []
+        std_intercept = []
+
+    # Return all that
+    return {"slope": float(slope), "intercept": intercept, "r": r,
+            "std_slope": std_slope, "std_intercept": std_intercept,
+            "predict": predict}
+
+
+# if __name__ == '__main__':
+#     x = np.linspace(0, 10, 100)
+#     # Add random error on y
+#     e = np.random.normal(size=len(x))
+#     y = x + e
+#     results = regress2(x, y, _method_type_2="reduced major axis",
+#                        _need_intercept=False)
+#     # print(results)

{sciml-0.0.9.dist-info → sciml-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciml
-Version: 0.0.9
+Version: 0.0.11
 Summary: draw and basic calculations/conversions
 Home-page: https://github.com/soonyenju/sciml
 Author: Songyan Zhu

sciml-0.0.11.dist-info/RECORD

@@ -0,0 +1,11 @@
+sciml/__init__.py,sha256=OglTSUWcPOHOFqTObFkbwIpv-ZStEl-iMHRZG9aT2pU,80
+sciml/ccc.py,sha256=uQryOK1y2w3iLPhC2AScXFfbcvc5gMXjRAibYD38GkQ,1245
+sciml/metrics.py,sha256=wLO1bka7GeXEbMT-w3ZZAwFt1TH0A4U3wf1-TkGtDuM,3699
+sciml/models.py,sha256=UD8wOOJTeVrjzHM_OZmfNIGq32l4g4-6ZZoPwodcMhU,30104
+sciml/pipelines.py,sha256=vhWbyoOi7-7F7v65ShMFi0aEBj08JhjHh-JDAxdc65c,8606
+sciml/regress2.py,sha256=GvD3eQPRdzNSvOBhdcKd08NDg56CHlNZSQgwx5aN_bY,9194
+sciml-0.0.11.dist-info/LICENSE,sha256=hcunSTJmVgRcUNOa1rKl8axtY3Jsy2B4wXDYtQsrAt0,1081
+sciml-0.0.11.dist-info/METADATA,sha256=1FCJe3TgTnVW2jQLKfP0CRf2u2ghuJF1P-2dPWOjExg,327
+sciml-0.0.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sciml-0.0.11.dist-info/top_level.txt,sha256=dS_7aBCZFKQE3myPy5sh4USjQZCZyGg382-YxUUYcdw,6
+sciml-0.0.11.dist-info/RECORD,,

sciml/utils.py

@@ -1,46 +0,0 @@
-import numpy as np
-import pandas as pd
-from sklearn.model_selection import ShuffleSplit
-from sklearn.model_selection import train_test_split
-
-# randomly select sites
-def random_select(ds, count, num, random_state = 0):
-    np.random.seed(random_state)
-    idxs = np.random.choice(np.delete(np.arange(len(ds)), count), num, replace = False)
-    return np.sort(idxs)
-
-def split(Xs, ys, return_index = False, test_size = 0.33, random_state = 42):
-    if return_index:
-        sss = ShuffleSplit(n_splits=1, test_size = test_size, random_state = random_state)
-        sss.get_n_splits(Xs, ys)
-        train_index, test_index = next(sss.split(Xs, ys)) 
-        return (train_index, test_index)
-    else:
-        X_train, X_test, y_train, y_test = train_test_split(
-            Xs, ys, 
-            test_size = test_size, 
-            random_state = random_state
-        )
-        return (X_train, X_test, y_train, y_test)
-    
-def split_cut(Xs, ys, test_ratio = 0.33):
-    assert ys.ndim == 2, 'ys must be 2D!'
-    assert len(Xs) == len(ys), 'Xs and ys should be equally long!'
-    assert type(Xs) == type(ys), 'Xs and ys should be the same data type!'
-    if not type(Xs) in [pd.core.frame.DataFrame, np.ndarray]: raise Exception('Only accept numpy ndarray or pandas dataframe')
-    anchor = int(np.floor(len(ys) * (1 - test_ratio)))
-
-    if type(Xs) == pd.core.frame.DataFrame:
-        X_train = Xs.iloc[0: anchor, :]
-        X_test = Xs.iloc[anchor::, :]
-        y_train = ys.iloc[0: anchor, :]
-        y_test = ys.iloc[anchor::, :]
-    else:
-        X_train = Xs[0: anchor, :]
-        X_test = Xs[anchor::, :]
-        y_train = ys[0: anchor, :]
-        y_test = ys[anchor::, :]
-
-    assert len(X_train) + len(X_test) == len(Xs), 'The sum of train and test lengths must equal to Xs/ys!'
-
-    return (X_train, X_test, y_train, y_test)

sciml-0.0.9.dist-info/RECORD

@@ -1,9 +0,0 @@
-sciml/__init__.py,sha256=wtdlXERN2ik7NT_TQxFdd2gdodBY9vSU1ClSdeJnLm4,59
-sciml/models.py,sha256=BjbliW-KNfzbNdGNgM7nBdJ2SF2z21qCoAvug_v0FEg,10574
-sciml/pipelines.py,sha256=ReNEkQbdFn04D5G2tbxcA7jdSwACy8SnmZ8bFZI_oqE,15702
-sciml/utils.py,sha256=qCdABaTUu3K0R269jI7D_8SO6AqEjphg03CzdxCJR2k,1876
-sciml-0.0.9.dist-info/LICENSE,sha256=hcunSTJmVgRcUNOa1rKl8axtY3Jsy2B4wXDYtQsrAt0,1081
-sciml-0.0.9.dist-info/METADATA,sha256=S5hG3pP3x4yDPe8AJOKn4R-fIuvL-DL1GSKqGqiImSw,326
-sciml-0.0.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sciml-0.0.9.dist-info/top_level.txt,sha256=dS_7aBCZFKQE3myPy5sh4USjQZCZyGg382-YxUUYcdw,6
-sciml-0.0.9.dist-info/RECORD,,