add hira kata options

app.py

@@ -3,7 +3,6 @@ from copy import deepcopy
 from pathlib import Path
 
 import gradio as gr
-import numpy as np
 
 from utils import KanaData, Recognizer
 
@@ -18,8 +17,12 @@ class App:
         model_char_path="model/chars.txt",
         default_kana="あ",
         font_name="Kiwi Maru",
+        css_path="style.css",
+        favicon_path="favicon.png",
         brush_color="#111",
         brush_size=15,
+        storage_key="kana-write-storage-key",
+        storage_secret="kana-write-secret",
     ):
         self.brush_color = brush_color
         self.brush_size = brush_size
@@ -28,19 +31,32 @@ class App:
 
         self.kana_data = KanaData.load(kana_data_path)
         self.kana_set = {kana for kana in self.kana_data.spell if len(kana) == 1}
+        self.hira_set = {kana for v in self.kana_data.hiragana.values() for kana in v}
+        self.kata_set = {kana for v in self.kana_data.katakana.values() for kana in v}
 
         self.kana_char_dir = Path(kana_char_dir)
         self.kana_images = [str(p) for p in self.kana_char_dir.rglob("*")]
 
         self.font_name = font_name
+        self.css_path = css_path
+        self.favicon_path = favicon_path
 
         self.default_kana = default_kana
         self.default_kana_image = str(self.kana_char_dir / f"{self.default_kana}.png")
         roma = self.conv_kana_to_roma(self.default_kana)
-        self.default_roma = f"{self.default_kana} ({roma})"
+        self.default_roma = f"平假名 {self.default_kana} ({roma})"
+
+        self.storage_key = storage_key
+        self.storage_secret = storage_secret
 
         self.init_app()
 
+    def is_hiragana(self, kana):
+        return kana in self.hira_set
+
+    def is_katakana(self, kana):
+        return kana in self.kata_set
+
     def init_app(self):
         with self.init_blocks() as self.app:
             self.init_states()
@@ -52,10 +68,11 @@ class App:
         return gr.Blocks(title="假名手寫練習")
 
     def init_layout(self):
-        with gr.Sidebar("練習設定"):
+        gr.Markdown("# ✍️ 假名手寫練習")
+        self.init_practice_tab()
+
+        with gr.Sidebar():
             self.init_setting_tab()
-        with gr.Tab("寫字練習"):
-            self.init_practice_tab()
 
     def init_states(self):
         self.curr_kana = gr.State(self.default_kana)
@@ -70,41 +87,48 @@ class App:
             brush=gr.Brush(self.brush_size, self.brush_color),
             eraser=False,
             layers=False,
-            label="寫字板",
+            label="🖊️ 寫字板",
         )
 
         with gr.Row():
-            self.target_txt = gr.Textbox(self.default_roma, label="練習目標")
-            self.result_txt = gr.Textbox(label="辨識結果")
+            self.target_txt = gr.Textbox(self.default_roma, label="🎯 練習目標")
+            self.result_txt = gr.Textbox(label="💯 辨識結果")
 
         with gr.Row():
-            self.next_btn = gr.Button("下一個字")
-            self.recog_btn = gr.Button("手寫辨識")
+            self.next_btn = gr.Button("👉 下一個字")
+            self.recog_btn = gr.Button("🔎 手寫辨識")
 
     def init_setting_tab(self):
-        with gr.Row():
+        with gr.Accordion("⚙️ 練習設定"):
+            self.use_hiragana = gr.Checkbox(True, label="練習平假名")
+            self.use_katakana = gr.Checkbox(True, label="練習片假名")
             self.use_assist_chk = gr.Checkbox(True, label="顯示輔助字")
-            self.use_kana_hint_chk = gr.Checkbox(True, label="提示假名")
+            self.use_kana_hint_chk = gr.Checkbox(True, label="練習目標提示假名")
 
     def init_events(self):
-        recog_kwargs = gr_kwargs(self.do_recog, self.sketchpad, self.result_txt)
+        recog_kwargs = gr_kwargs(
+            self.recognize, [self.sketchpad, self.curr_kana], self.result_txt
+        )
+        clear_kwargs = gr_kwargs(self.clear, self.curr_kana_image, self.sketchpad)
 
