Neural Network Untuk Klasifikasi dengan Tensorflow

Artikel ini diterbitkan sebagai bagian dari Blogathon Ilmu Data

Pada artikel ini, saya akan membuat model jaringan saraf dengan TensorFlow untuk menyelesaikan masalah klasifikasi. Mari jelajahi bersama bagaimana kita bisa mendekati masalah klasifikasi di Tensorflow. Tapi pertama-tama, saya ingin memastikan bahwa kami dapat menjawab pertanyaan-pertanyaan ini:

itu jaringan saraf?

Tujuan utama dari jaringan saraf adalah untuk mencoba menemukan hubungan antara fitur dalam kumpulan data., dan itu terdiri dari sekumpulan algoritma yang meniru cara kerja otak manusia. "Neuron" dalam jaringan saraf adalah fungsi matematika yang mengumpulkan dan mengklasifikasikan informasi menurut arsitektur tertentu.

Apa itu Klasifikasi?

Masalah klasifikasi melibatkan prediksi jika sesuatu milik satu kelas atau tidak. Dengan kata lain, saat melakukannya kami mencoba melihat sesuatu adalah satu atau lain hal.

Jenis Klasifikasi

• Misalkan Anda ingin memprediksi apakah seseorang menderita diabetes atau tidak. Jika Anda menghadapi situasi seperti ini, ada dua kemungkinan, bukan? Itu yang dipanggil Klasifikasi Biner.
• Misalkan Anda ingin mengidentifikasi apakah sebuah foto adalah mainan, orang, atau kucing, bukan? ini disebut Klasifikasi multi-kelas karena ada lebih dari dua pilihan.
• Misalkan Anda ingin memutuskan kategori mana yang harus ditetapkan untuk sebuah artikel. Jika demikian, itu disebut Klasifikasi Multi-label, karena satu artikel dapat memiliki lebih dari satu kategori yang ditetapkan. Mari simak penjelasan kami melalui artikel ini. Kami dapat menetapkan kategori seperti "Pembelajaran Mendalam, TensorFlow, Klasifikasi", dll. ke artikel ini

Sekarang kita bisa bergerak maju karena kita memiliki kesamaan pemahaman tentang masalah yang akan kita kerjakan. Jadi, saatnya untuk coding. Saya harap Anda menuliskannya bersama saya karena satu-satunya cara untuk menjadi lebih baik, membuat lebih sedikit kesalahan adalah dengan menulis lebih banyak kode.

Kami mulai dengan mengimpor pustaka yang akan kami gunakan:

impor numpy sebagai np impor panda sebagai pd impor matplotlib.pyplot sebagai plt impor tensorflow sebagai tf print(tf.__version__)

Membuat Kumpulan Data

Saatnya membuat kumpulan data untuk dikerjakan:

dari sklearn.datasets import make_circles sample = 1000 X, y = make_circles(samples, noise = 0.03, random_state = 42)

cetak(X >>[[ 0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [ 0.67036156 -0.76750154 0.28105665] [ 0.96382443 XNUMX]]

cetak(y) >> [1 1 1 1 0 1 1 1 1 0]

Oke, kita sudah melihat dataset kita lebih detail, tapi kita masih belum tahu apa-apa kan? Itulah mengapa di sini satu langkah penting adalah menyatu dengan data, dan visualisasi adalah cara terbaik untuk melakukannya.

lingkaran = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'label' : y}) circle.head()

Di sini muncul satu pertanyaan, label seperti apa yang kita hadapi?

circle.label.value_counts() >> 1 500 0 500 Nama: label, dtype: int64

Sepertinya kita berurusan dengan masalah klasifikasi biner, karena kami memiliki 2 label (0 dan 1).

