from keras.utils import plot_model#
path = "drive/My Drive/Colab Notebooks/アリス"#
#path = "."
import sys,os,shutil
sys.path.append('/content/drive/My Drive/Colab Notebooks/アリス')#
import importlib#


from keras.callbacks import ModelCheckpoint as 数回置きにセーブ
import numpy as np

from keras.optimizers import Adam
from keras.losses import mean_squared_error as mse
from keras.models import load_model, Model, Sequential
import keras
from keras.layers import *
from PIL import Image
from sklearn.utils.extmath import cartesian as デカルト積 # ←lambda式な要素を文字列に変換してしまうバグあり。
デカルト積_ = lambda listA, listB: np.array([  [[A,B] for A in listA]   for B in listB  ]).reshape(-1,2).tolist()


import hashlib
sha256 = lambda data :int(hashlib.sha256(str(data).encode('utf-8')).hexdigest(), 16)
import re

"""
(path)/(ex_id)/config.txtの書式
 1行目に開始エポック番号
 2行目にデコーダオンリーモードか否か
 3行目に高さ
 4行目にデータの条件式 (evalを使用するのでやや危険。i,x,yを使った条件式。但しi=360*x+y)
 5行目にデータを分類する式 (eval。i,x,yを使った式で、訓練データならTRAIN,検証データならVAL,テストデータならPUREと評価される必要がある(TRAIN,VAL,PUREは変数名である))
                           分類に乱数を使うと、再開のたびに再現性が失われるので非推奨。代わりにハッシュ関数sha256が利用可能
 6行目に潜在変数正規ノイズの標準偏差
 7行目にバッチサイズ
 8行目に何エポックごとにモデルを保存するか
 9行目に何回モデルを保存するごとにテストデータに対する応答を予測するか
10行目に学習率
# 11行目以降はモデルを作るためのkerasコード。


(path)/npy/data.npy
"""

def learn(**kwargs):
    arg = kwargs # キーワード引数の仕組みを途中で知ったので、つじつま合わせ
    def 処理():
        実験ID = 読み取る("実験ID")
        実験データ = 実験データクラス(実験ID)
        if 実験データ.存在する():
            再開モード = 読み取る("再開", msg="実験"+str(実験ID)+"は過去に実行されたことがあるようです。\n続きから学習するなら1, 新規学習なら0を入力", tipe=真偽)
            if 再開モード:
                実験データ.config_txtを(読む)
                モデル = 実験データ.モデルを読む()
                if モデル:
                    print("モデルを読み込みました(epoch "+文字列(開始エポック番号)+"から再開")
                else:
                    ファイルが存在しないエラー.投げる("モデルファイルが次のパスに存在しませんでした。\n"+path+"/"+文字列(self.実験ID)+"/weights.hdf5")
            else:
                input("新規学習を行うため、既存のデータを消去します。enterで続行")
                実験データ.消去する()
                
        if 実験データ.開始エポック番号 is None:
            実験データ.新規設定する()
            print("モデルを作成します") # デバグ用
            モデル = モデルを作る(実験データ) 
            print("モデルを作成しました。")

        print("設定を検証します") # デバグ用
        try:
            実験データ.設定の検証()
        except 検証エラー as e:
            メッセージ = e.args[0]
            設定エラー.投げる(メッセージ)
        print("設定を検証しました") # デバグ用

        # print(arg["データを分類する式"]) # デバグ用            
        npyデータ = npyデータクラス(実験データ)    


        print("学習を開始します")
        try:
            モデル.学習する(npyデータ) # 未定義
        except KeyboardInterrupt:
            print("学習を強制停止しました。エポック番号は"+文字列(モデル.エポック番号))


    def モデルを作る(実験データ):
        高さ = 実験データ.get設定辞書("高さ")
        デコーダオンリー =  実験データ.get設定辞書("デコーダオンリー")
        コードヒント = \
