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, validation, and test datasets together with image-level topology statistics. Table 2 summarizes the common configuration used for all comparison methods.

Comparative evaluation results

The comparative evaluation followed the common data partitions, preprocessing operations, training controls, and metric definitions specified in Protocol sections 7–9. Table 3 compares general visual encoders, part-aligned models, graph-based garment representations, cross-domain fashion retrieval networks, topology-and-appearance fusion methods, and e-commerce visual retrieval methods, all evaluated using the same image-query protocol. The domain-specific methods comprise Topology Feature Histogram with Color and Texture Fusion (TFH-CT), Attention-Guided Cascade Network (AGC-Net), Multi-scale and Multi-granularity Feature Learning Network (MMFL-Net), and Fashion Retrieval using Residual Network with Egret Swarm Optimization (FARE-RNET). All evaluation metrics in Table 3 are reported as the mean and sample standard deviation across five independent runs using the same random seeds, training manifest, validation manifest, test manifest, query-gallery assignment, and metric implementation. The paired p-values were calculated separately for SCI, SDI, Recall@5, mAP, and silhouette coefficient by comparing each method with the proposed method under matched random-seed conditions. These results provide the quantitative basis for the subsequent structural visualization, retrieval, clustering, and design-oriented analyses.

Representative protocol outcomes and interpretation

Successful protocol execution is indicated when the image-level component graph reconstructed from the saved parsing and graph files places every active node inside its corresponding garment region and preserves the relation types recorded in the typed adjacency matrix, as shown in Figure 5C. The structure-aware response should remain concentrated on the garment foreground, as shown in Figure 5D. Figure 6E presents an expected retrieval outcome in which the proposed method reduces the influence of the red background and retrieves upper-body garments rather than unrelated red objects. Figure 6B–G also demonstrates that the retrieval ranking is supported by image-level component relations and post-fusion component correspondence. This result reflects the recovery of the coarse garment category, although sleeve length and local topology still vary among the retrieved samples.

Common failure cases include the texture-dominated activation in Figure 5B, the background-color-driven retrieval in the upper row of Figure 6, and the residual background activation in Figure 7. Figure 7 should be interpreted as partial localization because the dominant response follows the enlarged lower-body silhouette and the right garment boundary, while residual activation remains in adjacent background regions. The localization is considered structurally supported only when the topology-difference matrix, geometric-relation-difference matrix, post-fusion component-difference graph, and spatial response identify consistent garment regions. A spatial hotspot without corresponding changes in the matrix or components indicates visual interference rather than structural evidence.

A protocol run is considered valid when every accepted image produces a normalized semantic probability map, a relation matrix with K rows and K columns, appearance and structural feature matrices with K rows and 512 columns, and a finite fused feature vector linked to the correct image identifier. Visual inspection should confirm that the topology follows the garment components, that the foreground response exceeds the background response, and that retrieval results are guided by garment category and structure rather than by background color. Fragmented probability maps, missing component nodes, nonnumeric matrices, diffuse background responses, or color-dominated retrieval indicate unsuccessful execution and require inspection of parsing, graph construction, feature fusion, or checkpoint loading.

Visual analysis of image-level garment component responses

Figure 5 compares the ResNet-50 baseline with the component-aware model using the same garment image. Figure 5B shows the class activation map for the appearance baseline. Figure 5C presents the image-level garment component graph reconstructed from the foreground-restricted probability map, component center matrix, typed adjacency matrix, inactive-node mask, and component label mapping generated in Protocol sections 3 and 4. Figure 5D presents the activation response of the fused representation. No human pose estimator or human joint annotation is used to generate Figure 5C.

The baseline response was concentrated on local texture regions in the lower garment and did not consistently follow the complete garment boundary, as shown in Figure 5B. In Figure 5C, each node corresponds to the center of an active garment component region, while each edge represents a shared foreground boundary or a predefined vertical-order relation. The graph reflects garment-region organization and does not represent human anatomical joints. The structure-aware response covered the principal garment foreground while maintaining lower activation in most background areas, as shown in Figure 5D. These results indicate that the component graph and feature-fusion module reduced texture-dominated activation in the evaluated image.

Clothing structural similarity analysis and design reference results

