ver1.2

.gitignore

@@ -0,0 +1,3 @@
+# cache files
+__pycache__
+.DS_store

README.md

@@ -1,6 +1,6 @@
 ---
 title: Play Semantle with GPT (Japanese)
-emoji: 🤓💬
+emoji: 🍡💬
 colorFrom: pink
 colorTo: purple
 sdk: gradio

app.py

@@ -5,75 +5,87 @@ import pandas as pd
 import gradio as gr
 import openai
 
-from src.semantle import get_guess, get_secret
+from src.semantle import get_guess, get_secret, get_puzzle_num
 from src.functions import get_functions
-from src.utils import add_guess
 
 GPT_MODEL = "gpt-3.5-turbo"
-TITLE = "やりとりSemantle"
+TITLE = "やりとりxイミトル"
 
-system_content = task_background+task_description
-system_message = [{"role": "system", "content": system_content}]
+with open("data/rule.md", "r", encoding="utf-8") as f:
+    RULEBOOK = "\n".join(f.readlines())
 
-def create_chat(user_input, chat_history, api_key):
-    openai.api_key = api_key
-    chat_messages = [{"role": "user", "content": user_input}]
-    response = openai.ChatCompletion.create(
-        model=GPT_MODEL,
-        messages=system_message+chat_messages,
-        functions=get_functions()
-    )
-    response_message = response.choices[0].message
+def get_rulebook():
+    return RULEBOOK
 
-    # Step 2: check if CPT wanted to call a function
-    if response_message.get("function_call"):
+def _execute_function(function_call, chat_messages, guess_result):
         # Step 3: call the function
         # Note: the JSON response may not always be valid; be sure to handle errors
         available_functions = {
-            "evaluate_score": get_guess,
-            "get_data_for_hint": get_play_data,
+            "guess_word": get_guess,
+            "lookup_answer": get_secret,
+            "retrieve_puzzle_num": get_puzzle_num,
+            "read_rule": get_rulebook,
         }
-        function_name = response_message["function_call"]["name"]
+        function_name = function_call["name"]
         function_to_call = available_functions[function_name]
-        function_args = json.loads(response_message["function_call"]["arguments"])
+        function_args = json.loads(function_call["arguments"])
         function_response = function_to_call(
-            word=function_args.get("word"),
-            puzzle_num=puzzle_num
+            **function_args
         )
-        guess_result = update_guess(function_response, guessed, guesses)
-        print(guess_result)
+        if function_call["name"] == "guess_word":
+            guess_result = function_response
+        print(function_response)
         # Step 4: send the info on the function call and function response to GPT
-        chat_messages.append(response_message.to_dict()) # extend conversation with assistant's reply
         chat_messages.append(
             {"role": "function",
              "name": function_name,
-             "content": guess_result}
+             "content": f"{function_response}"}
         )   # extend conversation with function response
