PaleoVeg 0.1.0__tar.gz

paleoveg-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Philipp Schlüter
+
+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.

paleoveg-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+exclude paleoveg/model.pkl.bz2

paleoveg-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: PaleoVeg
+Version: 0.1.0
+Summary: Predict paleovegetation from bioclimatic variables.
+Home-page: https://github.com/roink/PaleoVeg
+Author: Philipp Schlüter
+Author-email: p.schlueter@uni-koeln.de
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.5.2
+Requires-Dist: numpy>=2.1.3
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: joblib
+Requires-Dist: matplotlib
+Requires-Dist: cartopy
+Requires-Dist: requests

paleoveg-0.1.0/PaleoVeg.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: PaleoVeg
+Version: 0.1.0
+Summary: Predict paleovegetation from bioclimatic variables.
+Home-page: https://github.com/roink/PaleoVeg
+Author: Philipp Schlüter
+Author-email: p.schlueter@uni-koeln.de
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.5.2
+Requires-Dist: numpy>=2.1.3
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: joblib
+Requires-Dist: matplotlib
+Requires-Dist: cartopy
+Requires-Dist: requests

paleoveg-0.1.0/PaleoVeg.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+PaleoVeg.egg-info/PKG-INFO
+PaleoVeg.egg-info/SOURCES.txt
+PaleoVeg.egg-info/dependency_links.txt
+PaleoVeg.egg-info/requires.txt
+PaleoVeg.egg-info/top_level.txt
+paleoveg/__init__.py
+paleoveg/model_loader.py
+paleoveg/predictor.py
+paleoveg/setup.py
+tests/test_predictor.py

paleoveg-0.1.0/PaleoVeg.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

paleoveg-0.1.0/PaleoVeg.egg-info/requires.txt

@@ -0,0 +1,7 @@
+scikit-learn>=1.5.2
+numpy>=2.1.3
+pandas>=2.2.3
+joblib
+matplotlib
+cartopy
+requests

paleoveg-0.1.0/PaleoVeg.egg-info/top_level.txt

@@ -0,0 +1 @@
+paleoveg

paleoveg-0.1.0/README.md

