하지만 영어를 한국어로 번역해주는 영한 번역 라이브러리는 있지만 영타를 한국어로 번역해주는 라이브러리는 없었다.

그래서 이번 시간에는 영타를 한국어로 번역해주는 코드를 직접 작성하기로 했다.

_CHO_ = 'ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ'
_JUNG_ = 'ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ'
_JONG_ = 'ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ' # index를 1부터 시작해야 함

먼저 첫 번째로 우리 한국어에서 나올 수 있는 모든 초성, 중성, 종성을 다 종합해서 정리를 했다.

우리는 위에 나온 CHO JUNG JONG 세 변수를 이용해서 다양한 한국어를 구사할 예정이다.

_JAMO2ENGKEY_ = {
 'ㄱ': 'r',
 'ㄲ': 'R',
 'ㄴ': 's',
 'ㄷ': 'e',
 'ㄸ': 'E',
 'ㄹ': 'f',
 'ㅁ': 'a',
 'ㅂ': 'q',
 'ㅃ': 'Q',
 'ㅅ': 't',
 'ㅆ': 'T',
 'ㅇ': 'd',
 'ㅈ': 'w',
 'ㅉ': 'W',
 'ㅊ': 'c',
 'ㅋ': 'z',
 'ㅌ': 'x',
 'ㅍ': 'v',
 'ㅎ': 'g',
 'ㅏ': 'k',
 'ㅐ': 'o',
 'ㅑ': 'i',
 'ㅒ': 'O',
 'ㅓ': 'j',
 'ㅔ': 'p',
 'ㅕ': 'u',
 'ㅖ': 'P',
 'ㅗ': 'h',
 'ㅘ': 'hk',
 'ㅙ': 'ho',
 'ㅚ': 'hl',
 'ㅛ': 'y',
 'ㅜ': 'n',
 'ㅝ': 'nj',
 'ㅞ': 'np',
 'ㅟ': 'nl',
 'ㅠ': 'b',
 'ㅡ': 'm',
 'ㅢ': 'ml',
 'ㅣ': 'l',
 'ㄳ': 'rt',
 'ㄵ': 'sw',
 'ㄶ': 'sg',
 'ㄺ': 'fr',
 'ㄻ': 'fa',
 'ㄼ': 'fq',
 'ㄽ': 'ft',
 'ㄾ': 'fx',
 'ㄿ': 'fv',
 'ㅀ': 'fg',
 'ㅄ': 'qt'
}

이후 각 자음, 모음에 대응되는 영어 알파벳을 설정했다.

예시로 'ㄱ'의 경우 'r', 'ㅆ'의 경우 'T' 이런 방식으로 설정했다.

def is_hangeul_syllable(ch):
    '''한글 음절인지 검사
    '''
    if not isinstance(ch, str):
        return False
    elif len(ch) > 1:
        ch = ch[0]

    return 0xAC00 <= ord(ch) <= 0xD7A3

다음으로 한글 음절인지 검사하는 is_hangeil_syllable 함수를 만들었다.

이 함수는 간단하게 유니 코드를 이용해서 현재 음절이 한글 음절인지 확인하는 방식으로 만들었다.

def compose(cho, jung, jong):
    '''초성, 중성, 종성을 한글 음절로 조합
    cho : 초성
    jung : 중성
    jong : 종성
    return value: 음절
    '''
    if not (0 <= cho <= 18 and 0 <= jung <= 20 and 0 <= jong <= 27):
        return None
    code = (((cho * 21) + jung) * 28) + jong + 0xAC00

    return chr(code)

그 다음으로 초성, 중성, 종성을 조합해서 하나의 음절로 만들어 주는 compose 함수를 만들었다.

이 역시 유니 코드를 이용해서 작성을 했다.

