An Image Feature Learning Protocol Based on Image-Level Garment Component Topology for Design Reference Retrieval

Summary

This protocol generates structure-aware garment representations by integrating semantic component parsing, topology modeling, dual-stream feature encoding, and structure-guided fusion. It enables computer vision and apparel researchers to perform garment retrieval and design-reference comparison based on component organization and silhouette layout rather than color or texture.

Abstract

Clothing image retrieval methods often emphasize color and texture, which can lead to confusion between garments that share a similar appearance but differ in their component layouts. This study presents a component-aware feature-learning protocol for garment image retrieval and design reference comparison. The protocol parses semantic garment regions, constructs an image-level garment component graph, encodes appearance and component relations in parallel, and fuses both representations using structural consistency, structural relationship, and structural discrimination losses. DeepFashion2 images are standardized to 512 x 512 pixels, parsed with HRNet-W48, encoded with ResNet-50 and graph convolution, and evaluated through structural retrieval and clustering. The complete model achieved a structural consistency index of 0.81, a structural discrimination index of 0.71, a Recall@5 of 89.2%, a mean average precision of 86.4%, and a silhouette coefficient of 0.74. The protocol supports garment structure retrieval, structural comparison, and difference localization when surface appearance does not reliably represent garment construction.

Introduction

With the continued integration of computer vision and artificial intelligence into the apparel industry, clothing image analysis has gradually expanded from basic recognition tasks to design-oriented analysis and decision support^1,2. In the apparel design process, the distinction between design schemes depends more on structural composition and component relationships than on simple differences in appearance, which makes the structural expressiveness of apparel image features in design assistance a key factor affecting the effectiveness of analysis^3,4. However, most existing visual methods still rely on texture, color, and global contours as their primary features, making it difficult to systematically analyze garment hierarchies and construction differences during the design process^5,6. Therefore, developing a structure-aware image feature-learning method for apparel design assistance is important for improving the objectivity and consistency of design analysis⁷. This protocol is appropriate when garments share similar colors, textures, or global contours but differ in component organization, connection patterns, or spatial layout. Under these conditions, appearance-centered representations tend to place structurally different designs close together in the feature space, which weakens the reliability of retrieval and design comparison. The protocol addresses tasks in which relationships among garment components form the primary basis for structural retrieval, design assessment, and localized difference analysis.

In terms of data scale, model complexity, and task diversity, current research on automatic analysis and understanding of clothing images has made significant progress^8,9. However, in practical applications, clothing structural information is often implicitly included in segmentation or detection results and is not accounted for in the unified modeling of the feature-learning stage, resulting in a lack of stable distinction among different structural designs in the feature space^10,11. The spatial relationships, hierarchical constraints, and topological structures among garment components are not explicitly encoded, making it difficult for feature representations to reflect structural differences at the design level^12,13. The absence of explicit structural modeling limits the analytical granularity and decision reliability of clothing image features in design-assisted scenarios, posing a major barrier to the development of intelligent design systems with deeper semantic understanding¹⁴.

To support clothing image feature learning and analysis, related studies have explored several technical directions¹⁵. Semantic segmentation and garment parsing methods have enabled fine-grained delineation of garment regions and components through pixel-level annotation, providing a foundation for structural information extraction^16,17. Image-query garment retrieval methods have incorporated topology and color-texture fusion, global and local attention alignment, garment parsing, multiscale and multigranularity representation, and residual attention with feature selection. These methods address catalog search, consumer-to-store matching, cross-domain product retrieval, and e-commerce visual search. Their application settings are closely related to design-reference retrieval because each method ranks garment images based on a visual query, although their representations do not preserve typed component adjacency and vertical-order relations throughout feature fusion^18,19,20. Meanwhile, research on design and recommendation scenarios has gradually introduced multimodal fusion, relation modeling, and style analysis, expanding the application boundaries of clothing visual features^21,22. Although these methods have made progress in their respective tasks, their core features are still largely based on appearance descriptions, and structural information has not been uniformly modeled as an inherent constraint for feature learning, making it difficult to meet the needs of clothing design assistance for structural alignment and structural comparison²³.

To address the insufficient structural differentiation capability in garment design assistance, this paper proposes an image feature learning method based on the perception of garment structure. This method incorporates garment analysis results and key structural information into the garment image input stage, jointly modeling garment component regions, spatial relationships, and hierarchical connections. Structural relationship encoding and visual feature alignment explicitly integrate garment constraints into the feature-learning process, producing a representation that preserves both visual appearance and structural consistency. This feature characterizes garment structural differences within a unified space, providing a stable basis for subsequent structural similarity analysis, structural clustering, and design-assisted decision-making, thereby alleviating the feature confusion problem caused by the lack of structural modeling in existing methods. Unlike general visual retrieval strategies that treat structural information as loosely connected auxiliary attributes, this framework constructs a feature-modulation mechanism centered on topological relationships. The mechanism encourages the learned representation to follow visible garment-region organization while reducing texture-dominated responses. Each graph node denotes an image-level semantic region, and each graph relation describes visible adjacency or normalized relative position in the image plane. The resulting embedding supports comparison of component layout and silhouette organization across garment images. These regions and relations are not sewing-pattern pieces, seam connections, construction landmarks, or grading parameters. Compared with appearance-driven retrieval methods, the protocol retains explicit component topology throughout feature learning rather than treating structural information as a downstream analysis result. Compared with approaches that introduce structural cues only as auxiliary inputs, the dual-stream encoding and topology-consistent fusion preserve geometric relationships while reducing texture-dominated responses. The resulting representation supports garment structure retrieval, structural clustering, design-reference screening, and localized design difference analysis, while providing component-level evidence that remains interpretable within the garment design process. Research relevant to this protocol spans clothing image feature learning, garment structure modeling, structure-aware representation, and visual analysis for apparel design assistance.

