"""UserWarning SYMLINK 해결"""
import os
os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"

"""TqdmWarning 해결방법"""
%pip install --upgrade ipywidgets jupyter --break-system-packages

from huggingface_hub import login

# Hugging Face API 토큰을 입력합니다.
api_token = "HUGGINGFACE_TOKEN"
login(api_token)

from transformers import pipeline

model = pipeline("sentiment-analysis") 
output=model("I am so sick because I catch a cold.")
print(output)

from transformers import pipeline

model = pipeline("sentiment-analysis", model="alsgyu/sentiment-analysis-fine-tuned-model")
output=model("나는 며칠째 감기에 걸려서 몸이 아프다.")
print(output)
output=model("나는 오늘 날씨가 좋아서 소풍을 갈것이다.")
print(output)

from transformers import pipeline

pipe = pipeline(
    "text-generation", 
    model="naver-hyperclovax/HyperCLOVAX-SEED-Text-Instruct-1.5B",
    max_length=300
)

output = pipe("오늘 나는 그녀와 만나기로 하였는데,")
print(output)

from transformers import pipeline

# KLUE(Korean Language Understanding Evaluation) 프로젝트 산출물.
model = pipeline("fill-mask", model="klue/roberta-base")
output = model("너는 나에게는 [MASK]와 같은 존재다.", top_k=3)
for result in output:
    print(result['sequence'], round(result['score'], 3))

from transformers import pipeline

# Microsoft가 개발한 모델 - 100개 언어를 다루는 CC100 데이터셋으로 사전학습, 이후 XNLI로 파인튜닝
# 한국어 포함 XNLI 테스트셋으로 평가된 결과가 공개되어 있어 신뢰도 검증됨
classifier = pipeline("zero-shot-classification", model="MoritzLaurer/mDeBERTa-v3-base-mnli-xnli")

classifier(
   "한국의 대통령으로 이재명이 당선되었다.",
   candidate_labels=["교육", "정치", "경제"],
)

from transformers import pipeline
# "ner"은 사실 "token-classification"의 별칭이다. 런타임에서는 둘 다 똑같이 동작하지만 
# pipeline() 함수의 타임 스텁(오버로드 정의)에는 "token-classification"이라는 정식 이름만
# 명시되어 있고 "ner" 별칭까지는 등록이 안 되어 있는 경우가 많다.
ner = pipeline("token-classification", model="Leo97/KoELECTRA-small-v3-modu-ner", aggregation_strategy="simple")

test_sentences = [
    "톰은 서울에 있는 구글 코리아에서 근무하고 있다.",
    "2002년 한일 월드컵은 한국 축구 역사에 큰 전환점이었다.",
    "아인슈타인의 상대성이론은 현대 물리학의 근간이 되었다.",
    "그는 2024년 3월에 태어났고, 매일 오전 7시에 일어난다.",
    "이 반지는 순금과 다이아몬드로 만들어졌다.",
    "경복궁은 조선 왕조의 대표적인 궁궐이다.",
]

for sentence in test_sentences:
    print(f"\n입력: {sentence}")
    for entity in ner(sentence):
        print(f"  {entity['word']} -> {entity['entity_group']} ({entity['score']:.2f})")

""" Summarization
"""
from transformers import PreTrainedTokenizerFast, BartForConditionalGeneration
import torch

model_name = "gogamza/kobart-summarization"
tokenizer = PreTrainedTokenizerFast.from_pretrained(model_name)
model = BartForConditionalGeneration.from_pretrained(model_name)

text = "[TEXT_TO_SUMMARIZE]"

# 토크나이징
inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)
inputs = tokenizer(text,
	return_tensors="pt",	# 토큰화 결과를 PyTorch 텐서로 반환
    max_length=1024,		# 토큰화할 최대 길이
    truncation=True			# max_length를 넘는 입력은 뒷부분을 잘라낸다
)
# print("===>", inputs)