#input: 음절
#return: 초, 중, 종성
def decompose(syll):
    '''한글 음절을 초성, 중성, 종성으로 분해
    syll : 한글 음절
    return value : tuple of integers (초성, 중성, 종성)
    '''
    if not is_hangeul_syllable(syll):
        return (None, None, None)

    uindex = ord(syll) - 0xAC00

    jong = uindex % 28
    jung = ((uindex - jong) // 28) % 21
    cho = ((uindex - jong) // 28) // 21

    return (cho, jung, jong)

초성, 중성, 종성을 하나의 음절로 조합하는 기능이 있다면 반대로 하나의 음절을 초성, 중성, 종성으로 나누어주는 decompose 함수도 만들었다.

이 함수는 위에 있는 compose 함수를 살짝만 수정하면 만들 수 있다.

def str2jamo(str):
    '''문자열을 자모 문자열로 변환
    '''
    jamo = []
    for ch in str:
        if is_hangeul_syllable(ch):
            cho, jung, jong = decompose(ch)
            jamo.append( _CHO_[cho])
            jamo.append( _JUNG_[jung])
            if jong != 0:
                jamo.append( _JONG_[jong-1])
        else:
            jamo.append(ch)
    return ''.join(jamo)

이제 본격적으로 영타를 한국어로 바꾸는 작업을 시작할 예정이다.

먼저 문자열을 한글 자음, 모음 문자열로 변환하는 str2jamo 함수를 만들었다.

문자열을 입력 받았을 때, 각 문자열의 글자마다 먼저 한글 음절인지 확인하고 한글 음절이면 decompose를 통해 음절로 분해 시키는 작업을 한다.

이후 각 음절을들 모와 return 시키는 작업을 했다.

def jamo2engkey(jamo):
    engkey = []
    for ch in jamo:
        if ch in _JAMO2ENGKEY_:
            engkey.append(_JAMO2ENGKEY_[ch])
        else:
            engkey.append(ch)
    return ''.join(engkey) #ekfrrhrl

다음으로 자음, 모음을 영타로 바꾸는 jamo2engkey 함수를 만들었다.

우리가 앞에서 JAMO2ENGKEY dictionary를 만들었기 때문에 이 dictionary를 이용해서 쉽게 변환할 수 있다.

def engkey2jamo(engkey):
    inv_dict = {v: k for k, v in _JAMO2ENGKEY_.items()}
    jamo = []
    for eng in engkey:
        if eng in inv_dict:
            jamo.append(inv_dict[eng])
        else:
            jamo.append(eng)
    return ''.join(jamo)  #ㄷㅏㄹㄱㄱㅗㄱㅣ 

자음, 모음을 영타로 바꾸는 jamo2engkey와 만대로 영타를 자음, 모음으로 바꾸는 engkey2jamo 함수 또한 만들었다.

def jamo2syllable(jamo):
    inv_dict = {v: k for k, v in _JAMO2ENGKEY_.items()}
    cjj = []
    res =[]
    first_mo = []
    first_ja = []
    for ch in jamo:
        if ch in _JAMO2ENGKEY_:
            if len(cjj) == 0 and ch in _CHO_: #초성
                cjj.append(ch)
                if len(first_mo) == 1:
                    res.append(first_mo[0])
                elif len(first_mo) == 2:
                    double_eng = jamo2engkey(first_mo[0] + first_mo[1])
                    if double_eng in inv_dict:
                        double_jung = inv_dict[double_eng]
                        res.append(double_jung)
                    else:
                        res.append(first_mo[0])
                        res.append(first_mo[1])
                first_mo = []
                first_ja.append(ch)

            elif len(cjj) == 0 and ch in _JUNG_:
                first_mo.append(ch)

            elif len(cjj) == 1 and ch in _JUNG_: #중성
                cjj.append(ch)

                if len(first_ja) == 2:
                    res.append(first_ja[0])
                first_ja = []

            elif len(cjj) == 1 and ch not in _JUNG_: #중성 아닐 때
                first_ja.append(ch)
                cjj = []
                cjj.append(ch)

            elif len(cjj) == 2 and ch in _JUNG_: #겹모음 (중성)
                double_eng = jamo2engkey(cjj[1]+ch)
                if double_eng in inv_dict:
                    double_jung = inv_dict[double_eng]
                    cjj[1] = double_jung
                else:
                    res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), 0))
                    first_mo.append(ch)
                    cjj = []
                    first_ja = []

            elif len(cjj) == 2 and ch in _CHO_ and ch not in _JONG_: #무조건 초성
                res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), 0))
                cjj = []
                cjj.append(ch)
                first_ja = []
                first_ja.append(ch)

            elif len(cjj) == 2 and ch in _JONG_: #초성 또는 종성 일단 종성간주
                cjj.append(ch) #길이 3됨

            elif len(cjj) == 3 and ch in _JUNG_: #이러면 종성이 아니라 초성
                res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), 0)) #cjj index 1까지만 res에
                cho = cjj[2]
                cjj = []
                cjj.append(cho)
                cjj.append(ch)
                first_ja = []

            elif len(cjj) == 3 and ch in _CHO_ and ch not in _JONG_: #무조건 초성
                res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1)) #결과로 넘기고(초, 중, 종) 다 존재
                cjj = []
                cjj.append(ch)
                first_ja = []
                first_ja.append(ch)

            elif len(cjj) == 3 and ch in _JONG_: #일단 종성 간주 (종성이면 겹받침)
                cjj.append(ch)

            elif len(cjj) == 4 and ch in _JUNG_: #종성이 아니라 초성
                res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1)) #index 2까지만 res에
                cho = cjj[3]
                cjj = []
                cjj.append(cho)
                cjj.append(ch)
                first_ja = []

            elif len(cjj) == 4 and ch not in _JUNG_: #겹받침
                double_eng = jamo2engkey(cjj[2]+ cjj[3])
                first_ja = []
                if double_eng in inv_dict:
                    double_jong = inv_dict[double_eng]
                    cjj[2] = double_jong
                    del cjj[3]
                    res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1)) #res 저장
                else:
                    res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1))
                    first_ja.append(cjj[3])
                cjj = []
                cjj.append(ch)
                first_ja.append(ch)

            if len(first_mo) == 2:   
                double_eng = jamo2engkey(first_mo[0] + first_mo[1])
                if double_eng in inv_dict:
                    double_jung = inv_dict[double_eng]
                    res.append(double_jung)
                    first_mo = []
                else: 
                    res.append(first_mo[0])
                    first_mo[0] = first_mo[1]
                    del first_mo[1]

            if len(first_ja) == 3:
                double_eng = jamo2engkey(first_ja[0] + first_ja[1])
                if double_eng in inv_dict:
                    double_cho = inv_dict[double_eng]
                    res.append(double_cho)
                    first_ja[0] = first_ja[2]
                    del first_ja[2]
                    del first_ja[1]
                else:
                    res.append(first_ja[0])
                    first_ja[0] = first_ja[1]
                    first_ja[1] = first_ja[2]
                    del first_ja[2]

        else:   #한글 아닌 경우
            if len(cjj) == 1 and len(first_ja) == 0:
                res.append(cjj[0])
            if len(cjj) == 2:
                res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), 0))
            elif len(cjj) == 3:
               res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1))
            elif len(cjj) == 4:
                double_eng = jamo2engkey(cjj[2]+ cjj[3])
                if double_eng in inv_dict:
                    double_jong = inv_dict[double_eng]
                    cjj[2] = double_jong
                    del cjj[3]
                    res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1)) #res 저장
                else:
                    res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1))
                    res.append(cjj[3])
                cjj = []
                cjj.append(ch)

            if len(first_mo) == 2:   
                double_eng = jamo2engkey(first_mo[0] + first_mo[1])
                if double_eng in inv_dict:
                    double_jung = inv_dict[double_eng]
                    res.append(double_jung)
                else: 
                    res.append(first_mo[0])
                    res.append(first_mo[1])
            elif len(first_mo) == 1:
                res.append(first_mo[0])

            if len(first_ja) == 2:
                double_eng = jamo2engkey(first_ja[0] + first_ja[1])
                if double_eng in inv_dict:
                    double_cho = inv_dict[double_eng]
                    res.append(double_cho)
                else:
                    res.append(first_ja[0])
                    res.append(first_ja[1])
            elif len(first_ja) == 1:
                res.append(first_ja[0])

            res.append(ch)
            cjj = []
            first_mo = []
            first_ja = []

    if len(cjj) == 1 and len(first_ja) == 0:
        res.append(cjj[0])
    elif len(cjj) == 2:
        res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), 0))
    elif len(cjj) == 3:
        res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1))
    elif len(cjj) == 4:
        double_eng = jamo2engkey(cjj[2]+ cjj[3])
        if double_eng in inv_dict:
            double_jong = inv_dict[double_eng]
            cjj[2] = double_jong
            del cjj[3]
            res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1)) #res 저장
        else:
            res.append(compose(_CHO_.index(cjj[0]), _JUNG_.index(cjj[1]), _JONG_.index(cjj[2])+1))
            res.append(cjj[3])
        cjj = []
        cjj.append(ch)

    if len(first_mo) == 2:   
        double_eng = jamo2engkey(first_mo[0] + first_mo[1])
        if double_eng in inv_dict:
            double_jung = inv_dict[double_eng]
            res.append(double_jung)
        else: 
            res.append(first_mo[0])
            res.append(first_mo[1])
    elif len(first_mo) == 1:
        res.append(first_mo[0])

    if len(first_ja) == 2:
        double_eng = jamo2engkey(first_ja[0] + first_ja[1])
        if double_eng in inv_dict:
            double_cho = inv_dict[double_eng]
            res.append(double_cho)
        else:
            res.append(first_ja[0])
            res.append(first_ja[1])
    elif len(first_ja) == 1:
        res.append(first_ja[0])

    return ''.join(res)