plt.menyebar(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Seperti yang saya sebutkan di atas, cara terbaik untuk mendapatkannya dengan data adalah visualisasi. Sekarang plot mengatakan dengan sendirinya model seperti apa yang perlu kita buat. Kami akan membuat model yang dapat membedakan titik biru dari titik merah.

Sebelum membangun model jaringan saraf apa pun, kita harus memeriksa bentuk fitur masukan dan keluaran. mereka harus sama!

cetak(bentuk-X, bentuk-y) cetak(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

Kami memiliki jumlah nilai yang sama untuk setiap fitur, tetapi bentuk X berbeda? Mengapa? Mari kita periksa.

X[0], y[0] >> (larik([0.75424625, 0.23148074]), 1)

Oke, kami memiliki 2 fitur X untuk 1 tahun. Jadi kita bisa bergerak maju tanpa masalah.

Langkah-langkah Pemodelan Neural Network Untuk Klasifikasi dengan Tensorflow

Di TensorFlow ada tahapan tetap untuk membuat model:

• Membuat model – menyatukan lapisan-lapisan Neural Network menggunakan Functional atau Sequential API
• Menyusun model – menentukan bagaimana kinerja model harus diukur, dan bagaimana peningkatannya (fungsi kerugian dan pengoptimal)
• Memasang model – membiarkan model menemukan pola dalam data

Kami akan menggunakan Sequential API. Jadi, mari kita mulai

tf.acak.set_seed(42)

model_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 optimizer = tf.keras.optimizers.SGD(), #SGD singkatan dari Stochastic Gradient Descent metrics = ['accuracy']) model_1.fit(X, y, epochs = 5)

>> Zaman 1/5 32/32 [=========================================] - 1 detik 1 md/langkah - kerugian: 2.8544 - akurasi: 0.4600 Epoch 2/5 32/32 [==============================] - 0s 2ms/langkah - kerugian : 0.7131 - akurasi: 0.5430 Epoch 3/5 32/32 [==============================] - 0s 2ms/langkah - kerugian: 0.6973 - akurasi: 0.5090 Epoch 4/5 32/32 [==============================] - 0s 2ms /langkah - kerugian: 0.6950 - akurasi: 0.5010 Zaman 5/5 32/32 [==============================] - 0s 1ms/langkah - kerugian: 0.6942 - akurasi: 0.4830

Keakuratan model kurang lebih 50% yang pada dasarnya berarti model hanya menebak-nebak, coba kita latih lebih lama

model_1.fit(X, y, epochs = 200, verbose = 0) #kami menyetel verbose = 0 untuk menghapus prosedur pelatihan ) model_1.evaluate(X, y)

>> 32/32 [=========================================] - 0s 1ms/langkah - kerugian: 0.6935 - akurasi: 0.5000 [0.6934829950332642, 0.5]

Bahkan setelah 200 zaman, kinerjanya masih seperti dugaan. Langkah selanjutnya adalah menambahkan lebih banyak lapisan dan pelatihan lebih lama.

tf.acak.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), pengoptimal = tf.keras.optimizers.SGD(), metrik = ['akurasi']) model_2.fit(X, y, zaman = 100, verbose = 0)

 model_2.evaluasi(X,y)

>> 32/32 [=========================================] - 0s 1ms/langkah - kerugian: 0.6933 - akurasi: 0.5000 [0.6933314800262451, 0.5]

Tetap saja tidak ada sedikit pun perubahan, sepertinya ada yang tidak beres.

Memperbaiki model Neural Network For Classification dengan Tensorflow

Ada berbagai cara untuk meningkatkan model pada berbagai tahap:

• Membuat model- tambahkan lebih banyak lapisan, tambah jumlah unit tersembunyi (neuron), ubah fungsi aktivasi setiap lapisan
• Menyusun model- coba fungsi pengoptimalan yang berbeda, misalnya gunakan Adam() alih-alih SGD().
• Memasang model – kita bisa meningkatkan jumlah zaman

Ayo coba menambahkan lebih banyak neuron dan mencoba Adam pengoptimal

tf.acak.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # tambahkan 100 neuron padat tf.keras.layers.Dense(10), # tambahkan layer lain dengan 10 neuron tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['akurasi']) model_3.fit(X, y, zaman =100, bertele-tele=0)

model_3.evaluate(X,y) >> 32/32 [==============================] - 0s 1ms/langkah - kerugian: 0.6980 - akurasi: 0.5080 [0.6980254650115967, 0.5080000162124634]

Masih belum membaik! Mari memvisualisasikan data untuk melihat apa yang salah.

Visualisasikan model Neural Network

Untuk memvisualisasikan prediksi model kita, kita akan membuat fungsi plot_decision_boundary() yang:

• Menggunakan model, fitur, dan label terlatih
• Buat meshgrid dari nilai X yang berbeda.
• Membuat prediksi di seluruh meshgrid.
• Plot prediksi dengan garis.

Catatan:  Fungsi ini diadaptasi dari dua sumber:

CS231n Dibuat dengan dasar-dasar ML 

