py3dcal 1.0.0__py3-none-any.whl

py3DCal/data_collection/Sensors/Sensor.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+
+class Sensor(ABC):
+    """
+    Sensor: An abstract base class for tactile sensors.
+    """
+    def __init__(self):
+        self.name = ""
+        self.x_offset = 5
+        self.y_offset = 5
+        self.z_offset = 5
+        self.z_clearance = 2
+        self.max_penetration = 0
+        self.default_calibration_file = "calibration_procs/digit/default.csv"
+
+    @abstractmethod
+    def connect(self):
+        """ Connects to the sensor
+        """
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """ Disconnects from the sensor
+        """
+        pass
+
+    @abstractmethod
+    def capture_image(self):
+        """ Captures an image from the sensor
+
+        Returns:
+            numpy.ndarray: The image from the sensor.
+        """
+        pass

py3DCal/model_training/datasets/DIGIT_dataset.py

@@ -0,0 +1,75 @@
+import os
+import requests
+import tarfile
+from tqdm import tqdm
+from typing import Union
+from pathlib import Path
+from .tactile_sensor_dataset import TactileSensorDataset
+from ..lib.validate_parameters import validate_root
+
+
+class DIGIT(TactileSensorDataset):
+    """
+    DIGIT: A Dataset Class for the DIGIT sensor
+    Args:
+        root (str or pathlib.Path): The root directory containing digit_calibration_data.
+        download (bool, optional): If True, downloads the dataset for the specified sensor type. Defaults to False.
+        add_coordinate_embeddings (bool, optional): If True, adds xy coordinate embeddings to each image. Defaults to True.
+        subtract_blank (bool, optional): If True, subtracts a blank image from each input image. Defaults to False.
+        transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed version. Default: ``transforms.ToTensor()``
+    """
+    def __init__(self, root: Union[str, Path] = Path("."), download=False, add_coordinate_embeddings=True, subtract_blank=True, transform=None):
+        validate_root(root)
+
+        self.dataset_path = os.path.join(root, "digit_calibration_data")
+
+        super().__init__(root=self.dataset_path, add_coordinate_embeddings=add_coordinate_embeddings, subtract_blank=subtract_blank, transform=transform)
+
+        if download:
+            self._download_dataset()
+
+    def _download_dataset(self):
+        """
+        Downloads the dataset for either the DIGIT sensor.
+
+        """
+        # Check if self.dataset_path exists
+        if not os.path.exists(self.dataset_path):
+            os.makedirs(self.root, exist_ok=True)
+
+            tar_path = os.path.join(self.root, "digit_calibration_data.tar.gz")
+
+            print(f"Downloading DIGIT dataset ...")
+            response = requests.get('https://zenodo.org/records/17517028/files/digit_calibration_data.tar.gz?download=1', stream=True)
+            response.raise_for_status()
+
+            total_size = int(response.headers.get('content-length', 0))
+            block_size = 1024
+
+            # Save file in chunks to handle large datasets
+            with open(tar_path, 'wb') as f, tqdm(
+                total=total_size,
+                unit='B',
+                unit_scale=True,
+                desc="Downloading",
+                ncols=80
+            ) as progress_bar:
+                for chunk in response.iter_content(chunk_size=block_size):
+                    if chunk:
+                        f.write(chunk)
+                        progress_bar.update(len(chunk))
+
+            print(f"Download complete!")
+
+            # Extract .tar.gz file
+            print("Extracting files ...")
+            with tarfile.open(tar_path, "r:gz") as tar:
+                tar.extractall(path=self.root)
+
+            os.remove(tar_path)
+
+            print(f"Extraction complete! Files are in: {self.root}/")
+
+        else:
+            print(f"DIGIT dataset already exists at: {self.dataset_path}/")
+

py3DCal/model_training/datasets/GelSightMini_dataset.py

