This README is available in English below and in Italian / italiano. La versione italiana si trova nella seconda parte del documento.

These weights were trained and used with my OutfitTransformer model, available in the FlorindoDev/OutfitTransformer repository. To use them, refer to that project's code, architecture, and instructions.

OutfitTransformer: Weights and precomputed embeddings

This repository contains checkpoints trained with my implementation of OutfitTransformer and precomputed embeddings for the project's training and evaluation workflows.

The source code, model configuration, and usage instructions are available on GitHub. It includes the CP_precomputed (Compatibility Prediction) and CIR_precomputed (Complementary Item Retrieval) runs, both on the Polyvore nondisjoint subset, together with train, validation, and test embeddings.

Contents and organization

Artifacts are organized as follows. Each run contains best.pt, config.json, individual epoch checkpoints in epochs/, and plots in plots/.

.
├── README.md
├── .gitattributes
├── checkpoints/
│   └── nondisjoint/
│       ├── CP_precomputed/
│       └── CIR_precomputed/
└── precomputed_embeddings/
    └── nondisjoint/
        ├── train/                  # manifest.json + shard-*.pt
        ├── validation/             # manifest.json + shard-*.pt
        └── test/                   # manifest.json + shard-*.pt

Parameters and hyperparameters of the published runs

The following values come from the saved configurations for CP_precomputed and CIR_precomputed, compared with run_config in their respective best.pt files and latest available checkpoints. Descriptions follow the project documentation; the values shown are those of the published experiments. null indicates an unset value; not recorded indicates a field absent from the saved configuration.

Checkpoints and recorded progress

Parameter	CP_precomputed	CIR_precomputed
Run folder	`checkpoints/nondisjoint/CP_precomputed/`	`checkpoints/nondisjoint/CIR_precomputed/`
Checkpoint format version (`checkpoint_schema_version`)	`2`	`1`
Configured maximum epochs (`training.epochs`)	`200`	`200`
Available epoch checkpoints	`81`, epochs `1–81`	`42`, epochs `1–42`
Latest available checkpoint	`epochs/cp_epoch_081.pt`	`epochs/cir_epoch_042.pt`
Epoch of `best.pt`	`73`	`17`
Selection metric (`training.best_metric`)	`val_auc`, maximize	`val_fitb_accuracy`, maximize
Metric value in the best checkpoint	AUC `0.95082516`	FITB accuracy `0.6854` (`68.54%`)
Training examples in the best epoch	`106612`	`53248`
Validation examples in the best epoch	`10000`	`5000`

The 200 epochs and the total number of optimizer steps listed below describe the configured plan. Available checkpoints document training through epochs 81 and 42 respectively; they do not establish that all 200 epochs were completed.

Dataset and features

The values in this table are shared by both runs.

Parameter	Recorded value
Dataset (`dataset.name`)	`polyvore`
Dataset identifier (`dataset.id`)	`mvasil/polyvore-outfits`
Subset (`dataset.subset`)	`nondisjoint`
Dataset directory during training (`dataset.dataset_root`)	`datasets/polyvore-outfits`
Custom dataset cache (`dataset.cache_dir`)	`null`
Embedding directory during training (`dataset.embedding_root`)	`precomputed_embeddings/patrickjohncyh-fashion-clip`
Feature mode (`dataset.feature_mode`, `features.mode`)	`precomputed`
Use of precomputed embeddings (`features.precomputed`)	`true`
Encoder in the configuration (`features.encoder`)	`from_embedding_manifest`
Encoder identified in the manifests	`patrickjohncyh/fashion-clip`
Trainable features (`features.trainable`)	`false`: the encoders are not trained in these runs

The recorded embedding path is the one used during training. In this repository, the caches are stored directly under precomputed_embeddings/nondisjoint/<split>/. To use this layout, set --embedding-root to the path of the downloaded precomputed_embeddings folder.

Architecture

For CP, Transformer keys are under model; for CIR, they are under model.transformer. The total input dimension is derived by concatenating the two modalities.

