神経科学 | USHITORA Lab.

Abdou E et al. Synapse-specific representation of the identity of overlapping memory engrams. Science 360, 1227-1231 (2018)

目的

他と神経アンサンブルを共有して保持された個々の記憶がアイデンティティーを保っているか、また１つの記憶が消去された場合に、それは異なる運命を辿ることになるのか、を調べる。

事実

introduction

Auditory Fear Conditioning (AFC) の記憶は、 auditory cortex (AC) / medial geniculate nucleus (MGm) と lateral amygdala (LA) の間のシナプス増強として蓄積される。
- Tovote P et al. Nat Rev Neurosci 16, 317-331 (2015)

fig 1

記憶を部分的に消去 (anisomycin: Ani) した場合は光刺激によって回復させることができるが、完全に消去 (anisomysin + tat-beclin: Ani+tBC) した場合は回復不能。
Ani 群は光刺激による LTP で回復。Ani+tBC 群における LTP での記憶の強化は、Un-paired な群と同程度。
- →新規に記憶が形成されたことによる
Ani+tBC による記憶の消去は長期的であり、自然回復しない。

fig 2

Ani+tBC 群では、AC/MGm → LA の接続が消失。
- LA のエングラム細胞を mCherry 、AC/MGm の軸索終末を oChIEF でラベルすると、PBS, Ani 群に比べて c-Fos-mCherry を共発現する細胞割合が低下

fig 3

7Hz による AFC のあと、2Hz で AFC を行うと、 2Hz の記憶が増強される。
- Rashid AJ et al. Science 353, 383-387 (2016)
LA において、7Hz と 2Hz に対応する細胞の多くは共有されているが、AC では分離している。
- ↑２つの記憶が５時間離れている場合。24時間離れると、LA でも分離する
7Hz 後に Ani+tBC → 2Hz ： 7Hz 消失・2Hz 影響なし
7Hz → 2Hz 後に Ani+tBC ： 7Hz 影響なし・2Hz 消失。

fig 4

7Hz, 2Hz の AFC をした後で、7Hz に対応するシナプスに LTD を誘発すると、7Hz の記憶は低下するが、2Hz は影響を受けない。
7Hz の AFC → Ani+tBC で消去、2Hz の AFC → Ani+tBC で消去の後、7Hz に対応するシナプスに LTD を誘発すると、7Hz の記憶は低下するが、2Hz は影響を受けない。

プログラミング/神経科学/自然科学

Neural Trojanミニレビュー

2020年1月21日 by 大野駿太郎 / 0件のコメント

この記事は、2020年1月12日に行われた「第二回サイバーセキュリティ系LT会 in 東京」で発表した、「Neural Trojan — mini review」の内容を解説する記事です。
主に、arXivに投稿されているNeural Trojanについての論文をまとめています。

LT資料

[slideshare id=219010240&doc=seclt-dist20200112-200112075317]

Neural Trojanとは？

「ニューラル　トロージャン」と発音します。
簡単に言うと、ニューラルネットワークの中に組み込まれたトロイの木馬のことです。

Liu et al.では、

IP（知財）提供者によってニューラルネットワークの中に組み込まれた、悪意ある隠し機能
（拙訳）

と定義されました。
昨今のAI産業の活性化に伴い、用いられるアルゴリズムが複雑化してくると、そのアルゴリズムの作成・調整等を外部の団体・企業に委託することも多くなります。
その際に、委託先が、顧客の意図しない動作をアルゴリズムの中に組み込むという攻撃が起こりうるのです。

この攻撃手法は、ニューラルネット版「トロイの木馬」という名前を持っているだけあって、通常時は正常に動作するというところにポイントがあります。
すなわち、攻撃者は好きなタイミングでトリガーを発動することによってアルゴリズムに誤作動を起こすことができますが、防御側が事前にその存在を検知することは非常に困難なのです。

Neural Trojanによる攻撃

Liu et al. “Neural Trojans”

Liu et al.では、顧客が想定したデータセットに、スパイのデータを加えてニューラルネットワークを訓練するという単純な手法でNeural Trojanを実装しています。

