Difference between revisions of "Keras: Develop Your First Neural Network in Python Step-By-Step"

From OnnoWiki
Jump to navigation Jump to search
 
(18 intermediate revisions by the same user not shown)
Line 73: Line 73:
 
  ...
 
  ...
  
−
We can now load the file as a matrix of numbers using the NumPy function loadtxt().
+
Kita dapat me-load file sebagai matrix menggunakan NumPy function loadtxt().
  
−
There are eight input variables and one output variable (the last column). We will be learning a model to map rows of input variables (X) to an output variable (y), which we often summarize as y = f(X).
+
Ada delapan variabel input dan satu variabel output (kolom terakhir). Kita akan mempelajari sebuah model untuk memetakan baris variabel input (X) ke variabel output (y), yang sering kita ringkas sebagai y = f (X).
  
−
The variables can be summarized as follows:
+
Variabel dapat diringkas sebagai berikut:
  
−
Input Variables (X):
+
Variable Input (X):
  
−
* Number of times pregnant
+
* Berapa kali hamil
−
* Plasma glucose concentration a 2 hours in an oral glucose tolerance test
+
* Konsentrasi Plasma glucose dalam 2 jam dalam oral glucose tolerance test
 
* Diastolic blood pressure (mm Hg)
 
* Diastolic blood pressure (mm Hg)
 
* Triceps skin fold thickness (mm)
 
* Triceps skin fold thickness (mm)
Line 88: Line 88:
 
* Body mass index (weight in kg/(height in m)^2)
 
* Body mass index (weight in kg/(height in m)^2)
 
* Diabetes pedigree function
 
* Diabetes pedigree function
−
* Age (years)
+
* Umur (Tahun)
  
−
Output Variables (y):
+
Variable Output (y):
  
−
* Class variable (0 or 1)
+
* Class variable (0 atau 1)
  
−
Once the CSV file is loaded into memory, we can split the columns of data into input and output variables.
+
Setelah file CSV dimuat ke dalam memori, kita dapat membagi kolom data menjadi variabel input dan output.
  
−
The data will be stored in a 2D array where the first dimension is rows and the second dimension is columns, e.g. [rows, columns].
+
Data akan disimpan dalam array 2D di mana dimensi pertama adalah baris dan dimensi kedua adalah kolom, mis. [baris, kolom].
  
−
We can split the array into two arrays by selecting subsets of columns using the standard NumPy slice operator or “:” We can select the first 8 columns from index 0 to index 7 via the slice 0:8. We can then select the output column (the 9th variable) via index 8.
+
Kita dapat membagi array menjadi dua array dengan memilih subset kolom menggunakan operator slice NumPy standar atau “:” Kita dapat memilih 8 kolom pertama dari indeks 0 hingga indeks 7 melalui slice 0:8. Kita kemudian dapat memilih kolom output (variabel ke-9) melalui indeks 8.
  
 
  ...
 
  ...
Line 108: Line 108:
 
  ...
 
  ...
  
−
We are now ready to define our neural network model.
+
Kita sekarang siap untuk mendefinisikan model neural network kita.
  
−
Note, the dataset has 9 columns and the range 0:8 will select columns from 0 to 7, stopping before index 8. If this is new to you, then you can learn more about array slicing and ranges in this post:
+
Catatan, dataset memiliki 9 kolom dan kisaran 0:8 akan memilih kolom dari 0 hingga 7, berhenti sebelum indeks 8. Jika ini baru bagi anda, maka anda dapat mempelajari lebih lanjut tentang pengirisan array dan rentang dalam:
  
−
    How to Index, Slice and Reshape NumPy Arrays for Machine Learning in Python
+
* [[NumPy: Index, Slice and Reshape NumPy Arrays for Machine Learning]]
  
 
==2. Define Keras Model==
 
==2. Define Keras Model==
  
−
Models in Keras are defined as a sequence of layers.
+
Model dalam Keras didefinisikan sebagai urutan lapisan.
  
−
We create a Sequential model and add layers one at a time until we are happy with our network architecture.
+
Kita membuat model Sequential dan menambahkan layer satu per satu sampai kita puas dengan arsitektur network yang kita buat.
  
−
The first thing to get right is to ensure the input layer has the right number of input features. This can be specified when creating the first layer with the input_dim argument and setting it to 8 for the 8 input variables.
+
Hal pertama yang harus dilakukan adalah memastikan layer input memiliki jumlah fitur input yang tepat. Ini dapat ditentukan saat membuat layer pertama dengan argumen input_dim dan, misalnya, men-set menjadi 8 untuk 8 variabel input.
  
−
How do we know the number of layers and their types?
+
Bagaimana kita mengetahui jumlah lapisan dan jenisnya?
  
−
This is a very hard question. There are heuristics that we can use and often the best network structure is found through a process of trial and error experimentation (I explain more about this here). Generally, you need a network large enough to capture the structure of the problem.
+
Ini pertanyaan yang sangat sulit. Setelah melalui proses trial dan experimen / percobaan panjang kita akan menemukan struktur network yang terbaik. Secara umum, kita memerlukan network yang cukup besar untuk menangkap struktur masalah.
  
−
In this example, we will use a fully-connected network structure with three layers.
+
Dalam contoh ini, kita akan menggunakan fully-connected network structure dengan tiga layer.
  
−
Fully connected layers are defined using the Dense class. We can specify the number of neurons or nodes in the layer as the first argument, and specify the activation function using the activation argument.
+
Fully connected layer di definisikan dengan menggunakan Dense class. Kita dapat menentukan jumlah neuron atau node di lapisan sebagai argumen pertama, dan menentukan fungsi aktivasi menggunakan argumen aktivasi.
  
 
We will use the rectified linear unit activation function referred to as ReLU on the first two layers and the Sigmoid function in the output layer.
 
We will use the rectified linear unit activation function referred to as ReLU on the first two layers and the Sigmoid function in the output layer.
  
−
It used to be the case that Sigmoid and Tanh activation functions were preferred for all layers. These days, better performance is achieved using the ReLU activation function. We use a sigmoid on the output layer to ensure our network output is between 0 and 1 and easy to map to either a probability of class 1 or snap to a hard classification of either class with a default threshold of 0.5.
+
Pada masa lalu fungsi aktivasi Sigmoid dan Tanh lebih disukai untuk semua lapisan. Saat ini, kinerja yang lebih baik dicapai menggunakan fungsi aktivasi ReLU. Kita menggunakan sigmoid pada layer output untuk memastikan output jaringan kami antara 0 dan 1 dan mudah dipetakan ke probabilitas class 1 atau snap ke klasifikasi keras dari kedua kelas dengan ambang batas standar 0,5.
  