-        next_inputs = [self.use_assist_chk, self.use_kana_hint_chk, self.curr_kana_list]
+        next_inputs = [self.use_hiragana, self.use_katakana, self.use_assist_chk]
+        next_inputs += [self.use_kana_hint_chk, self.curr_kana_list]
         next_outputs = [self.curr_kana, self.sketchpad, self.curr_kana_image]
         next_outputs += [self.target_txt, self.result_txt, self.curr_kana_list]
         next_kwargs = gr_kwargs(self.get_rand_kana, next_inputs, next_outputs)
 
-        clear_kwargs = gr_kwargs(self.clear, self.curr_kana_image, self.sketchpad)
-
-        update_inputs = [self.curr_kana, self.use_assist_chk]
-        update_inputs += [self.use_kana_hint_chk, self.curr_kana_list]
+        update_inputs = [self.curr_kana, self.use_hiragana, self.use_katakana]
+        update_inputs += [self.use_assist_chk, self.use_kana_hint_chk]
+        update_inputs += [self.curr_kana_list]
         update_outputs = [self.curr_kana, self.sketchpad, self.curr_kana_image]
         update_outputs += [self.target_txt, self.curr_kana_list]
         update_kwargs = gr_kwargs(self.update, update_inputs, update_outputs)
 
         self.recog_btn.click(**recog_kwargs)
-        self.next_btn.click(**next_kwargs)
         self.sketchpad.clear(**clear_kwargs)
+        self.next_btn.click(**next_kwargs)
+        self.use_hiragana.change(**update_kwargs)
+        self.use_katakana.change(**update_kwargs)
         self.use_assist_chk.change(**update_kwargs)
         self.use_kana_hint_chk.change(**update_kwargs)
 
@@ -112,11 +136,10 @@ class App:
         components = [self.use_assist_chk, self.use_kana_hint_chk]
         triggers = [component.change for component in components]
 
-        default_value = [component.value for component in components]
         browser_state = gr.BrowserState(
-            default_value,
-            storage_key="storage-key",
-            secret="secret",
+            [component.value for component in components],
+            storage_key=self.storage_key,
+            secret=self.storage_secret,
         )
 
         self.app.load(inputs=browser_state, outputs=components)(lambda data: data)
@@ -126,7 +149,12 @@ class App:
         font = gr.themes.GoogleFont(self.font_name)
         text_size = gr.themes.sizes.text_lg
         theme = gr.themes.Ocean(font=font, text_size=text_size)
-        self.app.launch(theme=theme)
+        self.app.launch(
+            theme=theme,
+            css_paths=self.css_path,
+            footer_links=[None],
+            favicon_path=self.favicon_path,
+        )
 
     def conv_kana_to_roma(self, kana):
         return self.kana_data.spell[kana][0]
@@ -136,54 +164,63 @@ class App:
         random.shuffle(curr_kana_list)
         return curr_kana_list
 
-    def get_kana(self, kana: str, use_assist: bool, use_kana_hint: bool, kana_list: list):
+    def get_kana(
+        self,
+        kana: str,
+        use_hira: bool,
+        use_kata: bool,
+        use_assist: bool,
+        use_kana_hint: bool,
+        kana_list: list,
+    ):
         kana_list = kana_list if kana_list else self.init_kana_list()
         kana_image = self.kana_char_dir / f"{kana}.png" if kana else kana_list.pop()
         kana = Path(kana_image).stem
 
+        if use_hira ^ use_kata:
+            while self.is_hiragana(kana) and not use_hira:
+                kana_list = kana_list if kana_list else self.init_kana_list()
+                kana_image = kana_list.pop()
+                kana = Path(kana_image).stem
+            while self.is_katakana(kana) and not use_kata:
+                kana_list = kana_list if kana_list else self.init_kana_list()
+                kana_image = kana_list.pop()
+                kana = Path(kana_image).stem
+
         kana_image = kana_image if use_assist else self.bg_image_path
 
+        kana_type = "平假名" if self.is_hiragana(kana) else "片假名"
         roma = self.conv_kana_to_roma(kana)
-        roma = f"{kana} ({roma})" if use_kana_hint else f"{roma}"
+        roma = f"{kana_type} {kana} ({roma})" if use_kana_hint else f"{kana_type} {roma}"
 
         return kana, str(kana_image), roma, kana_list
 
