Quelques réflexions sur la commercialisation de la génération de code

Solutions de génération de code

Il existe trois grandes catégories de solutions pour générer du code de projet :

1. Génération ascendante, la génération partielle de code génère une ligne de code ou une méthode pour générer un petit morceau de code. L'idée de base de la génération de code de plug-in ide est

2. Le grand modèle de langage agit comme un agent avec différents rôles dans l'ingénierie logicielle. L'utilisateur donne une idée et chaque agent divise automatiquement le travail pour générer du code.

3. Résumé du cadre de processus pour la génération de code dans le cadre de projets spécifiques et utiliser de grands modèles pour générer des codes de module dans le cadre

La première voie technique est la voie principale actuelle pour les produits to c. Ce que cette voie technique résout réellement, c'est de résoudre le problème d'une API de langage général complexe, de nombreux types de méthodes de fonction, d'une grande quantité de code de langage général et d'une forte cohérence de code de logique non métier.question. Il est impossible de se souvenir de toutes les méthodes, fonctions et fonctions d'un langage général, et la quantité de code est également importante.Si vous pouvez écrire directement les fonctions, méthodes et fonctions requises, ainsi qu'une courte section de logique générale non métier codez en saisissant vos propres idées, cela permettra d'améliorer considérablement l'efficacité du développement des programmeurs. L'essence de cette méthode est d'intégrer les environnements de développement courants utilisés par les programmeurs, tels que la vérification des manuels de développement, la référence à des exemples de codes, le développement de communautés de questions-réponses et l'aide à la modification des codes dans un grand modèle, et peut aider au développement via des questions-réponses textuelles.

La deuxième voie de jeu de rôle sur modèle à grande échelle de solutions techniques présente l'avantage que les gens peuvent générer un code de projet à condition qu'ils donnent une idée ; l'inconvénient est qu'il est plus aléatoire, a une faible contrôlabilité et le code peut ne pas répondent nécessairement aux exigences, et le coût de vérification du code du projet est relativement élevé. L’essence de cette solution est d’ignorer le processus de développement du programme et de laisser la machine développer le code sur la base du processus d’ingénierie logicielle.

La troisième voie de solution technique est une neutralisation des deux solutions précédentes. De nombreuses entreprises ont commencé à moins mettre en œuvre l'idée du code et concevront des codes commerciaux appropriés en fonction des besoins de leur propre entreprise ; la logique syntaxique et les fonctions fonctionnelles de ces codes commerciaux sont beaucoup plus simples que les langages courants. La plupart des développeurs sont convertir la logique métier en code, donc les quelques lignes et un petit morceau de capacités de génération de code fournies par la première voie technique ne sont pas nécessairement applicables dans ce scénario. La précision du code généré sera relativement faible et la complexité des problèmes de description du développement commercial est équivalente à la complexité de l'écriture de la mise en œuvre du code commercial. Par conséquent, si vous souhaitez aider au code métier, vous ne pouvez pas suivre la première solution technique. Vous devez réaliser un développement commercial avec une petite quantité d'entrée pour produire au moins un module fonctionnel entièrement utilisable, ou générer directement un projet de code. La deuxième option stipule théoriquement que le formulaire de livraison répond aux attentes des étudiants en développement commercial, mais cette méthode de jeu multi-rôle présente actuellement des problèmes tels qu'une faible stabilité, une mauvaise contrôlabilité et une qualité relativement faible du code généré qui ne répond pas aux attentes. La meilleure façon est donc de combiner 2 ou 2 technologies. Le grand modèle agit uniquement comme un programmeur de code. La conception globale du processus de code et la construction du cadre sont toutes abstraites par des personnes. Cela équivaut à un grand modèle résolvant des problèmes dans un cadre limité et générer Le code est plus contrôlable, mais il existe également des problèmes tels que des processus rigides et des tâches complexes telles que l'abstraction, les hypothèses de cadre et la gestion des invites de génération de code. Bien entendu, ces problèmes peuvent être résolus de manière appropriée grâce à l'automatisation des systèmes d'ingénierie.

exploration en mode multi-agnet

Cette partie est un travail exploratoire. Selon la structure organisationnelle et le processus événementiel requis par le processus de développement du code de génie logiciel (processus de développement en cascade), LLM est autorisé à jouer différents rôles pour simuler les activités de développement logiciel ; le programme de code final est généré sur la base du points de demande d'entrée de l'utilisateur.