−
We can piece it all together by adding each layer:
+
Kita dapat menyatukan semuanya dengan menambahkan setiap layer:
  
−
    The model expects rows of data with 8 variables (the input_dim=8 argument)
+
* Model mengharapkan deretan data dengan 8 variabel (argumen input_dim = 8)
−
    The first hidden layer has 12 nodes and uses the relu activation function.
+
* Lapisan hidden pertama memiliki 12 node dan menggunakan fungsi aktivasi relu.
−
    The second hidden layer has 8 nodes and uses the relu activation function.
+
* Lapisan hidden kedua memiliki 8 node dan menggunakan fungsi aktivasi relu.
−
    The output layer has one node and uses the sigmoid activation function.
+
* Lapisan output memiliki satu node dan menggunakan fungsi aktivasi sigmoid.
  
 
  ...
 
  ...
Line 150: Line 150:
  
  
−
Note, the most confusing thing here is that the shape of the input to the model lis defined as an argument on the first hidden layer. This means that the line of code that adds the first Dense layer is doing 2 things, defining the input or visible layer and the first hidden layer.
+
Catatan, hal yang paling membingungkan di sini adalah bahwa bentuk input ke model didefinisikan sebagai argumen pada lapisan hidden pertama. Ini berarti bahwa baris kode yang menambahkan Dense Layer melakukan 2 hal, menentukan input atau lapisan yang terlihat dan lapisan hidden pertama.
  
 
==3. Compile Keras Model==
 
==3. Compile Keras Model==
  
−
Now that the model is defined, we can compile it.
+
Sekarang model sudah didefinisikan, kita bisa meng-compile-nya.
  
−
Compiling the model uses the efficient numerical libraries under the covers (the so-called backend) such as Theano or TensorFlow. The backend automatically chooses the best way to represent the network for training and making predictions to run on your hardware, such as CPU or GPU or even distributed.
+
Meng-compile model menggunakan library numerik yang efisien di belakang layar (yang disebut backend) seperti Theano atau TensorFlow. Backend secara otomatis memilih cara terbaik untuk me-representasikan network untuk training dan membuat prediksi untuk berjalan pada perangkat keras kita, seperti CPU atau GPU atau bahkan terdistribusi.
  
−
When compiling, we must specify some additional properties required when training the network. Remember training a network means finding the best set of weights to map inputs to outputs in our dataset.
+
Saat mengkompilasi, kita harus menentukan beberapa properti tambahan yang diperlukan saat men-train network. Ingat network training berarti menemukan set weight terbaik untuk memetakan input ke output dalam dataset yang kita miliki.
  
−
We must specify the loss function to use to evaluate a set of weights, the optimizer is used to search through different weights for the network and any optional metrics we would like to collect and report during training.
+
Kita harus menentukan fungsi loss yang digunakan untuk mengevaluasi satu set weight, optimizer digunakan untuk mencari berbagai weight untuk network dan metrik opsional yang ingin kita kumpulkan dan laporkan selama pelatihan.
  
−
In this case, we will use cross entropy as the loss argument. This loss is for a binary classification problems and is defined in Keras as “binary_crossentropy“. You can learn more about choosing loss functions based on your problem here:
+
Dalam hal ini, kita akan menggunakan cross entropy sebagai argumen loss. Loss ini untuk masalah klasifikasi biner dan didefinisikan dalam Keras sebagai "binary_crossentropy". Kita dapat mempelajari lebih lanjut tentang memilih fungsi loss berdasarkan masalah kita di sini:
  
−
    How to Choose Loss Functions When Training Deep Learning Neural Networks
+
* [[Keras: Memilih Fungsi Loss]]
  
−
We will define the optimizer as the efficient stochastic gradient descent algorithm “adam“. This is a popular version of gradient descent because it automatically tunes itself and gives good results in a wide range of problems. To learn more about the Adam version of stochastic gradient descent see the post:
+
Kita akan mendefinisikan optimizer sebagai algoritma  stochastic gradient descent yang efisien "adam". Ini adalah versi populer dari gradient descent karena secara otomatis men-tune diri sendiri dan memberikan hasil yang baik dalam berbagai masalah. Untuk mempelajari lebih lanjut tentang versi Adam dari stochastic gradient descent, lihat tulisan:
  
−
    Gentle Introduction to the Adam Optimization Algorithm for Deep Learning
+
* [[Keras: Introduction to the Adam Optimization Algorithm]]
  
−
Finally, because it is a classification problem, we will collect and report the classification accuracy, defined via the metrics argument.
+
Akhirnya, karena ini adalah masalah klasifikasi, kita akan mengumpulkan dan melaporkan keakuratan klasifikasi, yang didefinisikan melalui argumen metrik.
  
 
  ...
 
  ...
Line 179: Line 179:
 
==4. Fit Keras Model==
 
==4. Fit Keras Model==
  
−
We have defined our model and compiled it ready for efficient computation.
+
Kita telah mendefinisikan model dan meng-compile-nya agar siap untuk melakukan komputasi yang efisien.
  
−
Now it is time to execute the model on some data.
+
Sekarang saatnya untuk mengeksekusi model pada beberapa data.
  
−
We can train or fit our model on our loaded data by calling the fit() function on the model.
+
Kita dapat men-train atau fit model kita pada data yang dimuat dengan meng-call fungsi fit() pada model.
  
−
Training occurs over epochs and each epoch is split into batches.
+
Training terjadi pada epoch dan setiap epoch dibagi menjadi beberapa batch.
  
−
    Epoch: One pass through all of the rows in the training dataset.
+
* Epoch: Satu pass pada semua baris dalam dataset training.
−
    Batch: One or more samples considered by the model within an epoch before weights are updated.
+
* Batch: Satu atau lebih sampel yang di analisa oleh model dalam epoch sebelum weaight diperbarui.
  
−
One epoch is comprised of one or more batches, based on the chosen batch size and the model is fit for many epochs. For more on the difference between epochs and batches, see the post:
+
Satu epoch terdiri dari satu atau lebih batch, berdasarkan ukuran batch yang dipilih dan model ini cocok untuk banyak epoch. Untuk lebih lanjut tentang perbedaan antara epoch dan batch, lihat posting:
  
