KBR's Stacked Thoughts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
model_config = types.GenerateContentConfig(
    temperature=0.1,
    top_p=1,
    max_output_tokens=5,
)
# 영화 리뷰를 긍정 / 중립 / 부정으로 분류하기
zero_shot_prompt = """Classify movie reviews as POSITIVE, NEUTRAL or NEGATIVE.
Review: "Her" is a disturbing study revealing the direction
humanity is headed if AI is allowed to keep evolving,
unchecked. I wish there were more movies like this masterpiece.
Sentiment: """

response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=model_config,
    contents=zero_shot_prompt)

print(response.text)

1
2
3
4
5
6
7
8
9
10
11
# 영화 리뷰를 긍정 / 중립 / 부정으로 분류하기
zero_shot_prompt = """Classify movie reviews as POSITIVE, NEUTRAL or NEGATIVE.
Review: movie "Her" was quite interesting. but kinda boring some part.
Sentiment: """

response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=model_config,
    contents=zero_shot_prompt)

print(response.text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import enum

# 출력값을 세 가지 중 하나로 고정
class Sentiment(enum.Enum):
    POSITIVE = "positive"
    NEUTRAL = "neutral"
    NEGATIVE = "negative"


response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=types.GenerateContentConfig(
        response_mime_type="text/x.enum",
        response_schema=Sentiment
    ),
    # 위에서 작성한 프롬프트를 다시 넣기
    contents=zero_shot_prompt)

print(response.text)
# 모델이 생성한 텍스트 그대로를 보여줌

1
2
3
enum_response = response.parsed
print(enum_response)
print(type(enum_response))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
few_shot_prompt = """Parse a customer's pizza order into valid JSON:

EXAMPLE:
I want a small pizza with cheese, tomato sauce, and pepperoni.
JSON Response:
`` `
{
"size": "small",
"type": "normal",
"ingredients": ["cheese", "tomato sauce", "pepperoni"]
}
`` `

EXAMPLE:
Can I get a large pizza with tomato sauce, basil and mozzarella
JSON Response:
`` `
{
"size": "large",
"type": "normal",
"ingredients": ["tomato sauce", "basil", "mozzarella"]
}
`` `
ORDER:
"""

customer_order = "버섯과 치즈가 들어간 라지 피자를 주십쇼"

response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=types.GenerateContentConfig(
        temperature=0.1,
        top_p=1,
        max_output_tokens=250,
    ),
    contents=[few_shot_prompt, customer_order])

print(response.text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import typing_extensions as typing

class PizzaOrder(typing.TypedDict):
    size: str
    ingredients: list[str]
    type: str


response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=types.GenerateContentConfig(
        temperature=0.1,
        response_mime_type="application/json",
        response_schema=PizzaOrder,
    ),
    contents="Can I have a large dessert pizza with apple and chocolate")

print(response.text)

1
2
3
4
5
6
7
8
9
# 추론 없이 답하라고 했을 때
prompt = """When I was 4 years old, my partner was 3 times my age. Now, I
am 20 years old. How old is my partner? Return the answer directly."""

response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents=prompt)

print(response.text)

1
2
3
4
5
6
7
8
9
# 추론 과정을 출력하라고 지시했을 때
prompt = """When I was 4 years old, my partner was 3 times my age. Now,
I am 20 years old. How old is my partner? Let's think step by step."""

response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents=prompt)