-    def parse_item(self, item):
-        prob = item["prob"]
-        char = item["char"]
-        return f"{char} ({self.conv_kana_to_roma(char)}): {prob:.2%}"
+    def get_rand_kana(self, use_hira, use_kata, use_assist, use_hint, kana_list):
+        args = (None, use_hira, use_kata, use_assist, use_hint, kana_list)
+        kana, image, roma, kana_list = self.get_kana(*args)
+        return kana, image, image, roma, None, kana_list
 
-    def is_valid_item(self, item):
-        if item["prob"] < 1e-2:
-            return False
-        if item["char"] not in self.kana_set:
-            return False
-        return True
+    def update(self, kana, use_hira, use_kata, use_assist, use_hint, kana_list):
+        args = (kana, use_hira, use_kata, use_assist, use_hint, kana_list)
+        kana, image, roma, kana_list = self.get_kana(*args)
+        return kana, image, image, roma, kana_list
 
-    def do_recog(self, image: dict[str, np.ndarray]):
+    def recognize(self, image, curr_kana):
         image = image["layers"][0]
         image[image == 0] = 255
         image[image != 255] = 0
-        _, nbest = self.recognizer(image)
-        return ", ".join(
-            self.parse_item(item)
-            for items in nbest
-            for item in items
-            if self.is_valid_item(item)
-        )
+        _, results = self.recognizer.recognize(image)
 
-    def get_rand_kana(self, assist, kana, chars):
-        char, img, roma, chars = self.get_kana(None, assist, kana, chars)
-        return char, img, img, roma, None, chars
+        return f"正解：{curr_kana} - 辨識：" + ", ".join(
+            f"{result.char} ({self.conv_kana_to_roma(result.char)}): {result.prob:.2%}"
+            for items in results
+            for result in items
+            if result.prob > 1e-2 and result.char in self.kana_set
+        )
 
     def clear(self, curr_kana_image):
         return curr_kana_image
 
-    def update(self, kana, use_assist, use_hint, kana_list):
-        kana_info = self.get_kana(kana, use_assist, use_hint, kana_list)
-        kana, image, roma, kana_list = kana_info
-        return kana, image, image, roma, kana_list
-
 
 def gr_kwargs(fn, inputs=None, outputs=None, show_progress="hidden", **kwargs):
     return dict(

style.css

@@ -0,0 +1,3 @@
+.divider {
+    display: none;
+}

utils.py

@@ -24,6 +24,10 @@ class KanaData(BaseModel):
 
 
 class Recognizer:
+    class Result(BaseModel):
+        char: str
+        prob: float
+
     def __init__(self, model_path, char_list_path, device="CPU", blank="[blank]"):
         core = Core()
         self.model = core.read_model(model_path)
@@ -38,7 +42,7 @@ class Recognizer:
         with open(char_list_path, "rt", encoding="UTF-8") as fp:
             self.chars = [blank] + fp.read().split("\n")
 
-    def __call__(self, image, top_k=10):
+    def recognize(self, image, top_k=10):
         image = self.preprocess(image, self.input_height, self.input_width)[None, :, :, :]
 
         for _ in range(2):
@@ -61,7 +65,7 @@ class Recognizer:
         # right edge padding
         return np.pad(img, ((0, 0), (0, height - h), (0, width - w)), mode="edge")
 
-    def ctc_decode(self, preds, top_k):
+    def ctc_decode(self, preds, top_k) -> tuple[list, list[list[Result]]]:
         index, texts, nbest = 0, list(), list()
 
         preds_index: np.ndarray = np.argmax(preds, 2)
@@ -88,10 +92,13 @@ class Recognizer:
 
                 # process n-best
                 probs = self.softmax(preds[i][0])
-                k_idx = np.argsort(-probs)[:top_k]
-                k_probs = probs[k_idx]
-                k_res = [dict(prob=p, char=self.chars[j]) for j, p in zip(k_idx, k_probs)]
-                nbest.append(k_res)
+                k_indices = np.argsort(-probs)[:top_k]
+                k_probs = probs[k_indices]
+                k_results = [
+                    Recognizer.Result(char=self.chars[j], prob=prob)
+                    for j, prob in zip(k_indices, k_probs)
+                ]
+                nbest.append(k_results)
 
             text = "".join(char_list)
             texts.append(text)
@@ -101,5 +108,5 @@ class Recognizer:
         return texts, nbest
 
     def softmax(self, x):
-        e_x = np.exp(x - np.max(x))
-        return e_x / np.sum(e_x, axis=0)
+        exp_x = np.exp(x - np.max(x))
+        return exp_x / np.sum(exp_x, axis=0)