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

sciml/__init__.py

@@ -1,2 +1,2 @@
-# coding: utf-8
-__all__ = ["utils", "pipelines", "models"]
+# coding: utf-8
+__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