Markdown(response.text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
# model instructions
# 질문에 답을 할 때는 생각(thought), 행동(action), 관찰(observation) 단계를 번갈아가면서 수행하세요. 
# '생각'은 현재 상황에 대한 추론입니다
# '관찰'은 '행동'의 결과로 얻은 정보를 해석하는 것입니다.
# '행동'은 세 가지 타입 중 하나입니다
# (1) <search>엔티티</search>: 위키백과에서 해당 엔티티를 검색하고 첫 문단 반환하기. 문단이 없으면 유사한 항목들 제시
# (2) <lookup>키워드</lookup>: 현재 문맥에서 키워드가 포함된 다음 문장을 반환하기. (정확히 일치하는 단어만 찾고 검색어는 짧게 유지하세요)
# (3) <finish>정답</finish>: 정답을 반환하고 작업 종료하기

model_instructions = """
Solve a question answering task with interleaving Thought, Action, Observation steps. Thought can reason about the current situation,
Observation is understanding relevant information from an Action's output and Action can be one of three types:
 (1) <search>entity</search>, which searches the exact entity on Wikipedia and returns the first paragraph if it exists. If not, it
     will return some similar entities to search and you can try to search the information from those topics.
 (2) <lookup>keyword</lookup>, which returns the next sentence containing keyword in the current context. This only does exact matches,
     so keep your searches short.
 (3) <finish>answer</finish>, which returns the answer and finishes the task.
"""

# 질문 >> 생각 >> 행동 >> 관찰 >> 생각 >> 행동 >> 관찰 >> 생각 >> 행동 (반복)
example1 = """Question
Musician and satirist Allie Goertz wrote a song about the "The Simpsons" character Milhouse, who Matt Groening named after who?

Thought 1
The question simplifies to "The Simpsons" character Milhouse is named after who. I only need to search Milhouse and find who it is named after.

Action 1
<search>Milhouse</search>

Observation 1
Milhouse Mussolini Van Houten is a recurring character in the Fox animated television series The Simpsons voiced by Pamela Hayden and created by Matt Groening.

Thought 2
The paragraph does not tell who Milhouse is named after, maybe I can look up "named after".

Action 2
<lookup>named after</lookup>

Observation 2
Milhouse was named after U.S. president Richard Nixon, whose middle name was Milhous.

Thought 3
Milhouse was named after U.S. president Richard Nixon, so the answer is Richard Nixon.

Action 3
<finish>Richard Nixon</finish>
"""

example2 = """Question
What is the elevation range for the area that the eastern sector of the Colorado orogeny extends into?

Thought 1
I need to search Colorado orogeny, find the area that the eastern sector of the Colorado orogeny extends into, then find the elevation range of the area.

Action 1
<search>Colorado orogeny</search>

Observation 1
The Colorado orogeny was an episode of mountain building (an orogeny) in Colorado and surrounding areas.

Thought 2
It does not mention the eastern sector. So I need to look up eastern sector.

Action 2
<lookup>eastern sector</lookup>

Observation 2
The eastern sector extends into the High Plains and is called the Central Plains orogeny.

Thought 3
The eastern sector of Colorado orogeny extends into the High Plains. So I need to search High Plains and find its elevation range.

Action 3
<search>High Plains</search>

Observation 3
High Plains refers to one of two distinct land regions

Thought 4
I need to instead search High Plains (United States).

Action 4
<search>High Plains (United States)</search>

Observation 4
The High Plains are a subregion of the Great Plains. From east to west, the High Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130m).

Thought 5
High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer is 1,800 to 7,000 ft.

Action 5
<finish>1,800 to 7,000 ft</finish>
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
question = """Question
Who was the youngest author listed on the transformers NLP paper?
"""

# observation 단계 직전까지만 출력하도록 제한
react_config = types.GenerateContentConfig(
    stop_sequences=["\nObservation"],
    # 위에서 작성한 instruction과 예제 두 개 넣기 (CoT + few-shot)
    system_instruction=model_instructions + example1 + example2,
)

# 모델에게 지시와 예제를 미리 입력한 채로 대화 시작하고
react_chat = client.chats.create(
    model='gemini-2.0-flash',
    config=react_config,
)

# 질문을 던지면 모델은 thought와 action까지 출력하고 observation은 생략한다.
# 모델이 어떻게 행동해야 할 지 생각(thought)하고, 사람이 직접 행동(action)하여 환각현상 방지하는 것
resp = react_chat.send_message(question)
print(resp.text)

1
2
3
4
5
6
7
8
9
10
# 위 질문에 대해 수동으로 observation 1을 모델에게 제공하기
# (공동저자가 너무 많아서 대충 4명으로 줄임)
observation = """Observation 1
[1706.03762] Attention Is All You Need
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely.
"""
resp = react_chat.send_message(observation)
print(resp.text)
# 모델에게 observation을 제공하면 이걸 보고 이어서 thought 2를 한다. 그리고 action2 를 제안한다

1
2
3
4
5
observation2 = """Observation 2
Ashish Vaswani was born in 1986.
"""
resp = react_chat.send_message(observation2)
print(resp.text)

1
2
3
4
5
observation3 = """Observation 3
Noam Shazeer was born in 1975.
"""
resp = react_chat.send_message(observation3)
print(resp.text)

1
2
3
4
5
observation4 = """Observation 4
I couldn't find Niki Parmar's exact birthdate, but I found that she graduated with her bachelor's degree in 2015.
"""
resp = react_chat.send_message(observation4)
print(resp.text)

1
2
3
4
5
observation5 = """Observation 5
Jakob Uszkoreit was born in 1982.
"""
resp = react_chat.send_message(observation5)
print(resp.text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import io
from IPython.display import Markdown, clear_output


response = client.models.generate_content_stream(
    model='gemini-2.0-flash-thinking-exp',
    contents='Who was the youngest author listed on the transformers NLP paper?',
)

buf = io.StringIO()
for chunk in response:
    buf.write(chunk.text)
    # Display the response as it is streamed
    print(chunk.text, end='')

# And then render the finished response as formatted markdown.
clear_output()
Markdown(buf.getvalue())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 팩토리얼을 계산하는 파이썬 함수 생성 (설명 없이 코드만)
code_prompt = """
Write a Python function to calculate the factorial of a number. No explanation, provide only the code.
"""

response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=types.GenerateContentConfig(
        temperature=1,
        top_p=1,
        max_output_tokens=1024,
    ),
    contents=code_prompt)

Markdown(response.text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from pprint import pprint

config = types.GenerateContentConfig(
    tools=[types.Tool(code_execution=types.ToolCodeExecution())],
)

code_exec_prompt = """
Generate the first 14 odd prime numbers, then calculate their sum.
"""

response = client.models.generate_content(
    model='gemini-2.0-flash',
    config=config,
    contents=code_exec_prompt)

for part in response.candidates[0].content.parts:
  pprint(part.to_json_dict())
  print("-----")

1
2
3
4
5
6
7
8
9
10
for part in response.candidates[0].content.parts:
    if part.text:
        display(Markdown(part.text))
    elif part.executable_code:
        display(Markdown(f'```python\n{part.executable_code.code}\n```'))
    elif part.code_execution_result:
        if part.code_execution_result.outcome != 'OUTCOME_OK':
            display(Markdown(f'## Status {part.code_execution_result.outcome}'))

        display(Markdown(f'```\n{part.code_execution_result.output}\n```'))

1
2
3
4
5
6
7
8
9
10
11
12
13
file_contents = !curl https://raw.githubusercontent.com/magicmonty/bash-git-prompt/refs/heads/master/gitprompt.sh

explain_prompt = f"""
Please explain what this file does at a very high level. What is it, and why would I use it?
`` `
{file_contents}
`` `
"""
response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents=explain_prompt)

Markdown(response.text)