"""\
・numpy imported as np
・from keras.layers * imported
・from keras.models load_model, Model, Sequential imported
・各層を表現する関数へ渡すキーワード引数は、次のように英訳されます。
"""+\
文字列(get和英辞書())+\
"""
また、Kerasの各層を用いて、次のようなラムダ式が定義済みです。
"""+\
文字列(get層lambda_code(高さ))



        
        def 処理_():
            return モデルクラス( # 未定義
                       (デコーダを作る if デコーダオンリー else EAEを作る)
                       ()
                       ,
                       実験データ                       
                   )

        def EAEを作る():
            exec(get層lambda_code(高さ))
            エンコーダ         = エンコーダを作る()
            デコーダ出力層     = デコーダを作る()(エンコーダ.output)
            カラーバンド出力層 = カラーバンドを作る()(エンコーダ.output)

            EAE出力 = 層を合体(軸=1)([デコーダ出力層, カラーバンド出力層])
            EAE = Model(EAE入力, EAE出力)
            return EAE

        def エンコーダを作る():
            msg = \
"""\
エンコーダのモデルを指示するkerasコードを入力してください。
・最初の層は「EAE入力」という変数で表現され、出力形状は("""+文字列(高さ)+","+文字列(高さ*2)+""",3)です。
"""+コードヒント+\
"""
(def直後のインデントは半角スペース4文字を強制します。)
例1:
「(エンコーダ = f()」
「def f(): )」
「    model = 直列モデル()」
「    model.add(EAE入力)」
「    model.add(畳み込み(チャンネル数=2))」
「    model.add(縮小(行=16, 列=32)) # デフォルト値について。活性化関数="relu", フィルタサイズ=(3,3), ストライド=(1,1), パディング="same"」
「    model.add(変形(形状=(2,)))」
「    return model」
「__end__」
例1の通り、関数定義終了後は「__end__」だけを入力してください。(空白やその他の文字を入れないでください)
「\n__end__」が含まれることにより、連続入力は終了します。\
"""

            # _仮_ = 読み取る_代入式なし("エンコーダ", msg=msg+"\nエンコーダ = f()\ndef f(): \n")
            # コード = "def エンコーダ生成関数():\n" + _仮_ 
            コード = 読み取る("エンコーダ", msg=msg)
            if コード.空白を取り除く() =="f()":
                if 'エンコーダ生成関数' not in arg:
                    コード = "def エンコーダ生成関数():"
                    while 文字列(コード).含まない("\n__end__"):
                        コード = コード+ "\n" + input("def f():" if コード == "def エンコーダ生成関数():" else "")
                    コード = コード.replace("\n__end__", "\n")
                else:
                    コード = arg['エンコーダ生成関数'] 
                exec(コード) # 危険
                コード = "エンコーダ生成関数()"

            try:             
                エンコーダ = eval(コード) # 危険
            except:
                モデルエラー.投げる("次のコードはエンコーダを正しく生成するkerasコードではありません: "+コード+"\n"+msg)
            else:
                try:
                    if   エンコーダ.input_shape  != (高さ, 高さ*2):
                        モデルエラー.投げる("エンコーダの入力の大きさが異常です。\n"+文字列((高さ, 高さ*2))+"でなくてはいけませんが、"+文字列(エンコーダ.input_shape)+"でした。")
                    elif エンコーダ.output_shape != (2,):
                        モデルエラー.投げる("エンコーダの出力の大きさが異常です。\n"+文字列((2,))+"でなくてはいけませんが、"+文字列(エンコーダ.output_shape)+"でした。")
                except モデルエラー as e:
                    e.投げる(e.args[0])

            return エンコーダ            
        
        def デコーダを作る():
            msg = \