Cette image décrit le processus de développement logiciel dans le cadre du modèle de développement en cascade. Il transforme également le processus de développement en un modèle conversationnel, produisant des produits intermédiaires pour contraindre et garantir la fiabilité du code de sortie en aval.

L'image ci-dessus décrit comment le LLM réel exécute le processus ci-dessus pour générer du code, ainsi que l'organigramme du dialogue continu pour essayer de connaître l'emplacement du code exécutable de sortie.

Les trois idées de génération de code sont mentionnées ci-dessus, et quelle que soit l'idée utilisée, un modèle de base puissant est requis. La section suivante présentera les modèles open source disponibles et les voies technologiques de formation qui peuvent rendre le modèle plus puissant.

Comparaison des paramètres du modèle de génération de code open source

La figure ci-dessous est un tableau de données de comparaison des paramètres et des effets du modèle de génération de code open source.

Modèle	taille	Architecture	passer@1
codeT5+		T5
code-davinci-2		Google Tag	59,86%
codegeex2	6B	GLM	35%
code étoile	15,5 milliards	décoder seulement	38,2%
codegen16b	16B	décoder seulement	29,28%
InCoder-6.7B	6,7B	Fairseq	15,6%
Codeur Palm	540B		36%
appels codés	34B	décoder seulement	43%

Codellama est un modèle de langage qui effectue une pré-formation linguistique à grande échelle, permettant au modèle d'avoir la capacité de générer du code en fonction des besoins humains ; il possède de fortes capacités en matière de génération de code, de complétion de code, de génération de commentaires de code et de compréhension sémantique. dans certains cas, il dépasse chatgpt dans la génération de code basé sur le langage humain. Capacités de code, prend en charge des contextes de 16 000 ou même plus.

Starcoder est un modèle de code qui remplit les blancs et génère des commentaires, permettant au modèle d'avoir la capacité de générer du code en fonction des besoins humains ; il dispose de la génération de code, des commentaires de code, de la complétion du code, des capacités de compréhension sémantique et prend en charge 8 000 jetons de contexte.

code étoile

pré-formation starcode

Utilisez mega-ml pour implémenter

 

#下载megatron-ml
git clone https://github.com/bigcode-project/Megatron-LM.git

#安装apex
git clone https://github.com/NVIDIA/apex.git
cd apex
pip install -v --disable-pip-version-check --no-cache-dir --no-build-isolation --config-settings "--build-option=--cpp_ext" --config-settings "--build-option=--cuda_ext" ./

#下载wiki_zh数据
******/pleisto___json

#数据预处理
bash preprocess_santacoderpack.sh

#跑预训练模型
bash pretraning_santacoderpack.sh

'''
附件preprocess_santacoderpack.sh脚本
'''
INPUT=****/pleisto___json # merge datasets jsonl from commitpack-subset-cf
NAME=wiki_zh # you want data name
TOKENIZER_FILE=******/starcoderplus/tokenizer.json
VOCAD=******/starcoderplus/vocab.json

# File Path setup
SCRIPT_REPO=******/Megatron-LM
pushd $SCRIPT_REPO

python tools/preprocess_data.py \
    --input $INPUT \
    --output-prefix $NAME \
    --dataset-impl mmap \
    --tokenizer-type TokenizerFromFile  \
    --tokenizer-file $TOKENIZER_FILE \
    --json-keys 'completion'\
    --workers 30 \
    --chunk-size 1000

'''
附件pretraning_santacoderpack.sh脚本
'''
#! /bin/bash

# set -u # stop on unset variables

#export WANDB_API_KEY= # your wandb key
#export WANDB_PROJECT= # your wandb project name

NNODES=1 #$WORLD_SIZE  # Adjust
GPUS_PER_NODE=4
RANK=0
export MASTER_ADDR=127.0.0.1
export MASTER_PORT=9001
export CUDA_DEVICE_MAX_CONNECTIONS=1


GPU_NUM=$(($GPUS_PER_NODE*$NNODES))
WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))

echo "================================================"
echo "GPU_NUM: $GPU_NUM"
echo "================================================"

DISTRIBUTED_ARGS="\
              --nproc_per_node $GPUS_PER_NODE \
              --nnodes $NNODES \
              --node_rank $RANK \
              --master_addr $MASTER_ADDR \
              --master_port $MASTER_PORT \
"

