Panduan ringkas untuk Unit Logik Aritmetika Neural (NALU): Penjelasan, Intuisi dan Kod

Jurutera penyelidikan di DeepMind termasuk penyelidik AI yang terkenal dan pengarang buku Grokking Deep Learning, Andrew Trask telah menerbitkan kertas yang mengagumkan pada model rangkaian saraf yang boleh belajar dengan mudah ke fungsi berangka kompleks dengan kemampuan ekstrapolasi (generalisasi) yang hebat.

Dalam jawatan ini saya akan menerangkan NALU, senibina, komponen dan kepentingannya terhadap rangkaian saraf tradisional. Tujuan utama di sebalik jawatan ini adalah untuk memberikan penjelasan yang ringkas dan intuitif kepada NALU (kedua-duanya dengan konsep dan kod) yang dapat difahami oleh penyelidik, jurutera dan pelajar yang mempunyai pengetahuan yang terhad mengenai rangkaian saraf dan pembelajaran yang mendalam.

Nota: Saya sangat mengesyorkan pembaca untuk membaca karya asal untuk pemahaman yang lebih terperinci tentang perkara ini. Kertas ini boleh dimuat turun dari sini.

Di mana Rangkaian Neural gagal?

Imej ini diambil dari jawatan sederhana ini

Rangkaian neural, secara teori, adalah penentu fungsi yang sangat baik. Mereka hampir boleh mempelajari apa-apa hubungan bermakna antara input (data atau ciri) dan output (label atau sasaran). Oleh itu, mereka digunakan dalam pelbagai aplikasi dari pengesanan objek dan klasifikasi untuk ucapan kepada penukaran teks kepada ejen permainan pintar yang boleh mengalahkan pemain juara dunia manusia. Terdapat banyak model rangkaian neural yang berkesan yang memenuhi pelbagai keperluan aplikasi seperti Rangkaian Neural Convolutional (CNNs), Rangkaian Neural Berulang (RNN), Autoencoders dll. Pendahuluan dalam pembelajaran mendalam dan model rangkaian neural adalah topik lain dengan sendirinya.

Walau bagaimanapun, menurut penulis kertas, mereka tidak mempunyai keupayaan yang sangat asas yang kelihatannya remeh untuk manusia atau bahkan lebah! Itulah keupayaan untuk mengira / memanipulasi nombor-nombor dan juga, untuk mengekstrapolasikan hubungan berangka dari corak numerik yang dapat dilihat. Di dalam kertas, ditunjukkan bahawa rangkaian saraf piawai juga berjuang untuk belajar bahkan fungsi identiti (fungsi yang input dan outputnya sama; f (x) = x) yang merupakan hubungan numerik yang paling lurus. Imej di bawah menunjukkan kesilapan min kesilapan (MSE) daripada pelbagai NN yang dilatih untuk mempelajari fungsi identiti sedemikian.

Imej menunjukkan MSE untuk rangkaian Neural standard yang mempunyai seni bina yang sama yang dilatih menggunakan fungsi pengaktifan berbeza (bukan linear) dalam lapisan tersembunyi

Mengapa mereka gagal?

Alasan utama untuk NNs gagal mempelajari perwakilan berangka tersebut adalah penggunaan fungsi pengaktifan linier dalam lapisan tersembunyi rangkaian. Fungsi pengaktifan sedemikian adalah penting untuk mempelajari hubungan non linier abstrak antara input dan label tetapi mereka gagal terasa ketika datang untuk mempelajari perwakilan berangka di luar jangkauan bilangan yang dilihat dalam data latihan. Oleh itu, rangkaian sedemikian adalah sangat baik untuk menghafal corak berangka yang dilihat dalam latihan tetapi gagal untuk menonjolkan perwakilan ini dengan baik.

