[GPT] API를 활용한 서비스 만들기(2)

Sep 14, 2023

Contents

5. 인공지능 서비스 6. AWS to-do..

5. 인공지능 서비스 5.1. 번역 AI서비스 5.2. 광고문구 작성 서비스 5.3. (변형) 법률 블로그 작성 서비스 6. AWS 6.1. AWS EC2 6.2. Git, Github to-do..

5. 인공지능 서비스

5.1. 번역 AI서비스

chatgpt api를 사용해야 비용이 더 saving됨

few shot 프롬프트 : 데모를 제공해서 모델이 더 나은 성능을 발휘하도록 문맥 내 학습 지원


parellel_example = {
    "한국어" : ["오늘 날씨 어때", "딥러닝 기반 AI기술이 인기를 끌고 있다"],
    "영어" : ["How's the weather today", "Deep learning-based AI technology is gaining popularity."],
    "일본어" : ["今日の天気はどうですか", "ディープラーニングベースのAI技術は人気があります"]
}

def translate_text_using_chatgpt(text, src_lang, trg_lang):
    def build_fewshot(src_lang, trg_lang):
        src_examples = parellel_example[src_lang]
        trg_examples = parellel_example[trg_lang]
        fewshot_messages = []

        for src_text, trg_text in zip(src_examples, trg_examples):
            fewshot_messages.append({"role" : "user", "content" : src_text})
            fewshot_messages.append({"role" : "assistant", "content" : trg_text})
        return fewshot_messages 

    system_instruction = f"assistant는 번역앱으로 동작한다. {src_lang}을 {trg_lang}으로 적절하게 번역하고 번역된 텍스트만 출력한다."
    fewshot_messages = build_fewshot(src_lang=src_lang, trg_lang=trg_lang)
    
    user_message = {"role": "user", "content": text}
    messages = [{"role": "system", "content": system_instruction}, 
                *fewshot_messages, 
                user_message]

    response = openai.ChatCompletion.create(model="gpt-3.5-turbo",                                         messages=messages)
    translated_text = response['choices'][0]['message']['content']
    return translated_text

st.title("번역 서비스")
text = st.text_area("번역할 텍스트 입력하세요", "")
src_lang = st.selectbox("원본 언어", ["영어", "한국어", "일본어"])
#기본 값을 1로 설정하자
trg_lang = st.selectbox("목표 언어", ["영어", "한국어", "일본어"], index=1)

if st.button("번역"):
    translated_text = translate_text_using_chatgpt(text, src_lang, trg_lang)
    st.success(translated_text)

5.2. 광고문구 작성 서비스

step 1 Class, 함수 사용해서 간단한 prompt engineering 진행


#fasptapi api 서버
#openai api를 활용해서 광고 문구 작성 함수 호출

import openai
openai.api_key = ""

class SloganGenerator:
    def __init__(self, engine='gpt-3.5-turbo'):
        self.engine = engine
        self.infer_type = self._get_infer_type_by_engine(engine)

    def _get_infer_type_by_engine(self, engine):
        if engine.startswith("text-"):
            return "completion"
        elif engine.startswith("gpt-"):
            return "chat"
        raise Exception(f"Unknown engine type: {engine}")

    def _infer_using_completion(self, prompt):
        response = openai.Completion.create(
            engine=self.engine,
            prompt=prompt,
            max_tokens=200,
            n=1
        )
        result = response.choices[0].text.strip()
        return result

    def _infer_using_chatgpt(self, prompt):
        system_instruction = "assistant는 마케팅 문구 작성 도우미로 동작한다. user의 내용을 참고해서 마케팅 문구를 작성해라"
        messages = [{"role": "system", "content": system_instruction},
                    {"role": "user", "content": prompt}]
        response = openai.ChatCompletion.create(model=self.engine, messages=messages)
        result = response['choices'][0]['message']['content']
        return result

    def generate(self, product_name, details, tone_and_manner):
        prompt = f"제품 이름: {product_name}\n주요 내용: {details}\n광고 문구의 스타일: {tone_and_manner} 위 내용을 참고하여 마케팅 문구를 만들어라."
        if self.infer_type == "completion":
            result = self._infer_using_completion(prompt=prompt)
        elif self.infer_type == "chat":
            result = self._infer_using_chatgpt(prompt=prompt)
        return result

slogan_generator = SloganGenerator(engine="gpt-3.5-turbo")
result = slogan_generator.generate(product_name="나이키 신발", details="mz세대에 맞춘 트렌디한 디자인", tone_and_manner="과장")
print(result)

step 2 fastapi를 사용해서 백엔드 구축 (backend.py)

http://127.0.0.1:8000/docs 이렇게 하면 swagger ui로 감


#실행 명령
uvicorn backend:app --reload


import openai
from fastapi import FastAPI
from pydantic import BaseModel

openai.api_key = ""