At the feature-representation level, clothing image research has long focused on appearance modeling, deep feature extraction, and multiscale representation^24,25. Early work used convolutional neural networks to perform end-to-end modeling of clothing images for classification, retrieval, and similarity matching tasks^26,27. Subsequently, multi-scale feature fusion and cross-domain learning were introduced to alleviate differences in clothing images under different viewing angles, poses, and shooting conditions^28,29. In retrieval tasks, attention mechanisms and feature compression strategies were used to improve feature discriminativeness and computational efficiency^30,31. These methods achieve reliable appearance discrimination, but their feature-learning processes still focus on global visual information and lack systematic representations of internal garment structures³². Composed fashion retrieval methods further combine a reference image with textual modification instructions, but their query modality differs from the image-only protocol studied here. They are reviewed as a related commercial retrieval direction and are not included in the quantitative comparison because additional text input would prevent a controlled image-query evaluation.

As clothing image analysis has shifted from appearance discrimination to structural understanding, research has increasingly focused on modeling garment components, geometric relationships, and topological connections³³. Semantic segmentation networks have achieved clothing component-level analysis through feature projection and multi-attention mechanisms, providing a reliable foundation for structural information extraction^34,35. Keypoint detection and structural topology modeling methods have further characterized the relationship between garment outlines and local structures, enhancing the model's ability to represent the geometric features of clothing^36,37. Several studies have introduced graph structures and relational reasoning networks to model relationships among clothing components, thereby improving fine-grained recognition and cross-domain retrieval performance^38,39. These works have verified the important role of structural information in visual analysis, but structure is mostly used as an auxiliary feature or an intermediate result, and a feature-learning system with structural constraints at its core has not yet been developed⁴⁰.

Within apparel design assistance, these developments have supported design recommendations, style analysis, interactive system construction, and structure-oriented design evaluation⁴¹. Recommendation system research has achieved apparel matching and personalized recommendations by integrating visual features with user preferences⁴². Design assistance-related work has explored new paths for intelligent design support by combining generative models, style modeling, and human-computer collaboration mechanisms⁴³. Research on virtual try-on, size measurement, and style transfer has broadened the application of apparel visual analysis throughout the design and production process. Although these studies have enriched the technical forms of apparel design assistance, their core visual features are still primarily driven by appearance and lack a unified representation of design structure for analysis. In contrast, this paper treats garment structure as the core constraint on feature representation and provides a visual representation method for structural analysis in apparel design assistance.

Despite these developments, recent methods in generative design often treat structural conditions as loose spatial guidance matrices within diffusion processes. Contemporary structural parsing frameworks represent topologies as auxiliary semantic labels, separate from the primary visual embedding space. The proposed framework changes this mechanism by defining a graph-prior-based topological constraint that explicitly modulates visual feature learning at the component level. The multi-level consistency objective encourages garments with similar image-level component layouts to remain close in the feature space while separating garments with different visible region organizations. The objective reduces texture dependence in the evaluated retrieval setting but does not establish invariance to changes in material, pose, or background. The protocol should be selected when the input image contains a sufficiently visible individual garment, semantic components retain identifiable boundaries, and the analytical objective requires component-level structural comparison rather than coarse category recognition. It is intended for computer vision researchers, apparel design researchers, and digital garment development teams engaged in structure-sensitive visual analysis. It is not intended for tasks focused solely on color or material recognition, or for images in which garment topology is largely obscured. The following protocol presents the workflow from dataset preparation and semantic probability mapping to geometric relationship construction, dual-stream feature encoding, structure-guided fusion, and consistency-based optimization. The complete workflow is summarized in Figure 1.

Protocol

This study uses publicly available garment image datasets and does not recruit human participants, collect personally identifiable information, conduct animal experiments, or use biological materials. Institutional ethics approval and informed consent are not applicable.

1. Software environment and project configuration