Ia seperti menghafal jawapan atau topik tanpa memahami konsep dasar untuk peperiksaan. Melakukannya, seseorang boleh melakukannya dengan sangat baik jika soalan-soalan yang sama ditanya dalam peperiksaan, bagaimanapun, akan gagal dalam hal soalan yang dipintal yang dirancang untuk menguji pengetahuan dan bukannya kemampuan menghafal seorang calon.

Keterukan kegagalan ini secara langsung sepadan dengan tahap non-linear dalam fungsi pengaktifan yang dipilih. Dari imej di atas, dapat dilihat dengan jelas bahawa fungsi non-linear keras seperti Tanh dan Sigmoid mempunyai keupayaan yang lebih rendah untuk umum daripada fungsi non-linear yang terlambat seperti PReLU dan ELU.

Penyelesaian: Pengumpul Neural (NAC)

Akumulator saraf (NAC) membentuk asas kepada model NALU. NAC adalah model rangkaian neural yang mudah tetapi berkesan (unit) yang menyokong keupayaan untuk belajar tambahan dan penolakan - yang merupakan harta yang wajar untuk mempelajari fungsi linear dengan berkesan.

NAC adalah lapisan khas garis lurus yang parameter beratnya mempunyai sekatan yang mempunyai satu-satunya nilai 1, 0 atau -1. Dengan mengehadkan nilai-nilai berat dalam cara sedemikian menghalang lapisan dari mengubah skala data input dan mereka tetap konsisten di seluruh rangkaian tidak kira berapa banyak lapisan disusun bersama-sama. Oleh itu, output akan menjadi gabungan linear vektor masukan yang dengan mudah boleh mewakili operasi tambahan dan penolakan.

Intuisi: Untuk memahami fakta ini, mari kita pertimbangkan contoh berikut lapisan NN yang melakukan operasi aritmetik linier pada input.

Ilustrasi untuk menjelaskan bahawa lapisan rangkaian neural tanpa bias dan mempunyai nilai berat -1, 0 atau 1 boleh mempelajari ekstrapolasi linear.

Seperti yang ditunjukkan dalam lapisan NN di atas, rangkaian boleh belajar untuk mengekstrapolasi fungsi aritmetik mudah seperti tambahan dan penolakan (y = x1 + x2 dan y = x1-x2) dengan menyekat parameter berat kepada -1, 0 dan 1.

Nota: Seperti ditunjukkan dalam gambar rajah rangkaian di atas, NAC tidak mengandungi parameter bias (b) dan tidak ada garis lurus yang digunakan untuk output unit lapisan tersembunyi.

Oleh kerana kekangan pada parameter berat dalam NAC sukar dipelajari oleh rangkaian saraf piawai, penulis telah menerangkan formula yang sangat berguna untuk mempelajari nilai parameter yang terhad seperti menggunakan parameter (tidak terkawal) W_hat dan M_hat. Parameter ini adalah seperti mana-mana parameter berat NN standard yang boleh dimulakan secara rawak dan boleh dipelajari sepanjang proses latihan. Formula untuk mendapatkan W dari segi W_hat dan M_hat diberikan di bawah:

Formula menandakan produk bijak elemen antara dua matriks

Menggunakan persamaan di atas untuk mengira parameter berat dalam rangkaian, menjamin bahawa nilai parameter tersebut berada dalam julat [-1,1] dengan lebih cenderung ke arah -1, 0 dan 1. Juga, persamaan ini adalah persamaan yang berbeza (yang derivatifnya boleh dikira berkenaan dengan parameter berat). Oleh itu, lebih mudah bagi NAC belajar W menggunakan keturunan kecerunan dan penyebaran semula. Berikut adalah gambarajah arkitek unit NAC.

Senibina NAC untuk mempelajari fungsi numerik mudah (linear)

Pelaksanaan NAC dalam python menggunakan Tensorflow

Seperti yang dapat dibayangkan, NAC adalah model NN yang mudah dengan sedikit tweak. Di bawah ini saya telah menunjukkan pelaksanaan sederhana lapisan NAC tunggal dalam python menggunakan perpustakaan Tensorflow dan Numpy.