Figure 6 presents the retrieval ranking along with the structural evidence used to interpret it. The query component graph in Figure 6B records active garment regions and their typed relations, while the matrix in Figure 6C exposes the relation pattern supplied to graph propagation. The baseline results in Figure 6D remain dominated by red appearance cues. The structure-aware results in Figure 6E retain the upper-body garment category across different colors and backgrounds. The component graph of the highest-ranked result in Figure 6F permits direct comparison with the query graph, and the correspondence matrix in Figure 6G reveals whether components sharing the same identifiers remain aligned after structure-guided fusion. The diagonal correspondence should be interpreted jointly with missing nodes and changed graph relations. Strong appearance similarity without graph agreement does not constitute successful structural retrieval.

The retrieved garments retain the coarse category, but differences in sleeve configuration and local component relations indicate incomplete fine-grained correspondence. The proposed method achieved a Recall@5 of 89.2% and an mAP of 86.4%, as reported in Table 3. These quantitative values describe ranking performance, while Figure 6B–G provides intermediate structural evidence supporting the interpretation. The retrieval conclusion is therefore limited to improved resistance to background-color interference and stronger image-level component organization under the tested query.

Structural difference response and design analysis support

The pure difference-response heatmap in Figure 7H shows that the dominant response is concentrated on the enlarged lower-body silhouette and the right garment boundary of the target image. The overlay in Figure 7I shows that the strongest response remains aligned with the main garment foreground, while weaker activation in the adjacent curtain and wall regions remains as residual background interference. The spatial response should be interpreted together with the component graph and matrix evidence presented in Figures 7C–G. A response is treated as a valid structural difference only when the high-response garment region is consistent with the adjacency change, geometric relation change, and post-fusion component-distance pattern.

A structural difference is accepted only when the typed adjacency change in Figure 7E or the geometric relation change in Figure 7F is accompanied by an increased component distance in Figure 7G and a foreground-aligned spatial response in Figure 7H,I. The enlarged lower-body region and the right garment boundary satisfy this cross-stage criterion. Activation over the curtain and wall does not correspond to changes in component nodes, relation patterns, or fused component distances, and is therefore rejected as non-structural residual interference. The result supports image-level difference localization but does not establish variation in sewing patterns or construction parameters.

Feature spatial distribution and structural cluster analysis

Analyzing the distribution of the latent feature space reveals the model's ability to discriminate the structural semantics of clothing. This analysis examines whether the structural prior organizes garments with different topological configurations into distinct feature manifolds. Five representative structural categories from the test set—short-sleeved tops, trousers, skirts, long coats, and dresses—were selected. The high-dimensional feature vectors were projected onto a two-dimensional plane using t-distributed stochastic neighbor embedding (t-SNE). The cohesion of similar samples and separation of dissimilar samples were assessed to characterize the organization of structural semantics in the feature space. The t-SNE distribution of the structure-aware feature space is shown in Figure 8.

The t-SNE projection formed five main feature regions with limited overlap between neighboring categories, as shown in Figure 8A. Representative samples corresponding to the five category regions are shown in Figure 8B. The SCI of 0.81 reflects the compactness of samples sharing the same structural label, and the SDI of 0.71 reflects the separation between samples with different structural labels, as reported in Table 3 and visualized in Figure 8. These indices should be interpreted as measures of feature-space distribution and do not directly establish a false-alarm rate. Short-sleeved tops and skirts occupied different principal regions in the projected feature space, while a small number of samples remained near neighboring category boundaries, as shown in Figure 8A. Trousers and dresses also showed clear separation from neighboring categories. This distribution indicates that the graph prior contributed to category-level structural organization without producing complete cluster separation. The evaluation separates representation quality from retrieval effectiveness. SCI assesses whether garments sharing the same structural label remain compact in the learned feature space, whereas SDI assesses whether garments with different structural labels remain separated. These metrics correspond to the protocol's structural representation objective. Recall@5 measures whether a structurally relevant garment appears within the first five retrieved results, while mAP measures ranking quality across all relevant gallery samples. These metrics correspond to the design-reference retrieval objective. The silhouette coefficient was used only to evaluate clustering performance because SCI and SDI already characterize feature-space organization.

