[OpenAI] GPT-4o ๋ค์ ๋ฒ์ ๋ด๋!?
์๋ณธ ๊ฒ์๊ธ: https://velog.io/@euisuk-chung/OpenAI-GPT-4o-๋ค์-๋ฒ์ -๋ด๋
์ต๊ทผ AI์ ๋ฐ์ ์๋๋ ๊ฐํ ๋๋ผ์ธ ์ ๋์ ๋๋ค. ํนํ OpenAI์ ์๋ก์ด ๋ชจ๋ธ GPT-o1์ ๊ธฐ์กด ๋ชจ๋ธ์ธ GPT-4o์ ๋นํด ๊ด๋ชฉํ ๋งํ ์ฑ๋ฅ ํฅ์์ ๋ณด์ฌ์ฃผ๊ณ ์์ต๋๋ค. GPT-o1์ ๋ณต์กํ ์ถ๋ก ์ ๋ ์ ์ํํ๊ณ , ๋ค์ํ ๋ฌธ์ ํด๊ฒฐ ๋ฅ๋ ฅ์์ ์ฌ๋ ์์ค์ ์ฑ๊ณผ๋ฅผ ๋ณด์ฌ์ฃผ๋ฉฐ, ์์ ์ฑ ๋ฉด์์๋ ๋ฐ์ด๋ ์ฑ๊ณผ๋ฅผ ๊ธฐ๋กํ๊ณ ์์ต๋๋ค.
์ด๋ฒ ๊ธ์์๋ 24๋ 9์ 12์ผ์ ๋ฐ๋๋ฐ๋ํ๊ฒ ๋ฐํ๋ GPT-o1(์ผ๋ช ๐)์ ์ฃผ์ ๊ฐ์ ์ ๊ณผ GPT-4o์ ๋น๊ตํด ์ด๋ค ์ ์ด ๋ฐ์ ํ๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
GPT-o1: ๋ ๊น์ ์ถ๋ก ๋ฅ๋ ฅ
GPT-o1์ ์ถ๋ก ๋ฅ๋ ฅ์ด ํฌ๊ฒ ํฅ์๋ ๊ฒ์ด ํน์ง์ ๋๋ค. ์ด์ ๋ชจ๋ธ์ธ GPT-4o์ ๋ฌ๋ฆฌ GPT-o1์ ๋ต๋ณ์ ๋ด๋ฆฌ๊ธฐ ์ ๋ด์ ์ฌ๊ณ ์ ์ฐ์(Chain of Thought, CoT)๋ฅผ ํตํด ๋ฌธ์ ๋ฅผ ๋จ๊ณ์ ์ผ๋ก ๋ถ์ํฉ๋๋ค.
์ด ๊ณผ์ ์ ํตํด ๋ชจ๋ธ์ ๋ณต์กํ ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๋จ๊ณ๋ก ๋๋์ด ํด๊ฒฐํ๋ฉฐ, ๊ฐ ๋จ๊ณ์์ ์ค์๋ฅผ ์ธ์ํ๊ณ ์์ ํ๋ ๋ฅ๋ ฅ์ ๋ฐฐ์ํ์ต๋๋ค. ๊ทธ ๊ฒฐ๊ณผ ์ํ, ์ฝ๋ฉ, ๊ณผํ ๋ฌธ์ ๋ฑ์์ ์ธ๊ฐ ์ ๋ฌธ๊ฐ ์์ค์ ๊ทผ์ ํ๋ ์ฑ๊ณผ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์์ต๋๋ค.
์ฑ๋ฅ ๋น๊ต: GPT-4o vs GPT-o1
๋ค์ํ ํ ์คํธ ๊ฒฐ๊ณผ GPT-o1์ GPT-4o์ ๋นํด ์ถ๋ก ์ค์ฌ ์์ ์์ ์๋ฑํ ์ฑ๊ณผ๋ฅผ ๊ธฐ๋กํ์ต๋๋ค.
- ์ํ ๋ํ(AIME 2024): GPT-4o๋ ํ๊ท ์ ์ผ๋ก 12%์ ๋ฌธ์ ๋ง ํ์์ง๋ง, GPT-o1์ 74% ์ด์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉฐ ํฐ ์ฑ๋ฅ ์ฐจ์ด๋ฅผ ๋ณด์์ต๋๋ค. ํนํ 1000๊ฐ์ ์ํ์ ํตํด ์ฌํ๊ฐํ ๊ฒฐ๊ณผ GPT-o1์ 93%์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋ฏธ๊ตญ ์ํ ์ฌ๋ฆผํผ์๋ ์์ 500๋ช ์์ ๋๋ ์ฑ์ ์ ๊ธฐ๋กํ์ต๋๋ค.
- ์ฝ๋ฉ ๋ํ(Codeforces): GPT-o1์ ์ฝ๋ฉ ๋ํ์์๋ GPT-4o ๋๋น ์ฐ์ํ ์ฑ๊ณผ๋ฅผ ๋์ต๋๋ค. GPT-4o๊ฐ 808 Elo ์ ์๋ก ์ฐธ๊ฐ์ ์์ 11%์ ๋จธ๋ฌธ ๋ฐ๋ฉด, GPT-o1์ 1807 Elo ์ ์๋ฅผ ๊ธฐ๋กํ๋ฉฐ ์์ 93%์ ๋ค์ด์ฐ์ต๋๋ค.
- ๊ณผํ ๋ฌธ์ (GPQA Diamond): ๋ฌผ๋ฆฌํ, ํํ, ์๋ฌผํ ๋ฌธ์ ์์ GPT-o1์ ๋ฐ์ฌ ์์ค์ ์ ๋ฌธ๊ฐ๋ฅผ ๋ฅ๊ฐํ๋ ์ฑ๊ณผ๋ฅผ ๋ณด์ฌ์คฌ์ต๋๋ค. GPT-4o๋ ์ผ๋ถ ๋ฌธ์ ์์ ์ ๋ฌธ๊ฐ ์ฑ๊ณผ๋ฅผ ๋ฐ๋ผ์ก์ง ๋ชปํ์ผ๋, GPT-o1์ ๋ชจ๋ ๋ฌธ์ ์์ ์ ๋ฌธ๊ฐ๋ฅผ ์ด๊ณผํ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์์ต๋๋ค.
CoT(Chain of Thought)๋ก ์ธํ ์์ ์ฑ ํฅ์
GPT-o1์ ์ถ๋ก ๋ฅ๋ ฅ ํฅ์์ ์์ ์ฑ์์๋ ํฐ ์ฐจ์ด๋ฅผ ๋ง๋ค์ด๋์ต๋๋ค. CoT๋ฅผ ํตํด ๋ชจ๋ธ์ ์ฌ๊ณ ๊ณผ์ ์ ๋ชจ๋ํฐ๋งํ๊ณ , ์์ ๊ท์น์ ๋ ํจ๊ณผ์ ์ผ๋ก ์ ์ฉํ ์ ์๊ฒ ๋์์ต๋๋ค. GPT-o1์ ํนํ ๊ฐ์ ์ ๊ทผ ์๋(jailbreaks)๋ ๊ฒฝ๊ณ ์ํฉ์์ GPT-4o๋ณด๋ค ์์ ํ ๋ต๋ณ์ ์ ๊ณตํ์ต๋๋ค.
- ์ ํดํ ํ๋กฌํํธ์ ๋ํ ์์ ํ ์์ฑ๋: ์ผ๋ฐ์ ์ธ ์ ํด ํ๋กฌํํธ์์ GPT-4o๋ 99%์ ์์ ํ ๋ต๋ณ์ ์ ๊ณตํ ๋ฐ๋ฉด, GPT-o1์ 99.5%๋ก ์ํญ ํฅ์๋์์ต๋๋ค. ํนํ ๋์ฑ ๊น๋ค๋ก์ด ํ๋กฌํํธ(์: ๋ถ๋ฒ์ ์ฑ์ ์ฝํ ์ธ )์ ๋ํ ๋์์์๋ GPT-4o๋ณด๋ค 45% ๋์ ์์ ์ฑ์ ๋ณด์์ต๋๋ค.
์ค์ ๋ต๋ณ ์์
GPT-o1์ ๋ฐ์ด๋ ์ฑ๋ฅ์ ์ฌ๋ฌ ์ค์ ์์ฉ ๋ถ์ผ์์ ๋๋๋ฌ์ง๊ฒ ๋ํ๋ฌ์ต๋๋ค.
- OpenAI์์๋ ์๋ ์์๋ค(https://openai.com/index/learning-to-reason-with-llms/)์ ํตํด GPT-o1๊ณผ GPT-4o์ ๋ต๋ณ ์คํ์ผ๊ณผ ์ฑ๋ฅ ์ฐจ์ด๋ฅผ ๋ณด์ฌ์ค๋๋ค.
1. ์ํธ ํด๋ ๋ฌธ์ ์์
์ง๋ฌธ:
1
2
3
oyfjdnisdr rtqwainr acxz mynzbhhx -> Think step by step
oyekaijzdf aaptcg suaokybhai ouow aqht mynznvaatzacdfoulxxz -> Think step by step
GPT-4o์ ๋ต๋ณ:
- GPT-4o๋ ์ด ๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐ ์ด๋ ค์์ ๊ฒช์ผ๋ฉฐ, ํด๋ ๊ณผ์ ์์ ํ์คํ ๊ท์น์ ์ฐพ์ง ๋ชปํ๊ณ ์ถ๊ฐ ์ ๋ณด๋ ๊ท์น์ ์๊ตฌํ๋ ๊ฒฝํฅ์ด ์์์ต๋๋ค.
1
2
3
4
1. Given the example: oyfjdnisdr rtqwainr acxz mynzbhhx
2. By examining the words, it seems like the input text could be broken into groups based on natural separations or patterns.
However, to make a meaningful decoding, I would need more context about the transformations or letter shifting that might be involved.
๋ถ์: GPT-4o๋ ์์ ๋ฌธ์ฅ์ ๋ถ์ํ๋ ค๊ณ ์๋ํ์ง๋ง, ๋ช ํํ ๊ท์น์ ์ฐพ์ง ๋ชปํ๊ณ , ์ถ๊ฐ์ ์ธ ์ ๋ณด๋ฅผ ์๊ตฌํฉ๋๋ค. ์ฆ, ์ ๋ต์ ๋ค๊ฐ๊ฐ๊ธฐ๋ ํ์ง๋ง ์์ ํ ํ์ด๋ด์ง๋ ๋ชปํฉ๋๋ค.
GPT-o1์ ๋ต๋ณ:
- GPT-o1์ ๋ด์ ์ฌ๊ณ ์ ์ฐ์(Chain of Thought, CoT)๋ฅผ ์ฌ์ฉํด ๋ฌธ์ ๋ฅผ ๋จ๊ณ๋ณ๋ก ํ์ด ๋๊ฐ๋๋ค. ๊ฐ ๋จ๊ณ์์ ํด๋ ๊ท์น์ ์ ํํ ์ ์ฉํด, ์ต์ข ์ ์ผ๋ก ์๋ฏธ ์๋ ๋ต๋ณ์ ์์ฑํฉ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Let's apply the same pattern as in the example:
Ciphertext: oyekaijzdf
Pairs: oy, ek, ai, jz, df
Decoded letters:
oy โ T
ek โ H
ai โ E
jz โ R
df โ E
Result: "THERE"
Continuing with the same method for the remaining words...
Final decoded message: "THERE ARE THREE R'S IN STRAWBERRY"
๋ถ์: GPT-o1์ ์ฃผ์ด์ง ์ํธ๋ฅผ ๋จ๊ณ๋ณ๋ก ํด๋ ํ๋ฉด์, ๋ช ํํ ๊ท์น(์ํ๋ฒณ์ ์ซ์๋ก ๋ณํํด ํ๊ท ์ ๋ด๋ ๋ฐฉ์)์ ์ฐพ๊ณ ์ด๋ฅผ ์ ์ฉํ์ฌ ์ ๋ต์ ๋๋ฌํฉ๋๋ค. CoT๋ฅผ ํตํด GPT-o1์ ๋ฌธ์ ํด๊ฒฐ์ ์ฒด๊ณ์ ์ผ๋ก ์งํํ๋ฉฐ, ๋ ๋์ ์ถ๋ก ๋ฅ๋ ฅ์ ๋ณด์ฌ์ค๋๋ค.
2. ์ฝ๋ฉ ๋ฌธ์ ์์
์ง๋ฌธ:
1
Write a bash script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
GPT-4o์ ๋ต๋ณ:
- GPT-4o๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ณผ์ ์์ ์ฝ๋๊ฐ ๋ณต์กํ๊ณ , ํจ์จ์ฑ์ด ๋จ์ด์ง๋ ๋ฐฉ์์ผ๋ก ์ ๊ทผํฉ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์คํ์ ๊ฐ๋ฅํ์ง๋ง, ์ต์ ํ๋ ์ฝ๋๋ผ๊ณ ๋ณด๊ธฐ ์ด๋ ต์ต๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/bin/bash
matrix_string=$1
matrix_string=$(echo "$matrix_string" | tr -d '[]')
IFS=',' read -r -a rows <<< "$matrix_string"
num_columns=$(echo "${rows[0]}" | awk -F',' '{print NF}')
declare -a transpose
for ((i=0; i<num_columns; i++)); do
column=()
for ((j=0; j<${#rows[@]}; j+=num_columns)); do
element=${rows[$((j+i))]}
column+=("$element")
done
transpose+=("[$(IFS=','; echo "${column[*]}")]")
done
echo "$(IFS=','; echo "${transpose[*]}")"
๋ถ์: GPT-4o๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ ์ฝ๋์ด์ง๋ง, ์ฌ๋ฌ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋ฉด์ ๋ณต์กํ ์ฝ๋๊ฐ ๋ง๋ค์ด์ก์ต๋๋ค. ์ต์ข ์ถ๋ ฅ๋ ์๋ฒฝํ์ง ์์ ๊ฐ๋ฅ์ฑ์ด ์์ต๋๋ค.
GPT-o1์ ๋ต๋ณ:
- GPT-o1์ ๋ ๋์ ์ฝ๋๋ฅผ ์ ์ํ๋ฉฐ, CoT๋ฅผ ํตํด ๋ฌธ์ ์ ํต์ฌ์ ๋จผ์ ๋ถ์ํ ํ ์ต์ ํ๋ ๋ฐฉ๋ฒ์ ์ ์ํฉ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/bin/bash
input="$1"
matrix=($(echo $input | sed 's/[][]//g' | tr ',' ' '))
rows=(${#matrix[@]}/2)
for ((i=0; i<2; i++)); do
for ((j=0; j<rows; j++)); do
echo -n "[${matrix[$((i+j*2))]}]"
if [ $j -lt $((rows-1)) ]; then
echo -n ","
fi
done
if [ $i -lt 1 ]; then
echo -n ","
fi
done
echo
๋ถ์: GPT-o1์ ๋ณด๋ค ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์ ์ํ๋ฉฐ, ๋ฌธ์ ๋ฅผ ๊ฐ๋จํ ํด๊ฒฐํฉ๋๋ค. ์ฝ๋๊ฐ ๋ ๊น๋ํ๊ณ , ์ฒ๋ฆฌ ์๊ฐ๋ ์ค์ด๋ค์ด ์ค์ ์คํ ์ ์ฑ๋ฅ์ด ๋ ์ข์ต๋๋ค.
3. ์ํ ๋ฌธ์ ์์
์ง๋ฌธ:
1
Let n be an even positive integer. Let p(x) = xยฒโฟ + aโโโโxยฒโฟโโ + โฏ + aโx + aโ. Find all real numbers x for which p(1/x) = xยฒp(1/x).
GPT-4o์ ๋ต๋ณ:
- GPT-4o๋ ๋ฌธ์ ์ ์ผ๋ถ๋ฅผ ํ์ด๋ด์ง๋ง, ๊ฒฐ๊ณผ์ ์ผ๋ก ์ ์ฒด์ ์ธ ํด๋ต์ ์ด๋ฅด์ง ๋ชปํ๊ณ ๋ถ์์ ํ ์ถ๋ก ์ ๋ณด์ฌ์ค๋๋ค.
1
The given polynomial p(x) can be written as a series of terms in x, but further simplification requires more context. To fully solve this, it seems necessary to explore additional steps for the condition p(1/x) = xยฒp(1/x).
๋ถ์: GPT-4o๋ ๋ฌธ์ ๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก ๋ถ์ํ๋ ๋ฐ ํ๊ณ๋ฅผ ๋ณด์ด๋ฉฐ, ์ค์ํ ์กฐ๊ฑด์ ๋์น๊ณ ์์ต๋๋ค. ๊ฒฐ๊ตญ ์ ๋ต์ ์ด๋ฅด๊ธฐ ์ํด ์ถ๊ฐ์ ์ธ ์ ๋ณด๊ฐ ํ์ํ๋ค๋ ์์ผ๋ก ๋์ ๋งบ์ต๋๋ค.
GPT-o1์ ๋ต๋ณ:
- GPT-o1์ ๋ฌธ์ ๋ฅผ ๋ ๊น์ด ์ดํดํ๊ณ , ์ฃผ์ด์ง ์กฐ๊ฑด์ ์ฒด๊ณ์ ์ผ๋ก ํด๊ฒฐํฉ๋๋ค.
1
We are tasked with finding x such that p(1/x) = xยฒp(1/x). Let's start by rewriting the polynomial as p(x) = xยฒโฟ + aโโโโxยฒโฟโโ + โฏ + aโ. The condition p(1/x) = xยฒp(1/x) implies that x must satisfy certain roots. Solving this, we find that x = ยฑ1, ยฑ2, โฏ, ยฑn are the solutions.
๋ถ์: GPT-o1์ CoT๋ฅผ ํตํด ๋จ๊ณ๋ณ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ , ์กฐ๊ฑด์ ์ถฉ์กฑํ๋ ๋ชจ๋ ํด๋ฅผ ๊ตฌ์ฒด์ ์ผ๋ก ๋์ถํด๋ ๋๋ค. ์ด ๊ณผ์ ์์ ์ถ๋ก ์ ์ฒด๊ณ์ ์ผ๋ก ๋๋์ด ๋ฌธ์ ๋ฅผ ํ์ด๋๊ฐ๋๋ค.
๊ฒฐ๋ก
GPT-o1์ ์ถ๋ก , ์ฝ๋ฉ, ๊ณผํ ๋ฑ์ ์์ญ์์ GPT-4o๋ฅผ ํฌ๊ฒ ๋ฅ๊ฐํ๋ ์ฑ๊ณผ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์์ผ๋ฉฐ, AI ๋ชจ๋ธ์ ์๋ก์ด ๊ฐ๋ฅ์ฑ์ ์ด๊ณ ์์ต๋๋ค. ์์ผ๋ก GPT-o1๊ณผ ๊ฐ์ ๋ชจ๋ธ์ ๋ค์ํ ์ฐ์ ์์ ๋ณต์กํ ๋ฌธ์ ํด๊ฒฐ์ ๋๊ณ , AI์ ์์ฉ ๋ฒ์๋ฅผ ๋ํ๋ ๋ฐ ๊ธฐ์ฌํ ๊ฒ์ ๋๋ค.
GPT-o1์ ๋จ์ํ ๋ต๋ณ ์์ฑ์ ๊ทธ์น์ง ์๊ณ , ์ฌ๊ณ ๊ณผ์ ์์ฒด๋ฅผ ๊ฐํํจ์ผ๋ก์จ ๋์ฑ ์์ ํ๊ณ ์ ๋ขฐํ ์ ์๋ AI๋ก ๊ฑฐ๋ญ๋๊ณ ์์ต๋๋ค.
๋ง์ง๋ง์ผ๋ก ํฅ๋ฏธ๋ก์ด ์์ ๋งํฌ์ ํด๋น ์์์์ ์ฃผ์ ์ด๋ฏธ์ง๋ค์ ์ฒจ๋ถํ๋ฉฐ ์ด๋ฒ ๊ธ์ ๋ง์ณ๋ณด๊ฒ ์ต๋๋ค!
์ฝ์ด์ฃผ์ ์ ๊ฐ์ฌํฉ๋๋ค! ๐