Create app.py

app.py

@@ -0,0 +1,985 @@
+from typing import Dict, List, Tuple, Any
+from __future__ import annotations
+from functools import reduce
+import operator
+import pandas as pd
+
+import gradio as gr
+
+from utility import load_json_obj
+from pandas_utility import read_csv_df
+from pipeline import NaturalLanguageProcessing
+from my_gradio import GrBlocks, GrLayout, GrComponent, GrListener
+
+class App(GrBlocks):
+    """
+    アプリのクラス
+    """
+    @staticmethod
+    def _create_children_and_listeners(
+            model_dir: str, cuisine_df_path: str, unify_dics_path: str
+    ) -> Tuple[Dict[str, Any] | List[Any], List[Any]]:
+        """
+        子要素とイベントリスナーの作成
+
+        Parameters
+        ----------
+        model_dir : str
+            ファインチューニング済みモデルが保存されているディレクトリ
+        cuisine_df_path : str
+            料理のデータフレームが保存されているパス
+        unify_dics_path : str
+            表記ゆれ統一用辞書が保存されているパス
+
+        Returns
+        -------
+        Tuple[Dict[str, Any] | List[Any], List[Any]]
+            子要素とイベントリスナーのタプル
+        """
+        cuisine_infos_num = 10
+        label_info_dics: Dict[str, str | List[str]] = {
+            'AREA': {
+                'jp': '都道府県/地方',
+                'color': 'red',
+                'df_cols': ['Prefecture', 'Areas']
+            },
+            'TYPE': {
+                'jp': '種類',
+                'color': 'green',
+                'df_cols': ['Types']
+
+            },
+            'SZN': {
+                'jp': '季節',
+                'color': 'blue',
+                'df_cols': ['Seasons']
+            },
+            'INGR': {
+                'jp': '食材',
+                'color': 'yellow',
+                'df_cols': ['Ingredients list']
+            }
+        }
+
+        input = InputTextbox(
+            model_dir, label_info_dics, cuisine_df_path, unify_dics_path,
+            cuisine_infos_num
+        )
+        input_samples = InputSamplesDataset()
+        extracted_words = ExtractedWordsHighlightedText(label_info_dics)
+        cuisine_infos = CuisineInfos(cuisine_infos_num)
+
+        input_submitted = GrListener(
+            trigger=input.comp.submit,
+            fn=input.submitted,
+            inputs=input,
+            outputs=[extracted_words, cuisine_infos],
+            scroll_to_output=True
+        )
+
+        input_samples_selected = GrListener(
+            trigger=input_samples.comp.select,
+            fn=InputSamplesDataset.selected,
+            outputs=input,
+            thens=input_submitted
+        )
+
+        children = [input, input_samples, extracted_words, cuisine_infos]
+        listeners = [input_submitted, input_samples_selected]
+
+        return children, listeners
+
+
+class InputTextbox(GrComponent):
+    """
+    入力欄のクラス
+
+    Attributes
+    ----------
+    _nlp : NaturalLanguageProcessing
+        固有表現を抽出するオブジェクト
+    _jp_label_dic : Dict[str, str]
+        固有表現のラベルとその日本語訳の辞書
+    _cuisine_info_dics_maker : CuisineInfoDictionariesMaker
+        検索結果の料理の情報の辞書のリストを作成するオブジェクト
+    """
+    def __init__(
+            self,
+            model_dir: str,
+            label_info_dics: Dict[str, str | List[str]],
+            cuisine_df_path: str,
+            unify_dics_path: str,
+            cuisine_infos_num: int
+    ):
+        """
+        コンストラクタ
+
+        Parameters
+        ----------
+        model_dir : str
+            ファインチューニング済みモデルが保存されているディレクトリ
+        label_info_dics : Dict[str, str  |  List[str]]
+            固有表現のラベルとラベルに対する各種設定情報の辞書
+        cuisine_df_path : str
+            料理のデータフレームが保存されているパス
+        unify_dics_path : str
+            表記ゆれ統一用辞書が保存されているパス
+        cuisine_infos_num : int
+            表示する料理検索結果の最大数
+        """
+        self._nlp = NaturalLanguageProcessing(model_dir)
+        self._jp_label_dic: Dict[str, str] = {
+            label: dic['jp'] for label, dic in label_info_dics.items()
+        }
+
+        self._cuisine_info_dics_maker = CuisineInfoDictionariesMaker(
+            cuisine_df_path, unify_dics_path, label_info_dics, cuisine_infos_num
+        )
+
+        super().__init__()
+
+    def _create(self) -> gr.Textbox:
+        """
+        コンポーネントの作成
+
+        Returns
+        -------
+        gr.Textbox
+            入力欄のコンポーネント
+        """
+        label = self._create_label()
+        placeholder = 'どんな料理をお探しでしょうか？'
+        comp = gr.Textbox(placeholder=placeholder, label=label)
+
+        return comp
+
+    def _create_label(self) -> str:
+        """
+        ラベルの作成
+
+        Returns
+        -------
+        str
+            コンポーネントのラベル
+        """
+        categories = [f'"{jp}"' for jp in self._jp_label_dic.values()]
+        label = f'入力文から、料理の{"、".join(categories)}を示す語彙を検出します'
+
+        return label
+
+    def submitted(
+            self, classifying_text: str
+    ) -> List[List[Tuple[str, str]] | List[gr.Textbox | gr.Button]]:
+        """
+        submitイベントリスナーの関数
+
+        Parameters
+        ----------
+        classifying_text : str
+            固有表現抽出対象
+
+        Returns
+        -------
+        List[List[Tuple[str, str]] | List[gr.Textbox | gr.Button]]
+            抽出結果のリストと、料理検索結果に応じた
+            テキストボックスとボタンのリストのリスト
+        """
+        classified_words: Dict[str, List[str]] = self._nlp.classify(classifying_text)
+
+        pos_tokens = [
+            (word, self._jp_label_dic[label])
+            for label, words in classified_words.items()
+            for word in words
+        ]
+
+        cuisine_info_dics = self._cuisine_info_dics_maker.create(classified_words)
+        cuisine_infos = CuisineInfos.update(cuisine_info_dics)
+
+        return [pos_tokens] + cuisine_infos
+
+
+class InputSamplesDataset(GrComponent):
+    """
+    入力例のクラス
+    """
+    def _create(self) -> gr.Dataset:
+        """
+        コンポーネントの作成
+
+        Returns
+        -------
+        gr.Dataset
+            入力例のコンポーネント
+        """
+        label = 'こんな風に聞いてみてください'
+        input_samples = [
+            'オオカミとムカデを使った肉料理を教えてください',
+            '野菜料理で仙豆を使用したものはありますか？',
+            'オールマイトの髪の毛を使った料理は？',
+            '仙台の、宿儺の指を使った、夏に食べられる肉料理',
+            '呪胎九相図が使われている料理を探しています'
+        ]
+
+        comp = gr.Dataset(
+            label=label,
+            components=[gr.Textbox()],
+            samples=[[sample] for sample in input_samples]
+        )
+
+        return comp
+
+    @staticmethod
+    def selected(input: gr.SelectData) -> str:
+        """
+        selectイベントリスナーの関数
+
+        Parameters
+        ----------
+        input : gr.SelectData
+            _description_
+
+        Returns
+        -------
+        str
+            選択した入力例
+        """
+        return input.value[0]
+
+
+class ExtractedWordsHighlightedText(GrComponent):
+    """
+    抽出結果のクラス
+    """
+    def __init__(self, label_info_dics: Dict[str, str | List[str]]):
+        """
+        コンストラクタ
+
+        Parameters
+        ----------
+        label_info_dics : Dict[str, str  |  List[str]]
+            固有表現のラベルとラベルに対する各種設定情報の辞書
+        """
+        super().__init__(label_info_dics)
+
+    def _create(
+            self, label_info_dics: Dict[str, str | List[str]]
+    ) -> gr.HighlightedText:
+        """
+        コンポーネントの作成
+
+        Parameters
+        ----------
+        label_info_dics : Dict[str, str  |  List[str]]
+            固有表現のラベルとラベルに対する各種設定情報の辞書
+
+        Returns
+        -------
+        gr.HighlightedText
+            抽出結果のコンポーネント
+        """
+        color_map: Dict[str, str] = {
+            dic['jp']: dic['color'] for dic in label_info_dics.values()
+        }
+
+        comp = gr.HighlightedText(
+            color_map=color_map,
+            combine_adjacent=True,
+            adjacent_separator='、',
+            label='検出語彙一覧'
+        )
+
+        return comp
+
+
+class CuisineInfos(GrLayout):
+    """
+    全検索結果のクラス
+
+    Attributes
+    ----------
+    layout_type : gr.Column
+        GradioのColumn
+    """
+    layout_type = gr.Column
+
+    def _create(self, cuisine_infos_num: int) -> List[CuisineInfo]:
+        """
+        子要素の作成
+
+        Parameters
+        ----------
+        cuisine_infos_num : int
+            表示する料理検索結果の最大数
+
+        Returns
+        -------
+        List[CuisineInfo]
+            全検索結果
+        """
+        children = [CuisineInfo() for _ in range(cuisine_infos_num)]
+
+        return children
+
+    @staticmethod
+    def update(
+            cuisine_info_dics: List[Dict[str, str]]
+    ) -> List[gr.Textbox | gr.Button]:
+        """
+        全検索結果の更新
+
+        Parameters
+        ----------
+        cuisine_info_dics : List[Dict[str, str]]
+            検索で見つかった料理の情報を持つ辞書のリスト
+
+        Returns
+        -------
+        List[gr.Textbox | gr.Button]
+            全料理の情���のテキストボックスと、詳細ページへのボタンのリスト
+        """
+        cuisine_infos: List[gr.Textbox | gr.Button] = []
+
+        for cuisine_info_dic in cuisine_info_dics:
+            cuisine_info = CuisineInfo.update(cuisine_info_dic)
+
+            cuisine_infos.extend(cuisine_info)
+
+        return cuisine_infos
+
+
+class CuisineInfo(GrLayout):
+    """
+    料理の情報とURLボタンのクラス
+
+    Attributes
+    ----------
+    layout_type : gr.Row
+        GradioのRow
+    """
+    layout_type = gr.Row
+
+    def _create(self) -> List[InfoTextbox | UrlButton]:
+        """
+        子要素の作成
+
+        Returns
+        -------
+        List[InfoTextbox | UrlButton]
+            料理の情報のテキストボックスと、詳細ページへのボタンのリスト
+        """
+        info_textbox = InfoTextbox()
+        url_btn = UrlButton()
+
+        children = [info_textbox, url_btn]
+
+        return children
+
+    @staticmethod
+    def update(cuisine_info_dic: Dict[str, str]) -> List[gr.Textbox | gr.Button]:
+        """
+        料理の情報とURLボタンの更新
+
+        Parameters
+        ----------
+        cuisine_info_dic : Dict[str, str]
+            検索で見つかった料理の情報を持つ辞書
+
+        Returns
+        -------
+        List[gr.Textbox | gr.Button]
+            料理の情報のテキストボックスと、詳細ページへのボタンのリスト
+        """
+        if cuisine_info_dic:
+            textbox, btn = CuisineInfo._reset(cuisine_info_dic)
+
+        else:
+            textbox, btn = CuisineInfo._hide()
+
+        return [textbox, btn]
+
+    @staticmethod
+    def _reset(cuisine_info_dic: Dict[str, str]) -> Tuple[gr.Textbox, gr.Button]:
+        """
+        料理の変更
+
+        Parameters
+        ----------
+        cuisine_info_dic : Dict[str, str]
+            検索で見つかった料理の情報を持つ辞書
+
+        Returns
+        -------
+        Tuple[gr.Textbox, gr.Button]
+            料理の情報のテキストボックスと、詳細ページへのボタンのタプル
+        """
+        cuisine_name = cuisine_info_dic['name']
+        cuisine_info = cuisine_info_dic['info']
+        cuisine_url = cuisine_info_dic['url']
+
+        textbox = InfoTextbox.reset(cuisine_name, cuisine_info)
+        btn = UrlButton.reset(cuisine_name, cuisine_url)
+
+        return textbox, btn
+
+    @staticmethod
+    def _hide() -> Tuple[gr.Textbox, gr.Button]:
+        """
+        料理の非表示
+
+        Returns
+        -------
+        Tuple[gr.Textbox, gr.Button]
+            料理の情報のテキストボックスと、詳細ページへのボタンのタプル
+        """
+        textbox = InfoTextbox.hide()
+        btn = UrlButton.hide()
+
+        return textbox, btn
+
+
+class InfoTextbox(GrComponent):
+    """
+    料理の情報のクラス
+    """
+    def _create(self) -> gr.Textbox:
+        """
+        コンポーネントの作成
+
+        Returns
+        -------
+        gr.Textbox
+            料理の情報のコンポーネント
+        """
+        comp = gr.Textbox(scale=9, visible=False)
+
+        return comp
+
+    @staticmethod
+    def reset(cuisine_name: str, cuisine_info: str) -> gr.Textbox:
+        """
+        料理の情報の変更
+
+        Parameters
+        ----------
+        cuisine_name : str
+            料理名
+        cuisine_info : str
+            料理の情報
+
+        Returns
+        -------
+        gr.Textbox
+            料理の情報のコンポーネント
+        """
+        comp = gr.Textbox(value=cuisine_info, label=cuisine_name, visible=True)
+
+        return comp
+
+    @staticmethod
+    def hide() -> gr.Textbox:
+        """
+        料理の情報の非表示
+
+        Returns
+        -------
+        gr.Textbox
+            非表示になった料理の情報のコンポーネント
+        """
+        comp = gr.Textbox(visible=False)
+
+        return comp
+
+
+class UrlButton(GrComponent):
+    """
+    URLボタンのクラス
+    """
+    def _create(self) -> gr.Button:
+        """
+        コンポーネントの作成
+
+        Returns
+        -------
+        gr.Button
+            詳細ページへのボタンのコンポーネント
+        """
+        comp = gr.Button(scale=1, visible=False)
+
+        return comp
+
+    @staticmethod
+    def reset(cuisine_name: str, cuisine_url: str) -> gr.Button:
+        """
+        料理のボタンの更新
+
+        Parameters
+        ----------
+        cuisine_name : str
+            料理名
+        cuisine_url : str
+            料理の詳細ページへのURL
+
+        Returns
+        -------
+        gr.Button
+            詳細ページへのボタンのコンポーネント
+        """
+        value = cuisine_name + '\n詳細ページ'
+        comp = gr.Button(value=value, link=cuisine_url, visible=True)
+
+        return comp
+
+    @staticmethod
+    def hide() -> gr.Button:
+        """
+        料理のボタンの非表示
+
+        Returns
+        -------
+        gr.Button
+            非表示になった詳細ページへのボタンのコンポーネント
+        """
+        comp = gr.Button(visible=False)
+
+        return comp
+
+
+class CuisineInfoDictionariesMaker:
+    """
+    料理検索結果の辞書のリスト作成用クラス
+
+    Attributes
+    ----------
+    _cuisine_searcher : CuisineSearcher
+        料理を検索するオブジェクト
+    _word_unifier : WordUnifier
+        抽出結果の表記ゆれを統一するオブジェクト
+    """
+    def __init__(
+            self,
+            cuisine_df_path: str,
+            unify_dics_path: str,
+            label_info_dics: Dict[str, str | List[str]],
+            cuisine_infos_num: int
+    ):
+        """
+        コンストラクタ
+
+        Parameters
+        ----------
+        cuisine_df_path : str
+            料理のデータフレームが保存されているパス
+        unify_dics_path : str
+            表記ゆれ統一用辞書が保存されているパス
+        label_info_dics : Dict[str, str  |  List[str]]
+            固有表現のラベルとラベルに対する各種設定情報の辞書
+        cuisine_infos_num : int
+            表示する料理検索結果の最大数
+        """
+        self._cuisine_searcher = CuisineSearcher(
+            cuisine_df_path, label_info_dics, cuisine_infos_num
+        )
+        self._word_unifier = WordUnifier(unify_dics_path)
+
+    def create(
+            self, classified_words: Dict[str, List[str]]
+    ) -> List[Dict[str, str]]:
+        """
+        料理検索結果の辞書の作成
+
+        Parameters
+        ----------
+        classified_words : Dict[str, List[str]]
+            ラベルと、そのラベルに分類された固有表現の辞書
+
+        Returns
+        -------
+        List[Dict[str, str]]
+            料理検索結果の辞書のリスト
+        """
+        unified_words = self._word_unifier.unify(classified_words)
+        cuisine_info_dics = self._cuisine_searcher.search(unified_words)
+
+        return cuisine_info_dics
+
+
+class CuisineSearcher:
+    """
+    料理検索用のクラス
+
+    Attributes
+    ----------
+    _search_infos : List[str]
+        料理のどの情報を取ってくるか示したリスト
+    _df : pd.DataFrame
+        料理のデータフレーム
+    _label_to_col : Dict[str, List[str]]
+        固有表現のラベルに対して、検索するデータフレームの列のリストの辞書
+    _words_dic : Dict[str, List[str]]
+        データフレームの列と、列に含まれる全ての要素の辞書
+    _cuisine_infos_num : int
+        表示する料理検索結果の最大数
+    """
+    _search_infos = [
+        'Name', 'Prefecture', 'Types', 'Seasons', 'Ingredients', 'Detail URL'
+    ]
+
+    def __init__(
+            self,
+            cuisine_df_path: str,
+            label_info_dics: Dict[str, str | List[str]],
+            cuisine_infos_num: int
+    ):
+        """
+        コンストラクタ
+
+        Parameters
+        ----------
+        cuisine_df_path : str
+            料理のデータフレームが保存されているパス
+        label_info_dics : Dict[str, str  |  List[str]]
+            固有表現のラベルとラベルに対する各種設定情報の辞書
+        cuisine_infos_num : int
+            表示する料理検索結果の最大数
+        """
+        self._df = read_csv_df(cuisine_df_path)
+        self._label_to_col = self._create_label_to_col(label_info_dics)
+        self._words_dic = {
+            col: self._find_words(col)
+            for cols in self._label_to_col.values() for col in cols
+        }
+        self._cuisine_infos_num = cuisine_infos_num
+
+    def _create_label_to_col(
+            self, label_info_dics: Dict[str, str | List[str]]
+    ) -> Dict[str, List[str]]:
+        """
+        label_to_colの作成
+
+        固有表現のラベルに対応したデータフレームの列を
+        特定するための辞書を作成する
+
+        Parameters
+        ----------
+        label_info_dics : Dict[str, str  |  List[str]]
+            固有表現のラベルとラベルに対する各種設定情報の辞書
+
+        Returns
+        -------
+        Dict[str, List[str]]
+            固有表現のラベルに対して、検索するデータフレームの列のリストの辞書
+
+        Raises
+        ------
+        ValueError
+            label_info_dicsに、データフレームに存在しない列名が含まれている場合
+        """
+        label_to_col: Dict[str, List[str]] = {
+            label: dic['df_cols'] for label, dic in label_info_dics.items()
+        }
+
+        df_cols = self._df.columns.tolist()
+        for cols in label_to_col.values():
+            for col in cols:
+                if col not in df_cols:
+                    raise ValueError(f'"{col}"という列名は存在しません')
+
+        return label_to_col
+
+    def _find_words(self, col: str) -> List[str]:
+        """
+        列に含まれる全要素の取得
+
+        Parameters
+        ----------
+        col : str
+            列名
+
+        Returns
+        -------
+        List[str]
+            列に含まれる全ての要素のリスト
+        """
+        words: List[str, List[str]] = self._df[col].value_counts().index.tolist()
+
+        if isinstance(words[0], list):
+            words_lst = words
+            unique_words: List[str] = []
+
+            for words in words_lst:
+                for word in words:
+                    if word not in unique_words:
+                        unique_words.append(word)
+
+            return unique_words
+
+        return words
+
+    def search(self, unified_words: Dict[str, List[str]]) -> List[Dict[str, str]]:
+        """
+        料理の検索
+
+        Parameters
+        ----------
+        unified_words : Dict[str, List[str]]
+            表記ゆれが統一された固有表現の辞書
+
+        Returns
+        -------
+        List[Dict[str, str]]
+            検索結果の料理の情報を持つ辞書のリスト
+        """
+        on_df_words_dic = self._create_on_df_words_dic(unified_words)
+
+        if not on_df_words_dic:
+            gr.Info('いずれの語彙もデータに存在しませんでした')
+
+            return self._create_empty_dics()
+
+        cuisine_info_dics = self._create_cuisine_info_dics(on_df_words_dic)
+
+        return cuisine_info_dics
+
+    def _create_on_df_words_dic(
+            self, unified_words: Dict[str, List[str]]
+    ) -> Dict[str, List[str]]:
+        """
+        データフレームに存在する固有表現だけの辞書の作成
+
+        Parameters
+        ----------
+        unified_words : Dict[str, List[str]]
+            表記ゆれが統一された固有表現の辞書
+
+        Returns
+        -------
+        Dict[str, List[str]]
+            データフレームに存在する表記ゆれが統一された固有表現の辞書
+        """
+        on_df_words_dic = {col: [] for col in self._words_dic}
+        not_on_df_words: List[str] = []
+
+        for label, words in unified_words.items():
+            search_cols = self._label_to_col[label]
+
+            for word in words:
+                not_on_df = True
+
+                for col in search_cols:
+                    if word in self._words_dic[col]:
+                        on_df_words_dic[col].append(word)
+
+                        not_on_df = False
+
+                        break
+
+                if not_on_df:
+                    not_on_df_words.append(word)
+
+        if not_on_df_words:
+            CuisineSearcher._show_not_on_df_words(not_on_df_words)
+
+        on_df_words_dic = {
+            col: words for col, words in on_df_words_dic.items() if words
+        }
+
+        return on_df_words_dic
+
+    @staticmethod
+    def _show_not_on_df_words(not_on_df_words: List[str]) -> None:
+        """
+        データフレームに存在しなかった固有表現の表示
+
+        Parameters
+        ----------
+        not_on_df_words : List[str]
+            データフレームに存在しなかった固有表現のリスト
+        """
+        words = '、'.join(not_on_df_words)
+        message = f'無効な語彙:　{words}'
+
+        gr.Info(message)
+
+    def _create_empty_dics(self) -> List[Dict[Any, Any]]:
+        """
+        空の辞書のリストの作成
+
+        検索結果に該当する料理がなかった場合は、CuisineInfosを非表示にする
+        CuisineInfo.update()に空の辞書を渡すと、
+        InfoTextboxとUrlButtonが非表示になる
+
+        Returns
+        -------
+        List[Dict[Any, Any]]
+            空の辞書のリスト
+        """
+        return [{} for _ in range(self._cuisine_infos_num)]
+
+    def _create_cuisine_info_dics(
+            self, words_dic: Dict[str, List[str]]
+    ) -> List[Dict[str, str]]:
+        """
+        料理の情報を持つ辞書の作成
+
+        Parameters
+        ----------
+        words_dic : Dict[str, List[str]]
+            検索ワードのリストを持つ辞書
+
+        Returns
+        -------
+        List[Dict[str, str]]
+            料理の情報を持つ辞書のリスト
+        """
+        condition_lst: List[pd.Series] = []
+
+        for col, words in words_dic.items():
+            condition = self._create_condition(col, words)
+            condition_lst.append(condition)
+
+        conditions = reduce(operator.and_, condition_lst)
+
+        cuisine_infos_lst = self._df.loc[conditions, self._search_infos].values.tolist()
+
+        if len(cuisine_infos_lst) > self._cuisine_infos_num:
+            cuisine_infos_lst = cuisine_infos_lst[:self._cuisine_infos_num]
+
+        if not cuisine_infos_lst:
+            gr.Info('検索条件が厳しすぎて、該当料理が見つかりませんでした')
+
+            return self._create_empty_dics()
+
+        cuisine_info_dics = self._lst_to_dics(cuisine_infos_lst)
+
+        return cuisine_info_dics
+
+    def _create_condition(self, col: str, words: List[str]) -> pd.Series:
+        """
+        検索条件の作成
+
+        Parameters
+        ----------
+        col : str
+            絞り込み対象列
+        words : List[str]
+            検索ワード
+
+        Returns
+        -------
+        pd.Series
+            該当料理の行がTrueになったboolのシリーズ
+        """
+        value_type = type(self._df.at[0, col])
+
+        if value_type is list:
+            condition = self._df[col].apply(
+                lambda values: any(word in values for word in words)
+            )
+
+        else:
+            conditions = [self._df[col] == word for word in words]
+            condition = reduce(operator.or_, conditions)
+
+        return condition
+
+    def _lst_to_dics(
+            self, infos_lst: List[List[str | List[str]]]
+    ) -> List[Dict[str, str]]:
+        """
+        リストから辞書への変換
+
+        料理の情報のリストのリストを、料理の情報の辞書のリストに変換する
+
+        Parameters
+        ----------
+        infos_lst : List[List[str  |  List[str]]]
+            料理の情報のリストのリスト
+
+        Returns
+        -------
+        List[Dict[str, str]]
+            料理の情報の辞書のリスト
+        """
+        dics: List[Dict[str, str]] = []
+
+        for infos in infos_lst:
+            infos = [
+                '、'.join(info) if isinstance(info, list) else info
+                for info in infos
+            ]
+
+            name = infos[0]
+            info = ' | '.join(infos[1:-1])
+            url = infos[-1]
+
+            dic = {'name': name, 'info': info, 'url': url}
+            dics.append(dic)
+
+        dics_len = len(dics)
+
+        if dics_len < self._cuisine_infos_num:
+            dics = dics + [{} for _ in range(self._cuisine_infos_num - dics_len)]
+
+        return dics
+
+
+class WordUnifier:
+    """
+    表記ゆれ統一用のクラス
+
+    Attributes
+    ----------
+    _not_unify_labels : List[str]
+        表記ゆれ統一対象ではない固有表現のラベルのリスト
+    _unify_dics : Dict[str, Dict[str, str]]
+        ラベルと、そのラベルの固有表現の表記ゆれ統一用の辞書の辞書
+    """
+    _not_unify_labels = ['SZN']
+
+    def __init__(self, unify_dics_path: str):
+        """
+        コンストラクタ
+
+        Parameters
+        ----------
+        unify_dics_path : str
+            表記ゆれ統一用辞書が保存されているパス
+        """
+        self._unify_dics: Dict[str, Dict[str, str]] = load_json_obj(unify_dics_path)
+
+    def unify(
+            self, classified_words: Dict[str, List[str]]
+    ) -> Dict[str, List[str]]:
+        """
+        表記ゆれの統一
+
+        Parameters
+        ----------
+        classified_words : Dict[str, List[str]]
+            ラベルと、そのラベルに分類された固有表現の辞書
+
+        Returns
+        -------
+        Dict[str, List[str]]
+            表記ゆれが統一された固有表現の辞書
+        """
+        for label, words in classified_words.items():
+            if label in self._not_unify_labels:
+                continue
+
+            unify_dic = self._unify_dics[label]
+
+            unified_words = [
+                unify_dic[word] if word in unify_dic else word for word in words
+            ]
+
+            classified_words[label] = unified_words
+
+        return classified_words
+
+
+model_name = 'wolf4032/bert-japanese-token-classification-search-local-cuisine'
+cuisine_df_path = 'local_cuisine_dataframe.csv'
+unify_dics_path = 'unifying_dictionaries.json'
+
+app = App.create_and_launch(model_name, cuisine_df_path, unify_dics_path)