Figure 9 reports the raw five-run results for four representative methods without cross-method normalization. Figure 9A presents SCI and SDI on their original scale, while Figure 9B presents Recall@5 and mAP as percentages. The individual run markers and standard deviation error lines show the variation associated with model training rather than only the aggregate ranking. The appearance-driven baseline achieved an SCI of 0.62, while the proposed method achieved an SCI of 0.81 and an SDI of 0.71 (Table 3 and Figure 9A). The SCI and SDI results indicate stronger within-label compactness and between-label separation under the evaluated setting. The proposed method achieved a Recall@5 of 89.2% and an mAP of 86.4% (Table 3 and Figure 9B). These retrieval metrics assess different ranking properties and are interpreted separately from SCI and SDI. The consistent ordering of methods across the four metrics indicates agreement between representation quality and retrieval performance, but it does not imply that the relative improvement is identical across the four evaluation dimensions.

Ablation experiments and structural module effectiveness analysis

The ablation experiment compares the complete model with variants in which the structural prior or the fusion module is removed. All three configurations use the same reference and target images, enabling direct comparison of background response and localization concentration. The variant without the structure prior removes the image-level garment component graph and its relation constraints, relying only on the convolutional backbone to extract appearance features; the non-fusion variant retains graph inference but removes the feature pyramid, using only high-level semantic features. Visualized difference heatmaps reveal the specific roles of each module in noise suppression and boundary definition; a qualitative comparison of structural difference responses under different module configurations is shown in Figure 10.

The response maps in Figure 10C–E were rendered using a shared response scale and identical overlay settings. The variant without the structure prior produced strong activation in the left background and around unrelated environmental regions, as shown in Figure 10C. The variant without the fusion module reduced part of that off-garment response but still retained a broader spread over the lower garment and the right-side surrounding region, as shown in Figure 10D. The complete model further contracted the dominant response toward the main garment foreground, as shown in Figure 10E. Figure 10F directly visualizes the difference in foreground-restricted responses between the non-fusion variant and the complete model, showing that the complete model suppresses residual lateral spread while preserving the principal garment-aligned response. These results indicate that the structure prior mainly reduced environmental noise and that the fusion module further improved response concentration and structural alignment. Figure 10E represents a relative improvement rather than a complete removal of background activation.

Table 4 reports SCI, SDI, and Recall@5 for the variants without the structure prior, without the fusion module, and with the complete model. Removing the structure prior reduced the SCI from 0.81 to 0.65 and reduced Recall@5 from 89.2% to 74.5%. Removing the fusion module reduced the SDI from 0.71 to 0.64 and reduced Recall@5 from 89.2% to 85.1%, a decrease of 4.1 percentage points. These results indicate that the structure prior had a greater effect on structural consistency and retrieval, while feature fusion improved the alignment between appearance and structural information.

The efficiency analysis compares the computational cost of the complete model with the ResNet-50 baseline. The ResNet-50 baseline required 25.6 million parameters and 4.1 billion floating-point operations. The complete structure-aware model required 29.3 million parameters and 5.4 billion floating-point operations. The average inference time was 15 milliseconds per image for the baseline and 22 milliseconds per image for the complete model, an increase of 7 milliseconds. This result indicates a measurable computational cost that should be considered when deploying the protocol in time-sensitive workflows (Table 5). The structural constraint weight was determined from the validation split before the final test evaluation. Validation Recall@5 was examined at structural constraint weights of 0.1, 0.3, 0.5, 0.8, 1.0, 1.2, 1.5, and 2.0. A weight of 1.0 was fixed for every subsequent training and test run. Figure 11 documents the validation-based selection of a structural constraint weight of 1.0.

Figure 1: Overall workflow of the structure-aware garment image feature learning protocol. The input garment image is processed by an appearance feature branch and a structural feature branch that uses semantic parsing and spatial graph modeling. The two representations are processed by the structure-guided fusion module to generate the final structure-aware feature. Structural consistency loss, structural discrimination loss, and structural relationship loss jointly constrain the feature space. The figure shows how garment appearance and component topology are integrated throughout feature learning. Please click here to view a larger version of this figure.