@@ -0,0 +1,73 @@
+import os
+import requests
+import tarfile
+from tqdm import tqdm
+from typing import Union
+from pathlib import Path
+from .tactile_sensor_dataset import TactileSensorDataset
+from ..lib.validate_parameters import validate_root
+
+
+class GelSightMini(TactileSensorDataset):
+    """
+    GelSight Mini: A Dataset Class for the GelSight Mini sensor
+    Args:
+        root (str or pathlib.Path): The root directory containing gsmini_calibration_data.
+        download (bool, optional): If True, downloads the dataset for the specified sensor type. Defaults to False.
+        add_coordinate_embeddings (bool, optional): If True, adds xy coordinate embeddings to each image. Defaults to True.
+        subtract_blank (bool, optional): If True, subtracts a blank image from each input image. Defaults to False.
+        transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed version. Default: ``transforms.ToTensor()``
+    """
+    def __init__(self, root: Union[str, Path] = Path("."), download=False, add_coordinate_embeddings=True, subtract_blank=True, transform=None):
+        validate_root(root)
+
+        self.dataset_path = os.path.join(root, "gsmini_calibration_data")
+
+        super().__init__(root=self.dataset_path, add_coordinate_embeddings=add_coordinate_embeddings, subtract_blank=subtract_blank, transform=transform)
+
+        if download:
+            self._download_dataset()
+
+    def _download_dataset(self):
+        """
+        Downloads the dataset for the GelSight Mini sensor.
+        """
+        # Check if self.dataset_path exists
+        if not os.path.exists(self.dataset_path):
+            os.makedirs(self.root, exist_ok=True)
+            
+            tar_path = os.path.join(self.root, "gsmini_calibration_data.tar.gz")
+
+            print(f"Downloading GelSight Mini dataset ...")
+            response = requests.get('https://zenodo.org/records/17517028/files/gsmini_calibration_data.tar.gz?download=1', stream=True)
+            response.raise_for_status()
+
+            total_size = int(response.headers.get('content-length', 0))
+            block_size = 1024
+
+            # Save file in chunks to handle large datasets
+            with open(tar_path, 'wb') as f, tqdm(
+                total=total_size,
+                unit='B',
+                unit_scale=True,
+                desc="Downloading",
+                ncols=80
+            ) as progress_bar:
+                for chunk in response.iter_content(chunk_size=block_size):
+                    if chunk:
+                        f.write(chunk)
+                        progress_bar.update(len(chunk))
+
+            print(f"Download complete!")
+
+            # Extract .tar.gz file
+            print("Extracting files ...")
+            with tarfile.open(tar_path, "r:gz") as tar:
+                tar.extractall(path=self.root)
+
+            os.remove(tar_path)
+
+            print(f"Extraction complete! Files are in: {self.root}/")
+
+        else:
+            print(f"GelSight Mini dataset already exists at: {self.dataset_path}/")

py3DCal/model_training/datasets/__init__.py

@@ -0,0 +1,3 @@
+from .tactile_sensor_dataset import TactileSensorDataset
+from .DIGIT_dataset import DIGIT
+from .GelSightMini_dataset import GelSightMini

py3DCal/model_training/datasets/split_dataset.py

@@ -0,0 +1,38 @@
+import copy
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from .tactile_sensor_dataset import TactileSensorDataset
+
+def split_dataset(dataset, train_ratio=0.8):
+    """
+    Splits a dataset into training and validation sets.
+
+    Args:
+        dataset (py3DCal.datasets.TactileSensorDataset): The dataset to split.
+        train_ratio (float): The proportion of the dataset to include in the training set. Default is 0.8.
+
+    Returns:
+        tuple: A tuple containing the training and validation datasets.
+    """
+    if not isinstance(dataset, TactileSensorDataset):
+        raise TypeError("Expected dataset to be an instance of py3DCal.datasets.TactileSensorDataset")
+
+    df = dataset.data.copy()
+
+    unique_coords = df[['x_mm', 'y_mm']].drop_duplicates().reset_index(drop=True)
+
+    train_df, val_df = train_test_split(unique_coords, train_size=train_ratio, random_state=42)
+
+    # Merge back to get full rows
+    train_data = pd.merge(df, train_df, on=['x_mm', 'y_mm'])
+    val_data = pd.merge(df, val_df, on=['x_mm', 'y_mm'])
+
+    # Create two copies of the original dataset
+    train_dataset = copy.deepcopy(dataset)
+    val_dataset = copy.deepcopy(dataset)
+
+    # Update the data attribute of each dataset
+    train_dataset.data = train_data
+    val_dataset.data = val_data
+
+    return train_dataset, val_dataset

py3DCal/model_training/datasets/tactile_sensor_dataset.py

