Stride Independent Patching for Deep Learning

arXiv:2610.12216 · cs.CV · Submitted 2026-10-08 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Today's paper: "Stride Independent Patching for Deep Learning".

Jane: The gist: Semi-automatic stride-independent patching (SSP) offers an alternative to automatic stride-dependent patching techniques by leveraging user input to position predefined patches over objects of interest,

Tom: First, who's behind it and why it matters.

Title and authors: Tom: So, we're looking at this paper called "Stride Independent Patching for Deep Learning." It sounds super technical, but basically, it's about a way to cut out image patches that doesn't depend on a fixed step size.

Jane: Right. It’s about moving away from those old methods where you just pick a stride and see what happens with the patches. The authors are proposing this semi-automatic patching method, SSP, which uses user input to place the patches over specific objects of interest.

Lu: It's interesting because it directly addresses the problem of traditional patching techniques that often create redundant or irrelevant patches depending on whether you use overlapping or non-overlapping methods <ref:2610.12216#pg1>.

Meng: So, if I understand this right, the authors are trying to make the patch selection process less arbitrary and more guided by human expertise?

Tom: Exactly. They introduce this SSP tool that lets you manually mark where you want your patches to go, constrained within a fixed size like six hundred forty by six hundred forty pixels <ref:2610.12216#pg2>.

Jane: That’s the core idea: instead of letting a computer decide the stride, you let the expert guide where the patches land on important parts of an image.

Lalam: From an AI perspective, this means we can create training data that is inherently more relevant because it's targeted around what actually matters in the image <ref:2610.12216#pg3>.

The paper's summary: Tom: So, what’s the actual summary of this "Stride Independent Patching for Deep Learning" paper? It explains how SSP works and why it’s an alternative to the standard methods we usually see.

Jane: Well, the paper describes SSP as a way to use user input to position predefined patches right over objects of interest <ref:2610.12216#pg1>. They show that this approach is different because it doesn't rely on down-scaling operations at any stage <ref:2610.12216#pg2>.

Lu: The key distinction they make is that the SSP tool directly uses the expert’s ability to fit a patch-of-interest around those objects of interest, making sure everything fits inside the pre-defined six hundred forty by six hundred forty pixel size <ref:2610.12216#pg2>.

Meng: So, it bypasses the need for fixed stride settings, which in traditional methods can either cut through objects arbitrarily or leave gaps between patches <ref:2610.12216#pg3>.

Tom: Right. And they show that when you compare their SSP dataset with the Overlap and Nonoverlap datasets, the SSP coverage varies based on where the user selects those POIs <ref:2610.12216#pg3>.

Jane: That means you get a different kind of patch distribution depending on your manual selections, which is what they call stride-independent patching <ref:2610.12216#pg3>.

The paper's improvements: Tom: What are the specific improvements this paper suggests? It’s not just about a new tool; it’s about how it changes the training process itself.

Jane: The main improvement they highlight is that SSP generally achieves higher segmentation scores across all three DeepLabV3+ backbones when compared to the other patching strategies <ref:2610.12216#pg1>.

Lu: They point out that for every backbone, SSP required the shortest training time <ref:2610.12216#pg3>, which is a big deal when you’re dealing with large images like those from the MiniTEM microscope seven.

Meng: So, we're talking about better performance without needing extra compute time for training, just by getting the patches positioned smarter?

Tom: Precisely. And on the external test set, SSP achieved the highest average precision and F1-score across all three backbones <ref:2610.12216#pg3>.

Jane: That’s a strong result. It suggests that by using this user-guided positioning, you get very reliable segmentation of those intact objects <ref:2610.12216#pg3>.

Conclusion: Tom: Alright, let's wrap up with the conclusion of "Stride Independent Patching for Deep Learning." The paper suggests that selecting patches around objects is a solid way to balance performance and training speed.

Jane: It really does. SSP generally gave higher segmentation scores on the test splits and was faster to train than Noverlap or Overlap <ref:2610.12216#pg3>.

Lu: The result that SSP achieved the highest average precision of zero point nine seven three one and F1-score of zero point nine seven nine five across all backbones on the external test set really shows its potential for reliable segmentation <ref:2610.12216#pg3>.

Meng: From an engineering standpoint, that high precision means we can trust the model to find those adenoviruses in real-world, full-resolution images like those two thousand forty-eight by two thousand forty-eight pixel ones seven <ref:2610.12216#pg1>.

Lalam: And for a larger language model like me, this capability means we can generate much better training data tailored precisely around specific targets, which improves the overall quality of our learning <ref:2610.12216#pg3>.

Tom: So, in short, "Stride Independent Patching for Deep Learning" shows that letting experts position patches can give you a way to get better segmentation results with less training time across different model architectures.

Olivier Rukundo

Department of Electronic and Computer Engineering; University of Limerick

cs.CV

Submitted: 2026-10-08

Updated: 2026-10-08

Comments: 8 pages, 6 figures, 2 tables

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 74/100

The gist: The gist: Semi-automatic stride-independent patching (SSP) offers an alternative to automatic stride-dependent patching techniques by leveraging user input to position predefined patches over objects

Key concepts