# 생성
summary_ids = model.generate(
    inputs["input_ids"],	# 모델에 넣을 토큰 id 시퀀스
    attention_mask=inputs["attention_mask"],	# 어떤 토큰을 실제로 attend할지 표시하는 마스크
    max_length=128,			# 생성할 요약문의 최대 토큰 길이
    num_beams=4,            # 빔서치 탐색 폭. 한 스텝마다 상위 4개의 후보 시퀀스를 유지하며 탐색 (연산량 증가)
    no_repeat_ngram_size=3,	# 동일한 3-gram(연속 3개 토큰 조합)이 반복 생성되지 않도록 강제
							# 요약 모델이 흔히 겪는 "같은 구절 반복" 문제를 줄여줌
    early_stopping=True,	# 빔서치 진행 중 모든 빔이 EOS 토큰에 도달하면 max_length까지 기다리지 않고 즉시 생성을 종료
)

summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
print(summary)

from transformers import AutoTokenizer, pipeline, GenerationConfig
import torch

model_name = "LGAI-EXAONE/EXAONE-4.0-1.2B"

# 토크나이저를 미리 별도로 로드해서 pipeline에 넘겨줌
tokenizer = AutoTokenizer.from_pretrained(model_name, clean_up_tokenization_spaces=False)

pipe = pipeline(
    "text-generation",
    model=model_name,
    tokenizer=tokenizer,   # 위에서 만든 토크나이저 사용
    dtype=torch.bfloat16,  # 모델 가중치 정밀도 설정
    device_map="auto",     # GPU/CPU에 모델을 자동으로 배치
)

messages = [
    {"role": "system", "content": "당신은 폴리텍 대학의 AI도우미이며 문장요약의 강자 입니다."},
    {"role": "user", "content": 
"""
다음문장을 요약해줘?
----
수랭쿨러 시장은 이제 쿨링 성능만으로는 차별화가 쉽지 않은 단계에 접어들었습니다. 
대부분의 제품이 상향평준화되면서, 최근에는 독특한 디자인이나 디스플레이로 PC의 인상을 완성하는 역할까지 맡고 있죠. 
다만 아무리 화려한 디자인이라도 결국 제품을 통째로 바꿔야 새로운 룩을 즐길 수 있다는 한계는 여전했습니다. 
마음에 드는 신제품이 나올 때마다 수랭쿨러 자체를 새로 사야 했으니까요. 
오늘 소개할 TCOMAS EXIT D3 PRO  360 ARGB와 NEOX PRO 360 AMOLED ARGB는 이 지점에서 꽤 흥미로운 답을 내놓은 제품입니다.

두 제품은 각각 독립적으로 판매되는 별개의 수랭쿨러입니다. 
3면 디스플레이로 입체감을 살린 EXIT D3 PRO, 곡면 OLED로 화면 자체를 강조한 NEOX PRO. 
겉보기엔 완전히 다른 제품이죠. 
그런데 재미있는 건 이 둘이 같은 펌프 헤더 플랫폼을 공유한다는 겁니다. 
즉 EXIT를 쓰던 사람도, NEOX를 쓰던 사람도 마그네틱 모듈식 구조 덕분에 도구 없이 손으로 헤더만 서로 바꿔 낄 수 있다는 뜻이죠. 
여기에 알루미늄 다이캐스트 마감과 29 mm 라디에이터 + 30 mm 팬으로 이어지는 두꺼운 설계까지 더해져 단순한 디자인 쿨러를 넘어서는 완성도를 보여줍니다. 
과연 이 두 제품이 “기변병”을 대하는 새로운 방식을 제시할 수 있을지, 영상에서 자세히 확인해 보세요.
"""
	},
]

# 생성 시 사용할 파라미터들을 하나의 설정 객체로 묶음
gen_config = GenerationConfig(
    max_new_tokens=512,   # 생성할 최대 토큰(단어 조각) 수
    do_sample=True,       # True면 확률적 샘플링, False면 항상 최고 확률 토큰만 선택
    temperature=0.6,
)

# 메시지(대화 기록)와 생성 설정을 넘겨 추론 실행
result = pipe(messages, generation_config=gen_config)

# 결과는 대화 기록 리스트로 반환되므로, 마지막 turn(모델의 응답)의 content만 추출
print(result[0]['generated_text'][-1]['content'])

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

model_name = "circulus/kobart-trans-ko-en-v2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

text = "런던에서 파리로 가는 기차는 얼마인가요?"
inputs = tokenizer(text, return_tensors="pt")
output_ids = model.generate(**inputs, max_length=300)
translated = tokenizer.decode(output_ids[0], skip_special_tokens=True)
print(translated)

""" 영어 -> 한국어 실습 """
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

model_name = "circulus/kobart-trans-en-ko-v2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

