개발자로서 현장에서 일하면서 새로 접하는 기술들이나 알게된 정보 등을 정리하기 위한 블로그입니다. 운 좋게 미국에서 큰 회사들의 프로젝트에서 컬설턴트로 일하고 있어서 새로운 기술들을 접할 기회가 많이 있습니다. 미국의 IT 프로젝트에서 사용되는 툴들에 대해 많은 분들과 정보를 공유하고 싶습니다.
Large language 모델들은 writing에 아주 탁월합니다. 그들은 모든 종류의 작업을 지원할 수 있습니다.
Blog posts
Email copy
Ad copy
Website copy
Product descriptions
Memos
Storytelling
Brainstorming
Question generation
etc.
GPT-3에서 prompt 하는 가장 쉬운 방법은 여러분이 하고 싶은 말을 하는 것입니다. 예를 들어 여러분이 이메일을 쓰기를 원한다면 아래와 같이 프롬프트를 사용할 수 있습니다.
Write an email to a colleague named Jill congratulating her on her promotion. The tone should be warm yet professional. Mention how you admire the work she's been putting in. Include a joke about how her pet lizard Max enjoys eating grasshoppers. Mention how you're looking forward to the team off-site next week.
Subject: Congratulations on Your Promotion, Jill!
Dear Jill,
Congratulations on your promotion! I'm so proud of you and all the hard work you've been putting in. It's been inspiring to watch you grow in your career.
I'm sure Max the lizard is also celebrating with you. I hear he loves eating grasshoppers, so you should treat him to a special snack!
I'm looking forward to seeing you at the team off-site next week. I'm sure it will be a great opportunity to celebrate your success.
All the best,
[Your Name]
일반적으로 writing은 어떤 스타일의 prompt에도 작동합니다. 그것이 어떤 지시 (instruction)이든 따라야 할 일련의 예제들이든 관계 없이 작동합니다. 여러분이 하고 싶은 것을 실현하기 위해 가장 잘 작동 시킬 수 있는 방법은 무엇인지 직접 실험 해 보세요.
Writing은 또한 모든 유형의 모델들과 같이 작동할 수 있지만 각각 장 단점이 있습니다.
Search for a better prompt that elicits more reliable answers?
좀더 신뢰할 수 있는 답변을 이끌어내기 위해 더 좋은 prompt를 찾으시겠습니까?
Invest in thousands of examples to fine-tune a custom model?
custom 모델로 fine-tune 하기 위해 수천개의 예제들을 마련하는 일을 하시겠습니까?
Assume the model is incapable of the task, and move on?
해당 모델이 그 작업에 적당하지 않다고 가정하고 그냥 진행 하시겠습니까?
간단하게 답할 수 있는 문제가 아닙니다. 상황에 따라 다르니까요. 하여간 여러분의 작업에 논리적 추론이나 복잡성이 있다면 좀 더 신뢰성 있는 결과를 도출하기 위해 그리고 고성능 prompt를 만들기 위해 이 글에서 제시하는 기술들을 고려해 보세요.
Why GPT-3 fails on complex tasks
GPT-3는 왜 복잡한 작업에 대해 실패 할까요?
여러분은 13 곱하기 17이 무엇이냐고 물으면 즉시 답할 수 있습니까?
대부분의 사람들은 그렇지 못할 겁니다. 그렇다고 해서 인간이 두자릿수 곱셈을 못 하는 것은 아닙니다.
몇초의 시간과 종이와 연필만 있으면 13 x 17 = 130 + 70 + 21 = 221 이라는 계산을 하는 것은 그리 어렵지 않습니다.
마찬가지로 GPT-3도 다음 token을 계산하는데 너무 복잡한 임무를 부여하면 잘못된 추측을 만들 수 있습니다. 위의 인간의 예와 마찬가지로 이것이 GPT-3가 해당 작업을 수행하지 못하는 것을 의미하는 것은 아닙니다. 문제를 추론할 충분한 시간과 공간이 있으면 그 모델은 여전히 안정적으로 대답할 수 있습니다.
예를 들어 text-davinci-002에게 저글링 공에 대한 다음 수학 문제를 묻는 다면 아마 대답을 잘 못 할 겁니다.
Q: A juggler has 16 balls. Half of the balls are golf balls and half of the golf balls are blue. How many blue golf balls are there?
A:
There are 8 blue golf balls.
16개의 공 중에 반은 골프공이다. 그리고 골프공의 반은 파란색이다. 파란 골프 공은 몇개가 있을까?
8개의 파란 골프공이 있다.
==> 이 대답은 틀렸죠. 8개 골프공 중에 반이 파란색이니까 4개가 되겠죠.
Q: A juggler has 16 balls. Half of the balls are golf balls and half of the golf balls are blue. How many blue golf balls are there?
A: Let's think step by step.
There are 16 balls in total.
Half of the balls are golf balls.
That means that there are 8 golf balls.
Half of the golf balls are blue.
That means that there are 4 blue golf balls.
이렇게 스텝 바이 스텝으로 생각하면 제대로 된 대답을 내 놓습니다.
물론 이 단계별 트릭이 일반적으로 적용되는 경우인지 혹은 운 좋게 특정 경우에만 적용 된 것인지는 이 한가지 예만 가지고 판단하기 어렵습니다. 어쨌든 이 질문에 대해서는 효과가 있었습니다. 이런식의 단어로 된 수학문제에서 이렇게 스텝 바이 스텝으로 생각하도록 함으로서 GPT-3가 문제를 제대로 해결하는 비율이 무의미한 18%에서 유의미한 79%로 엄청나게 높아 졌습니다.
Model capabilities depend on context
GPT-3으로 작업하는 방법을 배울 때 흔히 발생하는 개념적 실수 중 하나는 GPT-3의 기능이 모든 컨텍스트에서 고정되어 있다고 믿는 것입니다. 예를 들어 GPT-3가 간단한 논리 질문을 틀린다면 GPT-3는 간단한 논리 질문에 적합하지 않은것이다 라고 생각하는 것.
Let's think step by step 예제에서 알 수 있듯이 GPT-3의 명백한 오류는 때때로 올바른 output을 내 오는데 대해 스스로 조종하는 것에 도움이 되는 좀 더 나은 prompt줄 제공함으로서 해결될 수 있습니다.
How to improve reliability on complex tasks
이 문서의 나머지 부분에서는 복잡한 작업에서 Large language 모델의 신뢰성(안정성)을 개선할 수 있는 기술들을 공유합니다.
일부 기술은 특정 유형의 문제에만 적용 되지만 대부분은 다음과 같이 광범위한 상황에 적용할 수 있는 일반 원칙을 기반으로 합니다.
Give clearer instructions
명확하게 지시한다.
Split complex tasks into simpler subtasks
복잡한 임무는 좀 더 간단한 작은 임무들로 나눈다.
Structure the instruction to keep the model on task
모델이 작업을 계속 수행할 수 있도록 지시를 구조화 한다.
Prompt the model to explain before answering
모델이 대답을 하기전에 설명을 하도록 요구하는 내용을 Prompt에 넣어 작성한다.
Ask for justifications of many possible answers, and then synthesize
많은 가능한 응답들의 정당성을 묻고 그것들을 종합한다.
Generate many outputs, and then use the model to pick the best one
많은 output들을 생성한다. 그리고 모델을 사용해서 그 중에 가장 좋은 것을 선택하도록 한다.
Fine-tune custom models to maximize performance
Fine-tune 커스텀 모델로 성능을 최대화 한다.
Split complex tasks into simpler tasks
모델에게 생각할 시간과 space를 좀 더 많이 주는 방법 중 하나는 더 간단한 조각들로 임무를 나누는 것입니다.
예를 들어 어떤 텍스트에 대해 여러 가지의 보기를 주고 모델에게 물어본다고 했을 때를 생각해 보세요. (아래 예제 참조) 그냥 주관식으로 물어 본다면 text-davinci-002는 그 중 3번과 5번을 고를 수가 없습니다. 이렇게 되면 잘못된 대답을 할 확률이 높아 집니다.
하지만 보기를 5개를 주고 그 중 3번과 5번이 답이라면 text-davinci-002는 그 3번과 5번을 선택하던가 그 둘을 종합해서 좀 더 정답에 가깝거나 완전한 정답을 output으로 내 놓을 수 있습니다.
Use the following clues to answer the following multiple-choice question.
Clues:
1. Miss Scarlett was the only person in the lounge.
2. The person with the pipe was in the kitchen.
3. Colonel Mustard was the only person in the observatory.
4. Professor Plum was not in the library nor the billiard room.
5. The person with the candlestick was in the observatory.
Question: Was Colonel Mustard in the observatory with the candlestick?
(a) Yes; Colonel Mustard was in the observatory with the candlestick
(b) No; Colonel Mustard was not in the observatory with the candlestick
(c) Unknown; there is not enough information to determine whether Colonel Mustard was in the observatory with the candlestick
Solution:
(c) Unknown; there is not enough information to determine whether Colonel Mustard was in the observatory with the candlestick
3번과 5번이 Mustard 대령이 천문대에 있는 유일한 사람이고 천문데애 있는 사람이 촛대를 가지고 있다는 것을 설명하고 있지만 모델은 그것을 (a) Yes; .. 라고 정답으로 결함하지 못합니다.
이렇게 직접 묻는 대신 작업을 세 부분으로 나눌 수 있습니다.
First, go through the clues one by one and consider whether the clue is potentially relevant
먼저 단서를 하나씩 살펴보고 단서가 잠재적으로 관련이 있는지 고려 하세요.
Second, combine the relevant clues to reason out the answer to the question\
두번째로 관련 단서를 결합하여 질문에 대한 답을 추론하세요.
Third, write the final answer: either (a), (b), or (c)
셋째 (a),(b) 혹은 (c) 중 하나의 최종 답변을 작성합니다.
Use the following clues to answer the following multiple-choice question, using the following procedure:
(1) First, go through the clues one by one and consider whether the clue is potentially relevant
(2) Second, combine the relevant clues to reason out the answer to the question
(3) Third, map the answer to one of the multiple choice answers: either (a), (b), or (c)
Clues:
1. Miss Scarlett was the only person in the lounge.
2. The person with the pipe was in the kitchen.
3. Colonel Mustard was the only person in the observatory.
4. Professor Plum was not in the library nor the billiard room.
5. The person with the candlestick was in the observatory.
Question: Was Colonel Mustard in the observatory with the candlestick?
(a) Yes; Colonel Mustard was in the observatory with the candlestick
(b) No; Colonel Mustard was not in the observatory with the candlestick
(c) Unknown; there is not enough information to determine whether Colonel Mustard was in the observatory with the candlestick
Solution:
(1) First, go through the clues one by one and consider whether the clue is potentially relevant:
Clue 1: Miss Scarlett was the only person in the lounge. This clue is not relevant.
Clue 2: The person with the pipe was in the kitchen. This clue is not relevant.
Clue 3: Colonel Mustard was the only person in the observatory. This clue is relevant.
Clue 4: Professor Plum was not in the library nor the billiard room. This clue is not relevant.
Clue 5: The person with the candlestick was in the observatory. This clue is relevant.
(2) Second, combine the relevant clues to reason out the answer to the question:
Clue 3 and Clue 5 both say that the person with the candlestick was in the observatory. Colonel Mustard was the only person in the observatory, so Colonel Mustard was the person with the candlestick.
(3) Third, write the final answer:
(a) Yes; Colonel Mustard was in the observatory with the candlestick
모델에게 생각할 시간과 공간을 더 주고 reasoning plan (추론 계획)에 따르는 가이드를 제공함으로써 모델은 (a) 라는 정답을 알아낼 수 있습니다.
복잡한 명령을 더 작은 하위 작업으로 분할하는 또 다른 잇점은 모델이 각 하위 작업에 집중하도록 도울 수 있다는 것입니다.
예를 들어 우리가 text-davinci-002에게 원래의 언어로 텍스트를 요약해달라고 부탁하면 모델은 다시 영어로 전환 될 수 있습니다.
Summarize the text using the original language of the text. The summary should be one sentence long.
Text:
"""
La estadística (la forma femenina del término alemán Statistik, derivado a su vez del italiano statista, "hombre de Estado") es una ciencia que estudia la variabilidad, colección, organización, análisis, interpretación, y presentación de los datos, así como el proceso aleatorio que los genera siguiendo las leyes de la probabilidad. La estadística es una ciencia formal deductiva, con un conocimiento propio, dinámico y en continuo desarrollo obtenido a través del método científico formal. En ocasiones, las ciencias fácticas necesitan utilizar técnicas estadísticas durante su proceso de investigación factual, con el fin de obtener nuevos conocimientos basados en la experimentación y en la observación. En estos casos, la aplicación de la estadística permite el análisis de datos provenientes de una muestra representativa, que busca explicar las correlaciones y dependencias de un fenómeno físico o natural, de ocurrencia en forma aleatoria o condicional.
"""
Summary:
The text explains that statistics is a science that studies the variability, collection, organization, analysis, interpretation, and presentation of data, as well as the random process that generates them following the laws of probability.
여기서 일단 모델에게 해당 언어를 판별하라고 지시할 수 있습니다. 그리고 난 후 그 내용을 요약하라고 하면 좀 더 신뢰도가 높은 답변을 얻을 수 있습니다.
First, identify the language of the text. Second, summarize the text using the original language of the text. The summary should be one sentence long.
Text:
"""
La estadística (la forma femenina del término alemán Statistik, derivado a su vez del italiano statista, "hombre de Estado") es una ciencia que estudia la variabilidad, colección, organización, análisis, interpretación, y presentación de los datos, así como el proceso aleatorio que los genera siguiendo las leyes de la probabilidad. La estadística es una ciencia formal deductiva, con un conocimiento propio, dinámico y en continuo desarrollo obtenido a través del método científico formal. En ocasiones, las ciencias fácticas necesitan utilizar técnicas estadísticas durante su proceso de investigación factual, con el fin de obtener nuevos conocimientos basados en la experimentación y en la observación. En estos casos, la aplicación de la estadística permite el análisis de datos provenientes de una muestra representativa, que busca explicar las correlaciones y dependencias de un fenómeno físico o natural, de ocurrencia en forma aleatoria o condicional.
"""
Language:
Spanish
La estadística es una ciencia que estudia la variabilidad, colección, organización, análisis, interpretación, y presentación de los datos, así como el proceso aleatorio que los genera siguiendo las leyes de la probabilidad.
Prompt the model to explain before answering
답변의 신뢰도를 향상 시킬 수 있는 또 다른 강력한 기술은 모델이 최종 답변을 곧바로 하도록 하는 대신 점진적으로 답변을 추론하도록 유도하는 것입니다.
저자는 이 간단한 트릭을 MultiArith 수학 데이터 세트에 적용하여 Let's think step by step으로 정확도를 18%에서 79%로 4배로 높였다는 사실을 발견했습니다.
Source: Large Language Models are Zero-Shot Reasoners by Takeshi Kojima et al. (2022).
Implications
이 Let's think step by step 트릭이 수학 문제 에서는 잘 작동한다고 모든 작업에 효과적으로 적용 될 수 있는 것은 아닙니다. 저자는 이 방법이 multi-step 산술 문제, 상징적 추론 문제, 전략 문제 그리고 다른 추론 문제들에 아주 유용하게 적용될 수 있다는 것을 발견했습니다. 아주 간단한 수학문제나 아주 상식적인 질문에는 도움이 되지 않았으며 아마도 다른 많은 비추론 작업에도 도움이 되지 않을 것입니다.
Source: Large Language Models are Zero-Shot Reasoners by Takeshi Kojima et al. (2022).
이 테크닉을 자신의 작업에 적용하는 경우 instruction을 customizing 하는 실험을 두려워 하지 마세요. Let's think step by step은 오히려 일반적입니다. 사용사례에 맞게 맞춤화 된 보다 엄격한 형식을 따르는 instruction을 통해 더 나은 성능을 찾을 수 있습니다. 예를 들어 더 구조화된 변형을 시도할 수 있다면 첫번째 X가 참일 수 있는 이유에 대해 Step by Step으로 생각 해 보세요. 두번째로 왜 Y가 참일 수 있는지를 step by step 으로 생각합니다. 그리고 세번쨰로 X 나 Y 중 어느게 더 나은지에 대해 step by step으로 생각하는 겁니다. 그리고 이 과정을 계속 이어나가는 예제 형식의 모델을 제공할 수도 있습니다.
예:
Using the IRS guidance below, answer the following questions using this format:
(1) For each criterion, determine whether it is met by the vehicle purchase
- {Criterion} Let's think step by step. {explanation} {yes or no, or if the question does not apply then N/A}.
(2) After considering each criterion in turn, phrase the final answer as "Because of {reasons}, the answer is likely {yes or no}."
IRS guidance:
"""
You may be eligible for a federal tax credit under Section 30D if you purchased a car or truck that meets the following criteria:
- Does the vehicle have at least four wheels?
- Does the vehicle weigh less than 14,000 pounds?
- Does the vehicle draw energy from a battery with at least 4 kilowatt hours that may be recharged from an external source?
- Was the vehicle purchased in a year before 2022?
- If so, has the manufacturer sold less than 200,000 qualifying vehicles? (Tesla and GM have sold more than 200,000 qualifying vehicles.)
- Was the vehicle purchased in a year after 2022?
- If so, is the vehicle present in the following list of North American-assembled vehicles? (The only electric vehicles assembled in North America are the Audi Q5, BMW 330e, BMW X5, Chevrolet Bolt EUV, Chevrolet Bolt EV, Chrysler Pacifica PHEV, Ford Escape PHEV, Ford F Series, Ford Mustang MACH E, Ford Transit Van, GMC Hummer Pickup, GMC Hummer SUV, Jeep Grand Cherokee PHEV, Jeep Wrangler PHEV, Lincoln Aviator PHEV, Lincoln Corsair Plug-in, Lucid Air, Nissan Leaf, Rivian EDV, Rivian R1S, Rivian R1T, Tesla Model 3, Tesla Model S, Tesla Model X, Tesla Model Y, Volvo S60, BMW 330e, Bolt EV, Cadillac Lyriq, Mercedes EQS SUV, and Nissan Leaf.)
"""
Question: Can I claim a federal tax credit for my Toyota Prius Prime bought in 2021?
Solution:
(1) For each criterion, determine whether it is met by the vehicle purchase
- Does the vehicle have at least four wheels? Let's think step by step.
The Toyota Prius Prime has four wheels, so the answer is yes.
- Does the vehicle weigh less than 14,000 pounds? Let's think step by step. The Toyota Prius Prime weighs less than 14,000 pounds, so the answer is yes.
- Does the vehicle draw energy from a battery with at least 4 kilowatt hours that may be recharged from an external source? Let's think step by step. The Toyota Prius Prime has a battery with at least 4 kilowatt hours that may be recharged from an external source, so the answer is yes.
- Was the vehicle purchased in a year before 2022? Let's think step by step. The Toyota Prius Prime was purchased in 2021, which is before 2022, so the answer is yes.
- Was the vehicle purchased in a year after 2022? N/A
- If so, is the vehicle present in the following list of North American-assembled vehicles? N/A
(2) After considering each criterion in turn, phrase the final answer as "Because of {reasons}, the answer is likely {yes or no}."
Because the Toyota Prius Prime meets all of the criteria for a federal tax credit, the answer is likely yes.
Few-shot examples
Method
모델이 답을 추론하도록 유도하는 방법은 여러가지가 있습니다. 그 중 하나는 Jason Wei와 Denny Zhou 등이 구글에서 연구한 몇가지 예 (few-shot) 로 시연하는 것입니다. 다음은 few-shot 의 chain-of-thought 프롬프트 입니다.
Let's thin step by step 테크닉과 비교해서 few-shot example-based 접근법에는 한가지 강점은 format, length 그리고 추론의 스타일을 좀 더 쉽게 특정할 수 있다는 것입니다. 이 작업은 최종 답변을 확정하기 전에 모델이 하는 사전 작업입니다. 이것은 모델이 초기 추론을 깊게 혹은 옳은 방향이 아닌 쪽으로 할 경우 특히 도움이 됩니다.
Fine-tuned
Method
일반적으로 최대 성능을 얻으려면 fine-tune a custom 모델을 사용할 필요가 있습니다. 그런데 모델을 fine-tuning 하는 것은 작성하는데 비용이 드는 예제 explanation들을 수천개 이상을 사용해야 합니다.
2022년 Eric Zelikman과 Yuhuai We et al 은 모델을 fine-tune 하는데 사용될 수 있는 explanation 데이터 세트를 생성하기 위한 few-shot 프롬프트를 사용하기 위한 아주 현명한 procedure를 발표했습니다. 그것은 후보 explanation들을 생성하기 위한 few-shot 프롬프트를 사용하자는 아이디어 입니다. 그 후보 explanation들 중 정답을 생산한 explanation들만 keep 한다는 아이디어죠.
그 다음 오답에 대한 추가적인 explanation들을 얻기 위해 few-shot 프롬프트를 retry 하는 겁니다. 정답은 질문의 일 부분으로서 제공되게 됩니다. 저자들은 그 절차를 STaR(Self-taught Reasoner) 절차라고 부릅니다.
이 기술을 사용하면 수천개의 example explanation들을 작성할 필요 없습니다. 그러기 위해서 fine-tune의 강점과 chain-of-thought 프롬프팅의 장점을 결합할 수 있습니다.
Results
저자들이 이 기술을 Common Sense Q&A 데이타 세트에 적용 했을 때 그들은 이 STaR이 chain-of-thought 프롬프트만 사용했을 때 와 fine-tuning 만을 사용했을 때 보다 성능이 더 뛰어나게 나타난 다는 것을 발견했습니다. (73% > 37% , 73% > 60%)
fine-tuning 데이터세트를 확장하거나 수정하기 위해 few-shot 프롬프트를 사용하는 것은 explanation 작성을 뛰어 넘어 일반화할 수 있게 해 주는 아이디어 입니다. 예를 들어 여러분이 train 하기 위한 구조화 되지 않은 텍스트를 많이 가지고 있는 경우 프롬프트를 이용해서 구조화되지 않은 텍스트에서 구조화 된 데이터 세트를 추출한 다음 그 구조화 된 데이터 세트에서 custom 모델을 fine-tune 하는 것입니다.
Extensions to chain-of-thought prompting
이 외에 chain-of-thought 의 확장관련한 발표도 몇개 더 있습니다.
Selection-inference prompting
Method
Published by Antonia Creswell et al., one extension of the chain-of-thought technique is to split the single prompt for generating explanations and answers into smaller parts. First, a prompt selects a relevant subset of facts from the text ('selection prompt'). Then, a second prompt infers a conclusion from the selected facts ('inference prompt'). These prompts are then alternated in a loop to generate multiple steps of reasoning and eventually land on a final answer. The authors illustrate the idea in the following figure:
Antonia Creswell 등이 발표한 chain-of-thought 테크닉의 확장은 explanation들을 생성하기 위해 단일 프롬프트를 분할하는 것입니다. 그 답변들은 좀 더 작은 부분으로 분할 되는 것이죠. 우선 프롬프트는 텍스트 (selection prompt)로부터 연관된 fact의 subset를 선택합니다. 그런 다음 두번째 프롬프트가 선택된 사실(inference prompt) 에서 결론을 추론합니다. 그런 다음 이러한 프롬프트는 루프에서 번갈아 가며 여러단계의 추론을 생성하고 결국 최종 답변에 도달합니다. 저자는 아래 그림으로 그 아이디어를 설명합니다.
7B-parameter 모델을 적용 했을 때 저자들은 selection-interference 프롬프팅이 bAbi 와 Proof Writer benchmark task들에 대해 chain-of-thought 프롬프팅과 비교해서 대체적으로 성능이 향상된다는 것을 발견했습니다.
(bAbi와 Proof Writer benchmark task들은 둘 다 더 긴 일련의 추론 단계들이 더 필요합니다.)
그들이 달성한 최고의 성능은 fine-tuning과 함께 selection-interferne 프롬프팅을 결합했을 때 달성했습니다.
selection-inference 프롬프팅 테크닉을 발표한 다음 몇달 후 저자는 다음 논문에서 테크닉을 확장할 수 있는 다음과 같은 아이디어를 발표 했습니다.
figuring out when the selection-inference cycle should stop or continue
selection-inference 사이클이 언제 중단되고 언제 계속 되어야 하는지 알아내기
adding a value function to help search over multiple reasoning paths
여러 추론 경로들에 대해 검색하는 것을 돕기 위한 value function 추가하기
reducing hallucination of fake facts by fine-tuning a model to reason about sentence labels (e.g., sen1) rather than writing out the sentences themselves
문장 자체를 작성하는 대신 문장 레이블에 대한 추론을 위한 모델을 fine-tuning 함으로서 fake fact들의 hallucination (환각) 를 감소시키기
Method
In the original selection-inference technique, specialized 'selection' and 'inference' prompts are alternated to select facts and make inferences from those facts, combining to generate a sequence of reasoning steps.
오리지널 selection-inference 테크닉에서는 특별한 'selection' 과 'inference' (추론) 프롬프트 들은 fact들을 선택하는 것과 그러한 fact들을 가지고 추론을 만드는 것을 번갈아 가면서 하고 이 추론 과정들의 sequence를 발생시키기 위해 결합합니다.
저자들은 이 테크닉을 2개의 추가 구성 요소들로 확장합니다.
첫째, 저자들은 각각의 추론 단계 이후 'halter' 모델을 추가합니다. 이것은 이 추론들이 그 질문에 대한 대답으로서 충분한 것인지를 질문하기 위함입니다.
이 halter 모델은 몇가지 장점들이 있습니다.
it can tell the selection-inference process to stop or keep going, as necessary.
이것은 필요에 따라 중지 하거나 아니면 계속 진행하기 위한 selection-inference 프로세스인지 여부를 알려 줄 수 있습니다.
if the process never halts, you'll get no answer, which is often preferable to a hallucinated guess
만약 그 프로세스가 중단되지 않는다면 답을 얻지 못할 것입니다. 이것이 hallucinated guess 보다 나은 경우가 있기는 합니다.
이 두가지 확장에다가 추가적으로 저자들은 또한 fake fact들의 hallucination을 감소시키기 위한 트릭을 사용합니다. 모델에게 factual sentence들을 작성하도록 요구하는 대신 sentence label (e.g. sen1)들로 작업을 하도록 모델을 fine-tune 합니다. 이렇게 하면 프롬프트 context에 언급되지 않은 fake fact들을 hallucinating 하는 것을 방지하는데 도움이 됩니다.
정답을 받을 확률을 최대화 하려는 이전의 테크닉들과는 달리 다른 접근법은 (정답이든 오답이든) 가능한 explanation들 의 tree를 발생시키도록 하기 위해 GPT-3를 사용합니다. 그리고 나서 어떤 세트가 correct한지 를 알아내기 위해 그들의 관계들을 분석합니다. 이 테크닉은 2022년 5월에 정재훈 등에 의해 만들어진 coined maieutic 프롬프팅입니다. (maieutic은 아이디어를 이끌어내기 위해 질문하는 소크라테스 식 방법과 관련 돼 있습니다.)
이 방법은 복잡합니다. 아래와 같이 작동합니다.
First, build a maieutic tree, where each node is a statement that could be true or false:
첫째로 maieutic tree를 만듭니다. 각 노드는 참이나 거짓이 될 수 있는 하나의 statement 입니다.
Start with a multiple-choice question or true/false statement (e.g.War cannot have a tie)
객관식 질문 또는 참/거짓을 답할 수 있는 질문으로 시작합니다. (예. 전쟁은 무승부일 수 없다)
For each possible answer to the question, use the model to generate a corresponding explanation (with a prompt likeWar cannot have a tie? True, because)
질문에 대해 각각의 가능한 answer 들에 대해 각각 상응하는 explanation을 생성하도록 모델을 사용합니다. (전쟁은 무승부일 수 없다? 참, 왜냐하면... 같은 프롬프트가 될 것입니다.)
Then, prompt the model with the question and the generated explanation, and ask it to produce the answer. If reversing the explanation (with a prefix likeIt is wrong to say that {explanation}) reverses the answer, then the explanation is considered 'logically integral.'
그런 다음 질문과 생성된 explanation으로 모델의 프롬프트를 만듭니다. 그리고 나서 답을 만들도록 요청합니다. 만약 설명을 뒤집으면 (예를 들어 {explanation} 이라고 얘기하면 틀립니다와 같은 prifix를 만드는 방법)답도 뒤집어 집니다. 그러면 explanation은 "logically integral" 로 간주되게 됩니다.
If an explanation is not logically integral, then repeat the above process recursively, with each explanation turned into a True or False question, and generate more explanations for each new question.
만약 explanation이 logically integral 되지 않았다면 위의 과정을 재귀적으로 반복합니다. (이 때 각각의 explanation은 True 나 False question으로 바뀌게 되는 것이죠. 그리고 각각의 새로운 질문들에 대한 좀 더 많은 explanation들을 생성합니다.
After all of the recursive explaining is done, you end up with a tree of explanations, where each leaf on the tree has the property that reversing the explanation reverses the model's answer.
이렇게 모든 재귀적인 explaining이 종류된 후에 explanation tree를 얻게 됩니다. 나무에 있는 각각의 leaf (잎)들은 explanation을 뒤집으면 모델의 답도 뒤집어지는 그런 프로퍼티를 갖게 됩니다.
Second, convert the tree into a graph of relations:
두번째, 그 tree를 관계 그래프로 변환합니다.
For each node in the tree, calculate the model's relative belief in each node (inferred from the probability of getting an answer ofTrueto given an explanation)
그 나무의 각각의 노드들은 각 노드에 대한 모델의 상대적 신뢰도를 계산하게 됩니다. (주어진 explanation에 True라는 답을 얻기 위한 추정치로 부터 추론 합니다.)
For each pair of nodes in the tree, use the model to identify whether they are entailed (implied) or contradicted
그 나무에 있는 노드들의 각 쌍들에 대해 그 쌍들이 그것들이 entailed (implied) 인지 contradicted (모순)인지의 여부를 모델을 사용하여 판정합니다.
Third, find the most consistent set of beliefs and take those to be true:
세번째, 가장 일관성 있는 belief들을 찾아내서 그것들을 true라고 작업합니다.
Specifically, using the strength of belief in each node and the logical relationships between them, formulate the problem as a weighted maximum satisfiability problem (MAX-SAT)
특히 각 노드의 신뢰도의 강도와 그들간의 논리적인 관계를 사용하여 weighted maximum satisfiability problem (MAX-SAT)로 그 문제를 공식화 합니다.
Use a solver to the find the most self-consistent set of beliefs, and take those as true
Solver를 사용하여 가장 self-consistent 한 belief들의 세트를 찾아 냅니다. 그리고 그것들을 true로 취합니다.
descrete set의 답변이 있는 task에 대해 신뢰도를 제고시킬 수 있는 간단한 방법 중 하나는 모델에서 여러 explanation 및 답변을 샘플링 한 다음에 (positive temperature를 사용) 가장 자주 등장하는 답변을 최종 답변으로 선택하는 겁니다.
이 테크닉은 여러 수학과 reasoning benchmark들에서 정확도를 1~24 퍼센트 향상 시켰습니다. (아래 도표는 구글의 LamDa 모델의 결과 입니다. 구글의 larger PaLM 모델을 사용했습니다. 기준선은 높지만 그로부터 얻는 것은 약간 좀 더 작았습니다.)
이 테크닉은 구현이 간단하지만 비용이 많이 들 수 있습니다. 10개의 답변 세트를 생성하면 비용이 10배 증가합니다.
또한 많은 이러한 기술들과 마찬가지로 제한된 답변 세트가 있는 작업에만 적용할 수 있습니다. 각 답변이 유니크한 (시를 쓰는 것 처럼) 각각의 답변이 있는 open-ended 작업에 대해 가장 일반적인 답변을 하나 선택한다는 것은 과연 유의미한 건가에 대해서는 확언할 수는 없습니다.
마지막으로, 이 테크닉은 답을 얻기 위해 여러 경로나 여러 구문들이 있는 경우에 가장 유용합니다. 답변에 이르는 경로가 오직 하나 뿐이면 이 테크닉은 전혀 도움이 되지 않을 수 있습니다. 극단적인 예로 이 작업이 single token answer를 생성하는 것이라면 100개의 생성된 토큰 중 가장 일반적인 것을 가져오는 것은 가장 높은 logprobs(temperature=0 으로 생성된) 로 생성된 토큰을 가져오는 것과 다른 것이 없습니다.
Verifiers
작업 성능을 개선하기 위한 또 다른 주요한 테크닉은 main generative 모델의 output들을 평가하기 위한 verifier(검증자) 혹은 discriminator(판별자) 모델을 훈련 시키는 겁니다. 이 판별자가 output을 reject 한다면 acceptable output을 얻을 때까지 generative 모델을 resample 할 수 있습니다. 많은 경우 답을 만드는 것 보다 답을 판단하는 것이 더 쉽기 때문에 이 방법의 power를 설명하는데 도움이 됩니다.
Method
2021년에 OpenAI 연구자들은 이 테크닉을 아래와 같은 절차들을 사용해서 초등학교 수학 문제에 적용했습니다.
First, they fine-tuned a model on questions and solutions
우선 질문과 솔루션에 대한 모델을 fine-tune 합니다.
For each problem in the training set, they generated 100 solutions
훈련 세트에 있는 각 문제들에 대해 100개의 솔루션들을 생성합니다.
Each of those 100 solutions was automatically labeled as either correct or incorrect, based on whether the final answer was correct
그 100개의 솔루션 각각은 정답인지 오답인지 자동적으로 label 됩니다. (정답/오답 근거는 최종 대답이 올바른지의 여부에 근거합니다.)
Using those solutions, with some labeled correct and some labeled incorrect, they fine-tuned a verifier model to classify whether a question and candidate solution was correct or incorrect
이러한 솔루션을 사용하여 만든 어떤 레이블들은 옳고 또 어떤 레이블들은 그렇지 않았습니다. 그들은 문제와 후보 솔루션이 옳은지 옳지 않은지를 구별하는 verifier 모델을 fine-tune 했습니다.
Finally, at test time, the generative model creates 100 solutions to each problem, and the one with the highest score according to the verifier model is picked as the final answer
마지막으로 테스트 할 때 generative 모델은 각 문제당 100개의 솔루션들을 만들었습니다. 그리고 그 verifier 모델에 의해 가장 높은 점수를 얻은 솔루션을 최종 답변으로 선택합니다.
이러한 테크닉들을 확률적 그래픽 모델로서 공식화 하는 것은 특정 문제를 해결하는데 곧바로 유용한 방법으로 사용할 수는 없을 수 있습니다. 하지만 이 프레임워크는 새로운 기술을 선택, 결합 그리고 발견하는데 도움이 될 수 있습니다.
Closing thoughts
Large language 모델을 연구하는 것은 매우 활발하고 빠르게 발전하고 있습니다. 연구자들은 계속해서 모델을 개선할 뿐만 아니라 모델을 가장 잘 활용하는 방법에 대한 이해도 지속적으로 향상 시키고 있습니다. 위에서 공유한 모든 논문은 지난 12개월 이내에 출판된 것이라는 것이 최근에 더욱 활발하고 빠르게 발전하고 있다는 것을 보여 줍니다. (이 글은 2022년 9월에 작성함)
앞으로 더 나은 모델과 더 나은 기술이 발표 될 것으로 기대합니다. 여기에서 다룬 특정 기술이 미래의 새로운 모범 사례에 의해 잊혀지더라도 그 모델들에서 제시한 일반 원칙은 다른 전문가들의 유용한 도구의 핵심 개념으로 남을 것입니다.
Bibliography
Lesson Paper Date
Break complex tasks into simpler subtasks (and consider exposing the intermediate outputs to users)
기본적으로 OpenAI Completions api 콜을 하면 Request된 Prompt에 대해 작업을 완료 한 다음 하나의 response로 답을 보내 옵니다.
davinci 모델의 경우 아주 긴 completion을 생성하게 되면 응담까지 몇초가 걸릴 수 있습니다. 2022년 8월 현재 text-davinci-002 모델의 응답시간은 일반적으로 100 completion token당 1초에서 2초 정도가 걸립니다.
이 정도도 기다리지 않고 더 빨리 응답을 받고 싶으면 Stream을 사용하실 수 있습니다.
이렇게 되면 Request된 Prompt에 대한 답을 완료하기 전에 일부분에 대한 답을 받아서 인쇄를 시작하거나 Completion 의 시작 부분을 처리할 수 있습니다.
Completions를 stream 하려면 API를 호출 할 때 stream=True를 사용하시면 됩니다. 이렇게 하면 data-only 서버가 보낸 이벤트와 같이 텍스트를 streams back 하는 object를 return 하게 됩니다. (답변의 일부분이라도 완료 되면 그 일 부분들을 계속 해서 stream으로 응답을 보내 온 다는 얘기 입니다.)
Downsides
주의 할 점은 프로덕션 어플리케이션에서 stream=True를 사용하면 completions 의 내용을 조정하기가 더 어려워 집니다.
(streaming 되는 동안 답변의 일부분만 가지고 있기 때문에 전체 답변에 대한 보정이나 처리 작업을 하는데는 한계가 있다는 얘기 입니다.)
이 Streaming response의 다른 작은 단점은 Response에 사용된 토큰 수를 알려 주는 정보가 없다는 겁니다.
해당 토큰수를 알려면 모든 응답을 결합한 후 toktoken을 사용해서 직접 계산 해야 합니다.
Example code
아래에 이 streaming completions를 어떻게 사용하는지에 대한 파이썬 예제가 있습니다.
# imports
import openai # for OpenAI API calls
import time # for measuring time savings
우선 openai를 import 합니다. 그리고 응답 시간을 알아보기 위해 time 모듈도 import 합니다.
# Example of an OpenAI Completion request
# https://beta.openai.com/docs/api-reference/completions/create
# record the time before the request is sent
start_time = time.time()
# send a Completion request to count to 100
response = openai.Completion.create(
model='text-davinci-002',
prompt='1,2,3,',
max_tokens=193,
temperature=0,
)
# calculate the time it took to receive the response
response_time = time.time() - start_time
# extract the text from the response
completion_text = response['choices'][0]['text']
# print the time delay and text received
print(f"Full response received {response_time:.2f} seconds after request")
print(f"Full text received: {completion_text}")
이 방법은 stream을 사용하지 않은 일반적인 방법입니다.
openai.Completion.create() 파라미터를 보면 stream=True 부분이 없습니다. 즉 응답받는데 streaming을 사용하지 않는 겁니다.
openai.COmpletion.create() api를 호출하기 전 시간을 start_time에 담고 호출 한 후의 시간을 response_time에 담았습니다.
response 받은 데이터 중 choices의 첫번째 아이템에 있는 text 부분만 떼어내서 completion_text 에 담습니다.
그런 다음 전체 소요 시간을 print 하고 두번째 print에서는 completion_text를 print 합니다.
저는 위 소스코드를 조금 수정해서 openaiapikey를 text 파일에서 읽어와서 인증 받는 부분을 추가했고 Completion api를 호출할 때 davinci보다 저렴한 ada 모델을 사용하는 것으로 했습니다.
응답은 2.86초 걸렸고 그 내용은 Full text received 에 있습니다.
A streaming completion request
# Example of an OpenAI Completion request, using the stream=True option
# https://beta.openai.com/docs/api-reference/completions/create
# record the time before the request is sent
start_time = time.time()
# send a Completion request to count to 100
response = openai.Completion.create(
model='text-ada-001', #model='text-davinci-002',
prompt='1,2,3,',
max_tokens=193,
temperature=0,
stream=True, # this time, we set stream=True
)
# create variables to collect the stream of events
collected_events = []
completion_text = ''
# iterate through the stream of events
for event in response:
event_time = time.time() - start_time # calculate the time delay of the event
collected_events.append(event) # save the event response
event_text = event['choices'][0]['text'] # extract the text
completion_text += event_text # append the text
print(f"Text received: {event_text} ({event_time:.2f} seconds after request)") # print the delay and text
# print the time delay and text received
print(f"Full response received {event_time:.2f} seconds after request")
print(f"Full text received: {completion_text}")
이번에는 Streaming을 사용하는 에제입니다.
openai.Completion.create() 의 파라미터를 보면 stream=True 를 추가 하신것을 보실 수 있습니다.
이것이 streaming을 사용하는 방법 입니다.
그 이후의 코드들은 이 스트리밍을 어떻게 receive 하는지 print 해주기 위해 만든 스크립트 들 입니다.
for 문이 있는데 이 for 문에서는 response 에 발생한 이벤트만큼 실행 됩니다.
이벤트가 일어날 때마다 그 이벤트 시각에서 start_time을 뺍니다. 즉 Completion api 콜 한 시점에서 그 이벤트가 일어난 시점까지의 시간을 알기 위해서 이런 계산을 합니다. 그 값은 event_time에 저장 됩니다.
그리고 collected_events에 이 이벤트를 append 합니다.
그리고 그 이벤트에서 받은 reponse에서 choices의 첫번째 아이템에 있는 text 내용을 가져 옵니다.
completion_text에는 지금까지 받은 evnet_text에 현재 받은 event_text를 추가 합니다.
그리고 for 문 안에 있는 print 문에서는 응답 내용과 그 응답을 받기 까지 얼마나 걸렸는지를 print 해 줍니다.
for 문이 완료 되면 전체 소요 시간과 전체 응답을 print 합니다.
그러면 아래와 같은 응답을 받습니다.
.......
Stream을 사용하지 않았을 때는 전체 결과 값을 받는데까지 2.86초 걸렸습니다.
그런데 이렇게 Stream을 사용하니까 응답의 시작부분을 0.35초 후부터 받기 시작해서 전체 메세지를 받는데까지 1.52초가 걸렸습니다.
이렇게 streaming 해서 받은 값들을 모두 합한 값은 위에 stream을 사용하지 않았을 때와 동일합니다.
Time comparison
쿡북의 예에서는 Davinci 모델을 사용해서 Stream을 사용하지 않은 경우는 7.32초가 걸렸고 사용한 경우는 7.25초가 걸렸습니다.
둘 다 거의 비슷하게 걸렸지만 streaming을 사용한 경우에는 0.16초가 지나면서부터 응답의 일부를 받기 시작해서 전체 응답을 받기까지 7.25초가 걸린 겁니다.
영어로 된 텍스트인 경우 토큰의 길이는 일반적으로 문자 하나이거나 단어 하나가 한개의 토큰이 됩니다. (e.g., "t" or " great")
다른 언어에서는 한문자보다 짧거나 한단어보다 길 수 있습니다.
공백은 일반적으로 단어의 시작으로 그룹화 됩니다. (e.g., " is" instead of "is " or " "+"is")
OpenAI Tokenizer를 사용해서 문자열이 어떻게 tokenized 되는지 빠르게 체크할 수 있습니다.
0. Installtiktoken
이 tiktoken을 사용하려면 먼저 이 모듈을 인스톨 해야 합니다.
pip install tiktoken
1. Importtiktoken
그러면 이 tiktoken을 import 할 수 있습니다.
import tiktoken
2. Load an encoding
tiktoken.get_encoding()을 사용해서 인코딩을 로딩 합니다. 이 때 인코딩 이름을 파라미터로 전달합니다.
처음 이 작업을 할 때는 인터넷에 연결 돼 있어야 합니다.
한번 로딩한 다음에는 인터넷이 연결 돼 있지 않아도 사용할 수 있습니다.
encoding = tiktoken.get_encoding("gpt2")
3. Turn text into tokens withencoding.encode()
.encode() 메소드는 문자열을 token integer들로 변환합니다.
위에서 tiktoken is great! 이 아래와 같은 토큰들로 나누어 진다고 했습니다.
["t", "ik", "token", " is", " great", "!"]
그렇다면 t는 83이고 ik 는 1134 이고 token 은 30001 ..... 마지막으로 ! 는 0 이 됩니다.
아래 함수는 토큰 갯수를 계산해서 반환해 주는 함수 입니다.
def num_tokens_from_string(string: str, encoding_name: str) -> int:
"""Returns the number of tokens in a text string."""
encoding = tiktoken.get_encoding(encoding_name)
num_tokens = len(encoding.encode(string))
return num_tokens
함수 이름은 num_tokens_from_string() 이고 파라미터로는 String 과 인코딩 이름이 전달 됩니다.
그리고 반환 타입은 integer 입니다.
get_encoding()을 사용해서 사용할 encoding을 정의 합니다.
그리고 len() 함수를 사용해서 인코드해서 얻은 리스트의 아이템 갯수를 num_tokens 변수에 넣습니다.
이 아이템들이 각각의 토큰들 입니다.
이 함수를 사용해서 토큰의 갯수를 아래와 같이 얻을 수 있습니다.
4. Turn tokens into text withencoding.decode()
인코딩이 있으면 디코딩도 있겠죠.
.decode()를 사용하면 숫자로 된 토큰 정보를 문자로 바꿀 수 있습니다.
Warning : .decode()는 single tokens에 적용될 수 있지만 utf-8 boundaries가 아닌 경우 토큰의 손실이 발생 할 수 있습니다.
single tokens의경우 decode_single_token_bytes() 는 단일 정수 토큰을 그것이 나타내는 바이트로 안전하게 변환합니다.
여기서 각 string 앞에 있는 b가 가리키는 것은 이 String들이 byte string들이라는 의미 입니다.
5. Comparing encodings
그렇다면 각 인코딩 별로 어떻게 입력값을 분할 해서 토큰으로 나누는지를 알아 보겠습니다.
def compare_encodings(example_string: str) -> None:
"""Prints a comparison of three string encodings."""
# print the example string
print(f'\nExample string: "{example_string}"')
# for each encoding, print the # of tokens, the token integers, and the token bytes
for encoding_name in ["gpt2", "p50k_base", "cl100k_base"]:
encoding = tiktoken.get_encoding(encoding_name)
token_integers = encoding.encode(example_string)
num_tokens = len(token_integers)
token_bytes = [encoding.decode_single_token_bytes(token) for token in token_integers]
print()
print(f"{encoding_name}: {num_tokens} tokens")
print(f"token integers: {token_integers}")
print(f"token bytes: {token_bytes}")
이 compare_encodings() 함수는 string을 입력 파라미터로 받습니다. return 값은 없고 그냥 이 함수 안에서 계산해서 그 정보를 print 해 줍니다.
첫번째 있는 print 문은 Example string : 입력 받은 문자열 을 출력합니다.
그 다음 for 문이 있는데 각 인코딩 별로 이 for 문안에 있는 작업을 해 줄 겁니다.
우선 get_encoding() 을 사용해서 사용할 encoding을 세팅해 줍니다.
그리고 encode()를 사용해서 토큰으로 나눠 줍니다. (결과값을 리스트 형식으로 반환 합니다.)
그리고 len()을 이용해서 이 리스트안에 있는 아이템 갯수들을 num_tokens에 담습니다.
그리고 decode_single_token_bytes()를 사용해서 각 바이트별 텍스트를 token_bytes에 담습니다.
그 다음 인코딩 이름과 토큰 리스트의 인티저 값 그리고 각 바이트 별 문자를 표시해 줍니다.
이렇게 한 단어인데 긴것을 넣어 봤습니다. 이것은 반체제주의라는 의미라고 합니다.
gpt2와 p50k_base는 5개의 토큰으로 나눴고 cl100k_base는 6개의 토큰으로 나눴습니다.
이 request 수 제한은 API 관리하는 일반적인 관행입니다. 이것을 관리하는 이유는 몇가지 있습니다.
* 첫번째로는 API 남용과 오용으로부터 시스템을 보호하는데 도움을 줍니다. 예를 들어 악의적인 의도를 가지고 API에 과부하를 일으키거나 서비스를 중단시키려는 의도로 API 요청을 다량 발생 시킬 수 있습니다. 이런 악의적인 공격으로 부터 OpenAI API 서비스를 보호하기 위해 Request 수 제한 정책이 필요합니다.
* 둘째로는 이 OpenAI API 자원을 다양한 사람이 공평하게 사용할 수 있도록 하는 목적이 있습니다. 한 개인이나 조직이 과도한 수의 요청을 하면 다른 소비자들의 API 서비스가 중단 될 수 있습니다. 단일 사용자가 만들 수 있는 요청 수를 제한 함으로서 이 API 서비스를 더 많은 사람들이 속도 저하 없이 API를 사용할 수 있는 기회를 더 보장할 수 있습니다.
* 세번째 마지막으로 이 요청량 제한은 OpenAI 가 인프라의 총 부하를 관리하는데 도움이 될 수 있습니다. API에 대한 요청이 급격하게 증가하면 서버에 부담을 주고 성능에 문제를 일으킬 수 있습니다. 이 요청량 베한을 설정함으로서 OpenAI는 모든 사용자에게 원활하고 일관된 경험을 유지하는데 도움을 줄 수 있습니다.
API 요청들이 너무 빨리 보내지면 아래 요청량 제한 에러가 발생합니다. OpenAI 파이썬 라이브러리를 사용한다면 그 에러 메세지는 아래와 같을 겁니다.
아래 코드는 요청량 제한을 초과하는 한 예를 보여 줍니다.
import openai # for making OpenAI API requests
# request a bunch of completions in a loop
for _ in range(100):
openai.Completion.create(
model="code-cushman-001",
prompt="def magic_function():\n\t",
max_tokens=10,
)
저는 굳이 이 코드는 실행해 보지 않겠습니다.
코드는 그냥 간단합니다. max_tokens를 10으로 설정한 다음에 Completion.create() api를 100번 요청하는 for 문 입니다.
How to avoid rate limit errors
Retrying with exponential backoff
이 요청량 제한 오류를 방지하는 쉬운 방법 중 하나는 random exponential backoff로 요청을 자동적으로 재 시도 하는 겁니다.
exponential backoff로 retry를 한다는 의미는 요청량 제한 에러에 도달했을 때 잠시 쉬었다가 실패한 요청을 다시 요청한다는 겁니다. 만약 그 요청이 또다시 실패 한다면 잠시 쉬는 시간이 좀 더 늘어나고 그 다음에 요청하는 과정을 반복하는 겁니다. 이 과정은 요청이 성공할 때까지 이루어지게 할 수도 있고 특정 시도 횟수를 지정해서 그 횟수 만큼만 실행하게 할 수도 있습니다.
이 접근법은 다음과 같은 이점이 있습니다.
* 자동재시도는 crash나 데이터 손실 없이 요청량 제한 에러를 극복할 수 있다는 의미입니다.
* Exponential backoff는 첫번째 시도를 빠르게 시도할 수 있음을 의미하며 처음 몇번의 재시도가 실패할 경우 점점 더 재시도까지의 쉬는 시간이 점점 더 길어진다는 겁니다. 그렇기 때문에 초기에 성공하면 좀 더 빠른 시간안에 에러를 복구 할 수 있습니다.
* Random jitter를 추가하면 동시에 모든 hitting으로부터 재시도를 하는데 도움을 줍니다.
Note. 실패한 요청은 여러분의 per-minute limit에 포함 되므로 계속 재시도를 해도 작동하지 않을 수 있습니다.
아래에 이 방법을 이용하는 몇가지 방법을 소개합니다.
Example #1: Using the Tenacity library
Tenacity 는 파이썬으로 작성된 아파치 2.0 라이센스 범용 retrying 라이브러리 입니다. 이것을 이용하면 거의 모든 상황에 재시도 동작을 추가하는 작업을 단순화 할 수 있습니다.
요청에 exponential backoff를 추가하려면 tenacity.retrydecorator를 사용하면 됩니다.
tenacity.wait_random_exponential 함수를 사용하여 random exponential backoff를 요청에 추가하는 방법을 아래 예제에서 보여 줍니다.
Note : Tenacity 라이브러리는 별도로 개발한 회사가 있고 그 회사가 배포한 라이브러리 입니다. OpenAI에서 그 안정성이나 보안을 보장하지는 않습니다.
import openai # for OpenAI API calls
from tenacity import (
retry,
stop_after_attempt,
wait_random_exponential,
) # for exponential backoff
@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
def completion_with_backoff(**kwargs):
return openai.Completion.create(**kwargs)
completion_with_backoff(model="text-davinci-002", prompt="Once upon a time,")
@retry() 를 사용하며 wait과 stop을 지정합니다.
재시도 사이 대기시간이 1초에서 60초 사이가 되고 재시도는 6번 시도하라는 겁니다.
이것은 그 아래 함수인 Completion_with_backoff() 함수에 적용 됩니다.
Tenacity와 마찬가지로 Backoff 라이브러리는 third-party tool 입니다. OpenAI에서 그 안정성이나 보안성을 보장하지는 않습니다.
import backoff # for exponential backoff
import openai # for OpenAI API calls
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def completions_with_backoff(**kwargs):
return openai.Completion.create(**kwargs)
completions_with_backoff(model="text-davinci-002", prompt="Once upon a time,")
이런 3rd-party 툴을 사용하지 않고 직접 backoff 로직을 구현할 수도 있습니다.
# imports
import random
import time
import openai
# define a retry decorator
def retry_with_exponential_backoff(
func,
initial_delay: float = 1,
exponential_base: float = 2,
jitter: bool = True,
max_retries: int = 10,
errors: tuple = (openai.error.RateLimitError,),
):
"""Retry a function with exponential backoff."""
def wrapper(*args, **kwargs):
# Initialize variables
num_retries = 0
delay = initial_delay
# Loop until a successful response or max_retries is hit or an exception is raised
while True:
try:
return func(*args, **kwargs)
# Retry on specified errors
except errors as e:
# Increment retries
num_retries += 1
# Check if max retries has been reached
if num_retries > max_retries:
raise Exception(
f"Maximum number of retries ({max_retries}) exceeded."
)
# Increment the delay
delay *= exponential_base * (1 + jitter * random.random())
# Sleep for the delay
time.sleep(delay)
# Raise exceptions for any errors not specified
except Exception as e:
raise e
return wrapper
@retry_with_exponential_backoff
def completions_with_backoff(**kwargs):
return openai.Completion.create(**kwargs)
completions_with_backoff(model="text-davinci-002", prompt="Once upon a time,")
이 에제를 보면 위에서 설명했던 동작인 요청하고 error가 발생하면 재시도를 정해진 횟수만큼 하고 그 재시도 사이의 지연 시간은 점차 증가해 나가는 동작을 하도록 직접 wrapper() 함수 안에 구현을 해 놨습니다.
그리고 최대 재시도 횟수와 지연시간 관련 값들은 retry_with_exponential_backoff() 함수에서 세팅을 했습니다.
그리고 위에 설명한 wrapper() 함수는 이 retry_with_exponential_backoff() 함수에 속해 있습니다.
How to maximize throughput of batch processing given rate limits
만약 여러분의 애플리케이션이 고객의 실시간 요청을 처리하는 서비스를 제공한다면 backoff and retry는 요청량 제한 에러를 피하면서 latency를 minimize할 수 있는 아주 좋은 전략입니다.
그런데 이렇게 서비스 제공 시간이 중요한게 아니라 얼마나 많은 양을 처리하느냐가 더 중요한 애플리케이션이 있을 수 있습니다. 대량의 batch data를 처리하는 것이 더 중요한 경우이죠. 이런 경우 backoff and retry 말고 여러분이 사용할 수 있는 몇가지 다른 방법이 있습니다.
Proactively adding delay between requests
만약 여러분의 앱이 요청량 제한에 걸리고 back off 하고 재시도하고 하는 상황이 계속 반복 되면서 금방 요청량 제한에 걸린다면 남아 있는 시간은 제한량 초과 메세지만 받으면서 요청을 계속 할 수 있습니다. (예를 들어 1분에 20회가 제한량인데 이 20회가 10초만에 도달하면 나머지 50초는 제한량 초과 메세지만 받게 될 것입니다.) 그러면 이 50초 동안의 요청은 낭비 되는 것이죠. 그것을 하기 위해 사용한 내 시스템의 리소스가 낭비 되는 것입니다.
이 경우 잠재적 해결책이 될 수 있는 것은 여러분의 요청량 제한을 계산하고 그 reciprocal에 맞게 지연 시간을 만드는 것입니다.
reciprocal(예: 만약 여러분의 요청량 제한이 분당 20이라면 각 request마다 지연시간을 3~6초씩 추가 해 주는 것)
이렇게 하면 요청량 제한의 상한선에 도달하지 않고 낭비되는 요청도 발생 시키지 않는 상황에 가깝게 만들 수 있습니다.
Example of adding delay to a request
# imports
import time
import openai
# Define a function that adds a delay to a Completion API call
def delayed_completion(delay_in_seconds: float = 1, **kwargs):
"""Delay a completion by a specified amount of time."""
# Sleep for the delay
time.sleep(delay_in_seconds)
# Call the Completion API and return the result
return openai.Completion.create(**kwargs)
# Calculate the delay based on your rate limit
rate_limit_per_minute = 20
delay = 60.0 / rate_limit_per_minute
delayed_completion(
delay_in_seconds=delay,
model="text-davinci-002",
prompt="Once upon a time,"
)
이 소스 코드는 위에 예시로 들었던 상황에 맞게 만든 겁니다.
요청량 제한이 분당 20이라면 delay는 60/20 즉 3초가 됩니다.
delay_completion() 함수 안데 time.sleep() 을 이 3초로 했기 때문에 이 함수를 호출할 때 마다 3초씩 기다렸다가 openai.Completion.create() api 를 사용하게 되는 겁니다.
그러면 이 1분이라는 시간에 할 수 있는 요청량을 최대한으로 사용할 수 있게 됩니다.
단 10초만에 요청량 제한에 걸려서 나머지 50초는 그냥 손 놓고 있는 상황을 피할 수 있게 되는 거죠.
Batching requests
OpenAI api에는 분당 요청량 제한 이외에 분당 요청 토큰에 대한 별도의 제한이 있습니다.
만약 여러분이 분당 요청량 제한에 도달했지만 분당 토큰에 여유가 있는 경우 각 요청에 여러 작업을 batch 함으로서 throughput(처리량)을 증가시킬 수 있습니다.
프롬프트들의 batch를 보내는 방법은 일반적인 API 콜과 동일하게 작동합니다.
단지 프롬프트 파라미터가 Single string이 아니라 String 의 List라는 것만 다릅니다.
Warning: Response 는 그 prompt 의 순서대로 반환을 하지 않을 수 있습니다. 그렇기 때문에 index 필드를 사용하여 그 response를 prompt 의 파라미터 순서와 맞게 일치시키는 작업을 반드시 해야 합니다.
Example without batching
import openai # for making OpenAI API requests
num_stories = 10
prompt = "Once upon a time,"
# serial example, with one story completion per request
for _ in range(num_stories):
response = openai.Completion.create(
model="curie",
prompt=prompt,
max_tokens=20,
)
# print story
print(prompt + response.choices[0].text)
Example with batching
import openai # for making OpenAI API requests
num_stories = 10
prompts = ["Once upon a time,"] * num_stories
# batched example, with 10 stories completions per request
response = openai.Completion.create(
model="curie",
prompt=prompts,
max_tokens=20,
)
# match completions to prompts by index
stories = [""] * len(prompts)
for choice in response.choices:
stories[choice.index] = prompts[choice.index] + choice.text
# print stories
for story in stories:
print(story)
위의 예제는 prompt 'once upon a time' 단일 파라미터로 하는 openai.Completion.create() 호출을 for 문을 통해서 10번 일으켰습니다.
즉 10번 요청을 한 것입니다.
그런데 두번째 예제는 prompt 자체를 Once upon a time이 10번 들어가 있는 리스트로 만든 다음 이 리스트를 파라미터로 전달해서 openai.Completion.create() api를 호출 했습니다.
즉 1번 요청한 것입니다.
이렇게 함으로서 요청량을 줄일 수 있게 되는 것입니다.
두번째 예제의 첫번째 for 문에서는 response를 request의 index 와 맞게 매치 시키는 작업을 하고 있습니다.
그래서 질문 + 응답 이런 식으로 stories[] 에 저장되게 했습니다.
이제 이 stories[]를 두번째 for 문처럼 print 하기만 하면 해당 질문과 그에 대한 답변 식으로 출력이 됩니다.
Example parallel processing script
대량의 API 요청을 parallel (병렬) 처리하기 위한 예제 스크립트는 아래에 있습니다.
오늘 예제는 이 모델의 최대 context 길이보다 더 긴 텍스트는 어떻게 처리를 해야 하는지를 보여 줍니다.
1. Model context length
import openai
from tenacity import retry, wait_random_exponential, stop_after_attempt, retry_if_not_exception_type
EMBEDDING_MODEL = 'text-embedding-ada-002'
EMBEDDING_CTX_LENGTH = 8191
EMBEDDING_ENCODING = 'cl100k_base'
# let's make sure to not retry on an invalid request, because that is what we want to demonstrate
@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6), retry=retry_if_not_exception_type(openai.InvalidRequestError))
def get_embedding(text_or_tokens, model=EMBEDDING_MODEL):
return openai.Embedding.create(input=text_or_tokens, model=model)["data"][0]["embedding"]
가장 먼저 openai를 import 하고 그 다음에 tenacity 모듈을 import 합니다.
tenacity는 런타임 중 오류가 발생해서 종료가 될 때 이 종료하는 것을 막고 다시 retry 하고자 할 때 사용하는 파이썬 모듈입니다.
이 모듈 중에서 retry, wait_random_exponential, Stop_after_attempt, retry_if_not_exception_type 만 import 합니다.
(이렇게 하면 @tenacity.retry 라고 하지 않고 간단하게 @retry 형식으로 사용할 수 있습니다.)
그 다음은 openai 모델을 설정하고 context length 를 8191 로 지정하고 encoding은 cl100k_base 로 합니다.
cl100k_base 는 tokenizer로 Max Input Token은 8191 로 정해져 있습니다. 2021년 9월에 발표 됐습니다.
자세한 내용은 OpenAI Guide의 Embeddings Overview 페이지를 참조하세요.
그 다음 은 @retry 구문이 나옵니다. retry 사이에 기다리는 시간은 1~20초이고 6번 까지 시도하고 exception type이 InvalidRequestError 가 아닌 경우만 retry를 시도합니다. InvalidRequest인 경우는 Retry를 해도 아무 소용 없으니까요.
그 다음은 get_embedding() 함수를 만들었습니다.
입력 파라미터로는 text_or_tokens와 모델 이름을 받습니다.
그리고 이 입력값에 대한 embedding 값을 전달받은 모델을 사용해서 openai.Embedding.create() api로 부터 받고 그 값을 return 합니다.
여기서 크기는 토큰으로 정해지기 때문에 먼저 입력값이 몇개의 토큰으로 이루어져 있는지 알아봐야 합니다.
위 Tokenizer 페이지에서 그 작업을 했었죠. 10001 이었습니다. 그리고 위에서 사용한 모델은 8191 개의 토큰이 입력 허용 최대값이구요.
아래 방법이 이렇게 입력값을 토큰화 해서 자르는 부분입니다.
import tiktoken
def truncate_text_tokens(text, encoding_name=EMBEDDING_ENCODING, max_tokens=EMBEDDING_CTX_LENGTH):
"""Truncate a string to have `max_tokens` according to the given encoding."""
encoding = tiktoken.get_encoding(encoding_name)
return encoding.encode(text)[:max_tokens]
from itertools import islice
def batched(iterable, n):
"""Batch data into tuples of length n. The last batch may be shorter."""
# batched('ABCDEFG', 3) --> ABC DEF G
if n < 1:
raise ValueError('n must be at least one')
it = iter(iterable)
while (batch := tuple(islice(it, n))):
yield batch
우선 itertools 의 islice 함수를 import 합니다.
그리고 batched() 함수를 만들고 입력값으로는 iterable과 n을 받습니다.
그 다음 입력 받은 데이터를 길이가 n인 tuple로 batch 처리 합니다. 마지막 batch는 길이가 n 보다 작을 수 있습니다.
{"text": " Morada Limited is a textile company based in Altham Lancashire. Morada specializes in curtains.", "category": "Company"} {"text": " The Armenian Mirror-Spectator is a newspaper published by the Baikar Association in Watertown Massachusetts.", "category": "WrittenWork"}
text 와 category 두 항목이 있습니다.
text는 한 문장이 있고 category에는 말 그대로 카테고리들이 있습니다.
어떤 카테고리들이 있고 각 카테고리는 몇개씩 있는지 알아 보겠습니다.
여기서는 pandas 모듈을 사용합니다.
read_json()을 사용해서 데이터세트를 읽어 옵니다. (samples)
그리고 이 데이터세트의 category를 수집해서 unique 한 리스트를 만든 후 정렬을 합니다. (categories)
print("Categories of DBpedia samples:", samples["category"].value_counts())
이것을 위 방식으로 프린트를 하면 이런 결과를 얻습니다.
카테고리는 총 14개가 있고 그 중에 가장 많이 있는 카테고리는 Artist 로 21번 나옵니다.
그 외에 다른 카테고리들과 각 카테고리별 갯수를 표시합니다.
그리고 samples.head() 를 하면 아래 결과를 얻습니다.
text와 category를 표 형식으로 보여 줍니다. head()를 사용하면 디폴트로 상위 5줄을 print 합니다.
그 다음은 openai api를 이용해서 각 text별로 임베딩 값을 받아 옵니다.
import openai
from openai.embeddings_utils import get_embeddings
def open_file(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return infile.read()
openai.api_key = open_file('openaiapikey.txt')
# NOTE: The following code will send a query of batch size 200 to /embeddings
matrix = get_embeddings(samples["text"].to_list(), engine="text-embedding-ada-002")
embeddings_utils 의 get_embeddings를 사용해서 각 text 별로 openai로 부터 임베딩 값을 받아 옵니다.
Note : openai api는 유료입니다. 200개의 데이터에 대한 임베딩값을 받아오는데 대한 과금이 붙습니다.
t-SNE decomposition (분해)를 사용해서 dimensionality를 2차원으로 줄입니다.
import pandas as pd
from sklearn.manifold import TSNE
import numpy as np
# Load the embeddings
datafile_path = "data/fine_food_reviews_with_embeddings_1k.csv"
df = pd.read_csv(datafile_path)
# Convert to a list of lists of floats
matrix = np.array(df.embedding.apply(eval).to_list())
# Create a t-SNE model and transform the data
tsne = TSNE(n_components=2, perplexity=15, random_state=42, init='random', learning_rate=200)
vis_dims = tsne.fit_transform(matrix)
vis_dims.shape
모듈은 pandas, numpy 그리고 sklearn.manifold의 TSNE를 사용합니다.
모두 이전 글에서 배운 모듈들 입니다.
판다스의 read_csv() 함수를 사용해서 csv 데이터 파일을 읽습니다.
그 다음 numpy 의 array()를 사용해서 csv 파일의 embedding 컬럼에 있는 값들을 리스트 형식으로 변환합니다.
이 값을 shape을 이용해서 리스트의 크기와 차원을 표시하면 위에 처럼 1000,2 라고 나옵니다.
2. Plotting the embeddings
위에서 처럼 2차원으로 데이터를 정리하면 2D 산점도 분포도를 그릴 수 있다고 했습니다.
아래에서는 그것을 그리기 전에 알아보기 쉽도록 각 review에 대한 색을 지정해서 알아보기 쉽도록 합니다.
이 색은 별점 점수와 ranging 데이터를 기반으로 빨간색에서 녹색에 걸쳐 표현됩니다.
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
colors = ["red", "darkorange", "gold", "turquoise", "darkgreen"]
x = [x for x,y in vis_dims]
y = [y for x,y in vis_dims]
color_indices = df.Score.values - 1
colormap = matplotlib.colors.ListedColormap(colors)
plt.scatter(x, y, c=color_indices, cmap=colormap, alpha=0.3)
for score in [0,1,2,3,4]:
avg_x = np.array(x)[df.Score-1==score].mean()
avg_y = np.array(y)[df.Score-1==score].mean()
color = colors[score]
plt.scatter(avg_x, avg_y, marker='x', color=color, s=100)
plt.title("Amazon ratings visualized in language using t-SNE")
그리고 plt.title()에서 이 표의 제목을 정해주면 결과와 같은 그림을 얻을 수 있습니다.
4개의 그룹중에 녹색 그룹은 다른 그룹들과 좀 동떨어져 있는 것을 보실 수 있습니다.
2. Text samples in the clusters & naming the clusters
지금까지는 raw data를 clustering 하는 법과 이 clustering 한 데이터를 시각화 해서 보여주는 방법을 보았습니다.
이제 openai의 api를 이용해서 각 클러스터의 랜덤 샘플들을 보여 주는 코드입니다.
openai.Completion.create() api를 사용할 것이고 모델 (engine)은 text-ada-001을 사용합니다.
prompt는 아래 질문 입니다.
What do the following customer reviews have in common?
그러면 각 클러스터 별로 review 를 분석한 값들이 response 됩니다.
우선 아래 코드를 실행 해 보겠습니다.
import openai
def open_file(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return infile.read()
openai.api_key = open_file('openaiapikey.txt')
# Reading a review which belong to each group.
rev_per_cluster = 5
for i in range(n_clusters):
print(f"Cluster {i} Theme:", end=" ")
reviews = "\n".join(
df[df.Cluster == i]
.combined.str.replace("Title: ", "")
.str.replace("\n\nContent: ", ": ")
.sample(rev_per_cluster, random_state=42)
.values
)
response = openai.Completion.create(
engine="text-ada-001", #"text-davinci-003",
prompt=f'What do the following customer reviews have in common?\n\nCustomer reviews:\n"""\n{reviews}\n"""\n\nTheme:',
temperature=0,
max_tokens=64,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
print(response)
openai를 import 하고 openai api key를 제공하는 부분으로 시작합니다.
그리고 rev_per_cluster는 5로 합니다.
그 다음 for 문에서 n_clusters만큼 루프를 도는데 위에서 n_clusters는 4로 설정돼 있었습니다.
reviews에는 Title과 Content 내용을 넣는데 샘플로 5가지를 무작위로 뽑아서 넣습니다.
그리고 이 reviews 값을 prompt에 삽입해서 openai.Completion.create() api로 request 합니다.
그러면 이 prompt에 대한 response 가 response 변수에 담깁니다.
이 response 만 우선 출력해 보겠습니다.
Cluster 0 Theme: {
"choices": [
{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"text": " Customer reviews:gluten free, healthy bars, content:\n\nThe customer reviews have in common that they save money on Amazon by ordering by themselves by looking for gluten free healthy bars. The bars are also delicious."
}
],
"created": 1677191195,
"id": "cmpl-6nEKppB6SqCz07LYTcaktEAgq06hm",
"model": "text-ada-001",
"object": "text_completion",
"usage": {
"completion_tokens": 44,
"prompt_tokens": 415,
"total_tokens": 459
}
}
Cluster 1 Theme: {
"choices": [
{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"text": " Cat food\n\nMessy, undelicious, and possibly unhealthy."
}
],
"created": 1677191195,
"id": "cmpl-6nEKpGffRc2jyJB4gNtuCa09dG2GT",
"model": "text-ada-001",
"object": "text_completion",
"usage": {
"completion_tokens": 15,
"prompt_tokens": 529,
"total_tokens": 544
}
}
Cluster 2 Theme: {
"choices": [
{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"text": " Coffee\n\nThe customer's reviews have in common that they are among the best in the market, Rodeo Drive, and that the customer is able to enjoy their coffee half and half because they have an Amazon account."
}
],
"created": 1677191196,
"id": "cmpl-6nEKqxza0t8vGRAiK9K5RtCy3Gwbl",
"model": "text-ada-001",
"object": "text_completion",
"usage": {
"completion_tokens": 45,
"prompt_tokens": 443,
"total_tokens": 488
}
}
Cluster 3 Theme: {
"choices": [
{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"text": " Customer reviews of different brands of soda."
}
],
"created": 1677191196,
"id": "cmpl-6nEKqKuxe4CVJTV4GlIZ7vxe6F85o",
"model": "text-ada-001",
"object": "text_completion",
"usage": {
"completion_tokens": 8,
"prompt_tokens": 616,
"total_tokens": 624
}
}
이 respons를 보시면 각 Cluster 별로 응답을 받았습니다.
위에 for 문에서 각 클러스터별로 request를 했기 때문입니다.
이제 이 중에서 실제 질문에 대한 답변인 choices - text 부분만 뽑아 보겠습니다.
import openai
def open_file(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return infile.read()
openai.api_key = open_file('openaiapikey.txt')
# Reading a review which belong to each group.
rev_per_cluster = 5
for i in range(n_clusters):
print(f"Cluster {i} Theme:", end=" ")
reviews = "\n".join(
df[df.Cluster == i]
.combined.str.replace("Title: ", "")
.str.replace("\n\nContent: ", ": ")
.sample(rev_per_cluster, random_state=42)
.values
)
response = openai.Completion.create(
engine="text-ada-001", #"text-davinci-003",
prompt=f'What do the following customer reviews have in common?\n\nCustomer reviews:\n"""\n{reviews}\n"""\n\nTheme:',
temperature=0,
max_tokens=64,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
print(response["choices"][0]["text"].replace("\n", ""))
답변은 아래와 같습니다.
Cluster 0 Theme: Customer reviews:gluten free, healthy bars, content:The customer reviews have in common that they save money on Amazon by ordering by themselves by looking for gluten free healthy bars. The bars are also delicious.
Cluster 1 Theme: Cat foodMessy, undelicious, and possibly unhealthy.
Cluster 2 Theme: CoffeeThe customer's reviews have in common that they are among the best in the market, Rodeo Drive, and that the customer is able to enjoy their coffee half and half because they have an Amazon account.
Cluster 3 Theme: Customer reviews of different brands of soda.
Cluster 0 Theme: Unnamed: 0 ProductId UserId Score \
117 400 B008JKU2CO A1XV4W7JWX341C 5
25 274 B008JKTH2A A34XBAIFT02B60 1
722 534 B0064KO16O A1K2SU61D7G41X 5
289 7 B001KP6B98 ABWCUS3HBDZRS 5
590 948 B008GG2N2S A1CLUIIJL6EHLU 5
Summary \
117 Loved these gluten free healthy bars, saved $$...
25 Should advertise coconut as an ingredient more...
722 very good!!
289 Excellent product
590 delicious
Text \
117 These Kind Bars are so good and healthy & glut...
25 First, these should be called Mac - Coconut ba...
722 just like the runts<br />great flavor, def wor...
289 After scouring every store in town for orange ...
590 Gummi Frogs have been my favourite candy that ...
combined n_tokens \
117 Title: Loved these gluten free healthy bars, s... 96
25 Title: Should advertise coconut as an ingredie... 78
722 Title: very good!!; Content: just like the run... 43
289 Title: Excellent product; Content: After scour... 100
590 Title: delicious; Content: Gummi Frogs have be... 75
embedding Cluster
117 [-0.002289338270202279, -0.01313735730946064, ... 0
25 [-0.01757248118519783, -8.266511576948687e-05,... 0
722 [-0.011768403463065624, -0.025617636740207672,... 0
289 [0.0007493243319913745, -0.017031244933605194,... 0
590 [-0.005802689120173454, 0.0007485789828933775,... 0
Cluster 1 Theme: Unnamed: 0 ProductId UserId Score \
536 731 B0029NIBE8 A3RKYD8IUC5S0N 2
332 184 B000WFRUOC A22RVTZEIVHZA 4
424 153 B0007A0AQW A15X1BO4CLBN3C 5
298 24 B003R0LKRW A1OQSU5KYXEEAE 1
960 589 B003194PBC A2FSDQY5AI6TNX 5
Summary \
536 Messy and apparently undelicious
332 The cats like it
424 cant get enough of it!!!
298 Food Caused Illness
960 My furbabies LOVE these!
Text \
536 My cat is not a huge fan. Sure, she'll lap up ...
332 My 7 cats like this food but it is a little yu...
424 Our lil shih tzu puppy cannot get enough of it...
298 I switched my cats over from the Blue Buffalo ...
960 Shake the container and they come running. Eve...
combined n_tokens \
536 Title: Messy and apparently undelicious; Conte... 181
332 Title: The cats like it; Content: My 7 cats li... 87
424 Title: cant get enough of it!!!; Content: Our ... 59
298 Title: Food Caused Illness; Content: I switche... 131
960 Title: My furbabies LOVE these!; Content: Shak... 47
embedding Cluster
536 [-0.002376032527536154, -0.0027701142244040966... 1
332 [0.02162935584783554, -0.011174295097589493, -... 1
424 [-0.007517425809055567, 0.0037251529283821583,... 1
298 [-0.0011128562036901712, -0.01970377005636692,... 1
960 [-0.009749102406203747, -0.0068712360225617886... 1
Cluster 2 Theme: Unnamed: 0 ProductId UserId Score \
135 410 B007Y59HVM A2ERWXZEUD6APD 5
439 812 B0001UK0CM A2V8WXAFG1TEOC 5
326 107 B003VXFK44 A21VWSCGW7UUAR 4
475 852 B000I6MCSY AO34Q3JGZU0JQ 5
692 922 B003TC7WN4 A3GFZIL1E0Z5V8 5
Summary \
135 Fog Chaser Coffee
439 Excellent taste
326 Good, but not Wolfgang Puck good
475 Just My Kind of Coffee
692 Rodeo Drive is Crazy Good Coffee!
Text \
135 This coffee has a full body and a rich taste. ...
439 This is to me a great coffee, once you try it ...
326 Honestly, I have to admit that I expected a li...
475 Coffee Masters Hazelnut coffee used to be carr...
692 Rodeo Drive is my absolute favorite and I'm re...
combined n_tokens \
135 Title: Fog Chaser Coffee; Content: This coffee... 42
439 Title: Excellent taste; Content: This is to me... 31
326 Title: Good, but not Wolfgang Puck good; Conte... 178
475 Title: Just My Kind of Coffee; Content: Coffee... 118
692 Title: Rodeo Drive is Crazy Good Coffee!; Cont... 59
embedding Cluster
135 [0.006498195696622133, 0.006776264403015375, 0... 2
439 [0.0039436533115804195, -0.005451332312077284,... 2
326 [-0.003140551969408989, -0.009995664469897747,... 2
475 [0.010913548991084099, -0.014923149719834328, ... 2
692 [-0.029914353042840958, -0.007755572907626629,... 2
Cluster 3 Theme: Unnamed: 0 ProductId UserId Score \
495 831 B0014X5O1C AHYRTWABDAG1H 5
978 642 B00264S63G A36AUU1UNRS48G 5
916 686 B008PYVINQ A1DRWYIO7JN1MD 2
696 926 B0062P9XPU A33KQALCZGXG8C 5
491 828 B000EIE20M A39QHSDUBR8L0T 3
Summary \
495 Wonderful alternative to soda pop
978 So convenient, for so little!
916 bot very cheesy
696 Delicious!
491 Just ok
Text \
495 This is a wonderful alternative to soda pop. ...
978 I needed two vanilla beans for the Love Goddes...
916 Got this about a month ago.first of all it sme...
696 I am not a huge beer lover. I do enjoy an occ...
491 I bought this brand because it was all they ha...
combined n_tokens \
495 Title: Wonderful alternative to soda pop; Cont... 273
978 Title: So convenient, for so little!; Content:... 121
916 Title: bot very cheesy; Content: Got this abou... 46
696 Title: Delicious!; Content: I am not a huge be... 97
491 Title: Just ok; Content: I bought this brand b... 58
embedding Cluster
495 [0.022326279431581497, -0.018449820578098297, ... 3
978 [-0.004598899278789759, -0.01737511157989502, ... 3
916 [-0.010750919580459595, -0.0193503275513649, -... 3
696 [0.009483409114181995, -0.017691848799586296, ... 3
491 [-0.0023960231337696314, -0.006881058216094971... 3
여기서 데이터를 아래와 같이 가공을 합니다.
for j in range(rev_per_cluster):
print(sample_cluster_rows.Score.values[j], end=", ")
print(sample_cluster_rows.Summary.values[j], end=": ")
print(sample_cluster_rows.Text.str[:70].values[j])
Score의 값들을 가지고 오고 끝에는 쉼표 , 를 붙입니다.
그리고 Summary의 값을 가지고 오고 끝에는 : 를 붙입니다.
그리고 Text컬럼의 string을 가지고 오는데 70자 까지만 가지고 옵니다.
전체 결과를 보겠습니다.
Cluster 0 Theme: Customer reviews:gluten free, healthy bars, content:The customer reviews have in common that they save money on Amazon by ordering by themselves by looking for gluten free healthy bars. The bars are also delicious.
5, Loved these gluten free healthy bars, saved $$ ordering on Amazon: These Kind Bars are so good and healthy & gluten free. My daughter ca
1, Should advertise coconut as an ingredient more prominently: First, these should be called Mac - Coconut bars, as Coconut is the #2
5, very good!!: just like the runts<br />great flavor, def worth getting<br />I even o
5, Excellent product: After scouring every store in town for orange peels and not finding an
5, delicious: Gummi Frogs have been my favourite candy that I have ever tried. of co
Cluster 1 Theme: Cat foodMessy, undelicious, and possibly unhealthy.
2, Messy and apparently undelicious: My cat is not a huge fan. Sure, she'll lap up the gravy, but leaves th
4, The cats like it: My 7 cats like this food but it is a little yucky for the human. Piece
5, cant get enough of it!!!: Our lil shih tzu puppy cannot get enough of it. Everytime she sees the
1, Food Caused Illness: I switched my cats over from the Blue Buffalo Wildnerness Food to this
5, My furbabies LOVE these!: Shake the container and they come running. Even my boy cat, who isn't
Cluster 2 Theme: CoffeeThe customer's reviews have in common that they are among the best in the market, Rodeo Drive, and that the customer is able to enjoy their coffee half and half because they have an Amazon account.
5, Fog Chaser Coffee: This coffee has a full body and a rich taste. The price is far below t
5, Excellent taste: This is to me a great coffee, once you try it you will enjoy it, this
4, Good, but not Wolfgang Puck good: Honestly, I have to admit that I expected a little better. That's not
5, Just My Kind of Coffee: Coffee Masters Hazelnut coffee used to be carried in a local coffee/pa
5, Rodeo Drive is Crazy Good Coffee!: Rodeo Drive is my absolute favorite and I'm ready to order more! That
Cluster 3 Theme: Customer reviews of different brands of soda.
5, Wonderful alternative to soda pop: This is a wonderful alternative to soda pop. It's carbonated for thos
5, So convenient, for so little!: I needed two vanilla beans for the Love Goddess cake that my husbands
2, bot very cheesy: Got this about a month ago.first of all it smells horrible...it tastes
5, Delicious!: I am not a huge beer lover. I do enjoy an occasional Blue Moon (all o
3, Just ok: I bought this brand because it was all they had at Ranch 99 near us. I
이제 좀 보기 좋게 됐습니다.
이번 예제는 raw 데이터를 파이썬의 여러 모듈들을 이용해서 clustering을 하고 이 cluster별로 openai.Completion.create() api를 이용해서 궁금한 답을 받는 일을 하는 예제를 배웠습니다.
큰 raw data를 카테고리화 해서 나누고 이에 대한 summary나 기타 정보를 Completion api를 통해 얻을 수 있는 방법입니다.
전체 소스코드는 아래와 같습니다.
# imports
import numpy as np
import pandas as pd
# load data
datafile_path = "./data/fine_food_reviews_with_embeddings_1k.csv"
df = pd.read_csv(datafile_path)
df["embedding"] = df.embedding.apply(eval).apply(np.array) # convert string to numpy array
matrix = np.vstack(df.embedding.values)
matrix.shape
from sklearn.cluster import KMeans
n_clusters = 4
kmeans = KMeans(n_clusters=n_clusters, init="k-means++", random_state=42)
kmeans.fit(matrix)
labels = kmeans.labels_
df["Cluster"] = labels
df.groupby("Cluster").Score.mean().sort_values()
from sklearn.manifold import TSNE
import matplotlib
import matplotlib.pyplot as plt
tsne = TSNE(n_components=2, perplexity=15, random_state=42, init="random", learning_rate=200)
vis_dims2 = tsne.fit_transform(matrix)
x = [x for x, y in vis_dims2]
y = [y for x, y in vis_dims2]
for category, color in enumerate(["purple", "green", "red", "blue"]):
xs = np.array(x)[df.Cluster == category]
ys = np.array(y)[df.Cluster == category]
plt.scatter(xs, ys, color=color, alpha=0.3)
avg_x = xs.mean()
avg_y = ys.mean()
plt.scatter(avg_x, avg_y, marker="x", color=color, s=100)
plt.title("Clusters identified visualized in language 2d using t-SNE")
import openai
def open_file(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return infile.read()
openai.api_key = open_file('openaiapikey.txt')
# Reading a review which belong to each group.
rev_per_cluster = 5
for i in range(n_clusters):
print(f"Cluster {i} Theme:", end=" ")
reviews = "\n".join(
df[df.Cluster == i]
.combined.str.replace("Title: ", "")
.str.replace("\n\nContent: ", ": ")
.sample(rev_per_cluster, random_state=42)
.values
)
response = openai.Completion.create(
engine="text-ada-001", #"text-davinci-003",
prompt=f'What do the following customer reviews have in common?\n\nCustomer reviews:\n"""\n{reviews}\n"""\n\nTheme:',
temperature=0,
max_tokens=64,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
print(response["choices"][0]["text"].replace("\n", ""))
sample_cluster_rows = df[df.Cluster == i].sample(rev_per_cluster, random_state=42)
for j in range(rev_per_cluster):
print(sample_cluster_rows.Score.values[j], end=", ")
print(sample_cluster_rows.Summary.values[j], end=": ")
print(sample_cluster_rows.Text.str[:70].values[j])