Image Patching: This technique involves breaking down large images into smaller, manageable pieces called patches. These patches are then fed into deep learning models for training. The goal is to make training large or high-resolution images possible under hardware limits by using these smaller inputs.
Stride-Dependent Patching: Traditional methods use a fixed 'stride' (step size) to move the patch across an image. If the stride is too small, you get many overlapping patches; if it's too large, you create gaps. This method is limited because the stride setting cannot be changed once chosen, often leading to redundant or irrelevant patches.
Semi-Automatic Stride-Independent Patching (SSP): SSP lets the user manually select 'points of interest' (POIs) in an image. The tool then automatically extracts fixed-size patches centered at these user-defined locations. This approach removes the limitation of fixed strides, allowing for flexible patch placement based on what the user deems important for segmentation.
Precision and F1-Score: These are metrics used to evaluate how good a model's segmentation is. Precision measures how many of the predicted segments were actually correct (minimizing false positives). The F1-score combines precision and recall into a single metric, providing a balanced measure of the model's overall performance in identifying objects.

Terminology

Accuracy — 5× in this paper · explained in 1 episode
Data Augmentation — 4× in this paper · explained in 7 episodes
Adam — 2× in this paper · explained in 2 episodes
Benchmark — 2× in this paper · explained in 2 episodes
Conference on Computer Vision and Pattern Recognition — 2× in this paper
Core — 2× in this paper · explained in 2 episodes
Regularization — 2× in this paper · explained in 3 episodes
Transformer — 2× in this paper · explained in 2 episodes
Aperture — 1× in this paper · explained in 1 episode
Initial Data — 1× in this paper · explained in 2 episodes
Redundancy — 1× in this paper · explained in 2 episodes
Self-Supervised Learning — 1× in this paper · explained in 8 episodes

Summary

The gist: Semi-automatic stride-independent patching (SSP) offers an alternative to automatic stride-dependent patching techniques by leveraging user input to position predefined patches over objects of interest, achieving a favorable balance between segmentation performance and model training time.

Introduction and Problem Statement

Image patching techniques are used as an alternative approach that makes training deep learning models on large or high-resolution images feasible under tight hardware constraints all these techniques remain stride-dependent and often produce redundant or irrelevant patches, which may lead to inefficient training and suboptimal accuracy. Traditional image patching techniques, namely non-overlapping and overlapping techniques, are still popular or widely used to create image patches for deep learning model training purposes. These traditional techniques remain stride-dependent and often produce redundant or irrelevant patches, which may lead to inefficient training and suboptimal accuracy. A stride is the step size by which the small image patch, of a specific or pre-defined size, moves across a large image. When stride < patch size, overlapping patches are created resulting in excessive number of patches that may introduce redundancy and increasing computational cost. When stride = patch size, non-overlapping patches are created and the resulting patching may possibly cut through objects arbitrarily, often ignoring object of interest boundaries, which can lead to fragmented and incomplete segmentation. When stride > patch size, gaps between patches are created and, in this context, this stride setting cannot be an option.

Semi-Automatic Stride-Independent Patching (SSP) Tool

The SSP tool was developed in Python/PyTorch using Anaconda’s Spyder environment The developed tool allows the user to semi-automatically create the patchof-interest pairs. The main parts of the tool are user selection and extraction of the patch-of-interest (POI).

The process for creating patches involves two main steps:

Selection of the POI: The ManualRoiPatchingFunction.py script enables users to manually define and mark POIs in each input image Users can mark POIs by left-clicking and make corrections by right-clicking. Each POI is constrained to a predefined fixed size (e.g., 640 x 640). The script generates two outputs: (a) A marked image displaying the selected POIs as fixed-size squares, and (b) A corresponding text file containing the coordinates of the POI centers.
Extraction of the POI: The patchExportFunction.py script automates the extraction of image patches based on the predefined POI centers from ManualRoiPatchingFunction.py The script reads the stored POI coordinates, extracts fixed-size patches centered at these locations and saves the patches to a designated output folder for further processing.

Dataset Construction and Patch Comparison

Three patch-based datasets were created using SSP, overlapping patching (Overlap), and non-overlapping patching (Noverlap). The training data used in our experiments are the same as data used in our previous work presented in [7]. The image data were generated by the MiniTEM microscope by Vironova AB, Stockholm, Sweden, with an operating voltage of 25 kV and with a field of view of 3 µm for the adenovirus samples.

The patch sizes used across all datasets were fixed at 640 x 640 pixels. The dataset sizes varied significantly:

** SSP dataset (no stride or stride independent) consisted of 282 image patches and their corresponding masks. **

** Noverlap dataset (stride = patch size) consisted of 450 image patches and their corresponding masks. **

** Overlap dataset (stride = 0.5 × patch size – i.e., half patch size for simplification purposes) consisted of 1250 image patches and their corresponding masks. **

Table 1 summarizes the number of patches and the unique image area covered or omitted by each patching strategy The SSP coverage varies with user-selected patch locations. Noverlap and Overlap generated 9 and 25 patches per source image, respectively, but both covered the same 1920 × 1920 region, leaving 12.11% of each image outside the extracted patches