import numpy sebagai np
import tensorflow sebagai tf
# Tentukan Pengikulat Saraf (NAC) untuk penambahan / penolakan -> Berguna untuk mempelajari penambahan / penolakan operasi

def nac_simple_single_layer (x_in, out_units):
    '' '
    Atribut:
        x_in -> Tensor input
        out_units -> bilangan unit keluaran

    Pulangan:
       y_out -> Tensor output bentuk yang disebutkan
       W -> Berat matriks lapisan
    '' '
# Dapatkan jumlah ciri input (nombor)
    in_features = x_in.shape [1]

    # tentukan W_hat dan M_hat

    W_hat = tf.get_variable (shape = [in_features, out_units],
    initializer = tf.initializers.random_uniform (minval = -2, maxval = 2),
    dilatih = Benar, nama = "W_hat")

    M_hat = tf.get_variable (shape = [in_shape, out_units],
    initializer = tf.initializers.random_uniform (minval = -2, maxval = 2),
    dilatih = Benar, nama = "M_hat")

    # Dapatkan W menggunakan formula
    W = tf.nn.tanh (W_hat) * tf.nn.sigmoid (M_hat)

    y_out = tf.matmul (x_in, W)

    kembali y_out, W

Dalam kod di atas, saya menggunakan permulaan seragam rawak untuk parameter yang boleh dilatih W_hat dan M_hat tetapi seseorang boleh menggunakan teknik inisialisasi berat yang disyorkan untuk parameter ini. Untuk kod kerja penuh sila semak semula repo GitHub saya yang disebutkan di hujung jawatan ini.

Bergerak di luar tambahan dan penolakan: NAC untuk fungsi angka kompleks

Walaupun model rangkaian neural sederhana yang disebutkan dapat mempelajari fungsi aritmetik asas seperti penambahan dan penolakan, adalah wajar untuk mempunyai keupayaan untuk mempelajari operasi aritmetik yang lebih kompleks seperti pendaraban, fungsi pembahagian dan kuasa.

Berikut adalah seni bina diubahsuai NAC yang dapat mempelajari fungsi numerik yang lebih kompleks menggunakan ruang log (nilai logaritma dan eksponen) untuk parameter beratnya. Perhatikan bagaimana NAC ini berbeza daripada yang disebut dahulu di dalam pos.

Senibina NAC untuk mempelajari fungsi numerik yang lebih kompleks

Seperti yang ditunjukkan dalam rajah di atas, sel ini menggunakan fungsi log kepada data input sebelum pendaraban matriks dengan matriks W berat dan kemudian ia menggunakan fungsi eksponen pada matriks yang dihasilkan. Formula untuk mendapatkan output diberikan dalam persamaan di bawah.

Persamaan keluaran NAC kompleks yang ditunjukkan di atas. Epsilon di sini adalah nilai yang sangat kecil untuk mengelakkan keadaan log (0) semasa latihan

Oleh itu, semuanya adalah sama dari segi mekanisme asas NAC yang mudah dan kompleks NAC termasuk formula untuk berat W yang terhad dari segi W_hat dan M_hat. Satu-satunya perbezaan ialah NAC yang kompleks memohon ruang log pada input dan output lapisan.

Pelaksanaan Python kompleks NAC:

Seperti pada seni bina kedua NAC, pelaksanaan python NAC kompleks hampir sama kecuali perubahan yang disebutkan dalam formula tensor keluaran. Berikut adalah kod bagi NAC tersebut.

# menentukan NAC kompleks dalam ruang log -> untuk fungsi aritmetik yang lebih kompleks seperti pendaraban, pembahagian dan kekuasaan