−
    What is the Difference Between a Batch and an Epoch in a Neural Network?
+
* [[Keras: Difference Between a Batch and an Epoch]]
  
−
The training process will run for a fixed number of iterations through the dataset called epochs, that we must specify using the epochs argument. We must also set the number of dataset rows that are considered before the model weights are updated within each epoch, called the batch size and set using the batch_size argument.
+
Proses training akan berjalan untuk sejumlah iterasi yang tetap melalui dataset yang disebut epochs, yang harus kita tentukan menggunakan argumen epochs. Kita juga harus mengatur jumlah baris dataset yang dipertimbangkan sebelum weightmodel diperbarui dalam setiap epoch, mengambil ukuran batch dan di-set menggunakan argumen batch_size.
  
−
For this problem, we will run for a small number of epochs (150) and use a relatively small batch size of 10. This means that each epoch will involve (150/10) 15 updates to the model weights.
+
Untuk masalah ini, kita akan menjalakan untuk epoch yang kecil (150) dan menggunakan ukuran batch yang relatif kecil yaitu 10. Ini berarti bahwa setiap epoch akan melibatkan (150/10) 15 pembaruan untuk weight model.
  
−
These configurations can be chosen experimentally by trial and error. We want to train the model enough so that it learns a good (or good enough) mapping of rows of input data to the output classification. The model will always have some error, but the amount of error will level out after some point for a given model configuration. This is called model convergence.
+
Konfigurasi ini dapat dipilih secara eksperimental dengan coba-coba. Kita ingin melatih model cukup sehingga ia dapat belajar memetakan baris input data dengan baik (atau cukup baik) ke klasifikasi output. Model akan selalu memiliki beberapa kesalahan, tetapi jumlah kesalahan akan keluar setelah beberapa titik untuk konfigurasi model yang diberikan. Ini disebut model konvergensi.
  
 
  ...
 
  ...
Line 205: Line 205:
 
  ...
 
  ...
  
−
This is where the work happens on your CPU or GPU.
+
Ini adalah perintah yang menyebabkan pekerjaan terjadi pada CPU atau GPU yang kita gunakan.
  
−
No GPU is required for this example, but if you’re interested in how to run large models on GPU hardware cheaply in the cloud, see this post:
+
Pada contoh ini memang tidak digunakan GPU. Tapi jika kita tertarik untuk menjalankan model yang besar pada GPU hardware dapat menggunakan cloud yang murah seperti Amazon.
−
 
 
−
    How to Setup Amazon AWS EC2 GPUs to Train Keras Deep Learning Models
 
  
 
==5. Evaluate Keras Model==
 
==5. Evaluate Keras Model==
  
−
We have trained our neural network on the entire dataset and we can evaluate the performance of the network on the same dataset.
+
Kita telah men-train neural network kita pada keseluruhan dataset dan kita dapat mengevaluasi kinerja jaringan pada dataset yang sama.
  
−
This will only give us an idea of how well we have modeled the dataset (e.g. train accuracy), but no idea of how well the algorithm might perform on new data. We have done this for simplicity, but ideally, you could separate your data into train and test datasets for training and evaluation of your model.
+
Ini hanya akan memberi kita gambaran tentang seberapa baik kita telah memodelkan dataset (mis. akurasi training), tetapi tidak tahu seberapa baik algoritma dapat bekerja pada data baru. Kita melakukan ini agar sedehana, tetapi idealnya, kita dapat memisahkan data kita ke dalam set data training dan testing untuk men-training dan meng0evaluasi model yang kita gunakan.
  
−
You can evaluate your model on your training dataset using the evaluate() function on your model and pass it the same input and output used to train the model.
+
Kita dapat meng-evaluasi model pada dataset training menggunakan fungsi evaluate() pada model yang kita gunakan dan memberikan input dan output yang sama dengan yang digunakan untuk men-train model.
  
−
This will generate a prediction for each input and output pair and collect scores, including the average loss and any metrics you have configured, such as accuracy.
+
Ini akan menghasilkan prediksi untuk setiap pasangan input dan output dan mengumpulkan skor, termasuk loss rata-rata dan metrik apa pun yang telah kita konfigurasi, seperti akurasi.
  
−
The evaluate() function will return a list with two values. The first will be the loss of the model on the dataset and the second will be the accuracy of the model on the dataset. We are only interested in reporting the accuracy, so we will ignore the loss value.
+
Fungsi evaluate() akan mengembalikan list dengan dua nilai. Yang pertama adalah loss model pada dataset dan yang kedua adalah akurasi model pada dataset. Kita hanya tertarik untuk melaporkan keakuratan, sehingga kami akan mengabaikan nilai loss-nya.
  
 
  ...
 
  ...
Line 227: Line 225:
 
  _, accuracy = model.evaluate(X, y)
 
  _, accuracy = model.evaluate(X, y)
 
  print('Accuracy: %.2f' % (accuracy*100))
 
  print('Accuracy: %.2f' % (accuracy*100))
−
 
  
 
==6. Tie It All Together==
 
==6. Tie It All Together==
  
−
You have just seen how you can easily create your first neural network model in Keras.
+
Kita baru saja melihat bagaimana kita dapat dengan mudah membuat model neural network pertama kita di Keras.
  
−
Let’s tie it all together into a complete code example.
+
Mari ikat semuanya menjadi contoh kode lengkap.
  
 
  # first neural network with keras tutorial
 
  # first neural network with keras tutorial
Line 257: Line 254:
 
  print('Accuracy: %.2f' % (accuracy*100))
 
  print('Accuracy: %.2f' % (accuracy*100))
  
−
You can copy all of the code into your Python file and save it as “keras_first_network.py” in the same directory as your data file “pima-indians-diabetes.csv“. You can then run the Python file as a script from your command line (command prompt) as follows:
+
Kita dapat menyalin semua kode ke file Python dan menyimpannya sebagai "keras_first_network.py" di direktori yang sama dengan file data "pima-indians-diabetes.csv". Kita kemudian dapat menjalankan file Python sebagai skrip dari command line (command prompt) sebagai berikut:
  
 
  python keras_first_network.py
 
  python keras_first_network.py
  
 +