마지막 요소이자 가장 핵심이라고 볼 수 있는 jamo2syllable에 대해서 알아보자.

이 함수는 자음, 모음을 한국어 단어로 변환해주는 함수이다.

일단 기본적으로 코드가 엄청 길기 때문에 어떻게 구성되어 있는지를 중심으로 설명할 예정이다.

먼저 우리가 입력 받은 자음과 모음이 한글인지 아닌지 확인하는 작업이 필요하다.

만약 한글이라면, 주어진 자음과 모음을 이용해서 단어를 만들면 되는데 한 음절을 만드는 방법에는 총 4가지의 경우의 수가 있다.

먼저 첫 번째로 [아, 이, 우, 에, 오]와 같이 하나의 모음으로만 구성되어 있는 경우가 있고

두 번째로 [가, 차, 수, 거, 레]와 같이 자음이 먼저 나오고 다음으로 모음이 나오는 경우가 있고

세 번째로 [알, 임, 왕, 옆, 옛]과 같이 모음이 먼저 나오고 다음으로 자음이 나오는 경우가 있고

마지막 네 번째로 [강, 숲, 땅, 삶, 창]과 같이 자음, 모음, 자음으로 나오는 경우가 있다.

나는 이 네 가지 경우의 수를 기준으로 코드를 작성했다.

