Papier | ? Collection Câlins Visage | Page de discussion
Nous présentons la série Granite de modèles de code uniquement décodeurs pour les tâches génératives de code (par exemple, correction de bogues, explication du code, documentation du code), entraînés avec du code écrit dans 116 langages de programmation. Une évaluation complète de la famille de modèles Granite Code sur diverses tâches démontre que nos modèles atteignent systématiquement des performances de pointe parmi les LLM de code open source disponibles.
Les principaux avantages des modèles Granite Code comprennent :
La famille des modèles Granite Code se décline en deux variantes principales :
Les modèles de base et d'instruction sont disponibles dans les tailles de paramètres 3B, 8B, 20B et 34B.
Notre processus de préparation des données de pré-formation du code comporte plusieurs étapes. Tout d'abord, nous collectons une combinaison d'ensembles de données accessibles au public (par exemple, GitHub Code Clean, données Starcoder), de référentiels de codes publics et de problèmes de GitHub. Deuxièmement, nous filtrons les données de code collectées en fonction du langage de programmation dans lequel les données sont écrites (que nous avons déterminé en fonction de l'extension du fichier). Ensuite, nous filtrons également les données dont la qualité de code est faible. Troisièmement, nous adoptons une stratégie de déduplication agressive qui inclut à la fois une déduplication exacte et une déduplication floue pour supprimer les documents ayant un contenu de code (presque) identique. Enfin, nous appliquons un filtre de contenu HAP qui réduit la probabilité que les modèles génèrent un langage haineux, abusif ou grossier. Nous veillons également à supprimer les informations personnelles identifiables (PII) en remplaçant le contenu des PII (par exemple, noms, adresses e-mail, clés, mots de passe) par les jetons correspondants (par exemple, ⟨NOM⟩, ⟨EMAIL⟩, ⟨KEY⟩, ⟨PASSWORD⟩). . Nous analysons également tous les ensembles de données à l'aide de ClamAV pour identifier et supprimer les instances de logiciels malveillants dans le code source. En plus de collecter des données de code pour la formation du modèle, nous conservons plusieurs ensembles de données en langage naturel de haute qualité accessibles au public pour améliorer les compétences du modèle en matière de compréhension du langage et de raisonnement mathématique.
Les modèles Granite Code Base sont formés sur des jetons 3-4T de données de code et des ensembles de données en langage naturel liés au code. Les données sont tokenisées via le codage par paire d'octets (BPE), en utilisant le même tokenizer que StarCoder. Nous utilisons des données de haute qualité avec deux phases de formation comme suit :
Les modèles Granite Code Instruct sont affinés sur les types de données d'instruction suivants : 1) les validations de code provenant de CommitPackFT, 2) les ensembles de données mathématiques de haute qualité, en particulier nous avons utilisé MathInstruct et MetaMathQA, 3) les ensembles de données d'instructions de code tels que Glaive-Code-Assistant- v3, Self-OSS-Instruct-SC2, Glaive-Function-Calling-v2, NL2SQL11 et une petite collection d'ensembles de données d'appel d'API synthétiques, et 4) des ensembles de données d'instructions de langage de haute qualité tels que HelpSteer et une version ouverte filtrée par licence de Platypus. .
Nous effectuons une évaluation approfondie de nos modèles de code sur une liste complète de références qui comprend, sans s'y limiter, HumanEvalPack, MBPP et MBPP+. Cet ensemble de références englobe différentes tâches de codage dans les langages de programmation couramment utilisés (par exemple, Python, JavaScript, Java, Go, C++, Rust).
Nos résultats révèlent que les modèles Granite Code surpassent les modèles open source puissants, quelle que soit la taille des modèles. La figure ci-dessous illustre comment Granite-8B-Code-Base surpasse Mistral-7B , LLama-3-8B et d'autres modèles open source dans trois tâches de codage. Nous fournissons d’autres résultats d’évaluation dans notre article.
Pour utiliser l'un de nos modèles, choisissez un model_path approprié parmi :
ibm-granite/granite-3b-code-base-2kibm-granite/granite-3b-code-instruct-2kibm-granite/granite-8b-code-base-4kibm-granite/granite-8b-code-instruct-4kibm-granite/granite-20b-code-base-8kibm-granite/granite-20b-code-instruct-8kibm-granite/granite-34b-code-base-8kibm-granite/granite-34b-code-instruct-8k from transformers import AutoModelForCausalLM , AutoTokenizer
device = "cuda" # or "cpu"
model_path = "ibm-granite/granite-3b-code-base-2k" # pick anyone from above list
tokenizer = AutoTokenizer . from_pretrained ( model_path )
# drop device_map if running on CPU
model = AutoModelForCausalLM . from_pretrained ( model_path , device_map = device )
model . eval ()
# change input text as desired
input_text = "def generate():"
# tokenize the text
input_tokens = tokenizer ( input_text , return_tensors = "pt" )
# transfer tokenized inputs to the device
for i in input_tokens :
input_tokens [ i ] = input_tokens [ i ]. to ( device )
# generate output tokens
output = model . generate ( ** input_tokens )
# decode output tokens into text
output = tokenizer . batch_decode ( output )
# loop over the batch to print, in this example the batch size is 1
for i in output :
print ( i ) Nous utilisons Dolomite Engine pour le réglage fin (ou le réglage des instructions) de tous nos modèles. Nous fournissons des exemples de scripts pour affiner ibm-granite/granite-3b-code-base . Pour affiner les modèles, suivez simplement ces étapes :
git clone https://github.com/IBM/dolomite-engine/
cd dolomite-engine
# you might need to modify configs/granite-example/training.yml
sh scripts/finetune.sh configs/granite-example/training.yml
# once the model is trained, convert to HuggingFace-compatible safetensors
sh scripts/export.sh configs/granite-example/export.ymlConseil
Si vous souhaitez utiliser des transformateurs sans remplissage pour économiser l'empreinte mémoire et les FLOP pendant la formation, suivez les instructions du fichier README de Dolomite Engine pour plus de détails.
Veuillez consulter nos lignes directrices et notre code de conduite pour contribuer à notre projet.
Les cartes modèles pour chaque variante de modèle sont disponibles dans leur référentiel HuggingFace respectif. Veuillez visiter notre collection ici.
Le modèle de choix (granite-3b-code-base dans cet exemple) peut être cloné en utilisant :
git clone https://huggingface.co/ibm-granite/granite-3b-code-base-2kTous les modèles Granite Code sont distribués sous licence Apache 2.0.
Veuillez nous faire part de vos commentaires sur notre famille de modèles de code en visitant notre collection. Sélectionnez le référentiel du modèle sur lequel vous souhaitez fournir des commentaires. Ensuite, allez dans l'onglet Communauté et cliquez sur Nouvelle discussion . Alternativement, vous pouvez également publier des questions/commentaires sur notre page de discussions github.