Menjalankan contoh ini, kita akan melihat pesan untuk masing-masing dari 150 epoch yang mencetak loss dan accuracy, diikuti dengan evaluasi akhir dari model yang di-train pada dataset training.
  
−
Running this example, you should see a message for each of the 150 epochs printing the loss and accuracy, followed by the final evaluation of the trained model on the training dataset.
+
Idealnya, kita ingin loss menjadi nol dan accuracy menjadi 1,0 (mis. 100%). Ini tidak mungkin untuk problem machine learning yang paling sederhana sekalipun. Sebaliknya, kita akan selalu memiliki beberapa kesalahan dalam model yang kita gunakan. Tujuannya adalah untuk memilih konfigurasi model dan konfigurasi pelatihan yang mencapai loss terendah dan akurasi setinggi mungkin untuk dataset yang diberikan.
−
 
 
−
It takes about 10 seconds to execute on my workstation running on the CPU.
 
−
 
 
−
Ideally, we would like the loss to go to zero and accuracy to go to 1.0 (e.g. 100%). This is not possible for any but the most trivial machine learning problems. Instead, we will always have some error in our model. The goal is to choose a model configuration and training configuration that achieve the lowest loss and highest accuracy possible for a given dataset.
 
  
 
  ...
 
  ...
Line 281: Line 275:
 
  Accuracy: 76.56
 
  Accuracy: 76.56
  
 +
Catatan, bagi mereka yang menjalankan contoh ini menggunakan IPython atau Jupyter notebook kemungkinan akan mendapat error.
  
−
Note, if you try running this example in an IPython or Jupyter notebook you may get an error.
+
Ini karena ada progress bar saat training. Kita dapat dengan mudah mematikannya dengan mengatur verbose=0 saat call ke fungsi fit() dan  fungsi evaluasi(), misalnya:
  
−
The reason is the output progress bars during training. You can easily turn these off by setting verbose=0 in the call to the fit() and evaluate() functions, for example:
 
 
  ...
 
  ...
 
  # fit the keras model on the dataset without progress bars
 
  # fit the keras model on the dataset without progress bars
Line 292: Line 286:
 
  ...
 
  ...
  
 +
Perhatikan, akurasi model anda akan bervariasi.
  
−
Note, the accuracy of your model will vary.
+
Neural network adalah algoritma stokastik, yang berarti bahwa algoritma yang sama pada data yang sama dapat melatih model yang berbeda dengan kemampuan yang berbeda setiap kali kode dijalankan. Ini adalah fitur, bukan bug. Kita dapat mempelajari lebih lanjut tentang ini di tulisan:
  
−
Neural networks are a stochastic algorithm, meaning that the same algorithm on the same data can train a different model with different skill each time the code is run. This is a feature, not a bug. You can learn more about this in the post:
+
* [[Keras: Embrace Randomness]]
  
−
    Embrace Randomness in Machine Learning
+
Varian dalam kinerja model berarti bahwa untuk mendapatkan perkiraan yang masuk akal tentang seberapa baik kinerja model, kita mungkin perlu menyesuaikannya berkali-kali dan menghitung rata-rata skor akurasi. Untuk lebih lanjut tentang pendekatan ini untuk meng-evaluasi neural network, lihat posting:
  
−
The variance in the performance of the model means that to get a reasonable approximation of how well your model is performing, you may need to fit it many times and calculate the average of the accuracy scores. For more on this approach to evaluating neural networks, see the post:
 
  
−
    How to Evaluate the Skill of Deep Learning Models
+
* [[Keras: Evaluate the Skill of Deep Learning Model]]
  
−
For example, below are the accuracy scores from re-running the example 5 times:
+
Misalnya, di bawah ini adalah skor akurasi dari re-run contoh 5 kali:
  
 
  Accuracy: 75.00
 
  Accuracy: 75.00
Line 311: Line 305:
 
  Accuracy: 76.17
 
  Accuracy: 76.17
  
 +
Kita dapat melihat bahwa semua skor akurasi sekitar 77% dan rata-rata 76,924%.
  
−
We can see that all accuracy scores are around 77% and the average is 76.924%.
+
==7. Make Prediction==
  
−
==7. Make Predictions==
+
Pertanyaan pertama yang biasanya akan kita tanyakan adalah "Setelah kita men-train model, bagaimana kita bisa menggunakan-nya untuk melakukan prediksi pada data baru?"
  
−
The number one question I get asked is:
+
Pertanyaan yang baik.
  
−
    After I train my model, how can I use it to make predictions on new data?
+
Kita dapat mengadaptasi contoh di atas dan menggunakannya untuk menghasilkan prediksi pada dataset training, menganggapnya sebagai dataset baru yang belum kita lihat sebelumnya.
  
−
Great question.
+
Membuat prediksi semudah memanggil fungsi predict() pada model. Kita menggunakan fungsi aktivasi sigmoid pada layer output, sehingga prediksi akan menjadi probabilitas dalam kisaran antara 0 dan 1. Kita dapat dengan mudah mengubahnya menjadi prediksi biner yang tajam untuk tugas klasifikasi ini dengan membulatkannya.
  
−
We can adapt the above example and use it to generate predictions on the training dataset, pretending it is a new dataset we have not seen before.
+
Contoh:
−
 
 
−
Making predictions is as easy as calling the predict() function on the model. We are using a sigmoid activation function on the output layer, so the predictions will be a probability in the range between 0 and 1. We can easily convert them into a crisp binary prediction for this classification task by rounding them.
 
−
 
 
−
For example:
 
  
 
  ...
 
  ...
Line 335: Line 326:
  
  
−
Alternately, we can call the predict_classes() function on the model to predict crisp classes directly, for example:
+
Sebagai alternatif, kita dapat memanggil fungsi predict_classes() pada model untuk memprediksi class secara langsung, misalnya:
  
 
  ...
 
  ...
Line 341: Line 332:
 
  predictions = model.predict_classes(X)
 
  predictions = model.predict_classes(X)
  
−
 
+
Contoh lengkap di bawah ini membuat prediksi untuk setiap contoh dalam dataset, lalu mencetak data input, prediksi class dan class yang diharapkan untuk 5 contoh pertama dalam dataset.
−
The complete example below makes predictions for each example in the dataset, then prints the input data, predicted class and expected class for the first 5 examples in the dataset.
 
  
 
  # first neural network with keras make predictions
 
  # first neural network with keras make predictions