1. Place the released project files in a directory with sufficient storage space and open a terminal in the project root directory.
2. Run conda env create -f environment.yml to create the software environment. Run conda activate garment_structure to activate the environment.
3. Run python --version, conda --version, pip show numpy, pip show torch, pip show torchvision, and nvidia-smi. Save the complete command output to software_versions.txt.
4. Use the same recorded environment for preprocessing, training, inference, efficiency measurement, and evaluation. Record the HRNet-W48 checkpoint filename and SHA-256 value, the ImageNet-pretrained ResNet-50 weights identifier and SHA-256 value, the DeepFashion2 release source, and the source-code repository identifier in the same file.
5. Create the directories data_raw, data_processed, parser_outputs, structural_priors, feature_outputs, checkpoints, logs, and evaluation_results under the project root directory.
6. Open configs/protocol.yaml. Enter the DeepFashion2 directory in dataset_root, the pretrained HRNet-W48 checkpoint path in parser_checkpoint, and the project output directory in output_root.
7. Set input_height to 512, input_width to 512, batch_size to 32, structural_categories_per_batch to 8, samples_per_category to 4, random_seed to 42, feature_dimension to 512, structural_constraint_weight to 1.0, structural_relationship_weight to 0.5, structural_discrimination_weight to 1.0, and separation_threshold to 0.3.
8. Set the optimizer to mini-batch stochastic gradient descent. Set initial_learning_rate to 0.0001, momentum to 0.9, weight_decay to 0.0005, max_epochs to 120, learning_rate_schedule to multi-step decay, and learning_rate_decay_factor to 0.1. Enter the verified decay epochs used by the released configuration in learning_rate_milestones.
9. Run python tools/export_experiment_tables.py --config configs/protocol.yaml --output evaluation_results. Export the complete model configuration to model_setting_statistics.csv. Verify that the exported file records the input image size, input format, batch composition, optimizer, learning rate, learning-rate schedule, epoch count, weight decay, momentum, augmentation probabilities, feature dimension, structural loss weights, separation threshold, random seeds, checkpoint-selection rule, and independent-run count.
10. Expected output: Confirm that the software environment starts without dependency errors, software_versions.txt contains the environment record, all output directories exist, and configs/protocol.yaml contains valid absolute paths and numerical settings.
    NOTE: Use the same environment and configuration file during data processing, model training, inference, and evaluation. Store a copy of configs/protocol.yaml with every trained checkpoint.
    ​TROUBLESHOOTING: If environment creation stops because a package is unavailable, remove the incomplete environment, verify the package channels in environment.yml, and recreate the environment. If nvidia-smi does not report a graphics processing unit, stop model training and restore the graphics driver and CUDA runtime. If a directory error appears during execution, replace relative paths with absolute paths and verify write permission for output_root.

2. Input image acceptance, dataset construction, and preprocessing

1. Use only files with the extensions JPG, JPEG, or PNG. Use 8-bit RGB images containing a single principal garment.
2. Retain eight-bit RGB images with a width and height of at least 512 pixels and one identifiable principal garment. Reject an image when the garment foreground occupies less than 15% of the complete image area, when more than 5% of the garment-mask boundary coincides with the image border, when a secondary garment region exceeds 10% of the principal garment area, when the estimated occluded area exceeds 20% of the principal garment mask, or when the variance of the Laplacian response is below 100.
3. Record the image identifier, measured value, triggered exclusion rule, and annotation path in excluded_samples.csv.
4. Apply the input acceptance rules to the DeepFashion2 source images before structural labeling and data partitioning. Record every accepted and rejected image identifier, the original dataset split, the garment annotation identifier, the source pair identifier, the foreground area ratio, the boundary-contact ratio, the occlusion ratio, the blur score, and the final retention status in data_filtering_manifest.csv.
5. Run python tools/prepare_data.py --config configs/protocol.yaml.
6. Read the garment bounding box from the dataset annotation. Extend the bounding box by 5% of its width and height, without exceeding the image boundaries.
7. Crop the garment region, preserve its original aspect ratio, add zero padding to form a square image, and resize the padded image to 512 x 512 pixels.
8. Convert the resized image to an RGB tensor with floating-point values. Divide each pixel value by 255.
9. Normalize the red, green, and blue channels with means of 0.485, 0.456, and 0.406 and standard deviations of 0.229, 0.224, and 0.225.
10. Apply horizontal flipping with a probability of 0.5 and random erasure with a probability of 0.2 to training images. Apply only deterministic cropping, padding, resizing, and normalization to validation and test images.
11. Run python tools/assign_structural_levels.py --config configs/protocol.yaml after the seven-channel component maps and the shared-boundary and vertical-order matrices have been generated. For every retained image, calculate the active-node count, connected-component count, branch-node count, independent-cycle count, and longest directed vertical-order path. Define a branch node as an active node connected to at least three other active nodes in the shared-boundary graph.
12. Assign S1 when the graph is connected, contains no independent cycle, contains no branch node, and has a longest vertical-order path of no more than two edges. Assign S2 when the graph is connected, contains no independent cycle, contains exactly one branch node, and has a longest vertical-order path of no more than two edges. Assign S3 when the graph is connected, contains no independent cycle, and contains at least two branch nodes or a vertical-order path of at least three edges. Assign S4 when the graph is connected, contains exactly one independent cycle, and has a vertical-order path of no more than two edges. Assign S5 when the graph contains at least two independent cycles or contains one independent cycle together with a vertical-order path of at least three edges.
13. Apply the rules in the order S5, S4, S3, S2, and S1 and save the calculated graph statistics, assigned level, and rule identifier in structural_level_manifest.csv.
14. Generate the preliminary S1–S5 labels automatically from the saved component masks and relation matrices. Mark a sample as structurally ambiguous when its component graph contains more than one connected component, when the mean maximum component probability inside the garment foreground is lower than 0.60, when an active component occupies less than 1% of the garment foreground, or when its assigned structural level changes after the boundary-contact width is changed from one pixel to two pixels.
15. Submit every ambiguous sample to two authors for independent inspection of the source image, component map, shared-boundary matrix, vertical-order matrix, and preliminary graph. Retain the label when the two inspections agree. Submit a disagreement to a third author and use the majority decision as the final label. Exclude a sample when no stable component relation is recovered after review. Record the automatic label, review labels, disagreement reason, final label, and exclusion status in structural_label_audit.csv.
16. Calculate the SHA-256 value of every retained source file and calculate a 64-bit perceptual hash from the normalized garment crop. Place images with identical SHA-256 values in the same exact-duplicate group. Place images whose perceptual hashes have a Hamming distance of no more than four in the same near-duplicate group after verifying that they originate from the same garment instance.
17. Merge all images sharing the same DeepFashion2 source pair identifier or garment identity into one source group. Save the file hashes, perceptual hashes, source identifiers, and duplicate-group identifiers in duplicate_group_manifest.csv.
18. Perform data partitioning at the source-group level rather than at the individual-image level. Assign every exact-duplicate group, near-duplicate group, and source-identity group entirely to one subset. Check all cross-subset pairs after partitioning and write every detected identity conflict, hash conflict, and perceptual-hash conflict to leakage_audit.csv. Rebuild the manifests until leakage_audit.csv contains no unresolved cross-subset records.
19. Stratify the source groups by the final S1-S5 labels and assign complete groups to the training, validation, and test subsets according to the verified allocation shown in Table 1. Report the exact image count and source-group count for every structural level and subset.
20. Calculate the realized training, validation, and test percentages from the final retained cohort rather than from the unfiltered dataset. Do not use validation images, test images, ambiguous excluded images, or images belonging to their duplicate groups during parameter learning, threshold determination, structural-level rule adjustment, or checkpoint selection.
21. Save the processed images to data_processed/images. Save train_manifest.csv, validation_manifest.csv, test_manifest.csv, pair_manifest.csv, and structural_level_manifest.csv to data_processed/manifests.
22. Read the final structural labels, review status, duplicate-group identifiers, source-group identifiers, and subset labels from the processed manifests. Count the automatically accepted samples, manually reviewed samples, ambiguity exclusions, duplicate exclusions, source groups, training images, validation images, and test images for S1 through S5.
23. Calculate the realized subset ratios, mean active-node count, mean branch-node count, mean independent-cycle count, mean vertical-order depth, and mean typed-edge count. Save the complete statistics to evaluation_results/dataset_statistics.csv.
24. Expected output: Confirm that every accepted image is an eight-bit RGB image with a size of 512 x 512 pixels and has one filtering record, one final structural-level label, one source-group identifier, one duplicate-group identifier, one subset label, and one valid annotation path. Confirm that every ambiguous sample has a complete review record. Confirm that no source identifier, exact-duplicate group, near-duplicate group, or garment identity occurs in more than one subset. Confirm that the image counts in train_manifest.csv, validation_manifest.csv, test_manifest.csv, and dataset_statistics.csv are identical.
    NOTE: Preserve the original unprocessed images in data_raw. Do not apply random augmentation to validation or test images.
    ​TROUBLESHOOTING: If cropping removes a collar, sleeve, hem, or trouser leg, restore the original annotation and enlarge the retained boundary margin. If a garment appears stretched, verify that the square padding is present before resizing. If a processed image contains one channel or four channels, convert the source file to eight-bit RGB and rerun preprocessing. If duplicate identifiers occur across subsets, rebuild all subset manifests before training.

