Chinese CLIP
1.0.0
Description chinoise | Anglais
Modelscope ｜ Demo ｜ Paper ｜ Blog
Ce projet est une version chinoise du modèle de clip et utilise des données chinoises à grande échelle pour la formation (~ 200 millions de paires graphiques et de texte), visant à aider les utilisateurs à réaliser rapidement des tâches telles que les caractéristiques graphiques et texte et le calcul de la similitude, la récupération croisée et la classification d'image zéro-échantillon dans le domaine chinois. Le code de ce projet est basé sur le projet Open_CLIP et est optimisé pour les données de terrain chinois et pour obtenir de meilleurs résultats sur les données chinoises. Ce projet fournit des API, du code de formation et du code de test, et les détails seront décrits en détail ci-dessous.
Chinese-CLIP est actuellement ouvert à 5 échelles différentes, et ses méthodes d'informations et de téléchargement de modèles sont présentées dans le tableau suivant:
| Taille du modèle | Lien de téléchargement | Quantité de paramètre | Squelette latéral visuel | Quantité de paramètre côté visuel | Squelette côté texte | Quantité du paramètre côté texte | Résolution |
|---|---|---|---|---|---|---|---|
| CN-CLIP RN50 | Télécharger | 77m | Resnet50 | 38m | RBT3 | 39m | 224 |
| CN-CLIP Vit-B / 16 | Télécharger | 188m | Vit-B / 16 | 86m | Roberta-wwm-base | 102m | 224 |
| CN-CLIP Vit-L / 14 | Télécharger | 406m | Vit-L / 14 | 304m | Roberta-wwm-base | 102m | 224 |
| CN-CLIP Vit-L / 14 @ 336px | Télécharger | 407m | Vit-L / 14 | 304m | Roberta-wwm-base | 102m | 336 |
| CN-CLIP Vit-H / 14 | Télécharger | 958m | Vit-h / 14 | 632m | Roberta-wwm-glancier | 326m | 224 |
Pour la tâche graphique et de récupération de texte, nous avons mené des expériences de zéro-shot et finetune sur Muge Retrieval, FlickR30K-CN et CoCo-CN. Pour la classification de l'échantillon d'image zéro, nous avons mené des expériences sur 10 ensembles de données d'Ecenater. Les résultats expérimentaux sont présentés dans le tableau ci-dessous. En raison des limites de l'espace, nous donnons ici ici les résultats du modèle à échelle optimale du modèle de base et du CLIP chinois. Pour les indicateurs de résultats détaillés de chaque échelle de CLIP chinois, veuillez consulter les résultats.md pour plus de détails.
Muge Text-to-Image Retrieval (ensemble de validation officiel) :
| Installation | Zéro | Affiner | ||||||
|---|---|---|---|---|---|---|---|---|
| Métrique | R @ 1 | R @ 5 | R @ 10 | M | R @ 1 | R @ 5 | R @ 10 | M |
| Wukong | 42.7 | 69.0 | 78.0 | 63.2 | 52.7 | 77.9 | 85.6 | 72.1 |
| R2d2 | 49.5 | 75.7 | 83.2 | 69.5 | 60.1 | 82.9 | 89.4 | 77.5 |
| CN-CLIP | 63.0 | 84.1 | 89.2 | 78.8 | 68.9 | 88.7 | 93.1 | 83.6 |
FLICKR30K-CN RETRIVAL (TEST OFFICIEL) :
| Tâche | Texte à l'image | Image à texte | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Installation | Zéro | Affiner | Zéro | Affiner | ||||||||
| Métrique | R @ 1 | R @ 5 | R @ 10 | R @ 1 | R @ 5 | R @ 10 | R @ 1 | R @ 5 | R @ 10 | R @ 1 | R @ 5 | R @ 10 |
| Wukong | 51.7 | 78.9 | 86.3 | 77.4 | 94.5 | 97.0 | 76.1 | 94.8 | 97.5 | 92.7 | 99.1 | 99.6 |
| Taiyi | 60.8 | 85.0 | 91.0 | - | - | - | - | - | - | - | - | - |
| R2d2 | 60.9 | 86.8 | 92.7 | 84.4 | 96.7 | 98.4 | 77.6 | 96.7 | 98.9 | 95.6 | 99.8 | 100.0 |
| CN-CLIP | 71.2 | 91.4 | 95.5 | 83.8 | 96.9 | 98.6 | 81.6 | 97.5 | 98.8 | 95.3 | 99.7 | 100.0 |
Coco-CN Retrieval (ensemble de tests officiels) :
| Tâche | Texte à l'image | Image à texte | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Installation | Zéro | Affiner | Zéro | Affiner | ||||||||
| Métrique | R @ 1 | R @ 5 | R @ 10 | R @ 1 | R @ 5 | R @ 10 | R @ 1 | R @ 5 | R @ 10 | R @ 1 | R @ 5 | R @ 10 |
| Wukong | 53.4 | 80.2 | 90.1 | 74.0 | 94.4 | 98.1 | 55.2 | 81.0 | 90.6 | 73.3 | 94.0 | 98.0 |
| Taiyi | 60.0 | 84.0 | 93.3 | - | - | - | - | - | - | - | - | - |
| R2d2 | 56.4 | 85.0 | 93.1 | 79.1 | 96.5 | 98.9 | 63.3 | 89.3 | 95.7 | 79.3 | 97.1 | 98.7 |
| CN-CLIP | 69.2 | 89.9 | 96.1 | 81.5 | 96.9 | 99.1 | 63.0 | 86.6 | 92.9 | 83.5 | 97.3 | 99.2 |
Classification d'image zéro :
| Tâche | Cifar10 | CIFAR100 | Dtd | Eurosat | Fer | FGVC | Kitti | MNIST | PC | Voc |
|---|---|---|---|---|---|---|---|---|---|---|
| Git | 88.5 | 61.1 | 42.9 | 43.4 | 41.4 | 6.7 | 22.1 | 68.9 | 50.0 | 80.2 |
| ALIGNER | 94.9 | 76.8 | 66.1 | 52.1 | 50.8 | 25.0 | 41.2 | 74.0 | 55.2 | 83.0 |
| AGRAFE | 94.9 | 77.0 | 56.0 | 63.0 | 48.3 | 33.3 | 11.5 | 79.0 | 62.3 | 84.0 |
| Wukong | 95.4 | 77.1 | 40.9 | 50.3 | - | - | - | - | - | - |
| CN-CLIP | 96.0 | 79.7 | 51.2 | 52.0 | 55.1 | 26.2 | 49.9 | 79.4 | 63.5 | 84.9 |
Avant de démarrer ce projet, vous devez vérifier si les exigences de configuration environnementale suivantes sont satisfaites:
Exécutez la commande suivante pour installer les bibliothèques triparties requises pour ce projet.
pip install -r requirements.txtVoici un exemple de code simple pour illustrer comment utiliser l'API Clip chinois. Avant de commencer à utiliser, veuillez installer CN_CLIP:
# 通过pip安装
pip install cn_clip
# 或者从源代码安装
cd Chinese-CLIP
pip install -e .Une fois l'installation réussie, vous pouvez facilement appeler l'API via les méthodes suivantes, passer dans l'image spécifiée (exemple) et le texte, extraire le vecteur de fonctionnalité graphique et calculer la similitude:
import torch
from PIL import Image
import cn_clip . clip as clip
from cn_clip . clip import load_from_name , available_models
print ( "Available models:" , available_models ())
# Available models: ['ViT-B-16', 'ViT-L-14', 'ViT-L-14-336', 'ViT-H-14', 'RN50']
device = "cuda" if torch . cuda . is_available () else "cpu"
model , preprocess = load_from_name ( "ViT-B-16" , device = device , download_root = './' )
model . eval ()
image = preprocess ( Image . open ( "examples/pokemon.jpeg" )). unsqueeze ( 0 ). to ( device )
text = clip . tokenize ([ "杰尼龟" , "妙蛙种子" , "小火龙" , "皮卡丘" ]). to ( device )
with torch . no_grad ():
image_features = model . encode_image ( image )
text_features = model . encode_text ( text )
# 对特征进行归一化，请使用归一化后的图文特征用于下游任务
image_features /= image_features . norm ( dim = - 1 , keepdim = True )
text_features /= text_features . norm ( dim = - 1 , keepdim = True )
logits_per_image , logits_per_text = model . get_similarity ( image , text )
probs = logits_per_image . softmax ( dim = - 1 ). cpu (). numpy ()
print ( "Label probs:" , probs ) # [[1.268734e-03 5.436878e-02 6.795761e-04 9.436829e-01]]Nous avons également préparé un support pertinent pour le déploiement de modèles ONNX et Tensorrt. Pour plus de détails, veuillez consulter Deployment.md.
Si vous n'êtes pas satisfait de simplement utiliser l'API, veuillez continuer à lire ce document pour apprendre à utiliser notre projet pour la formation et le test des modèles de clip.
Ce qui suit comprendra des tutoriels de récupération croisée (y compris les tutune et l'inférence, le calcul KNN, etc.) et les didacticiels de classification d'image zéro-échantillon.
Après avoir téléchargé ce projet, veuillez créer un nouveau dossier ${DATAPATH} pour stocker l'ensemble de données, le CKPT pré-formé et le modèle de modèle et le CKPT généré par Finetune. La structure du répertoire de l'espace de travail recommandé est la suivante:
Chinese-CLIP/
├── run_scripts/
│ ├── muge_finetune_vit-b-16_rbt-base.sh
│ ├── flickr30k_finetune_vit-b-16_rbt-base.sh
│ └── ... # 更多finetune或评测脚本...
└── cn_clip/
├── clip/
├── eval/
├── preprocess/
└── training/
${DATAPATH}
├── pretrained_weights/
├── experiments/
├── deploy/ # 用于存放ONNX & TensorRT部署模型
└── datasets/
├── MUGE/
├── Flickr30k-CN/
└── .../ # 更多自定义数据集...
Ici, nous fournissons la méthode de téléchargement des paramètres du modèle pré-formé, ainsi que le processus de prétraitement des données avant Finetune.
Veuillez vous référer à la section précédente du lien d'échelle et de téléchargement du modèle pour télécharger le modèle CKPT correspondant. Il est recommandé de stocker le fichier CKPT téléchargé dans ${DATAPATH}/pretrained_weights/ .
Afin de s'adapter au code de CLIP chinois et de garantir l'efficacité du traitement et de la lecture des données, nous recommandons que les ensembles graphiques et de données de texte utilisés pour la formation et l'évaluation soient organisés dans les méthodes suivantes:
${DATAPATH}
└── datasets/
└── ${dataset_name}/
├── train_imgs.tsv # 图片id & 图片内容
├── train_texts.jsonl # 文本id & 文本内容，连同匹配的图片id列表
├── valid_imgs.tsv
├── valid_texts.jsonl
├── test_imgs.tsv
└── test_texts.jsonl
où ${dataset_name} fait référence au nom de l'ensemble de données (comme Muge)
Pour assurer l'efficacité du traitement des fichiers, nous ne stockons pas d'images en grande quantité de petits fichiers, mais stockons les images de formation / vérification / test dans la base64 dans le fichier ${split}_imgs.tsv respectivement. Chaque ligne du fichier représente une image, y compris l'ID d'image (Type int) et l'image Base64, séparée par TAB, et le format est le suivant:
1000002 /9j/4AAQSkZJ...YQj7314oA//2Q==
La façon de convertir le fichier image d'origine en base64 est très simple, veuillez exécuter le code Python suivant:
from PIL import Image
from io import BytesIO
import base64
img = Image . open ( file_name ) # 访问图片路径
img_buffer = BytesIO ()
img . save ( img_buffer , format = img . format )
byte_data = img_buffer . getvalue ()
base64_str = base64 . b64encode ( byte_data ) # bytes
base64_str = base64_str . decode ( "utf-8" ) # str Les informations texte et la relation correspondante entre les paires graphiques et texte sont enregistrées dans le fichier ${split}_texts.jsonl . Chaque ligne du fichier est une ligne de JSON, le format est le suivant:
{"text_id": 8428, "text": "高级感托特包斜挎", "image_ids": [1076345, 517602]}
Pour l'ensemble de tests, il n'y a que du texte et je ne connais pas la relation correspondante entre l'image et les paires de texte, le champ image_ids de chaque ligne peut être traité comme une liste vide, c'est-à-dire "image_ids": [] .
Enfin, nous devons également sérialiser les fichiers TSV et JSONL et les convertir en fichiers de base de données LMDB indexés par la mémoire pour faciliter la lecture aléatoire pendant la formation.
python cn_clip/preprocess/build_lmdb_dataset.py
--data_dir ${DATAPATH}/datasets/${dataset_name}
--splits train,valid,test
Par exemple, pour Muge DataSet, ${dataset_name} est défini sur muge, et --splits Spécifie la division de jeu de données qui doit être convertie, séparée par des virgules sans espaces. Après la conversion, les fichiers sérialisés LMDB suivants seront ajoutés au dossier de l'ensemble de données.
${DATAPATH}
└── datasets/
└── ${dataset_name}/
└── lmdb/
├── train
│ ├── imgs
│ └── pairs
├── valid
└── test
Afin de réduire la difficulté de commencer, nous fournissons également le package de compression Data (Télécharger le lien de téléchargement) et Flickr30K-CN (lien de téléchargement) prétraité selon les étapes ci-dessus. Téléchargez et décompressez-le et placez-le dans ${DATAPATH}/datasets/ Directory. Si des données CoCO-CN sont requises, veuillez nous contacter par e-mail après avoir demandé l'autorisation de l'auteur d'origine.
Ici, nous présentons les étapes de formation pour faciliter les autres utilisateurs pour comprendre les détails du modèle et utiliser le modèle pré-formé du clip chinois que nous fournissons à Finetune. Sur la base des deux ensembles de données de recherche en aval de Muge et Flickr30k-CN, nous fournissons des échantillons de formation Scripts run_scripts/muge_finetune_vit-b-16_rbt-base.sh et run_scripts/flickr30k_finetune_vit-b-16_rbt-base.sh . Les scripts en cours d'exécution prennent en charge la formation distribuée par machine unique (simple ou multiple) et multi-machine. Avant d'exécuter, veuillez remplir les configurations liées à la distribution en fonction des directives et des commentaires au début du script, puis exécutez les commandes suivantes pour démarrer la formation (veuillez exécuter les commandes sur chaque machine pour une formation multi-machine). Pour une mémoire vidéo insuffisante, vous pouvez envisager d'activer la stratégie de recalcul dans l'élément de configuration. Les fichiers CKPT Journal et modèle générés par formation seront automatiquement enregistrés dans le répertoire spécifié par l'utilisateur:
cd Chinese-CLIP/
bash run_scripts/muge_finetune_vit-b-16_rbt-base.sh ${DATAPATH}Les éléments de configuration de formation connexes comprennent:
WORKER_CNT : le nombre de machines forméesGPUS_PER_NODE : nombre de GPU sur chaque machinetrain-data : Le répertoire LMDB de données de formation, voir ci-dessus pour le processus de prétraitement pour préparer les fichiers de données LMDB.val-data : Vérifiez le répertoire des données LMDB. Lorsqu'il est spécifié comme aucun, la vérification pendant la formation ne sera pas effectuée.num-workers : Le nombre de processus dans le traitement des données de l'ensemble de formation (DatalOader), la valeur par défaut est de 4.valid-num-workers : Le nombre de processus pour le traitement des données de l'ensemble de vérification (DatalOader) (si la validation est effectuée), la valeur par défaut est 1.vision-model : spécifiez l'épine dorsale visuelle, sélectionnez parmi ["ViT-B-16", "ViT-L-14", "ViT-L-14-336", "ViT-H-14", "RN50"] .text-model : spécifiez l'épine dorsale du texte, sélectionnez dans ["RoBERTa-wwm-ext-base-chinese", "RoBERTa-wwm-ext-large-chinese", "RBT3-chinese"] .context-length : longueur de séquence d'entrée de texte.warmup : étapes d'échauffement.batch-size : taille par lots à carte unique pendant l'entraînement. (Veuillez vous assurer训练样本总数> batch-size * GPU数, qui rencontre au moins 1 lot de formation)lr : Taux d'apprentissage.wd : Déris de poids.max-steps : le nombre d'étapes de formation et le nombre de tours de formation peuvent également être spécifiés par le max-epochs .freeze-vision : s'il faut geler la colonne vertébrale visuelle.use-augment : IF UTILISER AUTOAUGMENT pour améliorer les données de l'image.valid-batch-size : LA TIME DE LA LAT-SUPPORT SUR LA VÉRIFICATION. (Veuillez vous assurer que验证集样本总数> batch-size * GPU数, satisfaisant au moins 1 lot de vérification)valid-step-interval et valid-epoch-interval : Vérifiez la fréquence étape / époque. S'il est spécifié comme -1, la vérification ne sera pas effectuée pendant la formation.grad-checkpointing : Utilisez la stratégie de recalcul pour ne pas enregistrer les résultats intermédiaires pendant le processus à terme, en échange de moins de frais de mémoire en temps de formation, ce qui convient à une mémoire insuffisante. (Paramètre store_true , il suffit d'ajouter --grad-checkpointing au script, actuellement pytorch> 1.8.0 est requis)mask-ratio : Se référant à la stratégie FLIP, un masque aléatoire peut être spécifié dans une certaine proportion de patchs d'image pendant Finetune pour réduire les frais généraux de mémoire et accélérer l'entraînement. La valeur par défaut est 0,0, ce qui signifie que cette politique n'est pas activée.use-flash-attention : L'utilisation de Flashattention peut accélérer considérablement le processus Finetune de la CLIP chinois et réduire la consommation de mémoire sans affecter l'effet. (Paramètre store_true . Après avoir configuré l'environnement, ajoutez --use-flash-attention au script. Veuillez consulter flash_attention.md pour plus de détails)accum-freq : La fréquence d'accumulation de gradient est 1 par défaut. Lorsqu'elle est spécifiée comme un entier supérieur à 1, l'accumulation de gradient d'apprentissage comparatif est permettant de simuler une plus grande taille de lot. Si la taille du lot de carte unique est m , la taille totale du lot est accum_freq * m * GPU数.gather-with-grad : s'il faut effectuer des fonctionnalités de fonctionnement avec des gradients complets pendant la formation distribuée, il est désactivé par défaut.name : spécifiez le chemin de sortie. Le journal hyperparamètre, le journal de formation et la sortie CKPT seront stockés dans ${DATAPATH}/experiments/${name}/ .save-step-frequency ET save-epoch-frequency : L'intervalle entre les marches ou les tours de CKPT.report-training-batch-acc : Si le journal rapporte la précision du graphique de formation au texte et au texte en un lot graphique.resume : le chemin à lire par poids. L'exemple de script spécifie comme un chemin CKPT pré-formé, ou il peut être spécifié comme propre chemin CKPT FineTune de l'utilisateur pour une formation continue.reset-data-offset : s'il faut continuer à exécuter à partir du point d'arrêt des données précédent. Si la taille du lot ou le numéro de carte GPU dépasse le paramètre, il est recommandé d'activer cette option.reset-optimizer : s'il faut utiliser Optimizer State. Après la formation, le journal existera automatiquement ${DATAPATH}/experiments/${name}/out_${timestamp}.log . Le format de journal de formation est le suivant:
2022-12-11,20:40:34 | INFO | Rank 0 | Global Steps: 1/735 | Train Epoch: 1 [1024/250880 (0%)] | Loss: 2.371020 | Image2Text Acc: 49.90 | Text2Image Acc: 48.73 | Data Time: 1.039s | Batch Time: 3.625s | LR: 0.000000 | logit_scale: 4.605 | Global Batch Size: 1024
Le format du journal de vérification est le suivant:
2022-12-11,20:42:47 | INFO | Rank 0 | Validation Result (epoch 1 @ 150 steps) | Valid Loss: 0.502810 | Image2Text Acc: 84.95 | Text2Image Acc: 84.26 | logit_scale: 4.605 | Valid Batch Size: 128
Remarque : La comparaison de la convergence de la formation et la stabilité de l'apprentissage sont corrélées avec la taille totale du lot. Si vous utilisez une taille de lot plus petite (par rapport à la configuration par défaut de 128 GPU Per-GPU * 8), il est recommandé d'utiliser un taux d'apprentissage plus petit. Nous vous recommandons d'utiliser plus de GPU et de plus grande taille de lot pour de meilleurs résultats.
Nous fournissons le processus d'extraction des fonctionnalités et d'évaluation des tâches de récupération graphique, qui est la suivante:
Actuellement, ce code prend en charge l'utilisation de la carte unique GPU pour l'extraction des fonctionnalités graphiques, veuillez vous référer à la commande suivante. Nous fournissons également une prise en charge du déploiement des modèles ONNX et Tensorrt pour accélérer l'inférence des fonctionnalités, voir Deployment.md pour plus de détails.
cd Chinese-CLIP/
export CUDA_VISIBLE_DEVICES=0
export PYTHONPATH= ${PYTHONPATH} : ` pwd ` /cn_clip
split=valid # 指定计算valid或test集特征
resume= ${DATAPATH} /pretrained_weights/clip_cn_vit-b-16.pt
python -u cn_clip/eval/extract_features.py
--extract-image-feats
--extract-text-feats
--image-data= " ${DATAPATH} /datasets/ ${dataset_name} /lmdb/ ${split} /imgs "
--text-data= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _texts.jsonl "
--img-batch-size=32
--text-batch-size=32
--context-length=52
--resume= ${resume}
--vision-model=ViT-B-16
--text-model=RoBERTa-wwm-ext-base-chinese Les fonctionnalités graphiques de sortie seront enregistrées dans le répertoire ${DATAPATH}/datasets/${dataset_name} par défaut, et les fonctionnalités d'image sont enregistrées dans le fichier ${split}_imgs.img_feat.jsonl . Chaque ligne stocke les caractéristiques d'une image dans JSON, et le format est le suivant:
{"image_id": 1000002, "feature": [0.0198, ..., -0.017, 0.0248]}
Les fonctionnalités de texte sont enregistrées dans ${split}_texts.txt_feat.jsonl , avec le format comme suit:
{"text_id": 248816, "feature": [0.1314, ..., 0.0018, -0.0002]}
Pour les ensembles de données de recherche académique à petite échelle, nous fournissons une simple implémentation de recherche KNN pour faciliter le calcul des résultats de rappel Top-K pour la recherche de texte à graphiques et graphique à texte (Conseils: si vous souhaitez créer une démo de recherche dans le projet, il est recommandé de produire des graphiques et des fonctionnalités de texte basées sur le modèle de clip chinois et combinez le Framework Open Source Framework-Retrierie pour créer des services frontaux.)).).
Pour la recherche de texte à l'image (images liées au rappel de texte), exécutez la commande suivante:
cd Chinese-CLIP/
split=valid # 指定计算valid或test集特征
python -u cn_clip/eval/make_topk_predictions.py
--image-feats= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _imgs.img_feat.jsonl "
--text-feats= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _texts.txt_feat.jsonl "
--top-k=10
--eval-batch-size=32768
--output= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _predictions.jsonl "Le résultat est enregistré dans le fichier JSONL spécifié. Chaque ligne représente l'ID d'image supérieur-K d'un rappel de texte, et le format est le suivant:
{ "text_id" : 153915 , "image_ids" : [ 5791244 , 1009692167 , 7454547004 , 3564007203 , 38130571 , 2525270674 , 2195419145 , 2503091968 , 4966265765 , 3690431163 ]}Pour la recherche d'image à texte (texte lié au rappel d'image), de même, exécutez la commande suivante:
split=valid # 指定计算valid或test集特征
python -u cn_clip/eval/make_topk_predictions_tr.py
--image-feats= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _imgs.img_feat.jsonl "
--text-feats= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _texts.txt_feat.jsonl "
--top-k=10
--eval-batch-size=32768
--output= " ${DATAPATH} /datasets/ ${dataset_name} / ${split} _tr_predictions.jsonl "Chaque ligne des résultats de sortie représente l'ID de texte supérieur-K d'un rappel d'image, et le format est le suivant:
{ "image_id" : 977856234 , "text_ids" : [ 156914 , 157914 , 158914 , 155914 , 156179 , 158907 , 157179 , 154179 , 154914 , 154723 ]}Nous fournissons le script d'évaluation pour calculer le rappel @ 1/5/10 de la tâche de recherche et donner le rappel moyen (la moyenne du rappel @ 1/5/10). Exécutez la commande suivante pour obtenir le score:
Pour la recherche text-to-image, exécutez la commande:
split=valid # 指定计算valid或test集特征
python cn_clip/eval/evaluation.py
${DATAPATH} /datasets/ ${dataset_name} / ${split} _texts.jsonl
${DATAPATH} /datasets/ ${dataset_name} / ${split} _predictions.jsonl
output.json
cat output.jsonPour la recherche d'image à texte, veuillez d'abord exécuter la commande suivante pour convertir le fichier JSONL marqué du format d'image à texte en image à texte:
python cn_clip/eval/transform_ir_annotation_to_tr.py
--input ${DATAPATH} /datasets/ ${dataset_name} / ${split} _texts.jsonlUne fois terminé, exécutez la commande:
split=valid # 指定计算valid或test集特征
python cn_clip/eval/evaluation_tr.py
${DATAPATH} /datasets/ ${dataset_name} / ${split} _texts.tr.jsonl
${DATAPATH} /datasets/ ${dataset_name} / ${split} _tr_predictions.jsonl
output.json
cat output.jsonLe format du résultat imprimé sera le suivant:
{ "success" : true , "score" : 85.67 , "scoreJson" : { "score" : 85.67 , "mean_recall" : 85.67 , "r1" : 71.2 , "r5" : 90.5 , "r10" : 95.3 }}En ce qui concerne le processus de formation et de test de la récupération intermodale, nous prenons l'ensemble de données Muge Search (Graphics de commerce électronique multimodal et le défi du texte) à titre d'exemple, et fournit également un cahier Jupyter (lien de téléchargement) qui inclut tous les processus ci-dessus et peut être exécuté. Tout le monde est le bienvenu pour le pratiquer.
Cette section présente comment utiliser le CLIP chinois pour implémenter la classification d'images de l'échantillon zéro, en prenant l'ensemble de données dans Benchmark Eleater à titre d'exemple. Eleasater est un ensemble d'évaluation composé de plusieurs ensembles de données classifiés bien connus (y compris CIFAR-10, CIFAR-100, MNIST, etc.) pour évaluer l'effet d'échantillon zéro du modèle sur ces ensembles de données. Dans notre expérience, nous avons préparé une version chinoise du propt, des étiquettes de catégorie et des images originales pour chaque ensemble de données. Consultez le document de données pour que cela teste le modèle chinois. Pour plus de détails sur cette référence, veuillez cliquer sur le lien. Vous pouvez également vous référer au processus que nous fournissons pour préparer des données et les tester dans votre propre ensemble de données de classification chinoise.
Préparez d'abord les données dans le format suivant. Étant donné que la classification d'images de l'échantillon zéro ne nécessite que des tests, il vous suffit de préparer l'ensemble de tests et les paramètres du modèle pré-formé et les stocker sous le ${DATAPATH} spécifié par l'utilisateur en fonction de la structure du répertoire suivant:
${DATAPATH}
├── pretrained_weights/
└── datasets/
└── ${dataset_name}/
├── label_cn.txt
└── test/
├── 000/ # label id，如label个数大于10，则将其向左补零到3位数保证字典序
│ ├── image_0003.jpg # 图片样本，命名无特殊要求
│ ├── image_0005.jpg
│ └── ...
├── 001/
│ ├── image_0001.jpg
│ ├── image_0002.jpg
│ └── ...
└── 002/
├── image_0003.jpg
├── image_0005.jpg
└── ...
...
L'ensemble de tests garantit que les données du dossier de test sont divisées en fonction de l'ID correspondant à l'étiquette et garantit que l'ID est dans l'ordre du dictionnaire (plusieurs chiffres supérieurs à 10 doivent être complétés en zéros à l' label.zfill(3) , comme 001, 002, etc.). label_cn.txt est une étiquette de données avec un nom d'étiquette par ligne, comme indiqué ci-dessous:
手风琴
飞机
锚
...
L'ID d'étiquette correspondant à l'étiquette de chaque ligne est行号-1 , tel que l'ID de l'étiquette de la première ligne est 0, et que l'ID de l'étiquette de la deuxième ligne est 1. Si le nombre total de balises est supérieur à 10, alors zéro à trois chiffres sera ajouté à gauche, par exemple, le nombre de balises est de 100, et que l'ID d'étiquette sera 000-099 . L'utilisateur doit générer le dossier correspondant pour chaque ID d'étiquette et y mettre l'échantillon marqué avec l'étiquette. Nous prenons l'ensemble de données CIFAR-100 dans Eleasater à titre d'exemple, veuillez cliquer sur le lien pour télécharger les données traitées. Si vous souhaitez essayer de tester chinois sur d'autres ensembles de données contenus dans Eleasater, consultez notre documentation de données.
Nous avons préparé le script de prédiction, veuillez consulter run_scripts/zeroshot_eval.sh . Un exemple d'exécution d'une commande est le suivant:
bash run_scripts/zeroshot_eval.sh 0
${DATAPATH} ${dataset_name}
${vision_model} ${text_model}
${ckpt_path} ${index_file}Les significations de chaque paramètre sont:
0 est l'ID GPUDATAPATH Voir la section de préparation ci-dessus, entrez le chemin d'accès correspondant en fonction de l'emplacement réel.dataset_name Voir la section de préparation ci-dessus et entrez le nom du répertoire de l'ensemble de données pour l'évaluation, comme cifar-100vision_model est le type de modèle spécifié, et les options incluent ["ViT-B-32", "ViT-B-16", "ViT-L-14", "ViT-L-14-336", "RN50", "ViT-H-14"]text_model inclut ["RoBERTa-wwm-ext-base-chinese", "RoBERTa-wwm-ext-large-chinese", "RBT3-chinese"]ckpt_path est le chemin complet du CKPT pré-forméindex_file (facultatif, seule l'évaluation officielle du site Web d'Eléater doit être spécifiée), veuillez vous référer au document de données Par exemple, si vous utilisez le modèle pré-formé à l'échelle Vit-B / 16 pour évaluer CIFAR-100, alors exécuté ( ${DATAPATH} doit être remplacé en fonction des conditions réelles):
bash run_scripts/zeroshot_eval.sh 0
${DATAPATH} cifar-100
ViT-B-16 RoBERTa-wwm-ext-base-chinese
${DATAPATH} /pretrained_weights/clip_cn_vit-b-16.ptLe retour du résultat imprimera la précision du top-1.
Result:
zeroshot-top1: 0.6444
Sur CIFAR-100, l'échelle chinoise de Clip de Vit-B / 16 devrait atteindre 64,4%. Pour plus de détails, veuillez consulter les résultats.md pour plus de détails sur nos résultats de classification de l'échantillon zéro pour d'autres échelles et autres ensembles de données.
Dans le même temps, le programme sauvera également un dossier JSON pour avoir soumis l'éléasie officielle. Le contenu du fichier JSON est le suivant:
{ "model_name" : " CN-CLIP-ViT-B-16 " , "dataset_name" : " cifar-100 " , "num_trainable_params" : 0 , "num_params" : 188262913 , "num_visual_params" : 86192640 , "num_backbone_params" : 188262913 , "n_shot" : 0 , "rnd_seeds" : [ 123 ], "predictions" : " prediction probability tensor [size: (1, 10000, 100)] " } Ceux-ci incluent les informations Meta du modèle de modèle model_name , le nom de données de données dataset_name , la quantité de paramètre totale num_params , la quantité de paramètre de tour visuelle num_visual_params et d'autres modèles, ainsi que le résultat de sortie du modèle, c'est-à-dire le tenseur de probabilité de prédiction du modèle, et la taille est [1, 样本数, 标签个数] .
Sur la base de notre API d'extraction de fonctionnalités intégrée dans les transformateurs HuggingFace, nous fournissons une démo (API d'inférence hébergée) qui peut simplement essayer la classification d'image de l'échantillon zéro en ligne dans HuggingFace Model Hub. Voir les liens de démonstration pour chaque échelle de modèle ci-dessous. Bienvenue pour l'essayer!
Si vous pensez que ce projet est utile, j'espère que vous pourrez nous donner une étoile et le partager avec les utilisateurs autour de vous. Bienvenue dans la citation de travail pertinente, merci pour votre soutien!
@article{chinese-clip,
title={Chinese CLIP: Contrastive Vision-Language Pretraining in Chinese},
author={Yang, An and Pan, Junshu and Lin, Junyang and Men, Rui and Zhang, Yichang and Zhou, Jingren and Zhou, Chang},
journal={arXiv preprint arXiv:2211.01335},
year={2022}
}
