PyEvoMotion 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

share/analyze_test_runs.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""
+Analyze parameter variability across multiple PyEvoMotion runs.
+
+This script loads regression results from multiple runs and creates
+violin plots to visualize parameter distributions and assess
+reproducibility of the nonlinear fitting process.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, List
+
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import numpy as np
+import pandas as pd
+
+
+def set_matplotlib_params():
+    """Set consistent matplotlib styling."""
+    mpl_params = {
+        "font.sans-serif": "Helvetica",
+        "axes.linewidth": 2,
+        "axes.labelsize": 14,
+        "axes.spines.top": False,
+        "axes.spines.right": False,
+        "font.size": 12,
+        "xtick.major.width": 2,
+        "ytick.major.width": 2,
+        "xtick.major.size": 6,
+        "ytick.major.size": 6,
+        "legend.frameon": False,
+    }
+    for k, v in mpl_params.items():
+        mpl.rcParams[k] = v
+
+
+def load_regression_results(base_dir: Path, country: str, num_runs: int = 5) -> List[Dict]:
+    """
+    Load regression results from multiple runs.
+    
+    :param base_dir: Base directory containing run subdirectories
+    :type base_dir: Path
+    :param country: Either "UK" or "USA"
+    :type country: str
+    :param num_runs: Number of runs to load (default 5)
+    :type num_runs: int
+    :return: List of dictionaries containing regression results
+    :rtype: List[Dict]
+    """
+    results = []
+    
+    for run_num in range(1, num_runs + 1):
+        run_dir = base_dir / f"{country}_run{run_num}"
+        results_file = run_dir / f"fig{country}_regression_results.json"
+        
+        if results_file.exists():
+            with open(results_file, 'r') as f:
+                data = json.load(f)
+                results.append({
+                    'run': run_num,
+                    'country': country,
+                    'data': data
+                })
+        else:
+            print(f"Warning: {results_file} not found")
+    
+    return results
+
+
+def extract_parameters(results: List[Dict]) -> pd.DataFrame:
+    """
+    Extract parameters from regression results into a DataFrame.
+    
+    :param results: List of regression result dictionaries
+    :type results: List[Dict]
+    :return: DataFrame with parameters from all runs
+    :rtype: pd.DataFrame
+    """
+    records = []
+    
+    for result in results:
+        run = result['run']
+        country = result['country']
+        data = result['data']
+        
+        record = {
+            'run': run,
+            'country': country
+        }
+        
+        # Extract mean model parameters
+        mean_key = None
+        for key in ["mean number of mutations model", 
+                    "mean number of mutations per 7D model",
+                    "mean number of substitutions model"]:
+            if key in data:
+                mean_key = key
+                break
+        
+        if mean_key:
+            mean_model = data[mean_key]
+            record['mean_m'] = mean_model['parameters']['m']
+            record['mean_b'] = mean_model['parameters']['b']
+            record['mean_r2'] = mean_model['r2']
+        
+        # Extract variance model parameters
+        var_key = None
+        for key in ["scaled var number of mutations model",
+                    "scaled var number of mutations per 7D model",
+                    "scaled var number of substitutions model"]:
+            if key in data:
+                var_key = key
+                break
+        
+        if var_key:
+            var_model = data[var_key]
+            
+            # Check if model selection was performed
+            if "model_selection" in var_model:
+                selected = var_model["model_selection"]["selected"]
+                record['var_model_selected'] = selected
+                
+                if selected == "linear" and "linear_model" in var_model:
+                    linear = var_model["linear_model"]
+                    record['var_m'] = linear['parameters']['m']
+                    record['var_r2'] = linear['r2']
+                    record['var_d'] = None
+                    record['var_alpha'] = None
+                    
+                elif selected == "power_law" and "power_law_model" in var_model:
+                    power_law = var_model["power_law_model"]
+                    record['var_d'] = power_law['parameters']['d']
+                    record['var_alpha'] = power_law['parameters']['alpha']
+                    record['var_r2'] = power_law['r2']
+                    record['var_m'] = None
+            else:
+                # Old format without model selection
+                params = var_model['parameters']
+                record['var_r2'] = var_model['r2']
+                
+                if 'm' in params:
+                    record['var_m'] = params['m']
+                    record['var_d'] = None
+                    record['var_alpha'] = None
+                    record['var_model_selected'] = 'linear'
+                elif 'd' in params and 'alpha' in params:
+                    record['var_d'] = params['d']
+                    record['var_alpha'] = params['alpha']
+                    record['var_m'] = None
+                    record['var_model_selected'] = 'power_law'
+        
+        records.append(record)
+    
+    return pd.DataFrame(records)
+
+
+def create_violin_plots(df: pd.DataFrame, export: bool = False, show: bool = True, output_filename: str = "share/test_runs_violin_plot.pdf"):
+    """
+    Create violin plots for parameter distributions.
+    
+    :param df: DataFrame with extracted parameters
+    :type df: pd.DataFrame
+    :param export: Whether to save the figure (default False)
+    :type export: bool
+    :param show: Whether to display the figure (default True)
+    :type show: bool
+    :param output_filename: Path to save the figure
+    :type output_filename: str
+    """
+    set_matplotlib_params()
+    
+    # Define colors
+    colors = {
+        "UK": "#76d6ff",
+        "USA": "#FF6346",
+    }
+    
+    # Parameters to plot
+    mean_params = [
+        ('mean_m', 'Mean: Slope (m)', 'mutations/week'),
+        ('mean_b', 'Mean: Intercept (b)', 'mutations'),
+        ('mean_r2', 'Mean: R²', '')
+    ]
+    
+    # Check which variance model is predominantly used
+    var_model_counts = df['var_model_selected'].value_counts()
+    print("\nVariance model selection:")
+    print(var_model_counts)
+    
+    # Determine which variance parameters to plot
+    if var_model_counts.get('power_law', 0) > 0:
+        var_params = [
+            ('var_d', 'Variance: Coefficient (d)', ''),
+            ('var_alpha', 'Variance: Exponent (α)', ''),
+            ('var_r2', 'Variance: R²', '')
+        ]
+    else:
+        var_params = [
+            ('var_m', 'Variance: Slope (m)', 'mutations²/week'),
+            ('var_r2', 'Variance: R²', '')
+        ]
+    
+    all_params = mean_params + var_params
+    
+    # Create subplots
+    n_params = len(all_params)
+    fig, axes = plt.subplots(2, 3, figsize=(18, 12))
+    axes = axes.flatten()
+    
+    for idx, (param, title, unit) in enumerate(all_params):
+        if idx >= len(axes):
+            break
+            
+        ax = axes[idx]
+        
+        # Filter out None values for this parameter
+        plot_df = df[df[param].notna()].copy()
+        
+        if len(plot_df) == 0:
+            ax.text(0.5, 0.5, 'No data', ha='center', va='center', transform=ax.transAxes)
+            ax.set_title(title)
+            continue
+        
+        # Create violin plot
+        parts = ax.violinplot(
+            [plot_df[plot_df['country'] == 'UK'][param].values,
+             plot_df[plot_df['country'] == 'USA'][param].values],
+            positions=[0, 1],
+            showmeans=True,
+            showextrema=True,
+            widths=0.7
+        )
+        
+        # Color the violins
+        for i, pc in enumerate(parts['bodies']):
+            country = ['UK', 'USA'][i]
+            pc.set_facecolor(colors[country])
+            pc.set_alpha(0.7)
+            pc.set_edgecolor('black')
+            pc.set_linewidth(1.5)
+        
+        # Style the other elements
+        for partname in ['cmeans', 'cmaxes', 'cmins', 'cbars']:
+            if partname in parts:
+                parts[partname].set_edgecolor('black')
+                parts[partname].set_linewidth(2)
+        
+        # Add scatter points for individual runs
+        for i, country in enumerate(['UK', 'USA']):
+            country_data = plot_df[plot_df['country'] == country]
+            x_pos = np.random.normal(i, 0.04, size=len(country_data))
+            ax.scatter(x_pos, country_data[param].values, 
+                      alpha=0.6, s=50, c='black', zorder=3, edgecolors='white', linewidth=1)
+        
+        # Styling
+        ax.set_xticks([0, 1])
+        ax.set_xticklabels(['UK', 'USA'])
+        ax.set_ylabel(f'{title.split(": ")[1]} {f"({unit})" if unit else ""}'.strip())
+        ax.set_title(title, fontweight='bold')
+        ax.grid(axis='y', alpha=0.3, linestyle='--')
+        
+        # Add statistics text
+        for i, country in enumerate(['UK', 'USA']):
+            country_data = plot_df[plot_df['country'] == country][param]
+            if len(country_data) > 0:
+                mean_val = country_data.mean()
+                std_val = country_data.std()
+                cv = (std_val / mean_val * 100) if mean_val != 0 else 0
+                
+                text_y = ax.get_ylim()[1] * 0.95 - i * (ax.get_ylim()[1] - ax.get_ylim()[0]) * 0.08
+                ax.text(0.98, text_y, 
+                       f'{country}: μ={mean_val:.4f}, σ={std_val:.4f}, CV={cv:.2f}%',
+                       transform=ax.transData, ha='right', va='top',
+                       fontsize=9, bbox=dict(boxstyle='round', facecolor=colors[country], alpha=0.3))
+    
+    # Hide unused subplots
+    for idx in range(len(all_params), len(axes)):
+        axes[idx].set_visible(False)
+    
+    fig.suptitle('Parameter Variability Across Multiple Runs\n(Assessing Nonlinear Fitting Reproducibility)', 
+                 fontsize=16, fontweight='bold', y=0.995)
+    plt.tight_layout()
+    
+    if export:
+        fig.savefig(output_filename, dpi=400, bbox_inches='tight')
+        print(f"\nViolin plot saved as {output_filename}")
+    
+    if show:
+        plt.show()
+
+
+def print_summary_statistics(df: pd.DataFrame):
+    """
+    Print summary statistics for all parameters.
+    
+    Displays mean, standard deviation, and coefficient of variation (CV%)
+    for each parameter grouped by country.
+    
+    :param df: DataFrame with extracted parameters
+    :type df: pd.DataFrame
+    """
+    print("\n" + "="*80)
+    print("PARAMETER VARIABILITY SUMMARY")
+    print("="*80)
+    
+    for country in ['UK', 'USA']:
+        print(f"\n{country} Dataset:")
+        print("-" * 40)
+        
+        country_df = df[df['country'] == country]
+        
+        # Mean model parameters
+        print("\nMean Model:")
+        for param in ['mean_m', 'mean_b', 'mean_r2']:
+            if param in country_df.columns:
+                values = country_df[param].dropna()
+                if len(values) > 0:
+                    mean = values.mean()
+                    std = values.std()
+                    cv = (std / mean * 100) if mean != 0 else 0
+                    print(f"  {param:12s}: μ={mean:10.6f}, σ={std:10.6f}, CV={cv:6.2f}%")
+        
+        # Variance model parameters
+        print("\nVariance Model:")
+        var_model = country_df['var_model_selected'].mode()[0] if 'var_model_selected' in country_df.columns else 'unknown'
+        print(f"  Selected model: {var_model}")
+        
+        if var_model == 'power_law':
+            for param in ['var_d', 'var_alpha', 'var_r2']:
+                if param in country_df.columns:
+                    values = country_df[param].dropna()
+                    if len(values) > 0:
+                        mean = values.mean()
+                        std = values.std()
+                        cv = (std / mean * 100) if mean != 0 else 0
+                        print(f"  {param:12s}: μ={mean:10.6f}, σ={std:10.6f}, CV={cv:6.2f}%")
+        else:
+            for param in ['var_m', 'var_r2']:
+                if param in country_df.columns:
+                    values = country_df[param].dropna()
+                    if len(values) > 0:
+                        mean = values.mean()
+                        std = values.std()
+                        cv = (std / mean * 100) if mean != 0 else 0
+                        print(f"  {param:12s}: μ={mean:10.6f}, σ={std:10.6f}, CV={cv:6.2f}%")
+    
+    print("\n" + "="*80)
+
+
+def main():
+    """
+    Main execution function for analyzing test run parameter variability.
+    
+    Loads regression results from batch directories, extracts parameters,
+    computes statistics, and generates violin plots to visualize parameter
+    distributions across multiple runs.
+    """
+    
+    import sys
+    
+    # Parse command line arguments
+    if len(sys.argv) > 1:
+        batch_name = sys.argv[1]
+        BASE_DIR = Path(f"share/test-runs/{batch_name}")
+        output_suffix = f"_{batch_name}"
+    else:
+        # Try to auto-detect batch directories or use batch1 as default
+        test_runs_dir = Path("share/test-runs")
+        batch_dirs = [d for d in test_runs_dir.iterdir() if d.is_dir() and d.name.startswith("batch")]
+        
+        if len(batch_dirs) == 0:
+            # Fall back to old structure (no batch subdirectories)
+            BASE_DIR = Path("share/test-runs")
+            output_suffix = ""
+        elif len(batch_dirs) == 1:
+            # Use the only batch found
+            BASE_DIR = batch_dirs[0]
+            output_suffix = f"_{batch_dirs[0].name}"
+            print(f"Auto-detected batch: {batch_dirs[0].name}")
+        else:
+            # Multiple batches - ask user or default to batch1
+            print(f"Found {len(batch_dirs)} batches: {[d.name for d in batch_dirs]}")
+            print("Please specify which batch to analyze:")
+            print("  python analyze_test_runs.py batch1")
+            print("Or analyze all batches separately by running for each.")
+            return
+    
+    if not BASE_DIR.exists():
+        print(f"Error: Directory {BASE_DIR} does not exist!")
+        return
+    
+    # Auto-detect number of runs
+    uk_runs = list(BASE_DIR.glob("UK_run*"))
+    usa_runs = list(BASE_DIR.glob("USA_run*"))
+    NUM_RUNS = max(len(uk_runs), len(usa_runs))
+    
+    COUNTRIES = ["UK", "USA"]
+    
+    print(f"Loading regression results from {BASE_DIR}...")
+    print(f"Detected {NUM_RUNS} runs per country")
+    
+    # Load all results
+    all_results = []
+    for country in COUNTRIES:
+        results = load_regression_results(BASE_DIR, country, NUM_RUNS)
+        all_results.extend(results)
+        print(f"Loaded {len(results)} runs for {country}")
+    
+    if not all_results:
+        print("Error: No results found!")
+        return
+    
+    # Extract parameters into DataFrame
+    print("\nExtracting parameters...")
+    df = extract_parameters(all_results)
+    
+    # Save to CSV for further analysis
+    output_csv = f"share/test_runs_parameters{output_suffix}.csv"
+    df.to_csv(output_csv, index=False)
+    print(f"Parameters saved to {output_csv}")
+    
+    # Print summary statistics
+    print_summary_statistics(df)
+    
+    # Create violin plots
+    print("\nCreating violin plots...")
+    output_plot = f"share/test_runs_violin_plot{output_suffix}.pdf"
+    create_violin_plots(df, export=True, show=True, output_filename=output_plot)
+
+
+if __name__ == "__main__":
+    main()
+

