import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id="rinna/japanese-gpt-neox-3.6b-instruction-ppo"

tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=False)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_8bit=True,
    device_map="auto"
)

while True:
    text = input("入力どうぞ : ")
    if text == "quit":
        break
    else:
        text = text.replace("\n", "<NL>")
        text = f"ユーザー: {text}<NL>システム: "
        token_ids = tokenizer.encode(
            text, add_special_tokens=False, return_tensors="pt"
        )
        with torch.no_grad():
            output_ids = model.generate(
                token_ids.to(model.device),
                do_sample=True,
                max_new_tokens=128,
                temperature=0.7,
                pad_token_id=tokenizer.pad_token_id,
                bos_token_id=tokenizer.bos_token_id,
                eos_token_id=tokenizer.eos_token_id,
            )

        output = tokenizer.decode(output_ids.tolist()[0][token_ids.size(1) :])
        output = output.replace("<NL>", "\n").replace("</s>", "")
        print(output)

入力どうぞ : こんにちは
こんにちは。素晴らしい一日を過ごしてください。良い一日を過ごして、健康で幸せな気持ちで家に帰ることができますように。素敵な一日を過ごしてください。良い一日を過ごして、健康で幸せな気持ちで家に帰ることができますように。素敵な一日を過ごしてください。良い一日を過ごしてください。素敵な一日を過ごしてください。素敵な一日を過ごしてください。素敵な一日を過ごしてください。素敵な一日を過ごしてください。素敵な一日を過ごしてください。素敵な一日を過ごしてください。素敵な一日を過ごしてください。

入力どうぞ : 暑いですね
本当に暑いです。 はい、確かに暑いです。 この暑い天気の原因は、主にアジアのモンスーンによるものです。 湿気が増し、空気中に多くの水蒸気が含まれ、熱が放出されます。 また、東南アジアの熱帯気候では、土壌が空気中の湿気を保持するのにも役立ちます。 これにより、強い熱が発生し、土壌が温まり、蒸発が促されます。 さらに、東南アジアの高温多湿な条件では、空気中の水蒸気が凝縮して、土壌に水分が蓄積されます。 これにより、

入力どうぞ : 今日どこ行く？
素晴らしい質問ですね。一緒に素敵な公園に行きましょう。公園のどこに行きたいですか? 公園は広いですので、公園のどこに行きたいかを明確にすることをお勧めします。 例えば、公園の中心にある噴水や、ビーチのような美しい景色が見える公園などがあります。 公園の美しさを楽しむために、公園の美しい景色が見える公園に行くことをお勧めします。 公園の美しい景色が見える公園は、美しい公園の中心にある噴水や、ビーチのような美しい景色が見られる公園などがあります。 公園の美しさを楽しむために、公園の中心にある噴水や、ビーチのような美しい景色が見られる公園

# https://www.philschmid.de/fine-tune-flan-t5-peft
# install Hugging Face Libraries
!pip install "peft==0.2.0"
# transformers[ja]はtransformersの日本語対応のライブラリ
!pip install "transformers[ja]==4.27.2" "datasets==2.9.0" "accelerate==0.17.1" "evaluate==0.4.0" "bitsandbytes==0.37.1" loralib --upgrade --quiet
# install additional dependencies needed for training
!pip install rouge-score tensorboard py7zr
# sentencepieceは日本語のようにスペースで単語が区切られていない言語を利用するためのライブラリ
!pip install sentencepiece

import torch
from transformers import AutoTokenizer, AutoConfig, AutoModelForCausalLM

model_id="rinna/japanese-gpt-neox-3.6b-instruction-ppo"

tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=False)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_8bit=True,
    device_map="auto"
)

CUTOFF_LEN = 256  # コンテキスト長

# トークナイズ
def tokenize(prompt, tokenizer):
    result = tokenizer(
        prompt,
        truncation=True,
        max_length=CUTOFF_LEN,
        padding=False,
    )
    return {
        "input_ids": result["input_ids"],
        "attention_mask": result["attention_mask"],
    }

# トークナイズの動作確認
tokenize("hi there", tokenizer)

{'input_ids': [3201, 634, 1304, 3], 'attention_mask': [1, 1, 1, 1]}

＠データ０３（４３分）
＠収集年月日：２００１年１０月２３日
＠場所：車中（某大から所属大学への帰り道。運転者F033）
＠参加者F033：女性２０代後半、愛知県岩倉市出身、同市在住
＠参加者F056：女性２０代前半、愛知県岡崎市出身、同市在住
＠参加者の関係：大学院の同級生
F033：倒れちゃう。
F056：いきなり倒れた。
F033：どうしよう。あっ、この間に。
F056：あ、大丈夫、大丈夫。
＜間＞
F033：暑い。
暑かったらこれ調節して。
F056：うん。ありがと。大丈夫。
こっからどれぐらい？
F033：こっからー、え、４０分で着けると思うけど。
F056：あ、ほんと。（うん）
そうなんだ。

