간단하게 분석 글을 작성한다.

현재 GPT-4 는 유료 서비스인 ChatGPT plus

구독자에게만 제공되고 있다.

크게 달라진 점을 선요약 하자면 다음과 같다.

• 이미지에 대한 입력이 가능해짐
• 다양한 종류의 시험에서 성적이 향상됨
• 다양한 벤치마크에서의 성능이 향상됨
• 차별적이고 유해한 컨텐츠를 걸러내는 기능이 강화됨

많은 전문가들이 GPT-4의 parameter 수 는

GPT-3 / 3.5 와 큰 차이 없을 것으로 본다.

Parameter 를 증가시켜서 얻을 수 있는 이득이

증가할 computational cost 에 비해 크지 않기 때문일 것이다.

따라서 질의 응답 성능에서는 큰 개선을 느끼기 어려운 대신

일부 기능이 강화되거나 추가되었다.

참고로 GPT-4 역시 대부분 21년 9월까지의

데이터들로 학습되었다.

그러므로 학습되지 않았을만한 내용이나

추론하기 어려운 내용을 묻고 실망하지 말자.

몇번이나 이야기하지만 GPT-4 에

입력되지 않은 정보에 제대로 답할 수 없다.

GPT-4 특징 자세히 설명해봐

효율적인성능 예측이 가능해짐

GPT-4 논문 가장 앞에 나오는 개선점 이며

그만큼 주요한 포커스중 하나 이다.

연구진은 위 그래프를 통해 computing cost 와 loss 사이의

간단한 상관관계를 구할 수 있었다.

GPT-3~4 에 해당하는 모델들은 Computing cost 가

너무 크기때문에 알고리즘 평가, Fine tuning 이 효율적으로 이루어지기 어렵다.

반면, 이러한 상관관계를 이용한다면 Computing cost 가

1000~10000배 적은 모델로원본 모델의 성능을 예측할 수 있다.

즉, GPT-4 는 소형 모델을 이용해 같은 자원으로

더 많은 알고리즘 및 Fine tuning 을 평가할 수 있다.

이 방법을 이용했기때문에 비교적 짧은 시간 안에

GPT-4 가 나올 수 있었을 것이다.

이렇듯 향후 개선을 위해 가장 중요한 포인트 인데

아직까지 제대로 설명한 기사나 분석글 은 없었다.

참고로 openai 의 모델에 대해 보다 효율적인 벤치마킹을

할 수 있도록 evals라는 프레임워크를 오픈소스로 공개했다.

해당 툴을 이용해 일반 사용자들도 자유롭게

새로운 평가 기준, 방법을 제시할 수 있다.

추론성능이 강화됨

위 그래프에서 볼 수 있듯이 대다수의 시험에서

성적이 개선되었다.

정확히 어떤 부분이 개선되었는지는

다음 예제를 통해 유추할 수 있다.

같은 질문에 대해 GPT-3.5 는 그럴듯하지만 틀린 답을

GPT-4 는 정확한 답을 내놓았다.

이 예제에서 볼 수 있듯이 GPT 모델은 실제로

지능이 있는 건 아니기 때문에 추론 문제에 취약했다.

정확한 방법은 설명 되지 않았지만 GPT-4 에서는

특정 유형의 추론 문제에 대해 학습이 이루어진 것으로 보인다.

따라서 학습된 형태의 문제에 대해서는

비교적 정확한 답변이 가능하다.

이미지에 대한 입력이 가능해짐

질문) What is funny about this image? Describe it panel by panel.

VGA 커넥터의 외관을 사용한 라이트닝 케이블 사진을

어느정도 이해하고 설명했다.

이외에도 간단한 문제의 diagram 이나

카툰 에 대한 분석, 답변이 가능하다.

이와 같이 GPT-4는 사진 상 물체의classification &location이

가능하고 이를 통해 상황을 추론할 수 있다.

물론, 이번에 도입되는 기능인 만큼 일부 데이터셋 에서는

현재 최고 기술 보다 성능이 떨어진다.

8개의 데이터셋에 대해 accuracy가 평균적으로 68%에서 76%로 향상되었으나

2개의 데이터 셋에서는 7% 가량 하락하였다.

다양하게 활용할 수 있겠지만

선공개된 기능에는 포함되지 않았다.

이외의 소소한 개선

입력가능한 토큰이 최대 8k개로 증대 되었고

별도 모델을 사용할 경우 최대 32k개(단어 25k개)까지 가능하다.

예전보다 긴 문서의 번역이나 요약에 활용할 수 있다.

보다 세세한 역할 부여가 가능해졌다.

예제에서는 답을 직접적으로 알려주지 않는튜터,

셰익스피어처럼 말하는 해적 등을 보여주었다.

마지막으로 필터링 우회를 방지하기 위한 기술이 추가되었다.

상당 수 막은것으로 보이나 아직 완벽하지는 않다.

그럼 GPT-4 의 한계점은 뭐야?

거짓 답변을 내놓는 Hallucination에 대한 성능이

개선되었지만 아직 완전히 잡지는 못했다고 한다.

참고로 GPT-4 역시 대부분 21년 9월까지의

이야기도 있다.

