1. Giriş
Bu codelab'de, bir grup arabayı açıklayan sayısal verilerden tahminler yapmak için bir modeli eğiteceksiniz.
Bu alıştırmada, birçok farklı model türünü eğitirken kullanılan ortak adımlar gösterilecek ancak küçük bir veri kümesi ve basit (sığ) bir model kullanılacak. Bu kursun temel amacı, TensorFlow.js ile modelleri eğitme konusundaki temel terminoloji, kavram ve söz dizimi hakkında bilgi edinmenize yardımcı olmak ve daha fazla keşif ve öğrenme için bir başlangıç noktası sağlamaktır.
Sürekli sayıları tahmin etmek için bir model eğittiğimizden bu görev bazen regresyon görevi olarak da adlandırılır. Modele doğru çıkışla birlikte birçok giriş örneği göstererek modeli eğitiriz. Bu duruma denetimli öğrenme denir.
Ne oluşturacaksınız?
Tarayıcıda bir modeli eğitmek için TensorFlow.js'yi kullanan bir web sayfası oluşturacaksınız. Bir arabanın "Beygir Gücü" verildiğinde model, "Galon Başına Mil" (MPG) değerini tahmin etmeyi öğrenir.
Bunu yapmak için:
- Verileri yükleyin ve eğitime hazırlayın.
- Modelin mimarisini tanımlayın.
- Modeli eğitin ve eğitim sırasında performansını izleyin.
- Bazı tahminler yaparak eğitilmiş modeli değerlendirin.
Neler öğreneceksiniz?
- Karıştırma ve normalleştirme dahil olmak üzere makine öğrenimi için veri hazırlamayla ilgili en iyi uygulamalar.
- tf.layers API'yi kullanarak model oluşturmaya yönelik TensorFlow.js söz dizimi.
- tfjs-vis kitaplığını kullanarak tarayıcı içi eğitimi izleme
İhtiyacınız olanlar
- Chrome'un veya başka bir modern tarayıcının son sürümü
- Makinenizde yerel olarak veya web'de Codepen ya da Glitch gibi bir araç üzerinden çalışan bir metin düzenleyici.
- HTML, CSS, JavaScript ve Chrome Geliştirici Araçları (veya tercih ettiğiniz tarayıcıların geliştirici araçları) hakkında bilgi sahibi olmak
- Nöral ağlar hakkında üst düzey kavramsal bilgi Giriş veya hatırlatma için 3blue1brown'un bu videosunu ya da Ashi Krishnan'ın JavaScript'te Derin Öğrenme videosunu izleyebilirsiniz.
2. Hazırlanın
HTML sayfası oluşturma ve JavaScript'i ekleme
Aşağıdaki kodu
index.html
<!DOCTYPE html>
<html>
<head>
<title>TensorFlow.js Tutorial</title>
<!-- Import TensorFlow.js -->
<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@2.0.0/dist/tf.min.js"></script>
<!-- Import tfjs-vis -->
<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-vis@1.0.2/dist/tfjs-vis.umd.min.js"></script>
</head>
<body>
<!-- Import the main script file -->
<script src="script.js"></script>
</body>
</html>
Kod için JavaScript dosyasını oluşturun.
- Yukarıdaki HTML dosyasıyla aynı klasörde script.js adlı bir dosya oluşturun ve içine aşağıdaki kodu yerleştirin.
console.log('Hello TensorFlow');
Test edin
HTML ve JavaScript dosyalarını oluşturduğunuza göre bunları test edin. Tarayıcınızda index.html dosyasını ve geliştirici araçları konsolunu açın.
Her şey çalışıyorsa geliştirici araçları konsolunda iki genel değişken oluşturulmuş ve kullanılabilir olmalıdır:
tf, TensorFlow.js kitaplığına yapılan bir referanstır.tfvis, tfjs-vis kitaplığına yapılan bir referanstır.
Tarayıcınızın geliştirici araçlarını açın. Konsol çıkışında Hello TensorFlow mesajını görmeniz gerekir. Bu durumda, bir sonraki adıma geçebilirsiniz.
3. Giriş verilerini yükleme, biçimlendirme ve görselleştirme
İlk adım olarak, modeli eğitmek istediğimiz verileri yükleyelim, biçimlendirelim ve görselleştirelim.
Sizin için barındırdığımız bir JSON dosyasından "arabalar" veri kümesini yükleyeceğiz. Her bir otomobille ilgili birçok farklı özellik içerir. Bu eğitimde yalnızca beygir gücü ve galon başına mil ile ilgili verileri çıkarmak istiyoruz.
Aşağıdaki kodu
script.js dosya
/**
* Get the car data reduced to just the variables we are interested
* and cleaned of missing data.
*/
async function getData() {
const carsDataResponse = await fetch('https://storage.googleapis.com/tfjs-tutorials/carsData.json');
const carsData = await carsDataResponse.json();
const cleaned = carsData.map(car => ({
mpg: car.Miles_per_Gallon,
horsepower: car.Horsepower,
}))
.filter(car => (car.mpg != null && car.horsepower != null));
return cleaned;
}
Bu işlem, galon başına mil veya beygir gücü tanımlanmamış girişleri de kaldırır. Bu verileri nasıl göründüğünü görmek için saçılım grafiğinde de çizelim.
Aşağıdaki kodu
script.js file.
async function run() {
// Load and plot the original input data that we are going to train on.
const data = await getData();
const values = data.map(d => ({
x: d.horsepower,
y: d.mpg,
}));
tfvis.render.scatterplot(
{name: 'Horsepower v MPG'},
{values},
{
xLabel: 'Horsepower',
yLabel: 'MPG',
height: 300
}
);
// More code will be added below
}
document.addEventListener('DOMContentLoaded', run);
Sayfayı yenilediğinizde Sayfanın sol tarafında, verilerin dağılım grafiğini içeren bir panel görürsünüz. Şuna benzer bir görünümde olacaktır.
Bu panel, vizör olarak bilinir ve tfjs-vis tarafından sağlanır. Görselleştirmeleri görüntülemek için uygun bir yer sağlar.
Genellikle verilerle çalışırken verilerinize göz atmanın ve gerekirse temizlemenin yollarını bulmak iyi bir fikirdir. Bu durumda, gerekli tüm alanları içermeyen belirli girişleri carsData öğesinden kaldırmamız gerekti. Verileri görselleştirmek, modelin öğrenebileceği bir yapı olup olmadığını anlamamıza yardımcı olabilir.
Yukarıdaki grafikten, beygir gücü ile MPG arasında negatif bir korelasyon olduğu anlaşılıyor. Yani beygir gücü arttıkça arabalar genellikle galon başına daha az mil kat ediyor.
Görevimizi kavramsallaştırma
Giriş verilerimiz artık aşağıdaki gibi görünecek.
...
{
"mpg":15,
"horsepower":165,
},
{
"mpg":18,
"horsepower":150,
},
{
"mpg":16,
"horsepower":150,
},
...
Amacımız, bir sayı olan beygir gücünü alıp bir sayı olan galon başına mili tahmin etmeyi öğrenecek bir model eğitmek. Bire bir eşlemenin bir sonraki bölüm için önemli olacağını unutmayın.
Bu örnekleri (beygir gücü ve MPG) bir nöral ağa besleyeceğiz. Bu ağ, beygir gücü verildiğinde MPG'yi tahmin etmek için bu örneklerden bir formül (veya işlev) öğrenecek. Doğru yanıtlarını bildiğimiz örneklerden öğrenme sürecine Gözetimli Öğrenme adı verilir.
4. Model mimarisini tanımlama
Bu bölümde, model mimarisini açıklayan kodu yazacağız. Model mimarisi, "model yürütülürken hangi işlevleri çalıştıracak" veya alternatif olarak "modelimiz yanıtlarını hesaplamak için hangi algoritmayı kullanacak" demenin süslü bir yoludur.
Makine öğrenimi modelleri, giriş alıp çıkış üreten algoritmalardır. Sinir ağları kullanılırken algoritma, çıkışlarını yöneten "ağırlıklara" (sayılar) sahip bir nöron katmanları kümesidir. Eğitim süreci, bu ağırlıklar için ideal değerleri öğrenir.
Aşağıdaki işlevi
script.js Model mimarisini tanımlayan dosya.
function createModel() {
// Create a sequential model
const model = tf.sequential();
// Add a single input layer
model.add(tf.layers.dense({inputShape: [1], units: 1, useBias: true}));
// Add an output layer
model.add(tf.layers.dense({units: 1, useBias: true}));
return model;
}
Bu, tensorflow.js'de tanımlayabileceğimiz en basit modellerden biridir. Her satırı biraz inceleyelim.
Modeli örneklendirme
const model = tf.sequential();
Bu, tf.Model nesnesini oluşturur. Bu model, girişleri doğrudan çıkışına aktarıldığı için sequential. Diğer model türleri dallara veya hatta birden fazla girişe ve çıkışa sahip olabilir ancak çoğu durumda modelleriniz sıralı olur. Sıralı modellerin kullanımı daha kolay bir API'si de vardır.
Katman ekleme
model.add(tf.layers.dense({inputShape: [1], units: 1, useBias: true}));
Bu işlem, ağımıza bir giriş katmanı ekler. Bu katman, bir gizli birimli bir dense katmanına otomatik olarak bağlanır. dense katmanı, girişlerini bir matrisle (ağırlıklar olarak adlandırılır) çarpıp sonuca bir sayı (sapma olarak adlandırılır) ekleyen bir katman türüdür. Bu, ağın ilk katmanı olduğundan inputShape tanımlamamız gerekir. inputShape, [1]'dir. Çünkü giriş olarak 1 sayısını (belirli bir arabanın beygir gücü) kullanırız.
units, katmandaki ağırlık matrisinin boyutunu belirler. Burada 1 olarak ayarlayarak verilerin giriş özelliklerinin her biri için 1 ağırlık olacağını belirtiyoruz.
model.add(tf.layers.dense({units: 1}));
Yukarıdaki kod, çıkış katmanımızı oluşturur. 1 sayısını çıkış olarak almak istediğimiz için units değerini 1 olarak ayarladık.
Örnek oluşturma
Aşağıdaki kodu
run Daha önce tanımladığımız işlev.
// Create the model
const model = createModel();
tfvis.show.modelSummary({name: 'Model Summary'}, model);
Bu işlem, modelin bir örneğini oluşturur ve web sayfasında katmanların özetini gösterir.
5. Eğitim için verileri hazırlama
TensorFlow.js'nin makine öğrenimi modellerinin eğitimini pratik hale getiren performans avantajlarından yararlanmak için verilerimizi tensörlere dönüştürmemiz gerekir. Ayrıca, verilerimizde en iyi uygulamalar olan karıştırma ve normalleştirme gibi bir dizi dönüşüm gerçekleştireceğiz.
Aşağıdaki kodu
script.js dosya
/**
* Convert the input data to tensors that we can use for machine
* learning. We will also do the important best practices of _shuffling_
* the data and _normalizing_ the data
* MPG on the y-axis.
*/
function convertToTensor(data) {
// Wrapping these calculations in a tidy will dispose any
// intermediate tensors.
return tf.tidy(() => {
// Step 1. Shuffle the data
tf.util.shuffle(data);
// Step 2. Convert data to Tensor
const inputs = data.map(d => d.horsepower)
const labels = data.map(d => d.mpg);
const inputTensor = tf.tensor2d(inputs, [inputs.length, 1]);
const labelTensor = tf.tensor2d(labels, [labels.length, 1]);
//Step 3. Normalize the data to the range 0 - 1 using min-max scaling
const inputMax = inputTensor.max();
const inputMin = inputTensor.min();
const labelMax = labelTensor.max();
const labelMin = labelTensor.min();
const normalizedInputs = inputTensor.sub(inputMin).div(inputMax.sub(inputMin));
const normalizedLabels = labelTensor.sub(labelMin).div(labelMax.sub(labelMin));
return {
inputs: normalizedInputs,
labels: normalizedLabels,
// Return the min/max bounds so we can use them later.
inputMax,
inputMin,
labelMax,
labelMin,
}
});
}
Şimdi bu durumun nedenlerini inceleyelim.
Verileri karıştırma
// Step 1. Shuffle the data
tf.util.shuffle(data);
Burada, eğitim algoritmasına besleyeceğimiz örneklerin sırasını rastgele hale getiriyoruz. Genellikle eğitim sırasında veri kümesi, modelin eğitildiği gruplar adı verilen daha küçük alt kümeler halinde ayrıldığından karıştırma işlemi önemlidir. Karıştırma, her grubun veri dağılımının tamamından çeşitli veriler içermesine yardımcı olur. Bu şekilde modele şu konularda yardımcı oluruz:
- Tamamen verilerin girilme sırasına bağlı olan şeyleri öğrenmez.
- Alt gruplardaki yapıya duyarlı olmamalıdır (ör. eğitiminin ilk yarısında yalnızca yüksek beygir gücüne sahip arabaları görürse veri kümesinin geri kalanında geçerli olmayan bir ilişki öğrenebilir).
Tensörlere dönüştürme
// Step 2. Convert data to Tensor
const inputs = data.map(d => d.horsepower)
const labels = data.map(d => d.mpg);
const inputTensor = tf.tensor2d(inputs, [inputs.length, 1]);
const labelTensor = tf.tensor2d(labels, [labels.length, 1]);
Burada iki dizi oluşturuyoruz: biri giriş örneklerimiz (beygir gücü girişleri) için, diğeri ise gerçek çıkış değerleri (makine öğreniminde etiket olarak bilinir) için.
Ardından, her dizi verisini 2 boyutlu tensöre dönüştürürüz. Tensörün şekli [num_examples, num_features_per_example] olur. Burada inputs.length örnek var ve her örnekte 1 giriş özelliği (beygir gücü) bulunuyor.
Verileri normalleştirme
//Step 3. Normalize the data to the range 0 - 1 using min-max scaling
const inputMax = inputTensor.max();
const inputMin = inputTensor.min();
const labelMax = labelTensor.max();
const labelMin = labelTensor.min();
const normalizedInputs = inputTensor.sub(inputMin).div(inputMax.sub(inputMin));
const normalizedLabels = labelTensor.sub(labelMin).div(labelMax.sub(labelMin));
Ardından, makine öğrenimi eğitimi için başka bir en iyi uygulamayı ele alıyoruz. Verileri normalleştiririz. Burada, minimum ve maksimum ölçeklendirme kullanılarak veriler 0-1 sayısal aralığında normalleştirilir. Normalleştirme önemlidir. Çünkü tensorflow.js ile oluşturacağınız birçok makine öğrenimi modelinin iç kısımları, çok büyük olmayan sayılarla çalışacak şekilde tasarlanmıştır. Verileri normalleştirmek için kullanılan yaygın aralıklar 0 to 1 veya -1 to 1'yi içerir. Verilerinizi makul bir aralığa normalleştirme alışkanlığı kazanırsanız modellerinizi eğitme konusunda daha başarılı olursunuz.
Verileri ve normalleştirme sınırlarını döndürme
return {
inputs: normalizedInputs,
labels: normalizedLabels,
// Return the min/max bounds so we can use them later.
inputMax,
inputMin,
labelMax,
labelMin,
}
Çıkışları orijinal ölçeğimize geri döndürmek için normalleştirme işlemini geri alabilmek ve gelecekteki giriş verilerini aynı şekilde normalleştirebilmek için eğitim sırasında normalleştirme için kullandığımız değerleri korumak istiyoruz.
6. Modeli eğitme
Model örneğimiz oluşturuldu ve verilerimiz tensör olarak temsil edildi. Artık eğitim sürecini başlatmak için her şey hazır.
Aşağıdaki işlevi
script.js file.
async function trainModel(model, inputs, labels) {
// Prepare the model for training.
model.compile({
optimizer: tf.train.adam(),
loss: tf.losses.meanSquaredError,
metrics: ['mse'],
});
const batchSize = 32;
const epochs = 50;
return await model.fit(inputs, labels, {
batchSize,
epochs,
shuffle: true,
callbacks: tfvis.show.fitCallbacks(
{ name: 'Training Performance' },
['loss', 'mse'],
{ height: 200, callbacks: ['onEpochEnd'] }
)
});
}
Şimdi bu durumu ayrıntılı şekilde inceleyelim.
Eğitime hazırlanma
// Prepare the model for training.
model.compile({
optimizer: tf.train.adam(),
loss: tf.losses.meanSquaredError,
metrics: ['mse'],
});
Modeli eğitmeden önce "derlememiz" gerekir. Bunun için çok önemli birkaç noktayı belirtmemiz gerekir:
optimizer: Bu, örnekleri gördükçe modeldeki güncellemeleri yönetecek algoritmadır. TensorFlow.js'de birçok optimize edici bulunur. Burada, uygulamada oldukça etkili olduğu ve yapılandırma gerektirmediği için Adam optimizasyonunu seçtik.loss: Bu işlev, modele gösterilen her bir grubu (veri alt kümeleri) öğrenme konusunda ne kadar başarılı olduğunu bildirir. Burada, modelin yaptığı tahminleri gerçek değerlerle karşılaştırmak içinmeanSquaredErrorkullanıyoruz.
const batchSize = 32;
const epochs = 50;
Ardından, batchSize ve dönem sayısını seçiyoruz:
batchSize, modelin eğitimin her iterasyonunda göreceği veri alt kümelerinin boyutunu ifade eder. Genel toplu iş boyutları genellikle 32-512 aralığındadır. Tüm problemler için ideal bir grup boyutu yoktur ve çeşitli grup boyutlarının matematiksel gerekçelerini açıklamak bu eğitimin kapsamı dışındadır.epochs, modelin sağladığınız veri kümesinin tamamına kaç kez bakacağını ifade eder. Burada veri kümesi üzerinde 50 yineleme yapacağız.
Tren döngüsünü başlatma
return await model.fit(inputs, labels, {
batchSize,
epochs,
callbacks: tfvis.show.fitCallbacks(
{ name: 'Training Performance' },
['loss', 'mse'],
{ height: 200, callbacks: ['onEpochEnd'] }
)
});
model.fit, eğitim döngüsünü başlatmak için çağırdığımız işlevdir. Bu işlev eşzamansız olduğundan, arayanın eğitimin ne zaman tamamlandığını belirleyebilmesi için bize verdiği sözü döndürüyoruz.
Eğitimdeki ilerlemeyi izlemek için model.fit'ya bazı geri çağırmalar iletiriz. Daha önce belirttiğimiz "loss" ve "mse" metrikleri için grafikleri çizen işlevler oluşturmak üzere tfvis.show.fitCallbacks kullanırız.
Özet
Şimdi tanımladığımız işlevleri run işlevimizden çağırmamız gerekiyor.
Aşağıdaki kodu
run işlevi.
// Convert the data to a form we can use for training.
const tensorData = convertToTensor(data);
const {inputs, labels} = tensorData;
// Train the model
await trainModel(model, inputs, labels);
console.log('Done Training');
Sayfayı yenilediğinizde birkaç saniye sonra aşağıdaki grafiklerin güncellendiğini görürsünüz.
Bunlar, daha önce oluşturduğumuz geri çağırmalar tarafından oluşturulur. Bunlar, her dönemin sonunda tüm veri kümesi üzerinde ortalaması alınmış kaybı ve ortalama karesel hatayı gösterir.
Bir modeli eğitirken kaybın azalmasını isteriz. Bu durumda, metriğimiz bir hata ölçüsü olduğundan, bu metriğin de düşmesini isteriz.
7. Tahminler oluşturma
Modelimiz eğitildiğine göre artık bazı tahminler yapmak istiyoruz. Düşükten yükseğe kadar değişen beygir gücü aralığında modelin tahminlerini inceleyerek modeli değerlendirelim.
Aşağıdaki işlevi script.js dosyanıza ekleyin
function testModel(model, inputData, normalizationData) {
const {inputMax, inputMin, labelMin, labelMax} = normalizationData;
// Generate predictions for a uniform range of numbers between 0 and 1;
// We un-normalize the data by doing the inverse of the min-max scaling
// that we did earlier.
const [xs, preds] = tf.tidy(() => {
const xsNorm = tf.linspace(0, 1, 100);
const predictions = model.predict(xsNorm.reshape([100, 1]));
const unNormXs = xsNorm
.mul(inputMax.sub(inputMin))
.add(inputMin);
const unNormPreds = predictions
.mul(labelMax.sub(labelMin))
.add(labelMin);
// Un-normalize the data
return [unNormXs.dataSync(), unNormPreds.dataSync()];
});
const predictedPoints = Array.from(xs).map((val, i) => {
return {x: val, y: preds[i]}
});
const originalPoints = inputData.map(d => ({
x: d.horsepower, y: d.mpg,
}));
tfvis.render.scatterplot(
{name: 'Model Predictions vs Original Data'},
{values: [originalPoints, predictedPoints], series: ['original', 'predicted']},
{
xLabel: 'Horsepower',
yLabel: 'MPG',
height: 300
}
);
}
Yukarıdaki işlevde dikkat edilmesi gereken birkaç nokta:
const xsNorm = tf.linspace(0, 1, 100);
const predictions = model.predict(xsNorm.reshape([100, 1]));
Modele beslemek için 100 yeni "örnek" oluştururuz. Model.predict, bu örnekleri modele aktarmak için kullandığımız yöntemdir. Bunların, eğitim sırasında kullandığımız şekle ([num_examples, num_features_per_example]) benzer olması gerektiğini unutmayın.
// Un-normalize the data
const unNormXs = xsNorm
.mul(inputMax.sub(inputMin))
.add(inputMin);
const unNormPreds = predictions
.mul(labelMax.sub(labelMin))
.add(labelMin);
Verileri orijinal aralığımıza (0-1 yerine) geri getirmek için normalleştirme sırasında hesapladığımız değerleri kullanırız ancak işlemleri tersine çeviririz.
return [unNormXs.dataSync(), unNormPreds.dataSync()];
.dataSync(), tensörde depolanan değerlerin typedarray değerini almak için kullanabileceğimiz bir yöntemdir. Bu sayede, bu değerleri normal JavaScript'te işleyebiliriz. Bu, genellikle tercih edilen .data() yönteminin eşzamanlı sürümüdür.
Son olarak, orijinal verileri ve modelden gelen tahminleri çizmek için tfjs-vis'i kullanırız.
Aşağıdaki kodu
run işlevi.
// Make some predictions using the model and compare them to the
// original data
testModel(model, data, tensorData);
Sayfayı yenilediğinizde modelin eğitimi tamamlandıktan sonra aşağıdakine benzer bir ekran görürsünüz.
Tebrikler! Basit bir makine öğrenimi modelini eğittiniz. Şu anda, giriş verilerindeki trende bir çizgi sığdırmaya çalışan doğrusal regresyon olarak bilinen işlemi gerçekleştirir.
8. Temel çıkarımlar
Makine öğrenimi modelini eğitme adımları şunlardır:
Görevinizi formüle edin:
- Regresyon sorunu mu yoksa sınıflandırma sorunu mu?
- Bu işlem, gözetimli öğrenme veya gözetimsiz öğrenme ile yapılabilir mi?
- Giriş verilerinin şekli nedir? Çıkış verileri nasıl görünmelidir?
Verilerinizi hazırlayın:
- Verilerinizi temizleyin ve mümkün olduğunda tekrarlı karakteristikler için manuel olarak inceleyin.
- Eğitim için kullanmadan önce verilerinizi karıştırma
- Verilerinizi nöral ağ için makul bir aralığa normalleştirin. Sayısal veriler için genellikle 0-1 veya -1-1 aralıkları uygundur.
- Verilerinizi tensörlere dönüştürme
Modelinizi oluşturun ve çalıştırın:
tf.sequentialveyatf.modelkullanarak modelinizi tanımlayın, ardındantf.layers.*ile katmanlar ekleyin.- Bir optimize edici ( genellikle adam iyi bir seçenektir) ve grup boyutu ile dönem sayısı gibi parametreler seçin.
- Sorununuz için uygun bir kayıp işlevi ve ilerlemeyi değerlendirmenize yardımcı olacak bir doğruluk metriği seçin.
meanSquaredError, regresyon sorunları için yaygın bir kayıp işlevidir. - Kaybın azalıp azalmadığını görmek için eğitimi izleyin.
Modelinizi değerlendirme
- Modeliniz için eğitim sırasında izleyebileceğiniz bir değerlendirme metriği seçin. Model eğitildikten sonra tahmin kalitesini anlamak için bazı test tahminleri yapmayı deneyin.
9. Ek Kredi: Denenecekler
- Dönem sayısını değiştirmeyi deneyin. Grafiğin düzleşmesi için kaç döneme ihtiyacınız var?
- Gizli katmandaki birim sayısını artırmayı deneyin.
- Eklediğimiz ilk gizli katman ile son çıkış katmanı arasına daha fazla gizli katman ekleyerek denemeler yapın. Bu ekstra katmanların kodu aşağıdaki gibi görünmelidir.
model.add(tf.layers.dense({units: 50, activation: 'sigmoid'}));
Bu gizli katmanlarla ilgili en önemli yenilik, doğrusal olmayan bir aktivasyon fonksiyonu (bu örnekte sigmoid aktivasyonu) sunmalarıdır. Etkinleştirme işlevleri hakkında daha fazla bilgi edinmek için bu makaleyi inceleyin.
Modelin aşağıdaki resimdeki gibi bir çıkış oluşturup oluşturmadığını kontrol edin.