Parameter	CP_precomputed	CIR_precomputed
Dimension per modality (`modality_embedding_dim`)	`512`	`512`
Total input / Transformer dimension	`1024 = 512 + 512`	`1024 = 512 + 512`
Number of layers (`layers`)	`6`	`6`
Attention heads (`attention_heads`)	`16`	`16`
Feed-forward dimension (`feedforward_dim`)	`2024`	`2024`
Activation (`activation`)	`mish`	`mish`
Dropout (`dropout`)	`0.3`	`0.3`
Pre-norm (`norm_first`)	`true`	`true`
LayerNorm epsilon (`layer_norm_epsilon`)	`1e-5`	`1e-5`
L2 normalization epsilon (`normalization_epsilon`)	`1e-12`	`1e-12`
Embedding initialization standard deviation (`embedding_initialization_std`)	`0.02`	`0.02`
Maximum number of items (`max_items`)	`16`	`16`
Additional final LayerNorm, verified in the weights	Present: `cp.encoder.norm.*`	Absent: no `cir.encoder.norm.*` keys
Retrieval embedding dimension (`model.cir.embedding_dim`)	Not applicable	`128`
L2 normalization of final retrieval embeddings (`model.cir.normalize_embeddings`)	Not applicable	`false`
Category embedding (`model.use_category_embedding`)	Not applicable	`false`

Training and loss function

Parameter	CP_precomputed	CIR_precomputed
Microbatch (`training.batch_size` / `training.batch_size_per_process`)	`512` outfits	`64` outfits per process
Gradient accumulation (`training.gradient_accumulation_steps`)	`4` microbatches	`4` microbatches
Effective batch size (`training.effective_batch_size` / `training.effective_batch_size_global`)	`2048`	`256` global
Effective batch size per process (`training.effective_batch_size_per_process`)	Not recorded separately	`256`
Optimizer (`training.optimizer`)	`AdamW`	`AdamW`
Configured / maximum learning rate (`training.learning_rate`)	`2e-5`	`2e-5`
Weight decay (`training.weight_decay`)	`0.01`	`0.01`
Gradient clipping, maximum norm (`training.max_grad_norm`)	`1.0`	`1.0`
Seed (`training.seed`)	`42`	`42`
Loss (`training.loss`)	`FocalLoss`	`InBatchTripletMarginLoss`
Loss reduction (`training.focal_reduction` / `training.loss_reduction`, `model.cir.loss_reduction`)	`mean`	`mean`
Focal alpha (`training.focal_alpha`)	`0.5`	Not applicable
Focal gamma (`training.focal_gamma`)	`2.0`	Not applicable
Triplet margin (`training.triplet_margin`, `model.cir.triplet_margin`)	Not applicable	`2.0`
Negative sampling (`training.negative_sampling`)	Not applicable	`in_batch`
Target sampling (`training.target_sampling`)	Not applicable	`random_item_per_outfit_access`
Early stopping patience (`training.early_stopping_patience`)	`null`: disabled	`null`: disabled
Minimum improvement (`training.early_stopping_min_delta`)	`0.0`	`0.0`
Resume weights (`training.resume_weights`)	`null`	`null`
Initialization from CP (`training.pretrained_cp_weights`)	Not applicable	`best.pt`
Optimizer steps per epoch (`training.optimizer_steps_per_epoch`)	`53`	`208`
Total planned optimizer steps (`training.total_optimizer_steps`)	`10600`	`41600`

For CIR, the target is an item chosen at random on every access to an outfit. As described in the training README, the loss selects the hardest negative among the positives from the other rows in the same microbatch: accumulating up to 256 examples does not expand the negative pool of the 64-example microbatch.

CIR initialization records only the name best.pt of the source CP checkpoint, without its full path or hash. This alone does not uniquely identify that file as the CP_precomputed/best.pt published here.

Scheduler

All fields in this table are saved under training.scheduler and have the same values in both runs.