例えば、防犯カメラのセキュリティ認証システムを考えてみましょう。
顧客は、入館を許可されたメンバーの顔写真を用意し、委託先にニューラルネットワークの訓練を依頼します。
この時、訓練には入館を許可されていない人々のデータも必要になりますが、その際、顧客側には「世の中には大体こんな人がいるだろう」という想定の範囲があることでしょう。
そして後日、訓練済みのネットワークが届き、顧客はその想定の範囲内のデータで性能を検証します。
その際の性能が基準を満たしていたら、そのアルゴリズムは無事導入されることでしょう。

ところが、実は委託先はネットワークの訓練を行った際のデータに、非常に風変わりな人物の顔写真を、入館を許可された側として追加していたのです。
しかし、顧客はこれに気付くことはできません。
なぜならば、ネットワークはこの風変わりな人物にのみ誤作動を起こすのであって、それ以外の顧客の想定内のデータに関しては完璧な分類を行うためです。
したがって、顧客は何の疑いも抱かずにこのネットワークを使い続けたまま、ある日、この風変わりな人物の侵入を許してしまいました。

この風変わりな人物のことを、Neural Trojanの文脈の中ではトリガーと呼びます。

Gu et al. “BadNets: Identifying Vulnerablities in the Machine Learning Model Supply Chain”

Liu et al.では、そもそもが風変わりな画像をトリガーとしていました。
これに対し、Gu et al.では、通常の画像に特徴的なパーツを追加することで、Neural Trojanを作動させました。

このネットワークでは、通常時は画像（例えば、交通標識）の全体を見て、その内容を判断します。
しかし、その画像内に特徴的なパーツ（黄色の四角形、爆弾のマーク、花のマークなど）が追加されていると、このネットワークはその部分にのみ注目して、パーツと関連した内容を出力します。

このアルゴリズムが自動運転の車に積み込まれていたら、どうなるでしょうか？
通常時は車載カメラが標識を正確に認識し、運転を行っています。
しかし、特定のマークが貼られた標識を認めた途端、実際の標識の種類とは関係なく、あらかじめ仕組まれた内容の標識であると判断します。
すなわち、「止まれ」であろうと「進入禁止」であろうと関係なく、「速度制限80km」だと認識させてしまうことができるのです。
これにより、街中の交通標識に黄色いポストイットを貼って回るという行為により、大規模なテロを行うことが可能になります。
大きな標識にポストイットが１つ貼ってあるくらいなら、誰も不審に思わないかもしれません。

また、Gu et al.では、ネットワークを転移学習した後のNeural Trojanの効果についても検証しました。

転移学習とは、とある課題のために訓練されたネットワークを、他の似た課題のために訓練しなおして利用することを指します。
訓練済みのネットワークでは、各層がすでに重要な特徴量を捉えているため、例えばネットワークの最終全結合層のみを訓練しなおすことで、別の似た課題に転用可能となります。
これにより、ゼロの状態からネットワークを構築するよりも相当簡単に、学習モデルを利用することができます。

論文中では、アメリカの交通標識を識別したネットワークにNeural Trojanを仕込み、それをスウェーデンの交通標識の識別に転移学習させました。
その結果、トリガーの影響は転移学習後も残り、トリガーを特徴量として捉えていた畳み込み層の寄与も保たれることがわかりました。

すなわち、「良さそうだ」と思って取ってきたネットワークモデルにNeural Trojanが仕込まれていた場合、たとえある程度の再学習を行ったとしても、安心はできないということなのです。

Clements et al. “Hardware Trojan Attacks on Neural Networks”

Neural Trojanを仕込むことができるのは、ネットワークモデルを作成・訓練するソフトウェア企業だけではありません。
例えば、そのネットワークを載せるハードウェアを開発している企業も攻撃者となり得ます。

Clements et al.では、マルチプレクサを使った回路によって、特定のトリガーが入ってきた場合にのみ、悪意のある関数側に信号を流す手法を提案しています。

Zou et al. “PoTrojan: powerful neuron-level trojan designs in deep learning models”

同様に、ハードウェアにNeural Trojanを仕込む手法として、Zou et al.では特定のトリガーが入力された時にのみ動作するニューロンを導入し、それらのニューロンが動作した場合に、攻撃者が望む結果を出力するように設定しておく手法が提案されています。
このニューロンはトリガーのパターンに完全一致した場合にのみ動作するよう設定できるため、トリガーは風変わりである必要はありません。
（一般的な画像であっても、被写体の位置や角度が完全一致していないと動作しないように設定することができます）