Line 366: Line 356:
 
  # summarize the first 5 cases
 
  # summarize the first 5 cases
 
  for i in range(5):
 
  for i in range(5):
−
print('%s => %d (expected %d)' % (X[i].tolist(), predictions[i], y[i]))
+
print('%s => %d (expected %d)' % (X[i].tolist(), predictions[i], y[i]))
  
−
Running the example does not show the progress bar as before as we have set the verbose argument to 0.
+
Menjalankan contoh tidak menunjukkan progress bar seperti sebelumnya karena kita telah men-set argumen verbose menjadi 0.
  
−
After the model is fit, predictions are made for all examples in the dataset, and the input rows and predicted class value for the first 5 examples is printed and compared to the expected class value.
+
Setelah model fit, prediksi dibuat untuk semua contoh dalam dataset, dan baris input dan nilai class yang prediksi untuk 5 contoh pertama dicetak dan dibandingkan dengan nilai class yang diharapkan.
  
−
We can see that most rows are correctly predicted. In fact, we would expect about 76.9% of the rows to be correctly predicted based on our estimated performance of the model in the previous section.
+
Kita dapat melihat bahwa sebagian besar baris diprediksi dengan benar. Bahkan, kita berharap sekitar 76,9% dari baris akan diprediksi dengan benar berdasarkan perkiraan kinerja model kita di bagian sebelumnya.
  
 
  [6.0, 148.0, 72.0, 35.0, 0.0, 33.6, 0.627, 50.0] => 0 (expected 1)
 
  [6.0, 148.0, 72.0, 35.0, 0.0, 33.6, 0.627, 50.0] => 0 (expected 1)
Line 380: Line 370:
 
  [0.0, 137.0, 40.0, 35.0, 168.0, 43.1, 2.288, 33.0] => 1 (expected 1)
 
  [0.0, 137.0, 40.0, 35.0, 168.0, 43.1, 2.288, 33.0] => 1 (expected 1)
  
−
If you would like to know more about how to make predictions with Keras models, see the post:
+
Jika anda ingin tahu lebih banyak tentang cara membuat prediksi dengan model Keras, lihat tulisan:
−
 
 
−
    How to Make Predictions with Keras
 
−
 
 
−
==Keras Tutorial Summary==
 
−
 
 
−
In this post, you discovered how to create your first neural network model using the powerful Keras Python library for deep learning.
 
−
 
 
−
Specifically, you learned the six key steps in using Keras to create a neural network or deep learning model, step-by-step including:
 
−
 
 
−
* How to load data.
 
−
* How to define a neural network in Keras.
 
−
* How to compile a Keras model using the efficient numerical backend.
 
−
* How to train a model on data.
 
−
* How to evaluate a model on data.
 
−
* How to make predictions with the model.
 
−
 
 
−
==Keras Tutorial Extensions==
 
−
 
 
−
Well done, you have successfully developed your first neural network using the Keras deep learning library in Python.
 
−
 
 
−
This section provides some extensions to this tutorial that you might want to explore.
 
−
 
 
−
    Tune the Model. Change the configuration of the model or training process and see if you can improve the performance of the model, e.g. achieve better than 76% accuracy.
 
−
    Save the Model. Update the tutorial to save the model to file, then load it later and use it to make predictions (see this tutorial).
 
−
    Summarize the Model. Update the tutorial to summarize the model and create a plot of model layers (see this tutorial).
 
−
    Separate Train and Test Datasets. Split the loaded dataset into a train and test set (split based on rows) and use one set to train the model and the other set to estimate the performance of the model on new data.
 
−
    Plot Learning Curves. The fit() function returns a history object that summarizes the loss and accuracy at the end of each epoch. Create line plots of this data, called learning curves (see this tutorial).
 
−
    Learn a New Dataset. Update the tutorial to use a different tabular dataset, perhaps from the UCI Machine Learning Repository.
 
−
    Use Functional API. Update the tutorial to use the Keras Functional API for defining the model (see this tutorial).
 
−
 
 
−
 
 
  
 +
* [[Keras: Prediction]]
  
 +
==Summary==
  
 +
Dalam posting ini, kita menemukan cara membuat model neural network pertama kita menggunakan library Python Keras yang powerful untuk deep learning.
  
 +
Secara khusus, kita mempelajari enam langkah utama dalam menggunakan Keras untuk membuat neural network atau model deep learning, langkah-demi-langkah termasuk:
  
 +
* Cara load data.
 +
* Cara men-definisikan neural network di Keras.
 +
* Cara men-compile Keras model menggunakan numerical backend yang effisien.
 +
* Cara men-train model pada data.
 +
* Cara meng-evaluate model pada data.
 +
* Cara membuat prediction dengan model.
  
 
==Referensi==
 
==Referensi==

Latest revision as of 09:13, 19 August 2019

Sumber: https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/

Keras adalah library Python open source free yang powerful dan mudah digunakan untuk mengembangkan dan mengevaluasi model deep learning.

Ini membungkus library perhitungan numerik yang efisien Theano dan TensorFlow dan memungkinkan kita untuk mendefinisikan dan melatih model neural network hanya dalam beberapa baris kode.

Dalam tutorial ini, kita akan menemukan cara membuat model neural network deep learning pertama dalam Python menggunakan Keras.


Keras Tutorial Overview

Tidak ada banyak kode yang diperlukan, tetapi kita akan melangkah perlahan-lahan sehingga kita akan tahu cara membuat model sendiri di masa depan.

Langkah-langkah yang akan kita bahas dalam tutorial ini adalah sebagai berikut:

  • Load Data.
  • Define Keras Model.
  • Compile Keras Model.
  • Fit Keras Model.
  • Evaluate Keras Model.
  • Tie It All Together.
  • Make Predictions

Kebutuhan untuk bisa menjalankan tutorial:

  • Python 2 atau 3
  • SciPy (termasuk NumPy)
  • Keras dan backend (Theano atau TensorFlow)

Selanjutnya kita dapat membuat file baru, misalnya, 

keras_first_network.py

dan copy paste code ke file sambil kita jalan.

1. Load Data

Langkah pertama adalah mendefinisikan fungsi dan kelas yang ingin kita gunakan dalam tutorial ini.

Kita akan menggunakan library NumPy untuk memuat dataset kita dan kita akan menggunakan dua kelas dari library Keras untuk mendefinisikan model kita.

