LLaMa Fine-tuning

1
import sentencepiece as spm
2
 from pathlib import Path
3

4
 paths = [str(x) for x in Path('토크나이저 학습용 데이터 디렉토리 경로').glob("*.txt")]
5
 corpus = ",".join(paths)
6
 prefix = "golani"
7
 vocab_size = 32000-7 # 사용자 정의 토큰을 위해 -7
8
 spm.SentencePieceTrainer.train(
9
     f"--input={corpus} --model_prefix={prefix} --vocab_size={vocab_size + 7}" +
10
     " --model_type=bpe" +
11
     " --max_sentence_length=999999" + # 문장 최대 길이
12
     " --pad_id=0 --pad_piece=<pad>" + # pad (0)
13
     " --unk_id=1 --unk_piece=<unk>" + # unknown (1)
14
     " --bos_id=2 --bos_piece=<s>" + # begin of sequence (2)
15
     " --eos_id=3 --eos_piece=</s>" + # end of sequence (3)
16
     " --byte_fallback=true" + # add byte_fallback for unk tokens
17
     " --user_defined_symbols=<sep>,<cls>,<mask>"
18
 ) # 사용자 정의 토큰

1
import json
2

3
 # 디렉토리 경로와 파일명
4
 directory = "데이터 다운로드 위치/"
5
 file_name = "일상생활및구어체_영한_valid_set.json"
6

7
 # JSON 파일 열기
8
 with open(directory + file_name, "r", encoding="utf-8") as file:
9
     data = json.load(file)
10

11
 converted_data = []
12
 for item in data["data"]:
13
     converted_item = {
14
         "instruction": "주어진 문장이 한국어일 경우 영어로, 영어일 경우 한국어로 번역하시오.",
15
         "input": item["en"],
16
         "output": item["ko"]
17
     }
18
     converted_data.append(converted_item)
19

20
 output_file_name = "clean_" + file_name
21
 with open(directory + output_file_name, "w", encoding="utf-8") as output_file:
22
     json.dump(converted_data, output_file, ensure_ascii=False, indent=4)

1
import sys
2
 import torch
3
 from peft import PeftModel
4
 from transformers import AutoModelForCausalLM
5

6
 # Based on https://github.com/tloen/alpaca-lora/blob/main/export_hf_checkpoint.py
7
 # Note that this does NOT guard against no-op merges. I would suggest testing the output.
8

9
 if len(sys.argv) != 4:
10
     print("Usage: python export_hf_checkpoint.py <source> <lora> <dest>")
11
     exit(1)
12

13
 source_path = sys.argv[1]
14
 lora_path = sys.argv[2]
15
 dest_path = sys.argv[3]
16

17
 base_model = AutoModelForCausalLM.from_pretrained(
18
     source_path,
19
     load_in_8bit=False,
20
     torch_dtype=torch.float16,
21
     device_map={"": "cpu"},
22
     trust_remote_code=True,
23
 )
24

25
 lora_model = PeftModel.from_pretrained(
26
     base_model,
27
     lora_path,
28
     device_map={"": "cpu"},
29
     torch_dtype=torch.float16,
30
 )
31

32
 # merge weights - new merging method from peft
33
 lora_model = lora_model.merge_and_unload()
34
 lora_model.train(False)
35

36
 lora_model_sd = lora_model.state_dict()
37
 deloreanized_sd = {
38
     k.replace("base_model.model.", ""): v
39
     for k, v in lora_model_sd.items()
40
     if "lora" not in k
41
 }
42

43
 base_model.save_pretrained(
44
     dest_path, state_dict=deloreanized_sd, max_shard_size="1024MB"
45
 )

1
python 파일명.py <원본 모델 위치> <Lora 파일 위치> <저장할 경로>

1
import sys
2
 import struct
3
 import json
4
 import numpy as np
5

6
 from transformers import AutoModelForCausalLM, AutoTokenizer
7