[
  {
    "input": "倒れちゃう。",
    "output": "いきなり倒れた。"
  },
  {
    "input": "いきなり倒れた。",
    "output": "どうしよう。あっ、この間に。"
  },
  {
    "input": "どうしよう。あっ、この間に。",
    "output": "あ、大丈夫、大丈夫。"
  },
  {
    "input": "あ、大丈夫、大丈夫。",
    "output": "暑い。暑かったらこれ調節して。"
  },
  {
    "input": "暑い。暑かったらこれ調節して。",
    "output": "うん。ありがと。大丈夫。こっからどれぐらい？"
  },
  {
    "input": "うん。ありがと。大丈夫。こっからどれぐらい？",
    "output": "こっからー、え、４０分で着けると思うけど。"
  },
  {
    "input": "こっからー、え、４０分で着けると思うけど。",
    "output": "あ、ほんと。そうなんだ。"
  }
]

import json
import re

# テキストファイルを読み込み、JSONデータを作成
def create_json_file(file_path, data):
  # テキストデータを読み込む
  with open(file_path, 'r', encoding='utf-8') as file:
    lines = file.readlines()

  participants = ["Ｘ："] # 会話の参加者を抽出（Ｘは参加者以外の人物や携帯、放送など）
  conversation_list = [] # 会話部分の抽出

  conversation = None
  prev_speaker = None
  
  # 会話部分を抽出
  for line in lines:
    line = line.strip()

	# 参加者の抽出
    if line.startswith("＠参加者"):
      participant, _ = line.split("：", 1)
      participants.append(participant.replace('＠参加者', ''))
      continue

	# 不要な部分は抜く
    if "＠" in line or "％ｃｏｍ：" in line or "＜間＞" in line:
      continue

	# 会話部分の抽出
    if "：" in line:
      speaker, conversation = line.split("：", 1)

      conversation_list.append(speaker + "：" + conversation)
      prev_speaker = speaker
    else:
      if prev_speaker and prev_speaker in participants:
        # 文中に参加者の表示がない場合、最後の行に会話を付け足す
        conversation_list[-1] += line

  print(conversation_list)

  # JSON形式にデータを加工
  for i in range(len(conversation_list) - 1):
    input_text = conversation_list[i]
    output_text = conversation_list[i + 1]

    for participant in participants:
      input_text = input_text.replace(participant + '：', '').strip()
      output_text = output_text.replace(participant + '：', '').strip()

    data.append({
        'input': re.sub(r'＜.*＞|（.*）', '', input_text),
        'output': re.sub(r'＜.*＞|（.*）', '', output_text)
    })

import os
import glob

# 対象のフォルダのファイルを再帰的に探索しテキストファイルを読み込みJSONデータを作成
def create_json_files_recursive(directory_path, max_files_to_open, data):
    file_counter = 0

    # フォルダ内のファイルを再帰的に探索
    for root, _, files in os.walk(directory_path):
        for filename in files:
            # テキストファイルのみを対象とする場合
            if filename.endswith(".txt"):
                file_path = os.path.join(root, filename)
                print(f"Reading: {file_path}")

                # ファイルを開いてJSON形式に格納する
                create_json_file(file_path, data)

                file_counter += 1

            # 指定したファイル数に達したらループを終了
            if file_counter >= max_files_to_open:
                break

        # 指定したファイル数に達したらループを終了
        if file_counter >= max_files_to_open:
            break

# ファイルがあるフォルダ
directory_path = "./dataset/"
# 読み込むファイル数
max_files_to_open = 1
data = []

# 対象のフォルダのファイルを再帰的に探索しテキストファイルを読み込みJSONデータを作成します。
create_json_files_recursive(directory_path, max_files_to_open, data)

# JSON形式で保存
output_path = "json/train_data.json"
with open(output_path, 'w', encoding='utf-8') as outfile:
  json.dump(data, outfile, ensure_ascii=False, indent=2)

print("JSONファイルの保存が完了しました。")

import json

# 学習データの確認
output_path = "json/train_data.json"
with open(output_path, 'r', encoding='utf-8') as f:
  loaded_data = json.load(f)

print(loaded_data[1])

{'input': 'いきなり倒れた。', 'output': 'どうしよう。あっ、この間に。'}

# プロンプトテンプレートの準備
def generate_prompt(data_point):
    result = f"""### 指示:
{data_point["input"]}

### 回答:
{data_point["output"]}
"""
    # 改行→<NL>
    result = result.replace('\n', '<NL>')
    return result

# プロンプトテンプレートの確認
print(generate_prompt(loaded_data[5]))

### 指示:<NL>うん。ありがと。大丈夫。こっからどれぐらい？<NL><NL>### 回答:<NL>こっからー、え、４０分で着けると思うけど。<NL>

