Algunas reflexiones sobre la comercialización de la generación de código.

Soluciones de generación de código

Hay tres categorías principales de soluciones para generar código de proyecto:

1. Generación ascendente, la generación parcial de código genera una línea de código o un método para generar un pequeño fragmento de código. La idea básica de la generación de código de complemento ide es

2. El modelo de lenguaje grande actúa como un agente con diferentes roles en la ingeniería de software: el usuario da una idea y cada agente divide automáticamente el trabajo para generar código.

3. Resuma el marco del proceso para la generación de código en proyectos específicos y utilice modelos grandes para generar códigos de módulo en el marco.

La primera ruta técnica es la ruta principal actual para los productos C. Lo que esta ruta técnica realmente resuelve es resolver el problema de una API de lenguaje general compleja, muchos tipos de métodos de funciones, una gran cantidad de código de lenguaje general y una fuerte consistencia de Código de lógica no empresarial.Pregunta. Es imposible recordar todos los métodos, funciones y funciones de un lenguaje general, y la cantidad de código también es grande. Si puede escribir directamente las funciones, métodos y una breve sección de lógica central general no comercial, puede escribirlos codifique ingresando sus propias ideas, esto puede mejorar en gran medida la eficiencia del desarrollo de los programadores. La esencia de este método es integrar los entornos de desarrollo comunes utilizados por los programadores, como consultar los manuales de desarrollo, consultar códigos de muestra, desarrollar comunidades de preguntas y respuestas y ayudar a modificar códigos en un modelo grande, y puede ayudar al desarrollo a través de preguntas y respuestas de texto.

La segunda ruta del juego de roles de modelos a gran escala de soluciones técnicas tiene la ventaja de que las personas pueden generar un código de proyecto siempre que den una idea; la desventaja es que es más aleatorio, tiene una controlabilidad débil y el código puede no necesariamente cumple con los requisitos y el costo de verificación del código del proyecto es relativamente alto. La esencia de esta solución es omitir el proceso de desarrollo del programa y dejar que la máquina desarrolle el código basándose en el proceso de ingeniería de software.

La tercera ruta de solución técnica es una neutralización de las dos soluciones anteriores. Muchas empresas han comenzado a implementar la idea de menos código y diseñarán códigos comerciales apropiados de acuerdo con las necesidades de sus propias empresas; la lógica de sintaxis y las funciones funcionales de estos códigos comerciales son mucho más simples que los lenguajes comunes. La mayoría de los desarrolladores son convertir la lógica empresarial en código, por lo que las pocas líneas y una pequeña parte de las capacidades de generación de código proporcionadas por la primera ruta técnica no son necesariamente aplicables en este escenario. La precisión del código generado será relativamente baja y la complejidad de los problemas de descripción del desarrollo empresarial es equivalente a la complejidad de escribir la implementación del código empresarial. Por lo tanto, si desea ayudar en el código comercial, no puede seguir la primera solución técnica: debe lograr el desarrollo comercial con una pequeña cantidad de entrada para al menos generar un módulo funcional completamente utilizable o generar directamente un proyecto de código. La segunda opción teóricamente afirma que el formulario de entrega cumple con las expectativas de los estudiantes de desarrollo empresarial, pero este método de juego de roles múltiples actualmente tiene problemas como baja estabilidad, mala controlabilidad y una calidad relativamente baja del código generado que no cumple con las expectativas. Entonces, la mejor manera es combinar 2 o 2 tecnologías. El modelo grande solo actúa como un programador de código. El diseño general del proceso de código y la construcción del marco son abstraídos por las personas. Es equivalente a que el modelo grande resuelva problemas bajo un marco limitado y generar El código es más controlable, sin embargo, también existen problemas como procesos rígidos y tareas complejas de abstracción, suposiciones marco y gestión rápida de la generación de código. Por supuesto, estos problemas pueden resolverse adecuadamente mediante la automatización de los sistemas de ingeniería.

exploración en modo multi-agnet