Li et al. “Hu-Fu: Hardware and Software Collaborative Attack Framework against Neural Networks”

ハードウェアにNeural Trojanを仕込むLi et al.の手法は、より凝った実装であると言うことができるかもしれません。

この手法においては、ネットワークを構成する多数のニューロン-ニューロン間の結合を、W_actとW_inactの２グループに分割します。
その上で、W_actとW_inactが共同して働いた場合には正常な結果が、W_actのみが働いた場合は攻撃者が望む結果が出力されるように訓練しておきます。
そして、マルチプレクサを用いた回路設計により、トリガーが入ってきた時にW_inactが停止する（トリガーなし→W_inactの計算結果を下流に通す、トリガーあり→下流には0を通す）ように設計しておくと、トリガーによって出力を変えることができるのです。

画像分類モデル以外への適応

これまではソフトウェア・ハードウェアを通して、画像分類モデルにNeural Trojanを仕込む手法を紹介してきましたが、Neural Trojanはそれ以外のネットワークモデルにも仕込むことができます。

例えば、Dai et al.ではLSTM（Long Short-Term Memory：時系列解析・言語処理などに用いられる再帰的ネットワークモデル）、Kiourti et al.では深層強化学習にNeural Trojanを仕込む手法について提案しています。

Neural Trojanへの防御

Neural Trojanを検知することは基本的に困難なのですが、すでに多数の防御手法が提案されています。
ここでは、Neural Trojanの攻撃手法を

想定外の訓練データを追加する手法（Liu et al.）
トリガーパーツを追加する手法（Gu et al.）

の２種類に分けて、それぞれに対する代表的な防御手法を紹介します。

Liu et al. “Neural Trojans”

想定外の訓練データを追加する攻撃手法に対する防御法は、同じ論文の中で提案されています。
解説のため、もう一度攻撃手法についてのスライドを表示しておきました。

筆者らは、以下の３つの防御手法を提案しています。

入力されるデータに異常検知を施し、想定外のデータを除く
ネットワークを再訓練する
入力されるデータに変換を施す（Input Processing）

ここで、1.と2.はやや自明であるとして、3.のInput Processingについて解説します。

Input Processingでは、Neural Trojanが仕込まれた（かもしれない）ネットワークにデータを入力する前に、そのデータを簡単なオートエンコーダを通します。
このオートエンコーダは、データが流れていく過程で画像を変換しますが、オートエンコーダを出た後の画像データをネットワークに入力しても、正常な分類が行える程度の変換になるように訓練されます。

ここで、オートエンコーダの訓練も、想定の範囲内の画像にしか行われないことがポイントになります。
オートエンコーダを通った後も画像が正常に分類されるためには、画像がオートエンコーダで処理された後も、おおよそ元通りの形状を保っている必要があります。
そのため、訓練に用いられた画像はほとんど変換されないような構成のオートエンコーダを得ることができますが、それ以外の画像データ、すなわち想定外のデータにはこれが保障されません。
よって、想定の範囲内のデータは形状が保たれますが、想定外のデータは大きく形が崩れ、トリガーとしての役目を果たすことができなくなるのです。

Chou et al. “SentiNet: Detecting Physical Attacks Against Deep Learning Systems”

トリガーパーツを追加する攻撃手法は、ネットワークをトリガーパーツに注目させて、問題を引き起こすことを意図しています。
そのため、Chou et al.では、ネットワークがどこを見ているかを可視化するGrad-CAMという技術を応用した防御手法を提案しています。

Grad-CAMは深層学習の判断根拠を可視化する手法です。
「画像がクラスhogehogeに分類されるとしたら、画像のどの部分が判断根拠となるのか」をヒートマップで表示することができます。
Chou et al.で提案されたSentiNetという防御手法は、この技術を活用して、以下の手順でトリガーとなったパーツを特定します。

GradCAMを用いてトリガーパーツの候補を抽出
他の画像に、トリガーパーツの候補を貼ってみる
同時に、同じ画像のトリガーパーツの候補を貼った位置を隠したもの（マスク）も用意する
トリガーパーツの候補とマスクによって、判断結果が変えられるかを検証
マスクでは結果が変わらないが、トリガーパーツの候補によって変えられる場合、その候補がトリガーパーツであると判断する