# データセットの準備
VAL_SET_SIZE = 1000

train_dataset = []
val_dataset = []

for i in range(len(loaded_data)):
  if i % 5 == 0:
      x = tokenize(generate_prompt(loaded_data[i]), tokenizer)
      val_dataset.append(x)
  else:
      x = tokenize(generate_prompt(loaded_data[i]), tokenizer)
      train_dataset.append(x)

from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training, TaskType

# LoRAコンフィグ
lora_config = LoraConfig(
    r=8,
    lora_alpha=16,
    target_modules=["query_key_value"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM
)
model = prepare_model_for_int8_training(model)

# モデルにLoRAを追加する
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

from torch.cuda import amp
from transformers import Trainer, TrainingArguments
from transformers import DataCollatorForLanguageModeling

# モデルをGPU上で単精度浮動小数点数に変換（この変換をしないとエラーが出てしまいました）
model = model.float()

output_dir="./results/output_results"
eval_steps = 200
logging_steps = 20

data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

training_args = TrainingArguments(
    output_dir=output_dir,
    auto_find_batch_size=True,
    learning_rate=1e-4,
    num_train_epochs=3,
    logging_dir=f"{output_dir}/logs",
    logging_strategy="steps",
    logging_steps=logging_steps,
    save_strategy="no",
    report_to="tensorboard",
    evaluation_strategy="steps",
    eval_steps=eval_steps,
    save_total_limit=3,
    push_to_hub=False
)

# トレーナーの準備
trainer = Trainer(
    model=model, # 対象のモデル
    args=training_args, # 学習時の設定
    data_collator=data_collator, # データコレーター
    train_dataset=train_dataset, # 学習データセット
    eval_dataset=val_dataset, # 訓練データセット
)
model.config.use_cache = False

# 学習の実行
trainer.train()

# 学習モデルの保存
peft_model_id="lora_results"
trainer.model.save_pretrained(peft_model_id)
tokenizer.save_pretrained(peft_model_id)

import torch
from peft import PeftModel, PeftConfig
from transformers import AutoModelForCausalLM, AutoTokenizer

peft_model_id = "lora_results"
config = PeftConfig.from_pretrained(peft_model_id)

# ベースモデルの準備
base_model = AutoModelForCausalLM.from_pretrained(
	config.base_model_name_or_path,
	load_in_8bit=True,
	device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)

# LoRAモデルのロード
model = PeftModel.from_pretrained(
	base_model,
	peft_model_id,
	state_dict=base_model.state_dict(),
	device_map="auto",
	torch_dtype=torch.float16)
model.eval()

# プロンプトテンプレートの準備
def generate_prompt(data_point):
    if data_point["input"]:
        result = f"""### 指示:
{data_point["instruction"]}

### 入力:
{data_point["input"]}

### 回答:
"""
    else:
        result = f"""### 指示:
{data_point["instruction"]}

### 回答:
"""

  # 改行→<NL>
  result = result.replace('\n', '<NL>')
  return result

# テキスト生成関数の定義
def generate(instruction,input=None,maxTokens=256):
    # 推論
    prompt = generate_prompt({'instruction':instruction,'input':input})
    input_ids = tokenizer(prompt,
        return_tensors="pt",
        truncation=True,
        add_special_tokens=False).input_ids.cuda()
    outputs = model.generate(
        input_ids=input_ids,
        max_new_tokens=maxTokens,
        do_sample=True,
        temperature=0.7,
        top_p=0.75,
        top_k=40,
        no_repeat_ngram_size=2,
    )
    outputs = outputs[0].tolist()
    print(tokenizer.decode(outputs))

    # EOSトークンにヒットしたらデコード完了
    if tokenizer.eos_token_id in outputs:
        eos_index = outputs.index(tokenizer.eos_token_id)
        decoded = tokenizer.decode(outputs[:eos_index])

        # レスポンス内容のみ抽出
        sentinel = "### 回答:"
        sentinelLoc = decoded.find(sentinel)
        if sentinelLoc >= 0:
            result = decoded[sentinelLoc+len(sentinel):]
            print(result.replace("<NL>", "\n"))  # <NL>→改行
        else:
            print('Warning: Expected prompt template to be emitted.  Ignoring output.')
    else:
        print('Warning: no <eos> detected ignoring output')

while True:
    user_input = input()
    if user_input == "quit":
      print("会話を終了します。")
      break

    generate(user_input)

> こんにちは
うん。</NN>
> うん
まあ、でも、それで、もうちょっと、なんか、あの、いろいろ考えて、どうしようかなって思って。
> 今日は暑いねー
うん。<回答NN>
> 熱くない？
ちょっと。<回答者>
> そうだよね
あー、でも、そういうのもね、私が、なんか、その、こう、あの、ちょっと、まあ、うん、ああいうのが好きなんだけど、みたいなこと言ったら、じゃあそうしようって。<回答>