Figure 2: Construction of an image-level garment component topology prior. (A) The input garment image I. (B) The foreground-restricted visual component map P, in which seven colors denote image-level garment regions. All background pixels are excluded from the component channels. (C) The image-level component relation graph G. Nodes represent visible garment regions, solid edges represent shared foreground boundaries, and dashed relations represent predefined vertical order. The map and graph support image retrieval and visual structure comparison. They do not represent sewing-pattern pieces, seam geometry, dart structures, grading parameters, or cutting instructions. Please click here to view a larger version of this figure.

Figure 3: Structure-guided feature fusion module. The structural feature is transformed by the linear mapping and activation function Ψ to generate a structure weight. The structure weight modulates the appearance feature through element-wise multiplication. The modulated appearance feature and the structural feature are concatenated and projected by Wc, after which the residual structural feature is added to generate the final component feature . The figure shows that structural information regulates appearance-feature weighting before final fusion. Please click here to view a larger version of this figure.

Figure 4: Feature-space optimization under structural consistency constraints. (A) Samples belonging to the same structural class are pulled closer through the structure consistency loss, while their internal component relationships are preserved by the structure relationship loss. (B) Samples from different structural classes are pushed apart by the structure discrimination loss. The figure shows how the three structural objectives jointly increase within-class compactness and between-class separation. Please click here to view a larger version of this figure.

Figure 5: Representative garment feature responses and component-graph visualization. (A) The input garment image. (B) The class activation response of the ResNet-50 appearance baseline. (C) The image-level garment component graph was reconstructed from the foreground-restricted component map, component center matrix, typed adjacency matrix, inactive-node mask, and component label mapping, which were saved during Protocol sections 3 and 4. Nodes denote active garment regions, solid edges denote shared foreground boundaries, and dashed edges denote predefined vertical-order relations. (D) The activation response of the fused component-aware representation. The comparison shows the difference between texture-dominated activation and garment-region-guided activation. Please click here to view a larger version of this figure.

Figure 6: Retrieval outcomes and intermediate structural evidence under red-background interference. (A) The query image. (B) The query component graph is generated from the saved component centers and the typed adjacency matrix. (C) The query typed adjacency matrix, where the matrix values distinguish inactive relations, shared foreground boundaries, and predefined vertical-order relations. (D) The top-three retrieval results were produced by the appearance baseline. (E) The top-three results were produced by the structure-aware representation. (F) The component graph of the highest-ranked structure-aware result. (G) The post-fusion component correspondence matrix between the query and the highest-ranked result. High diagonal correspondence indicates agreement between components with the same identifiers, while weak or displaced responses indicate missing or mismatched component organization. The retrieval results preserve the coarse upper-body category but do not establish complete agreement in sleeve configuration and local topology. Please click here to view a larger version of this figure.

Figure 7: Structural difference tracing from image-level garment topology to spatial response. (A) The reference image. (B) The target image. (C) The reference component graph. (D) The target component graph. Both graphs are reconstructed from the saved component centers and typed adjacency matrices. (E) The typed adjacency difference matrix. (F) The geometric relation difference is derived from component-center displacement, spatial dispersion, and changes in relation weight. (G) The post-fusion component-difference graph, where node intensity represents the normalized distance between corresponding fused component vectors and edge width represents the relation-weight change. (H) The pure spatial difference-response heatmap was rendered using the same fixed response scale as the overlay. (I) The response overlaid on the target image. A structural difference is accepted only when the adjacency change, geometric relation change, component-distance change, and foreground-aligned heat response remain consistent. Background activation without corresponding evidence of components or relations is treated as residual interference rather than a valid garment-structure difference. Please click here to view a larger version of this figure.

Figure 8: Structure-aware feature-space clustering. (A) The t-SNE projection of short-sleeved tops, trousers, skirts, long coats, and dresses. The five categories form principal feature regions with limited overlap near the boundaries between them. (B) Representative test images assigned to the five garment categories, with the border color corresponding to the category color in (A). The figure shows category-level structural organization while retaining a small number of samples near adjacent category regions. Please click here to view a larger version of this figure.