以下、１つずつ見ていきます。

1. GradCAMを用いてトリガーパーツの候補を抽出

本当はクラスAなのに、クラスBと誤分類されてしまった画像があるとします。
GradCAMを用いると、それぞれのクラスに対する判断根拠が得られます。
ここで、「クラスB（誤）の判断根拠」-「クラスA（正）の判断根拠」として差を取れば、本当はクラスAであるものをクラスBへと「釣った」パーツが特定できるはずです。
これをトリガーパーツの候補として保持し、他の誤分類された画像にも同様の作業を行えば、複数の候補が得られることになります。

2. 他の画像に、トリガーパーツの候補を貼る

以下、得られたトリガーパーツの候補を１つずつ検証します。
そのために、本来正常に分類が行えるはずの画像群に、これらの候補を１つずつ貼ってみて、分類結果が変えられるかを検証します。

3. 同じ位置にマスクを貼ったものも用意する

とある画像にトリガーパーツの候補を貼った場合、同じ画像の同じ位置をただ隠した画像も用意します。
この行為を、ここでは「マスクを貼った」と表現します。
これは、コントロール群として用いられる画像です。

4. トリガーパーツの候補とマスクの影響を検証

トリガーパーツの候補とマスクのそれぞれを貼った画像を、ネットワークに入力して結果を見ます。
候補が本物のトリガーパーツであるならば、マスク（コントロール）との間には結果に差があるはずです。

5. トリガーパーツの判定

基本的に、パーツを貼り付けることによって画像の分類結果を変えられたなら、そのパーツはトリガーである可能性が高いでしょう。
しかしそれは、ネットワークがそのパーツに注目したことによって結果が変化したのか、パーツを貼り付けたことによって、画像の重要な部分が隠れてしまったことによるものなのかの判断はできません。
コントロール（マスク）は、この後者の影響を検証するために用意されました。

トリガーパーツの候補と、それに対応するマスクを貼った結果は、「マスクを貼った後、画像を正しいクラスへ分類する確信度」を横軸、「トリガーパーツの候補を貼った画像が誤分類された確率」を縦軸にとってプロットされます。
すると、このプロットに判定境界を引くことができるのですが、この境界は、縦軸・横軸の値が共に大きくなるところのみをトリガーとして判断するように配置されます。
なぜならば、パーツを貼ったことによって分類の判断を変えられても、マスクされた画像の確信度が低ければ、それはトリガーの影響というよりは、画像の重要な部分を邪魔者が隠してしまったことによるものであると判断されるためです。

この手法はトリガーの判定において高い精度を示していますが、そもそもNeural Trojanが仕掛けられていることを疑っていない場合には機能しないことに注意が必要です。

まとめ

広告：Geospatial Hackers Program 2019

今までの流れとは全く関係ありませんが、LT会では広告枠があったので載せました。

総務省が主催している地理空間情報活用ハッカソン「Geospatial Hackers Program 2019」にチューターとして参加し、約1か月をかけて全国4会場を巡ります。
各会場の日程は以下の通りです。

愛知会場：2020年02月01日（土）～2020年02月02日（日）
富山会場：2020年02月08日（土）～2020年02月09日（日）
東京会場：2020年02月15日（土）～2020年02月16日（日）
沖縄会場：2020年02月22日（土）～2020年02月23日（日）

この中で、筆者のホームである富山会場（富山県魚津市）では、ハンズオンの講師も務めます。
富山会場は少し特殊で、唯一「Unityを用いた地理空間情報ゲーム開発」をテーマにしています。
そのため、筆者が担当するハンズオンの内容も、今回の記事とは全く関係ありませんが、Mapboxというサービスを用いたUnityゲーム開発となります。

これは、富山会場のハッカソンが、富山県魚津市のゲームクリエイター育成イベント「つくるUOZU」と連携して行われるためです。

また、富山会場が他と異なる点は、2日間のイベントが泊まり込みで行われることです。
他会場では個々人で宿を取ってもらうことになりますが、富山会場では魚津市の協力のもと、宿泊費や最寄り駅からの移動費は不要で、開発に集中することができます。

富山は北陸新幹線が開通して、東京から片道2時間程度と非常に近くなりましたので、

Unityに興味がある人・自信がある人
地理空間情報活用に興味がある人

