WEBVTT

00:00.270 --> 00:06.230
Halo dan selamat datang di pipa ini dan ke Torro sekarang kita harus mendefinisikan lima variabel

00:06.240 --> 00:09.560
fungsi ini yaitu tiga konvolusi dan koneksi sementara.

00:09.810 --> 00:11.100
Jadi mari kita mulai dengan yang pertama.

00:11.250 --> 00:18.690
Konvolusional menerapkan konvolusi ke gambar input sehingga itulah gambar asli dan sekarang Anda akan melihat bagaimana semuanya

00:18.690 --> 00:22.710
akan menjadi sangat sederhana untuk membuat belokan ini.

00:22.770 --> 00:29.070
Yang harus kita lakukan adalah membuat subjek dari kelas tertentu dan kelas ini

00:29.070 --> 00:38.800
diambil dari dan kemudian kelas datang ke karena kita bekerja dengan gambar 2D dan sekarang seperti yang Anda lihat kita

00:38.800 --> 00:40.930
perlu meletakkan beberapa argumen.

00:40.930 --> 00:43.140
Yang pertama ada di saluran.

00:43.190 --> 00:45.910
Mari kita letakkan di saluran.

00:45.970 --> 00:49.210
Yang kedua adalah saluran keluar.

00:49.330 --> 00:57.070
Yang ketiga adalah ukuran Kerno dan sisanya dari mereka melangkah padding kelompok pelebaran dan bias.

00:57.130 --> 00:59.120
Dan kami memiliki nilai yang berbeda untuk semua ini.

00:59.260 --> 01:02.290
Jadi kita tidak akan tetapi mereka kita akan menjaga nilai default.

01:02.470 --> 01:08.500
Tetapi yang penting adalah ketiga argumen ini dalam saluran dan saluran serta ukuran kernel dan begitu juga saya kira apa

01:08.500 --> 01:09.740
yang berhubungan dengannya.

01:09.880 --> 01:15.730
Yah sangat sederhana secara umum sesuai dengan input konvolusi dan semua saluran sesuai

01:15.730 --> 01:17.900
dengan output dari kesimpulan.

01:17.920 --> 01:19.940
Jadi apa yang akan terjadi.

01:20.110 --> 01:24.460
Yah sangat sederhana itu akan menjadi jumlah saluran di gambar kami.

01:24.610 --> 01:30.460
Dan sebenarnya kita akan bekerja dengan gambar hitam putih karena pada dasarnya kita tidak warna untuk

01:30.460 --> 01:31.360
mengenali monster.

01:31.450 --> 01:35.310
AI benar-benar mampu mengenali monster dalam warna hitam dan putih.

01:35.440 --> 01:39.200
Jadi kita tidak melihat warna sama sekali hanya mengenalinya dengan bentuknya.

01:39.250 --> 01:44.380
Karena itu kita akan menggunakan satu saluran sehingga satu saluran adalah ketika Anda memiliki gambar hitam dan putih

01:44.380 --> 01:46.820
dan tiga saluran adalah ketika Anda memanggil gambar.

01:46.930 --> 01:51.320
Dan karena itu karena kami bekerja dengan gambar hitam dan putih di

01:51.340 --> 01:59.730
saluran itu akan sama dengan satu maka saluran kami sehingga saluran kami akan sama dengan gambar yang ingin Anda miliki di convolutional di

01:59.730 --> 02:02.970
sana yang merupakan output dari konstitusi ini satu.

02:02.970 --> 02:08.820
Dan pada dasarnya ini sama dengan jumlah fitur yang Anda inginkan ke teks dalam gambar asli Anda karena siapa

02:09.240 --> 02:15.040
yang akan membuat satu gambar per fitur yang ingin kami deteksi karena pada dasarnya Anda tahu cara kerjanya.

02:15.120 --> 02:21.390
Kami menerapkan satu fitur detektor pada gambar input untuk mendeteksi fitur spesifik pada gambar input dan oleh karena

02:21.390 --> 02:26.450
itu jumlah gambar keluaran di sini adalah jumlah fitur yang ingin kami deteksi.

02:26.460 --> 02:30.110
Jadi sekarang pertanyaannya adalah berapa banyak fitur yang ingin kita deteksi.

02:30.240 --> 02:38.730
Nah praktik yang umum adalah memulai dengan 32 fitur detektor dan sehingga akan membawa kita ke 32 persen

02:38.820 --> 02:46.170
gambar dalam lapisan konvolusional pertama ini sehingga inputnya adalah satu gambar hitam putih gambar nyata dan