text = "How much is the train from London to Paris?"
inputs = tokenizer(text, return_tensors="pt")
output_ids = model.generate(**inputs, max_length=300)
translated = tokenizer.decode(output_ids[0], skip_special_tokens=True)
print(translated)

import torch
from transformers import AutoTokenizer, AutoModelForQuestionAnswering

model_name = "monologg/koelectra-base-v3-finetuned-korquad"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForQuestionAnswering.from_pretrained(model_name)

question = "카카오의 본사는 어디에 있어?"
context = "카카오는 판교에 본사를 두고 있는 대한민국의 IT 기업이다."

inputs = tokenizer(question, context, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs)

start_idx = torch.argmax(outputs.start_logits)
end_idx = torch.argmax(outputs.end_logits) + 1

answer_ids = inputs["input_ids"][0][start_idx:end_idx]
answer = tokenizer.decode(answer_ids, skip_special_tokens=True)

print("답변:", answer)

from transformers import pipeline, GenerationConfig

pipe = pipeline(
    "text-generation",
    model="microsoft/Phi-4-mini-instruct",
    dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "user", "content": "철수가 100원이 있는데, 40원을 과자를 사먹었고, 엄마에게 100원 용돈을 받았어, 남은 돈은 얼마야?"}
]

gen_config = GenerationConfig(max_new_tokens=512, do_sample=False)
result = pipe(messages, generation_config=gen_config)

answer = result[0]['generated_text'][-1]['content']
print(answer)

from transformers import pipeline
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"

pipe = pipeline("text-generation", model="google/gemma-3-1b-it", device=device, torch_dtype=torch.bfloat16)

def qa(context):
    data =  [
        [
            {
            "role": "system",
            "content": [{"type": "text", "text": "너는 창의력이 풍부하고 독창적인 시인이야."},]
            },
            {
            "role": "user",
            "content": [{"type": "text", "text": context},]
            },
        ],
    ]
    return data

messages=qa("층간소음때문에 너무 힘든데 윗집에 뭐라고 말하면 좋을까?")

gen_config = GenerationConfig(
	max_new_tokens=1024,
)

output = pipe(messages, generation_config=gen_config)
print(output[0][0]["generated_text"][2]['content'])

class ChatBackend:
    def ask(self, user_message, model_name): ...

class OpenAIBackend(ChatBackend): ...
class LMStudioBackend(ChatBackend): ...
class HuggingFaceBackend(ChatBackend): ...

class ChatWorker(QThread):
    finished = pyqtSignal(str)

    def run(self):
        result = self.backend.ask(...)
        self.finished.emit(result)

def set_font_size(widget, size):
    font = widget.font()
    font.setPointSize(size)
    widget.setFont(font)

import os
import sys

from PyQt6.QtCore import QThread, pyqtSignal
from PyQt6.QtWidgets import (
    QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QTextEdit,
    QLineEdit, QPushButton, QComboBox,
)

# --- UI 상수 ---
WINDOW_GEOMETRY = (100, 100, 1200, 1200)
LABEL_FONT_SIZE = 20
ROW_FONT_SIZE = 12

# --- 모델 생성 공통 설정 ---
DEFAULT_MAX_TOKENS = 1024

def set_font_size(widget, size):
    """위젯의 폰트 크기만 바꿔서 다시 적용한다.

    Args:
        widget (QWidget): 폰트를 적용할 위젯.
        size (int): 적용할 포인트 크기.
    """
    font = widget.font()
    font.setPointSize(size)
    widget.setFont(font)

def build_messages(user_message):
    """OpenAI / LMStudio / HuggingFace가 공통으로 쓰는 messages 포맷을 생성한다.

    Args:
        user_message (str): 사용자가 입력한 질문.

    Returns:
        list[dict]: system + user 메시지 리스트.
    """
    return [
        {"role": "system", "content": "너는 챗봇이야."},
        {"role": "user", "content": user_message},
    ]

# ---------------------------------------------------------------------------
# 백엔드: UI와 분리된 순수 로직. 각 백엔드는 ask(user_message, model_name)만 구현한다.
# ---------------------------------------------------------------------------

class ChatBackend:
    """LLM 백엔드의 공통 인터페이스."""

    name = "Backend"
    default_model = ""

    def ask(self, user_message, model_name):
        """질문을 모델에 보내고 응답 텍스트를 반환한다.

        Args:
            user_message (str): 사용자 질문.
            model_name (str): 사용할 모델명.

        Returns:
            str: 모델의 응답 텍스트.
        """
        raise NotImplementedError