3. Foreground-restricted visual component parsing and probability mapping

1. Run python tools/parse_components.py --config configs/protocol.yaml.
2. Load the pretrained HRNet-W48 garment semantic parsing checkpoint from parser_checkpoint. Verify that the checkpoint outputs the garment component categories defined by the dataset annotation mapping. Switch the semantic parsing network to evaluation mode and disable gradient calculation.
3. Read the processed images from train_manifest.csv, validation_manifest.csv, and test_manifest.csv in sequence.
4. Extract one seven-channel semantic response tensor from each input image and set K to seven throughout the workflow. Use the fixed category order Upper Trim Region, Neckline Region, Bodice Region, Left Lower-Garment Region, Right Lower-Garment Region, Middle Lower-Garment Region, and Hem Region. Preserve this order in probability maps, component matrices, graph matrices, feature matrices, manifests, and visualization files.
5. Apply softmax along the channel dimension to generate the semantic component probability map P. Verify that the probabilities across all K channels sum to one at every pixel within a tolerance of 0.0001.
6. Load the garment foreground mask from the dataset annotation and align it with the 512 x 512 processed image. Set the probability of every component outside the garment foreground to zero. Renormalize the component probabilities inside the foreground mask along the channel dimension.
7. Verify that every active component region remains inside the garment foreground. Reject the parsed sample if a colored component region extends into the surrounding wall, floor, curtain, or other background area. Record the rejected image identifier and parsing error in parsing_quality_log.csv.
8. Calculate the foreground coverage ratio for every component and mark components with fragmented regions or unsupported isolated areas for manual inspection.
9. Save the semantic response tensor to parser_outputs/logits. Save the probability map to parser_outputs/probability_maps. Save a color-coded component preview to parser_outputs/previews.
10. Expected output: Confirm that each accepted image produces one seven-channel foreground-restricted probability map with a spatial size of 512 x 512 pixels, one seven-channel semantic response tensor, and one preview image. Confirm that channel indices one through seven follow the fixed component order defined in Step 3.4. Confirm that all colored component regions remain inside the garment foreground and that background pixels have zero component probability. Confirm that the file identifier matches the corresponding entry in the source manifest.
    NOTE: Retain continuous component probabilities inside the garment foreground during structural modeling. Treat the resulting regions as visual analysis regions. Do not interpret their boundaries as seam lines, cutting lines, pattern-piece contours, darts, notches, or grading references.
    ​TROUBLESHOOTING: If all channels show nearly uniform probabilities, verify parser_checkpoint, RGB channel order, and image normalization. If a component remains absent across an entire subset, compare the annotation index with the parser output channel index. If component colors extend into the background, verify foreground-mask alignment, interpolation settings, and annotation coordinates before graph construction. If a visual region spans multiple unrelated garment areas, mark the sample as a parsing failure and exclude it from structural-prior generation. If channel probabilities do not sum to one, apply softmax along the channel dimension rather than either spatial dimension. If an output file is missing, locate the final processed identifier in the parser log and resume parsing from the next identifier.

