自動機械学習でニューラルネットワークを進化させる方法

自動機械学習でニューラルネットワークを進化させる方法

機械学習に携わるほとんどの人にとって、ニューラル ネットワークの設計は芸術作品の作成に似ています。ニューラル ネットワークは通常、共通のアーキテクチャから始まり、レイヤー、アクティベーション関数、正規化子、最適化パラメータの適切な組み合わせが見つかるまで、パラメータを継続的に調整して最適化する必要があります。 VGG、Inception、ResNet、DenseNet などのよく知られたニューラル ネットワーク アーキテクチャのガイダンスに従って、ネットワークが期待する速度と精度に達するまで、ネットワーク変数を繰り返し操作する必要があります。ネットワーク処理能力が向上し続けると、ネットワーク最適化プロセスを自動化することがますます可能になります。

ランダムフォレストや SVM などの浅いモデルでは、ハイパーパラメータの最適化のプロセスを自動化できました。 sk-learn などのよく使用されるツールキットには、ハイパーパラメータ空間を検索する方法が用意されています。最も単純で基本的な形式では、「ハイパーパラメータ」とは、すべての可能なパラメータの中から検索されるパラメータ、またはパラメータ分布から任意にサンプリングして取得されるパラメータです。 (詳細については、このリンクをクリックしてください。) どちらの方法にも 2 つの問題があります。1 つ目は、間違ったパラメータ領域を検索するときにリソースを浪費することです。2 つ目は、多数の動的機能パラメータ セットを処理するのに非効率的であることです。したがって、プロセッサ アーキテクチャを変更することは非常に困難になります。現在では、ベイズ最適化法など、一見効率的と思われる方法が数多く存在します。しかし、ベイズ最適化は最初の問題を解決できますが、2 番目の問題は解決できません。さらに、ベイズ最適化設定でモデルを探索することは困難です。

攻撃パターンを自動的に識別するというアイデアは新しいものではなく、最近の処理能力の向上により、これまで以上に簡単に実行できるようになりました。

問題設定

ハイパーパラメータの最適化を考える方法の 1 つは、「メタ学習問題」として考えることです。

ネットワークのパフォーマンスが良好かどうかを判断するために使用できるアルゴリズムを作成できますか?

注: この問題を「メタ学習」と表現するのは少し混乱を招くかもしれませんが、以下では「メタ学習」という用語を使い続けます。ただし、これを「学習」に関連するいくつかの方法と混同してはなりません。

私たちの目標は、ネットワーク内の隠し層 (緑) の数と各隠し層のパラメータを定義することです。

具体的には、モデル アーキテクチャとモデルのパラメーター空間を調査して、特定のデータセットでのパフォーマンスを最適化します。問題は複雑であり、その見返りはわずかです。スパース報酬と言われる理由は、ネットワークを十分にトレーニングして評価する必要があり、トレーニングと評価が完了した後は報酬としていくつかのスコアしか得られないからです。これらのスコアはシステム全体のパフォーマンスを反映しており、このタイプの報酬は微分可能な関数ではありません。そういえば、何か思い出しますか？はい、これは典型的な「強化学習」の状況です。

Wikipedia では「強化学習」を次のように定義しています。

「強化学習」（RL）は、心理学の行動主義理論にヒントを得た重要な機械学習手法です。具体的には、「強化学習」とは、生物（エージェント）が環境（環境）の刺激を受けて、累積報酬を最大化する方法を学ぶことです。

「強化学習」と標準的な教師あり学習の違いは、正しい入力または出力のペアを表示する必要がなく、動作を最適化するために正確な調整も必要ないことです。さらに、「オンラインパフォーマンス」は「強化学習」の焦点でもあり、未知の領域の探索と既存の知識の発展のバランスを見つけることです。

上記のシナリオのエージェントはモデルであり、環境はトレーニングと評価に使用するデータセットです。インタープリターは、各動作を分析し、生物の状態 (この場合はネットワーク パラメーター) を設定するプロセスです。

通常、「強化学習」の問題は、マルコフ決定プロセスとして定式化されます。目標は、生物への総収益を最適化することです。各ステップで、モデル出力を最適化するか、新しい動作を探索するかを決定する必要があります。環境からの刺激を受けて、生物は受け取ったフィードバックに基づいて調整方針を形成し、継続的に行動を改善します。