Import yang dibibutuhkan tampak pada daftar di bawah ini, 

# first neural network with keras tutorial
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense
...

Kita sekarang dapat memuat dataset kita.

Dalam tutorial Keras ini, kita akan menggunakan dataset diabetes Pima Indian. Ini adalah dataset standar machine learning dari repositori UCI Machine Learning. Ini menggambarkan data rekam medis pasien untuk orang India Pima dan apakah mereka memiliki diabetes dalam lima tahun.

Dengan apa adanya, ini adalah masalah klasifikasi biner (dengan diabetes 1 atau tidak 0). Semua variabel input yang menggambarkan setiap pasien adalah numerik. Ini membuatnya mudah digunakan secara langsung dengan neural network yang mengharapkan input numerik dan nilai output, dan ideal untuk neural network kita yang pertama di Keras.

Dataset kita tersedia dari sini:

Download dataset dan letakkan di direktori kerja lokal anda, lokasi yang sama dengan file python anda. Save dan beri nama filename: 

pima-indians-diabetes.csv

Lihatlah di dalam file, kita akan melihat deretan data seperti berikut: 

6,148,72,35,0,33.6,0.627,50,1
1,85,66,29,0,26.6,0.351,31,0
8,183,64,0,0,23.3,0.672,32,1
1,89,66,23,94,28.1,0.167,21,0
0,137,40,35,168,43.1,2.288,33,1
...

Kita dapat me-load file sebagai matrix menggunakan NumPy function loadtxt().

Ada delapan variabel input dan satu variabel output (kolom terakhir). Kita akan mempelajari sebuah model untuk memetakan baris variabel input (X) ke variabel output (y), yang sering kita ringkas sebagai y = f (X).

Variabel dapat diringkas sebagai berikut:

Variable Input (X):

  • Berapa kali hamil
  • Konsentrasi Plasma glucose dalam 2 jam dalam oral glucose tolerance test
  • Diastolic blood pressure (mm Hg)
  • Triceps skin fold thickness (mm)
  • 2-Hour serum insulin (mu U/ml)
  • Body mass index (weight in kg/(height in m)^2)
  • Diabetes pedigree function
  • Umur (Tahun)

Variable Output (y):

  • Class variable (0 atau 1)

Setelah file CSV dimuat ke dalam memori, kita dapat membagi kolom data menjadi variabel input dan output.

Data akan disimpan dalam array 2D di mana dimensi pertama adalah baris dan dimensi kedua adalah kolom, mis. [baris, kolom].

Kita dapat membagi array menjadi dua array dengan memilih subset kolom menggunakan operator slice NumPy standar atau “:” Kita dapat memilih 8 kolom pertama dari indeks 0 hingga indeks 7 melalui slice 0:8. Kita kemudian dapat memilih kolom output (variabel ke-9) melalui indeks 8. 

...
# load the dataset
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=',')
# split into input (X) and output (y) variables
X = dataset[:,0:8]
y = dataset[:,8]
...

Kita sekarang siap untuk mendefinisikan model neural network kita.

Catatan, dataset memiliki 9 kolom dan kisaran 0:8 akan memilih kolom dari 0 hingga 7, berhenti sebelum indeks 8. Jika ini baru bagi anda, maka anda dapat mempelajari lebih lanjut tentang pengirisan array dan rentang dalam:

2. Define Keras Model

Model dalam Keras didefinisikan sebagai urutan lapisan.

Kita membuat model Sequential dan menambahkan layer satu per satu sampai kita puas dengan arsitektur network yang kita buat.

Hal pertama yang harus dilakukan adalah memastikan layer input memiliki jumlah fitur input yang tepat. Ini dapat ditentukan saat membuat layer pertama dengan argumen input_dim dan, misalnya, men-set menjadi 8 untuk 8 variabel input.

Bagaimana kita mengetahui jumlah lapisan dan jenisnya?

Ini pertanyaan yang sangat sulit. Setelah melalui proses trial dan experimen / percobaan panjang kita akan menemukan struktur network yang terbaik. Secara umum, kita memerlukan network yang cukup besar untuk menangkap struktur masalah.

Dalam contoh ini, kita akan menggunakan fully-connected network structure dengan tiga layer.

Fully connected layer di definisikan dengan menggunakan Dense class. Kita dapat menentukan jumlah neuron atau node di lapisan sebagai argumen pertama, dan menentukan fungsi aktivasi menggunakan argumen aktivasi.

We will use the rectified linear unit activation function referred to as ReLU on the first two layers and the Sigmoid function in the output layer.

Pada masa lalu fungsi aktivasi Sigmoid dan Tanh lebih disukai untuk semua lapisan. Saat ini, kinerja yang lebih baik dicapai menggunakan fungsi aktivasi ReLU. Kita menggunakan sigmoid pada layer output untuk memastikan output jaringan kami antara 0 dan 1 dan mudah dipetakan ke probabilitas class 1 atau snap ke klasifikasi keras dari kedua kelas dengan ambang batas standar 0,5.

Kita dapat menyatukan semuanya dengan menambahkan setiap layer:

  • Model mengharapkan deretan data dengan 8 variabel (argumen input_dim = 8)
  • Lapisan hidden pertama memiliki 12 node dan menggunakan fungsi aktivasi relu.
  • Lapisan hidden kedua memiliki 8 node dan menggunakan fungsi aktivasi relu.
  • Lapisan output memiliki satu node dan menggunakan fungsi aktivasi sigmoid.
...
# define the keras model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
...


Catatan, hal yang paling membingungkan di sini adalah bahwa bentuk input ke model didefinisikan sebagai argumen pada lapisan hidden pertama. Ini berarti bahwa baris kode yang menambahkan Dense Layer melakukan 2 hal, menentukan input atau lapisan yang terlihat dan lapisan hidden pertama.

3. Compile Keras Model

Sekarang model sudah didefinisikan, kita bisa meng-compile-nya.

Meng-compile model menggunakan library numerik yang efisien di belakang layar (yang disebut backend) seperti Theano atau TensorFlow. Backend secara otomatis memilih cara terbaik untuk me-representasikan network untuk training dan membuat prediksi untuk berjalan pada perangkat keras kita, seperti CPU atau GPU atau bahkan terdistribusi.

Saat mengkompilasi, kita harus menentukan beberapa properti tambahan yang diperlukan saat men-train network. Ingat network training berarti menemukan set weight terbaik untuk memetakan input ke output dalam dataset yang kita miliki.