echo $DISTRIBUTED_ARGS

CHECKPOINT_PATH=****/starcoderplus  # Adjust: Directory to store the checkpoints 
DATA_PATH=******/Megatron-LM/wiki_zh_completion_document  # Adjust: Prefix of the preprocessed dataset.
TOKENIZER_FILE=******/starcoderplus/tokenizer.json  # Adjust: starcoder-tokenizer/tokenizer.json

GPT_ARGS="\
       --tensor-model-parallel-size 1 \
       --pipeline-model-parallel-size 1 \
       --recompute-activations \
       --num-layers 24 \
       --hidden-size 2048 \
       --num-attention-heads 16 \
       --attention-head-type multiquery \
       --init-method-std 0.022 \
       --seq-length 8192 \
       --max-position-embeddings 8192 \
       --attention-dropout 0.1 \
       --hidden-dropout 0.1 \
       --micro-batch-size 2 \
       --global-batch-size 64 \
       --lr 0.0002 \
       --train-iters 250000 \
       --lr-decay-iters 600000 \
       --lr-decay-style cosine \
       --lr-warmup-fraction 0.02 \
       --weight-decay .1 \
       --adam-beta2 .95 \
       --clip-grad 1.0 \
       --bf16 \
       --log-interval 10 \
       --save-interval 1000 \
       --eval-interval 500 \
       --eval-iters 10 \
       --initial-loss-scale 65536 \
"

TENSORBOARD_ARGS="--tensorboard-dir ${CHECKPOINT_PATH}/tensorboard"

torchrun $DISTRIBUTED_ARGS \
       pretrain_gpt.py \
       $GPT_ARGS \
       --tokenizer-type TokenizerFromFile \
       --tokenizer-file $TOKENIZER_FILE \
       --save $CHECKPOINT_PATH \
       --load $CHECKPOINT_PATH \
       --data-path $DATA_PATH \
       $TENSORBOARD_ARGS \

starcoder fait sft

#代码下载
git clone https://github.com/bigcode-project/octopack.git

#数据准备
有问答的数据对，可以设计数据结构，比如：
{instruction:"",input:"",history:"",respond:""}

#参数设置
/mnt/user/caifu/252256/WizardLM/WizardCoder/configs/deepspeed_config.json
/mnt/user/caifu/252256/WizardLM/WizardCoder/WZsft.sh

#执行脚本
bash WZsft.sh

'''
附件WZsft.sh
'''
deepspeed --num_gpus 8 --master_port=9901 src/train_wizardcoder.py \
    --model_name_or_path "/mnt/user/caifu/252256/llm_model/starcode_instruct2/checkpoint-3600" \
    --data_path "/mnt/user/caifu/252256/LLaMA-Efficient-Tuning/data/alpaca_data_zh_51k.json" \
    --output_dir "/mnt/user/caifu/252256/llm_model/starcode_instruct3" \
    --num_train_epochs 3 \
    --model_max_length 8192 \
    --per_device_train_batch_size 8 \
    --per_device_eval_batch_size 1 \
    --gradient_accumulation_steps 1 \
    --evaluation_strategy "no" \
    --save_strategy "steps" \
    --save_steps 100 \
    --save_total_limit 2 \
    --learning_rate 2e-5 \
    --warmup_steps 30 \
    --logging_steps 2 \
    --lr_scheduler_type "cosine" \
    --report_to "tensorboard" \
    --gradient_checkpointing True \
    --deepspeed configs/deepspeed_config.json \
    --fp16 True

raisonnement efficace du starcoder

#下载代码
git clone https://github.com/bigcode-project/starcoder.cpp
cd starcoder.cpp

# Convert HF model to ggml
python convert-hf-to-ggml.py bigcode/gpt_bigcode-santacoder

# Build ggml libraries
#只支持cpu推理编译
make
#支持gpu和cpu推理编译
make clean && LLAMA_CUBLAS=1 make -j

# quantize the model
./quantize models/bigcode/gpt_bigcode-santacoder-ggml.bin models/bigcode/gpt_bigcode-santacoder-ggml-q4_1.bin 3

# run inference
./main -m models/bigcode/gpt_bigcode-santacoder-ggml-q4_1.bin -p "def fibonnaci(" --top_k 0 --top_p 0.95 --temp 0.2

codellama

code lama pré-formation