02:46.170 --> 02:53.010
output dalam konvolusional pertama ada 32 gambar yang diproses. maksud saya tentu saja kesimpulannya

02:53.380 --> 02:59.750
diterapkan pada gambar input untuk mendapatkan 32 gambar baru dengan fitur yang terdeteksi.

03:00.240 --> 03:06.990
Dan kemudian kita perlu menentukan ukuran kernel yang tidak lain dari dimensi persegi yang

03:07.080 --> 03:09.450
akan melalui gambar asli.

03:09.600 --> 03:15.350
Dan dalam praktik umum kita gunakan untuk membeli dua atau tiga lebar tiga atau lima kali lima.

03:15.660 --> 03:22.170
Dan untuk yang pertama kita akan menggunakan fitur detektor lima oleh lima yang merupakan fitur detektor yang akan

03:22.170 --> 03:24.580
memiliki lima oleh lima 10 mesin.

03:24.810 --> 03:29.290
Dan kemudian kita akan mengurangi ukuran kernel ini untuk lapisan convolutional berikutnya.

03:29.340 --> 03:32.320
Dan berbicara tentang ini, inilah yang akan kita lakukan sekarang.

03:32.390 --> 03:40.860
Kita akan menyalin ini untuk menentukan lilitan kedua dan oleh karena itu saya mendasarkannya di sini dan sekarang ini sangat lucu

03:40.890 --> 03:43.370
dan sangat mudah seperti domino.

03:43.500 --> 03:49.260
Saluran input dari lapisan konvolusional kedua adalah saluran keluaran dari konvolusional pertama di

03:49.260 --> 03:49.810
sana.

03:49.950 --> 03:55.300
Jadi jumlah output 32 Ini adalah jumlah input yang sama 32 di sini.

03:55.420 --> 04:01.290
Dan itu karena kita memiliki 32 gambar di lapisan konvolusional input dari konvolusi kedua.

04:01.440 --> 04:10.340
Dan konvolusi kedua diterapkan pada lapisan konvolusional kedua ini untuk mengembalikan lapisan konvolusional ketiga.

04:10.530 --> 04:13.280
Dan sekarang pertanyaannya adalah berapa banyak gambar baru yang kita inginkan.

04:13.410 --> 04:19.820
Yah sama yang membuat 32 gambar baru 32 sebenarnya adalah angka yang sangat umum di jaringan saraf convolutional jika

04:19.830 --> 04:23.710
Anda melihat arsitektur Anda akan menemukan 32 di banyak dari mereka.

04:24.030 --> 04:29.910
Dan kemudian untuk ukuran kernel Yah kita perlu mengurangi ukuran kernel yang merupakan dimensi dari detektor fitur

04:29.910 --> 04:30.610
kami.

04:30.780 --> 04:37.680
Dan sekarang kita akan beralih dari lima menjadi empat atau bahkan tiga dan kemudian kita akan menjadi lebih kecil lagi.

04:37.920 --> 04:40.790
Baiklah jadi konvolusi kedua kami sudah siap.

04:40.830 --> 04:43.830
Dibutuhkan sebagai input 32 proses gambar.

04:43.890 --> 04:51.130
Masing-masing dalam fitur pertama dari gambar input asli dan itu menciptakan 32 gambar baru.

04:51.270 --> 04:54.990
Berkat dimensi detektor fitur yang diperkecil ini.

04:55.120 --> 04:57.250
Dan sekarang mari kita mendorong ini lebih lagi

04:57.300 --> 05:05.450
Jadi saya menyalin ini dan menempelnya di sini untuk membuat konvolusi ketiga untuk mendeteksi beberapa fitur.

05:05.470 --> 05:08.010
Dan sekarang itu sama dengan saluran input.

05:08.010 --> 05:13.800
Berikut adalah jumlah gambar input di sebelah kiri koneksi dekonvolusi dan itu adalah jumlah

05:13.800 --> 05:17.740
gambar yang ada di sebelah kanan koneksi konvolusi sebelumnya.

05:17.740 --> 05:18.710
Itu 32.

05:18.750 --> 05:20.030
Karena itu kami tetap menyesal mendengarnya.

05:20.030 --> 05:20.990
Itu sempurna.

05:21.220 --> 05:25.220
Dan sekarang pertanyaannya adalah berapa banyak gambar baru yang ingin kita deteksi.

05:25.310 --> 05:31.130
Kami akan mengambil sekarang 64 dan karenanya 64 output gambar precess.

05:31.260 --> 05:36.800
Dan tentu saja sekarang kita mengambil ukuran kernel yang lebih kecil dan kita akan mengambil dua.