"""\
デコーダのモデルを指示するkerasコードを入力してください。
・最初の層は「潜在空間」という変数で表現され、出力形状は(2,)です。
・最終的な出力形状は("""+文字列(高さ)+","+文字列(高さ*2)+""")にしてください。
"""+コードヒント+\
"""
例1:「(デコーダ = )デコーダ生成関数()」
「(def デコーダ生成関数(): )」
「    model = 直列モデル()」
「    model.add(潜在空間)」
「    model.add(変形(形状=(1,1,2)))」
「    model.add(畳み込み(チャンネル数=3, フィルタサイズ=(5,5))) # デフォルト値について。活性化関数="relu", フィルタサイズ=(3,3), ストライド=(1,1), パディング="same"」
「    model.add(拡大(行=16, 列=32))」
「    return model」
「__end__」
例1の通り、関数定義終了後は「__end__」だけを入力してください。(空白やその他の文字を入れないでください)
「\n__end__」が含まれることにより、連続入力は終了します。\
"""
 
            コード = 読み取る("デコーダ", msg=msg)
            if コード.空白を取り除く() =="デコーダ生成関数()":
                if 'デコーダ生成関数' not in arg:
                    コード = "def デコーダ生成関数():"
                    while 文字列(コード).含まない("\n__end__"):
                        コード = コード+ "\n" + input("def デコーダ生成関数():" if コード == "def デコーダ生成関数():" else "")
                    コード = コード.replace("\n__end__", "\n")
                else:
                    コード = arg['デコーダ生成関数']
                    関数頭部の正規表現 = "^(def[ \t]+デコーダ生成関数[ \t]*\([ \t]*\)[ \t]*:[ \t]*)\n"
                    if not re.findall(関数頭部の正規表現, コード):
                        モデルエラー.投げる("コードの先頭が関数「デコーダ生成関数()」の頭部ではありませんでした。\n関数頭部は次の正規表現にマッチする必要があります。\n"+関数頭部の正規表現.replace("\t", "\\t").replace("\n","\\n"))
            try:
                with open(path+"/auto_generated.py", mode="w") as pyfile:
                    pyfile.write(\
"""\
from learn4 import 辞書, キーを英訳, get和英辞書
import keras
from keras.layers import *
from keras.models import load_model, Model, Sequential

"""+get層lambda_code(高さ)+"\n"+コード)
                import auto_generated
                importlib.reload(auto_generated)
                from auto_generated import デコーダ生成関数
                デコーダ = デコーダ生成関数()
            except (SyntaxError, NameError):
                モデルエラー.投げる("次のコードはデコーダを正しく生成するkerasコードではありません: \n-----\n"+コード+"\n-----\n"+msg)
            except (ModuleNotFoundError, OSError):
                エラー.投げる("pyファイル\""+(path+"/auto_generated.py")+"\"の自動生成に失敗したようです。")
            else:
                try:
                    if   デコーダ.input_shape  != (None, 2):
                        モデルエラー.投げる("デコーダの入力の大きさが異常です。\n"+文字列((2,))+"でなくてはいけませんが、"+文字列(デコーダ.input_shape)+"でした。")
                    elif デコーダ.output_shape != (None, 高さ, 高さ*2, 3):
                        モデルエラー.投げる("デコーダの出力の大きさが異常です。\n"+文字列((高さ, 高さ*2))+"でなくてはいけませんが、"+文字列(デコーダ.output_shape)+"でした。")
                except モデルエラー as e:
                    e.投げる(e.args[0])

            return デコーダ

        

        def カラーバンドを作る():
            青成分 = 定数層(0)
            色成分 = 層を合体(軸=1)([潜在空間, 青成分])
            出力層 = 拡大(行=16, 列=32)\
                     (
                         変形((1,1,3))\
                         (色成分)
                     )
            return Model(inputs=潜在空間, outputs=出力層)
       

        
          
        return 処理_() # return of モデルを作る(実験データ)



  




    読む = "r"
    書く = "w+"
    class 実験データクラス:
        """
        実験データクラスは、各実験の詳細情報を表現するクラスである。
        """
        
        
        def __init__(self, 実験ID):
            self.実験ID = 実験ID
            self.再開モード = False
            self.開始エポック番号 = None
            self.__設定項目リストのコード =        "[self.開始エポック番号, self.デコーダオンリー, self.高さ, self.データの条件式, self.データを分類する式, self.ノイズの標準偏差, self.バッチサイズ, self.モデル保存頻度, self.テスト頻度, self.学習率]"
            exec(self.__設定項目リストのコード + " =[                 None,                  None,      None,                None,                    None,                  None,              None,                None,            None,        None]") 

        def 存在する(self): return os.path.exists(self.config_txtのパス())
        def 消去する(self): return shutil.rmtree(path+"/"+文字列(self.実験ID))
        def config_txtのパス(self): return path+"/"+文字列(self.実験ID)+"/config.txt"
        def レポートのパス(self): return path+"/"+文字列(self.実験ID)+"/report.txt"
        def result_npyのパス(self): return path+"/"+文字列(self.実験ID)+"/result.npy"
        def config_txtを(self, モード):
            with open(self.config_txtのパス(), mode=モード) as f:
                一行読む = lambda tipe : tipe(f.readline().replace("\r", "").replace("\n", ""))
                一行書く = lambda obj : f.write(文字列(obj).replace("\r", "").replace("\n", "")+"\n")
                # f.writeメソッドは書き込まれた文字列を返却してくれる
                一行読み書き = lambda tipe, obj: 一行読む(tipe) if モード==読む else tipe(一行書く(obj))

                self._設定(処理=一行読み書き, tipe="設定項目の型", obj="設定項目")
        def モデルを読む(self):
            try:
                return load_model(path+"/"+文字列(self.実験ID)+"/weights.hdf5")
            except FileNotFoundError:
                return False
            
        def 新規設定する(self):
            if not self.存在する():
                try:os.mkdir(path+"/"+文字列(self.実験ID))
                except:pass
            self._設定(処理=読み取る, key="設定項目名", tipe="設定項目の型")


        def 設定の検証(self):
            偽ならエラー(0<self.高さ and self.高さ<41, msg="0<高さ<41 かつ 高さ∈Z の必要があります")

        def _設定(self, 処理, **引数の辞書):
            引数の辞書 = 辞書(引数の辞書) # dictの自作子クラス「辞書」へダウンキャスト

                        
            引数の辞書.値の置き換え("設定項目", eval(self.__設定項目リストのコード))
            引数の辞書.値の置き換え("設定項目の型", [                 整数,                  真偽,      整数,              文字列,                  文字列,                  実数,              整数,                整数,            整数,        実数])
            引数の辞書.値の置き換え("設定項目名",   [   "開始エポック番号",    "デコーダオンリー",    "高さ",    "データの条件式",    "データを分類する式",    "ノイズの標準偏差",    "バッチサイズ",    "モデル保存頻度",    "テスト頻度",    "学習率"])
            引数の辞書.値の置き換え("初期値",       [                    0,                未定義,    未定義,              未定義,                  未定義,                未定義,            未定義,              未定義,          未定義,      未定義])

            設定項目の値のリスト = list()
            print(引数の辞書.値のリスト())
            for val0, val1 in zip(引数の辞書.値のリスト(0), 引数の辞書.値のリスト(1)):
                設定項目の値のリスト.append(\
                    eval(
                        "処理("+引数の辞書.キーのリスト(0)+"=val0, "+引数の辞書.キーのリスト(1)+"=val1)"\
                   # 例: 読み取る(                     key  =val0,                         tipe  =val1)
                    )
                )
                print(\

                        "処理("+引数の辞書.キーのリスト(0)+"=val0, "+引数の辞書.キーのリスト(1)+"=val1)"\
                   # 例: 読み取る(                     key  =val0,                         tipe  =val1)

                ) # デバグ用
                print("処理 = "+str(処理)) # デバグ用
                print("val0 = "+str(val0)) # デバグ用
                print("val1 = "+str(val1)) # デバグ用
            exec(self.__設定項目リストのコード + "=" + str(設定項目の値のリスト))
                                                          #↑[None, None, ...]

        def get設定辞書(self, key="__all__"):
            設定項目名リストのコード = self.__設定項目リストのコード.replace("self.", "'").replace(",", "',").replace("]", "']")
            キーのリスト = eval(設定項目名リストのコード)
            値のリスト   = eval(self.__設定項目リストのコード)
            d = dict(zip(キーのリスト, 値のリスト))
            return d if key=="__all__" else d[key]
            
            
        def save(self, 試験出力):
            np.save(self.result_npyのパス(), 試験出力)
   
        def レポートを書く(self, 内容):
            try: os.mkdir(path+"/"+文字列(self.実験ID))
            except FileExistsError: pass
            with open(self.レポートのパス(), mode="a") as f:
                f.write(文字列(内容)+"\n")
                
        def レポートを消去(self):
            try: os.remove(self.レポートのパス())
            except FileNotFoundError: pass
            
                
                
            
            
    class TRAIN:pass; 
    class VAL:pass; 
    class PURE:pass;
    class npyデータクラス:
        """
        npyデータクラスは、npy形式で保存されたデータを表現するクラスである
        """
        def __init__(self, 実験データ):
            _ = 実験データ
            
            [デコーダオンリー, 高さ, データの条件式, データを分類する式, ノイズの標準偏差] = [_.デコーダオンリー, _.高さ, _.データの条件式, _.データを分類する式, _.ノイズの標準偏差]

            モード名リスト = ["訓練", "検証", "試験"]             

            def 処理_():
                self.ノイズの標準偏差 = ノイズの標準偏差
                self.データたち = リサイズする(分類を行う(データを読み込む())) # uint8

            # 関数内関数たち

            def データを読み込む():
                print("データを読み込みます") # デバグ用
                try: データ = np.load(path+"/npy/data.npy")
                except FileNotFoundError: ファイルが存在しないエラー.投げる("学習用のデータが見つかりません。\n学習用のデータは次のパスに存在する必要があります。\n"+path+"/npy/data.npy")
                if デコーダオンリー:
                    入力データ = デカルト積([range(360)]*2)
                    目標データ = データ[:,0:40,:,:]
                else:
                    入力データ = データ[:,0:40,:,:]
                    目標データ = データ

                print("データを読み込みました") # デバグ用
                return [入力データ, 目標データ]
                    

            def 分類を行う(データたち):
                
                [入力データ, 目標データ] = データたち
                
                def 処理__():
                    return 不要なコマを捨てる(不要なコマを求める(コマ番号を分類する()))


                def コマ番号を分類する():
                    d = dict()
                    [d["全体"], d["訓練"], d["検証"], d["試験"]] = [set(range(360*360)), set(), set(), set()]        
                    コマ番号の集合 = d
                    
                    for x in range(360):
                        for y in range(360):
                            i = x*360+y
                            if eval(データの条件式):
                                コマ番号の集合["試験"].add(i)
                                if    eval(データを分類する式) == TRAIN:
                                    コマ番号の集合["訓練"].add(i)
                                elif  eval(データを分類する式) == VAL:
                                    コマ番号の集合["検証"].add(i)
                                elif  eval(データを分類する式) == PURE:
                                    pass
                                else:
                                    設定エラー.投げる("データを分類する式の評価値がTRAIN,VAL,PUREのいずれでもありませんでした。\n評価結果は次の通り。\n"+文字列(データを分類する式.評価()))

                    return コマ番号の集合

                def 不要なコマを求める(コマ番号の集合の辞書):
                    全体集合 = コマ番号の集合の辞書["全体"]
                    不要なコマ番号の集合の辞書 = {key: get補集合of(コマ番号の集合の辞書[key], 全体集合) for key in コマ番号の集合の辞書.keys()}
                    return 不要なコマ番号の集合の辞書


                def 不要なコマを捨てる(不要なコマ番号の集合の辞書):
                    
                    捨てる = lambda モード名, io: np.delete(io, list(不要なコマ番号の集合の辞書[モード名]), axis=0)

                    io_lambda = np.array([lambda:入力データ, lambda:目標データ]) # lambda式にしないとデカルト積を求める時にioを1次元配列とみてくれない
                    return [捨てる(モード名, io_lambda()) for モード名, io_lambda in デカルト積_(モード名リスト, io_lambda)]
                        
                return 処理__()

            def リサイズする(データたち):
                [train_in, val_in, test_in, train_out, val_out, test_out] = データたち
                幅 = 高さ*2
                
                def 処理__():
                    if デコーダオンリー:
                        # 左辺と右辺で変数名を変えないと、右辺の変数でさえローカルとみなされる
                        # → UnboundLocalError: local variable 'train_out' referenced  before assignmentとなる
                        train_in_  = train_in
                        val_in_    = val_in
                        test_in_   = test_in 
                        train_out_ = リサイズ(train_out, 高さ  , 幅)
                        val_out_   = リサイズ(val_out  , 高さ  , 幅)
                        test_out_  = リサイズ(test_out , 高さ  , 幅)
                    else:
                        train_in_  = リサイズ(train_in , 高さ  , 幅)
                        val_in_    = リサイズ(val_in   , 高さ  , 幅)
                        test_in_   = リサイズ(test_in  , 高さ  , 幅)
                        train_out_ = リサイズ(trian_out, 高さ*2, 幅)
                        val_out_   = リサイズ(val_out  , 高さ*2, 幅)
                        test_out_  = リサイズ(test_out , 高さ*2, 幅)
                    return [train_in_, train_out_, val_in_, val_out_, test_in_, test_out_]    
                        
                def リサイズ(データ, 高さ, 幅):
                    for 画像id in range(len(データ)):
                        データ[画像id, 0:高さ, 0:幅, :] = Image.fromarray(データ[画像id]).resize((幅, 高さ))
                    return データ[:, 0:高さ, 0:幅, :]                

                return 処理__()

            処理_()
            # __init__ 終

        def get(self, 潜在変数にノイズを乗せる=True):
            データたち = [(データ/256).astype(np.float32) for データ in self.データたち]
            for idx in [0,2,4]:
                データたち[idx] = データたち[idx]+np.random.normal(
                                      0,
                                      self.ノイズの標準偏差 if 潜在変数にノイズを乗せる else 0,
                                      size=データたち[idx].shape
                                  )
            return データたち
           


    class モデルクラス:
        def __init__(self, kerasモデル, 実験データ, 最大エポック番号=100000000000000000000000000):
            self.kerasモデル = kerasモデル
            self.実験データ  = 実験データ
            self.エポック番号 = "まだ開始していません"
            self.__最大エポック番号 = 最大エポック番号

            
        def 学習する(self, npyデータ, **キーワード引数たち):
            実験データ     = self.実験データ
            モデル保存頻度 =      実験データ.モデル保存頻度
            テスト頻度     =                 モデル保存頻度 * 実験データ.テスト頻度
            
            def 処理_():
                コンパイル()
                for エポック番号 in range(実験データ.開始エポック番号, self.__最大エポック番号):

                    self.エポック番号 = エポック番号
                    一回だけ重みを更新(
                        モデルを保存する = True if 整数(エポック番号).割り切れる(モデル保存頻度) else False,
                        エポック番号 = エポック番号
                    )

                    if 整数(エポック番号).割り切れる(モデル保存頻度):
                        実験データ.開始エポック番号 = エポック番号
                        実験データ.config_txtを(書く)

                    if 整数(エポック番号).割り切れる(テスト頻度):
                        テスト()

            def コンパイル():
                self.kerasモデル.compile(
                    loss=mse,
                    optimizer=Adam(
                        lr=実験データ.学習率),
                        metrics=[
                             'accuracy'
#                            'binary_accuracy',
#                            'categorical_accuracy',
#                            'sparse_categorical_accuracy',
#                            'top_k_categorical_accuracy', 
#                            'sparse_top_k_categorical_accuracy'
                        ]
                    )

            def 一回だけ重みを更新(モデルを保存する, エポック番号):
                [訓練入力, 訓練目標, 検証入力, 検証目標, _, _] = npyデータ.get(潜在変数にノイズを乗せる=True)
                実験データ = self.実験データ            
                self.kerasモデル.fit(
                    x          = (訓練入力),
                    y          = (訓練目標),
                    batch_size = 実験データ.バッチサイズ,
                    epochs     = エポック番号+1,
                    verbose    = 1,
                    callbacks  = [
                        数回置きにセーブ(
                            path+"/"+文字列(実験データ.実験ID)+"/weights.hdf5",
                            period  = 1
                        )
                    ] if モデルを保存する else [],
                    validation_data = (検証入力, 検証目標),
                    initial_epoch=エポック番号
                )
                # todo 損失と誤差も書き出そう


            def テスト():
                [_, _, _, _, テスト入力, テスト目標] = npyデータ.get(潜在変数にノイズを乗せる=False)
                テスト出力 = self.kerasモデル.predict(テスト入力)
                self.実験データ.save(テスト出力)

            処理_()

                        

                        

                    



            
    # クラス定義

    class 文字列(str):
        def __new__(cls, self):return super(文字列, cls).__new__(cls, self)
        def 空白を取り除く(self): return self.replace(" ", "").replace("\t","").replace("\r", "").replace("\n", "")
        def replace(self, a,b): return 文字列(super().replace(a,b))
        def 含む(self, target): return target in self
        def 含まない(self, target): return target not in self

    """
    class 文:
        def __init__(self, code):
            self.as文字列 = 文字列(code)
            安全性検証 = lambda code: True # 本当は正規表現などで安全性を確認すべき
            if not 安全性検証(self.as文字列):
                式エラー.投げる("次のコードはブロックされました。\n"+code)
            self.メモリ = dict()

        def __str__(self):
            return self.as文字列

        def 評価(self, キー=None):
            if キー is None:
                #print(self.as文字列) 
                return eval(self.as文字列)
            else:
                self.メモリ[キー] = eval(self.as文字列)
        def 実行(self): exec(self.as文字列)
    """            
    class 整数(int):
        def __new__(cls, self):return super(整数, cls).__new__(cls, self)
        def 割り切れる(self, target): return not self % target            
        
    実数 = float
    真偽 = lambda x: bool(int(x))

    class エラー(Exception):
        @classmethod
        def 投げる(cls, msg=""): raise cls(msg)
    class ファイルが存在しないエラー(エラー, FileNotFoundError):pass
    class 検証エラー(エラー, AssertionError):pass
    class 設定エラー(エラー):pass
    class 式エラー(エラー):pass
    class モデルエラー(エラー):pass

