Python/AI/kuberai_2_5.py - main - Demek/DSam621

Python/AI/kuberai_2_5.py
192 строки5 KB
d_e_m_e_k
добавил учебную ai для обучения
27 июл 2026, 23:34
27 июл 2026, 23:342dfa071
import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    Trainer,
    DataCollatorForLanguageModeling,
    BitsAndBytesConfig
)
from huggingface_hub import login
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import Dataset
import json
import os

hf_token = "_токен_hf" # https://huggingface.co/

login(token=hf_token)
model_name = "Qwen/Qwen2.5-1.5B-Instruct"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

print("Модель етсь")

print("лора")

lora_config = LoraConfig(
    r=8,                     
    lora_alpha=16,           
    target_modules=[
        "q_proj",
        "k_proj", 
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)

model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

def load_dataset_from_jsonl(jsonl_path):
    data = []
    with open(jsonl_path, 'r', encoding='utf-8') as f:
        for line in f:
            if line.strip():
                try:
                    item = json.loads(line.strip())
                    data.append(item)
                except:
                    continue
    return data

def format_example(item):
    instruction = item.get('instruction', '')
    response = item.get('response', '')
    
    return {
        "text": f"<|im_start|>user\n{instruction}<|im_end|>\n<|im_start|>assistant\n{response}<|im_end|>"
    }


data = load_dataset_from_jsonl('dataset.jsonl')

formatted_data = [format_example(item) for item in data]

dataset = Dataset.from_list(formatted_data)
dataset = dataset.train_test_split(test_size=0.1) if len(dataset) > 10 else Dataset.from_dict({"text": [d["text"] for d in formatted_data]})

def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        padding="max_length",
        max_length=512,
        return_tensors="pt"
    )

print("токены")
tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=["text"])

print("настройка обучения")

training_args = TrainingArguments(
    output_dir="./qwen-k8s-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    gradient_accumulation_steps=4,
    warmup_steps=10,
    learning_rate=2e-4,
    logging_steps=10,
    save_steps=50,
    eval_strategy="no",             
    save_strategy="steps",
    eval_steps=50,
    save_total_limit=2,
    load_best_model_at_end=False,
    report_to="none",
    fp16=True,
)

data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"] if "train" in tokenized_dataset else tokenized_dataset,
    eval_dataset=tokenized_dataset["test"] if "test" in tokenized_dataset else None,
    data_collator=data_collator,
)

print("обучение--")
trainer.train()

print("save.")
model.save_pretrained("./qwen-k8s-finetuned")
tokenizer.save_pretrained("./qwen-k8s-finetuned")

print("Модель сохранена в ./qwen-k8s-finetuned")

def generate_yaml(prompt, max_length=512, temperature=0.7):
    model.eval()
    messages = [
        {"role": "user", "content": prompt}
    ]
    
    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )
    
    inputs = tokenizer(text, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_length,
            temperature=temperature,
            do_sample=True,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id
        )
    
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    if "assistant" in response:
        parts = response.split("assistant")
        return parts[-1].strip()
    return response

#--------------------------------------- после обучения будут веса в папке qwen-k8s-finetuned
# model = AutoModelForCausalLM.from_pretrained(
#     "./qwen-k8s-finetuned",  
#     device_map="auto"
# )

# prompt = "Создай Deployment для nginx с 3 репликами"
# yaml = generate_yaml(prompt)
# print(yaml)


print("\n вывод")
prompt = "Создай Deployment для nginx с 3 репликами"
yaml = generate_yaml(prompt)
print(f"Промпт: {prompt}")
print(f"YAML:\n{yaml}")