@@ -0,0 +1,82 @@
+import os
+import torch
+import pandas as pd
+from PIL import Image
+from typing import Union
+from pathlib import Path
+from torch.utils.data import Dataset
+from torchvision import transforms
+from ..lib.precompute_gradients import precompute_gradients
+from ..lib.get_gradient_map import get_gradient_map
+from ..lib.add_coordinate_embeddings import add_coordinate_embeddings
+from ..lib.validate_parameters import validate_root
+
+class TactileSensorDataset(Dataset):
+    """
+    Tactile Sensor Dataset.
+
+    Args:
+        root (str or pathlib.Path): The root directory that contains the dataset folder.
+        add_coordinate_embeddings (bool, optional): If True, adds xy coordinate embeddings to each image. Defaults to True.
+        subtract_blank (bool, optional): If True, subtracts a blank image from each input image. Defaults to False.
+        transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed version. Default: ``transforms.ToTensor()``
+    """
+    def __init__(self, root: Union[str, Path], add_coordinate_embeddings=True, subtract_blank=True, transform=None):
+        validate_root(root)
+
+        self.root = root
+        self.annotation_path = os.path.join(root, "annotations", "annotations.csv")
+        self.metadata_path = os.path.join(root, "annotations", "metadata.json")
+        self.blank_image_path = os.path.join(root, "blank_images", "blank.png")
+        self.add_coordinate_embeddings = add_coordinate_embeddings
+        self.subtract_blank = subtract_blank
+
+        if transform is None:
+            self.transform = transforms.ToTensor()
+        else:
+            self.transform = transform
+
+        # Load the CSV data
+        self.data = pd.read_csv(self.annotation_path)
+
+        # Get probe radius (in px) from metadata
+        metadata = pd.read_json(self.metadata_path, typ="series")
+        radius = metadata["probe_radius_mm"] * metadata["px_per_mm"]
+
+        # Precompute gradients
+        self.precomputed_gradients = precompute_gradients(dataset_path=self.root, annotation_path=self.annotation_path, r=radius)
+
+        # Load and transform blank image
+        if subtract_blank:
+            self.blank_image = self.transform(Image.open(self.blank_image_path).convert("RGB"))
+
+    def __len__(self):
+        return len(self.data)  # Use the DataFrame length
+
+    def __getitem__(self, idx):
+        # Check if index is valid
+        if idx < 0 or idx >= len(self.data):
+            raise IndexError("Index out of range")
+        
+        if torch.is_tensor(idx):
+            idx = idx.tolist()
+
+        image_name = os.path.join(self.root, "probe_images", self.data.iloc[idx, 0])
+        image = Image.open(image_name).convert("RGB")
+
+        target = get_gradient_map(idx, annotation_path=self.annotation_path, precomputed_gradients=self.precomputed_gradients)
+
+        image = self.transform(image)
+        target = self.transform(target)
+
+        if self.subtract_blank:
+            # Subtract pre-transformed blank tensor
+            image = image - self.blank_image
+
+        if self.add_coordinate_embeddings:
+            # Add coordinate embeddings
+            image = add_coordinate_embeddings(image)
+
+        sample = (image, target)
+
+        return sample

py3DCal/model_training/lib/add_coordinate_embeddings.py

@@ -0,0 +1,29 @@
+import torch
+
+def add_coordinate_embeddings(image):
+        """
+        Add coordinate embeddings to the input image.
+        - X channel: column indices (1s in first column, 2s in second column, etc.)
+        - Y channel: row indices (1s in first row, 2s in second row, etc.)
+
+        Args:
+            image (torch.Tensor): Input image tensor of shape (C, H, W).
+
+        Returns:
+            torch.Tensor: Image tensor with added coordinate embeddings of shape (C+2, H, W).
+        """
+        # Get image dimensions
+        _, height, width = image.shape
+        
+        # Create x coordinate channel (column indices)
+        x_embedding = torch.arange(1, width + 1, dtype=torch.float32).unsqueeze(0).repeat(height, 1)
+        x_channel = x_embedding.unsqueeze(0)  # Add channel dimension
+
+        # Create y coordinate channel (row indices)
+        y_embedding = torch.arange(1, height + 1, dtype=torch.float32).unsqueeze(1).repeat(1, width)
+        y_channel = y_embedding.unsqueeze(0)  # Add channel dimension
+
+        # Concatenate original image with position embeddings
+        image_with_embeddings = torch.cat([image, x_channel, y_channel], dim=0)
+
+        return image_with_embeddings