4. Image-level component geometry and spatial relation modeling

1. Load the shallow visual feature tensor and the corresponding probability map P for each image.
2. Multiply every spatial feature vector by the probability assigned to the corresponding semantic component.
3. Sum the weighted feature vectors over the spatial dimensions and divide the sum by the total probability mass of the component.
4. Assign a zero vector and an inactive-node indicator to any component with zero probability mass.
5. Apply L2 normalization to every active component embedding and stack the embeddings according to the fixed semantic component order.
6. Calculate the horizontal and vertical image-plane center coordinates of each visual component from its foreground-restricted probability distribution. Normalize the coordinates by image width and image height.
7. Calculate the horizontal and vertical image-plane spread of each visual component in the same normalized coordinate system. Use these values only to describe the visible region extent in the processed image.
8. Create seven graph nodes according to the fixed component order and retain inactive components as zero nodes. Construct a 7 x 7 shared-boundary matrix using eight-neighbor contact between foreground component masks. Construct a 7 x 7 vertical-order matrix using the fixed relations from Upper Trim Region to Neckline Region, from Neckline Region to Bodice Region, from Bodice Region to each lower-garment region, and from each lower-garment region to Hem Region. Store every valid relation in both directions.
9. Add a self-loop for every active node before graph convolution, and keep relations connected to inactive nodes at zero.
10. Calculate the relative center displacement and relative spatial dispersion between every ordered pair of semantic components. Stack the pairwise geometric values to form the geometric relationship tensor.
11. Calculate the dot product between every pair of normalized component embeddings. Apply row-wise softmax to the resulting similarity matrix and use the values as relation weights.
12. Multiply the geometric relationship tensor by the corresponding relation weights and aggregate the weighted relations for every component.
13. Save the component embedding matrix, component center matrix, spatial dispersion matrix, shared-boundary matrix, vertical-order matrix, self-loop matrix, relation-weight matrix, inactive-node mask, component label mapping, and structural prior representation to structural_priors. Save every matrix with seven rows and seven columns where applicable. The complete construction process from the foreground-restricted component map to the image-level garment component topology prior is shown in Figure 2.
14. Generate the component graph overlay for each visualization sample from the foreground-restricted probability map, component center matrix, typed adjacency matrix, inactive-node mask, and component label mapping.
15. Place each active node at the corresponding component center. Draw solid edges for shared foreground boundaries and dashed edges for predefined vertical-order relations.
16. Save each graph overlay to structural_priors/visualizations using the source image identifier. Record the source image path, probability-map path, component-center path, typed-adjacency path, inactive-node-mask path, semantic parsing checkpoint identifier, and graph-overlay path in component_graph_visualization_manifest.csv.
17. Expected output: Confirm that every image produces a component embedding matrix with K rows, a typed adjacency matrix with K rows and K columns, a relation-weight matrix with K rows and K columns, an inactive-node mask with K values, and one image-level structural prior representation. Confirm that every selected visualization sample produces a component graph overlay in which active nodes remain within the corresponding garment regions.
    NOTE: Preserve the same visual component order across all matrices, manifests, graphs, feature files, and graph overlays. Treat component centers, spatial spread values, and graph relations as garment-region descriptors in the image plane. Do not interpret the component graph as a human pose skeleton or derive its nodes from anatomical joint coordinates. Do not convert these descriptors into seam lengths, curve radii, dart intake, notch positions, grainline directions, grading increments, or pattern-piece dimensions.
    ​TROUBLESHOOTING: If a matrix contains a nonnumeric value, inspect the probability-mass denominator and coordinate normalization. If relation weights concentrate on one component, subtract the row maximum from the similarity matrix before softmax. If the number of graph nodes differs between images, verify that inactive components remain present as zero vectors rather than being removed.

5. Dual-stream structure-aware feature encoding