Esta parte es un trabajo exploratorio. De acuerdo con la estructura organizacional y el proceso de eventos requerido por el proceso de desarrollo del código de ingeniería de software (proceso de desarrollo en cascada), a llm se le permite desempeñar diferentes roles para simular las actividades de desarrollo de software; el programa de código final se genera en base al Puntos de demanda de entrada del usuario.

Esta imagen describe el proceso de desarrollo de software bajo el modelo de desarrollo en cascada. También convierte el proceso de desarrollo en un modelo conversacional, produciendo productos intermedios para limitar y garantizar la confiabilidad del código de salida posterior.

La imagen de arriba describe cómo el LLM real ejecuta el proceso anterior para generar código y el diagrama de flujo del diálogo continuo para intentar conocer la ubicación del código ejecutable de salida.

Las tres ideas para la generación de código se mencionaron anteriormente y, sin importar qué idea se utilice, se requiere un modelo base poderoso. La siguiente sección presentará qué modelos de código abierto están disponibles y qué rutas de tecnología de capacitación pueden hacer que el modelo sea más poderoso.

Comparación de parámetros del modelo de generación de código fuente abierto

La siguiente figura es una tabla de datos de comparación de efectos y parámetros del modelo de generación de código fuente abierto.

Modelo	tamaño	Arquitectura	pase@1
códigoT5+		T5
codigo-davinci-2		GPT	59,86%
codegeex2	6B	GLM	35%
código estelar	15,5 mil millones	solo decodificar	38,2%
codegen16b	16B	solo decodificar	29,28%
InCoder-6.7B	6,7 mil millones	Fairseq	15,6%
codificador de palma	540B		36%
code llama	34B	solo decodificar	43%

Codellama es un modelo de lenguaje que realiza un preentrenamiento de lenguaje a gran escala, lo que permite que el modelo tenga la capacidad de generar código de acuerdo con las necesidades humanas, tiene fuertes capacidades en generación de código, finalización de código, generación de comentarios de código y comprensión semántica. En algunos casos, supera a chatgpt en la generación de código basado en el lenguaje humano. Capacidades de código que admiten contextos de 16k o incluso más.

Starcoder es un modelo de código que completa los espacios en blanco y genera comentarios, lo que permite que el modelo tenga la capacidad de generar código de acuerdo con las necesidades humanas; tiene capacidades de generación de código, comentarios de código, finalización de código, comprensión semántica y admite tokens de contexto de 8k.

código estelar

preentrenamiento de código estelar

Utilice mega-ml para implementar

 

#下载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 hace 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

razonamiento eficiente del codificador estelar

#下载代码
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

código llama pre-entrenamiento

#下载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 del 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

entrenamiento llama2 dpo

#下载训练代码
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

llama razonamiento eficiente:

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:"

Hacer un seguimiento

1. Clasificación de datos

2.Ajustes de entrenamiento de diálogo en cuna y en múltiples rondas.

3. El muestreo especulativo acelera el razonamiento

4. Investigación sobre la generación de código colaborativo de múltiples robots.

5.formación de dpo de starcoder

resumen

Este artículo resume varias posibilidades de comercialización de la generación de código y describe escenarios aplicables y posibles problemas en diferentes modos. En la actualidad, la forma principal de generación de código es productos c, lo que equivale a integrar el manual de desarrollo de consultas, las preguntas y respuestas de la comunidad, la modificación de código y las capacidades de muestra de código en el desarrollo del programador en un modelo grande. Luego, para la generación de código to b con mayor valor comercial, aún no se han visto en el mercado módulos de código precisos, controlables y ejecutables ni productos de generación de código de proyecto. La dificultad de la generación de código B a menudo no radica en la complejidad del código, sino en la capacidad de generar con precisión código realmente utilizable, lo que realmente reduce la carga de trabajo de los desarrolladores comerciales. Este es en realidad un proceso de automatización de la ingeniería de software, que consiste en automatizar el desarrollo de software; la ingeniería suave y la automatización en sí son una automatización de la producción, y esta automatización es la automatización de la automatización.

El artículo también presenta la tecnología de entrenamiento de mejora de modelos starcoder y codellama para mejorar las capacidades del modelo.