Seimbang dalam pengambilan keputusan. Fork "pengalaman acak"

gambar

Untuk menulis kehidupan nyata, Anda tidak perlu apa pun selain untuk mengalahkan diri sendiri sepenuhnya dan sepenuhnya. Saya terus menciptakannya dan kemudian saya akan menulis artikel besar tentang topik ini, tapi, saya, apa hal ini dengan sendirinya dan betapa sulitnya untuk mengukur 7 kali, memotong satu, lalu mengukurnya lagi 77 kali dan akhirnya tidak terputus. Ukur, ukur lagi! - Ini adalah motto seseorang yang ingin membuat sesuatu yang benar-benar tidak biasa. Pengkodean jauh lebih mudah daripada berpikir. Tetapi berpikir itu menyakitkan dan tidak biasa pada umumnya.

Tapi hari ini saya ingin memikirkan satu "masalah" yang muncul di sini kampanye. Bayangkan gerakan kacau partikel atau elemen kimia - mereka bergerak dalam volume yang terbatas bersyarat, hanya saling bertabrakan, atau mengusir - kekacauan dalam bentuk yang paling murni. Jika sistem seperti itu diluncurkan, maka bahkan di sarang semut yang tampaknya tidak berguna ini, pergerakan terstruktur akan diamati dari waktu ke waktu: tabrakan acak pada saat tertentu dapat terjadi sedemikian rupa sehingga arah dampak (impuls) akan berubah kurang lebih dalam satu arah, dan kemudian bertabrakan partikel akan bergerak dalam satu arah, membentuk gelombang. Di masa depan, gelombang dari tabrakan pihak ketiga ini akan mulai membusuk dan kita akan kembali melihat gambaran kacau.

Itu acak dalam esensinya secara sukarela membentuk suatu struktur, tetapi struktur hanyalah bentuk sementara dari acak ini. Mengalir dengan cara ini, kekacauan terjadi dalam berbagai bentuk, yang kami anggap sebagai sesuatu yang masuk akal, mis. dipesan. Secara umum, rasionalnya adalah apa yang diulang sehingga pengulangan kepada seseorang dapat diperhatikan. Namun, kita tidak akan membahas ini sekarang, tetapi berpikir sedikit lebih luas.

Ingatlah bahwa kemungkinan besar yang disebut "Kehidupan" di Bumi muncul sebagai akibat dari interaksi kacau unsur-unsur kimia. Kehidupan seperti itu tidak akan pernah terjadi jika satu molekul tidak mampu menarik elektron dari yang lain, atau sebaliknya, berpisah dengan molekulnya sendiri. PELUANG ini sendiriitu hanya karena fakta bahwa senyawa muncul dari unsur-unsur, dan dari senyawa itu juga terdapat replika dan organisme. Karena itu, jika kita ingin menciptakan kehidupan digital, kita harus MEMBERIKAN PELUANG interaksi.

Jika kita adalah Arsitek Agung Alam Semesta dan tahu persis semua hukumnya, mulai dari yang utama, maka masalah digitalisasi mereka tidak akan menjadi masalah serius. Tapi karena karena kita bukan (sayangnya), kita hanya bisa mengandalkan fakta bahwa kita dapat menebak dan menciptakan kondisi yang sama dengan munculnya kehidupan biologis, sehingga memungkinkan kehidupan digital muncul.

Untuk inilah saya mencoba menggambarkan prinsip-prinsip kode bebas. Kode bebas maksimum yang mungkin. Bebas dari pemahaman kita sendiri tentang bagaimana kehidupan harus diatur - karena pemahaman seperti itu kemungkinan besar keliru atau tidak lengkap sehingga terlalu masuk akal. Kami makhluk kecil berusaha sangat keras untuk mempelajari dan menggambarkan segala sesuatu di sekitar kami sehingga kami bahkan tidak dapat melakukannya. Tapi tidak ada yang melarang mencoba.

Ketika Anda menulis kode kacau, Anda pasti menemukan garpu. Pengalaman acak. Itu baik bergerak lebih jauh secara kacau, atau memungkinkan pembentukan pengalaman. Itu memungkinkan tidak hanya partikel bertabrakan, tetapi juga berinteraksi. Kami mencari analog kehidupan biologis, yang tidak terpikirkan tanpa transfer dan regenerasi pengalaman. RNA / DNA adalah pengalaman yang direkam yang ditransmisikan.

Di sisi lain, itu tidak dapat ditentukan dalam hal apa pun, karena kita tidak benar-benar tahu bagaimana itu berkembang dan berkembang. Jika godaan ini tidak dihapus, kesalahan tidak bisa dihindari. Dengan kata lain, kita tidak bisa memberi tahu program itu bagaimana pengalaman itu harus dilihat dan bagaimana itu harus dibentuk. Tapi kita bisa memberinya alat yang pada prinsipnya dia bisa dibentuk.