は、ぜひ参加してみてください！

もちろん、他会場もよろしくお願いします。
（この記事の投稿時点で、愛知・東京会場は満席に達しています）

参加登録はこちらから↓
https://ghp.connpass.com/

プログラミング/神経科学

Rust for neuRo-enthUsiaST

2019年12月12日 by 大野駿太郎 / 0件のコメント

この記事について

C++やPythonが大半を占める神経回路シミュレーションの世界で、Rustを使ってみようって話です。
この記事は神経科学 Advent Calenderの2019年12月11日分です。
同様の内容をRust LT #7でLTしましたが、この記事はもっとRust初心者向けです。
「並列化はいいぞ」と何度も叫びますが、サンプルコードは並列化されていません。許して。

LT資料

[slideshare id=204395292&doc=lt20191211-191211110706]

Rust LT #7でLTした似た内容のスライドです。

北陸新幹線の中で超特急でつくったため、たぶん、何が言いたいか全くわからないと思います。

Rustとは？

プログラミング言語です。
Cと同じくらい早いです。
バグりやすい処理を、あらかじめコンパイラがダメ出ししてくれます。
そのため、非常に安全です。
ゆえに、並列化しても安全性が高いです。

なぜRustで神経回路シミュレーションをするか？

現在の神経回路シミュレーション界隈は、C++とPythonが主流で、そこにJuliaが挑戦している感じです（弊社調べ）。

しかし、大規模な神経回路をシミュレートする際にはPythonだと非常に遅い。数万の神経細胞を1ステップ10μsecで30分走らせるとなると絶望です。

C++はすぐバグる。配列の外を参照して、か弱い神経細胞に数億Aの電流が流れるということが良く起こる。神経回路の中で何が起こるかわからないからシミュレーションしてるのに、その最中にヤバいことが起こっても気付けるわけがない。

Juliaはなんか嫌。初速が遅い気がする（気のせい？）。

その点、Rustなら安心。Cと同程度の速度が出るし、安全性が保障されている。

「安全性が保障されている」とはどういうことか？これは、Rustのコンパイラが徹底的にバグの温床を潰しにくるということです。関数がとある値を利用している状況で、他の関数がそれを変更しにくると当然のように止める。さらに、実際には変更せずとも、変更しうる状況になったら辞めさせる。なんなら、変数名のつけ方にまで文句を言う。つまり、コンパイルはなかなか通らないが、通りさえすればバグらないことが保障されるのです。

そして、処理を並列化した際にも安全性は保障されます。同時に走っているニューロンがブッキングするようなこともありません。

とりあえず書いてみる

個々の神経のモデルにはIntegrate-and-Fireモデルライクなものを用います。

$$C_{m}\frac{dV_{i}}{dt}=-g_{L}V_{i}+\sum_{j} I^{rec}_{j}+I^{ext}$$

$$I^{rec}_{j}=w_{ij}s(t)$$

$$I^{ext}=I_{0}(1.0+I_{0}Noise)$$

$$V_{i}\geq10.0\ then\ s(t)=1,\ and\ \Delta t=2.0\ later\ V_{i}=0.0, s(t)=0$$

$$g_{L}=1.0, C_{m}=50.0$$

このへんの関係式は適当に設計したので、適宜変更してください。

struct Neuron {
    synapses: Vec<usize>,
    weights: Vec<f64>,
    v: f64,
    i_ext: f64,
    threshold: f64,
    t_rest: f64,
}

struct Neuron {

synapses: Vec<usize>,

weights: Vec<f64>,

v: f64,

i_ext: f64,

threshold: f64,

t_rest: f64,

}

というわけで、個々のニューロンをstructを使って実装しましょう。1個のニューロンは、それが刺激を受け取るニューロンのIDと結合強度が格納された配列（synapsesとweights）、膜電位v、外部電流i_ext、閾値threshold、不応期を計測する変数t_restを持ちます。

impl Neuron {
    fn new(n: usize) -> Neuron {
        let mut synapses: Vec<usize> = Vec::new();
        let mut weights: Vec<f64> = Vec::new();
        for i in 0..n {
            if random::<f64>() < 0.5 {
                synapses.push(i);
                weights.push(random::<f64>() * 10.0);
            }
        }
        Neuron {
            synapses: synapses,
            weights: weights,
            v: 0.0,
            i_ext: 0.0,
            threshold: 10.0,
            t_rest: 0.0,
        }
    }