참고로 GPT-4 역시 대부분 21년 9월까지의

데이터들로 학습되었다.

그러므로 학습되지 않았을 내용이나 추론하기 어려운 내용을 물으면

당연히 이상한 답변이 나온다.

GPT-4 의 성능이 안좋거나 한계점 이 아니라

그냥 사용자가 이상한 질문을 한것이다.

참고로 다국어 입력에 대한 성능도 강화되었지만

성능차이는 여전하기때문에 가능하면 영어로 질문하라.

유해하거나 차별적, 공격적인 컨텐츠에 대한

필터링이 강화되었으나 문제는 그 과정에 있다.

타임지에 따르면 해당 작업은 케냐의 노동자들에게

아웃소싱되었고 2$의 시급이 지불되었다.

케냐의 평균 임금과 비교했을 때 시급이 높은 편이지만

업무강도 및 정신적 고통이 상당했다고 한다.

기존에는 텍스트만 판별했다면 2월부터는 유해 이미지까지

판별하게 만들어 고통이 가중되었다.

결국, openAI 는 해당 아웃 소싱업체와의

계약을 예정보다 일찍 끝마쳤다.

최근 다양한 분야에서 공정 무역 에 대한 관심이

커진 만큼 이에 대한 대책이 필요하다.

GPT-4 API 는 언제 나와?

python api 는 아직 공개되지 않았고

대신 알림메일을 발송해준다고 하니 등록하자.

기본 모델도 가격이 비싸지만 32k 모델은 그것보다 2배비싸다.

참고로 gpt-3.5-turbo 는 1k 토큰당 0.002$

gpt-3.5 ( 다빈치 )는 0.02$이었다.

그리고 기본적으로 분당 토큰 40k개 &요청 200개의 리밋이 걸려있다.

마지막으로 개발자의 라이브스 데모를 첨부하며 글을 마친다.

관련글

• chat GPT 하이브리드 앱 만들기 C# python
• GPT3.5 Turbo – ChatGPT python API 소개
• chatGPT 한계점과 대체재에 대해
• GPT-3.5 python에서 사용하기
• 빙 생성 AI 까지 넘보는 중

The post GPT-4 뭐가 달라 졌을까? appeared first on JIN's BOT.

한두번 사용하기엔 상관없지만

매번 python 파일을 수정하는 건 번거롭고 바람직하지 않다.

간단하게 터미널에서 입력을 받아도 되지만

자유도, 활용도를 높이기 위해 GUI 를 구축해보자.

GUI 글에서 언급 했던 것처럼 웹앱을 만들어도 되지만

이번에는 데스크탑 앱을 만들어 보겠다.

그리고 보통 많이 사용되는 tkinter 나 PyQt 가 아니라

C# ( 닷넷 ) 을 활용해보자.

Python 으로 C#앱을 만든다고?

pythonnet 패키지를 이용하면

파이썬 에서 C# 코드를 간단하게 사용할 수 있다.

하지만 Windows Forms 까지 사용해본 사람은 드물 것이다.

다음에 해당하는 사람에게 이 가이드를 추천한다.

• Visual Studio (닷넷) 를 써보았다.
• C# 앱을 개발해봤다.
• tkinter 보다 복잡한 레이아웃을 만들고 싶다.
• 바이너리 크기를 최소화 하고 싶다.

이 방식은 기본적으로 닷넷 프레임워크를 사용하기때문에

바이너리 크기가 작은 장점이 있다.

기본적으로 간단한 UI는 CLI 환경에서

개발하는걸 추천한다.

만약 복잡한 UI를 개발할 거라면 Visual Studio로

UI 코드를 만든 후 포팅하길 바란다.

Chat GPT 앱 코드

설치 되어야 하는 필수 패키지는 다음과 같다.

• pythonnet

c함수 사용을 위한 ctypes 는 표준 함수라