Saya bergumul dengan diri saya sendiri untuk waktu yang sangat lama, karena menurut saya struktur penyimpanan pengalaman dapat digambarkan dengan cukup sederhana. Berpikir bahwa kesederhanaan, yang tampaknya sederhana bagi kita berdasarkan pada gagasan kita sendiri tentang kesederhanaan, adalah cara pasti untuk menipu diri kita sendiri. Saya curiga kesederhanaan sejati sangat kompleks. Tetapi saya mengusulkan untuk tidak masuk ke demagogi di sini.

Misalkan kita secara acak menghasilkan garis kode yang dapat dieksekusi sebagai respons terhadap set numerik input acak. Dapat diasumsikan bahwa generasi respons, atau reaksi, adalah pengalaman. Jika sesuatu bereaksi secara stabil sama dengan sinyal masuk yang sama, kita dapat mengatakan bahwa itu menggunakan pengalaman. Oleh karena itu, saya ingin mengingat string yang dihasilkan. Tetapi ini tidak bisa dilakukan secara langsung! Anda tidak bisa hanya mengambil baris ini dan mendorongnya ke suatu tempat ke dalam variabel array dari instance kelas dan mulai membuat semacam perpustakaan reaksi dengan cara ini, menulis sesuatu seperti JIKA [input.set di memory_ array] KEMUDIAN [memori .-> reaksi]. Itu tidak mungkin! Karena ini bukan fakta bahwa inilah "sistem memori biologis" bekerja. Dan bukan fakta bahwa konstruksi mereka pada awalnya sama seperti yang kita lihat sekarang.

Pada saat yang sama, Anda tidak dapat hanya mengambil dan secara acak menghasilkan string setidaknya 256 byte dan mencoba untuk mengeksekusinya, karena pada komputer modern akan membutuhkan banyak waktu dan tidak cocok untuk kami. Mungkin saja metode seperti itu ideal, tetapi sayangnya, tidak mungkin untuk memverifikasi ini dengan teknologi yang saat ini belum dikembangkan.

Plus, kami masih memiliki bahasa pemrograman dan, apa pun yang dikatakan orang, ide kami tentang setidaknya sesuatu. Anda tidak dapat membangun sesuatu dari ketiadaan sama sekali. Karena itu, kita perlu tampilan yang subyektif. Sebagai contoh, saya tidak bisa membantu tetapi melihat bagaimana satu bentuk melewati yang lain dan sebaliknya, bagaimana kekacauan dengan mudah mengambil formulir dan juga berpisah dengan itu seperti bola diangkat dari lantai dan dilepaskan jatuh ke lantai itu dan meninggalkan bekas. Akibatnya, saya tidak ingin menentukan sesuatu dengan tepat, tetapi saya juga tidak dapat mengacak semuanya.

Untuk memahami masalahnya, bayangkan kita memiliki 2 kemungkinan tindakan dalam kode. Anda tidak dapat secara langsung menunjukkan mana yang akan dipilih, karena ini akan menjadi penentuan. Dan jika Anda mengacak semuanya, maka Anda perlu menggunakan probabilitas. Hanya apa? 50/50? 30/70? 80/20? Misalkan, hal-hal lain dianggap sama, 50/50 memang hubungan yang paling tidak pasti. Maka kode akan terlihat seperti ini:

if random.random() >= 0.5:
      1
else:
     2


Apa yang salah dengan kode ini? Dan fakta bahwa pada setiap iterasi loop, kode ini SELALU akan memilih secara acak tindakan pertama atau kedua. Dengan kata lain, kekacauan seperti itu tidak pernah terstruktur, karena ia bahkan tidak memiliki kemungkinan teoretis seperti itu. Pada umumnya, di sini kita berurusan dengan tekad yang sama. Ada jalan keluar dari situasi ini. Terdiri dari fakta bahwa action1 dan action2 sendiri harus mengubah kondisi di mana mereka diterapkan. Ada, saya pikir, opsi yang berbeda, tetapi saya ingin menawarkan yang berikut.

Seperti yang Anda ketahui, sistem operasi menyeimbangkan utas dalam antrian eksekusi menggunakan penentuan prioritas. Thread yang mengeksekusi saat runtime secara bertahap kehilangan prioritas, sementara utas menganggur dalam antrian meningkatkan prioritas ini. Pada ketukan tertentu, prioritas yang terakhir menjadi lebih tinggi daripada yang pertama, arus berubah tempat, dan kemudian situasinya berulang. Jadi, alirannya agak cepat bergantian satu sama lain dan kita melihat ilusi bahwa mereka dieksekusi hampir bersamaan.

Dalam kasus kami, prinsip prioritas akan memungkinkan kami untuk mengubah bukan utas untuk eksekusi pada kernel, tetapi bagian-bagian dari kode di mana kontrol akan ditransfer. Dan jika kita membuat satu bagian dari kode sebagai "acak", dan yang kedua sebagai "berpengalaman", maka perubahan alternatif mereka akan menjadi solusi yang kita cari.