Kita harus menentukan fungsi loss yang digunakan untuk mengevaluasi satu set weight, optimizer digunakan untuk mencari berbagai weight untuk network dan metrik opsional yang ingin kita kumpulkan dan laporkan selama pelatihan.

Dalam hal ini, kita akan menggunakan cross entropy sebagai argumen loss. Loss ini untuk masalah klasifikasi biner dan didefinisikan dalam Keras sebagai "binary_crossentropy". Kita dapat mempelajari lebih lanjut tentang memilih fungsi loss berdasarkan masalah kita di sini:

Kita akan mendefinisikan optimizer sebagai algoritma stochastic gradient descent yang efisien "adam". Ini adalah versi populer dari gradient descent karena secara otomatis men-tune diri sendiri dan memberikan hasil yang baik dalam berbagai masalah. Untuk mempelajari lebih lanjut tentang versi Adam dari stochastic gradient descent, lihat tulisan:

Akhirnya, karena ini adalah masalah klasifikasi, kita akan mengumpulkan dan melaporkan keakuratan klasifikasi, yang didefinisikan melalui argumen metrik. 

...
# compile the keras model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
...

4. Fit Keras Model

Kita telah mendefinisikan model dan meng-compile-nya agar siap untuk melakukan komputasi yang efisien.

Sekarang saatnya untuk mengeksekusi model pada beberapa data.

Kita dapat men-train atau fit model kita pada data yang dimuat dengan meng-call fungsi fit() pada model.

Training terjadi pada epoch dan setiap epoch dibagi menjadi beberapa batch.

  • Epoch: Satu pass pada semua baris dalam dataset training.
  • Batch: Satu atau lebih sampel yang di analisa oleh model dalam epoch sebelum weaight diperbarui.

Satu epoch terdiri dari satu atau lebih batch, berdasarkan ukuran batch yang dipilih dan model ini cocok untuk banyak epoch. Untuk lebih lanjut tentang perbedaan antara epoch dan batch, lihat posting:

Proses training akan berjalan untuk sejumlah iterasi yang tetap melalui dataset yang disebut epochs, yang harus kita tentukan menggunakan argumen epochs. Kita juga harus mengatur jumlah baris dataset yang dipertimbangkan sebelum weightmodel diperbarui dalam setiap epoch, mengambil ukuran batch dan di-set menggunakan argumen batch_size.

Untuk masalah ini, kita akan menjalakan untuk epoch yang kecil (150) dan menggunakan ukuran batch yang relatif kecil yaitu 10. Ini berarti bahwa setiap epoch akan melibatkan (150/10) 15 pembaruan untuk weight model.

Konfigurasi ini dapat dipilih secara eksperimental dengan coba-coba. Kita ingin melatih model cukup sehingga ia dapat belajar memetakan baris input data dengan baik (atau cukup baik) ke klasifikasi output. Model akan selalu memiliki beberapa kesalahan, tetapi jumlah kesalahan akan keluar setelah beberapa titik untuk konfigurasi model yang diberikan. Ini disebut model konvergensi. 

...
# fit the keras model on the dataset
model.fit(X, y, epochs=150, batch_size=10)
...

Ini adalah perintah yang menyebabkan pekerjaan terjadi pada CPU atau GPU yang kita gunakan.

Pada contoh ini memang tidak digunakan GPU. Tapi jika kita tertarik untuk menjalankan model yang besar pada GPU hardware dapat menggunakan cloud yang murah seperti Amazon.

5. Evaluate Keras Model

Kita telah men-train neural network kita pada keseluruhan dataset dan kita dapat mengevaluasi kinerja jaringan pada dataset yang sama.

Ini hanya akan memberi kita gambaran tentang seberapa baik kita telah memodelkan dataset (mis. akurasi training), tetapi tidak tahu seberapa baik algoritma dapat bekerja pada data baru. Kita melakukan ini agar sedehana, tetapi idealnya, kita dapat memisahkan data kita ke dalam set data training dan testing untuk men-training dan meng0evaluasi model yang kita gunakan.

Kita dapat meng-evaluasi model pada dataset training menggunakan fungsi evaluate() pada model yang kita gunakan dan memberikan input dan output yang sama dengan yang digunakan untuk men-train model.

Ini akan menghasilkan prediksi untuk setiap pasangan input dan output dan mengumpulkan skor, termasuk loss rata-rata dan metrik apa pun yang telah kita konfigurasi, seperti akurasi.

Fungsi evaluate() akan mengembalikan list dengan dua nilai. Yang pertama adalah loss model pada dataset dan yang kedua adalah akurasi model pada dataset. Kita hanya tertarik untuk melaporkan keakuratan, sehingga kami akan mengabaikan nilai loss-nya. 

...
# evaluate the keras model
_, accuracy = model.evaluate(X, y)
print('Accuracy: %.2f' % (accuracy*100))

6. Tie It All Together

Kita baru saja melihat bagaimana kita dapat dengan mudah membuat model neural network pertama kita di Keras.

Mari ikat semuanya menjadi contoh kode lengkap. 

# first neural network with keras tutorial
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense
# load the dataset
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=',')
# split into input (X) and output (y) variables
X = dataset[:,0:8]
y = dataset[:,8]
# define the keras model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# compile the keras model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# fit the keras model on the dataset
model.fit(X, y, epochs=150, batch_size=10)
# evaluate the keras model
_, accuracy = model.evaluate(X, y)
print('Accuracy: %.2f' % (accuracy*100))

Kita dapat menyalin semua kode ke file Python dan menyimpannya sebagai "keras_first_network.py" di direktori yang sama dengan file data "pima-indians-diabetes.csv". Kita kemudian dapat menjalankan file Python sebagai skrip dari command line (command prompt) sebagai berikut: 

python keras_first_network.py

Menjalankan contoh ini, kita akan melihat pesan untuk masing-masing dari 150 epoch yang mencetak loss dan accuracy, diikuti dengan evaluasi akhir dari model yang di-train pada dataset training.

Idealnya, kita ingin loss menjadi nol dan accuracy menjadi 1,0 (mis. 100%). Ini tidak mungkin untuk problem machine learning yang paling sederhana sekalipun. Sebaliknya, kita akan selalu memiliki beberapa kesalahan dalam model yang kita gunakan. Tujuannya adalah untuk memilih konfigurasi model dan konfigurasi pelatihan yang mencapai loss terendah dan akurasi setinggi mungkin untuk dataset yang diberikan. 