class OpenAIBackend(ChatBackend):
    """OpenAI API를 호출하는 백엔드."""

    name = "OpenAI"
    default_model = "gpt-4o-mini"

    def ask(self, user_message, model_name):
        from openai import OpenAI

        api_key = os.environ.get("OPENAI_API_KEY")
        if not api_key:
            return ("OPENAI_API_KEY 환경변수가 안 잡혀있음. "
                    "터미널에서 set OPENAI_API_KEY=sk-... (윈도우) 또는 "
                    "export OPENAI_API_KEY=sk-... (리눅스/맥) 하고 다시 실행해줘.")

        client = OpenAI(api_key=api_key)
        resp = client.chat.completions.create(
            model=model_name or self.default_model,
            messages=build_messages(user_message),
            max_tokens=DEFAULT_MAX_TOKENS,
        )
        return resp.choices[0].message.content

class LMStudioBackend(ChatBackend):
    """LM Studio 로컬 OpenAI 호환 서버를 호출하는 백엔드."""

    name = "LMStudio"
    default_model = "local-model"  # LM Studio는 서버에 로드된 모델을 그대로 씀

    def ask(self, user_message, model_name):
        from openai import OpenAI

        # LM Studio는 로컬 서버라 key를 검증하지 않는다.
        client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
        try:
            resp = client.chat.completions.create(
                model=model_name or self.default_model,
                messages=build_messages(user_message),
                max_tokens=DEFAULT_MAX_TOKENS,
            )
        except Exception as e:
            return (f"LM Studio 서버 연결 실패({e}). "
                    "LM Studio 앱 켜고 모델 로드한 다음 'Start Server' 눌렀는지 확인해줘. "
                    "(기본 주소: http://localhost:1234/v1)")
        return resp.choices[0].message.content

class HuggingFaceBackend(ChatBackend):
    """로컬 transformers pipeline으로 추론하는 백엔드.

    모델은 최초 ask() 호출 시에만 로드하고(지연 로딩) 이후 재사용한다.
    """

    name = "HuggingFace"
    default_model = "google/gemma-3-1b-it"

    def __init__(self):
        self._pipe = None

    def _get_pipeline(self):
        if self._pipe is None:
            import torch
            from transformers import pipeline
            device = "cuda" if torch.cuda.is_available() else "cpu"
            self._pipe = pipeline(
                "text-generation",
                model=self.default_model,
                device=device,
                torch_dtype=torch.bfloat16,
            )
        return self._pipe

    def ask(self, user_message, model_name):
        pipe = self._get_pipeline()
        data = [build_messages(user_message)]
        output = pipe(data, max_new_tokens=DEFAULT_MAX_TOKENS)
        return output[0][0]["generated_text"][-1]["content"]

# 콤보박스에 표시될 순서와 백엔드 목록
BACKENDS = [OpenAIBackend(), LMStudioBackend(), HuggingFaceBackend()]
BACKENDS_BY_NAME = {b.name: b for b in BACKENDS}

# ---------------------------------------------------------------------------
# 백그라운드 워커: UI 스레드를 막지 않고 백엔드 호출을 실행한다.
# ---------------------------------------------------------------------------

class ChatWorker(QThread):
    """백엔드 호출을 별도 스레드에서 실행하고 결과를 시그널로 전달한다."""

    finished = pyqtSignal(str)

    def __init__(self, backend, user_message, model_name):
        super().__init__()
        self.backend = backend
        self.user_message = user_message
        self.model_name = model_name

    def run(self):
        try:
            result = self.backend.ask(self.user_message, self.model_name)
        except Exception as e:
            result = f"[오류 발생] {e}"
        self.finished.emit(result)

# ---------------------------------------------------------------------------
# UI
# ---------------------------------------------------------------------------