def nac_complex_single_layer (x_in, out_units, epsilon = 0.000001):

    '' '
    : param x_in: vektor ciri input
    : param out_units: bilangan unit output sel
    : param epsilon: nilai kecil untuk mengelakkan log (0) dalam hasil output
    : kembali m: tensor output
    : pulangan W: matriks berat berkaitan
    
    '' '

    in_features = x_in.shape [1]

    W_hat = tf.get_variable (shape = [in_shape, out_units],
    initializer = tf.initializers.random_uniform (minval = -2, maxval = 2),
    dilatih = Benar, nama = "W_hat")

    M_hat = tf.get_variable (shape = [in_features, out_units],
    initializer = tf.initializers.random_uniform (minval = -2, maxval = 2),
    dilatih = Benar, nama = "M_hat")
    #Get matrik parameter tak terbatas W
    W = tf.nn.tanh (W_hat) * tf.nn.sigmoid (M_hat)

    # Ciri Input Ekspres dalam ruang log untuk mempelajari fungsi kompleks
    x_modified = tf.log (tf.abs (x_in) + epsilon)

    m = tf.exp (tf.matmul (x_modified, W))

    kembali m, W

Sekali lagi, untuk kod kerja penuh sila semak repo GitHub saya yang disebutkan di hujung jawatan ini.

Meletakkannya bersama-sama: Unit Logik Aritmetika Neural (NALU)

Sekarang boleh dibayangkan bahawa di atas dua model NAC digabungkan bersama dapat mempelajari hampir semua operasi aritmetik. Itulah idea utama di sebalik NALU yang terdiri daripada gabungan NAC yang mudah dan NAC kompleks yang disebutkan di atas, dikawal oleh isyarat pintu yang dipelajari. Oleh itu, NAC membentuk blok bangunan dasar NALU. Jadi, jika anda memahami NAC dengan betul, NALU sangat mudah difahami. Jika anda tidak mempunyai, sila luangkan masa dan lalui kedua-dua penjelasan NAC sekali lagi. Imej bawah menggambarkan seni bina NALU.

Gambarajah NALU yang dirakamkan

Seperti yang ditunjukkan dalam gambar di atas, di NALU kedua-dua NAC (sel ungu) diinterpolasi (gabungan) oleh kawalan pintu sigmoid yang dipelajari (sel oren) supaya output NAC boleh diaktifkan atau dinyahaktifkan oleh pintu berdasarkan fungsi angka cuba untuk melatih rangkaian.

Seperti yang disebutkan di atas, NAC mudah mengira fungsi pengumpulannya sehingga bertanggungjawab untuk menyimpan operasi linear (penambahan dan penolakan) NALU. Walaupun kompleks NAC bertanggungjawab untuk menjalankan fungsi numerik yang lebih kompleks seperti pendaraban, pembahagian dan fungsi kuasa. Output sel-sel yang mendasari dalam NALU boleh diwakili secara matematik seperti berikut:

NAC mudah: a = W X
Kompleks NAC: m = exp (W log (| X | + e))
Di mana, W = tanh (W_hat) * sigmoid (M_hat)
Gerbang gerbang: g = sigmoid (GX) # Di mana G adalah matriks parameter dilatih standard
# Dan akhirnya output NALU
NALU: y = g * a + (1-g) * m # Dimana * adalah produk bijak elemen

Dalam formula NALU di atas, kita boleh mengatakan bahawa jika output gerbang g = 0 maka rangkaian akan belajar hanya fungsi kompleks tetapi bukan yang mudah. Sebaliknya, jika g = 1 maka rangkaian akan belajar hanya fungsi tambahan dan bukan yang kompleks. Oleh itu, secara keseluruhannya NALU dapat mempelajari sebarang fungsi berangka yang terdiri daripada pendaraban, penambahan, penolakan, pembahagian, dan fungsi kuasa sedemikian rupa yang mengekstrapolasi dengan baik kepada nombor di luar julat bilangan yang telah dilihat semasa latihan.

Pelaksanaan Python NALU:

