미니 프로젝트 3일차..

 

# 텍스트 요약 모델 사용하기 

 

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import nltk
from fastapi import FastAPI, Form
import torch

# NLTK 데이터 다운로드
nltk.download('punkt')

# 모델과 토크나이저 설정
model_dir = "lcw99/t5-base-korean-text-summary"
tokenizer = AutoTokenizer.from_pretrained(model_dir)
model = AutoModelForSeq2SeqLM.from_pretrained(model_dir)

# CUDA 장치 설정
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)  # 모델을 CUDA로 이동

app = FastAPI()

@app.post("/text_sum/")
async def text_sum(input_text: str = Form(...)):
    max_input_length = 512

    # 입력 텍스트 설정 및 전처리
    text = input_text
    inputs = ["summarize: " + text]
    inputs = tokenizer(inputs, max_length=max_input_length, truncation=True, return_tensors="pt").to(device)  # 입력을 CUDA로 이동

    # 요약 생성
    with torch.no_grad():
        output = model.generate(**inputs, num_beams=8, do_sample=True, min_length=10, max_length=100)

    # 요약된 텍스트 디코딩 및 문장화
    decoded_output = tokenizer.batch_decode(output, skip_special_tokens=True)[0]
    predicted_summary = nltk.sent_tokenize(decoded_output.strip())[0]

    return {"result": predicted_summary}

 

 

# 명언 추천 모델 사용 못하고 랜덤 돌리기;;;

 

from transformers import OPTForCausalLM, GPT2Tokenizer
from fastapi import FastAPI, Form
import torch
import random

# 모델과 토크나이저 설정
model = OPTForCausalLM.from_pretrained("facebook/opt-350m", torch_dtype=torch.float16)
tokenizer = GPT2Tokenizer.from_pretrained("facebook/opt-350m")

# 모델이 사용할 장치 설정
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)

# FastAPI 앱 초기화
app = FastAPI()

# 명언 파일에서 명언을 읽어 리스트에 저장
def load_quotes(file_path="wise_saying.txt"):
    with open(file_path, "r", encoding="utf-8") as file:
        return [line.strip() for line in file.readlines() if line.strip()]

quotes = load_quotes()  # wise_saying.txt에서 명언 불러오기

# FastAPI 엔드포인트: 입력한 텍스트를 기반으로 명언 생성
@app.post("/create_text/")
async def create_text(input_text: str = Form(...)):
    # 명언 리스트에서 무작위로 하나 선택
    selected_quote = random.choice(quotes)
    selected_quote = selected_quote.split('.', 1)[-1].strip()
    return {"result": selected_quote}


# # 입력 텍스트와 가장 관련 있는 명언을 찾는 함수
# def get_best_quote(input_text, quotes):
#     best_quote = ""
#     highest_score = -float("inf")  # 초기 최고 점수를 음의 무한대로 설정

#     for quote in quotes:
#         prompt = f"다음 입력 문구와 가장 잘 맞는 명언을 고르시오: '{input_text}'\n명언: '{quote}'"
        
#         # 입력 텍스트와 명언을 함께 토큰화하여 모델 입력으로 사용
#         inputs = tokenizer(prompt, return_tensors="pt").to(device)
#         with torch.no_grad():
#             # 텍스트와 명언의 관련성을 평가하도록 모델 사용
#             output = model(**inputs).logits.mean().item()
        
#         # 모델 출력이 높을수록 높은 연관성으로 간주
#         if output > highest_score:
#             highest_score = output
#             best_quote = quote

#     return best_quote

# # FastAPI 엔드포인트: 입력한 텍스트를 기반으로 가장 적합한 명언 선택
# @app.post("/create_text/")
# async def create_text(input_text: str = Form(...)):
#     # 입력 텍스트와 가장 관련 있는 명언을 찾음
#     selected_quote = get_best_quote(input_text, quotes)
#     selected_quote = selected_quote.split('.', 1)[-1].strip()
#     return {"result": selected_quote}

 

 

# 텍스트 이미지 생성 다시 해보기..

 

from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from fastapi.responses import FileResponse
from PIL import Image
import requests
import json
import torch

model_id = "CompVis/stable-diffusion-v1-4"
device = "cuda"

pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
pipe = pipe.to(device)


# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(input_text: str = Form(...)):       

    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=input_text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    # return {"image_path": image_path}
    return FileResponse(image_path, media_type="image/png")




# 시간 너무 오래 걸려서 줄이는 중...

from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from fastapi.responses import FileResponse
import torch

model_id = "runwayml/stable-diffusion-v1-5"
device = "cuda"

# Stable Diffusion Pipeline 설정 (FP16 사용)
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to(device)

app = FastAPI()

@app.post("/createimage/")
async def create_image(input_text: str = Form(...)):       
    # 텍스트 기반으로 이미지 생성 (속도 최적화를 위한 파라미터 조정)
    image = pipe(
        prompt=input_text,
        num_inference_steps=20,  # 생성 속도 개선을 위해 20단계로 설정
        guidance_scale=3.0       # 프롬프트 따르는 강도 조정
    ).images[0]

    # 이미지 저장 및 반환
    image_path = "generated_image.png"
    image.save(image_path)
    return FileResponse(image_path, media_type="image/png")

 

 

어제 쓴 StableDiffusion 로그인 하는 법 성범님이 알려주심...

 

1. token 새로 생성하고

2. 터미널에 huggingface-cli login 입력하면

3. 토큰 넣어라고 하는데... 안 보이니까 한번만 붙여넣기 하삼..

# '''
# 5. 음악, 명언, 그림 추천/생성: (모델 미정) :
#      (후보 1) facebook/musicgen-small 
#      프롬프터를 작성해주면 음악을 만들어주는 모델입니다. 
#      대신 이건 저희가 백엔드 쪽에서 프롬프터를 몇가지 만들어서 넣어줘야 할 것 같아요.
# '''


from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from PIL import Image
import torch
import json
import requests

# # Hugging Face API 토큰 설정
# API_TOKEN = "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"
# headers = {"Authorization": f"Bearer {API_TOKEN}"}

# Stable Diffusion 모델 로드
pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.float16,
    use_auth_token=API_TOKEN  # API 토큰을 사용해 인증
)
pipe = pipe.to("cuda")

# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(text: str = Form(...)):
    """
    주어진 텍스트 프롬프트를 기반으로 이미지를 생성하여 저장합니다.
    """
    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    return {"image_path": image_path}
    
 
 
 # 일단 수정 한번 한 이미지 생성 
 from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from fastapi.responses import FileResponse
import torch

# 호환 가능한 모델 ID를 사용하여 모델 로드
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    safety_checker=None  # 안전 검사기를 비활성화하여 일부 오류 방지
).to("cuda")
pipe.enable_attention_slicing()

# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(text: str = Form(...)):
    """
    주어진 텍스트 프롬프트를 기반으로 이미지를 생성하여 저장합니다.
    """
    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    return FileResponse(image_path, media_type="image/png")