Figure 9: Raw performance comparison across feature-space structure and retrieval-ranking objectives. (A) SCI and SDI for the appearance-driven baseline, weak-structure model, explicit-structure model, and proposed method. (B) Recall@5 and mAP for the same four methods. Large markers denote the arithmetic mean across five independent runs, error lines denote the sample standard deviation, and small markers denote the run-level results. SCI and SDI are displayed on a fixed scale from zero to one, while Recall@5 and mAP are displayed on a fixed percentage scale from zero to one hundred. No min-max normalization or cross-method rescaling is applied. Please click here to view a larger version of this figure.

Figure 10: Structural difference responses under different module configurations. (A) The reference image. (B) The target image. (C) The response of the variant without the structure prior. (D) The response of the variant without the fusion module. (E) The response of the complete model. (C–E) are rendered using the same normalized response scale, color map, and overlay settings. (F) The foreground-restricted absolute response difference between the non-fusion variant and the complete model. The complete model preserves the principal garment-aligned response while reducing residual spread outside the main structural region. The comparison shows that the structure prior reduces off-garment interference and that the fusion module further sharpens the structural response. Please click here to view a larger version of this figure.

Figure 11: Validation-based selection of the structural constraint weight. Validation Recall@5 is reported at structural constraint weights of 0.1, 0.3, 0.5, 0.8, 1.0, 1.2, 1.5, and 2.0. Each point denotes the arithmetic mean across five validation runs, and each error line denotes the sample standard deviation. The weight was fixed at 1.0 before the final test evaluation. This figure documents the parameter selection procedure and does not constitute an independent architectural contribution. Please click here to view a larger version of this figure.

Table 1: Dataset allocation and image-level topology statistics across the S1 to S5 garment subsets. The table reports the training, validation, test, and total image counts together with the mean semantic-component count, active-node count, typed-edge count, and annotated image-plane landmark count for each structural level. All values are generated from the processed data manifests. Training, validation, and test image counts were obtained from the final subset manifests after structural review, duplicate-group control, and leakage inspection, while topology statistics were calculated from the final graph records using the same component order and relation definitions as those applied during model evaluation. Please click here to download this file.

Table 2: Computational environment, input configuration, augmentation, representation, optimization, loss, and reproducibility settings used throughout the protocol. The table reports the exact operating system, processor, installed memory, graphics processing unit, graphics memory, graphics driver, CUDA, cuDNN, Python, NumPy, PyTorch, and torchvision versions together with the image size, batch construction, optimizer, learning-rate schedule, epoch count, random seeds, representation dimensions, and structural objective weights. Each value is linked to software_versions.txt, configs/protocol.yaml, or the corresponding training record. Please click here to download this file.

Table 3: Quantitative comparison of general visual representation models, graph-based garment models, and domain-specific fashion retrieval methods. The table reports the retrieval focus, query modality, SCI, SDI, Recall@5, mAP, and silhouette coefficient for eleven methods under the same data partitions and evaluation protocol. Every metric is reported as the mean and sample standard deviation across five independent runs. The reported p-values were obtained from two-sided paired t-tests comparing each comparison method with the proposed method, using results produced under the same five random seeds. The proposed method is treated as the reference row. Please click here to download this file.

Table 4: Ablation results for the structure prior and feature-fusion module. The table reports SCI, SDI, and Recall@5 for the variant without the structural prior, the variant without the fusion module, and the complete model. Removing the structure prior yields a larger reduction in SCI and Recall@5, whereas removing the fusion module reduces SDI and response alignment. The complete model records the highest value for all three metrics. Please click here to download this file.

Table 5: Computational efficiency of the ResNet-50 baseline and the complete structure-aware model. The table reports trainable parameters, floating-point operations per image, and average inference time per image under the exact hardware and software environment documented in Table 2 and the Table of Materials. Both models use the same image resolution, inference batch setting, preprocessing operations, and timing procedure. The complete model adds 3.7 million parameters, 1.3 billion floating-point operations, and 7 milliseconds of inference time per image relative to the baseline. Please click here to download this file.

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 dimensions while the represented component relations remain inconsistent with the source garment. The probability map, foreground restriction, component preview, and parsing-quality record must therefore be verified before the structural prior is accepted.