py3DCal/model_training/lib/depthmaps.py

@@ -0,0 +1,74 @@
+from pyexpat import model
+import numpy as np
+import torch
+from pathlib import Path
+from typing import Union
+from PIL import Image
+import matplotlib.pyplot as plt
+from torchvision import transforms
+from .validate_parameters import validate_device
+from .add_coordinate_embeddings import add_coordinate_embeddings
+from .fast_poisson import fast_poisson
+
+def get_depthmap(model, image_path: Union[str, Path], blank_image_path: Union[str, Path], device='cpu') -> np.ndarray:
+        """
+        Returns the depthmap for a given input image.
+        Args:
+            model: A model which takes in an image and outputs gradient maps.
+            image_path (str or pathlib.Path): Path to the input image.
+            blank_image_path (str or pathlib.Path): Path to the blank image.
+            device (str, optional): Device to run the model on. Defaults to 'cpu'.
+        Returns:
+            depthmap (numpy.ndarray): The computed depthmap.
+        """
+        validate_device(device)
+
+        transform = transforms.ToTensor()
+
+        model.to(device)
+        model.eval()
+        image = transform(Image.open(image_path).convert("RGB"))
+        blank_image = transform(Image.open(blank_image_path).convert("RGB"))
+        augmented_image = image - blank_image
+        augmented_image = add_coordinate_embeddings(augmented_image)
+        augmented_image = augmented_image.unsqueeze(0).to(device)
+
+        with torch.no_grad():
+            output = model(augmented_image)
+        
+        output = output.squeeze(0).permute(1, 2, 0).cpu().numpy()
+        
+        depthmap = fast_poisson(output[:,:,0], output[:,:,1])
+
+        depthmap = np.clip(-depthmap, a_min=0, a_max=None)
+
+        return depthmap
+
+def save_2d_depthmap(model, image_path: Union[str, Path], blank_image_path: Union[str, Path], device='cpu', save_path: Union[str, Path] = Path("depthmap.png")):
+    """
+    Save an image of the depthmap for a given input image.
+    Args:
+        image_path (str): Path to the input image.
+        save_path (str or pathlib.Path): Path to save the depthmap image.
+
+    Returns:
+        None.
+    """
+    depthmap = get_depthmap(model=model, image_path=image_path, blank_image_path=blank_image_path, device=device)
+
+    plt.imsave(save_path, depthmap, cmap='viridis')
+
+def show_2d_depthmap(model, image_path: Union[str, Path], blank_image_path: Union[str, Path], device='cpu'):
+    """
+    Show the depthmap for a given input image.
+
+    Args:
+        image_path (str): Path to the input image.
+
+    Returns:
+        None.
+    """
+    depthmap = get_depthmap(model=model, image_path=image_path, blank_image_path=blank_image_path, device=device)
+
+    plt.imshow(depthmap)
+    plt.show()

py3DCal/model_training/lib/fast_poisson.py

@@ -0,0 +1,51 @@
+import numpy as np
+from scipy.fftpack import dst
+from scipy.fftpack import idst
+
+def fast_poisson(Fx, Fy):
+    """
+    Fast Poisson solver for 2D images.
+    Args:
+        Fx: 2D array of x-derivatives
+        Fy: 2D array of y-derivatives
+    Returns:
+        img: 2D array of the solution to the Poisson equation
+    """
+    
+    height, width = Fx.shape
+    
+    # Compute the difference of the Fx array in the x-direction to approximate the second derivative in the x-direction (only for interior)
+    Fxx = Fx[1:-1,1:-1] - Fx[1:-1,:-2]
+    # Compute the difference of the Fy array in the y-direction to approximate the second derivative in the y-direction (only for interior)
+    Fyy = Fy[1:-1,1:-1] - Fy[:-2,1:-1]
+    
+    # Combine the two second derivatives to form the source term for the Poisson equation, g
+    g = Fxx + Fyy 
+    
+    # Apply the Discrete Sine Transform (DST) to the 2D array g (row-wise transform)
+    g_sinx = dst(g, norm='ortho')
+
+    # Apply the DST again (column-wise on the transposed array) to complete the 2D DST
+    g_sinxy = dst(g_sinx.T, norm='ortho').T
+    
+    # Create a mesh grid of indices corresponding to the interior points (excluding the boundaries)
+    x_mesh, y_mesh = np.meshgrid(range(1, width-1), range(1, height-1)) 
+
+    # Construct the denominator for the Poisson solution based on the 2D frequency space
+    denom = (2*np.cos(np.pi*x_mesh/(width-1))-2) + (2*np.cos(np.pi*y_mesh/(height-1))-2)
+    
+    # Divide the 2D DST coefficients by the frequency-dependent denominator to solve the Poisson equation in the frequency domain
+    out = g_sinxy / denom
+
+    # Apply the inverse DST (IDST) to the result in the x-direction
+    g_x = idst(out,norm='ortho')
+
+    # Apply the inverse DST again in the y-direction to obtain the solution in the spatial domain
+    g_xy = idst(g_x.T,norm='ortho').T
+
+    # Note: The norm='ortho' option in the DST and IDST ensures that the transforms are orthonormal, maintaining energy conservation in the transforms
+
+    # Pad the result (which is only for the interior) with 0's at the border because we are assuming fixed boundary conditions
+    img = np.pad(g_xy, pad_width=1, mode='constant')
+
+    return img