8
 # output in the same directory as the model
9
 dir_model = "병합 파일이 있는 디렉토리"
10
 fname_out = "ggml파일 저장할 디렉토리/ggml-model-f16.bin"
11
 ftype = 1
12

13
 with open(f"{dir_model}/config.json", "r", encoding="utf-8") as f:
14
     hparams = json.load(f)
15
     print(f"open susseced! {dir_model}/config.json")
16

17
 tokenizer = AutoTokenizer.from_pretrained(dir_model)
18
 print("load susseced! tokenizer")
19
 model = AutoModelForCausalLM.from_pretrained(dir_model, low_cpu_mem_usage=True)
20
 print("load susseced! model")
21

22
 list_vars = model.state_dict()
23
 for name in list_vars.keys():
24
     print(name, list_vars[name].shape, list_vars[name].dtype)
25

26
 fout = open(fname_out, "wb")
27

28
 print(hparams)
29

30
 fout.write(struct.pack("i", 0x67676d6c)) # magic: ggml in hex
31
 fout.write(struct.pack("i", hparams["vocab_size"]))
32
 fout.write(struct.pack("i", hparams["max_position_embeddings"]))
33
 fout.write(struct.pack("i", hparams["hidden_size"]))
34
 fout.write(struct.pack("i", hparams["num_attention_heads"]))
35
 fout.write(struct.pack("i", hparams["num_hidden_layers"]))
36
 fout.write(struct.pack("i", int(hparams["rotary_pct"]*(hparams["hidden_size"]//hparams["num_attention_heads"]))))
37
 fout.write(struct.pack("i", hparams["use_parallel_residual"] if "use_parallel_residual" in hparams else True))
38
 fout.write(struct.pack("i", ftype))
39

40
 # TODO: temporary hack to not deal with implementing the tokenizer
41
 for i in range(hparams["vocab_size"]):
42
     text = tokenizer.decode([i]).encode('utf-8')
43
     fout.write(struct.pack("i", len(text)))
44
     fout.write(text)
45

46
 for name in list_vars.keys():
47
     data = list_vars[name].squeeze().numpy()
48
     print("Processing variable: " + name + " with shape: ", data.shape)
49

50
     # we don't need these
51
     if name.endswith(".attention.masked_bias") or     \
52
        name.endswith(".attention.bias") or \
53
        name.endswith(".attention.rotary_emb.inv_freq"):
54
         print("  Skipping variable: " + name)
55
         continue
56

57
     n_dims = len(data.shape)
58

59
     # ftype == 0 -> float32, ftype == 1 -> float16
60
     ftype_cur = 0
61
     if ftype != 0:
62
         if name[-7:] == ".weight" and n_dims == 2:
63
             print("  Converting to float16")
64
             data = data.astype(np.float16)
65
             ftype_cur = 1
66
         else:
67
             print("  Converting to float32")
68
             data = data.astype(np.float32)
69
             ftype_cur = 0
70
     else:
71
         if data.dtype != np.float32:
72
             print("  Converting to float32")
73
             data = data.astype(np.float32)
74
             ftype_cur = 0
75

76
     # header
77
     str = name.encode('utf-8')
78
     fout.write(struct.pack("iii", n_dims, len(str), ftype_cur))
79
     for i in range(n_dims):
80
         fout.write(struct.pack("i", data.shape[n_dims - 1 - i]))
81
     fout.write(str)
82

83
     # data
84
     data.tofile(fout)
85

86
 fout.close()
87

88
 print("Done. Output file: " + fname_out)
89
 print("")

1
./bin/gpt-neox -m ../model/ggml-polyglot-translate-q4_0.bin -p "### 명령어: 주어진 문장이 한국어일 경우 영어로, 영어일 경우 한국어로 번역하시오.
2

3
### 원문: 번역할 영어 문장
4

5
### 번역:" -t 8 -b 16 --temp 0.7 --top_k 40 --top_p 0.1