注: このトピックはこの記事の範囲を超えています。R.Sutton と A. Barto による「Introduction to Reinforcement Learning」が、おそらくこのテーマに関する最高の入門書です。

進化的アルゴリズム

「強化学習」問題を解決するためのもう 1 つのアプローチは、「進化的アルゴリズム」です。生物の進化にヒントを得た進化型アルゴリズムは、一連のソリューションを作成することでソリューション空間を検索し、各ソリューションを評価し、評価スコアに基づいてソリューションのセットを継続的に調整します。生物進化論で言及される「進化」には、集団内の特定のメンバーの選択と変化が含まれます。したがって、当社のソリューション セットは、全体的な適応性を向上させ、問題に対する実行可能なソリューションを提供するために進化し続けます。

上の図の左側は進化のプロセスを示しています。「進化アルゴリズム」の設計には、「選択」と、従う必要のある「国境を越えた」または「突然変異」戦略という 2 つの部分が含まれます。

「選択」：「選択」では、通常、多様性を実現するために、最良の個体といくつかの任意の個体を選択します。より高度な選択方法は、個体群の下に異なる「サブグループ」または「種」を設定し、その種の多様性を保護するために種内の最良の個体を選択することです。もう一つの一般的なアプローチは「競争的選択」であり、これは競争に参加する個体をランダムに選択し、勝者（優れた遺伝子を持つ個体）を選ぶというものです。

「クロスオーバー」: 「クロスオーバー」は「交配」とも呼ばれ、2 つ以上の親のグループを交配させて子孫を生み出すことを指します。 「クロスオーバー」は、問題がどのように表現されるかによって大きく異なります。一般的なアプローチは、親を項目のリスト (通常は数値) で記述し、親から任意の部分を選択して新しい遺伝子の組み合わせを生成することです。

「突然変異」：「突然変異」または「変異」は、ゲノムを任意に変更するプロセスを指します。これは主要な発展要因であり、人口の多様性を維持するのに役立ちます。

実装

「進化的アルゴリズム」の実装では、PyTorch を使用して、単純な分類タスクのために DNN を探索するエージェントを構築します。この実験では、CPU でもトレーニングできるほど小さくて高速な MNIST を使用します。 DNN モデルのセットを構築し、N ステップで進化させます。

私たちが話している「進化」という話題は、実際には「自然選択」の実装です。完全な高レベルの「進化アルゴリズム」は次のとおりです。

  1. 新しい人口 = []
  2.   サイズ(新しい人口) < 人口サイズの場合:
  3.   集団からk(トーナメント)人の個体をランダムに選ぶ
  4.   確率p1でプール/トーナメントから最善のものを選択する
  5.   確率p2で2番目に良い個体を選択する
  6.   確率p3で3番目に良い個体を選択する
  7.   選択したものを変異させてnew_populationに追加する

補足：建築業界の合併となると、国境を越えた問題は非常に複雑になります。 2 つの親構造をどのように結合しますか?欠陥パターンと環境統合トレーニングはこれにどのような影響を与えるでしょうか? Miikkulainen らによる最近の論文では、CoDeepNEAT と呼ばれるソリューションが提案されています。エボリーノ進化理論に基づいて、アーキテクチャはいくつかの単位モジュールで構成され、各単位モジュールは進化理論の対象となります。このアーキテクチャは、すべてのコンポーネントを組み込んだ理想的な青写真です。このようなシナリオでは、親のコンポーネントを混合することは完全に理にかなっています。なぜなら、それらの構成は完全なマイクロネットワークだからです。記事をより簡潔で分かりやすくするために、このアルゴリズムの実装における国境を越えた問題を避け、単に NEAT (または CoDeepNEAT) のようなソリューションを紹介しました。 (これらの解決策については、次の投稿でさらに詳しく説明する予定です。)

基本的な構成要素