py3DCal/model_training/lib/get_gradient_map.py

@@ -0,0 +1,39 @@
+import os
+import numpy as np
+import pandas as pd
+
+def get_gradient_map(idx, annotation_path, precomputed_gradients):
+    """
+    Returns a gradient map for an image using precomputed gradients.
+    Inputs:
+        - idx: index of the image to use for gradient map
+        - precomputed_gradients: precomputed gradients
+        - root_dir: root directory of the dataset
+        - csv_file: name of the csv file containing the sensor data
+    """
+    # Read data file
+    sensor_data = pd.read_csv(annotation_path, comment='#')
+
+    height, width, _ = precomputed_gradients.shape
+
+    x = int(float(sensor_data['x_px'][idx]))
+    y = int(float(sensor_data['y_px'][idx]))
+
+    right_shift = x - width // 2
+    down_shift = y - height // 2
+
+    offset = max(abs(right_shift), abs(down_shift))
+
+    gradient_map = np.zeros((height + offset * 2, width + offset * 2, 2))
+    gradient_map[:,:,0] = np.pad(precomputed_gradients[:,:,0], pad_width=offset, mode='constant')
+    gradient_map[:,:,1] = np.pad(precomputed_gradients[:,:,1], pad_width=offset, mode='constant')
+
+    # Shift the array 1 position to the right along the horizontal axis (axis=1)
+    gradient_map = np.roll(gradient_map, right_shift, axis=1)
+
+    # Shift the array 1 position down along the vertical axis (axis=0)
+    gradient_map = np.roll(gradient_map, down_shift, axis=0)
+
+    gradient_map = gradient_map[offset:offset+height, offset:offset+width]
+
+    return gradient_map

py3DCal/model_training/lib/precompute_gradients.py

@@ -0,0 +1,61 @@
+import os
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+def precompute_gradients(dataset_path, annotation_path, r=36):
+    """
+    Computes the gradient map for a probe image. This is used to precompute the gradients for all images in the dataset for faster computation.
+
+    Args:
+        root_dir (str): The path of the data folder.
+        csv_file (str): The name of the csv data file (must be located in 'root_dir').
+        
+    Returns:
+        numpy.ndarray: A h x w x 2 numpy array with x and y gradient values for a circle located at the center.
+    """
+    # Read data file
+    calibration_data = pd.read_csv(annotation_path)
+
+    # Read the image
+    image_path = os.path.join(dataset_path, "probe_images", calibration_data['img_name'][0])
+    image = Image.open(image_path)
+    image = np.asarray(image)
+
+    # Get image height and width
+    height, width, _ = image.shape
+
+    # Get circle center and radius
+    x = width // 2
+    y = height // 2
+    r = r
+    
+    # Create graident map
+    gradient_map = np.zeros((height, width, 2))
+
+    for i in range(height):
+        for j in range(width):
+            # Distance from pixel to center of circle
+            d_center = np.sqrt((y - i) ** 2 + (x - j) ** 2)
+
+            # If pixel is outside circle, set gradients to 0
+            if d_center > r:
+                Gx = 0
+                Gy = 0
+            
+            # Otherwise, calculate the gradients
+            else:
+                normX = (j - x) / r
+                normY = (i - y) / r
+                normZ = np.sqrt(1 - normX ** 2 - normY ** 2)
+
+                if normZ == 0:
+                    normZ = 0.1
+                
+                Gx = normX / normZ
+                Gy = normY / normZ
+
+            # Update values in gradient map
+            gradient_map[i,j] = np.array([Gx,Gy])
+
+    return gradient_map