share/figUK_regression_results.json

@@ -1,18 +1,65 @@
 {
-    "mean number of mutations per 7D model": {
+    "mean number of mutations model": {
         "parameters": {
             "m": 0.19547481089767144,
             "b": 35.634115529420946
         },
+        "confidence_intervals": {
+            "m": [
+                0.18318447093035867,
+                0.2077651508649842
+            ],
+            "b": [
+                35.35560980879931,
+                35.912621250042584
+            ]
+        },
         "expression": "mx + b",
+        "confidence_level": 0.95,
         "r2": 0.9637010376538699
     },
-    "scaled var number of mutations per 7D model": {
-        "parameters": {
-            "d": 1.9496396213906204,
-            "alpha": 0.4010445329484692
+    "scaled var number of mutations model": {
+        "linear_model": {
+            "parameters": {
+                "m": 0.2701500514044973
+            },
+            "confidence_intervals": {
+                "m": [
+                    0.21165644420002577,
+                    0.3286436586089689
+                ]
+            },
+            "expression": "mx",
+            "r2": 0.23974456333891003,
+            "confidence_level": 0.95
+        },
+        "power_law_model": {
+            "parameters": {
+                "d": 1.949675756351066,
+                "alpha": 0.40103856972319674
+            },
+            "confidence_intervals": {
+                "d": [
+                    1.2336302228902016,
+                    2.6657212898119305
+                ],
+                "alpha": [
+                    0.2846823845254939,
+                    0.5173947549208996
+                ]
+            },
+            "expression": "d*x^alpha",
+            "r2": 0.7403444327630024,
+            "confidence_level": 0.95
         },
-        "expression": "d*x^alpha",
-        "r2": 0.7403444327797193
+        "model_selection": {
+            "selected": "power_law",
+            "linear_AIC": 173.79403093437475,
+            "power_law_AIC": 133.0411534485154,
+            "delta_AIC_linear": 40.75287748585936,
+            "delta_AIC_power_law": 0.0,
+            "akaike_weight_linear": 1.414572114240171e-09,
+            "akaike_weight_power_law": 0.999999998585428
+        }
     }
 }

share/figUK_run_args.json

@@ -5,6 +5,7 @@
     "delta_t": "7D",
     "show": false,
     "export_plots": true,
+    "confidence_level": 0.95,
     "length_filter": 0,
     "kind": "total",
     "filter": null,

share/figUK_stats.tsv

@@ -1,41 +1,41 @@
-date	mean number of mutations	var number of mutations	size
-2020-10-29	34.515151515151516	0.8689976689976701	66
-2020-11-05	35.029411764705884	0.9620915032679709	136
-2020-11-12	35.63250883392226	1.9921309174748796	283
-2020-11-19	36.07575757575758	2.5170742962621144	198
-2020-11-26	36.37826086956522	3.6685209796848266	230
-2020-12-03	36.20704845814978	4.297649214455573	227
-2020-12-10	36.555865921787706	3.715357651440464	358
-2020-12-17	37.040625	4.709943181818182	320
-2020-12-24	37.450171821305844	6.5794051427894376	291
-2020-12-31	37.649068322981364	6.614781060737982	322
-2021-01-07	37.97329376854599	5.907022749752713	337
-2021-01-14	38.126182965299684	7.1675717765443405	317
-2021-01-21	38.33774834437086	6.476909198917517	302
-2021-01-28	38.614285714285714	6.632053251408085	280
-2021-02-04	38.891373801916934	8.481752273285828	313
-2021-02-11	38.62369337979094	7.235520576984016	287
-2021-02-18	39.12367491166078	7.97401197904921	283
-2021-02-25	39.30167597765363	6.558596623006733	358
-2021-03-04	39.56273764258555	6.239369575944036	263
-2021-03-11	39.64939024390244	8.613699932870894	328
-2021-03-18	39.625	7.909090909090907	320
-2021-03-25	40.233676975945016	8.607275743571508	291
-2021-04-01	40.11	8.345719063545154	300
-2021-04-08	40.11552346570397	6.776461047454612	277
-2021-04-15	40.674121405750796	7.5344884082903265	313
-2021-04-22	40.55882352941177	8.050626808100292	306
-2021-04-29	41.38768115942029	9.140065876152836	276
-2021-05-06	41.098684210526315	7.442374500607957	304
-2021-05-13	41.06024096385542	8.75038865137971	249
-2021-05-20	41.205479452054796	9.091653721225812	292
-2021-05-27	40.85546875	9.69275428921569	256
-2021-06-03	41.12112676056338	8.886416805920257	355
-2021-06-10	41.49	6.96472361809045	200
-2021-06-17	41.723404255319146	7.741267493457731	188
-2021-06-24	42.27860696517413	6.611990049751241	201
-2021-07-01	42.541935483870965	8.717385839966484	155
-2021-07-08	42.71875	7.475198412698421	64
-2021-07-15	43.333333333333336	8.333333333333332	39
-2021-07-22	42.32142857142857	7.822077922077916	56
-2021-07-29	41.857142857142854	15.14285714285714	7
+date	mean number of mutations	var number of mutations	size	dt_idx
+2020-10-29	34.515151515151516	0.8689976689976701	66	0.0
+2020-11-05	35.029411764705884	0.9620915032679709	136	1.0
+2020-11-12	35.63250883392226	1.9921309174748796	283	2.0
+2020-11-19	36.07575757575758	2.5170742962621144	198	3.0
+2020-11-26	36.37826086956522	3.6685209796848266	230	4.0
+2020-12-03	36.20704845814978	4.297649214455573	227	5.0
+2020-12-10	36.555865921787706	3.715357651440464	358	6.0
+2020-12-17	37.040625	4.709943181818182	320	7.0
+2020-12-24	37.450171821305844	6.5794051427894376	291	8.0
+2020-12-31	37.649068322981364	6.614781060737982	322	9.0
+2021-01-07	37.97329376854599	5.907022749752713	337	10.0
+2021-01-14	38.126182965299684	7.1675717765443405	317	11.0
+2021-01-21	38.33774834437086	6.476909198917517	302	12.0
+2021-01-28	38.614285714285714	6.632053251408085	280	13.0
+2021-02-04	38.891373801916934	8.481752273285828	313	14.0
+2021-02-11	38.62369337979094	7.235520576984016	287	15.0
+2021-02-18	39.12367491166078	7.97401197904921	283	16.0
+2021-02-25	39.30167597765363	6.558596623006733	358	17.0
+2021-03-04	39.56273764258555	6.239369575944036	263	18.0
+2021-03-11	39.64939024390244	8.613699932870894	328	19.0
+2021-03-18	39.625	7.909090909090907	320	20.0
+2021-03-25	40.233676975945016	8.607275743571508	291	21.0
+2021-04-01	40.11	8.345719063545154	300	22.0
+2021-04-08	40.11552346570397	6.776461047454612	277	23.0
+2021-04-15	40.674121405750796	7.5344884082903265	313	24.0
+2021-04-22	40.55882352941177	8.050626808100292	306	25.0
+2021-04-29	41.38768115942029	9.140065876152836	276	26.0
+2021-05-06	41.098684210526315	7.442374500607957	304	27.0
+2021-05-13	41.06024096385542	8.75038865137971	249	28.0
+2021-05-20	41.205479452054796	9.091653721225812	292	29.0
+2021-05-27	40.85546875	9.69275428921569	256	30.0
+2021-06-03	41.12112676056338	8.886416805920257	355	31.0
+2021-06-10	41.49	6.96472361809045	200	32.0
+2021-06-17	41.723404255319146	7.741267493457731	188	33.0
+2021-06-24	42.27860696517413	6.611990049751241	201	34.0
+2021-07-01	42.541935483870965	8.717385839966484	155	35.0
+2021-07-08	42.71875	7.475198412698421	64	36.0
+2021-07-15	43.333333333333336	8.333333333333332	39	37.0
+2021-07-22	42.32142857142857	7.822077922077916	56	38.0
+2021-07-29	41.857142857142854	15.14285714285714	7	39.0

share/figUSA_regression_results.json

@@ -1,18 +1,65 @@
 {
-    "mean number of mutations per 7D model": {
+    "mean number of mutations model": {
         "parameters": {
             "m": 0.3258484867760181,
             "b": 35.93995331972901
         },
+        "confidence_intervals": {
+            "m": [
+                0.2883403045689692,
+                0.36335666898306695
+            ],
+            "b": [
+                35.24158897313613,
+                36.63831766632188
+            ]
+        },
         "expression": "mx + b",
+        "confidence_level": 0.95,
         "r2": 0.9071591655422693
     },
-    "scaled var number of mutations per 7D model": {
-        "parameters": {
-            "d": 0.6926241001872148,
-            "alpha": 0.7238661387949127
+    "scaled var number of mutations model": {
+        "linear_model": {
+            "parameters": {
+                "m": 0.2915484276133104
+            },
+            "confidence_intervals": {
+                "m": [
+                    0.24003648883099504,
+                    0.34306036639562576
+                ]
+            },
+            "expression": "mx",
+            "r2": 0.7243923706082853,
+            "confidence_level": 0.95
+        },
+        "power_law_model": {
+            "parameters": {
+                "d": 0.6926303070016426,
+                "alpha": 0.723863222453596
+            },
+            "confidence_intervals": {
+                "d": [
+                    0.2633037580510857,
+                    1.1219568559521995
+                ],
+                "alpha": [
+                    0.5238853883558428,
+                    0.9238410565513493
+                ]
+            },
+            "expression": "d*x^alpha",
+            "r2": 0.7761009815632863,
+            "confidence_level": 0.95
         },
-        "expression": "d*x^alpha",
-        "r2": 0.7761009815628838
+        "model_selection": {
+            "selected": "power_law",
+            "linear_AIC": 115.52445550217226,
+            "power_law_AIC": 110.93858154005544,
+            "delta_AIC_linear": 4.585873962116821,
+            "delta_AIC_power_law": 0.0,
+            "akaike_weight_linear": 0.0917096089306382,
+            "akaike_weight_power_law": 0.9082903910693618
+        }
     }
 }