    fn run(&mut self, spike: &Vec<u8>, dt: f64) -> u8 {
        if self.t_rest > 0.0 {
            self.t_rest -= dt;
            if self.t_rest <= 0.0 {
                self.v = 0.0;
            }
            1
        } else {
            let mut i_rec = 0.0;
            for i in 0..self.synapses.len() {
                if spike[self.synapses[i]] == 1 {
                    i_rec += self.weights[i];
                }
            }
            let i_ext = self.i_ext * (1.0 + self.i_ext * random::<f64>());
            let d_v = |y: f64| (-y + 1.0 * (i_rec + i_ext)) / 50.0;
            self.v += rk4(d_v, self.v, dt);
            if self.v > self.threshold {
                self.t_rest = 2.0;
                1
            } else {
                0
            }
        }
    }
}

impl Neuron {

fn new(n: usize) -> Neuron {

let mut synapses: Vec<usize> = Vec::new();

let mut weights: Vec<f64> = Vec::new();

for i in 0..n {

if random::<f64>() < 0.5 {

synapses.push(i);

weights.push(random::<f64>() * 10.0);

}

Neuron {

synapses: synapses,

weights: weights,

v: 0.0,

i_ext: 0.0,

threshold: 10.0,

t_rest: 0.0,

}

fn run(&mut self, spike: &Vec<u8>, dt: f64) -> u8 {

if self.t_rest > 0.0 {

self.t_rest -= dt;

if self.t_rest <= 0.0 {

self.v = 0.0;

}

} else {

let mut i_rec = 0.0;

for i in 0..self.synapses.len() {

if spike[self.synapses[i]] == 1 {

i_rec += self.weights[i];

}

let i_ext = self.i_ext * (1.0 + self.i_ext * random::<f64>());

let d_v = |y: f64| (-y + 1.0 * (i_rec + i_ext)) / 50.0;

self.v += rk4(d_v, self.v, dt);

if self.v > self.threshold {

self.t_rest = 2.0;

} else {

}

implを用いることで、このstructにメンバー関数やメソッドを追加することができます。

関数newではニューロンを新設する方法を設定しましょう。ここでは、一定確率で他のニューロン（自分自身を含む）とシナプスを形成し、その重みは0.0から10.0の範囲を取ることにしています。

メソッドrunでは微分方程式を処理し、閾値を超えたら1（スパイク）、そうでなければ0を返します。メソッドを書く際には、引数の先頭に&mut selfを置くことを忘れないようにしましょう。

fn rk4<F: Fn(f64) -> f64>(f: F, y: f64, h: f64) -> f64 {
    let k1 = h * f(y);
    let k2 = h * f(y + 0.5 * k1);
    let k3 = h * f(y + 0.5 * k2);
    let k4 = h * f(y + k3);
    (k1 + 2.0 * k2 + 2.0 * k3 + k4) / 6.0
}

fn rk4<F: Fn(f64) -> f64>(f: F, y: f64, h: f64) -> f64 {

let k1 = h * f(y);

let k2 = h * f(y + 0.5 * k1);

let k3 = h * f(y + 0.5 * k2);

let k4 = h * f(y + k3);

(k1 + 2.0 * k2 + 2.0 * k3 + k4) / 6.0

}

rk4はルンゲクッタ法を実装した関数です。

struct Network {
    n: usize,
    neurons: Vec<Neuron>,
    count: usize,
}

impl Network {
    fn new(n: usize) -> Network {
        let mut neurons: Vec<Neuron> = Vec::with_capacity(n);
        for _ in 0..n {
            neurons.push(Neuron::new(n));
        }
        Network {
            n: n,
            neurons: neurons,
            count: 0,
        }
    }

    fn run(&mut self, spike_train: &Vec<Vec<u8>>, dt: f64) -> Vec<u8> {
        let mut spike: Vec<u8> = vec![0; self.n];
        for i in 0..self.n {
            spike[i] = self.neurons[i].run(&spike_train[self.count], dt);
        }
        self.count += 1;
        spike
    }

    fn input(&mut self, current: f64) {
        for i in 0..self.n {
            self.neurons[i].i_ext = current;
        }
    }
}

struct Network {

n: usize,

neurons: Vec<Neuron>,

count: usize,

}

impl Network {

fn new(n: usize) -> Network {

let mut neurons: Vec<Neuron> = Vec::with_capacity(n);

for _ in 0..n {

neurons.push(Neuron::new(n));

}

Network {

n: n,

neurons: neurons,

count: 0,

}

fn run(&mut self, spike_train: &Vec<Vec<u8>>, dt: f64) -> Vec<u8> {

let mut spike: Vec<u8> = vec![0; self.n];

for i in 0..self.n {

spike[i] = self.neurons[i].run(&spike_train[self.count], dt);

}

self.count += 1;

spike

}

fn input(&mut self, current: f64) {

for i in 0..self.n {

self.neurons[i].i_ext = current;

}

これは個人的な感想ですが、マルチエージェントなシミュレーションにおいては、すべてのエージェントを統括するような存在がいると便利な気がします。というわけでNeuronを統括するNetworkを構築します。

Networkはフィールドにニューロン数nを持ち、n個のNeuronをneuronsに収納します。また、独自にステップ数を数える変数countを使用します。

メソッドrunではn個のニューロンに1ステップ前の神経活動情報を与え、すべてのニューロン活動を検証します。本来は、ここで並列化が効果を発揮するでしょう。inputでは、すべてのニューロンに与えられる外部電流の大きさを変更します。

fn main() {
    const N: usize = 100;
    let mut spike_train: Vec<Vec<u8>> = vec![Vec::new()];
    for _ in 0..N {
        if random::<f64>() < 0.5 {
            spike_train[0].push(1);
        } else {
            spike_train[0].push(0);
        }
    }
    let mut network: Network = Network::new(N);
    let mut t = 0.0;
    let dt = 0.1;
    let mut x: Vec<f64> = Vec::new();
    let mut y: Vec<f64> = Vec::new();
    // y.push(0.0);

    while t <= 4000.0 { // 800.0
        if (t >= 1000.0) & (t <= 3000.0) { // 200, 600
            network.input(5.0);
        } else {
            network.input(4.0);
        }
        spike_train.push(network.run(&spike_train, dt));
        t += dt;
        // x.push(t);
        // y.push(network.neurons[0].v);
        println!("{}", t);
    }
    let time_all = spike_train.len();
    for i in 0..time_all {
        for j in 0..N {
            if spike_train[i][j] == 1 {
                x.push(i as f64 * dt);
                y.push(j as f64);
            }
        }
    }

    let mut y: Vec<f64> = Vec::with_capacity(spike_train.len());
    for i in 0..spike_train.len() {
        y.push(spike_train[i][0] as f64)
    }

    let mut fg = gnuplot::Figure::new();
    fg.axes2d()
        .lines(x.iter(), y.iter(), &[gnuplot::Color("blue")])
        //.lines(x.iter(), y.iter(), &[gnuplot::Color("blue")])
        .set_x_range(Fix(0.0), Fix(4000.0));
    fg.echo_to_file("spike_train.plt"); // voltage.plt
}

fn main() {

const N: usize = 100;

let mut spike_train: Vec<Vec<u8>> = vec![Vec::new()];

for _ in 0..N {

if random::<f64>() < 0.5 {

spike_train[0].push(1);

} else {

spike_train[0].push(0);

}

let mut network: Network = Network::new(N);

let mut t = 0.0;

let dt = 0.1;

let mut x: Vec<f64> = Vec::new();

let mut y: Vec<f64> = Vec::new();

// y.push(0.0);

while t <= 4000.0 { // 800.0

if (t >= 1000.0) & (t <= 3000.0) { // 200, 600

network.input(5.0);

} else {

network.input(4.0);

}

spike_train.push(network.run(&spike_train, dt));

t += dt;

// x.push(t);

// y.push(network.neurons[0].v);

println!("{}", t);

}

let time_all = spike_train.len();

for i in 0..time_all {

for j in 0..N {

if spike_train[i][j] == 1 {

x.push(i as f64 * dt);

y.push(j as f64);

}

let mut y: Vec<f64> = Vec::with_capacity(spike_train.len());

for i in 0..spike_train.len() {

y.push(spike_train[i][0] as f64)

}

let mut fg = gnuplot::Figure::new();

fg.axes2d()

.lines(x.iter(), y.iter(), &[gnuplot::Color("blue")])

//.lines(x.iter(), y.iter(), &[gnuplot::Color("blue")])

.set_x_range(Fix(0.0), Fix(4000.0));

fg.echo_to_file("spike_train.plt"); // voltage.plt

}

実験操作はmain関数に記述します。ここでは、dt=0.1でt=4000.0だけシミュレーションを行い、そのうち$1000.0\leq t \leq 3000.0$の時間帯は外部電流を増強します。

spike_trainが神経活動を記録する配列で、最終的な図表の作成とニューロンに与える入力を保存するために使用します。すなわち、

Networkがspike_trainをNeuronに読ませる
Neuronが0or1を返す
Networkが各Neuronの返り値をspike_trainに渡す
さっきの値をNetworkがNeuronに読ませる
…

という流れを取ります。

全ソースコードはこちら

https://github.com/doraneko94/Rust_Neuron

成果物

x軸が時間、y軸がニューロンのID、青い点が神経活動を表します。外部電流が小さかった時にはまばらだった活動が、外部電流を上げることで高頻度のバーストに変化していることがわかります。

ちなみに、個々のニューロンの膜電位は上図のように変化します。（$200.0\geq t\geq 600.0$の期間に外部電流を増強）

並列化するなら

今回はすべてのニューロンを直列で計算しましたが、Rustのメリットを活かすなら、これらの計算を並列化することが効果的です。並列化の手法としては、ニューロンを何分の１かずつに分割し、複数のスレッドで処理を行って最後に合わせるフォーク・ジョイン並列などが有名ですが、ここでは神経回路特有の工夫点について説明します。

この図はC. elegans（線虫）の全神経細胞を、それぞれが入力を受け取る他の神経細胞の数ごとに集計したものです。この図によると、ほとんどのニューロンは少ないニューロンとしか接続していませんが、一方で、非常に多くのニューロンと接続したニューロンがわずかに存在します。この分布は、y軸を適当に対数変換すると直線系になり、べき乗則というルールにしたがいます。つまり、「ほとんどは『持たざる者』だが、ごく少数の者は大量に持っている」というルールです。

このような状況下では、各ニューロンごとに仕事量が大きく異なるため、均等な割り付けをランダムに行うだけではあまり高速化できません。そのため、シナプス数などのパラメータを参考に、割り付けを工夫する必要があります。

このような現象は、神経回路のみならず、ネットワーク構造をとるものにおいて一般的に見られるものです。

結論

Rustはいいぞ。

Rustは高速で安全で並列化できていいぞ。

みんなで神経回路シミュレーションの共通言語をRustにしよう。

※Rustのインストール方法や基本文法については、各種Webページや書籍を参考にしてください。

※Rustのプロの方は、Rust的な書き方についてアドバイスをいただけると幸いです。

カテゴリー: 神経科学

Abdou et al. Synapse-specific representation of the identity of overlapping memory engrams

目的

事実

introduction

fig 1

fig 2

fig 3

fig 4

Neural Trojanミニレビュー

LT資料

Neural Trojanとは？

Neural Trojanによる攻撃

Liu et al. “Neural Trojans”

Gu et al. “BadNets: Identifying Vulnerablities in the Machine Learning Model Supply Chain”

Clements et al. “Hardware Trojan Attacks on Neural Networks”

Zou et al. “PoTrojan: powerful neuron-level trojan designs in deep learning models”

Li et al. “Hu-Fu: Hardware and Software Collaborative Attack Framework against Neural Networks”

画像分類モデル以外への適応

Neural Trojanへの防御

Liu et al. “Neural Trojans”

Chou et al. “SentiNet: Detecting Physical Attacks Against Deep Learning Systems”

1. GradCAMを用いてトリガーパーツの候補を抽出

2. 他の画像に、トリガーパーツの候補を貼る

3. 同じ位置にマスクを貼ったものも用意する

4. トリガーパーツの候補とマスクの影響を検証

5. トリガーパーツの判定

まとめ

広告：Geospatial Hackers Program 2019

Rust for neuRo-enthUsiaST

この記事について

LT資料

Rustとは？

なぜRustで神経回路シミュレーションをするか？

とりあえず書いてみる

成果物

並列化するなら

結論