05:36.800 --> 05:42.660
Dan itulah arsitektur yang sangat klasik dari konvolusional di sana dan sangat efisien untuk memiliki

05:42.660 --> 05:45.840
deteksi fitur tingkat tinggi di dalam gambar.

05:46.200 --> 05:53.510
Baiklah dan sekarang setelah kita memiliki tiga konvolusi, ada tiga koneksi konvolusi di sini.

05:53.640 --> 05:59.970
Nah sekarang saatnya untuk mendapatkan koneksi penuh kami yang saya ingatkan kami akan mengambil vektor besar ini yang

05:59.970 --> 06:07.710
kami dapatkan setelah meratakan semua 64 kali 32 kali 32 lagi gambar yang kami dapatkan dari semua konvolusi ini sehingga kami meratakan

06:08.160 --> 06:13.920
semua piksel gambar ini dan kita dapat satu vektor besar yang akan menjadi input dari

06:14.190 --> 06:16.590
jaringan saraf baru yang sepenuhnya terhubung.

06:16.860 --> 06:22.230
Dan saat itulah kita harus membuat koneksi antara pertama ini vektor besar dan lapisan tersembunyi

06:22.470 --> 06:27.710
dan kemudian koneksi penuh kedua antara lapisan tersembunyi dan output mereka terdiri dari neuron

06:27.730 --> 06:28.270
output.

06:28.320 --> 06:31.940
Masing-masing sesuai dengan nilai kubus dari tindakan yang mungkin.

06:31.980 --> 06:33.960
Jadi mari kita buat dua koneksi ini.

06:33.960 --> 06:35.220
Anda tahu cara melakukannya.

06:35.220 --> 06:37.550
Itulah tepatnya yang kami lakukan untuk mobil self-driving.

06:37.560 --> 06:38.800
Jadi mari kita lakukan itu lagi.

06:39.000 --> 06:46.890
Baiklah pertama-tama kita mengambil Maggio kita lalu kita mengambil Lynnie kelas kita karena sekali lagi koneksi yang kita buat

06:46.920 --> 06:49.060
adalah objek dari kelas penguasa.

06:49.260 --> 06:50.550
Dan kemudian dalam tanda kurung.

06:50.670 --> 06:58.620
Nah itu sama untuk memasukkan fitur input yaitu jumlah mereka kemudian fitur output.

06:58.850 --> 07:03.110
Dan begitu fitur input untuk koneksi penuh pertama apa yang akan terjadi.

07:03.340 --> 07:10.300
Nah itu akan sama dengan jumlah piksel yang ada dalam perubahan vektor besar ini setelah

07:10.480 --> 07:13.830
meratakan semua gambar proses setelah tiga konvolusi.

07:13.830 --> 07:15.110
Dan jadi apa nomor ini.

07:15.220 --> 07:17.350
Ya sebenarnya ada trik di sini.

07:17.380 --> 07:19.620
Jumlah ini sebenarnya sulit didapat.

07:19.660 --> 07:22.770
Kita sebenarnya perlu membuat fungsi untuk menghitung angka itu.

07:22.960 --> 07:25.570
Kami tidak memiliki variabel yang akan memberi kami nomor ini.

07:25.570 --> 07:29.040
Kita harus menghitungnya dan oleh karena itu apa yang akan kita lakukan sekarang.

07:29.150 --> 07:34.780
Dan sekarang sangat penting untuk memahami pola pikir pemrograman yang harus kita miliki dan mencoba untuk membawa

07:35.200 --> 07:40.930
kepada Anda pola pikir itulah yang harus Anda pikirkan saat ini untuk mengatasi hambatan ini karena pertama kali

07:41.110 --> 07:45.690
Anda mungkin berkata hey saya tidak memiliki jumlah neuron ini dalam vektor Flaten.

07:45.730 --> 07:46.650
Apa yang harus saya lakukan.

07:46.660 --> 07:47.600
Saya terjebak di sini.

07:47.800 --> 07:55.720
Yah tidak benar-benar karena apa yang dapat Anda lakukan sekarang adalah hanya memasukkan nama apa pun di sini yang akan mewakili jumlah

07:55.720 --> 08:01.690
neuron sehingga tidak biasa bahwa jumlah neuron jumlah neuron dan kemudian kami hanya akan membuat fungsi

08:01.690 --> 08:05.130
yang akan kembali dan jumlah variabel neuron ini.

08:05.180 --> 08:07.100
Jumlah piksel yang kami cari.