Graph construction and feature fusion require a fixed order of semantic components. The graph is derived from foreground garment components and their image-plane relationships. The retrieval and difference-localization figures expose the structural processing path rather than displaying only final ranked images or response heatmaps. Typed adjacency matrices document discrete component relations, geometric relation matrices document normalized spatial organization, and post-fusion component matrices document the representation used for retrieval and localization. Structural conclusions should be accepted only when these intermediate representations agree with the final visual output. The component graph does not use anatomical landmarks, human joint coordinates, or a pose-estimation network. A graph overlay should be accepted only when its nodes and relation types are reproduced from the saved component and adjacency files. Inactive components should remain as zero vectors with inactive-node indicators, and the appearance and structural feature matrices must each contain K rows and 512 columns before fusion.These checks prevent node misalignment and dimension errors from being interpreted as model behavior.

Troubleshooting should begin at the earliest invalid intermediate output. Uniform probability maps indicate checkpoint, normalization, or category-index errors; nonnumeric structural matrices indicate invalid probability denominators or coordinate scaling; diffuse responses and color-dominated retrieval indicate weak structural priors, failed fusion, or incorrect checkpoint loading. Training logs should confirm gradients in the graph and fusion layers, as well as validation-based checkpoint selection. A visual heat response should not be used as a standalone structural conclusion. It must be checked against the saved foreground mask, the typed adjacency change, the geometric relation matrix, and the post-fusion component-difference graph. Residual activation outside the garment foreground indicates limited response specificity rather than a validated structural difference.

Compared with appearance-driven retrieval, the protocol introduces component topology before metric learning. Compared with weak structural constraints and fixed-topology graph models, semantic relation weights adapt graph propagation to the current garment. The complete model achieved an SCI of 0.81, an SDI of 0.71, a Recall@5 of 89.2%, an mAP of 86.4%, and a silhouette coefficient of 0.74, as reported in Table 3. The additional structural modules increased the parameter count from 25.6 million to 29.3 million and inference time from 15 to 22 milliseconds per image, as reported in Table 4. The technical contribution of the protocol lies in the construction of an image-level garment component graph, the parallel encoding of appearance and component relations, the structure-guided feature-fusion mechanism, and the structural consistency, relationship, and discrimination objectives. The validation sweep reported in Figure 11 serves only to determine a fixed training coefficient and is not presented as a contribution to network architecture or objective function design.

The protocol remains sensitive to severe occlusion, overlapping garments, small source images, pose variation, complex backgrounds, and garments whose visible organization does not conform to the fixed seven-region schema. Asymmetric designs, detachable layers, dense draping, multilayer lower garments, and overlapping decorative regions may merge several semantic regions or introduce component relations that are absent from the current graph definition. Occlusion may suppress an active component, shift its probability centroid, and remove a valid shared-boundary relation. Figure 6 shows recovery of the coarse upper-body category but incomplete sleeve-topology matching, while Figures 7 and 10 retain responses in adjacent background areas. These outcomes show that valid tensor dimensions and graph connectivity do not guarantee a semantically correct structural interpretation. The present study, therefore, supports image-based retrieval, clustering, and difference localization rather than design-workflow efficiency or direct estimation of pattern parameters. All quantitative experiments in the present study are conducted on the retained and structurally relabeled DeepFashion2 cohort. The current results do not establish robustness across independent datasets with different garment taxonomies, annotation standards, cultural clothing categories, image sources, or acquisition environments. Transfer to another dataset may require remapping the seven component channels and reconstructing the typed relation schema. The reported conclusions are therefore restricted to the evaluated data distribution and image-level component definition.

Within these limits, the protocol provides a reproducible sequence from garment images to component-aware representations through semantic parsing, geometric relationship modeling, dual-stream encoding, and structure-guided fusion. Future validation will use independent garment datasets with different annotation systems, clothing categories, poses, and background conditions. It will also examine whether the current seven-region mapping requires extension for asymmetric, layered, detachable, and culturally specific garment structures. Hand-drawn design sketches, cross-fabric variation, and parameterized pattern adjustment remain separate application directions that require task-specific data and evaluation procedures. Professional usability and design review efficiency require a separately documented human-subjects study with defined participants, evaluation criteria, and statistical procedures.

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