특히 [땅, 삶]과 같이 겹자음이나 쌍자음이 나오는 경우도 하나 하나 다 계산을 해야 한다.

def a(line):
    line = line.rstrip()
    # 문자열을 자모 문자열로 변환 ('닭고기' -> 'ㄷㅏㄺㄱㅗㄱㅣ')
    jamo_str = str2jamo(line)
    key_str = jamo2engkey(jamo_str)
    jamo_str = engkey2jamo(key_str)
    syllables = jamo2syllable(jamo_str)

    return (syllables)

마지막으로 우리가 지금까지 만든 함수들을 하나의 함수에 합치면 완성이다.

우리가 흔히 영타를 한국어로 바꾸는 일이 많기도 하고 익숙하기 때문에 코드로 쉽게 구현이 가능할 것 같다고 생각했는데 생각보다 음절을 만드는 규칙이 다양하고 까다로워서 많이 애를 먹었다.

만약 나처럼 영타를 한국어로 바꾸는 일이 필요하면 이 코드를 그대로 사용하면 될 것 같다.

위 사진에 나온 것처럼 인터넷에서 ffmpeg를 설치하고 난 이후 설치된 곳이 어디인지 미리 파악해 둬야 한다.

이제 본격적으로 tts 음성 녹음을 시작해 보자.

from gtts import gTTS
from pydub import AudioSegment
import simpleaudio as sa

먼저 gtts와 pydub, simpleaudio를 install 해준다.

# ffmpeg 경로 설정
AudioSegment.converter = "ffmpeg.exe"

다음으로 ffmpeg 경로를 converter에 넣어준다.

# 리스트 안에 있는 문장들
sentence =  "안녕하세요 저는 자전 웹사이트 안내 데스크 김자전이라고 합니다. 무엇을 도와드릴까요? 1번 전공 탐색하기. 2번 졸업 요건 확인하기. 3번 교수님 정보 찾기. 4번 종료하기."

