ai-nk-cce 0.1.0__py3-none-any.whl

ai_nk_cce-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.3
+Name: ai-nk-cce
+Version: 0.1.0
+Summary: This repository is used to train AI agents to predict good strategies in a social learning game based on a NK landscape.
+Author: Luis Mienhardt
+Author-email: mienhardt@mpib-berlin.mpg.de
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: model
+Requires-Dist: dataframe-image (>=0.2.7,<0.3.0)
+Requires-Dist: evaluate (>=0.4.3,<0.5.0)
+Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
+Requires-Dist: numpy (>=1.26.0,<2.0.0)
+Requires-Dist: openai (>=1.52.0,<2.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: scikit-learn (>=1.5.2,<2.0.0)
+Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
+Requires-Dist: tqdm (>=4.66.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+# human-ai-social-learning
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![PEP8](https://img.shields.io/badge/code%20style-pep8-orange.svg)](https://www.python.org/dev/peps/pep-0008/)
+
+## Description
+
+## Installation
+
+This project uses Poetry for package management. If you haven't installed Poetry yet, please follow the instructions on the [official Poetry website](https://python-poetry.org/docs/#installation).
+
+To install the project:
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/your-username/human-ai-social-learning.git
+   cd human-ai-social-learning
+   ```
+
+2. Install dependencies with Poetry:
+
+   ```bash
+   poetry install
+   ```
+
+3. Activate the virtual environment:
+
+   ```bash
+   poetry shell
+   ```
+
+4. (Optional) Set up Jupyter kernel for notebooks:
+
+   ```bash
+   poetry run python -m ipykernel install --user --name nk-cce-kernel
+   ```
+
+Now your development environment is set up and ready to use.
+
+## Contributing
+
+We welcome contributions! Please note:
+
+1. Please create a descriptive branch for each contribution (naming convention *feature_type/feature_name*)
+2. Follow the project style (PEP 8 for Python).
+3. Add tests and run all before commit. (At least one test per function or method.)
+4. Write meaningful commit messages.
+5. Keep in line with pre-commit linting.
+6. Submit a Pull Request, to include your code into main.
+
+### Pre-commit Hooks
+
+We use pre-commit hooks. Installation:
+
+```bash
+poetry add pre-commit
+pre-commit install
+pre-commit run --all-files
+```
+
+### Running Tests
+
+Tests need to be run in the virtual environment. You can use Poetry or Visual Studio Code settings to do so automatically.
+
+To run all tests using Poetry run:
+
+```bash
+poetry run pytest
+```
+
+We included Visual Studio Code settings in the repository.
+You can try to use them to run the tests within Visual Studio Code.
+
+```text
+.vscode/
+├── settings.json
+├── launch.json
+```
+
+## Documentation
+
+For an overview of the repository structure, module organization, and
+dependencies, see the [Repository Structure Guide](doc/repository_structure.md).
+
+Additional documentation is available in the `doc/` directory:
+
+- [How to compare hill climber vs AI](doc/how_to_compare_hill_climber_vs_ai.md)
+- [How to find average hill climber landscape](doc/how_to_find_average_hill_climber_landscape.md)
+- [Using MPCDF LLM inference](doc/use_mpcdf_llm_inference.md)
+

ai_nk_cce-0.1.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api/mpcdf_vllm.py,sha256=PlAUrwyiTrROVhRufxqjPGCYVh0GDPFyJlqSnJD6tZo,2821
+evals/nk_model.py,sha256=hJhtkdIclL-s2dN2HHpJSpZuTVIPe6SLM0EP9jzs0JA,9122
+model/README.md,sha256=c_qO2gyGjYmGfGcpnaxvQ7MWFg-WlAUtK8IMCfzHIPc,2226
+model/config/dataset_conv_v1.yml,sha256=cVT4Hgo5lB9w1Xl3EaUO_TtrHdMWQSe8U022JkKQ5SE,409
+model/config/dataset_conv_v2_m2.yml,sha256=Xz75wZs7tOpqVfiTSsgpepvOzlp_scKwoqyLLug-KGM,412
+model/config/dataset_conv_v3_m2_assembl_nearest.yml,sha256=8-H1TWK7w44eg1lx8YO9FY6tO_Q0Jw49pFOfYbm_rl4,444
+model/config/dataset_debug.yml,sha256=7oBNvLZ9vDh8jrgnf4Rc49Q3hE8wz1agG1SuK2pycsA,332
+model/config/dataset_v4_int_format.yml,sha256=A7oYBvzmX7YMq97sYhB-87xe5fUpApfR-zHydMm8VsQ,330
+model/config/dataset_v5.yml,sha256=SkgLZTB8yQE2lRg0N3Os360zKykGKHQHNajEN7MDj3k,404
+model/config/inference.yml,sha256=Gh9-QkZsSH9qdMFY5zYoFyYTPvOO2Ar-up9hnXpR9IU,276
+model/config/train.yml,sha256=6vbF0-EDuuGj94IltFY1z8IbMlP1xSu4sVVr_m7ZK1E,650
+model/config/train_debug.yml,sha256=IvUBTyZVWLQf7rdPaD_pSekGz1d1-EQ9T9hdzUiMKSg,517
+model/config/train_from_checkpoint.yml,sha256=GQ-DyemDxBiWG2MH8jGOVc8bZSPYejktVgf15ST5gxk,686
+model/config/train_from_checkpoint_debug.yml,sha256=T04e0t94G9s7JKZEAEm_CYvbgLvW9b1F0DISTHCaGak,553
+model/config/train_grpo.yml,sha256=jVZbSzx9OiFrNltgQhkbUQBkJkPRS-xaiYnCRExgPTw,861
+model/config/train_grpo_debug.yml,sha256=5LF1Y2pvVYOv8OujxQ3gLuPcJuEEpC8BVPrtQ4yP5TY,946
+model/config/train_grpo_debug_vllm.yml,sha256=rAB6O2GGoC7oHZ6V3zglx16U2IByoG6uZ9T4zwE0Nu8,999
+model/config.py,sha256=NGT1zWblFh0yfaHppjpJV-1CHb3GxBBVj3LFmkz9Bkg,1628
+model/dataset.py,sha256=cesCqK9vR8vgv7nIfVVjm7mob-lZa2eniekzofvzpEU,10433
+model/inference.py,sha256=eN4RwBQO1b35NL2tzAA2KkDAP5g1-t9KPF5uiPT2z2w,1585
+model/nk_assistant.py,sha256=TjHrYGCGvxLE2bZkWTKx4PoMw5t3mbYDxrXe1S55UWU,6696
+model/parser.py,sha256=Fg0yPmnK2DDiEgFRfh-WhIOZ3itbdf04hzOKd-bEwZM,1738
+model/run_slurm.py,sha256=CDx9qF_cz6jqgfRkAgrr--tN2dIoY2I7Foszu7GcxBE,9602
+model/score.ipynb,sha256=3iGnpQJJGhC5eH0YRTHAYWAaWZq8ZDzSwvX4rJMAEOk,21993
+model/scripts/template.slurm,sha256=4TPHAS5tuPmoFlgZ6r5WsGQwVyOtnIknuR5LnEELiys,1541
+model/scripts/template_rl.slurm,sha256=Un8VTcS8n-W4l4nkz6xER9R6NpeKX4vQp2Go2Hv6C7g,1565
+model/train.py,sha256=fhNvzUEgEqREsDZPjRLyNPVU4zjBUkF1lbUKr93d4b4,9619
+nk_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nk_model/assembler.py,sha256=ea9YDlYBiWp927jf2oxl9NaeMzYhXeaKBF5cOKSF1C4,3192
+nk_model/biased_prediction_agent.py,sha256=hXkgNi3yTlv3xwCrwPyAo6cBJ_G2CHXvgZaHn0T5hJI,12302
+nk_model/dataset.py,sha256=fwaCvSd75Rz4afQ5VmbMjLoBSi9lCNWARI4GpyJ5ENQ,14471
+nk_model/enums.py,sha256=rUzY6ky4tISpH9IVHc2Zxy7Uqzn0wTkDmlg6kDTxXnY,403
+nk_model/landscape_cache.py,sha256=7V2w9MErkoAMfTK_1MLf1NDPzIJ9PeuyBV8bEuWszO0,4727
+nk_model/models.py,sha256=dUBU1ONRUbwvfpdRADYoXKL4Q-q02lpsTp4_QNIjtEE,5269
+nk_model/nk_landscape.py,sha256=OW4hPQ7edlFT-KH5btpCMoZIVwbucN3mpHpwaBTzRi8,17096
+simulation/hill_climber_simulation.py,sha256=SgkhuEG0elzBpNwsaIPLiY2taj-ByCbmcM5TcpoAh6I,7162
+simulation/hill_climber_vs_ai_simulation.py,sha256=fn5kG2JsCKmpcZQkHnKtNtlbfYLpb-WYaIli3W0Mdxk,4083
+simulation/landscape_selection.py,sha256=Co0O2Te0kQYX1e3lj27B7Z_OLGtJyvQuPEECFmN9mvY,5274
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/binary_conversion.py,sha256=9YTEbxSUNuGnVWAIU5fG1U1bjdqSbhC1C3NGUmqv-C8,3705
+utils/logging.py,sha256=SQlSxGt4ntkW3kyyy8cj_Moldg10szIzP1Cu1wMJVVo,895
+utils/utils.py,sha256=_GypnP34bOrr3OD8PB-8QmJmMcpM6hTJm5G67PXhAME,1455
+ai_nk_cce-0.1.0.dist-info/METADATA,sha256=QrOK2mNNijYE-3d7W4um5DwdbXdPtV-sIsa_3QwvIAs,3604
+ai_nk_cce-0.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+ai_nk_cce-0.1.0.dist-info/RECORD,,

ai_nk_cce-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any

api/mpcdf_vllm.py

@@ -0,0 +1,94 @@
+import os
+import time
+from typing import Any, Optional
+
+import httpx
+from dotenv import load_dotenv
+
+from src.utils.logging import log_dec
+
+load_dotenv()
+
+BASE_URL = os.getenv("MPCDF_BASE_URL")
+API_KEY = os.getenv("MPCDF_API_KEY")
+MODEL_NAME = "center-for-humans-and-machines/assembl_nk_1"
+
+
+@log_dec
+def mpcdf_vllm_request(
+    prompt: str,
+    model: Optional[str] = None,
+    max_tokens: int = 150,
+    temperature: float = 0.7,
+    timeout: float = 30.0,
+    max_retries: int = 3,
+    initial_backoff: float = 1.0,
+    **kwargs: Any,
+) -> str:
+    """Make request to vLLM model with tokenized input.
+
+    Uses the /v1/completions endpoint which supports prompt_token_ids
+    directly, bypassing the tokenizer. This function tokenizes the prompt
+    and sends it as token IDs.
+
+    Args:
+        prompt: Text prompt string to send to the model.
+        model: Model name (defaults to MODEL_NAME).
+        max_tokens: Maximum tokens to generate.
+        temperature: Sampling temperature.
+        timeout: Request timeout in seconds.
+        max_retries: Maximum number of retry attempts (default: 3).
+        initial_backoff: Initial backoff delay in seconds (default: 1.0).
+        **kwargs: Additional parameters for completion request.
+
+    Returns:
+        Generated text content.
+    """
+    # Build request URL - ensure /v1 prefix if not present
+    base = BASE_URL.rstrip("/")
+    if not base.endswith("/v1"):
+        base = f"{base}/v1"
+    url = f"{base}/completions"
+
+    # Prepare payload - use prompt_token_ids for completions endpoint
+    payload = {
+        "model": model or MODEL_NAME,
+        "prompt": prompt,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        **kwargs,
+    }
+
+    # Make HTTP request
+    headers = {
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json",
+    }
+
+    last_exception = None
+    for attempt in range(max_retries + 1):
+        try:
+            with httpx.Client(timeout=timeout) as http_client:
+                response = http_client.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+                result = response.json()
+
+            # Completions endpoint returns text directly
+            return result["choices"][0]["text"]
+        except (
+            httpx.HTTPStatusError,
+            httpx.RequestError,
+            httpx.TimeoutException,
+            httpx.NetworkError,
+        ) as e:
+            last_exception = e
+            if attempt < max_retries:
+                backoff = initial_backoff * (2**attempt)
+                time.sleep(backoff)
+                continue
+            raise
+
+    # This should never be reached, but type checker needs it
+    if last_exception:
+        raise last_exception
+    raise RuntimeError("Request failed unexpectedly")

evals/nk_model.py

@@ -0,0 +1,277 @@
+"""
+NK Model evaluation functions for analyzing fitness landscapes.
+
+This module provides functions to evaluate statistical properties of NK
+fitness landscapes, including payoff distributions and peak prominence
+analysis.
+"""
+
+from collections import Counter
+from typing import Dict, Tuple
+
+import numpy as np
+import pandas as pd
+
+from src.nk_model.nk_landscape import NKLandscape
+
+
+def calculate_payoff_distribution(
+    landscape: NKLandscape, bins: int = 50
+) -> pd.DataFrame:
+    """
+    Calculate the average payoff distribution for an NK fitness landscape.
+
+    Args:
+        landscape: NKLandscape instance to analyze
+        bins: Number of bins for the histogram (default: 50)
+
+    Returns:
+        pd.DataFrame with columns ['bin_center', 'frequency', 'bin_edges_left',
+        'bin_edges_right'] suitable for plotting
+    """
+    # Extract payoffs from all items in the landscape
+    payoffs = [item.payoff for item in landscape.items]
+
+    # Calculate histogram
+    hist, bin_edges = np.histogram(payoffs, bins=bins, range=(0, 1))
+
+    # Calculate bin centers for plotting
+    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+
+    # Create DataFrame for easy plotting
+    return pd.DataFrame(
+        {
+            "bin_center": bin_centers,
+            "frequency": hist,
+            "bin_edges_left": bin_edges[:-1],
+            "bin_edges_right": bin_edges[1:],
+        }
+    )
+
+
+def calculate_peaks_prominence(landscape: NKLandscape) -> pd.DataFrame:
+    """
+    Calculate peaks and their prominence distribution in NK landscape.
+
+    Prominence is defined as the minimum Hamming distance to reach a
+    higher payoff. A prominence of n+1 indicates a global peak.
+
+    This elegant implementation uses vectorized operations for better
+    performance and readability.
+
+    Args:
+        landscape: NKLandscape instance to analyze
+
+    Returns:
+        pd.DataFrame with columns ['prominence', 'count', 'proportion',
+        'coordinates'] where prominence ranges from 1 to n+1, and coordinates
+        contains lists of coordinate tuples for points at each prominence level
+    """
+    n = landscape.params.n
+    items = landscape.items
+    total_items = len(items)
+
+    # Convert all coordinates and payoffs to numpy arrays for vectorization
+    coords = np.array(
+        [item.coordinates for item in items]
+    )  # Shape: (total_items, n)
+    payoffs = np.array(
+        [item.payoff for item in items]
+    )  # Shape: (total_items,)
+
+    # Calculate prominence for each point using vectorized operations
+    prominence_values = np.full(
+        total_items, n + 1, dtype=int
+    )  # Start with global peak assumption
+
+    # For each Hamming distance from 1 to n
+    for distance in range(1, n + 1):
+        # Find items that haven't found a higher payoff yet
+        unresolved_mask = prominence_values == n + 1
+        unresolved_indices = np.where(unresolved_mask)[0]
+
+        if len(unresolved_indices) == 0:
+            break  # All items have found their prominence
+
+        # For unresolved items, check if any other item is at this distance
+        # with higher payoff
+        for i in unresolved_indices:
+            current_coords = coords[i]
+            current_payoff = payoffs[i]
+
+            # Calculate Hamming distances to all other points
+            hamming_distances = np.sum(coords != current_coords, axis=1)
+
+            # Find items at exactly this distance with higher payoff
+            at_distance_mask = hamming_distances == distance
+            higher_payoff_mask = payoffs > current_payoff
+            found_higher = np.any(at_distance_mask & higher_payoff_mask)
+
+            if found_higher:
+                prominence_values[i] = distance
+
+    # Create DataFrame with all prominence levels (1 to n+1) and collect
+    # coordinates
+    prominence_range = np.arange(1, n + 2)
+    results = []
+
+    for prom_val in prominence_range:
+        mask = prominence_values == prom_val
+        count = np.sum(mask)
+        proportion = count / total_items
+
+        # Collect coordinates for this prominence level
+        coords_at_prominence = [tuple(coords[i]) for i in np.where(mask)[0]]
+
+        results.append(
+            {
+                "prominence": prom_val,
+                "count": count,
+                "proportion": proportion,
+                "coordinates": coords_at_prominence,
+            }
+        )
+
+    df = pd.DataFrame(results)
+
+    # Add summary statistics as metadata
+    peak_mask = df["prominence"] >= 2  # Prominence >= 2 indicates peaks
+    df.attrs["peak_count"] = df.loc[peak_mask, "count"].sum()
+    df.attrs["peak_proportion"] = df.loc[peak_mask, "proportion"].sum()
+    df.attrs["global_peaks"] = df.loc[df["prominence"] == n + 1, "count"].iloc[
+        0
+    ]
+
+    return df
+
+
+def _hill_climb_to_maximum(
+    start_coords: np.ndarray, landscape: NKLandscape
+) -> Tuple[np.ndarray, float]:
+    """
+    Perform hill-climbing from a starting point to find the local maximum
+    it reaches.
+
+    Args:
+        start_coords: Starting coordinates
+        landscape: NKLandscape instance
+
+    Returns:
+        Tuple of (final_coordinates, final_payoff) of the local maximum reached
+    """
+    current_coords = start_coords.copy()
+    current_payoff = landscape.get_payoff(current_coords)
+
+    improved = True
+    while improved:
+        improved = False
+        best_coords = current_coords.copy()
+        best_payoff = current_payoff
+
+        # Check all neighbors at Hamming distance 1
+        for i in range(len(current_coords)):
+            neighbor_coords = current_coords.copy()
+            neighbor_coords[i] = 1 - neighbor_coords[i]  # Flip bit
+            neighbor_payoff = landscape.get_payoff(neighbor_coords)
+
+            if neighbor_payoff > best_payoff:
+                best_coords = neighbor_coords.copy()
+                best_payoff = neighbor_payoff
+                improved = True
+
+        if improved:
+            current_coords = best_coords
+            current_payoff = best_payoff
+
+    return current_coords, current_payoff
+
+
+def calculate_basin_analysis(landscape: NKLandscape) -> pd.DataFrame:
+    """
+    Analyze basins of attraction for all local maxima in the NK landscape.
+
+    This implements a simplified basin analysis: for each point in the
+    landscape, hill-climb to find which local maximum it reaches, then count
+    unique destinations.
+
+    Args:
+        landscape: NKLandscape instance to analyze
+
+    Returns:
+        pd.DataFrame with columns:
+        - 'coordinates': tuple of coordinates for each local maximum
+        - 'payoff': payoff value of the local maximum
+        - 'basin_size': number of points in the basin of attraction
+        - 'is_global_max': boolean indicating if this is a global maximum
+    """
+    # Collect all destinations from hill-climbing
+    destinations = []
+    for item in landscape.items:
+        final_coords, final_payoff = _hill_climb_to_maximum(
+            item.coordinates, landscape
+        )
+        destinations.append((tuple(final_coords), final_payoff))
+
+    # Count unique destinations (basin sizes)
+    basin_counts = Counter(dest[0] for dest in destinations)
+
+    # Get payoffs for each unique destination
+    payoff_map = {dest[0]: dest[1] for dest in destinations}
+
+    # Find global maximum payoff
+    global_max_payoff = max(payoff_map.values())
+
+    # Create results
+    results = []
+    for coords_tuple, basin_size in basin_counts.items():
+        results.append(
+            {
+                "coordinates": coords_tuple,
+                "payoff": payoff_map[coords_tuple],
+                "basin_size": basin_size,
+                "is_global_max": payoff_map[coords_tuple] == global_max_payoff,
+            }
+        )
+
+    df = pd.DataFrame(results)
+
+    # Sort by payoff (descending) for better readability
+    df = df.sort_values("payoff", ascending=False).reset_index(drop=True)
+
+    # Add summary statistics as metadata
+    df.attrs["total_local_maxima"] = len(df)
+    df.attrs["total_points"] = len(landscape.items)
+    df.attrs["global_maxima_count"] = df["is_global_max"].sum()
+    df.attrs["average_basin_size"] = df["basin_size"].mean()
+
+    return df
+
+
+def evaluate_nk_landscape(
+    landscape: NKLandscape, bins: int = 50, include_basins: bool = False
+) -> Dict[str, pd.DataFrame]:
+    """
+    Comprehensive evaluation of an NK fitness landscape.
+
+    Args:
+        landscape: NKLandscape instance to analyze
+        bins: Number of bins for payoff distribution histogram
+        include_basins: If True, include basin analysis (computationally
+            expensive)
+
+    Returns:
+        Dict containing:
+        - 'payoff_distribution': DataFrame with payoff distribution
+        - 'peaks_prominence': DataFrame with peaks and prominence analysis
+        - 'basin_analysis': DataFrame with basin analysis
+            (if include_basins=True)
+    """
+    results = {
+        "payoff_distribution": calculate_payoff_distribution(landscape, bins),
+        "peaks_prominence": calculate_peaks_prominence(landscape),
+    }
+
+    if include_basins:
+        results["basin_analysis"] = calculate_basin_analysis(landscape)
+
+    return results

model/README.md

@@ -0,0 +1,64 @@
+
+# Debug
+
+## Create Dataset
+
+```
+python src/model/dataset.py --config src/model/config/dataset_debug.yml
+```
+
+# Train Model
+
+```
+python src/model/train.py --config src/model/config/train_debug.yml
+```
+
+# Train Model on Cluster
+
+```
+python src/model/run_slurm.py --config_file src/model/config/train_debug.yml --group_name debug --job_name debug --n_gpu 1 --time 00:10:00 --ds debug_1000
+```
+
+## Evaluate Model
+
+```
+python src/model/run_slurm.py --script src/model/inference.py --config_file src/model/config/inference.yml --group_name debug --job_name debug --ds debug_1000 --n_gpu 1 --model gpt2_debug_1000
+```
+
+# Train RL Model on Cluster
+
+python src/model/run_slurm.py --template  src/model/scripts/template_rl.slurm --config_file src/model/config/train_grpo_debug.yml --image /u/lumi/projects/llm-strategic-tuning/images/ai_nk_rl.sif --group_name debug --job_name rl_debug --n_gpu 1 --lr 1e-5 --time 00:10:00 --ds v5_xxl_3.0
+
+# Train RL Model with vLLM on Cluster
+
+python src/model/run_slurm.py --template  src/model/scripts/template_rl.slurm --config_file src/model/config/train_grpo_debug_vllm.yml --image /u/lumi/projects/llm-strategic-tuning/images/ai_nk_trl_vllm.sif --group_name debug --job_name rl_debug --n_gpu 1 --lr 1e-5 --time 00:10:00 --ds v5_xxl_3.0
+
+# Actual Run
+
+## Create Dataset
+
+```
+python src/model/dataset.py --config src/model/config/dataset.yml
+```
+
+## Train Model
+
+```
+python src/model/run_slurm.py --config_file src/model/config/train.yml --group_name gpt2_v4 --job_name 5e-5 --n_gpu 4 --lr 1e-5 --ds v4 --time 04:00:00
+```
+
+## Evaluate Model
+
+```
+python src/model/run_slurm.py --script src/model/inference.py --config_file src/model/config/inference.yml  --n_gpu 1 --group_name gpt2_v4 --job_name 5e-5 --ds v4 --train_job_id 2025_04_08__13_11_40 --time 01:30:00
+```
+
+# Train RL Model on Cluster
+
+python src/model/run_slurm.py --template  src/model/scripts/template_rl.slurm --config_file src/model/config/train_grpo.yml --image /u/lumi/projects/llm-strategic-tuning/images/ai_nk_rl.sif --group_name gpt2_v6 --job_name rl --n_gpu 4 --lr 1e-5 --time 24:00:00 --ds v5_xxl_3.0
+
+## Push Model
+
+```
+huggingface-cli upload center-for-humans-and-machines/nk-1 models/gpt2_v4/5e-5/2025_03_25__10_09_45
+```

model/config/dataset_conv_v1.yml

@@ -0,0 +1,9 @@
+input_file: "data/landscapes/landscapes_n8_k0-1-2-3-4-5-6-7_m1_p1_f1000._size100000_20250925_125128.parquet"
+output_file: "data/samples/conv_xxl_v1"
+samples_per_landscapes: 20
+constraints_range: [1, 9] # as the constraints are [low, high) this means 1, 2, 3, 4, 5, 6, 7, 8
+n_samples: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+include_payoff: true
+test_ratio: 0.2
+exp_ratio: 0.2
+debug_size: null

model/config/dataset_conv_v2_m2.yml

@@ -0,0 +1,9 @@
+input_file: "data/landscapes/landscapes_n8_k0-1-2-3-4-5-6-7_m2_p1_f1000._size100000_20251007_144922.parquet"
+output_file: "data/samples/conv_xxl_v2_m2"
+samples_per_landscapes: 20
+constraints_range: [1, 9] # as the constraints are [low, high) this means 1, 2, 3, 4, 5, 6, 7, 8
+n_samples: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+include_payoff: true
+test_ratio: 0.2
+exp_ratio: 0.2
+debug_size: null

model/config/dataset_conv_v3_m2_assembl_nearest.yml

@@ -0,0 +1,9 @@
+input_file: "data/landscapes/landscapes_n8_k0-1-2-3-4-5-6-7_m2_p1_f1000._nm-nearest_cm-symmetric_size100000_20251106_164449.parquet"
+output_file: "data/samples/assembl_conv_xxl_v3_m2"
+samples_per_landscapes: 20
+constraints_range: [1, 9] # as the constraints are [low, high) this means 1, 2, 3, 4, 5, 6, 7, 8
+n_samples: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+include_payoff: true
+test_ratio: 0.2
+exp_ratio: 0.2
+debug_size: null

model/config/dataset_debug.yml

@@ -0,0 +1,9 @@
+input_file: "data/landscapes/landscapes_n8_k0-1-2-3-4-5-6-7_p1_f1000_size100000_20250519_185138.parquet"
+output_file: "data/samples/debug_1000"
+samples_per_landscapes: 1
+constraints_range: [1, 9]
+n_samples: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+include_payoff: true
+test_ratio: 0.2
+exp_ratio: 0.2
+debug_size: 1000

model/config/dataset_v4_int_format.yml

@@ -0,0 +1,9 @@
+input_file: "data/landscapes/landscapes_n8_k0-1-2-3-4-5-6-7_p1_f1000._size100000_20250425_151338.parquet"
+output_file: "data/samples/v4_xxl"
+samples_per_landscapes: 10
+constraints_range: [0, 8]
+n_samples: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+include_payoff: true
+test_ratio: 0.2
+exp_ratio: 0.2
+debug_size: null

model/config/dataset_v5.yml

@@ -0,0 +1,9 @@
+input_file: "data/landscapes/landscapes_n8_k0-1-2-3-4-5-6-7_p1_f1000_size100000_20250519_185138.parquet"
+output_file: "data/samples/v5_xxl_2.0"
+samples_per_landscapes: 20
+constraints_range: [1, 9] # as the constraints are [low, high) this means 1, 2, 3, 4, 5, 6, 7, 8
+n_samples: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+include_payoff: true
+test_ratio: 0.2
+exp_ratio: 0.2
+debug_size: null

model/config/inference.yml

@@ -0,0 +1,7 @@
+dataset_file: data/samples/<<ds>>
+model_path: models/<<group_name>>/<<job_name>>/<<train_job_id>>
+output_dataset_file: models/<<group_name>>/<<job_name>>/<<train_job_id>>/inference_results_xxl
+splits: ["test"]
+max_test_samples: 80000
+# generation_params:
+#   temperature: 0.7