# ↓↓↓未定義なメソッドや関数を宣言するデコレータに使います。↓↓↓
    class 未定義Error(Exception):
        def __init__(self, f): super().__init__(str(f)+"は未定義です")
    class 未定義:
        def __init__(self, f): raise 未定義Error(f)
    class 未定義メソッド:
        def __init__(self, m): self.m = m
        def __call__(self, *args, **kwargs): raise 未定義Error(self.m)    
# ↑↑↑未定義なメソッドや関数を宣言するデコレータに使います。↑↑↑
            



            





        

    # 汎用的関数・ラムダ式たち

    def 偽ならエラー(条件式, msg="", if_ok=None):
        if not 条件式:
            検証エラー.投げる(msg)
        return if_ok
    # assert文は処理系の設定で無効にできるので公開プログラムに適用すべきではない


    """def 未定義(変数, 未定義のとき返すもの=True):
        try:変数
            return False
        except:
            return 未定義のとき返すもの"""
        
    読み取る            = lambda key, msg="", tipe=文字列, default=lambda key, msg: input(msg+"\n"+key + " = "): tipe(arg[key] if key in arg else default(key, msg))
    読み取る_代入式なし = lambda key, msg="", tipe=文字列, default=lambda key, msg: input(msg                 ): tipe(arg[key] if key in arg else default(key, msg))

    get補集合of = lambda 集合, 全体集合 : 全体集合-集合

    
    処理()