py3DCal/model_training/lib/train_model.py

@@ -0,0 +1,96 @@
+import torch
+import torch.optim as optim
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from ..datasets.tactile_sensor_dataset import TactileSensorDataset
+from ..datasets.split_dataset import split_dataset
+from .validate_parameters import validate_device
+
+
+def train_model(model: nn.Module, dataset: TactileSensorDataset, num_epochs: int = 60, batch_size: int = 64, learning_rate: float = 1e-4, train_ratio: float = 0.8, loss_fn: nn.Module = nn.MSELoss(), device='cpu'):
+    """
+    Train TouchNet model on a dataset for 60 epochs with a
+    64 batch size, and AdamW optimizer with learning rate 1e-4.
+
+    Args:
+        model (nn.Module): The PyTorch model to be trained.
+        dataset (py3DCal.datasets.TactileSensorDataset): The dataset to train the model on.
+        num_epochs (int): Number of epochs to train for. Defaults to 60.
+        batch_size (int): Batch size. Defaults to 64.
+        learning_rate (float): Learning rate. Defaults to 1e-4.
+        train_ratio (float): Proportion of data to use for training. Defaults to 0.8.
+        loss_fn (nn.Module): Loss function. Defaults to nn.MSELoss().
+        device (str): Device to run the training on. Defaults to 'cpu'.
+
+    Outputs:
+        weights.pth: Trained model weights.
+        loss.csv: Training and testing losses.
+    """
+    validate_device(device)
+    _validate_model_and_dataset(model, dataset)
+
+    optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=1e-4)
+    train_dataset, val_dataset = split_dataset(dataset, train_ratio=train_ratio)
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=True if device == "cuda" else False, persistent_workers=True)
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True if device == "cuda" else False, persistent_workers=True)
+
+    model.to(device)
+
+    epoch_train_losses = []
+    epoch_val_losses = []
+    
+    print("Starting training...\n")
+
+    # Training loop
+    for epoch in range(num_epochs):
+        print(f"Epoch {epoch+1}/{num_epochs}")
+
+        model.train()
+        train_loss = 0.0
+        for batch_idx, (inputs, targets) in enumerate(train_loader):
+            inputs = inputs.to(torch.float32).to(device)
+            targets = targets.to(torch.float32).to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+
+            loss = loss_fn(outputs, targets)
+            loss.backward()
+            optimizer.step()
+
+            train_loss += loss.item()
+
+            print(f"  [Batch {batch_idx}/{len(train_loader)}] - Loss: {loss.item():.4f}")
+
+        avg_train_loss = train_loss / len(train_loader)
+        epoch_train_losses.append(avg_train_loss)
+        print(f"Epoch {epoch+1}/{num_epochs} | Train Loss: {avg_train_loss:.4f}")
+
+        # Validation loop
+        model.eval()
+        val_loss = 0.0
+        
+        with torch.no_grad():
+            for inputs, targets in val_loader:
+                inputs = inputs.to(torch.float32).to(device)
+                targets = targets.to(torch.float32).to(device)
+                outputs = model(inputs)
+                loss = loss_fn(outputs, targets)
+                val_loss += loss.item()
+
+        avg_val_loss = val_loss / len(val_loader)
+        epoch_val_losses.append(avg_val_loss)
+        print(f"VAL LOSS: {avg_val_loss:.4f}")
+
+    with open("losses.csv", "w") as f:
+        f.write("epoch,train_loss,val_loss\n")
+        for i in range(len(epoch_train_losses)):
+            f.write(f"{i+1},{epoch_train_losses[i]},{epoch_val_losses[i]}\n")
+    
+    torch.save(model.state_dict(), "weights.pth")
+
+def _validate_model_and_dataset(model: nn.Module, dataset: TactileSensorDataset):
+    if not isinstance(model, nn.Module):
+        raise ValueError("Model must be an instance of torch.nn.Module.")
+    
+    if not isinstance(dataset, TactileSensorDataset):
+        raise ValueError("Dataset must be an instance of py3DCal.datasets.TactileSensorDataset.")