from transformers import AutoModelForCausalLM, AutoTokenizer

# A.X 4.0 Standard 모델 로드
model_name = "SKT-AI/A.X-4.0-Standard"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 텍스트 생성
input_text = "한국어 언어 모델의 발전은"
inputs = tokenizer(input_text, return_tensors="pt")
outputs = model.generate(inputs, max_length=100)
print(tokenizer.decode(outputs[0]))

pip install kobert-transformers
pip install transformers

from kobert_transformers import get_tokenizer
from transformers import BertModel

# 토크나이저와 모델 로드
tokenizer = get_tokenizer()
model = BertModel.from_pretrained('skt/kobert-base-v1')

# 텍스트 토큰화 및 임베딩 생성
text = "한국어 자연어 처리는 재미있습니다"
inputs = tokenizer(text, return_tensors='pt')
outputs = model(inputs)

# 문장 임베딩 추출
sentence_embedding = outputs.last_hidden_state[:, 0, :].squeeze()
print(sentence_embedding.shape)  # torch.Size([768])

import torch
from kobert_transformers import get_kobert_model, get_tokenizer

# 모델과 토크나이저 가져오기
tokenizer = get_tokenizer()
model = get_kobert_model()

# 텍스트 처리
text = "KoBERT는 한국어 이해에 특화되어 있습니다."
encoded = tokenizer.encode_plus(
    text,
    add_special_tokens=True,
    max_length=128,
    padding='max_length',
    return_attention_mask=True,
    return_tensors='pt'
)

# 모델 추론
with torch.no_grad():
    outputs = model(
        input_ids=encoded['input_ids'],
        attention_mask=encoded['attention_mask']
    )
    
pooled_output = outputs[1]  # [CLS] 토큰의 출력
print(pooled_output.shape)  # torch.Size([1, 768])

from transformers import AutoModel, AutoTokenizer

# Hugging Face Hub에서 직접 로드
model_name = "skt/kobert-base-v1"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

# 추론
text = "KoBERT는 한국어 자연어 처리의 표준입니다"
inputs = tokenizer(text, return_tensors="pt")
outputs = model(inputs)

pip install kogpt2-transformers

import torch
from transformers import GPT2LMHeadModel
from kogpt2_transformers import get_kogpt2_tokenizer

# 모델과 토크나이저 로드
tokenizer = get_kogpt2_tokenizer()
model = GPT2LMHeadModel.from_pretrained('skt/kogpt2-base-v2')

# 텍스트 생성
text = "인공지능의 미래는"
input_ids = tokenizer.encode(text, return_tensors='pt')

# 생성 파라미터 설정
gen_ids = model.generate(
    input_ids,
    max_length=128,
    repetition_penalty=2.0,
    pad_token_id=tokenizer.pad_token_id,
    eos_token_id=tokenizer.eos_token_id,
    bos_token_id=tokenizer.bos_token_id,
    use_cache=True
)

# 결과 디코딩
generated = tokenizer.decode(gen_ids[0])
print(generated)

from transformers import pipeline

# 텍스트 생성 파이프라인
generator = pipeline(
    'text-generation',
    model='skt/kogpt2-base-v2',
    tokenizer='skt/kogpt2-base-v2'
)

# 텍스트 생성
prompt = "한국어 자연어 처리 기술은"
result = generator(
    prompt,
    max_length=100,
    num_return_sequences=3,
    temperature=0.8
)

for i, text in enumerate(result):
    print(f"Result {i+1}: {text['generated_text']}")

from kogpt2_transformers import get_kogpt2_tokenizer
from transformers import GPT2LMHeadModel
import torch

tokenizer = get_kogpt2_tokenizer()
model = GPT2LMHeadModel.from_pretrained('skt/kogpt2-base-v2')

# 감성 분석을 위한 프롬프트
reviews = [
    "이 영화는 정말 재미있었다",
    "서비스가 형편없었다",
    "가격 대비 훌륭한 제품이다"
]

for review in reviews:
    # 긍정/부정 판단을 위한 프롬프트 엔지니어링
    prompt = f"{review} 이 리뷰는"
    input_ids = tokenizer.encode(prompt, return_tensors='pt')
    
    with torch.no_grad():
        output = model.generate(
            input_ids,
            max_length=len(input_ids[0]) + 10,
            num_return_sequences=1,
            temperature=0.7
        )
    
    result = tokenizer.decode(output[0])
    print(f"Original: {review}")
    print(f"Analysis: {result}\n")