Parameter	Value
Scheduler (`name`)	`OneCycleLR`
Update frequency (`step`)	`optimizer_step`: after each optimizer update
Maximum learning rate (`max_lr`)	`2e-5`
Initial fraction of the cycle (`pct_start`)	`0.3`
Annealing strategy (`anneal_strategy`)	`cos`
Initial LR factor (`div_factor`)	`25.0`
Minimum LR factor (`final_div_factor`)	`10000.0`

Runtime

Parameter	CP_precomputed	CIR_precomputed
Requested device (`runtime.requested_device`)	`auto`	`auto`
Resolved device (`runtime.resolved_device`)	`cuda`	`cuda`
DataLoader workers (`runtime.num_workers`)	`0`	`0`
Pinned memory (`runtime.pin_memory`)	`false`	`false`
Logging frequency (`runtime.log_every`)	Every `10` microbatches	Every `10` microbatches
Distributed training (`runtime.ddp`)	Not recorded	`false`
Number of processes (`runtime.world_size`)	Not recorded	`1`
Distributed backend (`runtime.distributed_backend`)	Not recorded	`null`
Mixed precision (`runtime.mixed_precision`)	Not recorded	`false`

The tables cover all fields present in the two config.json files. Implicit settings that were not serialized, such as AdamW betas and epsilon, and details such as the GPU model and software versions are not documented by the inspected artifacts.

Checkpoints

Weights are saved in PyTorch .pt format. In the project's current format, each checkpoint contains model_state_dict, run_config, the epoch number, metrics, training history, and best-model selection information. config.json stores a readable version of the experiment configuration.

best.pt is the checkpoint selected during training according to the configured metric. Files in epochs/, when available, allow other epochs from the run to be used. Current checkpoints do not include optimizer or scheduler state: resuming in this project initializes a new run from the saved weights.

To load a checkpoint, use the loaders and commands from the source repository with the configuration and architecture version used during training. It is also useful to record the Git commit of the code used for each experiment. The CP checkpoint published here contains cp.encoder.norm.*, which is absent from the current CP architecture. Handling these checkpoints for CIR initialization is described in the CIR README.

Uploading to the Hub preserves the project's format; it does not automatically add support for transformers.AutoModel.from_pretrained().

Precomputed embeddings

Embeddings are numerical representations of items, generated using the project's precomputation procedure. They can be reused in workflows that support precomputed features, avoiding the need to run the encoders again for each item.

Each cache includes manifest.json and all shard-*.pt files listed in the manifest, kept in the same folder. Shards contain schema_version, the item_ids identifiers, and the embeddings tensor; the manifest describes the encoder, dataset, subset, split, dimensions, precision, fingerprint, and shards.

In the current procedure, each embedding concatenates the image and text representations, each normalized separately with L2 normalization. With FashionCLIP and the default configuration, each vector has 1024 components: 512 visual and 512 textual. The actual cache values are documented in its manifest.

Parameters of the published caches

Parameter	Value in the manifests
Format version (`schema_version`)	`2`
Dataset / subset	`mvasil/polyvore-outfits` / `nondisjoint`
Encoder model (`encoder.model_name`)	`patrickjohncyh/fashion-clip`
Visual encoder (`encoder.visual_encoder`)	`FashionCLIPVisualEncoder`
Text encoder (`encoder.text_encoder`)	`FashionCLIPTextEncoder`
Dimension per modality (`encoder.modality_dim`)	`512`
Final dimension (`embedding_dim`)	`1024`
Aggregation (`encoder.aggregation`)	`concat_visual_then_text`
Normalization (`encoder.normalization`)	`l2_per_modality`
Saved precision (`dtype`)	`float32`
Item count limit (`limit`)	`null`
Visual / text encoder commit (`encoder.visual_commit`, `encoder.text_commit`)	`null` / `null`