#下载llama训练代码
git clone https://github.com/hiyouga/LLaMA-Efficient-Tuning.git

#准备预训练数据
wiki_zh
内部代码数据

#下载模型
******/CodeLlama-13b-Instruct-hf
******/CodeLlama-13b-hf
******/CodeLlama-34b-Instruct-hf
******/CodeLlama-34b-hf

#设定参数
******/LLaMA-Efficient-Tuning/ds_zero3_config.json
******/LLaMA-Efficient-Tuning/pretrain_finetune.sh

#执行预训练脚本
bash code_llama_fintune.sh

'''
附件pretrain_finetune.sh
'''
deepspeed --num_gpus 8 --master_port=9901 src/train_bash.py \
    --deepspeed ds_zero3_config.json \
    --stage pt \
    --model_name_or_path ******/CodeLlama-13b-Instruct-hf \
    --do_train \
    --dataset wiki_zh_pre \
    --template default \
    --finetuning_type full \
    --lora_target q_proj,v_proj \
    --output_dir ******/CodeLlama-13b-Instruct-pre1 \
    --overwrite_cache \
    --per_device_train_batch_size 16 \
    --gradient_accumulation_steps 2 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_strategy "steps" \
    --save_steps 1000 \
    --save_total_limit 2 \
    --learning_rate 5e-5 \
    --warmup_steps 30 \
    --num_train_epochs 3.0 \
    --plot_loss \
    --report_to "tensorboard" \
    --fp16

'''
附件ds_zero3_config.json
'''
{
    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "sub_group_size": 0,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "stage3_max_live_parameters": 0,
        "stage3_max_reuse_distance": 0,
        "stage3_gather_16bit_weights_on_model_save": true
    },
    "fp16": {
        "enabled": true,
        "auto_cast": false,
        "loss_scale": 0,
        "initial_scale_power": 32,
        "loss_scale_window": 1000,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
          "lr": 5e-5,
          "betas": [
            0.9,
            0.999
          ],
          "eps": 1e-8,
          "weight_decay": 0
        }
    },
    "train_batch_size":256 ,
    "train_micro_batch_size_per_gpu": 16,
    "gradient_accumulation_steps":2,
    "wall_clock_breakdown": false
}

codellama do sft

#数据准备
数据准备和任务设计是强绑定的
这部分是重点

#执行脚本
bash code_llama_fintune.sh

#如果用lora训练，参数合并
bash export_lora_sft.sh

'''
附件code_llama_fintune.sh
'''
deepspeed --num_gpus 4 --master_port=9901 src/train_bash.py \
    --deepspeed ds_zero3_config.json \
    --stage sft \
    --model_name_or_path ******/CodeLlama-13b-Instruct-hf  \
    --do_train \
    --dataset code_alpaca \
    --template default \
    --finetuning_type full \
    --lora_target q_proj,v_proj \
    --output_dir ******/CodeLlama-13b-Instruct-full0 \
    --overwrite_cache \
    --per_device_train_batch_size 16 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_strategy "steps" \
    --save_steps 1000 \
    --save_total_limit 2 \
    --learning_rate 5e-5 \
    --warmup_steps 30 \
    --num_train_epochs 3.0 \
    --plot_loss \
    --report_to "tensorboard" \
    --fp16

'''
附件export_lora_sft.sh
'''
python src/export_model.py \
    --model_name_or_path ******/CodeLlama-34b-hf \
    --template default \
    --finetuning_type lora \
    --checkpoint_dir ******/CodeLlama-34b-Instruct-sft1 \
    --output_dir ******/CodeLlama-34b-Instruct-0

formation dpo lama2

#下载训练代码
git clone https://github.com/shibing624/MedicalGPT.git

#准备数据
{"question": "维胺酯维E乳膏能治理什么疾病?", "response_chosen": "痤疮；暴发性痤疮；寻常痤疮；婴儿痤疮；聚合性痤疮；沙漠疮；背痈；肺风粉刺；职业性痤疮", "response_rejected": "维埃胶可以治疗湿疹、荨麻疹和过敏性鼻炎等皮肤病。"}
******/MedicalGPT/data/reward/test.json

#执行训练脚本
bash run_dpo.sh