def plot_decision_boundary(model, X, y): # Tentukan batas sumbu plot dan buat meshgrid x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # Buat nilai X (kita akan memprediksi semua ini) x_in = np.c_[xx.ravel(), yy.ravel()] # Membuat prediksi menggunakan yang terlatih model y_pred = model.predict(x_in) # Periksa multi-kelas

 if len(y_pred[0]) > 1: print("melakukan klasifikasi multikelas...") # Kita harus membentuk kembali prediksi kita agar siap untuk diplot y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("melakukan klasifikasi biner...") y_pred = np.round(y_pred).reshape(xx.shape) # Plot keputusan batas plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

Ini dia! Sekali lagi visualisasi menunjukkan kepada kita apa yang salah dan apa yang harus dilakukan? Model kami mencoba menggambar garis lurus melalui data, tetapi data kami tidak dapat dipisahkan oleh garis lurus. Ada sesuatu yang hilang dari masalah klasifikasi kita? Apa itu?

Ini adalah non-linearitas! Kami membutuhkan beberapa garis non-linear. Anda mungkin bingung sekarang, jika Anda berpikir bahwa Anda tidak melihat fungsi seperti itu sebelumnya, Anda salah, karena Anda pernah melihatnya. Mari kita lihat secara visual. Visualisasi selalu bekerja lebih baik!

Ada beberapa fungsi aktivasi di Neural Network yang bisa kita gunakan, seperti ReLu, sigmoid. Mari berkreasi sedikit tensor mainan dan memeriksa fungsi-fungsi di atasnya.

Fungsi Aktivasi untuk Neural Networks

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12.-11.-10.-9.-8.-7.- 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], bentuk=(24,), dtype=float32)

Mari kita lihat seperti apa tensor mainan kita?

plt.plot(A)

Sepertinya ini, garis lurus! 

Sekarang mari kita buat ulang fungsi aktivasi untuk melihat apa yang mereka lakukan pada tensor kita?

Sigmoid:

def sigmoid(x): kembalikan 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

Garis tidak lurus!

ReLu:

def relu(x): kembalikan tf.maximum(0,x) plt.plot(relu(A))

Garis non-lurus lainnya!

Sekarang Anda telah melihat fungsi aktivasi non-linier, dan inilah yang akan bekerja untuk kami, model tidak dapat mempelajari apa pun pada kumpulan data non-linier dengan fungsi aktivasi linier! Jika telah mempelajari ini, sekarang saatnya untuk membagi data kita menjadi set pelatihan dan pengujian dan membangun model yang kuat.

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2 ))

tf.acak.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, aktivasi = 'relu'), #kami mungkin berhak "tf.keras.activations.relu" juga tf.keras.layers.Dense(4 , aktivasi = 'relu'), tf.keras.layers.Dense(1, aktivasi = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, optimizer = tf.keras.optimizers.Adam( lr = 0.01), metrik = ['akurasi']) model_4.fit(X_train, y_train, epochs = 25, verbose = 0)

Evaluasi modelnya

loss, akurasi = model_4.evaluate(X_test, y_test) print(f' Model loss pada set tes: {loss}') print(f' Model akurasi pada set tes: {100*akurasi}')

>> 7/7 [==============================] - 0s 2ms/langkah - kerugian: 0.1247 - akurasi: 1.0000 Kerugian model pada set pengujian: 0.1246885135769844 Akurasi model pada set pengujian: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Kereta") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Test") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

Mari kita lihat sekilas apa yang kita bicarakan di artikel ini. Bersama-sama kita melihat cara mendekati tugas klasifikasi di Neural Network dengan TensorFlow. Kami membuat 3 model dengan cara pertama yang terlintas dalam pikiran, dan dengan bantuan visualisasi kami menyadari kesalahan kami, kami mengeksplorasi linearitas, non-linearitas, dan akhirnya, kami berhasil membuat model umum. Apa yang saya coba tunjukkan dengan semua kode ini dan langkah-langkah yang saya ikuti adalah tidak ada yang 100 persen akurat atau tetap, semuanya terus berubah setiap hari. Untuk menebak masalah mana yang mungkin Anda hadapi dalam jenis data yang mana dan untuk melihat kombinasi mana yang memberikan hasil yang lebih baik, yang Anda butuhkan hanyalah menulis lebih banyak kode dan mendapatkan pengalaman.

Saya harap artikel ini sedikit membantu Anda dan memberikan beberapa kontribusi.

Media yang ditampilkan dalam artikel ini bukan milik Analytics Vidhya dan digunakan atas kebijaksanaan Penulis

terkait

Sumber: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/