最初に定義する必要があるのは、各モデル (それぞれがアーキテクチャを表す) のソリューション スペースです。簡単にするために、n 個のレイヤーを積み重ねます。各レイヤーには、a) 隠れユニットの数、b) アクティベーション タイプ、c) ドロップアウト率という 3 つのパラメーターが含まれます。共通パラメータについては、さまざまなオプティマイザー、学習率、重み減衰、レイヤー数の中から選択します。

  1.  # スペースの定義
  2. # 下限 - 上限、型パラメータ、突然変異率
  3. LAYER_SPACE = dict()
  4.  LAYER_SPACE['nb_units'] = (128, 1024, 'int', 0.15)
  5.  LAYER_SPACE['ドロップアウト率'] = (0.0, 0.7, 'フロート', 0.2)
  6.  LAYER_SPACE['アクティベーション'] =\
  7.    (0, ['線形', 'tanh', 'relu', 'シグモイド', 'elu'], 'リスト', 0.2)
  9.  NET_SPACE = 辞書()
  10.  NET_SPACE['nb_layers'] = (1, 3, 'int', 0.15)
  11.  NET_SPACE['lr'] = (0.0001, 0.1, 'float', 0.15)
  12.  NET_SPACE['weight_decay'] = (0.00001, 0.0004, 'float', 0.2)
  13.  NET_SPACE['オプティマイザー'] =\
  14.    (0, ['sgd', 'adam', 'adadelta', 'rmsprop'], 'リスト', 0.2)

上記の操作を完了すると、モデルの空間が定義されます。次に、3 つの基本機能を確立する必要があります。

ランダムにネットワークを選択

  1. def random_value(スペース):
  2.    「指定された空間からランダムな値をサンプリングします。」
  3.    値 = なし
  4.    スペース[2] == 'int'の場合:
  5.        val = ランダム.randint(スペース[0], スペース[1])
  6.    スペース[2] == 'リスト'の場合:
  7.        val = ランダム.サンプル(空間[1], 1)[0]
  8.    スペース[2] == 'float'の場合:
  9.        val = ((スペース[1] - スペース[0]) * random.random()) + スペース[0]
  10.    戻り値: {'val': val, 'id': random.randint(0, 2**10)}
  13.  def randomize_network(bounded=True):
  14.    「ランダムネットワークを作成します。」
  15.    グローバル NET_SPACE、LAYER_SPACE
  16.    ネット = 辞書()
  17.    NET_SPACE.keys() の k の場合:
  18.        ネット[k] = ランダム値(NET_SPACE[k])
  20.    制限がある場合:
  21.        ネット['nb_layers']['val'] = min(ネット['nb_layers']['val'], 1)
  23.    レイヤー = []
  24.    i が範囲内(net['nb_layers']['val'])の場合:
  25.        レイヤー = dict()
  26.        LAYER_SPACE.keys() 内の k について:
  27.            レイヤー[k] = ランダム値(レイヤースペース[k])
  28.        レイヤーの追加
  29.    net['layers'] = レイヤー
  30.    リターンネット

まず、サンプル値が事前に定義された範囲の境界内に収まるように、レイヤーの数と各レイヤーのパラメータを任意にサンプリングします。パラメータを初期化するときに、任意のパラメータ ID も生成します。まだ使用可能ではありませんが、すべてのレイヤーを追跡できます。新しいモデルが変更されると、古いレイヤーは微調整され、変更されたレイヤーのみが初期化されます。これにより、ソリューションの速度と安定性が大幅に向上します。

注: 問題の性質に応じて、パラメータの合計数やレイヤーの合計数など、異なる制約が必要になる場合があります。

ネットワークの変異

  1. def mutate_net(ネット):
  2.    「ネットワークを変異させる。」
  3.    グローバル NET_SPACE、LAYER_SPACE
  5.    # ミューテートオプティマイザー
  6.    k が ['lr', 'weight_decay', 'optimizer'] の場合:
  8.        random.random() < NET_SPACE[k][-1]の場合:
  9.            ネット[k] = ランダム値(NET_SPACE[k])
  11.    # レイヤーを変更する
  12.    net['layers']内のレイヤーの場合:
  13.        LAYER_SPACE.keys() 内の k について:
  14.            random.random() < LAYER_SPACE[k][-1]の場合:
  15.                レイヤー[k] = ランダム値(レイヤースペース[k])
  16.    # レイヤーの数を変更する -- ランダムに追加
  17.    random.random() < NET_SPACE['nb_layers'][-1]の場合:
  18.        net['nb_layers']['val'] < NET_SPACE['nb_layers'][1]の場合:
  19.            random.random()< 0.5 の場合:
  20.                レイヤー = dict()
  21.                LAYER_SPACE.keys() 内の k について:
  22.                    レイヤー[k] = ランダム値(レイヤースペース[k])
  23.                net['レイヤー'].append(レイヤー)
  24.                # 値とIDの更新
  25.                ネット['nb_layers']['val'] = len(ネット['layers'])
  26.                ネット['nb_layers']['id'] += 1
  27.            それ以外：
  28.                net['nb_layers']['val'] > 1の場合:
  29.                    net['レイヤー'].pop()
  30.                    ネット['nb_layers']['val'] = len(ネット['layers'])
  31.                    ネット['nb_layers']['id'] -= 1
  32.    リターンネット