Split	Items (`count`)	Shards	Manifest
Train	`204679`	`21`	train/manifest.json
Validation	`25132`	`3`	validation/manifest.json
Test	`47854`	`5`	test/manifest.json

Each shard contains 10000 items, except the last shard in each split: 4679 for train, 5132 for validation, and 7854 for test. These counts refer to items with embeddings, not outfits or training examples.

Train and validation share the model_fingerprint dfcff17f9fb9335b22792d610cb7e4ba8cd73afa2954b725aa5e2d993bc10c27. The test cache instead records b00590d05bc4af1a3a5316ecb65dabea7315fa93adf0dcbdbec0b8399ec1e788. The encoder name and dimensions match, but the fingerprints differ: these metadata do not establish that the precomputation configuration is identical between test and the other splits.

Use embeddings consistent with the checkpoint and the required dataset, subset, and split. Training workflows also verify that encoder fingerprints match between train and validation caches. Caches contain identifiers and vectors; the data needed to construct outfits, labels, and queries are still those required by the project.

References

Questi sono pesi allenati e utilizzati con il mio modello OutfitTransformer, disponibile nella repository FlorindoDev/OutfitTransformer. Per utilizzarli, fai riferimento al codice, all'architettura e alle istruzioni di quel progetto.

OutfitTransformer: Pesi ed embedding precomputati

Questa repository raccoglie i checkpoint allenati con la mia implementazione di OutfitTransformer e gli embedding precomputati utilizzabili nei flussi di training e valutazione del progetto.

Il codice sorgente, la configurazione del modello e le istruzioni di utilizzo sono disponibili su GitHub. Sono inclusi i run CP_precomputed (Compatibility Prediction) e CIR_precomputed (Complementary Item Retrieval), entrambi sul subset nondisjoint di Polyvore, insieme agli embedding di train, validation e test.

Contenuto e organizzazione

Gli artefatti sono organizzati come segue. Ogni run contiene best.pt, config.json, i checkpoint delle singole epoche in epochs/ e i grafici in plots/.

.
├── README.md
├── .gitattributes
├── checkpoints/
│   └── nondisjoint/
│       ├── CP_precomputed/
│       └── CIR_precomputed/
└── precomputed_embeddings/
    └── nondisjoint/
        ├── train/                  # manifest.json + shard-*.pt
        ├── validation/             # manifest.json + shard-*.pt
        └── test/                   # manifest.json + shard-*.pt

Parametri e iperparametri dei run pubblicati

I valori seguenti provengono dalle configurazioni salvate nei run CP_precomputed e CIR_precomputed, confrontate con run_config nei rispettivi best.pt e nell'ultimo checkpoint disponibile. Le descrizioni seguono la documentazione del progetto; i valori riportati sono quelli degli esperimenti pubblicati. null indica un valore non impostato; non registrato indica un campo assente dalla configurazione salvata.

Checkpoint e avanzamento registrato

Parametro	CP_precomputed	CIR_precomputed
Cartella del run	`checkpoints/nondisjoint/CP_precomputed/`	`checkpoints/nondisjoint/CIR_precomputed/`
Versione del formato checkpoint (`checkpoint_schema_version`)	`2`	`1`
Epoche massime configurate (`training.epochs`)	`200`	`200`
Checkpoint di epoca disponibili	`81`, epoche `1–81`	`42`, epoche `1–42`
Ultimo checkpoint disponibile	`epochs/cp_epoch_081.pt`	`epochs/cir_epoch_042.pt`
Epoca di `best.pt`	`73`	`17`
Metrica di selezione (`training.best_metric`)	`val_auc`, da massimizzare	`val_fitb_accuracy`, da massimizzare
Valore della metrica nel best	AUC `0.95082516`	FITB accuracy `0.6854` (`68.54%`)
Esempi train nell'epoca del best	`106612`	`53248`
Esempi validation nell'epoca del best	`10000`	`5000`