설치 안해도 되지만 pythonnet ( c# ) 은 별도로 설치해야한다.

UI를 정의하는코드와 실행 코드를 나누었다.

우선 UI 코드를 설명하겠다.

#myform.py
import clr
clr.AddReference("System.Windows.Forms")
clr.AddReference('System.Drawing')
clr.AddReference('System')
from System.Windows.Forms import *
from System.Drawing import *

from concurrent.futures import ThreadPoolExecutor
import requests

# chatGPT
URL = "https://api.openai.com/v1/chat/completions"
headers = {"Authorization": "Bearer 발급받은API키",
           "Content-Type": "application/json"}


def task(form):
    if form.query != '':
        messages = [{"role": "system", "content": "You are a helpful assistant."}]
        if form.assist != '':
            messages.append({"role": "assistant", "content": form.assist})
            form.log.write(f'Assist:{form.assist}\n')
        messages.append({"role": "user", "content": form.query})
        Data = {"model": "gpt-3.5-turbo", "messages": messages, "temperature": form.temp,
                "max_tokens": form.max_token}
        res = requests.post(URL, headers=headers, json=Data)
        form.answer = res.json()['choices'][0]['message']['content']

        form.log.write('Q:' + form.query + "\n")
        form.log.write('A:')
        form.log.writelines(form.answer + "\n")
        form.log.write("\n")
        form.abox.Text = form.answer
        print('result arrived')
    else:
        MessagBox.Show("Query is empty")


class MyForm(Form):
    def __init__(self, temp, max_token, lq, la, log):
        self.log = log
        self.temp = temp
        self.max_token = max_token
        self.lq = lq
        self.la = la
        self.exe = ThreadPoolExecutor(max_workers=2)
        super().__init__()
        c_w = 1000
        c_h = 1000

        self.ClientSize = Size(c_w, c_h)

        self.pn = TableLayoutPanel()
        self.pn.RowCount = 3
        self.pn.ColumnCount = 1
        self.pn.ColumnStyles.Add(ColumnStyle(SizeType.Percent, 100.0))
        self.pn.RowStyles.Add(RowStyle(SizeType.Percent, 10.0))
        self.pn.RowStyles.Add(RowStyle(SizeType.Percent, 20.0))
        self.pn.RowStyles.Add(RowStyle(SizeType.Percent, 70.0))
        self.pn.Dock = DockStyle.Fill

        self.pn1 = TableLayoutPanel()
        self.pn1.RowCount = 2
        self.pn1.ColumnCount = 2
        self.pn1.ColumnStyles.Add(ColumnStyle(SizeType.Percent, 50.0))
        self.pn1.ColumnStyles.Add(ColumnStyle(SizeType.Percent, 50.0))
        self.pn1.RowStyles.Add(RowStyle(SizeType.Percent, 20.0))
        self.pn1.RowStyles.Add(RowStyle(SizeType.Percent, 80.0))
        self.pn1.Dock = DockStyle.Fill

        self.pn2 = TableLayoutPanel()
        self.pn2.RowCount = 2
        self.pn2.ColumnCount = 3
        b_width = 7.5
        self.pn2.ColumnStyles.Add(ColumnStyle(SizeType.Percent, b_width))
        self.pn2.ColumnStyles.Add(ColumnStyle(SizeType.Percent, 100 - 2 * b_width))
        self.pn2.ColumnStyles.Add(ColumnStyle(SizeType.Percent, b_width))
        self.pn2.RowStyles.Add(RowStyle(SizeType.Percent, 50.0))
        self.pn2.RowStyles.Add(RowStyle(SizeType.Percent, 50.0))
        self.pn2.Dock = DockStyle.Fill

        self.lbl = Label()
        self.lbl.Text = f'Temperature={temp}'
        self.lbl.TextAlign = ContentAlignment.MiddleCenter
        self.lbl.Dock = DockStyle.Fill
        self.lbl2 = Label()
        self.lbl2.Text = f'Max token={max_token}'
        self.lbl2.TextAlign = ContentAlignment.MiddleCenter
        self.lbl2.Dock = DockStyle.Fill
        self.trb = TrackBar()
        self.trb.Dock = DockStyle.Fill
        self.trb.Maximum = 20
        self.trb.Minimum = 0
        self.trb.TickFrequency = 1
        self.trb.LargeChange = 2
        self.trb.SmallChange = 1
        self.trb.Value = int(temp * 10)
        self.trb.Scroll += self.temp_moved
        self.trb2 = TrackBar()
        self.trb2.Dock = DockStyle.Fill
        self.trb2.Maximum = 1000
        self.trb2.Minimum = 0
        self.trb2.TickFrequency = 100
        self.trb2.LargeChange = 200
        self.trb2.SmallChange = 100
        self.trb2.Value = max_token
        self.trb2.Scroll += self.token_moved

        self.lbl3 = Label()
        self.lbl3.Text = 'Assitant:'
        self.lbl3.TextAlign = ContentAlignment.MiddleCenter
        self.lbl3.Dock = DockStyle.Fill
        self.txtbox = TextBox()
        self.txtbox.Dock = DockStyle.Fill
        self.txtbox.Multiline = True
        self.txtbox.Text = la

        self.lbl3_2 = Label()
        self.lbl3_2.Text = 'Query:'
        self.lbl3_2.TextAlign = ContentAlignment.MiddleCenter
        self.lbl3_2.Dock = DockStyle.Fill

        self.txtbox_2 = TextBox()
        self.txtbox_2.Dock = DockStyle.Fill
        self.txtbox_2.Multiline = True
        self.txtbox_2.Text = lq
        self.button1 = Button()
        self.button1.Text = "Clear"
        self.button1.ForeColor = Color.Black
        self.button1.Dock = DockStyle.Fill
        self.button1.Click += self.clear_clicked
        self.button2 = Button()
        self.button2.Text = "Send"
        self.button2.ForeColor = Color.Black
        self.button2.Dock = DockStyle.Fill
        self.button2.Click += self.send_clicked

        self.abox = TextBox()
        self.abox.Dock = DockStyle.Fill
        self.abox.Multiline = True
        self.Controls.Add(self.pn)
        self.pn1.Controls.Add(self.lbl, 0, 0)
        self.pn1.Controls.Add(self.lbl2, 1, 0)
        self.pn1.Controls.Add(self.trb, 0, 1)
        self.pn1.Controls.Add(self.trb2, 1, 1)

        self.pn2.Controls.Add(self.lbl3, 0, 0)
        self.pn2.Controls.Add(self.txtbox, 1, 0)
        self.pn2.Controls.Add(self.button1, 2, 0)
        self.pn2.Controls.Add(self.lbl3_2, 0, 1)
        self.pn2.Controls.Add(self.txtbox_2, 1, 1)
        self.pn2.Controls.Add(self.button2, 2, 1)

        self.pn.Controls.Add(self.pn1, 0, 0)
        self.pn.Controls.Add(self.pn2, 0, 1)
        self.pn.Controls.Add(self.abox, 0, 2)

    def run(self):
        Application.Run(self)

    def send_clicked(self, sender, args):
        self.assist = self.txtbox.Text
        self.query = self.txtbox_2.Text

        self.exe.submit(task, self)

    def clear_clicked(self, sender, args):
        self.txtbox.Clear()
        self.txtbox_2.Clear()
        print('Cleared')

    def temp_moved(self, sender, args):
        self.temp = self.trb.Value / 10.0
        self.lbl.Text = f'Temperature={self.temp}'

    def token_moved(self, sender, args):
        self.max_token = int(self.trb2.Value)
        self.lbl2.Text = f'Max Token={self.max_token}'

task 함수에서 쿼리 요청 및 수신을 처리하고

수신된 결과를 로그에 기록한다.

사용되는 메세지의 구조 는 이전글을 참고하라.

ThreadpoolExecutor ( 멀티 스레드 ) 를 사용해

task 함수는 UI 와 별도 스레드에서 실행 된다.

Async 로도 짜보았지만 수신에 시간이 걸릴 경우

UI 스레드가 freeze 된다.

Qthread 처럼 System.Threading 의

Thread함수를 사용해도 된다.

init 함수에서 UI 요소를 설정하는 건

C# 과 동일하며 코드도 거의 일치 한다.

TableLayoutPanel 을 이용해 레이아웃을 만들었고

TrackBar , Label , Button , TextBox 를 사용했다.

각 함수의 초기화 코드 및 사용법은 인터넷에

잘 나오니 따로 설명하지 않겠다.

버튼, 트랙바에 사용되는 callback 함수도

코드에 나온대로 매우 간단하게 짤 수 있다.

실행 코드는 더욱 더 간단하다.

#Only for python embed
import sys
sys.path.append('.')

import csv
from myform import MyForm

log=open('log.txt','a+')
try:
    f=open('cfg.csv','r')
    r=csv.DictReader(f,delimiter=';')
    cfg=dict(r.__next__())
    f.close()
    temp=float(cfg['Temperature'])
    max_token=int(cfg['MaxToken'])
    lq=cfg['LastQuery']
    la=cfg['LastAssist']
except:
    temp=0.1
    max_token=100
    lq=''
    la=''
a=MyForm(temp,max_token,lq,la,log)
a.run()
a.Dispose()
if hasattr(a,'query'):
    with open('cfg.csv','w') as f:
        wr=csv.DictWriter(f,fieldnames=["Temperature","MaxToken","LastQuery","LastAssist"],delimiter=';')
        wr.writeheader()
        wr.writerow({"Temperature":a.temp,"MaxToken":a.max_token,"LastQuery":a.query,"LastAssist":a.assist})
log.close()
print('')

path.append는 embeddable python 에만 필요하다.

그리고 필수적인 요소는 아니지만 참고를 위해

cfg.csv에 마지막으로 사용한 쿼리를 저장한다.

Assistant에 입력할 내용은 사전정보나

chat GPT 의 이전 답변이며 비워두어도 된다.

Query 에 질문을 적으면 된다.

로그 파일에 쿼리 들 과 답변을 기록한다.

이정도면 chat GPT 의 GUI 하이브리드 앱

코드에 대한 충분한 설명이 되었으리라 본다.

이 앱 은 openai 에 로그인 하기 귀찮은 사람이나

차단된 곳에서 활용하기 유용할 것이다.

30분만에 대충 짠 코드이니 UI, 성능에 대한

최적화는 직접 해보길 바란다.

(23.08.17 update)

Textbox에서는 \n 대신 \r\n을 사용해야한다.

이전글

• GPT3.5 Turbo – ChatGPT python API 소개
• chatGPT 한계점과 대체재에 대해
• GPT-3.5 python에서 사용하기( Temperature 에 대한 설명)
• GUI 라이브러리 소개 python
• GPT-4 뭐가 달라 졌을까?
• 빙 생성 AI 까지 넘보는 중

The post chat GPT 하이브리드 앱 만들기 C# python appeared first on JIN's BOT.

순수 GUI 라이브러리

• PyQt, PySide

QT는 본래 C++ 환경에서 사용가능하게 만들어진 프레임워크이다.

Qt Designer를 통해 Visual studio 처럼 GUI환경에서 UI를 만들 수 있는게 특징이다.

리눅스, 윈도우 등 크로스 플랫폼으로 사용할 수 있고

python, ruby 등의 언어와 붙일 수 있다는게 장점이다.

이중 python bindg인PyQt는 python에서

가장 대중적인 GUI 라이브러리 중 하나이다.

따라서 예제가 풍부하고 사용도 간편한 장점이 있지만

GPL 에 의해 배포시 소스코드를 공개해야하며 싫다면

상업용 라이센스를 구매,구독해야한다.

이에 반하여 Qt의 원저작자가 LGPL로 만든것이 PySide이다.

자세한 내용은 꺼무위키를 참고하길 바란다.

그러므로 배포할 계획이 있다면 제약이 적은  PySide를 사용하는게 바람직하다.

참고로 두 라이브러리는 사용법이 거의 같지만 관리하는 주체가 다르다.

• Tkinter

Tkinter 는 PyQT 와 함께 가장 많이 사용되는

GUI 라이브러리 중 하나이다.

Python 표준 라이브러리 에 해당하기때문에

Windows에서는 Python 설치시 같이 설치된다.

리눅스와, 윈도우, 맥 에서 사용가능하며   QT에 비해 저용량, 저사양이다.

실행파일의 크기도 작고 실행속도도 빠르기때문에

간단한 python 앱을 만들 때 자주 사용된다.

그러나 CLI 환경에서 디자인 해야하고 투박하며 기본 tkinter 의 편의성이 떨어진다.

예를 들어 표의 기능을 사용하고 싶다면 tksheet이라는

애드온 라이브러리를 설치해야 한다.

이외에도 wxPython, Kivy 등의 라이브러리가 많이 사용된다.

요즘 대세 = 웹앱

최근에는 위와 같은 전통적인 GUI 라이브러리보다

대시보드 형태의 웹앱 라이브러리가 각광 받고 있다.

• Dash

Dash는 flask, Plotly, React 등을 활용해 만들어진 GUI 라이브러리다.

잘 꾸밀 경우 상당히 유려하고 다양한 기능을 제공하며

SPA(Single Page Application) 라이브러리  중 가장 인지도가 높다.

그런 만큼 예제도 풍부하고 문서화도 잘 되어있다.

다만 Tkinter 처럼 CLI환경에서 디자인을 해야하고

HTML에 대한 지식이 약간 필요한게 단점이다.

또, 구성 요소가 많아질 경우 예쁘게 배치하는게 까다롭거나 번거롭다.

그래도 속도 하나만큼은 후술할 라이브러리에 비해서 빠르기때문에

대량의 데이터를 plot 하거나 Rendering 할 때 유리하다.

정적인 이미지 파일로도 export 가능하지만 Jupyterlab, 웹앱 등으로

interactive graph 를 그릴 때 가장 빛을 발한다.

• Streamlit

Dash와 비슷한 친구인데 사용법이 좀 더 간편하다.

사용자도 계속 늘어 Dashboard 계열 GUI 라이브러리 중

가장 관심받는 신성이다.

Dash보다 좀 더 간단한 그래프, 표를 나타나는데 적합하며

HTML에 대해 잘 몰라도 상관없다.

다만 설치 시 많은 의존성을 가지기 때문에 배포시 문제가 될 수 있다.

그리고 streamlit 앱 (streamlit.cli) 을 통해 실행되기때문에

이에 대한 설정, 디버깅이 번거롭다.

• Bokeh

Dash 와 유사한 라이브러리로 Panel, Dask 등을 이용해

다양한 기능을 제공한다.

기본 레이아웃들이 Dash에 비해 유려하지만

특색있고 예쁘게 customize 하기는 어렵다.

반면 Dash는 html 과 React 를 이용해 만들어졌기때문에

전문가가 붙으면 빠르고 쉽게 꾸밀 수 있다.

Bokeh는 Jupyterlab에 좀더 특화되었고 Dash는 웹앱에

좀 더 장점을 가진다.

수만개 이상의 데이터를 plot할 때는 Dash보다 상당히 느리다.

현재의 github stars , 다운로드는 링크를 참고하라.

다음에는 Dash 를 이용한 GUI 구축에 대해 적겠다.

python 관련글

• 30분만에 나스닥 기업 주가 예측
• GPT-3.5 python에서 사용하기
• GPT3.5 Turbo – ChatGPT python API 소개
• chat GPT 하이브리드 앱 만들기 C# python

The post GUI 라이브러리 소개 python appeared first on JIN's BOT.

그리고 ChatGPT 의 모델인 GPT3.5 Turbo 가 드디어 공개되었다.

이에 따라 변경된 python 사용법, 특징에 대해 소개하겠다.

GPT3.5 Turbo python 코드

openai 패키지를 설치하거나 업데이트 후에

다음과 같이 사용한다.

import openai
openai.api_key ="발급받은 API키"
completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo", 
  messages=[{"role": "user", "content": "Tell the world about the ChatGPT API in the style of a pirate."}]
)
print(completion)