class ChatApp(QWidget):
    """세 가지 LLM 백엔드를 선택해 대화할 수 있는 챗봇 윈도우."""

    def __init__(self):
        super().__init__()
        self._worker = None  # 실행 중인 ChatWorker 참조 (GC 방지 + 중복 전송 방지용)
        self._build_ui()

    def _build_ui(self):
        """윈도우의 모든 위젯을 생성하고 배치한다."""
        self.setWindowTitle("분당폴리텍 인공지능소프트웨어 LLM chat bot (Qt6)")
        self.setGeometry(*WINDOW_GEOMETRY)

        layout = QVBoxLayout()

        self.label = QLabel("홍교수님 너무 잘생겼어", self)
        self.label.setStyleSheet("background-color: lightgreen")
        set_font_size(self.label, LABEL_FONT_SIZE)
        layout.addWidget(self.label)

        layout.addLayout(self._build_backend_row())

        self.chat_box = QTextEdit(self)
        set_font_size(self.chat_box, LABEL_FONT_SIZE)
        self.chat_box.setReadOnly(True)
        layout.addWidget(self.chat_box)

        self.user_input = QLineEdit(self)
        set_font_size(self.user_input, LABEL_FONT_SIZE)
        self.user_input.setPlaceholderText('질문해 주셔요...')
        self.user_input.returnPressed.connect(self.send_message)
        layout.addWidget(self.user_input)

        self.send_button = QPushButton('보내기', self)
        set_font_size(self.send_button, LABEL_FONT_SIZE)
        self.send_button.clicked.connect(self.send_message)
        layout.addWidget(self.send_button)

        self.setLayout(layout)

    def _build_backend_row(self):
        """백엔드 선택 콤보박스 + 모델명 입력창 행을 생성한다.

        Returns:
            QHBoxLayout: 완성된 백엔드 선택 행 레이아웃.
        """
        backend_row = QHBoxLayout()

        backend_label = QLabel("방식 선택:", self)
        set_font_size(backend_label, ROW_FONT_SIZE)
        backend_row.addWidget(backend_label)

        self.backend_combo = QComboBox(self)
        self.backend_combo.addItems([b.name for b in BACKENDS])
        set_font_size(self.backend_combo, ROW_FONT_SIZE)
        self.backend_combo.currentTextChanged.connect(self.on_backend_changed)
        backend_row.addWidget(self.backend_combo)

        model_label = QLabel("모델명:", self)
        set_font_size(model_label, ROW_FONT_SIZE)
        backend_row.addWidget(model_label)

        self.model_input = QLineEdit(self)
        self.model_input.setText(BACKENDS[0].default_model)
        set_font_size(self.model_input, ROW_FONT_SIZE)
        backend_row.addWidget(self.model_input)

        return backend_row

    def on_backend_changed(self, backend_name):
        """콤보박스 선택이 바뀌면 모델명 입력창을 해당 백엔드의 기본값으로 갱신한다.

        Args:
            backend_name (str): 새로 선택된 백엔드 이름.
        """
        backend = BACKENDS_BY_NAME.get(backend_name)
        if backend:
            self.model_input.setText(backend.default_model)

    def send_message(self):
        """사용자 입력을 읽어 선택된 백엔드로 백그라운드 질의를 시작한다."""
        if self._worker is not None:
            return  # 이전 요청이 끝나기 전 중복 전송 방지

        user_message = self.user_input.text().strip()
        if not user_message:
            return

        self.chat_box.append(f'질문: {user_message}')
        self.user_input.clear()

        backend_name = self.backend_combo.currentText()
        backend = BACKENDS_BY_NAME[backend_name]
        model_name = self.model_input.text().strip()

        self._set_input_enabled(False)
        self._worker = ChatWorker(backend, user_message, model_name)
        self._worker.finished.connect(
            lambda result: self._on_response(backend_name, result)
        )
        self._worker.start()

    def _on_response(self, backend_name, bot_message):
        """워커 스레드로부터 응답을 받아 채팅창에 표시하고 입력을 다시 활성화한다.

        Args:
            backend_name (str): 응답을 생성한 백엔드 이름.
            bot_message (str): 생성된 응답 텍스트.
        """
        self.chat_box.append(f'KOPO bot ({backend_name}): {bot_message}')
        self.chat_box.append('---')
        self._set_input_enabled(True)
        self._worker = None

    def _set_input_enabled(self, enabled):
        """응답 대기 중 입력창/버튼을 잠그거나 푼다.

        Args:
            enabled (bool): True면 활성화, False면 비활성화.
        """
        self.user_input.setEnabled(enabled)
        self.send_button.setEnabled(enabled)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = ChatApp()
    window.show()
    sys.exit(app.exec())