class SloganGenerator:
    def __init__(self, engine='gpt-3.5-turbo'):
        self.engine = engine
        self.infer_type = self._get_infer_type_by_engine(engine)

    def _get_infer_type_by_engine(self, engine):
        if engine.startswith("text-"):
            return "completion"
        elif engine.startswith("gpt-"):
            return "chat"
        raise Exception(f"Unknown engine type: {engine}")

    def _infer_using_completion(self, prompt):
        response = openai.Completion.create(
            engine=self.engine,
            prompt=prompt,
            max_tokens=200,
            n=1
        )
        result = response.choices[0].text.strip()
        return result

    def _infer_using_chatgpt(self, prompt):
        system_instruction = "assistant는 마케팅 문구 작성 도우미로 동작한다. user의 내용을 참고해서 마케팅 문구를 작성해라"
        messages = [{"role": "system", "content": system_instruction},
                    {"role": "user", "content": prompt}]
        response = openai.ChatCompletion.create(model=self.engine, messages=messages)
        result = response['choices'][0]['message']['content']
        return result

    def generate(self, product_name, details, tone_and_manner):
        prompt = f"제품 이름: {product_name}\n주요 내용: {details}\n광고 문구의 스타일: {tone_and_manner} 위 내용을 참고하여 마케팅 문구를 만들어라."
        if self.infer_type == "completion":
            result = self._infer_using_completion(prompt=prompt)
        elif self.infer_type == "chat":
            result = self._infer_using_chatgpt(prompt=prompt)
        return result

app = FastAPI()

class Product(BaseModel):
    product_name: str
    details: str
    tone_and_manner: str 

@app.post("/create_ad_slogan")
def create_ad_slogan(product: Product):
    slogan_generator = SloganGenerator("gpt-3.5-turbo")
    ad_slogan = slogan_generator.generate(product_name = product.product_name,
                                          details = product.details,
                                          tone_and_manner = product.tone_and_manner)
    return {"ad_slogan": ad_slogan}

step3 프론트는 스트림릿으로 구현


import streamlit as st
import requests 

st.title("광고문구 작성 서비스")
generate_ad_slogan_url = "http://127.0.0.1:8000/create_ad_slogan"

product_name = st.text_input("제품 이름")
details = st.text_input("주요 내용")
options = st.multiselect("광고 문구의 톤앤 매너", options=["기본", "과장스럽게", "차분한", "웃긴"], default=["기본"])

if st.button("광구 문구 상세"):
    try:
        response = requests.post(generate_ad_slogan_url,
                    json={"product_name": product_name,
                            "details" : details,
                            "tone_and_manner" : ', '.join(options)})
        
        ad_slogan = response.json()['ad_slogan']
        st.success(ad_slogan)
    except:
        st.error("예상치 못한 에러 발생")

5.3. (변형) 법률 블로그 작성 서비스

backend.py


import openai
from fastapi import FastAPI
from pydantic import BaseModel

openai.api_key = ""

class Generator:
    def __init__(self, engine='gpt-3.5-turbo'):
        self.engine = engine
        self.infer_type = self._get_infer_type_by_engine(engine)

    def _get_infer_type_by_engine(self, engine):
        if engine.startswith("text-"):
            return "completion"
        elif engine.startswith("gpt-"):
            return "chat"
        raise Exception(f"Unknown engine type: {engine}")

    def _infer_using_completion(self, prompt):
        response = openai.Completion.create(
            engine=self.engine,
            prompt=prompt,
            max_tokens=200,
            n=1,
            temperature=0.7  # 추가: 생성 텍스트 다양성 조절
        )
        result = response.choices[0].text.strip()
        return result

    def _infer_using_chatgpt(self, prompt):
        system_instruction = "assistant는 법률 블로그의 콘텐츠 마케터로 동작한다. user의 내용을 참고해서 블로그 콘텐츠 글을 작성해라"
        messages = [{"role": "system", "content": system_instruction},
                    {"role": "user", "content": prompt}]
        response = openai.ChatCompletion.create(model=self.engine, messages=messages)
        result = response['choices'][0]['message']['content']
        return result

    def generate(self, case, type, key_message, bullet):
        prompt = f"판례: {case} \n블로그 콘텐츠 유형: {type}\n강조점: {key_message}\n 개요 및 소제목: {bullet} 위 내용을 참고하여 블로그 콘텐츠를 작성해줘. 결과물은 mark-down 형식으로 만들어줘"
        if self.infer_type == "completion":
            result = self._infer_using_completion(prompt=prompt)
        elif self.infer_type == "chat":
            result = self._infer_using_chatgpt(prompt=prompt)
        return result

app = FastAPI()

class Content(BaseModel):
    case: str
    type: str
    key_message: str 
    bullet: str

@app.post("/create_blog")
def create_blog_content(content: Content):
    content_generator = Generator("gpt-3.5-turbo")
    blog_content = content_generator.generate(case=content.case,
                                              type=content.type,
                                              key_message=content.key_message,
                                              bullet=content.bullet)
    return {"blog_content": blog_content}

app.py


import streamlit as st
import requests 

st.title("법률 블로그 작성 서비스")
generate_content_url = "http://127.0.0.1:8000/create_blog"

case = st.text_area("판례 내용을 복사 붙여넣기 해주세요", height=200)
type = st.multiselect("블로그 콘텐츠 유형", options=["승소 사례", "법적 이슈", "법률 상식", "공지 사항"], default=["승소 사례"])
key_message = st.text_area("해당 콘텐츠에서 강조하고 싶은 점", height=100)
bullet = st.multiselect("개요", options=["사건 경위", "변호 전략", "재판 결과", "우리 로펌과 함께해야할 이유"], default=["사건 경위"])

if st.button("블로그 작성 결과"):
    try:
        type_str = ", ".join(type)
        bullet_str = ", ".join(bullet)

        response = requests.post(generate_content_url,
                    json={"case" : case,
                        "type" : type_str,
                        "key_message" : key_message,
                        "bullet" : bullet_str
                        })
        
        blog_content = response.json()['blog_content']
        st.success(blog_content)
    except:
        st.error("예상치 못한 에러 발생")