Dalam pelaksanaan NALU, kami akan menggunakan NAC yang sederhana dan kompleks yang ditakrifkan dalam coretan kod sebelumnya.

def nalu (x_in, out_units, epsilon = 0.000001, get_weights = False):
    '' '
    : param x_in: vektor ciri input
    : param out_units: bilangan unit output sel
    : param epsilon: nilai kecil untuk mengelakkan log (0) dalam hasil output
    : parac get_weights: Benar jika mahu mendapatkan bobot model
                        sebagai balasan
    : pulangan: tensor output
    : pulangan: Matriks berat pintu
    : kembali: Matriks berat NAC1 (mudah NAC)
    : pulangan: Matriks berat NAC2 (kompleks NAC)
    '' '

    in_features = x_in.shape [1]

    # Dapatkan tensor output daripada NAC yang mudah
    a, W_simple = nac_simple_single_layer (x_in, out_units)

    # Dapatkan tensor keluaran dari NAC kompleks
    m, W_complex = nac_complex_single_layer (x_in, out_units, epsilon = epsilon)

    # Lapisan isyarat pintu
    G = tf.get_variable (bentuk = [in_features, out_units],
    initializer = tf.random_normal_initializer (stddev = 1.0),
    boleh dilatih = Benar, nama = "Gate_weights")

    g = tf.nn.sigmoid (tf.matmul (x_in, G))

    y_out = g * a + (1 - g) * m

    jika (get_weights):
        kembali y_out, G, W_simple, W_complex
    lain:
        kembali y_out

Sekali lagi, dalam kod di atas, saya menggunakan inisial biasa rawak untuk parameter gerbang G tetapi seseorang boleh menggunakan teknik inisialisasi berat yang disyorkan.

Ibelieve NALU adalah penemuan moden dalam AI dan khususnya dalam rangkaian saraf yang nampaknya sangat menjanjikan. Mereka boleh membuka pintu kepada banyak aplikasi yang nampaknya sukar untuk ditangani oleh standard NNs.

Penulis telah menunjukkan pelbagai eksperimen dan keputusan yang melaksanakan NALU dalam pelbagai bidang aplikasi rangkaian saraf dalam kertas daripada tugas pembelajaran fungsi aritmetik mudah untuk mengira bilangan digit tulisan tangan dalam siri gambar MNIST yang disediakan untuk membuat pembelajaran rangkaian untuk menilai program komputer!

Hasilnya mengagumkan dan membuktikan bahawa NALU unggul untuk umum dalam hampir semua tugas yang melibatkan perwakilan berangka daripada model NN standard. Saya cadangkan pembaca untuk melihat eksperimen dan hasilnya untuk mendapatkan pemahaman yang lebih mendalam tentang bagaimana NALU dapat berguna dalam beberapa tugas berangka yang menarik.

Walau bagaimanapun, tidak mungkin NAC atau NALU akan menjadi penyelesaian yang sempurna untuk setiap tugas. Sebaliknya, mereka menunjukkan strategi reka bentuk umum untuk membuat model yang bertujuan untuk kelas sasaran fungsi berangka.

Berikut adalah pautan ke repositori GitHub saya yang menunjukkan pelaksanaan penuh coretan kod yang dipaparkan dalam siaran ini.

https://github.com/faizan2786/nalu_implementation

Anda dialu-alukan untuk mencuba pelbagai fungsi untuk menguji model saya menggunakan hyperprims yang berbeza untuk menyesuaikan rangkaian.

Izinkan saya tahu jika anda mempunyai sebarang pertanyaan atau pemikiran mengenai siaran ini dalam ulasan di bawah dan saya akan cuba yang terbaik untuk mengatasinya.

PS: Ini adalah catatan blog saya yang pertama di mana-mana topik. Oleh itu, apa-apa cadangan, cadangan dan nasihat masa depan kedua-dua, teknikal dan tidak teknikal mengenai penulisan saya adalah dialu-alukan.