@@ -0,0 +1,195 @@
+---
+
+# **PaleoVeg**
+
+PaleoVeg is a Python package for predicting vegetation types based on bioclimatic variables. It is designed for paleovegetation reconstruction, allowing users to model vegetation based on past climate data or other environmental predictors.
+
+---
+
+## **Features**
+- Predict vegetation types for single or multiple locations using bioclimatic variables.
+- Apply optional C3/C4 competition corrections for higher CO2 levels.
+- Flexible output options:
+  - Probabilities for each vegetation type.
+  - Dominant vegetation type.
+- Supports input as:
+  - Pandas DataFrames for tabular data.
+  - Numpy arrays for map-like (grid-based) data.
+
+---
+
+## **Predicted Vegetation/Biome Types**
+
+PaleoVeg predicts the following vegetation/biome types:
+
+1. Evergreen Needleleaf Forest
+2. Evergreen Broadleaf Forest
+3. Deciduous Needleleaf Forest
+4. Deciduous Broadleaf Forest
+5. Mixed Forest
+6. Woodland
+7. Wooded Grassland
+8. Closed Shrubland
+9. Open Shrubland
+10. Grassland
+11. Bare Ground
+
+---
+
+## **Installation**
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/roink/PaleoVeg.git
+   cd PaleoVeg
+   ```
+
+2. Install the package:
+   ```bash
+   pip install .
+   ```
+
+---
+
+## **Usage**
+
+### **1. Import the Package**
+```python
+from paleoveg import predict, predict_map
+```
+
+### **2. Predict Using Tabular Data**
+
+#### **Input Data**
+Provide a Pandas DataFrame with the following required columns:
+```plaintext
+bio1, bio4, bio5, bio6, bio7, bio8, bio9, bio10, bio11, bio12, bio13, bio14, bio15, bio16, bio17, bio18, bio19
+```
+
+#### **Example**
+```python
+import pandas as pd
+from paleoveg import predict
+
+# Example input DataFrame
+data = {
+    "bio1": [10.2, 12.5],
+    "bio4": [15.6, 14.1],
+    "bio5": [20.1, 18.4],
+    "bio6": [5.3, 7.2],
+    "bio7": [14.8, 16.5],
+    "bio8": [12.4, 11.8],
+    "bio9": [9.7, 8.9],
+    "bio10": [8.5, 9.2],
+    "bio11": [7.9, 6.5],
+    "bio12": [300.5, 310.2],
+    "bio13": [100.2, 102.4],
+    "bio14": [150.4, 148.3],
+    "bio15": [180.6, 175.9],
+    "bio16": [170.3, 165.2],
+    "bio17": [160.9, 155.8],
+    "bio18": [140.7, 145.4],
+    "bio19": [130.8, 128.7],
+}
+
+df = pd.DataFrame(data)
+
+# Predict probabilities
+probabilities = predict(df, dominant="exclude", c3_c4_correction=False)
+
+# Predict dominant vegetation type
+dominant_class = predict(df, dominant="only", c3_c4_correction=True)
+
+# Include probabilities and dominant type
+result = predict(df, dominant="include", c3_c4_correction=True)
+```
+
+---
+
+### **3. Predict Using Map-Like Data**
+
+#### **Input Data**
+Provide a Numpy array with shape `(m, n, 17)` where:
+- `m` and `n` represent the grid dimensions.
+- `17` represents the bioclimatic variables in the required order.
+
+#### **Example**
+```python
+import numpy as np
+from paleoveg import predict_map
+
+# Example 3D data: m = 5, n = 5, 17 predictors
+m, n = 5, 5
+data = np.random.rand(m, n, 17)
+
+# Predict probabilities (m x n x 11)
+probabilities_map = predict_map(data, dominant="exclude", c3_c4_correction=False)
+
+# Predict dominant type (m x n x 1)
+dominant_map = predict_map(data, dominant="only", c3_c4_correction=True)
+```
+
+---
+
+## **Functions**
+
+### **1. `predict(input_df, dominant="exclude", c3_c4_correction=False)`**
+Predict vegetation types for tabular data.
+
+#### **Parameters**:
+- `input_df` (pd.DataFrame): Input DataFrame with 17 bioclimatic variables.
+- `dominant` (str): Specifies the output format.
+  - `"exclude"`: Returns probabilities for each vegetation type.
+  - `"include"`: Returns probabilities and the dominant type.
+  - `"only"`: Returns only the dominant type.
+- `c3_c4_correction` (bool): If `True`, applies C3/C4 competition correction.
+
+#### **Returns**:
+- Pandas DataFrame: Probabilities and/or dominant type based on `dominant`.
+
+---
+
+### **2. `predict_map(data, dominant="exclude", c3_c4_correction=False)`**
+Predict vegetation types for 3D map-like data.
+
+#### **Parameters**:
+- `data` (np.ndarray): Input Numpy array with shape `(m, n, 17)`.
+- `dominant` (str): Specifies the output format.
+  - `"exclude"`: Returns probabilities `(m x n x 11)`.
+  - `"only"`: Returns the dominant type `(m x n x 1)`.
+- `c3_c4_correction` (bool): If `True`, applies C3/C4 competition correction.
+
+#### **Returns**:
+- Numpy array: Probabilities or dominant type based on `dominant`.
+
+---
+
+## **C3/C4 Competition Factors**
+When `c3_c4_correction=True`, the following factors are applied to adjust probabilities for higher CO2 levels:
+
+| Vegetation Type                | Competition Factor |
+|--------------------------------|--------------------|
+| Evergreen Needleleaf Forest    | 0.28              |
+| Evergreen Broadleaf Forest     | 0.73              |
+| Deciduous Needleleaf Forest    | 0.20              |
+| Deciduous Broadleaf Forest     | 0.76              |
+| Mixed Forest                   | 1.00              |
+| Closed Shrubland               | 1.66              |
+| Open Shrubland                 | 1.66              |
+| Woodland                       | 1.62              |
+| Wooded Grassland               | 1.62              |
+| Grassland                      | 1.69              |
+| Bare Ground                    | 1.15              |
+
+---
+
+## **License**
+This project is licensed under the MIT License.
+
+---
+
+## **Contributing**
+Contributions are welcome! Please submit a pull request or open an issue if you have suggestions or find bugs.
+
+---
+

paleoveg-0.1.0/paleoveg/__init__.py

@@ -0,0 +1 @@
+from .predictor import predict, predict_map

paleoveg-0.1.0/paleoveg/model_loader.py

@@ -0,0 +1,44 @@
+import os
+import requests
+import bz2
+import pickle
+from sklearn.ensemble import RandomForestClassifier
+
+def download_model():
+    """Download the model file from GitHub Releases if it does not exist locally."""
+    model_path = os.path.join(os.path.dirname(__file__), "model.pkl.bz2")
+    if not os.path.exists(model_path):
+        url = "https://github.com/roink/PaleoVeg/releases/download/v0.1.0/model.pkl.bz2"
+        print(f"Downloading model from {url}...")
+        response = requests.get(url, stream=True)
+        if response.status_code == 200:
+            with open(model_path, "wb") as f:
+                f.write(response.content)
+            print("Download complete.")
+        else:
+            raise Exception(f"Failed to download model. HTTP Status: {response.status_code}")
+    return model_path
+
+def load_model():
+    """
+    Load the compressed model and validate its type.
+
+    Returns:
+        model: The loaded Random Forest Classifier.
+
+    Raises:
+        ValueError: If the loaded model is not a RandomForestClassifier.
+    """
+    model_path = download_model()  # Ensure the model is downloaded
+
+    # Load the model
+    with bz2.BZ2File(model_path, "rb") as f:
+        model = pickle.load(f)
+
+    # Validate the loaded model
+    if not isinstance(model, RandomForestClassifier):
+        raise ValueError(f"The loaded model is not a RandomForestClassifier. Loaded type: {type(model)}")
+
+    return model
+
+

paleoveg-0.1.0/paleoveg/predictor.py

@@ -0,0 +1,209 @@
+import numpy as np
+import pandas as pd
+from .model_loader import load_model
+import warnings
+
+# Load the model once when the module is imported
+_model = load_model()
+
+# Define the required column names
+REQUIRED_COLUMNS = [
+    "bio1", "bio4", "bio5", "bio6", "bio7", "bio8", "bio9", "bio10",
+    "bio11", "bio12", "bio13", "bio14", "bio15", "bio16", "bio17", "bio18", "bio19"
+]
+
+# Define class names in the order used by the model
+CLASS_NAMES = [
+    'Evergreen Needleleaf Forest', 'Evergreen Broadleaf Forest', 
+    'Deciduous Needleleaf Forest', 'Deciduous Broadleaf Forest', 
+    'Mixed Forest', 'Woodland', 'Wooded Grassland', 'Closed Shrubland', 
+    'Open Shrubland', 'Grassland', 'Bare Ground'
+]
+
+# Define the C3/C4 competition factors
+COMPETITION_FACTORS = {
+    'Evergreen Needleleaf Forest': 0.28,
+    'Evergreen Broadleaf Forest': 0.73,
+    'Deciduous Needleleaf Forest': 0.20,
+    'Deciduous Broadleaf Forest': 0.76,
+    'Mixed Forest': 1.00,
+    'Closed Shrubland': 1.66,
+    'Open Shrubland': 1.66,
+    'Woodland': 1.62,
+    'Wooded Grassland': 1.62,
+    'Grassland': 1.69,
+    'Bare Ground': 1.15,
+}
+
+# Min and max values for bioclimatic variables in the training set
+BIOCLIM_RANGES = {
+    "bio1": (-54.72659, 30.94079),
+    "bio4": (0.0, 2361.791),
+    "bio5": (-29.69077, 48.16399),
+    "bio6": (-72.50053, 25.17328),
+    "bio7": (1.0, 72.02339),
+    "bio8": (-66.30019, 37.73918),
+    "bio9": (-54.83078, 37.51987),
+    "bio10": (-37.78683, 38.28006),
+    "bio11": (-66.33826, 29.06288),
+    "bio12": (0.0, 7953.816),
+    "bio13": (0.0, 2561.44),
+    "bio14": (0.0, 487.3488),
+    "bio15": (0.0, 229.0017),
+    "bio16": (0.0, 5597.44),
+    "bio17": (0.0, 1526.664),
+    "bio18": (0.0, 5190.888),
+    "bio19": (0.0, 4756.88),
+}
+
+def validate_ranges(input_df):
+    """
+    Validate that input values are within reasonable ranges.
+
+    Parameters:
+        input_df (pd.DataFrame): Input DataFrame.
+
+    Returns:
+        None: Issues warnings for out-of-range values.
+    """
+    for col, (min_val, max_val) in BIOCLIM_RANGES.items():
+        if col in input_df.columns:
+            out_of_range = (input_df[col] < min_val) | (input_df[col] > max_val)
+            if out_of_range.any():
+                warnings.warn(f"Column '{col}' contains values outside the range ({min_val}, {max_val}).")
+
+def validate_map_ranges(data):
+    """
+    Validate that map input values are within reasonable ranges.
+
+    Parameters:
+        data (np.ndarray): 3D array (m x n x 17) of predictor values.
+
+    Returns:
+        None: Issues warnings for out-of-range values.
+    """
+    for i, (min_val, max_val) in enumerate(BIOCLIM_RANGES.values()):
+        out_of_range = (data[..., i] < min_val) | (data[..., i] > max_val)
+        if out_of_range.any():
+            warnings.warn(f"Layer {i} contains values outside the range ({min_val}, {max_val}).")
+
+
+def validate_input(input_df):
+    """
+    Validate the input DataFrame for prediction.
+    Ensures it is a pandas DataFrame and contains the required columns.
+
+    Parameters:
+        input_df (pd.DataFrame): Input data for prediction.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If input is not a DataFrame or required columns are missing.
+    """
+    if not isinstance(input_df, pd.DataFrame):
+        raise ValueError("Input must be a pandas DataFrame.")
+    
+    missing_columns = [col for col in REQUIRED_COLUMNS if col not in input_df.columns]
+    if missing_columns:
+        raise ValueError(f"Missing required columns: {missing_columns}")
+
+def predict(input_df, dominant="exclude", c3_c4_correction=False):
+    """
+    Predict vegetation based on bioclimatic features and return probabilities or dominant class.
+
+    Parameters:
+        input_df (pd.DataFrame): Bioclimatic variables for prediction.
+        dominant (str): One of "exclude", "include", or "only".
+            - "exclude": Return probabilities for each class.
+            - "include": Include probabilities and a column with the dominant class.
+            - "only": Return only the dominant class.
+        c3_c4_correction (bool): If True, apply C3/C4 competition correction.
+
+    Returns:
+        pd.DataFrame: DataFrame containing probabilities and/or dominant vegetation class.
+    """
+    # Validate input (assuming validate_input has already been defined)
+    validate_input(input_df)
+
+    # Use only the required columns for prediction
+    input_df = input_df[REQUIRED_COLUMNS]
+    
+    # Check for out-of-range values
+    validate_ranges(input_df)
+
+    # Predict probabilities
+    probabilities = _model.predict_proba(input_df)
+
+    # Create a dataframe for the probabilities
+    prob_df = pd.DataFrame(probabilities, columns=CLASS_NAMES, index=input_df.index)
+
+    # Apply C3/C4 competition correction if enabled
+    if c3_c4_correction:
+        correction_factors = np.array([COMPETITION_FACTORS[class_name] for class_name in CLASS_NAMES])
+        prob_df = prob_df.multiply(correction_factors, axis=1)
+        prob_df = prob_df.div(prob_df.sum(axis=1), axis=0)  # Normalize to sum to 1
+
+    if dominant == "exclude":
+        return prob_df
+    elif dominant == "include":
+        # Add a column with the dominant class
+        prob_df["Dominant Class"] = prob_df.idxmax(axis=1)
+        return prob_df
+    elif dominant == "only":
+        # Return only the dominant class
+        dominant_classes = prob_df.idxmax(axis=1)
+        return dominant_classes.to_frame(name="Dominant Class")
+    else:
+        raise ValueError("Invalid value for 'dominant'. Must be 'exclude', 'include', or 'only'.")
+        
+        
+def predict_map(data, dominant="exclude", c3_c4_correction=False):
+    """
+    Predict vegetation for a 3D map input (m x n x 17) and return probabilities or dominant types.
+
+    Parameters:
+        data (numpy.ndarray): 3D array (m x n x 17) of predictor values.
+        dominant (str): One of "exclude" or "only".
+            - "exclude": Return probabilities for each class (m x n x 11).
+            - "only": Return the dominant type as integers (m x n x 1).
+        c3_c4_correction (bool): If True, apply C3/C4 competition correction.
+
+    Returns:
+        numpy.ndarray: m x n x 11 (probabilities) or m x n x 1 (dominant type).
+    """
+    if not isinstance(data, np.ndarray):
+        raise ValueError("Input data must be a numpy array.")
+    
+    if data.ndim != 3 or data.shape[2] != 17:
+        raise ValueError("Input data must have shape (m x n x 17).")
+        
+    validate_map_ranges(data)
+
+    # Reshape the 3D array into a 2D array (flatten grid cells)
+    m, n, _ = data.shape
+    flat_data = data.reshape(-1, 17)
+
+    # Predict probabilities
+    probabilities = _model.predict_proba(flat_data)
+
+    # Apply C3/C4 correction if enabled
+    if c3_c4_correction:
+        correction_factors = np.array([COMPETITION_FACTORS[class_name] for class_name in CLASS_NAMES])
+        probabilities *= correction_factors
+        probabilities /= probabilities.sum(axis=1, keepdims=True)  # Normalize to sum to 1
+
+    # Reshape probabilities back to m x n x 11
+    probabilities_reshaped = probabilities.reshape(m, n, -1)
+
+    if dominant == "exclude":
+        # Return probabilities (m x n x 11)
+        return probabilities_reshaped
+    elif dominant == "only":
+        # Find dominant class (integer indices)
+        dominant_classes = probabilities.argmax(axis=1).reshape(m, n, 1)
+        return dominant_classes
+    else:
+        raise ValueError("Invalid value for 'dominant'. Must be 'exclude' or 'only'.")
+

paleoveg-0.1.0/paleoveg/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="PaleoVeg",
+    version="0.1.0",
+    description="Predict paleovegetation from bioclimatic variables.",
+    author="Philipp Schlüter",
+    author_email="p.schlueter@uni-koeln.de",
+    url="https://github.com/roink/PaleoVeg",  # Replace with actual URL
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "scikit-learn>=1.0",
+        "numpy>=1.21",
+        pandas,
+        joblib,
+        matplotlib,
+        cartopy,
+        pickle,
+        bz2,
+        requests
+    ],
+    package_data={
+        "paleoveg": ["model.pkl.bz2"],  # Include the model file
+    },
+    python_requires=">=3.6",
+)
+

paleoveg-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

paleoveg-0.1.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="PaleoVeg",
+    version="0.1.0",
+    description="Predict paleovegetation from bioclimatic variables.",
+    author="Philipp Schlüter",
+    author_email="p.schlueter@uni-koeln.de",
+    url="https://github.com/roink/PaleoVeg",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "scikit-learn>=1.5.2",
+        "numpy>=2.1.3",
+        "pandas>=2.2.3",
+        "joblib",
+        "matplotlib",
+        "cartopy",
+	"requests"
+    ],
+    package_data={
+        "paleoveg": ["model.pkl.bz2"],  # Include the model file
+    },
+    python_requires=">=3.7",
+)
+

paleoveg-0.1.0/tests/test_predictor.py

@@ -0,0 +1,111 @@
+import numpy as np
+import pandas as pd
+import pytest
+from paleoveg import predict, predict_map
+
+BIOCLIM_RANGES = {
+    "bio1": (-54.72659, 30.94079),
+    "bio4": (0.0, 2361.791),
+    "bio5": (-29.69077, 48.16399),
+    "bio6": (-72.50053, 25.17328),
+    "bio7": (1.0, 72.02339),
+    "bio8": (-66.30019, 37.73918),
+    "bio9": (-54.83078, 37.51987),
+    "bio10": (-37.78683, 38.28006),
+    "bio11": (-66.33826, 29.06288),
+    "bio12": (0.0, 7953.816),
+    "bio13": (0.0, 2561.44),
+    "bio14": (0.0, 487.3488),
+    "bio15": (0.0, 229.0017),
+    "bio16": (0.0, 5597.44),
+    "bio17": (0.0, 1526.664),
+    "bio18": (0.0, 5190.888),
+    "bio19": (0.0, 4756.88),
+}
+
+
+# Mock input data for tabular predictions
+@pytest.fixture
+def tabular_data():
+    data = {
+        "bio1": [-10.0, 15.0],  # Within range (-54.72659, 30.94079)
+        "bio4": [1000.0, 500.0],  # Within range (0.0, 2361.791)
+        "bio5": [20.0, 30.0],  # Within range (-29.69077, 48.16399)
+        "bio6": [-20.0, 5.0],  # Within range (-72.50053, 25.17328)
+        "bio7": [10.0, 50.0],  # Within range (1.0, 72.02339)
+        "bio8": [-30.0, 20.0],  # Within range (-66.30019, 37.73918)
+        "bio9": [-40.0, 10.0],  # Within range (-54.83078, 37.51987)
+        "bio10": [-20.0, 10.0],  # Within range (-37.78683, 38.28006)
+        "bio11": [-30.0, 15.0],  # Within range (-66.33826, 29.06288)
+        "bio12": [300.0, 700.0],  # Within range (0.0, 7953.816)
+        "bio13": [100.0, 200.0],  # Within range (0.0, 2561.44)
+        "bio14": [50.0, 100.0],  # Within range (0.0, 487.3488)
+        "bio15": [10.0, 50.0],  # Within range (0.0, 229.0017)
+        "bio16": [300.0, 500.0],  # Within range (0.0, 5597.44)
+        "bio17": [100.0, 200.0],  # Within range (0.0, 1526.664)
+        "bio18": [200.0, 400.0],  # Within range (0.0, 5190.888)
+        "bio19": [100.0, 300.0],  # Within range (0.0, 4756.88)
+    }
+    return pd.DataFrame(data)
+
+# Mock input data for map-like predictions
+@pytest.fixture
+def map_data():
+    m, n = 5, 5
+    data = np.random.uniform(
+        low=[BIOCLIM_RANGES[var][0] for var in BIOCLIM_RANGES.keys()],
+        high=[BIOCLIM_RANGES[var][1] for var in BIOCLIM_RANGES.keys()],
+        size=(m, n, 17)
+    )
+    return data
+
+def test_predict_probabilities(tabular_data):
+    # Test predict function with probabilities output
+    result = predict(tabular_data, dominant="exclude", c3_c4_correction=False)
+    assert isinstance(result, pd.DataFrame)
+    assert result.shape == (2, 11)  # 2 rows, 11 vegetation types
+    assert np.isclose(result.sum(axis=1).values, 1).all()  # Probabilities sum to 1
+
+def test_predict_dominant_only(tabular_data):
+    # Test predict function with dominant output
+    result = predict(tabular_data, dominant="only", c3_c4_correction=False)
+    assert isinstance(result, pd.DataFrame)
+    assert result.shape == (2, 1)  # 2 rows, 1 dominant type
+    assert result.iloc[:, 0].isin([
+        'Evergreen Needleleaf Forest', 'Evergreen Broadleaf Forest',
+        'Deciduous Needleleaf Forest', 'Deciduous Broadleaf Forest',
+        'Mixed Forest', 'Woodland', 'Wooded Grassland',
+        'Closed Shrubland', 'Open Shrubland', 'Grassland', 'Bare Ground'
+    ]).all()
+
+def test_predict_map_probabilities(map_data):
+    # Test predict_map function with probabilities output
+    result = predict_map(map_data, dominant="exclude", c3_c4_correction=False)
+    assert isinstance(result, np.ndarray)
+    assert result.shape == (5, 5, 11)  # m x n x 11
+    assert np.isclose(result.sum(axis=2), 1).all()  # Probabilities sum to 1 for each grid cell
+
+def test_predict_map_dominant_only(map_data):
+    # Test predict_map function with dominant output
+    result = predict_map(map_data, dominant="only", c3_c4_correction=False)
+    assert isinstance(result, np.ndarray)
+    assert result.shape == (5, 5, 1)  # m x n x 1
+    assert np.issubdtype(result.dtype, np.integer)
+
+def test_c3_c4_correction(tabular_data):
+    # Test C3/C4 correction
+    result_no_correction = predict(tabular_data, dominant="exclude", c3_c4_correction=False)
+    result_with_correction = predict(tabular_data, dominant="exclude", c3_c4_correction=True)
+    assert not result_no_correction.equals(result_with_correction)  # Results should differ
+    assert np.isclose(result_with_correction.sum(axis=1).values, 1).all()  # Probabilities still sum to 1
+    
+def test_predict_out_of_range(tabular_data):
+    tabular_data["bio1"][0] = -100.0  # Out-of-range value
+    with pytest.warns(UserWarning, match="Column 'bio1' contains values outside the range"):
+        predict(tabular_data)
+
+def test_predict_map_out_of_range(map_data):
+    map_data[0, 0, 0] = -100.0  # Out-of-range value for bio1
+    with pytest.warns(UserWarning, match="Layer 0 contains values outside the range"):
+        predict_map(map_data)
+