기존 Completion 에서 ChatCompletion 으로 바뀌었고

model이 gpt-3.5-turbo 로 바뀌었다.

마지막으로 prompt 가 messages로 바뀌었고

role이라는 인자가 추가되었다.

자세한 내용은 custom API 로 추가 설명하겠다.

import requests
import json
headers={"Authorization":"Bearer 발급키","Content-Type":"application/json"}
link="https://api.openai.com/v1/chat/completions"
messages=[        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who won the world series in 2020?"},
        {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
        {"role": "user", "content": "Where was it played?"}]
data={"model": "gpt-3.5-turbo", "messages": messages, "temperature": 0.2, "max_tokens": 300}
res=requests.post(link,data=json.dumps(data),headers=headers)
print(res.json()['choices'][0]['message'])

위 예제에서 볼 수 있듯이 이제 message를 복수개 보낼 수 있다.

system을 통해 GPT의 역할을 지정하는 것이고

user 는 사용자의 입력을 나타낸다.

마지막으로 assistant 는 이전 대답 혹은 사전 정보 를 의미한다.

나머지 parameter 는 이전과 동일하니 이전글 혹은

링크를 확인하길 바란다.

GPT3.5 용도

openai 에서는 가이드를 통해 다음과 같은 사용을 추천하고 있다.

• 이메일 이나 문서의 초안 작성
• 파이썬 코드 작성
• 문서에 담긴 정보에 대해 질의 응답
• 챗봇 생성
• 소프트웨어 자연어 인터페이스 추가
• 다양한 주제에 대한 tutor
• 번역
• Simulate characters for video games and much more

번역에 대해서는 다음과 같이 message를 작성하면 된다.

text='텍스트'
messages=[{"role": "user", "content": f'Translate the following English text to Korean: {text}'}]

이전 모델과 차이가 뭐야?

가격이 1/10 수준으로 저렴해졌다.

기존 GPT3.5 모델은 1000토큰 당 0.02$이었지만

GPT3.5 Turbo는 1000토큰 당 0.002$이다.

그리고 추가 학습 ( fine tuning ) 에 대한

API는 아직 공개되지 않았다. ( 23.03.01 기준)

따라서 커스텀 모델이 필요한 경우에는

기존 모델을 사용해야 한다.

그리고 GPT3.5 Turbo 에 입력된 데이터는

30일간 저장된다고 명시 되었다.

데이터 사용에 대한 정책은 다음 링크를 참조하라.

개인 정보를 입력했을 경우 삭제 요청을 할 수 있다.

또, 차별 및 성희롱에 대한 판단 기능을

추가적으로 사용할 수 있으니 다음 가이드를 참고하라.

이외에도 음성 텍스트 변환 및 번역 모델인

Whisper 모델이 개선되었다.

개선 모델의 사용료는 분당 0.006$로 굉장히 저렴하고

다양한 언어와 포맷을 지원한다.

자세한 내용은 다음 링크에서 확인할 수 있다.

GPT3.5 의 경쟁자는?

다른 글에서 meta ( facebook ) 의 OPT 모델에 대한 이야기를 했다.

meta 에서도 최근 새로운 모델인 LLaMA 를 제시했다.

가장 큰 모델이 65B 라 실망할 수도 있지만

학습 방법의 개선으로 성능은 이전 모델보다 뛰어나다고 한다.

논문에 따르면 GPT3 (구모델) 보다 나은 성능을 보인다.

성능 대비 요구 Parameter 가 줄었기 때문에 일부 모델은

3090, 3090S로 구동할 수 있을 것이다.

예를 들어 7B 모델은 max_batch_size를 1로 조정하면

16G VRAM으로 구동 가능하다.

fp8로 정밀도를 희생한다면 13B모델까지

3090에서 구동 가능할 것으로 예상된다.

참고로 LLaMa 의 상업적 사용은 별도의 협의가 필요하다.

아직 GPT3.5 수준에 이르지는 못했지만 둘의 경쟁으로

더 저렴하고 좋은 서비스가 나올 수 있을 것이다.

(23.03.06 updated)

흥미롭게도 LLaMa의 모델이 인터넷상에 유출되었다.

원래도 학술 목적으로는 어렵지 않게 받을 수 있었지만

일반인에게까지 오픈되어 사람들이 열심히 연구중이다.

흥미롭게도 누군가 LLaMa github 에 토렌트 ( 마그넷 ) 주소를

업로드 했으며 Meta에서도 딱히 삭제하지 않고 있다. (링크)

외국 친구들의 반응도 있으니 짤리기 전에 한번 보길 추천한다.

이번 유출로 인해 모델을 받아 손쉽게 customize, 테스트해 볼 수 있다.

관련글

• chatGPT 한계점과 대체재에 대해
• GPT-3.5 python에서 사용하기
• chat GPT 하이브리드 앱 만들기 C# python
• GPT-4 뭐가 달라 졌을까?
• 빙 생성 AI 까지 넘보는 중

The post GPT3.5 Turbo – ChatGPT python API 소개 appeared first on JIN's BOT.

회사에서 주가 예측 과 관련된 코딩 공모전을 열었다.

제대로 인공신경망 모델을 만들기 위해서는

설계, 튜닝에 상당한 시간을 투자해야한다.

현생이 바쁘기 때문에 순위는 일찌감치 포기했다.

다만 구현 난이도가 궁금해서 인터넷 상 코드를 테스트해 보았다.

Github 가 보편화된 이후로 코딩 실력은 필요한 코드를

얼마나 빠르게 찾아 응용할 수 있는지에 달렸다.

다행히 주가 예측 에 대한 코드는 인터넷에 차고 넘친다.

코드 선택 기준

• Tensorflow 로 작성될 것
• VM에서 학습 가능한 복잡도
• 논문 수준의 분석, 설계 필요없음
• 20년도 이후 비교적 최신 코드

많은 코드들 중에 위 조건에 해당하는 코드를 탐색했다.

주가 예측에는 보편적으로 LSTM , GRU , ARIMA 등이 사용되는데

데이터셋의 종류, 형태에 따라 성능이 달라진다.

그리고 LSTM + GRU , LSTM + ARIMA , ARIMA + GRU 처럼

하이브리드로 구성될 때 성능이 향상된다.

이중에서 LSTM + GRU 에 해당하는 코드들을 찾아봤다.

둘 다 RNN이기때문에 hybrid 로 만들기 쉽고

tensorflow 로 구현하기도 쉽다.

Kaggle 원본 코드는 링크로 첨부하니 참고하길 바란다.

본론

모듈 및 데이터 임포트

코드에서 사용되는 모듈들과 설명

• pandas : CSV를 사용하기 쉬운 dataframe , series로 변환,저장
• numpy : 데이터 가공
• sklearn : 학습에 필요한 utility 제공
• tensorflow : 실질적으로 학습을 진행
• matplotlib : plot 에 사용

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import mean_absolute_error
from sklearn.model_selection import train_test_split
import os
os.environ['TF_ENABLE_ONEDNN_OPTS']='0'
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.layers import LSTM, GRU
from keras.callbacks import EarlyStopping,ModelCheckpoint
from sklearn.preprocessing import MinMaxScaler

#import data
org_df={}
dflist=['AAPL','AMD','ATVI','CSCO','EBAY','GOOGL','INTC','MSFT','MU','NTGR','NVDA','SBUX','STX','TSM','WDC']
for i in range(1,16):
    org_df[i]=pd.read_csv(f"/dataset/{dflist[i-1]}.csv")

전처리

우선 데이터를 별도로 어떻게 전처리 할것인지 정해야 한다.

sklearn 에서 제공하는 MinMaxScaler 를 사용해

0에서 1 사이의 값을 가지도록 정규화 했다.

데이터의 노이즈가 심하지 않아 필터는 적용하지않았다.

data는 6개의 column을 가지는데 원본 저자는 종가만 학습에 사용했다.

다른 데이터로 accuracy를 올릴 수도 있지만 학습,튜닝에 오랜시간이 걸린다.

또한 volume을 제외한 column 들은 종가와 유사하기때문에

accuracy를 올리는데 효율적이지 못하다.

단순하게 k개의 사전데이터로 다음 날을 예측하도록 input을 구성했다.

따라서 위 그림 대로 Input 과 Output 데이터를 가공한다.

train set과 validation set을 나누어주기 위해서는 train_test_split을 사용하거나

model.fit에서 validation_split 옵션을 사용하면 된다.

def create_dataset(dataset, time_step=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-time_step-1):
        a = dataset[i:(i+time_step)]    
        dataX.append(a)
        dataY.append(dataset[i + time_step])
    return np.array(dataX), np.array(dataY)

t_step=10
scaler=MinMaxScaler(feature_range=(0,1))
scaled=scaler.fit_transform(np.array(org_df[1]['Close']).reshape(-1,1))
X_train,y_train=create_dataset(scaled,t_step)
# X_train,X_val,y_train,y_val=train_test_split(X_train,y_train,test_size=0.3,random_state=0)

신경망 구축 및 학습

def custom_loss(y_true, y_pred):
    mae = tf.keras.losses.MeanAbsoluteError()
    return mae(y_true, y_pred)/np.mean(abs(y_true))

callbacks = [EarlyStopping(monitor='val_loss',
                                           patience=15,min_delta=0.01),
             ModelCheckpoint(filepath='best_model.h5',
                                             monitor='val_loss',
                                             save_best_only=True, restore_best_weights=True)]
model=Sequential()
model.add(LSTM(32,return_sequences=True,input_shape=(t_step,1)))
model.add(LSTM(32,return_sequences=True))
model.add(Dropout(0.2))

model.add(GRU(32,return_sequences=True))
model.add(Dropout(0.2))

model.add(GRU(32,return_sequences=True))
model.add(GRU(32))
model.add(Dropout(0.2))

model.add(Dense(1))

model.compile(loss=custom_loss,optimizer='adam' , metrics = [ "mae",'mse'],run_eagerly=True)
model.summary()


history=model.fit(X_train,y_train,validation_split=0.3,epochs=100,batch_size=64,verbose=0,callbacks=callbacks)
# history=model.fit(X_train,y_train,validation_data=(X_val,y_val),epochs=100,batch_size=64,verbose=1,callbacks=callbacks)
print('done')

Model: "sequential_6"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 lstm_12 (LSTM)              (None, 10, 32)            4352      
                                                                 
 lstm_13 (LSTM)              (None, 10, 32)            8320      
                                                                 
 dropout_18 (Dropout)        (None, 10, 32)            0         
                                                                 
 gru_18 (GRU)                (None, 10, 32)            6336      
                                                                 
 dropout_19 (Dropout)        (None, 10, 32)            0         
                                                                 
 gru_19 (GRU)                (None, 10, 32)            6336      
                                                                 
 gru_20 (GRU)                (None, 32)                6336      
                                                                 
 dropout_20 (Dropout)        (None, 32)                0         
                                                                 
 dense_6 (Dense)             (None, 1)                 33        
                                                                 
=================================================================

LSTM과 GRU가 같이 배치된 하이브리드 모델이다.

학습의 속도, accuracy는 모델의 배치,shape에도 크게 영향 받으나 절대적인 법칙은 없다.

성능을 보면서 적절하게 변경하면 된다.

원본 코드와 다르게 레이어를 배치해 봤지만 원본대로 하는게 가장 정확도가 높다.

loss는 mse, mae 등 여러가지를 사용할 수 있는데 코드에 나온것처럼

새로운 loss function을 정의해도 된다.

물론, mae와 mse 를 섞는 등 다른 평가 요소를 사용하여 성능을 더 개선할 수 있다.

코드수행에 생각보다 시간이 걸리는데 EarlyStopping callback을 통해

학습을 조기 중단시킬 수 있다.

혹은 processpool executor를 사용하여 수행속도를 올릴 수 있다.

마지막으로 model.fit을 통해 학습을 수행하는데

epochs, batch_size 등 각종 parameter의 튜닝이 필요하다.

이러한 hyper parameter는 keras의 tuner를 사용해도 되고

단순한 반복문을 만들어 기록해도 된다.

verbose를 1로 두면 학습 과정을 지켜볼 수 있습니다.

epoch별 loss값을 지켜보면 학습이 정상진행되는지 알 수 있기때문에 신경망을 설계할 때 유용하다.

다음 코드를 통해 학습이 잘됐는지 plot해보자.

hh=history.history
epochs=range(len(hh['loss']))
plt.plot(epochs,hh['loss'],label='loss')
plt.plot(epochs,hh['val_loss'],label='val_loss')
plt.legend()
plt.show()

loss와 validation_loss가 둘 다 수렴하고 있으므로

학습이 어느정도 잘 이루어지고 있다.

과적합이 일어난다면 신경망의 설계,변수를 바꾸거나

정규화를 변경함으로써 해결할 수 있다.

주가 예측 값 도출

prd={}
nmae={}
day_to_predict=7
for _,i in enumerate(org_df):
    last_data=scaler[i].fit_transform(np.array(org_df[i]['Close'].iloc[-t_step:]).reshape(-1,1))
    prd_list=[]
    for j in range(day_to_predict):
        last_data=last_data[-t_step:]
        prd_temp=models[i].predict(np.array(last_data).reshape(1,t_step[i],1),verbose=0)
        prd_list.append(prd_temp[0][0])
        last_data=np.append(last_data,pd.Series(prd_temp[0][0]))
    prd[i]=scaler[i].inverse_transform(np.array(prd_list).reshape(-1,1))[:,0]
    nmae[i]=my_loss(test_df[i]['Close'][:7],prd[i])
    print(f'{dflist[i-1]} : {nmae[i]}')

print(f'avg={pd.Series(nmae).mean()}')

이제 위 코드를 통해 주가 예측 데이터를 도출한다.

루틴을 간단하게 설명하면 다음과 같습니다.

1. 마지막 k개의 데이터를 input으로 만든다.
2. input을 통해 다음날의 데이터를 예측한다.
3. 예측 데이터를 input 데이터에 덧붙인다.

위 과정을 예측하고 싶은만큼 날만큼 반복하여 loss값을 기록한다.

기록된 loss값이나 평균 loss값으로 학습이 잘 이루어졌는지 확인 가능하다.

주가 예측 결론

AAPL : 0.04620344564318657
AMD : 0.11094651371240616
ATVI : 0.0061081573367118835
CSCO : 0.01842576451599598
EBAY : 0.026052556931972504
GOOGL : 0.03204019367694855
INTC : 0.03417059779167175
MSFT : 0.05612574890255928
MU : 0.008338606916368008
NTGR : 0.02389097958803177
NVDA : 0.0929316058754921
SBUX : 0.015276948921382427
STX : 0.07766019552946091
TSM : 0.02993595041334629
WDC : 0.03140253946185112
avg = 0.04063398440678914

• 평균 오차: 주가의 4~5%
• 소요시간: 코딩 30분 + 학습 30분 (CPU,싱글 코어 기준)

약간의 튜닝으로도 성능을 2~3%까지 개선할 수 있다.

30분짜리 코딩치고 주가 예측 결과가 나쁘지 않다.

강화학습, deep learning 등에서 이론 공부만으로 시간을 버리는 경우가 많다.

Matlab의 Tuner/Optimizer를 쓰면서 알고리즘을 다 이해하는건 아니듯이

알고리즘 이해에 너무 긴 시간을 쏟을 필요 없다.

차라리 kaggle 등에서 실용적인 코드를 찾아 직접 해보는것이 도움이 된다.

여러분들께도 올려드린 코드가 도움이 되길 바란다.

The post 30분만에 나스닥 기업 주가 예측 appeared first on JIN's BOT.