class 辞書エラー(Exception):
    @classmethod
    def 投げる(cls, msg=""): raise cls(msg)

class 辞書(dict):
    def __init__(self,  obj={}): self.update(dict(obj))
    def 逆引き(self, 値):
        for k,v in self.items():
            if 値 == v:
                return k
        辞書エラー.投げる("値が"+str(値)+"となっているキーは、辞書内に見つかりませんでした")
    def 値の置き換え(self, 前,後):
        while True:
            try:
                self.update({self.逆引き(前):後})
            except 辞書エラー:
                return
    def キーのリスト(self, idx=None):
        if idx is None: return list(self.keys())
        else          : return list(self.keys())[idx]
    def 値のリスト(self, idx=None):
        if idx is None: return list(self[key] for key in self.キーのリスト())
        else          : return list(self[key] for key in self.キーのリスト())[idx]

    def 無ければ追加(self, 追加される辞書):
        for k,v in 追加される辞書.items():
            self.setdefault(k,v)
        return self



def キーを英訳(日本語kwargs):
    ks = list(日本語kwargs.keys())
    for k in ks:
        try:
            get和英辞書()[k]
            日本語kwargs[get和英辞書()[k]] = 日本語kwargs.pop(k)
        except KeyError: continue
    return 日本語kwargs
                   