from kogpt2_transformers import get_kogpt2_tokenizer
from transformers import GPT2LMHeadModel
import torch

tokenizer = get_kogpt2_tokenizer()
model = GPT2LMHeadModel.from_pretrained('skt/kogpt2-base-v2')

def generate_response(user_input, context=""):
    """대화 기반 응답 생성"""
    prompt = f"{context}\n사용자: {user_input}\nAI:"
    
    input_ids = tokenizer.encode(prompt, return_tensors='pt')
    
    with torch.no_grad():
        output = model.generate(
            input_ids,
            max_length=input_ids.shape[1] + 50,
            temperature=0.8,
            top_k=50,
            top_p=0.95,
            repetition_penalty=1.2,
            do_sample=True
        )
    
    response = tokenizer.decode(output[0], skip_special_tokens=True)
    # AI 응답 부분만 추출
    ai_response = response.split("AI:")[-1].strip()
    
    return ai_response

# 챗봇 대화 예제
context = ""
while True:
    user_input = input("You: ")
    if user_input.lower() in ['quit', 'exit', '종료']:
        break
    
    response = generate_response(user_input, context)
    print(f"AI: {response}\n")
    
    # 컨텍스트 업데이트
    context += f"사용자: {user_input}\nAI: {response}\n"

pip install transformers torch

from transformers import PreTrainedTokenizerFast, BartForConditionalGeneration

# 모델 및 토크나이저 로드
tokenizer = PreTrainedTokenizerFast.from_pretrained('gogamza/kobart-base-v2')
model = BartForConditionalGeneration.from_pretrained('gogamza/kobart-base-v2')

# 긴 텍스트 요약
text = """
SK텔레콤은 한국 최대의 이동통신사로, AI, 5G, 클라우드 등 
다양한 ICT 기술을 보유하고 있습니다. 최근에는 한국어 
대규모 언어 모델 A.X를 개발하여 오픈소스로 공개했으며,
이를 통해 국내 AI 생태계 발전에 기여하고 있습니다.
"""

# 인코딩 및 요약 생성
inputs = tokenizer(text, return_tensors='pt', max_length=1024, truncation=True)
summary_ids = model.generate(
    inputs['input_ids'],
    max_length=150,
    num_beams=5,
    early_stopping=True
)

# 디코딩
summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
print(summary)

# Prompt 기반 텍스트 생성
prompt = "인공지능 기술의 발전으로"

inputs = tokenizer(prompt, return_tensors='pt')
outputs = model.generate(
    inputs['input_ids'],
    max_length=100,
    temperature=0.8,
    do_sample=True,
    top_k=50
)

generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)

from transformers import Trainer, TrainingArguments

# Fine-tuning 설정
training_args = TrainingArguments(
    output_dir='./kobart-finetuned',
    num_train_epochs=3,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    evaluation_strategy="epoch"
)

# Trainer 생성
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)

# 학습 실행
trainer.train()

# PyPI에서 설치
pip install onot

# 또는 소스에서 설치
git clone https://github.com/sktelecom/onot.git
cd onot
pip install -e .

# SPDX 파일로부터 HTML 고지문 생성
onot -i sbom.spdx.json -o notice.html

# Markdown 형식으로 생성
onot -i sbom.spdx.json -o notice.md -f markdown

# Excel 형식으로 생성
onot -i sbom.spdx.json -o notice.xlsx -f excel

{
  "spdxVersion": "SPDX-2.3",
  "dataLicense": "CC0-1.0",
  "SPDXID": "SPDXRef-DOCUMENT",
  "name": "MyProject",
  "packages": [
    {
      "SPDXID": "SPDXRef-Package-1",
      "name": "express",
      "versionInfo": "4.18.2",
      "licenseConcluded": "MIT",
      "copyrightText": "Copyright (c) 2009-2014 TJ Holowaychuk",
      "downloadLocation": "https://registry.npmjs.org/express/-/express-4.18.2.tgz"
    }
  ]
}