Dengan kata lain, kode, menerapkan pengalaman, setiap kali akan meningkatkan kemungkinan bahwa tindakan berikutnya akan acak, dan bertindak secara acak, akan meningkatkan kemungkinan menerapkan pengalaman pada iterasi siklus berikutnya. Dengan demikian, kita mendapatkan aliran kekacauan yang diinginkan ke dalam pengalaman dan sebaliknya - persis apa yang kita butuhkan.

Keuntungan luar biasa dari desain ini adalah sama sekali tidak ada masalah dengan osifikasi sistem, yang dikenal, misalnya, dalam jaringan saraf yang sama. Di sisi lain, kami mengorbankan stabilitas, tetapi kami tidak membutuhkannya di sini.

Saya berharap di sini terutama untuk stresbahwa pemrogram klasik biasa membutuhkan stabilitas kode sebagai manna dari surga: pengakuan harus secara stabil mengenali, dan tidak setiap kali, server harus merespons dengan jawaban yang ditentukan untuk permintaan klien yang sesuai dari waktu ke waktu, dan tidak hanya untuk jawaban yang sama. , lalu yang lain, dll. dll. Dalam pemrograman reguler, ketidakstabilan kode adalah bug yang jelas yang tertangkap dalam pengujian. Dalam kasus kami, stabilitas ini tidak diperlukan dari kata sama sekali, karena kami tidak memiliki tugas kode yang jelas. Lebih tepatnya, tidak sama sekali. Tapi kita bisa mengatakannya dengan cara lain: kita perlu stabilitas perubahan kode transfer kontrol, dan kita mendapatkannya. Dapat juga dikatakan bahwa pendulum stabil, meskipun ia berhasil bergerak dari satu titik ke titik yang berlawanan dalam satu siklus.

Agar tidak berdasar, saya sarankan melihat kode dasar berikut di Python, yang saya buat sketsa hari ini, dipandu oleh semua pertimbangan di atas.

import random

deter_numb = 69
p_deter = 0.01
p_random = 0.99
iteration = 1

while True:
        print('iter = ',iteration)
        print('p_rand =  ', p_random)         
        print('p_deter = ', p_deter)
        input()
        if p_random > random.random():
            p_random-=0.01                     #  
            p_deter+=0.01
            print(random.random())    #  
        if p_deter > random.random():       
            p_deter-=0.01                      #  
            p_random+=0.01
            print(deter_numb)            #  
        iteration+=1


Saya mendorong Anda untuk mencoba menjalankan skrip ini sendiri dan melihat cara kerjanya. Ini adalah kode penyeimbang sendiri. Saat aksi 1 berdiri
print(random.random())
- yaitu hanya output angka acak, dan tindakan 2 -
print(deter_numb)
- Output dari nomor yang ditentukan. Dalam kode, akan ada tindakan di tempat mereka, saya membuat cetakan di sini hanya untuk menunjukkan prinsipnya.

Ketika kontrol beralih ke kondisi pertama (bagian acak dari kode), kode itu sendiri mengurangi kemungkinan pengulangan (p_random- = 0,01 - mengurangi sendiri) dan pada saat yang sama meningkatkan kemungkinan eksekusi bagian kode di mana pengalaman diterapkan (p_deter + = 0,01 - peningkatan probabilitas orang lain). Hal yang sama terjadi ketika mentransfer kontrol ke kondisi kedua. Dengan demikian, kedua potongan kode ini, ketika dieksekusi, mereka sendiri "melambat" dan pada saat yang sama "mempercepat" bagian "yang bersaing" lainnya dari kode.

Harap dicatat bahwa probabilitas awal bahwa kontrol akan ditransfer ke bagian acak dari kode adalah 99%, dan ke eksperimental - 1%. Ini untuk menunjukkan bahwa sistem seimbang bahkan dengan probabilitas yang sangat berbeda. Ketika mengeksekusi kode, akan terlihat bagaimana rasio ini akan mencapai 50/50 hanya dalam seratus iterasi, membentuk distribusi normal dengan puncak eksplisit 0,5 dan lingkungan kerja sekitar 6% (dalam 3-5 ratus iterasi berikutnya).

Ketika mengeksekusi kode, jelas bahwa probabilitas datang ke keseimbangan dan menetap di sekitar 0,5, menyeimbangkan melewati titik ini seperti pendulum yang menyeimbangkan di sekitar titik bawahnya.

Satu fitur lagi terlihat di sini: salah satu nomor acak atau yang ditentukan ditampilkan (69), atau keduanya sekaligus, yang berarti bahwa sistem dapat menerapkan pengalaman dan kemudian bertindak secara acak, atau sebaliknya, atau hanya menerapkan pengalaman, atau hanya bertindak secara acak. Dengan kata lain, eksekusi kode itu sendiri tetap acak, tetapi kami telah mengaktifkan sistem untuk menerapkan pengalaman, mis. kami menyingkirkan tekad ketika memutuskan tindakan, yang persis apa yang kami butuhkan.

Pada artikel selanjutnya, kita akan mempertimbangkan pembentukan tindakan dan pengalaman acak. Nah, atau sesuatu yang terpisah, mari kita lihat bagaimana kelanjutannya.

All Articles