이후 내가 만들고 싶은 음성의 내용은 sentence에 저장한다.

기본 밑 작업은 이 정도로 해주고 음성 녹음을 시작해 보자.

 # gTTS로 문장을 음성 파일로 변환
tts = gTTS(text=sentence, lang='ko')
filename = "temp.mp3"
tts.save(filename)

일단 gTTS를 이용해서 tts 변수에 내가 녹음하고 싶은 문장과 언어를 선택한다.

이후 음성 파일의 이름을 filename에 저장한 뒤 tts에 filename을 넣는다.

audio = AudioSegment.from_mp3(filename)

그다음으로 filename에 있는 mp3 정보를 읽어 AudioSegment 객체로 변환하는 작업을 실행해 준다.

# MP3를 WAV 데이터로 변환
wav_data = audio.raw_data
num_channels = audio.channels
bytes_per_sample = audio.sample_width
sample_rate = audio.frame_rate

이후 mp3를 WAV 데이터로 변환하는 작업을 실행한다(위에 있는 코드는 굳이 하나하나 의미를 파악해서 이해할 필요는 없는 것 같고 이런 과정이 필요하구나 정도로 알고 있으면 될 것 같다.)

# WAV 데이터를 simpleaudio로 재생
play_obj = sa.play_buffer(wav_data, num_channels=num_channels, bytes_per_sample=bytes_per_sample, sample_rate=sample_rate)
play_obj.wait_done()  # 재생이 끝날 때까지 대기

마지막으로 WAV 데이터를 simpleaudio로 재생하면 된다.

from gtts import gTTS
from pydub import AudioSegment
import simpleaudio as sa

# ffmpeg 경로 설정
AudioSegment.converter = "ffmpeg.exe"

# 리스트 안에 있는 문장들
sentence =  "안녕하세요 저는 자전 웹사이트 안내 데스크 김자전이라고 합니다. 무엇을 도와드릴까요? 1번 전공 탐색하기. 2번 졸업 요건 확인하기. 3번 교수님 정보 찾기. 4번 종료하기."

 # gTTS로 문장을 음성 파일로 변환
tts = gTTS(text=sentence, lang='ko')
filename = "temp.mp3"
tts.save(filename)

audio = AudioSegment.from_mp3(filename)

# MP3를 WAV 데이터로 변환
wav_data = audio.raw_data
num_channels = audio.channels
bytes_per_sample = audio.sample_width
sample_rate = audio.frame_rate

# WAV 데이터를 simpleaudio로 재생
play_obj = sa.play_buffer(wav_data, num_channels=num_channels, bytes_per_sample=bytes_per_sample, sample_rate=sample_rate)
play_obj.wait_done()  # 재생이 끝날 때까지 대기

이 코드는 현재 내가 프로젝트에서 사용하고 있는 코드의 일부분이다.

위 과정을 차례대로 수행하면 특정 문장을 읽어주는 tts 음성 파일을 만들 수 있을 것이다.

import openai

먼저 openai를 사용하기 위해선 openai를 install 한 이후 import 해줘야 한다.

# OpenAI API 키 설정
openai.api_key = '###########'

그다음으로 api key를 얻은 이후 그 키를 api_key에 저장해야 한다.

messages = [
    {"role": "system", "content": "You must answer as only 'True' or 'False'"},
    {"role": "user", "content": "너는 이제부터 특정 웹사이트에 있는 안내원의 역할을 해줘야해."},
    {"role": "user", "content": "일단 지금의 너는 다음의 답변을 듣고 '1. 전공 탐색하기', '2. 졸업 요건 확인하기', '3. 교수님 정보 찾기' , '4. 종료하기' 넷 중의 한 가지의 대답을 선택해서 그 대답 맨 앞에 있는 숫자를 말해줘야해. 하지만 만약 다음 답변이 저기에 있는 단어들 모두와 연관이 없다면 '다시 질문해주세요.' 라고 말해줘."},
    {"role": "user", "content": "즉, 너가 대답할 수 있는거는 앞에서 들은 4가지 답변의 번호와 '다시 질문해주세요.' 밖에 없는거야."},
    {"role": "user", "content": question}
]