1. Load the ImageNet-pretrained ResNet-50 weights and remove the final pooling and classification layers.
2. Pass each normalized garment image through ResNet-50 and extract the appearance tensor from the backbone stage declared by appearance_stage in configs/protocol.yaml. Verify the stage name, number of output channels, and output spatial dimensions generated by the selected backbone stage for an input image of 512 x 512 pixels. Use the same stage in every training, inference, ablation, and comparison run.
3. Resize the semantic probability map to the spatial size of the appearance feature tensor through bilinear interpolation. Multiply the appearance feature tensor by each resized component probability map, then aggregate the weighted responses over the spatial dimensions.
4. Pass every component appearance embedding through the channel-recalibration layer defined in configs/protocol.yaml. Record the layer type, input dimension, output dimension, reduction ratio, activation function, and parameter-sharing rule. Stack the resulting seven component vectors in the fixed semantic order to form the appearance feature matrix.
5. Pass every geometric relationship vector through the structural projection layer and set the output dimension to 512. Construct the component graph with the relation-weight matrix and inactive-node mask.
6. Apply two graph convolutional layers with an input dimension of 512 and an output dimension of 512. Apply batch normalization after each graph convolutional layer and then apply LeakyReLU. Record the negative-slope value used by LeakyReLU. Apply the inactive-node mask after each layer to retain zero features for inactive components.
7. Apply semantic alignment with the normalized component embeddings and stack the resulting vectors to form the structural feature matrix.
8. Expected output: Confirm that each image produces one appearance feature matrix and one structural feature matrix. Confirm that both matrices contain K rows and 512 columns.
   NOTE: Keep inactive components as zero vectors and preserve the component order established during structural-prior construction.
   TROUBLESHOOTING: If the two feature matrices contain different row counts, inspect the semantic category mapping and inactive-node handling. If matrix multiplication reports a dimension error, verify that the structural projection output and appearance channel dimensions are both 512. If structural features remain zero for all active components, verify that the graph edges and relation weights have been added to the current batch.

6. Structure-guided feature fusion

1. Apply the structure-guided feature-fusion sequence shown in Figure 3. Pass the structural feature matrix through the fusion-weight layer and apply the activation function declared by fusion_activation in configs/protocol.yaml. Record the activation name, input dimension, output dimension, and whether parameters are shared across the seven component nodes.
2. Verify that the generated structural weight matrix contains K rows and 512 columns.
3. Multiply the appearance feature matrix by the structural weight matrix element by element.
4. Concatenate the modulated appearance matrix and the structural feature matrix along the channel dimension.
5. Concatenate the 512-dimensional modulated appearance vector and the 512-dimensional structural vector for each component to form a 1024-dimensional vector. Pass the concatenated vector through the fusion projection layer and reduce its dimension from 1024 to 512.
6. Add the original structural feature matrix to the projected matrix through a residual connection.
7. Stack the fused component vectors in the fixed semantic order and apply L2 normalization to the flattened structure-aware representation.
8. Save the structural weight matrix, modulated appearance matrix, fused component matrix, and final structure-aware representation to feature_outputs.
9. Expected output: Confirm that every image produces one fused component matrix with K rows and 512 columns and one normalized structure-aware feature vector linked to the source image identifier.
   NOTE: Retain the structural weight matrix and fused component matrix for response visualization and local difference analysis.
   ​TROUBLESHOOTING: If fused values continue to grow, inspect the activation output and the normalization layer. If all structural weights approach the same value, verify that structural features vary across images and that the fusion layer receives gradients. If feature files and image identifiers do not match, rebuild the output manifest before training or retrieval evaluation.

7. Model training and consistency optimization

1. Load the five random seed values recorded in configs/seeds.yaml. For each run, set the same random seed for Python, NumPy, PyTorch CPU operations, and all CUDA devices. Enable deterministic algorithms, disable cuDNN benchmark mode, and record the exact five seed values in the corresponding run directory.
2. Load the processed training manifest, pair manifest, probability maps, and structural priors.
3. Construct every training batch with eight structural categories and four appearance-varying samples from each category.
4. Calculate the structural consistency loss from positive sample pairs that share the same structural prior.
5. Calculate the structural relationship consistency loss from pairwise distances among component features.
6. Calculate the structural discrimination loss from negative sample pairs with heterogeneous structures and apply the separation threshold of 0.3.
7. Combine the appearance objective, structural consistency objective, structural relationship objective, and structural discrimination objective with the weights stored in configs/protocol.yaml.The feature-space optimization process governed by the three structural objectives is shown in Figure 4.
8. Run python train.py --config configs/protocol.yaml. Update all trainable parameters with mini-batch stochastic gradient descent using the initial learning rate, momentum, weight decay, epoch count, decay factor, and decay epochs defined in Step 1.8. Record the learning rate after every epoch in the training log.
9. Record total loss, appearance loss, structural consistency loss, structural relationship loss, structural discrimination loss, learning rate, Structural Consistency Index (SCI), Structural Discrimination Index (SDI), and Recall@5 after every epoch.
10. Evaluate the model on validation_manifest.csv after every epoch. Save the checkpoint associated with the highest validation SCI to checkpoints/selected_model.pth.
11. Repeat training five times with five recorded random seeds. Save each configuration file, training log, and selected checkpoint in a separate run directory.
12. Expected output: Confirm that each run produces a training log, a validation log, an epoch-level metric file, and one selected checkpoint. Confirm that the selected checkpoint is based on validation performance rather than test performance.
    NOTE: Use the same training, validation, and test manifests in every model comparison and ablation experiment.
    ​TROUBLESHOOTING: If a loss becomes non-numeric, stop training, inspect the component probability masses, reduce the learning rate by a factor of 10, and restart from the latest valid checkpoint. If validation SCI remains unchanged while training loss decreases, verify that graph propagation and fusion parameters receive gradients. If graphics memory is exhausted, reduce the batch size and preserve an effective batch size of 32 through gradient accumulation. If validation performance changes sharply between runs, verify the recorded random seed and the data-manifest order.

8. Inference, retrieval, clustering, and output verification