各ネットワーク要素には突然変異の可能性があり、各突然変異によってパラメータ空間が再サンプリングされ、パラメータが変更されます。

ネットワークを構築する

  1. クラス CustomModel():
  3.    def __init__(self, build_info, CUDA=True):
  5.        前の単位 = 28 * 28
  6.        自己.モデル = nn.Sequential()
  7.        self.model.add_module('flatten', Flatten())
  8.        iの場合、layer_infoをenumerate(build_info['layers'])で指定します:
  9.            i = str(i)
  10.            自己.モデル.モジュールの追加(
  11.                'fc_' + i,
  12.                nn.Linear(前の単位、レイヤー情報['nb_units']['val'])
  13.                ）
  14.            自己.モデル.モジュールの追加(
  15.                'ドロップアウト_' + i,
  16.                nn.ドロップアウト(p=layer_info['ドロップアウト率']['val'])
  17.                ）
  18.            layer_info['activation']['val'] == 'tanh'の場合:
  19.                自己.モデル.モジュールの追加(
  20.                    'tanh_'+i、
  21.                    nn.Tanh()
  22.                ）
  23.            layer_info['activation']['val'] == 'relu'の場合:
  24.                自己.モデル.モジュールの追加(
  25.                    'relu_'+i、
  26.                    nn.ReLU()
  27.                ）
  28.            layer_info['activation']['val'] == 'sigmoid'の場合:
  29.                自己.モデル.モジュールの追加(
  30.                    'sigm_'+i、
  31.                    nn.シグモイド()
  32.                ）
  33.            layer_info['activation']['val'] == 'elu'の場合:
  34.                自己.モデル.モジュールの追加(
  35.                    'elu_'+i、
  36.                    nn.ELU()
  37.                ）
  38.            previous_units = レイヤー情報['nb_units']['val']
  40.        自己.モデル.モジュールの追加(
  41.            '分類レイヤー',
  42.            nn.Linear(前の単位、10)
  43.            ）
  44.        self.model.add_module('sofmax', nn.LogSoftmax())
  45.        自己.モデル.CPU()
  47.        build_info['optimizer']['val'] == 'adam'の場合:
  48.            オプティマイザー = optim.Adam(self.model.parameters(),
  49.                                lr = build_info['weight_decay']['val'],
  50.                                weight_decay = build_info['weight_decay']['val'])
  52.        elif build_info['optimizer']['val'] == 'adadelta':
  53.            オプティマイザ = optim.Adadelta(self.model.parameters(),
  54.                                    lr = build_info['weight_decay']['val'],
  55.                                    weight_decay = build_info['weight_decay']['val'])
  57.        elif build_info['optimizer']['val'] == 'rmsprop':
  58.            オプティマイザー = optim.RMSprop(self.model.parameters(),
  59.                                    lr = build_info['weight_decay']['val'],
  60.                                    weight_decay = build_info['weight_decay']['val'])
  61.        それ以外：
  62.            オプティマイザ = optim.SGD(self.model.parameters(),
  63.                                lr = build_info['weight_decay']['val'],
  64.                                weight_decay=build_info['weight_decay']['val'],
  65.                                運動量=0.9)
  66.        self.optimizer = オプティマイザー
  67.        self.cuda = False
  68.        CUDAの場合:
  69.            自己.モデル.cuda()
  70.            self.cuda = 真

上記のクラスは、モデルの「ゲノム」をインスタンス化します。

これで、任意のネットワークを構築し、そのアーキテクチャを変更してトレーニングするための基本的な構成要素が揃ったので、次のステップは、*** 個体を選択して変異させる「遺伝的アルゴリズム」を構築することです。各モデルのトレーニングは独立して実行され、他の生物からの情報は必要ありません。これにより、最適化プロセスは利用可能な処理ノードに応じて線形に拡張できるようになります。

GPオプティマイザのコーディング

  1. 「遺伝的プログラミングアルゴリズム」
  2.  __future__ から absolute_import をインポートする
  4. ランダムにインポート
  5. numpyをnpとしてインポートする
  6. 演算子からアイテムゲッターをインポート
  7. torch.multiprocessing を mp としてインポートします。
  8.  net_builderからrandomize_networkをインポートします
  9. インポートコピー
  10. ワーカーから CustomWorker をインポートし、スケジューラを作成します。
  13. クラスTournamentOptimizer:
  14.    「トーナメントプレイの選択プロセスを定義します。」
  16.    def __init__(self、population_sz、init_fn、mutate_fn、nb_workers=2、use_cuda=True):
  17.        「」
  18.        オプティマイザーを初期化します。
  20.            パラメータ::
  22.                init_fn: モデルを初期化する
  23.                mutate_fn: mutate関数 - モデルを変更する
  24.                nb_workers: ワーカー数
  25.        「」
  27.        自己.init_fn = init_fn
  28.        自己.mutate_fn = mutate_fn
  29.        自己.nb_workers = nb_workers
  30.        自己.use_cuda = 使用_cuda
  32.        ＃ 人口
  33.        自己.population_sz = 人口_sz
  34.        self.population = [init_fn() がiの範囲内(population_sz)]
  35.        自己評価 = np.zeros(population_sz)
  37.        ＃簿記
  38.        自己エリート = []
  39.        自己統計 = []
  40.        自己履歴 = []
  42.    defステップ(self):
  43.        「トーナメント進化ステップ」
  44.        print('\n人口サンプル:')
  45.        i が範囲 (0,self.population_sz,2) 内にある場合:
  46.            印刷(self.population[i]['nb_layers'],
  47.                  self.population[i]['レイヤー'][0]['nb_units'])
  48.        自己評価()
  49.        子供 = []
  50.        print('\n人口平均:{} 最大値:{}'.format(
  51.            np.mean(自己評価)、np.max(自己評価)))
  52.        n_エリート = 2
  53.        sorted_pop = np.argsort(self.evaluations)[::-1]
  54.        エリート = sorted_pop[:n_elite]
  56.        # top@n_elite のスコアを出力
  57.        # エリートは常に次の人口に含まれる
  58.        自己エリート = []
  59.        print('\nトップパフォーマー:')
  60.        enumerate(elite)のi,eの場合:
  61.            self.elite.append((self.evaluations[e], self.population[e]))
  62.            print("{}-score:{}".format(str(i), self.evaluations[e]))
  63.            children.append(自己.population[e]) を追加
  64.        # トーナメントの確率:
  65.        # 最初のp
  66.        # 2番目 p*(1-p)
  67.        # 3番目のp*((1-p)^2)
  68.        # などなど
  69.        p = 0.85 # 勝者の確率
  70.        トーナメントサイズ = 3
  71.        probs = [p*((1-p)**i)、i が範囲 (トーナメントサイズ-1)] 内である
  72.        # 確率が 1.0 に加算されることを確認するためのちょっとしたトリック
  73.        確率.append(1-np.sum(確率))
  75.        len(children) < self.population_sz の場合:
  76.            人口 = 範囲(len(自己人口))
  77.            sel_k = ランダムサンプル(pop, k=トーナメントサイズ)
  78.            fitness_k = リスト(np.array(self.evaluations)[sel_k])
  79.            選択された = zip(sel_k, fitness_k)
  80.            ランク = sorted(選択済み、キー = itemgetter(1)、逆順 = True)
  81.            pick = np.random.choice(トーナメントサイズ、サイズ=1、p=確率)[0]
  82.            ベスト = ランク[選択][0]
  83.            モデル = self.mutate_fn(self.population[best])
  84.            children.append(モデル)
  86.        自己人口 = 子供
  88.        # エポックごとに完全にランダムな検索を実行したい場合
  89.        # self.population = [randomize_network(bounded=False) i が range(self.population_sz) 内にある場合]
  91.    def 評価(自己):
  92.        「モデルを評価する」
  94.        ワーカーID = 範囲(self.nb_workers)
  95.        ワーカープール = Scheduler(ワーカーID、self.use_cuda)
  96.        self.population は、workerpool.start(self.population) を返します。
  98.        self.evaluations = 戻り値
  99.        self.stats.append(copy.deepcopy(戻り値))
  100.        自己履歴の追加(コピー.ディープコピー(自己人口))

「進化的アルゴリズム」は非常にシンプルに思えますよね?それは正しい！このアルゴリズムは、特に個体に対して適切なバリアントまたはクロスドメイン関数を定義している場合に、非常に成功する可能性があります。

リポジトリには、ワーカー クラスやスケジューラ クラスなどの追加の使用クラスも含まれており、GP オプティマイザーがモデルのトレーニングと評価を独立して並行して完了できるようになります。

コードを実行する

上記の手順に従って実行してください。

  1.  「トーナメントプレイ実験」
  2.  __future__ から absolute_import をインポートする
  3. net_builderをインポートする
  4. インポートGP
  5.  cPickleをインポートする
  6. # cuda を使用しますか?
  7.  CUDA_ = 真
  9. __name__ == '__main__' の場合:
  10.    # トーナメントを設定しましょう!
  11.    進化ステップ数 = 10
  12.    トーナメント = \
  13.        gp.トーナメントオプティマイザー(
  14.            人口規模=50,
  15.            init_fn=net_builder.randomize_network、
  16.            mutate_fn = net_builder.mutate_net、
  17.            労働者数=3,
  18.            use_cuda=True)
  20.    i が範囲内(nb_evolution_steps)の場合:
  21.        print('\n進化ステップ:{}'.format(i))
  22.        印刷('=================')
  23.        トーナメント.ステップ()
  24.        # 実験結果と対応するアーキテクチャを追跡する
  25.        名前 = "tourney_{}".format(i)
  26.        cPickle.dump(tournament.stats、open(name + '.stats'、'wb')) を実行します。
  27.        cPickle.dump(tournament.history、open(name +'.pop'、'wb')) でダンプします。

次は手術の結果を見てみましょう！

一致サイズが 3 の 50 個のソリューションのスコアリング結果を以下に示します。モデルは 10,000 個のサンプルのみでトレーニングされ、その後評価されました。一見すると、最初の進化段階ではソリューションが最適に近かったのに、7 番目の段階ではソリューションが最高のパフォーマンスに達したため、進化アルゴリズムはあまりうまく機能しなかったようです。下の図では、ボックス プロットを使用して、これらのソリューションの 4 分の 1 を順番に示しています。ほとんどのソリューションはうまく機能しましたが、ソリューションが進化するにつれて、ボックス プロットも縮小することがわかりました。

図のボックスはソリューションの 4 分の 1 を示しており、そのウィスカーはソリューションの残りの 4 分の 3 の分布を示すように伸びています。黒い点は解の平均値を表しており、図から平均値が増加していることがわかります。

この方法のパフォーマンスと動作をさらに理解するために、完全にランダムな集団検索と比較しました。各ステージ間で進化は必要ありません。各ソリューションはランダムな状態にリセットされます。

EA は比較的小規模な集団ではより優れたパフォーマンスを発揮します (93.66% 対 93.22%)。ランダムな集団検索ではいくつかの優れたソリューションが生成されるように見えますが、モデルの分散は大幅に増加します。つまり、最適ではないアーキテクチャを探している間にリソースが浪費されることになります。これを進化グラフと比較すると、進化によって確かにより有用なソリューションが生成され、より優れたパフォーマンスを実現する構造がうまく進化していることがわかります。

  • MNIST は非常にシンプルなデータセットであり、単層ネットワークでも高い精度を達成できます。

  • ADAM のようなオプティマイザーは学習率にあまり影響されず、ネットワークに十分なパラメータがある場合にのみ適切なソリューションを見つけることができます。

  • トレーニング中、モデルは 10,000 個の例 (トレーニング データ全体の 1/5) のみを参照します。より長くトレーニングすれば、優れたアーキテクチャでより高い精度を達成できる可能性があります。

  • サンプル数を制限することは、学習するレイヤーの数にとっても非常に重要です。より深いモデルには、より多くのサンプルが必要です。この問題に対処するために、突然変異を除去し、集団がレイヤーの数を調節するようにするレイヤーも追加しました。

この実験の規模は、この方法の利点を強調するには十分ではありません。これらの記事で使用されている実験はより大規模で、より複雑なデータセットを持っています。

私たちは、「適者生存」というテーマを非常によく表す単純な進化アルゴリズムを完成させました。私たちのアルゴリズムは、最終的な勝利のソリューションのみを選択し、それを変異させてより多くの子孫を生成します。次に必要なのは、より高度な方法を使用してソリューション グループを生成および開発することだけです。改善のための提案をいくつか示します。

  • 共通レイヤーの親ウェイトを再利用する

  • 2つの潜在的な親からのレイヤーを結合する

  • アーキテクチャは連続的である必要はなく、レイヤー間のさまざまな接続（分散または結合など）を探索できます。

  • 上にレイヤーを追加し、微調整を行います。

上記はすべて人工知能研究の分野におけるトピックです。最も人気のある方法の 1 つは、NEAT とその拡張です。 EAT バリアントは、進化的アルゴリズムを使用してネットワークを開発し、同時にネットワークの重みも設定します。典型的な強化学習シナリオでは、エージェントの重みの進化は非常に可能です。ただし、(x,y) 入力ペアが利用可能な場合、勾配降下法のパフォーマンスが向上します。

関連記事

Evolino: ハイブリッドニューロエボリューション / シーケンス学習のための最適線形探索

進化するディープ ニューラル ネットワーク — これは、ネットワーク全体とネットワーク内のブロックを共進化させる非常に興味深いアプローチであり、CNN 向けの Evolino メソッドに非常に似ています。

画像分類器の大規模進化

進化による畳み込み

この記事はLeiphone.comから転載したものです。転載する場合は、Leiphone.com公式サイトにアクセスして許可を申請してください。

<<:  データが限られている場合にディープラーニングモデルを最適化する方法

>>:  Uber劉延東：Uberがフードデリバリーサービスを開始したとき、世界中のフードデリバリー会社は衝撃を受けた

ブログ    
ブログ    
ブログ    
ブログ    

推薦する

...

...

プレイヤー同士のアライアンス形成が加速しているが、アライアンスは自動運転の新たな活路となり得るのか？

さまざまなメーカーが続々と参入し、スマートカー市場はますます熱を帯びています。このような背景から、ス...

顔認識アクセス制御システムの登場により、私たちのプライバシーを誰が守るのでしょうか?

最近は「顔カード」、つまり「顔を売る」という言葉をよく耳にしますが、あなたの「顔」が身分証明書や電話...

インターネット大手が一斉に禁止、AIによる顔の改造はどこまで可能か？

​​昨年、微博で話題になった動画を覚えている人はどれくらいいるだろうか。『射雁英雄伝』で朱茵娜が演じ...

Google、写真を撮るだけで皮膚疾患を検出するAIツールの新機能を発表

5月19日、Googleの開発者会議I/O 2021が開幕した。完全オンライン形式を採用し、Goog...

自動配送物流における人工知能の応用

[[406604]]コロナウイルスの流行を受けて、企業はサプライチェーンの複雑性と労働力不足の課題を...

人工知能を使ってエッセイを採点するのは信頼できると思いますか?

現在、5Gは世界的な注目を集めていますが、人工知能の開発は依然として力強いままです。各分野における技...

スマートホテルの室内技術トレンドを探る

オンライン予約プラットフォームは人々の旅行計画の方法に革命をもたらし、モバイルアプリによりユーザーは...

今後の展望：自動運転におけるビッグモデル技術の応用と影響

この記事は、Heart of Autonomous Driving の公開アカウントから許可を得て転...

...

...

Tencent IEG オープンソース AI SDK: PUBG および MOBA ゲームの自動テスト

SDK はゲームを自動的にプレイすることもできますか?この SDK はちょっと「クール」です。 [[...

世界最強のモデル クロード3号が物理・化学を覆す！博士課程の1年間の実験の結果が2時間で解読され、ネットユーザーは「科学的研究はもう存在しない」と叫んだ。

クロード3号は今も奇跡を起こし続けています。公開からわずか数日後、ますます多くの博士号取得者が、未発...

フーダンの新しい服が再びネイチャーに登場しました！体に装着したまま携帯電話を充電でき、洗濯可能で折り曲げることもできます。

[[421250]]この記事はAI新メディアQuantum Bit（公開アカウントID：QbitA...