현재 나는 chat gpt openai를 사용 중이고 chat gpt에게 질문을 하기 위한 messages를 설정하는 중이다.

messages를 좀 더 자세하게 보면 "role"에는 크게 chat gpt에게 직접 설정을 부여할 수 있는 "system"과 내가 직접 질문을 할 수 있는 "user" 2가지가 있다.

그리고 "content"에는 내가 원하는 설정 혹은 질문을 저장하면 된다.

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",  # 사용할 모델 이름
    messages=messages,
    max_tokens=150,  # 원하는 응답 길이 설정
    n=1,
    stop=None,
    temperature=0.7,  # 응답의 창의성 조절
    )

다음으로 실제로 chat gpt를 이용하여 우리가 원하는 답을 얻을 차례이다.

chat gpt에게 질문을 하기 위해 몇 가지 세팅이 필요한데 먼저 model의 경우 내가 실제로 사용할 openai의 model을 구해야 한다. 나 같은 경우 chat gpt를 사용할 예정이기 때문에 'gpt-3.5-turbo'를 사용했다.

다음으로 messages의 경우 위에서 내가 설정한 messages를 넣으면 되고 max_tokens의 경우 chat gpt가 생성할 응답의 최대 토큰을 의미하는데 여기서 토큰은 간단하게 말해서 model이 생성하는 텍스트의 단위라고 보면 된다.

이후 요청 당 생성할 응답의 수를 n에 설정하고 응답 생성을 중단할 토큰의 시퀀스를 stop에 저장하고(나 같은 경우에는 max_token에 도달할 때까지 계속 생성할 수 있도록 None으로 설정) 마지막으로 응답의 창의성을 조절하는 temperature을 설정하면 기본적인 세팅은 끝난다.

reply = response['choices'][0]['message']['content'].strip()

마지막으로 질문을 통해 얻은 정보가 response에 저장되어 있는데 여기에 저장되어 있는 정보는 우리가 편하게 볼 수 있게 정제된 자료가 아닌 순수한 데이터 덩어리이기 때문에 이를 정제하는 작업을 해서 reply에 넣었다.

import openai

# OpenAI API 키 설정
openai.api_key = '###########'

def question_in_beginning(question):

    messages = [
      {"role": "system", "content": "You must answer as only 'True' or 'False'"},
      {"role": "user", "content": "너는 이제부터 특정 웹사이트에 있는 안내원의 역할을 해줘야해."},
      {"role": "user", "content": "일단 지금의 너는 다음의 답변을 듣고 '1. 전공 탐색하기', '2. 졸업 요건 확인하기', '3. 교수님 정보 찾기' , '4. 종료하기' 넷 중의 한 가지의 대답을 선택해서 그 대답 맨 앞에 있는 숫자를 말해줘야해. 하지만 만약 다음 답변이 저기에 있는 단어들 모두와 연관이 없다면 '다시 질문해주세요.' 라고 말해줘."},
      {"role": "user", "content": "즉, 너가 대답할 수 있는거는 앞에서 들은 4가지 답변의 번호와 '다시 질문해주세요.' 밖에 없는거야."},
      {"role": "user", "content": question}
    ]

    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",  # 사용할 모델 이름
        messages=messages,
        max_tokens=150,  # 원하는 응답 길이 설정
        n=1,
        stop=None,
        temperature=0.7,  # 응답의 창의성 조절
    )

    reply = response['choices'][0]['message']['content'].strip()
    return reply

위 코드는 실제로 현재 내가 하고 있는 프로젝트의 일부분이다. 우리가 지금까지 한 과정을 함수로 표현한 이후 우리가 원하는 질문을 question_in_begining에 넣으면 chat gpt를 통해 얻은 정답을 바로 return 할 수 있도록 만들었다.

최근 들어 openai와 llm에 대한 공부를 하고 있는데 직접 공부하면서 이제는 순수하게 코드를 공부하는 것보다 openai를 어떻게 이용해야 하는지에 대한 공부가 더 필요하다고 느끼게 되었다.

이제는 대부분의 코드는 chat gpt와 같은 인공지능이 대신해줄 수 있기 때문에 나는 이런 정보들을 부드럽게 연결하고 효율적으로 이용할 수 있는 방법에 대해서 공부하는 것이 미래에 필요한 능력이라고 생각한다.