1. Run python infer.py --config configs/protocol.yaml --checkpoint checkpoints/selected_model.pth. Generate probability maps, structural priors, appearance feature matrices, structural feature matrices, fused component matrices, and final feature vectors for every test image.
2. Save all inference outputs under feature_outputs/test and record their paths in test_feature_manifest.csv. Calculate cosine similarity between every query feature and all gallery features. Sort the gallery identifiers in descending similarity order. Save the five highest-ranked results for each query to evaluation_results/retrieval_results.csv.
3. For every retrieval sample selected for visualization, load the typed adjacency matrix, relation-weight matrix, component-center matrix, inactive-node mask, component label mapping, and fused component matrix of the query image. Load the same files for the highest-ranked result generated by the structure-aware model.
4. Render the query component graph and the retrieved-image component graph from their saved component centers and typed adjacency matrices. Preserve the fixed component order and relation types used during model inference.
5. Render the query typed adjacency matrix as a categorical matrix. Use separate matrix values for inactive, shared-boundary, and vertical-order relations. Label the horizontal and vertical axes with the component identifiers stored in the component label mapping.
6. Apply L2 normalization to the query fused component matrix and the retrieved-image fused component matrix. Calculate the cosine similarity between every query component and every retrieved-image component. Save the resulting K × K component correspondence matrix to evaluation_results/structural_retrieval_evidence.
7. For every reference-target pair selected for local difference analysis, load the typed adjacency matrix, component-center matrix, spatial-dispersion matrix, relation-weight matrix, and fused component matrix of both images.
8. Calculate the absolute difference between the two typed adjacency matrices. Calculate the absolute differences in component-center displacement, spatial dispersion, and relation weights using the fixed component order. Save the resulting topology-difference matrix and geometric-relation-difference matrix to evaluation_results/structural_difference_evidence.
9. Calculate the L2 distance between corresponding rows of the two fused component matrices. Normalize the component-level distances and assign them to the nodes of the target component graph. Increase the edge width according to the normalized difference in relation weight. Save the resulting post-fusion component-difference graph.
10. Record the image identifiers, matrix paths, graph paths, component order, checkpoint identifier, and visualization output paths in structural_visualization_manifest.csv. Generate all structural visualizations programmatically from the recorded files; do not add graph nodes, graph edges, or matrix values manually.
11. Apply K-Means with five clusters to the final feature vectors and save the cluster assignments to evaluation_results/cluster_assignments.csv. Run python evaluate.py --config configs/protocol.yaml --feature_dir feature_outputs/test.
12. Calculate SCI, SDI, Recall@5, mean Average Precision (mAP), and the silhouette coefficient for each run. Use SCI to assess the compactness of normalized features that share the same structural label, and use SDI to assess the separation among different structural labels. Use Recall@5 to assess whether a relevant structural match appears in the short retrieval list, and use mAP to assess ranking quality across the entire gallery. Use the silhouette coefficient only for the clustering analysis.
13. Calculate the arithmetic mean and sample standard deviation across five independent runs. Retain the five run-level values for every method and metric. Do not apply min-max normalization, rank normalization, or rescaling based on the methods being compared. Conduct a paired t-test using results obtained under the same random seed and record the test statistic and exact two-sided significance value.
14. Compare the number of processed test identifiers, feature files, retrieval records, and cluster assignments. Resolve every mismatch before reporting or interpreting the evaluation results.
15. Expected output: Confirm that every test image has one complete inference record, one retrieval list, one cluster assignment, and one set of evaluation inputs. Confirm that every retrieval case selected for visualization has a query component graph, a retrieved-image component graph, a typed adjacency matrix, and a fused-component correspondence matrix.
16. Confirm that every structural difference case has a topology-difference matrix, a geometric-relation-difference matrix, a post-fusion component-difference graph, a spatial difference heatmap, and a response overlay. Confirm that all visualization files are linked to their source matrices through structural_visualization_manifest.csv. Save the pure heatmap, the target-image overlay, the foreground mask, and the top-response-region coordinates for each visualized case.
17. Accept a computed difference response only when the dominant high-response region overlaps the garment foreground and remains supported by the corresponding typed adjacency change, geometric relation change, and post-fusion component-distance evidence. If the strongest response falls mainly outside the garment foreground, inspect the parsing output, the component graph, and the fusion record.
    NOTE: Use the checkpoint selected from the validation set for inference on the test set. Do not select or replace a checkpoint according to test-set metrics. Use the same component order, inactive-node rule, relation-type encoding, and normalization process when generating graphs and matrices during inference and visualization.
    ​TROUBLESHOOTING: If inference stops before processing all test images, locate the final identifier in the inference log and resume from the following identifier. If retrieval results are dominated by color similarity, inspect the structural-prior and fusion outputs, and verify that checkpoint loading is successful. If evaluation reports duplicate identifiers, rebuild test_feature_manifest.csv and remove duplicate records before recalculation. If K-Means produces an empty cluster, verify feature normalization and rerun clustering with the recorded random seed.

9. Comparative model evaluation