Le 200 epoche e il numero totale di optimizer step riportato sotto descrivono il piano configurato. I checkpoint disponibili documentano il training fino alle epoche 81 e 42 rispettivamente; non attestano il completamento delle 200 epoche.

Dataset e feature

I valori di questa tabella sono comuni ai due run.

Parametro	Valore registrato
Dataset (`dataset.name`)	`polyvore`
Identificativo dataset (`dataset.id`)	`mvasil/polyvore-outfits`
Subset (`dataset.subset`)	`nondisjoint`
Directory dataset nel training (`dataset.dataset_root`)	`datasets/polyvore-outfits`
Cache dataset personalizzata (`dataset.cache_dir`)	`null`
Directory embedding nel training (`dataset.embedding_root`)	`precomputed_embeddings/patrickjohncyh-fashion-clip`
Modalità feature (`dataset.feature_mode`, `features.mode`)	`precomputed`
Uso di embedding precomputati (`features.precomputed`)	`true`
Encoder nella configurazione (`features.encoder`)	`from_embedding_manifest`
Encoder identificato nei manifest	`patrickjohncyh/fashion-clip`
Feature allenabili (`features.trainable`)	`false`: gli encoder non vengono allenati in questi run

Il percorso degli embedding registrato è quello usato durante il training. In questa repository le cache si trovano direttamente in precomputed_embeddings/nondisjoint/<split>/: per usare questa disposizione, imposta --embedding-root sul percorso della cartella precomputed_embeddings scaricata.

Architettura

Per CP le chiavi del Transformer sono in model; per CIR sono in model.transformer. La dimensione totale di input è derivata dalla concatenazione delle due modalità.

Parametro	CP_precomputed	CIR_precomputed
Dimensione per modalità (`modality_embedding_dim`)	`512`	`512`
Dimensione totale di input / Transformer	`1024 = 512 + 512`	`1024 = 512 + 512`
Numero di layer (`layers`)	`6`	`6`
Teste di attenzione (`attention_heads`)	`16`	`16`
Dimensione feed-forward (`feedforward_dim`)	`2024`	`2024`
Attivazione (`activation`)	`mish`	`mish`
Dropout (`dropout`)	`0.3`	`0.3`
Pre-norm (`norm_first`)	`true`	`true`
Epsilon LayerNorm (`layer_norm_epsilon`)	`1e-5`	`1e-5`
Epsilon normalizzazione L2 (`normalization_epsilon`)	`1e-12`	`1e-12`
Deviazione standard inizializzazione embedding (`embedding_initialization_std`)	`0.02`	`0.02`
Numero massimo di item (`max_items`)	`16`	`16`
LayerNorm finale aggiuntiva, verificata nei pesi	Presente: `cp.encoder.norm.*`	Assente: nessuna chiave `cir.encoder.norm.*`
Dimensione embedding di retrieval (`model.cir.embedding_dim`)	Non applicabile	`128`
Normalizzazione L2 degli embedding finali di retrieval (`model.cir.normalize_embeddings`)	Non applicabile	`false`
Embedding di categoria (`model.use_category_embedding`)	Non applicabile	`false`

Training e funzione di loss