08:07.330 --> 08:12.760
Jadi kita benar-benar bisa melakukan itu, kita bisa menempatkan ini sangat vokal tentu saja akan mendapat peringatan

08:12.760 --> 08:17.090
karena belum ada tetapi kita akan membuatnya setelah itu dengan suatu fungsi.

08:17.350 --> 08:21.140
Dan kami benar-benar diizinkan untuk melakukan itu bahkan jika fungsinya datang sesudahnya.

08:21.170 --> 08:25.970
Itu pemikiran pemrograman khas yang harus Anda miliki ketika Anda mendapatkan hambatan semacam itu.

08:26.020 --> 08:29.710
Anda bisa membuat fungsi untuk mendapatkan apa yang Anda lewatkan.

08:29.740 --> 08:32.640
Baiklah dan kemudian fitur dan masa depan kita.

08:32.650 --> 08:37.830
Itulah jumlah neuron dalam lapisan tersembunyi dan kali ini terserah Anda.

08:37.870 --> 08:41.230
Itu tergantung pada arsitektur jaringan baru yang ingin Anda buat.

08:41.230 --> 08:44.230
Dan jumlah yang baik bukan jumlah yang kecil.

08:44.230 --> 08:46.960
Jadi misalnya 40 neuron mungkin baik-baik saja.

08:46.960 --> 08:48.660
Kita dapat mencoba meningkatkannya.

08:48.790 --> 08:51.280
Jika pelatihan tidak terlalu lambat, Anda dapat mencoba meningkatkannya.

08:51.340 --> 08:56.750
Mungkin itu akan meningkatkan prediksi tetapi mari kita mulai dengan 40 mungkin kita akan meningkatkannya nanti.

08:57.130 --> 09:04.690
Baiklah itu saja untuk koneksi penuh pertama maka kita akan menyalin paste ini di sini untuk koneksi

09:04.710 --> 09:09.300
penuh kedua yaitu koneksi antara lapisan tersembunyi dan lapisan output.

09:09.370 --> 09:15.720
Jadi fitur di sini menjadi fitur keluar dari layer sebelumnya dan itu adalah 40.

09:15.790 --> 09:18.020
Jadi di sini kita dapat menempatkan 40.

09:18.190 --> 09:20.500
Itu tentu saja jumlah neuron dalam satu lapisan.

09:20.860 --> 09:27.280
Dan masa depan kita akan sama dengan jumlah neuron keluaran, seharusnya tidak ada jaringan saraf.

09:27.340 --> 09:33.360
Dan karena setiap neuron keluaran sesuai dengan satu nilai baru dan satu Cuvee dan respons terhadap satu

09:33.370 --> 09:38.440
tindakan sedangkan jumlah neuron keluaran di sini tentu saja jumlah tindakan dan kami

09:38.740 --> 09:47.320
memiliki satu variabel untuk ini yang merupakan tindakan angka dan oleh karena itu di sini memasukkan aksi angka dan di sana kami pergi selamat.

09:47.390 --> 09:53.850
Kami memang menemukan arsitektur jaringan saraf kami. Jaringan saraf kami terdiri dari tiga lapisan konvolusional

09:53.850 --> 09:55.960
dan satu lapisan tersembunyi.

09:56.130 --> 10:03.020
Semua ini dalam satu CNN besar dan CNN ini akan mendeteksi fitur dalam game sehingga AI akan tahu ke mana harus melakukan

10:03.020 --> 10:06.550
ke mana harus pergi dan ke mana ia harus menembak.

10:06.900 --> 10:08.240
Jadi kita lanjutkan untuk langkah ini.

10:08.340 --> 10:10.720
Itu langkah pertama yang sangat penting dilakukan.

10:10.720 --> 10:16.020
Sekarang kita akan beralih ke langkah berikutnya yang tentu saja untuk mendapatkan jumlah neuron yang

10:16.020 --> 10:17.010
masih hilang

10:17.010 --> 10:21.930
Itu sebenarnya mengapa kami memiliki peringatan di sini dan neuron nomor telepon tetapi tidak perlu khawatir.

10:21.960 --> 10:26.970
Sekarang kita akan membuat fungsi yang akan mengembalikan jumlah neuron dalam vektor besar ini dan kita akan

10:26.970 --> 10:30.210
meletakkan angka itu dalam variabel yang akan memanggil sejumlah neuron.

10:30.270 --> 10:32.070
Jadi mari kita lakukan ini di tutorial selanjutnya.

10:32.070 --> 10:33.130
Itu langkah kita selanjutnya.

10:33.180 --> 10:34.790
Dan sampai saat itu nikmati AI.