-        second_response = openai.ChatCompletion.create(
+        next_response = openai.ChatCompletion.create(
             model=GPT_MODEL,
-            messages=system_message+chat_history+chat_messages,
+            messages=chat_messages,
+            functions=get_functions(),
+            temperature=0
         )   # get a new response from GPT where it can se the function response
-        chat_messages.append(second_response["choices"][0]["message"].to_dict())
-        chat_history = chat_history[-8:] + chat_messages
-        return chat_messages[-1]
-    
-    chat_messages.append(response_message.to_dict())
-    chat_history = chat_history[-8:] + chat_messages
-    return chat_messages[-1]
+        chat_messages.append(next_response.choices[0].message.to_dict())
+        return next_response.choices[0].message.to_dict(), chat_messages, guess_result
 
-with gr.Blocks() as demo:
+def create_chat(system_input, user_input, guess_result=dict()):
+    chat_messages = []
+    for s in system_input:
+        chat_messages.append({"role": "system", "content": s})
+    chat_messages.append({"role": "user", "content": user_input})
+    response = openai.ChatCompletion.create(
+        model=GPT_MODEL,
+        messages=chat_messages,
+        functions=get_functions(),
+        temperature=0
+    )
+    response_message = response.choices[0].message.to_dict()
+    chat_messages.append(response_message) # extend conversation with assistant's reply
 
+    # Step 2: check if CPT wanted to call a function
+    while response_message.get("function_call"):
+        # Step 3: call the function
+        # Note: the JSON response may not always be valid; be sure to handle errors
+        response_message, chat_messages, guess_result = _execute_function(response_message["function_call"], chat_messages, guess_result)
+    print(chat_messages)
+    return response_message, chat_messages, guess_result
+
+with gr.Blocks() as demo:
     with gr.Row():
         gr.Markdown(
             """
-            # やりとりSemantle
-            [semantle日本語版](https://semantoru.com/)をchatbotと楽しめるspaceです。
+            # やりとりxイミトル
+            「イミトル」は[semantle日本語版](https://semantoru.com/)の名前で、こちらはイミトルをassistantと楽しめるspaceです。
             ## ゲームのやり方
             - 正解は一つの単語で、これを答えるとゲームの勝利になります。
             - 推測した単語が正解じゃない場合、類似度スコアと順位が表示されます。それは正解を推測する大事なヒントになります。
-            ## chatbotの仕事
+            ## assistantの仕事
             - 単語のスコアとランク以外に他のヒントがもらえます。
             - ゲームに関して困っている時、何か質問してみてください。
+            ## ご了承のお願い
+            - ゲームをするため、openaiのapiが必要です。答えによって少々tokenを使うようになります。
             """
         )
 
@@ -83,10 +95,11 @@ with gr.Blocks() as demo:
             idx = gr.State(value=0)
             guessed = gr.State(value=set())
             guesses = gr.State(value=list())
-            cur_guess = gr.State()
+            cur_guess = gr.JSON(visible=False)
+            history = gr.State(list())
             guesses_table = gr.DataFrame(
-                value=pd.DataFrame(columns=["#", "答え", "スコア", "ランク"]),
-                headers=["#", "答え", "score", "score"],
+                value=pd.DataFrame(columns=["i", "guess", "sim", "rank"]),
+                headers=["i", "guess", "score", "rank"],
                 datatype=["number", "str", "number", "str"],
                 elem_id="guesses-table",
                 interactive=False
@@ -102,27 +115,42 @@ with gr.Blocks() as demo:
 
         def unfreeze():
             return msg.update(interactive=True, placeholder="正解と思う言葉を答えてください。")
-        def greet():
-            return "", [("[START]", "ゲームを始まります！好きな言葉をひとつだけいってみてください。")]
+        def reset_history():
+            return list()
+        def greet(key, gradio_messages):
+            openai.api_key = key
+            system_input = [get_rulebook(), "あなたは「イミトル」というゲームの進行役です。ユーザーが答えをするところです。よろしくお願いします。"]
+            user_input = ""
+            reply, _, _ = create_chat(system_input, user_input, guess_result=dict())
+            gradio_messages.append(("", reply["content"]))
+            # gradio_messages.append(("", f"今日のゲームのパズル番号は{get_puzzle_num()}です。それでは、始めましょう！言葉を当ててみてください。"))
+            time.sleep(2)
+            return gradio_messages
         
-        def respond(key, user_input):
-            reply = create_chat(key, user_input)
-            chatbot.append((user_input, reply["content"]))
+        def respond(user_input, gradio_messages,  guess_result=dict()):
+            system_input = [get_rulebook(), """あなたは「イミトル」というゲームの進行役です。
+                            普段、ユーザーは答えをしますが、たまにゲームに関するヒントをリクエストをします。短くても丁寧に答えてください。
+                            ヒントを教える場合、正解を必ず隠してください。絶対、正解を言わないでください。"""]
+
+            _user_input = "答え:" + user_input
+            reply, messages, guess_result = create_chat(system_input, _user_input, guess_result=dict())
+            gradio_messages.append((user_input, reply["content"]))
             time.sleep(2)
-            return "", chatbot
+            return gradio_messages, guess_result
         
         def update_guesses(cur, i, guessed_words, guesses_df):
-            if cur[0] not in guessed_words:
-                guessed_words.add(cur[0])
-                guesses_df.loc[i] = [i+1] + cur
+            if cur.get('guess') and cur['guess'] not in guessed_words:
+                guessed_words.add(cur['guess'])
+                cur['sim'] = round(cur['sim'], 2)
+                cur['i'] = i
+                guesses_df.loc[i] = cur
                 i += 1
-                guesses_df = guesses_df.sort_values(by=["score"], ascending=False)
+                guesses_df = guesses_df.sort_values(by=["sim"], ascending=False)
             return i, guessed_words, guesses_df
 
-        api_key.change(unfreeze, [], [msg]).then(greet, [], [msg, chatbot])
-        msg.submit(respond, [api_key, msg, chatbot, cur_guess], [msg, chatbot, cur_guess]).then(
-            update_guesses, [cur_guess, idx, guessed, guesses_table], [idx, guessed, guesses_table]
-        )
+        api_key.change(unfreeze, [], [msg]).then(reset_history, [], [history]).then(greet, [api_key, chatbot], [chatbot])
+        msg.submit(respond, [msg, chatbot, cur_guess], [chatbot, cur_guess])
+        cur_guess.change(update_guesses, [cur_guess, idx, guessed, guesses_table], [idx, guessed, guesses_table])
             
     gr.Examples(
         [
@@ -137,4 +165,5 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.queue(concurrency_count=20).launch()
+    demo.queue(concurrency_count=20).launch()
+# demo.queue(concurrency_count=20).launch()

data/rule.md

@@ -0,0 +1,10 @@
+# イミトル
+
+## ゲームの遊び方
+今日の言葉を当てるゲームです。 正解と推測される単語を答えると、正解かどうかがわかります。正解でない場合、正解に近い度合いと順位がわかります。正解に近い程度とは単語の意味や文脈、単語の言語的特性などによって決まります。 推測した単語の近い度合いと順位を参考にして、答えを当て続けてみてください。
+
+## ヒントのについて
+もし正解が難しかったり、ゲームのルールがわかりにくい場合は、ヒントを求めることができます。正解単語を使う例文、正解単語とある単語の意味や文法的な共通点など正解に関する様々な情報を聞くことができます。正し、ヒントに正解単語は`<mask>`などで隠すようになっています。
+
+## 「近い度合いと順位」について
+「近い度合い」は正解単語との類似度で、-100から+100までの数字で表します。「順位」はデータベースの中、近い度合いの相対的な位置で、１位から1000位まで表します。「近い度合い('sim')」が100の単語が正解単語です。

src/functions.py

@@ -7,42 +7,29 @@ guess_word = {"name": "guess_word",
                               "type": "string",
                               "description": "A single Japanese word to guess, which is can be a noun, verb, adverb or adjective. e.g. 空, 近い, 行く, etc."
                               },
-                          "puzzle_num": {
-                              "type": "integer",
-                              "description": "An index indicating today's puzzle."
-                          }
+                        #   "puzzle_num": {
+                        #       "type": "integer",
+                        #       "description": "An index indicating today's puzzle."
+                        #   }
                       },
-                      "required": ["word", "puzzle_num"]
+                      "required": ["word"]
                   }}
 
-prepare_hint = {"name": "prepare_hint",
-                "description": "Use this function to retrieve information for hint.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "puzzle_num": {
-                            "type": "interger",
-                            "description": "An index for today's puzzle set."
-                        }
-                    },
-                    "required": ["puzzle_num"]
-                }}
-
-get_secret = {"name": "get_secret",
-                "description": "You can check what the correct answer of today's puzzle is by this function.",
+lookup_answer = {"name": "lookup_answer",
+                "description": "Use this function to check the correct answer of today's puzzle.",
                 "parameters": {
                     "type": "object",
                     "properties": {
-                        "puzzle_num": {
-                            "type": "integer",
-                            "description": "An index indicating today's puzzle."
+                        # "puzzle_num": {
+                        #     "type": "integer",
+                        #     "description": "An index indicating today's puzzle."
                         }
-                    },
-                    "required": ["puzzle_num"]
+                    # },
+                    # "required": ["puzzle_num"]
                 }}
 
-get_puzzle_num = {"name": "get_puzzle_num",
-                  "description": "Use this function to check today's puzzle number.",
+retrieve_puzzle_num = {"name": "retrieve_puzzle_num",
+                  "description": "Use this function to retrieve today's puzzle number.",
                   "parameters": {
                       "type": "object",
                       "properties": {}
@@ -60,13 +47,23 @@ update_history = {"name": "update_history",
                           },
                           "guess_history": {
                               "type": "object",
-                              "description": "A dataframe containing the guessed words and its xore and rank in a row."
+                              "description": "A dataframe containing the guessed words and its score and rank in a row."
                           }
                       },
                       "required": ["current_guess", "guess_history"]
                   }}
+read_rule = {"name": "read_rule",
+                 "description": "Use this function to read the game rule for clarification of your response.",
+                 "parameters": {
+                     "type": "object",
+                     "properties": {},
+                 }}
 
 
 def get_functions():
-    functions = [guess_word]
+    functions = [guess_word, 
+                 lookup_answer, 
+                #  retrieve_puzzle_num, 
+                #  update_history, 
+                 read_rule]
     return functions

src/semantle.py

@@ -2,25 +2,34 @@ from datetime import date, datetime
 from pytz import utc, timezone
 import requests
 
-def get_secret(puzzle_num: int):
+def get_secret():
+    puzzle_num = get_puzzle_num()
     request_url = f"https://semantoru.com/yesterday/{puzzle_num+1}"
-    response = requests.get(request_url)
+    response = requests.get(request_url, timeout=5)
     if response.status_code == 200:
         return response.content
     else:
         return "Not found error."
 
-def get_guess(word: str, puzzle_num: int):
+def get_guess(word: str):
+    puzzle_num = get_puzzle_num()
     request_url = f"https://semantoru.com/guess/{puzzle_num}/{word}"
-    response = requests.get(request_url)
+    print(request_url)
+    response = requests.get(request_url, timeout=5)
     print(response.status_code)
     if response.status_code == 200:
-        return response.json()
+        rtn = response.json()
+        print(rtn)
+        if rtn['rank'] == '正解!':
+            return rtn
+        elif rtn['rank'] > 1000:
+            rtn['rank'] = '?'
+            return rtn
     else:
         return {"guess": word, 
                 "sim": None,
                 "rank": None}
     
 def get_puzzle_num():
-    FIRST_DAY = date(2023, 4, 2)
-    return (utc.localize(datetime.utcnow()).astimezone(timezone('Asia/Tokyo')).date() - FIRST_DAY).days
+    fisrt_day = date(2023, 4, 2)
+    return (utc.localize(datetime.utcnow()).astimezone(timezone('Asia/Tokyo')).date() - fisrt_day).days

src/utils.py

@@ -1,18 +1,3 @@
-
-
-def add_guess(guess_result, guessed, guesses):
-    word, sim, rank = guess_result
-    if sim:
-        if word not in guessed:
-            sim = round(sim, 2)
-            rank = "情報なし" if rank == 1001 else rank
-            guesses.loc[len(guessed)] = ([len(guessed), word, sim, rank])
-            guessed.add(word)
-        cur_result = format_result(word, sim, rank)
-    else:
-        cur_result =  "不正解: 正しくない単語"
-    return "\n".join([cur_result, "最高スコア:", format_table(guesses)]), guessed, guesses
-
 def format_result(word, sim, rank):
     return f"{word}: スコア {sim}, ランク {rank}"