1. Run python compare_models.py --config configs/protocol.yaml.
2. Train and evaluate ResNet-50, Part-based Convolutional Baseline (PCB), GCN, FashionGraph, Swin Transformer, CLIP, Topology Feature Histogram with Color and Texture Fusion, Attention-Guided Cascade Network, MMFL-Net, FARE-RNET, and the proposed method with the same training, validation, and test manifests.
3. Use the same image size, preprocessing operations, training epochs, effective batch size, evaluation queries, and metric implementation for every method.
4. Retain global average pooling for ResNet-50. Apply horizontal-strip alignment in PCB. Apply a fixed image-level garment graph in GCN. Apply attribute-guided dynamic graph inference in FashionGraph. Use the standard image encoders of Swin Transformer and CLIP. Implement Topology Feature Histogram with Color and Texture Fusion using topology, color, and texture descriptors. Implement an Attention-Guided Cascade Network using global and local feature branches with garment parsing. Implement MMFL-Net using multi-scale and multi-granularity feature branches. Implement FARE-RNET using residual attention, feature selection, and dilated contextual encoding.
5. Use only the image-query branch of every comparison method. Retrain every trainable method on the common training manifest and select its checkpoint from the common validation manifest. Generate a ranked gallery list for every test query.
6. Project every learned embedding to 512 dimensions through a registered trainable linear layer when its original dimension differs. Apply L2 normalization before cosine-similarity ranking. Use the same query-gallery assignment and metric implementation for all methods.
7. Repeat every comparison method with the same five random seeds. Report the mean and sample standard deviation of SCI, SDI, Recall@5, mAP, and silhouette coefficient. For each metric, conduct a two-sided paired t-test between the proposed method and every comparison method using results obtained under the same random seed. Record the five run-level values, test statistic, degrees of freedom, and exact p-value in evaluation_results/comparison_metrics.csv.
8. Calculate SCI, SDI, Recall@5, mAP, and the silhouette coefficient for every method. Save all run-level and aggregate values to evaluation_results/comparison_metrics.csv.
9. Expected output: Confirm that comparison_metrics.csv contains the same metric fields and the same number of independent runs for every comparison method.
   NOTE: Do not alter the data partitions, metric code, or query-gallery assignment between comparison methods.
   TROUBLESHOOTING: If a comparison model produces a feature dimension other than 512, add a single registered linear projection layer before the metric calculation and train that layer with the corresponding model. If a model fails to converge under the common learning rate, use the learning rate specified by its published implementation and retain all remaining experimental conditions. Record every method-specific setting in the comparison log.

Results

All reported experiments were executed using the hardware and software environment documented in Table 2 and the Table of Materials. The same graphics driver, CUDA, cuDNN, Python, NumPy, PyTorch, and torchvision versions were used throughout preprocessing, training, inference, and evaluation. The complete hardware and software environment is summarized in Table 2 and the Table of Materials. Table 1 summarizes the processed training, vali...

Discussion

The most critical protocol stages are garment-preserving preprocessing and foreground-restricted semantic component parsing. Component centers, spatial dispersion values, shared-boundary relations, vertical-order relations, relation weights, and fused representations are all derived from the parsing output. Boundary leakage, merged component regions, missing component regions, and incorrect channel assignments propagate through graph construction and feature fusion. These errors may produce graph files with valid dimensi...

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
Central Processing Unit	Intel Corporation	Intel Core i9-13900K, 24 cores, 32 threads, up to 5.80 GHz
Conda	Anaconda, Inc., anaconda.com	Miniconda3 23.11.0
CUDA Toolkit	NVIDIA Corporation, developer.nvidia.com	CUDA 11.8
cuDNN	NVIDIA Corporation, developer.nvidia.com	cuDNN 8.9.7
DeepFashion2 Dataset	The Chinese University of Hong Kong, github.com/switchablenorms/DeepFashion2	Official DeepFashion2 release, Version 1.0
Graphics Processing Unit	NVIDIA Corporation	NVIDIA GeForce RTX 4090, 24 GB GDDR6X
HRNet-W48 Semantic Parsing Checkpoint	HRNet Project, github.com/HRNet/HRNet-Semantic-Segmentation	hrnet_w48_garment_parser_7class.pth, project checkpoint Version 1.0
ImageNet-Pretrained ResNet-50 Weights	PyTorch Foundation, pytorch.org	ResNet50_Weights.IMAGENET1K_V2
Matplotlib	Matplotlib Development Team, matplotlib.org	Version 3.8.2
NumPy	NumPy Developers, numpy.org	Version 1.26.4
NVIDIA Graphics Driver	NVIDIA Corporation	Version 546.33
OpenCV-Python	OpenCV Team, opencv.org	Version 4.8.1.78
Operating System	Microsoft Corporation	Windows 11 Pro 23H2, 64-bit, OS Build 22631.3155
Pandas	Pandas Development Team, pandas.pydata.org	Version 2.1.4
Python	Python Software Foundation, python.org	Version 3.10.13
PyTorch	PyTorch Foundation, pytorch.org	Version 2.1.2 with CUDA 11.8
PyYAML	PyYAML Project, pyyaml.org	Version 6.0.1
scikit-learn	scikit-learn Developers, scikit-learn.org	Version 1.3.2
SciPy	SciPy Developers, scipy.org	Version 1.11.4
Source-Code Repository	Supplementary source-code archive submitted with the manuscript	Garment Topology Protocol, Version 1.0
Storage Device	Samsung Electronics	Samsung 990 PRO NVMe SSD, 2 TB
System Memory	Kingston Technology	Kingston FURY Beast DDR5, 64 GB, 2 × 32 GB, 5600 MHz
torchvision	PyTorch Foundation, pytorch.org	Version 0.16.2 with CUDA 11.8
Workstation	Custom-built deep-learning workstation	Intel Core i9-13900K, NVIDIA GeForce RTX 4090, 64 GB memory, 2 TB NVMe SSD