Revert last upload

.gitattributes

@@ -0,0 +1,61 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+Test_data/For_leaf_counting/okra/p1/d22/L2/PXL_20230808_110153626_6.dng filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,195 @@
+---
+license: cc-by-4.0
+task_categories:
+- image-classification
+- text-to-image
+- image-to-text
+language:
+- en
+tags:
+- plant-growth
+- phenotyping
+- agriculture
+- multiview
+- time-series
+- leaf-counting
+- age-estimation
+- precision-agriculture
+pretty_name: GroMo 25 — Multiview Plant Growth Dataset
+size_categories:
+- 10K<n<100K
+---
+
+# GroMo25: Multiview Time-Series Plant Image Dataset for Age Estimation and Leaf Counting
+
+## Dataset Summary
+
+**GroMo25** is a multiview, time-series plant image dataset designed for plant age estimation (in days) and leaf counting tasks in precision agriculture. It contains high-quality images of four crop species — **Wheat, Okra, Radish, and Mustard** — captured over multiple days under controlled conditions. Each plant is photographed from 24 angles across 5 vertical levels per day, providing rich spatial and temporal information for plant growth modeling.
+
+This dataset is intended for researchers and practitioners in **academic research, plant phenotyping, and agriculture**, and serves as the official dataset for the **GroMo Challenge**.
+
+>  **Paper:** [GroMo Challenge: Multiview time-series plant image dataset for age estimation and leaf counting in precision agriculture](https://dl.acm.org/doi/abs/10.1145/3746027.3762097)
+
+---
+
+## Dataset Structure
+
+### Crops Included
+
+| Crop    | Description                             |
+|---------|-----------------------------------------|
+| Wheat   | Cereal crop,    multiple growth stages  |
+| Okra    | Vegetable crop, leaf-heavy growth       |
+| Radish  | Root vegetable, rapid growth cycle      |
+| Mustard | Oilseed crop,   distinct leaf pattern   |
+
+### Image Capture Setup
+
+All images were captured in a **controlled indoor environment**:
+- Each plant is grown in a **pot** placed on a **rotating disk**
+- The background is covered with a **white cloth** to ensure clean segmentation and consistent background
+- Images are taken at **24 angles** per level (0° to 345°, 15° increment between consecutive angles)
+- Each plant is photographed across **5 vertical levels** (L1 to L5) per day
+
+### Images Per Day (Per Plant)
+
+```
+5 levels × 24 angles = 120 images per plant per day
+```
+
+### Directory Structure
+
+```
+dataset/
+├── train/
+│   ├── p1/
+│   │   ├── d1/
+│   │   │   ├── L1/
+│   │   │   │   ├── radish_p1_d1_L1_0.png
+│   │   │   │   ├── radish_p1_d1_L1_15.png
+│   │   │   │   ├── ...
+│   │   │   │   └── radish_p1_d1_L1_345.png
+│   │   │   ├── L2/
+│   │   │   ├── L3/
+│   │   │   ├── L4/
+│   │   │   └── L5/
+│   │   ├── d2/
+│   │   └── ...
+│   ├── p2/
+│   ├── p3/
+│   └── p4/
+└── test/
+    └── (same structure as train)
+```
+
+### File Naming Convention
+
+Each image follows the format:
+
+```
+{crop}_p{X}_d{Y}_L{Z}_{A}.png
+```
+
+| Field | Description |
+|-------|-------------|
+| `crop` | Crop name (e.g., `radish`, `wheat`) |
+| `X` | Plant ID (e.g., `p1`, `p2`) |
+| `Y` | Day number (e.g., `d1`, `d2`) |
+| `Z` | Level (L1 to L5) |
+| `A` | Angle in degrees (0 to 345, step 15) |
+
+**Example:** `radish_p1_d3_L2_90.png` → Radish, Plant 1, Day 3, Level 2, angle 90°
+
+---
+
+## Ground Truth / Annotations
+
+Each crop has a corresponding `{crop}_train.csv` file containing per-image labels.
+
+### Format
+
+| Column | Description |
+|--------|-------------|
+| `filename` | Relative path to the image |
+| `leaf_count` | Number of leaves on the plant |
+| `Age` | Age of the plant in days |
+
+### Example
+```csv
+filename,leaf_count,Age
+mustard/p1/d1/L1/mustard_p1_d1_L1_0.png,2,1
+```
+
+A separate CSV is provided for each crop covering all plants, days, levels, and angles.
+
+---
+
+## Tasks
+
+This dataset supports the following tasks:
+
+- **Plant Age Estimation** — Predict the number of days since planting (regression)
+- **Leaf Counting** — Predict the number of leaves visible on the plant (regression)
+
+### Evaluation Metrics
+
+| Metric | Description |
+|--------|-------------|
+| RMSE | Root Mean Squared Error |
+| MAE  | Mean Absolute Error |
+
+---
+
+## Citation
+
+If you use this dataset in your research, please cite:
+
+```bibtex
+@inproceedings{10.1145/3746027.3762097,
+author = {Bansal, Shreya and Bhatt, Ruchi and Chander, Amanpreet and Kaur, Rupinder and Singh, Malya and Kankanhalli, Mohan and El Saddik, Abdulmotaleb and Saini, Mukesh},
+title = {GroMo25: ACM Multimedia 2025 Grand Challenge for Plant Growth Modeling with Multiview Images},
+year = {2025},
+isbn = {9798400720352},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3746027.3762097},
+doi = {10.1145/3746027.3762097},
+abstract = {Understanding plant growth dynamics is a critical component of modern agricultural research, with applications in yield prediction, phenotyping, and sustainable crop management. Despite recent advances in computer vision and deep learning, progress in plant growth modeling has been constrained by the lack of publicly available, high-resolution, multiview, and temporally rich datasets. To address this gap, we introduce Growth Modelling GroMo25, the first international challenge on plant growth modeling using multiview imagery. In this challenge, we propose a dataset that comprises high-resolution images of four crops: wheat, mustard, radish, and okra, captured at consistent time intervals from multiple camera viewpoints under controlled environmental conditions. The challenge focuses on two key tasks: (1) plant age prediction and (2) leaf count estimation, both requiring models to use spatial and temporal plant features. GroMo25 attracted participation from multiple teams worldwide, encouraging benchmarking and innovation in vision-based plant phenotyping. The GitHub repository is publicly available at https://github.com/mriglab/GroMo-Plant-Growth-Modeling-with-Multiview-Images.},
+booktitle = {Proceedings of the 33rd ACM International Conference on Multimedia},
+pages = {14204–14209},
+numpages = {6},
+keywords = {growth age prediction, leaf count estimation, multiview},
+location = {Dublin, Ireland},
+series = {MM '25}
+}
+```
+
+---
+
+## Authors & Affiliations
+
+| Name | Institution |
+|------|------------|
+| Shreya Bansal | IIT Ropar |
+| Ruchi Bhatt | IIT Ropar |
+| Amanpreet Chander | IIT Ropar |
+| Rupinder Kaur | IIT Ropar |
+| Malya Singh | IIT Ropar |
+| Dr. Mohan Kankanhalli | National University of Singapore |
+| Abdulmotaleb El Saddik | University of Ottawa |
+| Mukesh Kumar Saini | IIT Ropar |
+
+ For queries, contact: **mrig@iitrpr.ac.in**
+
+---
+
+## License
+
+This dataset is released under the [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) license.
+
+You are free to use, share, and adapt this dataset for any purpose, including commercial use, as long as appropriate credit is given to the authors.
+
+---
+
+## Note
+The dataset is part of a challenge organised by [ANNAM.AI](http://data.annam.ai/gromo25/)

Test_data/For_age_prediction/acm_test_py.py

@@ -0,0 +1,336 @@
+# -*- coding: utf-8 -*-
+"""acm_test.py.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1iMB_SLHX4vbCzsA_7Q8MJe-SSKX4Cphr
+"""
+
+from google.colab import drive
+drive.mount('/content/drive')
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader, random_split
+from torchvision import transforms
+import os
+from PIL import Image
+import random
+import numpy as np
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn.metrics import r2_score, mean_absolute_error
+
+# Define the device (GPU or CPU)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(device)
+
+################################# Input here ###################################
+root_path='/content/drive/MyDrive/ACM grand challenge/Test_data/For_age_prediction/'
+csv_file='/content/okra_test.csv'
+crop='okra'
+n_images=4
+plant_input=2
+days_input=86
+batch_size = 8
+seed=42
+height, width = 224, 224
+# Transformations for resizing and converting to tensor
+transform = transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor()])
+##############################################################################
+
+class CropDataset(Dataset):
+    def __init__(self, root_dir, csv_file, images_per_level, crop, plants, days,
+                 levels=['L1', 'L2', 'L3', 'L4', 'L5'], transform=None):
+        """
+        Args:
+            root_dir (str): Directory with all the images.
+            csv_file (str): Path to the CSV file containing ground truth (filename, leaf_count, age).
+            images_per_level (int): Number of images to select per level (should be factors of 24).
+            crop (str): Crop type (e.g., "radish").
+            plants (int): Number of plants (e.g., 4).
+            days (int): Number of days (e.g., 59).
+            levels (list): List of levels (e.g., ['L1', 'L2', 'L3', 'L4', 'L5']).
+            transform (callable, optional): Transform to be applied on a sample.
+        """
+        self.root_dir = root_dir
+        self.csv_file = csv_file
+        self.images_per_level = images_per_level
+        self.crop = crop
+        self.plants_num = plants
+        self.max_days = days
+        self.levels = levels
+        self.transform = transform
+        self.image_data = self._load_metadata()
+        self.image_paths = self._load_image_paths()
+
+    def _load_metadata(self):
+        """Load CSV file into a pandas DataFrame and map filenames to leaf counts and ages."""
+        df = pd.read_csv(self.csv_file)
+        df["filename"] = df["filename"].astype(str)  # Ensure filenames are strings
+        return df.set_index("filename")  # Use filename as the index for quick lookup
+
+    def _select_angles(self):
+        """
+        Select angles dynamically for a given level.
+        """
+        images_needed = self.images_per_level
+        selected_angles = [i for i in range(0, 360, int(360 / images_needed))]
+
+        initial_angles = [i for i in range(15, selected_angles[1], 15)]
+        multiple_selections = [selected_angles]
+
+        for initial_angle in initial_angles:
+            selection = [initial_angle]
+            while len(selection) < images_needed:
+                next_angle = (selection[-1] + int(360 / images_needed)) % 360
+                if next_angle not in selection:
+                    selection.append(next_angle)
+            multiple_selections.append(selection)
+        print(multiple_selections)
+        return multiple_selections
+
+    def _load_image_paths(self):
+        """
+        Load image paths for all levels and plants based on the selection of angles.
+        """
+        image_paths = []
+        multiple_selections = self._select_angles()
+
+        for plant in range(1, self.plants_num + 1):
+            plant_path = os.path.join(self.root_dir, crop, f"p{plant}")
+            if not os.path.isdir(plant_path):
+                print(f"Plant directory not found: {plant_path}")
+                continue
+            for day in range(1, self.max_days + 1):
+                day_path = os.path.join(self.root_dir, crop, f"p{plant}", f"d{day}")
+                if not os.path.isdir(day_path):
+                    continue
+                for selected_angles in multiple_selections:
+                    for level in self.levels:
+                        level_path = os.path.join(self.root_dir,self.crop, f"p{plant}", f"d{day}", level)
+                        level_image_paths = [
+                            os.path.join(level_path, f"{self.crop}_p{plant}_d{day}_{level}_{angle}.png")
+                            for angle in selected_angles
+                        ]
+                        filename = os.path.join(self.crop,f"p{plant}", f"d{day}", level,f"{self.crop}_p{plant}_d{day}_{level}_{selected_angles[0]}.png")
+                        print(filename)
+                        leaf_count = self.image_data.loc[filename, "leaf_count"]
+                        # print(level_image_paths)
+                        image_paths.append((level_image_paths, leaf_count,day))  # Append day number along with image paths
+
+        print(f"Total samples loaded: {len(image_paths)}")
+        # print(f"individual sample size: {len(image_paths[0][0])}")
+        return image_paths
+
+
+    def __len__(self):
+        return len(self.image_paths)
+
+
+    def __getitem__(self, idx):
+        """
+        Get a batch of images from the dataset corresponding to the angles selected.
+        """
+        images = []
+        leaf_count = self.image_paths[idx][1]
+        age = self.image_paths[idx][2]
+        # print(leaf_count,age)
+        all_images= self.image_paths[idx][0]
+        # print("length of all images:", len(all_images))
+        for img_path in all_images:  # Get the image paths for this sample
+            if os.path.isfile(img_path):
+                  level_image = Image.open(img_path)
+                  if self.transform:
+                      level_image = self.transform(level_image)
+                  images.append(level_image)
+            else:
+                    print(f"Path is not a valid file: {img_path}")
+
+        images = torch.cat(images, dim=0)
+
+        return images, torch.tensor(leaf_count, dtype=torch.float32), torch.tensor(age, dtype=torch.float32)  # Return both images and the corresponding day as ground truth
+
+test_dataset = CropDataset(root_dir=root_path,
+                      csv_file=csv_file,
+                      images_per_level=n_images,
+                      crop=crop,
+                      plants=plant_input,
+                      days=days_input,
+                      transform=transform)
+
+num_images = n_images  # Number of images (24 RGB images)
+input_channels = num_images*3  # 24 RGB images (3 channels each)
+patch_size = 16  # Size of each patch
+num_patches = (height // patch_size) * (width // patch_size)  # Number of patches (14 * 14 for 224x224 images)
+projection_dim = 256  # Embedding dimension for each patch
+num_heads = 8  # Number of attention heads
+num_layers = 6  # Number of transformer layers
+mlp_dim = 512  # Dimension of the MLP head
+num_classes = 1  # Number of output classes (for day or leaf count prediction)
+dropout_rate = 0.1  # Dropout rate
+
+
+
+
+# DataLoader for training and validation sets
+test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
+
+class VisionTransformer(nn.Module):
+    def __init__(self, input_channels, patch_size, num_patches, projection_dim, num_heads, num_layers, mlp_dim, num_images, dropout_rate=0.1):
+        super(VisionTransformer, self).__init__()
+
+        self.num_images = num_images  # Total number of images (24 images in your case)
+        self.patch_size = patch_size
+        self.num_patches = num_patches
+        self.projection_dim = projection_dim
+        self.num_heads = num_heads
+        self.num_layers = num_layers
+        self.mlp_dim = mlp_dim
+
+        # Separate patch embedding layers for each image (RGB)
+        self.patch_embeds = nn.ModuleList([
+            nn.Conv2d(input_channels // num_images, projection_dim, kernel_size=patch_size, stride=patch_size)
+            for _ in range(num_images)
+        ])
+
+        # Positional Encoding (Learnable)
+        self.positional_encoding = nn.Parameter(torch.randn(1, num_patches, projection_dim))
+
+        # Transformer Encoder Layers (modified to return attention weights)
+        self.attention_layers = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                d_model=projection_dim,
+                nhead=num_heads,
+                dim_feedforward=mlp_dim,
+                dropout=dropout_rate,
+                batch_first=True
+            )
+            for _ in range(num_layers)
+        ])
+
+        # MLP Head for classification/regression
+        self.mlp_head = nn.Sequential(
+            nn.Linear(projection_dim * num_images, mlp_dim),
+            nn.ReLU(),
+            nn.Linear(mlp_dim, 1)
+        )
+
+    def forward(self, x):
+        batch_size = x.shape[0]
+
+        # Step 1: Patch Embedding (Separate for each image)
+        patch_embeddings = []
+        for i in range(self.num_images):
+            # Split the input channels into separate images (3 channels each for RGB)
+            img_x = x[:, i*3:(i+1)*3, :, :]  # Shape: (batch_size, 3, height, width)
+            patch_embed = self.patch_embeds[i](img_x)  # Apply separate embedding
+            patch_embed = patch_embed.flatten(2).transpose(1, 2)  # Shape: (batch_size, num_patches, projection_dim)
+            patch_embeddings.append(patch_embed)
+
+        # Step 2: Add Positional Encoding
+        patch_embeddings = [pe + self.positional_encoding for pe in patch_embeddings]
+
+        # Step 3: Transformer Encoder Layers (Self-attention + Feed Forward)
+        attention_weights = []  # To store attention weights
+        for layer in self.attention_layers:
+            layer_attention_weights = []  # Store the attention weights for each layer
+            for i in range(self.num_images):
+                # Modified to return attention weights (self-attention)
+                attn_output, attn_weights = layer.self_attn(patch_embeddings[i], patch_embeddings[i], patch_embeddings[i])
+                patch_embeddings[i] = attn_output
+                layer_attention_weights.append(attn_weights)
+            attention_weights.append(layer_attention_weights)
+
+        # Step 4: Concatenate the projections from each image (Shape: (batch_size, num_patches, projection_dim * num_images))
+        x = torch.cat(patch_embeddings, dim=-1)  # Concatenate across the last dimension (projection_dim)
+
+        # Step 5: Pooling (Take mean across all patches)
+        x = x.mean(dim=1)  # Mean pooling over patches (Shape: (batch_size, projection_dim * num_images))
+
+        # Step 6: MLP Head for classification/regression
+        output = self.mlp_head(x)
+
+        return output, attention_weights  # Return attention weights too
+
+# Load the trained model
+model_path = "/content/drive/MyDrive/ACM grand challenge/Crops data/For_age_prediction/results/okra_all files/okra_vit_age_prediction_10.pth"  # Change this to your actual model path
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Assuming your model class is defined as MyModel
+model = VisionTransformer(input_channels, patch_size, num_patches, projection_dim, num_heads, num_layers, mlp_dim, num_images, dropout_rate)  # Replace with your actual model class
+model.load_state_dict(torch.load(model_path, map_location=device))
+model.to(device)
+model.eval()  # Set model to evaluation mode
+
+# Initialize lists to store predictions and actual values
+y_true = []
+y_pred = []
+
+# Run inference on the test set
+with torch.no_grad():
+    for images, count, age in test_loader:  # Assuming test_loader gives (images, labels)
+        images = images.to(device)
+        count = count.to(device)
+        age = age.to(device)
+
+        outputs, attention = model(images)  # Ensure outputs are properly shaped
+        y_true.extend(age.cpu().numpy())
+        y_pred.extend(outputs.cpu().numpy())
+
+# Convert to NumPy arrays
+y_true = np.array(y_true)
+y_pred = np.array(y_pred)
+
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+# Compute metrics
+rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+mae = mean_absolute_error(y_true, y_pred)
+r2 = r2_score(y_true, y_pred)
+
+# Print results
+print(f"RMSE: {rmse:.4f}")
+print(f"MAE: {mae:.4f}")
+print(f"R² Score: {r2:.4f}")
+
+# Load the trained model
+model_path = "/content/drive/MyDrive/ACM grand challenge/Crops data/For_age_prediction/results/okra_all files/okra_vit_leaf_count_8.pth"  # Change this to your actual model path
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Assuming your model class is defined as MyModel
+model = VisionTransformer(input_channels, patch_size, num_patches, projection_dim, num_heads, num_layers, mlp_dim, num_images, dropout_rate)  # Replace with your actual model class
+model.load_state_dict(torch.load(model_path, map_location=device))
+model.to(device)
+model.eval()  # Set model to evaluation mode
+
+# Initialize lists to store predictions and actual values
+y_true = []
+y_pred = []
+
+# Run inference on the test set
+with torch.no_grad():
+    for images, count, age in test_loader:  # Assuming test_loader gives (images, labels)
+        images = images.to(device)
+        count = count.to(device)
+        count = count.to(device)
+
+        outputs, attention = model(images)  # Ensure outputs are properly shaped
+        y_true.extend(count.cpu().numpy())
+        y_pred.extend(outputs.cpu().numpy())
+
+# Convert to NumPy arrays
+y_true = np.array(y_true)
+y_pred = np.array(y_pred)
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+# Compute metrics
+rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+mae = mean_absolute_error(y_true, y_pred)
+r2 = r2_score(y_true, y_pred)
+
+# Print results
+print(f"RMSE: {rmse:.4f}")
+print(f"MAE: {mae:.4f}")
+print(f"R² Score: {r2:.4f}")