Parametro	CP_precomputed	CIR_precomputed
Microbatch (`training.batch_size` / `training.batch_size_per_process`)	`512` outfit	`64` outfit per processo
Accumulo gradienti (`training.gradient_accumulation_steps`)	`4` microbatch	`4` microbatch
Batch effettivo (`training.effective_batch_size` / `training.effective_batch_size_global`)	`2048`	`256` globale
Batch effettivo per processo (`training.effective_batch_size_per_process`)	Non registrato separatamente	`256`
Ottimizzatore (`training.optimizer`)	`AdamW`	`AdamW`
Learning rate configurato / massimo (`training.learning_rate`)	`2e-5`	`2e-5`
Weight decay (`training.weight_decay`)	`0.01`	`0.01`
Gradient clipping, norma massima (`training.max_grad_norm`)	`1.0`	`1.0`
Seed (`training.seed`)	`42`	`42`
Loss (`training.loss`)	`FocalLoss`	`InBatchTripletMarginLoss`
Riduzione della loss (`training.focal_reduction` / `training.loss_reduction`, `model.cir.loss_reduction`)	`mean`	`mean`
Focal alpha (`training.focal_alpha`)	`0.5`	Non applicabile
Focal gamma (`training.focal_gamma`)	`2.0`	Non applicabile
Margine triplet (`training.triplet_margin`, `model.cir.triplet_margin`)	Non applicabile	`2.0`
Campionamento negativi (`training.negative_sampling`)	Non applicabile	`in_batch`
Campionamento target (`training.target_sampling`)	Non applicabile	`random_item_per_outfit_access`
Early stopping, patience (`training.early_stopping_patience`)	`null`: disabilitato	`null`: disabilitato
Miglioramento minimo (`training.early_stopping_min_delta`)	`0.0`	`0.0`
Pesi per resume (`training.resume_weights`)	`null`	`null`
Inizializzazione da CP (`training.pretrained_cp_weights`)	Non applicabile	`best.pt`
Optimizer step per epoca (`training.optimizer_steps_per_epoch`)	`53`	`208`
Optimizer step totali pianificati (`training.total_optimizer_steps`)	`10600`	`41600`

Per CIR il target è un item scelto casualmente a ogni accesso all'outfit. Come descritto nel README del training, la loss seleziona il negativo più difficile tra i positivi delle altre righe dello stesso microbatch: l'accumulo fino a 256 esempi non amplia il gruppo di negativi del microbatch da 64.

L'inizializzazione CIR registra soltanto il nome best.pt del checkpoint CP sorgente, senza percorso completo o hash. Questo dato da solo non identifica univocamente il file come il CP_precomputed/best.pt qui pubblicato.

Scheduler

Tutti i campi di questa tabella sono salvati in training.scheduler e hanno lo stesso valore nei due run.

Parametro	Valore
Scheduler (`name`)	`OneCycleLR`
Frequenza di aggiornamento (`step`)	`optimizer_step`: dopo ogni aggiornamento dell'ottimizzatore
Learning rate massimo (`max_lr`)	`2e-5`
Frazione iniziale del ciclo (`pct_start`)	`0.3`
Strategia di annealing (`anneal_strategy`)	`cos`
Fattore LR iniziale (`div_factor`)	`25.0`
Fattore LR minimo (`final_div_factor`)	`10000.0`

Runtime

Parametro	CP_precomputed	CIR_precomputed
Dispositivo richiesto (`runtime.requested_device`)	`auto`	`auto`
Dispositivo risolto (`runtime.resolved_device`)	`cuda`	`cuda`
Worker del DataLoader (`runtime.num_workers`)	`0`	`0`
Pinned memory (`runtime.pin_memory`)	`false`	`false`
Frequenza log (`runtime.log_every`)	Ogni `10` microbatch	Ogni `10` microbatch
Training distribuito (`runtime.ddp`)	Non registrato	`false`
Numero processi (`runtime.world_size`)	Non registrato	`1`
Backend distribuito (`runtime.distributed_backend`)	Non registrato	`null`
Mixed precision (`runtime.mixed_precision`)	Non registrata	`false`

Le tabelle coprono tutti i campi presenti nei due config.json. Impostazioni implicite non serializzate, come i beta e l'epsilon di AdamW, e dettagli quali modello di GPU e versioni software non sono documentati dagli artefatti letti.

Checkpoint

I pesi sono salvati in formato PyTorch .pt. Nel formato attuale del progetto, ogni checkpoint contiene model_state_dict, run_config, il numero dell'epoca, le metriche, la cronologia del training e le informazioni sulla selezione del modello migliore. config.json conserva una versione leggibile della configurazione dell'esperimento.

best.pt è il checkpoint selezionato dal training secondo la metrica configurata. Gli eventuali file in epochs/ permettono di utilizzare altre epoche del run. I checkpoint attuali non includono lo stato di optimizer e scheduler: il resume del progetto inizializza un nuovo run a partire dai pesi salvati.