...
768/768 [==============================] - 0s 63us/step - loss: 0.4817 - acc: 0.7708
Epoch 147/150
768/768 [==============================] - 0s 63us/step - loss: 0.4764 - acc: 0.7747
Epoch 148/150
768/768 [==============================] - 0s 63us/step - loss: 0.4737 - acc: 0.7682
Epoch 149/150
768/768 [==============================] - 0s 64us/step - loss: 0.4730 - acc: 0.7747
Epoch 150/150
768/768 [==============================] - 0s 63us/step - loss: 0.4754 - acc: 0.7799
768/768 [==============================] - 0s 38us/step
Accuracy: 76.56

Catatan, bagi mereka yang menjalankan contoh ini menggunakan IPython atau Jupyter notebook kemungkinan akan mendapat error.

Ini karena ada progress bar saat training. Kita dapat dengan mudah mematikannya dengan mengatur verbose=0 saat call ke fungsi fit() dan fungsi evaluasi(), misalnya: 

...
# fit the keras model on the dataset without progress bars
model.fit(X, y, epochs=150, batch_size=10, verbose=0)
# evaluate the keras model
_, accuracy = model.evaluate(X, y, verbose=0)
...

Perhatikan, akurasi model anda akan bervariasi.

Neural network adalah algoritma stokastik, yang berarti bahwa algoritma yang sama pada data yang sama dapat melatih model yang berbeda dengan kemampuan yang berbeda setiap kali kode dijalankan. Ini adalah fitur, bukan bug. Kita dapat mempelajari lebih lanjut tentang ini di tulisan:

Varian dalam kinerja model berarti bahwa untuk mendapatkan perkiraan yang masuk akal tentang seberapa baik kinerja model, kita mungkin perlu menyesuaikannya berkali-kali dan menghitung rata-rata skor akurasi. Untuk lebih lanjut tentang pendekatan ini untuk meng-evaluasi neural network, lihat posting:


Misalnya, di bawah ini adalah skor akurasi dari re-run contoh 5 kali: 

Accuracy: 75.00
Accuracy: 77.73
Accuracy: 77.60
Accuracy: 78.12
Accuracy: 76.17

Kita dapat melihat bahwa semua skor akurasi sekitar 77% dan rata-rata 76,924%.

7. Make Prediction

Pertanyaan pertama yang biasanya akan kita tanyakan adalah "Setelah kita men-train model, bagaimana kita bisa menggunakan-nya untuk melakukan prediksi pada data baru?"

Pertanyaan yang baik.

Kita dapat mengadaptasi contoh di atas dan menggunakannya untuk menghasilkan prediksi pada dataset training, menganggapnya sebagai dataset baru yang belum kita lihat sebelumnya.

Membuat prediksi semudah memanggil fungsi predict() pada model. Kita menggunakan fungsi aktivasi sigmoid pada layer output, sehingga prediksi akan menjadi probabilitas dalam kisaran antara 0 dan 1. Kita dapat dengan mudah mengubahnya menjadi prediksi biner yang tajam untuk tugas klasifikasi ini dengan membulatkannya.

Contoh: 

...
# make probability predictions with the model
predictions = model.predict(X)
# round predictions 
rounded = [round(x[0]) for x in predictions]


Sebagai alternatif, kita dapat memanggil fungsi predict_classes() pada model untuk memprediksi class secara langsung, misalnya: 

...
# make class predictions with the model
predictions = model.predict_classes(X)

Contoh lengkap di bawah ini membuat prediksi untuk setiap contoh dalam dataset, lalu mencetak data input, prediksi class dan class yang diharapkan untuk 5 contoh pertama dalam dataset. 

# first neural network with keras make predictions
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense
# load the dataset
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=',')
# split into input (X) and output (y) variables
X = dataset[:,0:8]
y = dataset[:,8]
# define the keras model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# compile the keras model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# fit the keras model on the dataset
model.fit(X, y, epochs=150, batch_size=10, verbose=0)
# make class predictions with the model
predictions = model.predict_classes(X)
# summarize the first 5 cases
for i in range(5):
	 print('%s => %d (expected %d)' % (X[i].tolist(), predictions[i], y[i]))

Menjalankan contoh tidak menunjukkan progress bar seperti sebelumnya karena kita telah men-set argumen verbose menjadi 0.

Setelah model fit, prediksi dibuat untuk semua contoh dalam dataset, dan baris input dan nilai class yang prediksi untuk 5 contoh pertama dicetak dan dibandingkan dengan nilai class yang diharapkan.

Kita dapat melihat bahwa sebagian besar baris diprediksi dengan benar. Bahkan, kita berharap sekitar 76,9% dari baris akan diprediksi dengan benar berdasarkan perkiraan kinerja model kita di bagian sebelumnya. 

[6.0, 148.0, 72.0, 35.0, 0.0, 33.6, 0.627, 50.0] => 0 (expected 1)
[1.0, 85.0, 66.0, 29.0, 0.0, 26.6, 0.351, 31.0] => 0 (expected 0)
[8.0, 183.0, 64.0, 0.0, 0.0, 23.3, 0.672, 32.0] => 1 (expected 1)
[1.0, 89.0, 66.0, 23.0, 94.0, 28.1, 0.167, 21.0] => 0 (expected 0)
[0.0, 137.0, 40.0, 35.0, 168.0, 43.1, 2.288, 33.0] => 1 (expected 1)

Jika anda ingin tahu lebih banyak tentang cara membuat prediksi dengan model Keras, lihat tulisan:

Summary

Dalam posting ini, kita menemukan cara membuat model neural network pertama kita menggunakan library Python Keras yang powerful untuk deep learning.

Secara khusus, kita mempelajari enam langkah utama dalam menggunakan Keras untuk membuat neural network atau model deep learning, langkah-demi-langkah termasuk:

  • Cara load data.
  • Cara men-definisikan neural network di Keras.
  • Cara men-compile Keras model menggunakan numerical backend yang effisien.
  • Cara men-train model pada data.
  • Cara meng-evaluate model pada data.
  • Cara membuat prediction dengan model.

Referensi

Pranala Menarik

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=Keras:_Develop_Your_First_Neural_Network_in_Python_Step-By-Step&oldid=56887"