Model Training and Evaluation

DeepLabV3+ models were implemented in MATLAB, version R2024b [9]. The original DeepLabV3+ network main block diagram was provided in [8]. Each DeepLabV3+ model was configured with ResNet50, ResNet18, or MobileNetV2 as its backbone and trained separately on each of three patch-based datasets (SSP, Overlap, and Noverlap). All DeepLabV3+ versions were trained in a single-GPU environment with the Nvidia GeForce RTX 3070 graphic card and 11th Gen Intel(R) Core (TM) i7-11700 F@ 2.50 GHz, 2496 MHz, 8 Core(s), 16 Logical Processor(s).

Training hyperparameters were set as follows: the number of epochs = 30; the mini-batch size = 2; the initial learning rate = 0.0001; L2 regularization = 0.00005; optimizer = Adam (adaptive moment estimation algorithm). Data augmentation included random rotation between −45° and 45°, uniform scaling by a factor between 0.8 and 1.2, horizontal and vertical translation between −10 and 10 pixels, and horizontal and vertical shearing between −15° and 15°.

The performance was evaluated on the test split (70% of training dataset), validation set split (15% of the training dataset), and external test set (15% of the training dataset). Quantitative metrics used were Precision, Recall, and F1-score.

Key Results Summary

The results showed that SSP generally achieved higher segmentation scores across the three backbones, although its IoU and Dice scores were similar to those of Overlap for MobileNetV2. Figure 6 shows that SSP required the shortest training time for every backbone.

Table 2 showed that SSP achieved the highest average precision (0.9731) and F1-score (0.9795) across the three backbones, suggesting a favorable balance between correctly detecting intact adenoviruses and limiting false positives. Noverlap achieved the highest average recall (0.9932), but its lower precision (0.9470) indicates a greater tendency to include false positives. Overall, these averages support SSP as the strongest patching strategy in terms of precision and F1-score under the evaluated conditions, while Noverlap favored recall.

Conclusion

Selecting patches around objects of interest can provide a favorable balance between segmentation performance and model training time. SSP generally achieved higher segmentation scores on the test splits and the shortest training time across all three backbones. Its highest average precision and F1-score on the external test set further support its potential, although Noverlap retained an advantage in average recall. Although Noverlap and Overlap omitted only 12.11% of each source image, potentially less than SSP, their greater spatial coverage did not generally translate into better segmentation performance. These results establish stride-independent patching as a promising alternative to stridedependent patching for the evaluated task. Its practical value must nevertheless be weighed against the user effort required for patch selection. Future work should assess that effort and performance across broader datasets.

Author Contributions and Funding

Conceptualization, O.R.; methodology, O.R.; software, O.R.; validation, O.R.; formal analysis, O.R.; investigation, O.R.; resources, O.R.; data curation, O.R.; writing—original draft preparation, O.R.; writing—review and editing, O.O; visualization, R.

Improvements for AI systems

The SSP tool allows users to inspect and adjust patch placement to fully include objects of interest, reducing the risk of object omission or fragmentation during patch selection. This enables semi-automatic creation of high-quality training data by leveraging expert input directly, bypassing the limitations of traditional stride-dependent methods.
DeepLabV3+ models trained with SSP generally achieved higher segmentation scores on the test splits and required the shortest model training time across all three backbones. This suggests that SSP provides a favorable balance between performance and computational efficiency for high-resolution medical image analysis tasks like adenovirus detection.
The system can achieve the highest average precision (0.9731) and F1-score (0.9795) across the three backbones on external test sets, specifically showing that SSP is the strongest patching strategy in terms of precision and F1-score under the evaluated conditions. This capability allows for highly reliable segmentation of intact objects in real-world, full-resolution images.
The system can be deployed to segment intact adenoviruses on 20 full images measuring 2048 x 2048 pixels with high accuracy, as demonstrated by the highest average precision (0.9731) and F1-score (0.9795) reported for the SSP R50 backbone on the external test set.
The system can be used to create specialized training datasets where patches are positioned around specific objects of interest, allowing researchers to leverage the expert user’s capability to locate and select patch-of-interest containing selected objects of interest. This moves beyond fixed spatial constraints, enabling targeted data generation for difficult segmentation problems.

Abstract

This paper presents semi-automatic stride-independent patching (SSP) as an alternative to automatic stride-dependent patching techniques. SSP uses user or expert input to position predefined patches over one or more objects of interest. To evaluate its effectiveness, three patch-based datasets were created using SSP, overlapping patching (Overlap), and non-overlapping patching (Noverlap). DeepLabV3+ models with ResNet50, ResNet18, and MobileNetV2 backbones were trained sepa-rately on each dataset. Quantitative evaluations were performed on the respective test splits and a common external test set. SSP generally achieved higher segmentation scores on the test splits and required the shortest model training time across all three backbones. On the external test set, SSP achieved the highest average precision and F1-score across backbones, whereas Noverlap achieved the highest average recall. These preliminary results demonstrate that the potentially greater spatial coverage of Noverlap and Overlap does not generally translate into better segmentation perfor-mance and that SSP offers a favorable balance between segmentation performance and model training time.