'''
附件run_dpo.sh
'''
CUDA_VISIBLE_DEVICES=0,1,2,3 python   dpo_training.py \
    --model_type llama \
    --model_name_or_path ******/CodeLlama-13b-Instruct-hf \
    --train_file_dir ./data/reward \
    --validation_file_dir ./data/reward \
    --per_device_train_batch_size 4 \
    --per_device_eval_batch_size 1 \
    --do_train \
    --do_eval \
    --use_peft True \
    --max_train_samples 10000 \
    --max_eval_samples 10 \
    --max_steps 10000 \
    --eval_steps 20 \
    --save_steps 1000 \
    --max_source_length 1024 \
    --max_target_length 1024 \
    --output_dir  ******/CodeLlama-13b-Instruct-dpo1\
    --target_modules all \
    --lora_rank 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --torch_dtype float16 \
    --fp16 True \
    --device_map auto \
    --report_to tensorboard \
    --remove_unused_columns False \
    --gradient_checkpointing True \
    --cache_dir ./cache

raisonnement efficace du lama :

1.下载和安装llama.cpp代码项目
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
#只支持cpu推理编译
make
#支持gpu和cpu推理编译
make clean && LLAMA_CUBLAS=1 make -j


2.把模型转成gmml格式，方便后面cpp推理使用
# convert the 7B model to ggml FP16 format
python3 convert.py models/7B/

# [Optional] for models using BPE tokenizers
python convert.py models/7B/ --vocabtype bpe

# quantize the model to 4-bits (using q4_0 method)
./quantize /mnt/qian.lwq/CodeLlama-34b-Instruct-0/ggml-model-f16.gguf /mnt/qian.lwq/CodeLlama-34b-Instruct-0/ggml-model-q4_0.gguf q4_0

3.用转化好的模型推理
#仅用cpu推理
./main -m /mnt/qian.lwq/CodeLlama-34b-Instruct-0/ggml-model-f16.gguf -p "给下面这段代码添加注释 \n def querySymbolInfo = { row, symbolList, fields ->\n def symbolFacadeClient = row.get('symbolFacadeClient') as SymbolFacadeClient \n SymbolRequest req = new SymbolRequest() \t\n req.setSymbols(symbolList as List<String>) \n req.setFields(fields as String) \t\n Result<SymbolDTOWrapper> result = symbolFacadeClient.querySymbolInfo(req) \n AssertUtils.assertTrue(Status.SUCCESS.equals(result.getStatus()), ErrorCodeEnum.REMOTE_UNEXPECTED_RESULT,\t\n result.getStatus().getMessage()) \t\b return result.getData().getDatas() \t\n } \n " -n 512 -ngl 15 -e
#cpu和gpu混合推理
./main --color --interactive --model /mnt/qian.lwq/CodeLlama-34b-Instruct-0/ggml-model-f16.gguf --n-predict 512 --repeat_penalty 1.0 --n-gpu-layers 15 --reverse-prompt "User:" --in-prefix " " -p "Building a website can be done in 10 simple steps:\nStep 1:"

Suivi

1. Tri des données

2. Ajustements de la formation au dialogue à plusieurs tours

3. L’échantillonnage spéculatif accélère le raisonnement

4. Recherche sur la génération de code collaboratif multi-robots

5.formation dpo starcoder

résumé

Cet article résume plusieurs possibilités de commercialisation de la génération de code et décrit les scénarios applicables et les problèmes possibles dans différents modes. À l'heure actuelle, la principale forme de produit de génération de code consiste à créer des produits C, ce qui équivaut à l'intégration du manuel de développement de requêtes, des questions et réponses de la communauté, de la modification du code et des capacités d'exemples de code dans le développement du programmeur dans un grand modèle. Ensuite, pour une génération de code ayant une plus grande valeur commerciale, des modules de code précis, contrôlables et exécutables et des produits de génération de code de projet n'ont pas encore été vus sur le marché. La difficulté de la génération de code B ne réside souvent pas dans la complexité du code, mais dans la capacité à générer avec précision du code réellement utilisable, ce qui réduit véritablement la charge de travail des développeurs métier. Il s'agit en fait d'un processus d'automatisation du génie logiciel, qui consiste à automatiser le développement de logiciels ; l'ingénierie logicielle et l'automatisation elle-même sont une automatisation de la production, et cette automatisation est l'automatisation de l'automatisation.

L'article présente également la technologie de formation à l'amélioration des modèles Starcoder et Codellama pour améliorer les capacités du modèle.