Per caricare un checkpoint, usa i loader e i comandi della repository sorgente, con la configurazione e la versione dell'architettura usate durante il training. Per ciascun esperimento è utile riportare anche il commit Git del codice usato. Il checkpoint CP qui pubblicato contiene cp.encoder.norm.*, assente nell'architettura CP attuale. La gestione di questi checkpoint per l'inizializzazione di CIR è descritta nel README CIR.

Il caricamento sul Hub conserva il formato del progetto; non aggiunge automaticamente il supporto a transformers.AutoModel.from_pretrained().

Embedding precomputati

Gli embedding sono rappresentazioni numeriche degli articoli, generate con la procedura di precomputazione del progetto. Possono essere riutilizzati nei flussi che supportano feature precomputate, evitando di eseguire nuovamente gli encoder per ogni articolo.

Ogni cache comprende manifest.json e tutti gli shard-*.pt elencati nel manifest, mantenuti nella stessa cartella. Gli shard contengono schema_version, gli identificativi item_ids e il tensore embeddings; il manifest descrive encoder, dataset, subset, split, dimensioni, precisione, fingerprint e shard.

Nella procedura attuale, ogni embedding concatena le rappresentazioni di immagine e testo, normalizzate L2 separatamente. Con FashionCLIP e la configurazione predefinita, ogni vettore ha 1024 componenti: 512 visuali e 512 testuali. I valori effettivi della cache sono documentati nel relativo manifest.

Parametri delle cache pubblicate

Parametro	Valore nei manifest
Versione del formato (`schema_version`)	`2`
Dataset / subset	`mvasil/polyvore-outfits` / `nondisjoint`
Modello encoder (`encoder.model_name`)	`patrickjohncyh/fashion-clip`
Encoder visuale (`encoder.visual_encoder`)	`FashionCLIPVisualEncoder`
Encoder testuale (`encoder.text_encoder`)	`FashionCLIPTextEncoder`
Dimensione per modalità (`encoder.modality_dim`)	`512`
Dimensione finale (`embedding_dim`)	`1024`
Aggregazione (`encoder.aggregation`)	`concat_visual_then_text`
Normalizzazione (`encoder.normalization`)	`l2_per_modality`
Precisione salvata (`dtype`)	`float32`
Limite al numero di articoli (`limit`)	`null`
Commit encoder visuale / testuale (`encoder.visual_commit`, `encoder.text_commit`)	`null` / `null`

Split	Articoli (`count`)	Shard	Manifest
Train	`204679`	`21`	train/manifest.json
Validation	`25132`	`3`	validation/manifest.json
Test	`47854`	`5`	test/manifest.json

Gli shard contengono 10000 articoli ciascuno, tranne gli ultimi: 4679 per train, 5132 per validation e 7854 per test. I conteggi indicano articoli con embedding, non outfit o esempi di training.

Train e validation condividono il model_fingerprint dfcff17f9fb9335b22792d610cb7e4ba8cd73afa2954b725aa5e2d993bc10c27. La cache test registra invece b00590d05bc4af1a3a5316ecb65dabea7315fa93adf0dcbdbec0b8399ec1e788. Nome encoder e dimensioni coincidono, ma i fingerprint differiscono: questi metadati non attestano l'identità della configurazione di precomputazione tra test e gli altri split.

Usa embedding coerenti con il checkpoint e con il dataset, il subset e lo split richiesti. I flussi di training verificano anche la corrispondenza del fingerprint degli encoder tra le cache di train e validation. Le cache contengono gli identificativi e i vettori; i dati necessari a costruire outfit, etichette e query restano quelli richiesti dal progetto.

Riferimenti

Downloads last month: -; Downloads are not tracked for this model. How to track

Inference Providers NEW

This model isn't deployed by any Inference Provider. 🙋 Ask for provider support