# {形:(1,), ストライド:(1,1)} を{"shape":(1,), "strides":(1,1)}へ
        

def get和英辞書():
    
    return {
        "形"                 :"shape"             ,
        "ストライド"         :"strides"           ,
        "パディング"         :"padding"           ,
        "重み行列初期化"     :"kernel_initializer",
        "バイアス初期化"     :"bias_initializer"  ,
        "学習可能"           :"trainable"         ,
        "名前"               :"name"              ,
        "軸"                 :"axis"              ,
        "活性化関数"         :"activation"        ,
        "フィルタ数"         :"filters"           ,
        "フィルタサイズ"     :"kernel_size"
    }

def get層lambda_code(高さ):
    return """\
全結合層 = lambda 出力次元数,   **キーワード引数たち: Dense(出力次元数, **キーを英訳(キーワード引数たち))
初期化   = lambda 定数,         **キーワード引数たち: keras.initializers.Constant(value=定数, **キーを英訳(キーワード引数たち))
定数層   = lambda 定数,         **キーワード引数たち: 全結合層(1, 重み行列初期化=初期化(0), バイアス初期化=初期化(定数), 学習可能=False, **キーを英訳(キーワード引数たち))(潜在空間)
層を合体 = lambda               **キーワード引数たち: Concatenate(**キーを英訳(キーワード引数たち))
変形     = lambda 形状,         **キーワード引数たち: Reshape(形状, **キーを英訳(キーワード引数たち))
拡大     = lambda 行,列,        **キーワード引数たち: UpSampling2D(size=(行,列), **キーを英訳(キーワード引数たち))
縮小     = lambda 行,列,        **キーワード引数たち: MaxPooling2D(pool_size=(行,列), **キーを英訳(キーワード引数たち))
畳み込み = lambda チャンネル数, **キーワード引数たち: Conv2D(filters=チャンネル数, **(キーを英訳(辞書(キーワード引数たち)).無ければ追加({"kernel_size":(3,3), "strides":(1,1), "padding":"same", "activation":"relu"})))
直列モデル = Sequential
入力層   = lambda 形状,         **キーワード引数たち: Input(shape=形状, **キーを英訳(キーワード引数たち))
潜在空間 = 入力層(形状=(2,))
EAE入力  = 入力層(形状= ("""+str(高さ)+""", """+str(高さ*2)+""", 3))"""