TensorFlow.js — CNN'ler ile el yazısıyla yazılmış rakam tanıma

1. Giriş

Bu eğitimde, evrişimli sinir ağıyla el yazısıyla yazılmış rakamları tanımak için bir TensorFlow.js modeli oluşturacağız. Öncelikle, sınıflandırıcıyı binlerce el yazısı rakam resmine ve etiketlerine "bakarak" eğiteceğiz. Ardından, modelin daha önce hiç görmediği test verilerini kullanarak sınıflandırıcının doğruluğunu değerlendiririz.

Bu görev, modeli giriş resmine bir kategori (resimde görünen rakam) atayacak şekilde eğittiğimiz için sınıflandırma görevi olarak kabul edilir. 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. Belirli bir boyuttaki siyah beyaz bir resim verildiğinde, resimde hangi rakamın göründüğünü sınıflandırır. İlgili adımlar şunlardır:

Verileri yükleyin.
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?

TensorFlow.js Layers API'yi kullanarak evrişimli modeller oluşturmaya yönelik TensorFlow.js söz dizimi.
TensorFlow.js'de sınıflandırma görevleri oluşturma
tfjs-vis kitaplığını kullanarak tarayıcı içi eğitimi izleme

Gerekenler

Chrome'un son sürümü veya ES6 modüllerini destekleyen başka bir modern tarayıcı.
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üzeyde kavramsal bilgi sahibi olmak. Giriş veya hatırlatma için 3blue1brown'un bu videosunu ya da Ashi Krishnan'ın JavaScript'te Derin Öğrenme videosunu izleyebilirsiniz.

Ayrıca, ilk eğitim videomuzda yer alan bilgiler hakkında da bilgi sahibi olmanız gerekir.

2. Hazırlanın

HTML sayfası oluşturma ve JavaScript'i ekleme

Aşağıdaki kodu

index.html

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>TensorFlow.js Tutorial</title>

  <!-- Import TensorFlow.js -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@1.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>

  <!-- Import the data file -->
  <script src="data.js" type="module"></script>

  <!-- Import the main script file -->
  <script src="script.js" type="module"></script>

</head>

<body>
</body>
</html>

Veriler ve kod için JavaScript dosyalarını oluşturma

Yukarıdaki HTML dosyasıyla aynı klasörde data.js adlı bir dosya oluşturun ve bu bağlantıdaki içeriği bu dosyaya kopyalayın.
Birinci adımla aynı klasörde script.js adlı bir dosya oluşturun ve aşağıdaki kodu bu dosyaya 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 düzgün çalışıyorsa iki genel değişken oluşturulur. tf, TensorFlow.js kitaplığına, tfvis ise tfjs-vis kitaplığına referanstır.

Hello TensorFlowmesajını görmelisiniz. Bu mesajı görüyorsanız sonraki adıma geçebilirsiniz.

3. Verileri yükleme

Bu eğitimde, aşağıdaki gibi resimlerdeki rakamları tanımayı öğrenecek bir model eğiteceksiniz. Bu görüntüler, MNIST adlı bir veri kümesinden alınan 28x28 piksel boyutunda gri tonlamalı görüntülerdir.

mnist 4 mnist 3 mnist 8

Eğitim bölümüne odaklanabilmemiz için bu resimleri, sizin için oluşturduğumuz özel bir imge dosyasından (~10 MB) yükleyecek kodu sağladık.

Verilerin nasıl yüklendiğini anlamak için data.js dosyasını inceleyebilirsiniz. Alternatif olarak, bu eğitimi tamamladıktan sonra verileri yüklemek için kendi yaklaşımınızı oluşturabilirsiniz.

Sağlanan kod, iki herkese açık yöntemi olan bir sınıf MnistData içeriyor:

nextTrainBatch(batchSize): Eğitim setinden rastgele bir görüntü grubu ve etiketlerini döndürür.
nextTestBatch(batchSize): Test setinden bir grup resim ve etiketlerini döndürür.

MnistData sınıfı, verileri karıştırma ve normalleştirme gibi önemli adımları da gerçekleştirir.

Toplam 65.000 resim var. Modeli eğitmek için 55.000'e kadar resim kullanacağız. Geriye kalan 10.000 resmi ise modelin performansını test etmek için kullanacağız. Tüm bunları tarayıcıda yapacağız.

Verileri yükleyelim ve doğru şekilde yüklendiğini test edelim.

Aşağıdaki kodu script.js dosyanıza ekleyin.

import {MnistData} from './data.js';

async function showExamples(data) {
  // Create a container in the visor
  const surface =
    tfvis.visor().surface({ name: 'Input Data Examples', tab: 'Input Data'});  

  // Get the examples
  const examples = data.nextTestBatch(20);
  const numExamples = examples.xs.shape[0];
  
  // Create a canvas element to render each example
  for (let i = 0; i < numExamples; i++) {
    const imageTensor = tf.tidy(() => {
      // Reshape the image to 28x28 px
      return examples.xs
        .slice([i, 0], [1, examples.xs.shape[1]])
        .reshape([28, 28, 1]);
    });
    
    const canvas = document.createElement('canvas');
    canvas.width = 28;
    canvas.height = 28;
    canvas.style = 'margin: 4px;';
    await tf.browser.toPixels(imageTensor, canvas);
    surface.drawArea.appendChild(canvas);

    imageTensor.dispose();
  }
}

async function run() {  
  const data = new MnistData();
  await data.load();
  await showExamples(data);
}

document.addEventListener('DOMContentLoaded', run);

Sayfayı yenilediğinizde birkaç saniye sonra solda bir panelde çeşitli resimler gösterilir.

4. Görevimizi kavramsallaştırma

Giriş verilerimiz aşağıdaki gibi görünür.

Amacımız, tek bir görüntü alıp bu görüntünün ait olabileceği olası 10 sınıfın her biri için bir puan (0-9 rakamları) tahmin etmeyi öğrenecek bir model eğitmek.

Her resim 28 piksel genişliğinde ve 28 piksel yüksekliğindedir. Gri tonlamalı bir resim olduğundan 1 renk kanalına sahiptir. Bu nedenle her resmin şekli [28, 28, 1] olur.

Bir sonraki bölüm için önemli olduğundan, her giriş örneğinin şeklinin yanı sıra bire bir eşleme yaptığımızı unutmayın.

5. Model mimarisini tanımlama

Bu bölümde, model mimarisini açıklayan kodu yazacağız. Model mimarisi, "model çalışırken hangi işlevleri yürütecek" veya alternatif olarak "modelimiz yanıtlarını hesaplamak için hangi algoritmayı kullanacak" demenin şık bir yoludur.

Makine öğreniminde bir mimari (veya algoritma) tanımlarız ve eğitim sürecinin bu algoritmanın parametrelerini öğrenmesine izin veririz.

Aşağıdaki işlevi

script.js Model mimarisini tanımlayan dosya

function getModel() {
  const model = tf.sequential();
  
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const IMAGE_CHANNELS = 1;  
  
  // In the first layer of our convolutional neural network we have 
  // to specify the input shape. Then we specify some parameters for 
  // the convolution operation that takes place in this layer.
  model.add(tf.layers.conv2d({
    inputShape: [IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS],
    kernelSize: 5,
    filters: 8,
    strides: 1,
    activation: 'relu',
    kernelInitializer: 'varianceScaling'
  }));

  // The MaxPooling layer acts as a sort of downsampling using max values
  // in a region instead of averaging.  
  model.add(tf.layers.maxPooling2d({poolSize: [2, 2], strides: [2, 2]}));
  
  // Repeat another conv2d + maxPooling stack. 
  // Note that we have more filters in the convolution.
  model.add(tf.layers.conv2d({
    kernelSize: 5,
    filters: 16,
    strides: 1,
    activation: 'relu',
    kernelInitializer: 'varianceScaling'
  }));
  model.add(tf.layers.maxPooling2d({poolSize: [2, 2], strides: [2, 2]}));
  
  // Now we flatten the output from the 2D filters into a 1D vector to prepare
  // it for input into our last layer. This is common practice when feeding
  // higher dimensional data to a final classification output layer.
  model.add(tf.layers.flatten());

  // Our last layer is a dense layer which has 10 output units, one for each
  // output class (i.e. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9).
  const NUM_OUTPUT_CLASSES = 10;
  model.add(tf.layers.dense({
    units: NUM_OUTPUT_CLASSES,
    kernelInitializer: 'varianceScaling',
    activation: 'softmax'
  }));

  
  // Choose an optimizer, loss function and accuracy metric,
  // then compile and return the model
  const optimizer = tf.train.adam();
  model.compile({
    optimizer: optimizer,
    loss: 'categoricalCrossentropy',
    metrics: ['accuracy'],
  });

  return model;
}

Bu konuyu biraz daha ayrıntılı olarak inceleyelim.

Konvolüsyonlar

model.add(tf.layers.conv2d({
  inputShape: [IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS],
  kernelSize: 5,
  filters: 8,
  strides: 1,
  activation: 'relu',
  kernelInitializer: 'varianceScaling'
}));

Burada sıralı bir model kullanıyoruz.

Yoğun katman yerine conv2d katmanı kullanıyoruz. Evrişimlerin işleyiş şeklinin tüm ayrıntılarına giremesek de temel işleyişi açıklayan birkaç kaynağı aşağıda bulabilirsiniz:

conv2d için yapılandırma nesnesindeki her bağımsız değişkeni inceleyelim:

inputShape. Modelin ilk katmanına akacak verilerin şekli. Bu durumda, MNIST örneklerimiz 28x28 piksellik siyah beyaz görüntülerdir. Resim verileri için standart biçim [row, column, depth] olduğundan burada [28, 28, 1] şekli yapılandırmak istiyoruz. Her boyuttaki piksel sayısı için 28 satır ve sütun, resimlerimizde yalnızca 1 renk kanalı olduğundan derinlik 1. Giriş şekli için grup boyutu belirtmediğimizi unutmayın. Katmanlar, çıkarım sırasında herhangi bir grup boyutunda tensör iletilebilmesi için grup boyutundan bağımsız olacak şekilde tasarlanmıştır.
kernelSize Giriş verilerine uygulanacak kayan evrişimli filtre pencerelerinin boyutu. Burada, 5x5 boyutunda kare bir evrişimli pencere belirten kernelSize 5 değerini ayarlıyoruz.
filters. Giriş verilerine uygulanacak kernelSize boyutundaki filtre pencerelerinin sayısı. Burada verilere 8 filtre uygulayacağız.
strides. Kayıt penceresinin "adım boyutu", yani filtrenin görüntü üzerinde her hareket ettiğinde kaç piksel kayacağı. Burada, adımları 1 olarak belirtiyoruz. Bu, filtrenin görüntü üzerinde 1 piksellik adımlarla kayacağı anlamına gelir.
activation. Evrişim tamamlandıktan sonra verilere uygulanacak etkinleştirme işlevi. Bu durumda, makine öğrenimi modellerinde çok yaygın bir etkinleştirme işlevi olan düzeltilmiş doğrusal birim (ReLU) işlevini uyguluyoruz.
kernelInitializer. Model ağırlıklarını rastgele başlatmak için kullanılacak yöntem. Bu, eğitim dinamikleri açısından çok önemlidir. Burada başlatma ayrıntılarına girmeyeceğiz ancak VarianceScaling (burada kullanılmıştır) genellikle iyi bir başlatıcı seçimidir.

Veri temsilimizi düzleştirme

model.add(tf.layers.flatten());

Görüntüler yüksek boyutlu verilerdir ve konvolüsyon işlemleri, bu verilere giren verilerin boyutunu artırır. Verileri son sınıflandırma katmanımıza iletmeden önce tek bir uzun diziye düzleştirmemiz gerekir. Yoğun katmanlar (son katman olarak kullandığımız) yalnızca tensor1d sürer. Bu nedenle bu adım, birçok sınıflandırma görevinde yaygın olarak kullanılır.

Son olasılık dağılımımızı hesaplama

const NUM_OUTPUT_CLASSES = 10;
model.add(tf.layers.dense({
  units: NUM_OUTPUT_CLASSES,
  kernelInitializer: 'varianceScaling',
  activation: 'softmax'
}));

10 olası sınıf üzerindeki olasılık dağılımlarını hesaplamak için softmax etkinleştirmeli yoğun bir katman kullanacağız. En yüksek puana sahip sınıf, tahmin edilen rakam olur.

Bir optimize edici ve kayıp işlevi seçin

const optimizer = tf.train.adam();
model.compile({
  optimizer: optimizer,
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy'],
});

Optimizasyon aracı, kayıp işlevi ve izlemek istediğimiz metrikleri belirterek modeli derleriz.

İlk eğitimimizin aksine, burada kayıp fonksiyonumuz olarak categoricalCrossentropy kullanıyoruz. Adından da anlaşılacağı gibi, bu işlev modelimizin çıktısı bir olasılık dağılımı olduğunda kullanılır. categoricalCrossentropy, modelimizin son katmanı tarafından oluşturulan olasılık dağılımı ile gerçek etiketimiz tarafından verilen olasılık dağılımı arasındaki hatayı ölçer.

Örneğin, rakamımız gerçekten 7'yi temsil ediyorsa aşağıdaki sonuçları elde edebiliriz.

Dizin	0	1	2	3	4	5	6	7	8	9
Doğru Etiket	0	0	0	0	0	0	0	1	0	0
Tahmin	0,1	0,01	0,01	0,01	0,20	0,01	0,01	0,60	0,03	0,02

Kategorik çapraz entropi, tahmin vektörünün gerçek etiket vektörümüze ne kadar benzediğini gösteren tek bir sayı üretir.

Etiketler için burada kullanılan veri gösterimine tek sıcaklık kodlaması adı verilir ve bu yöntem, sınıflandırma sorunlarında yaygın olarak kullanılır. Her sınıfla, her örnek için bir olasılık ilişkilendirilir. Tam olarak ne olması gerektiğini bildiğimizde bu olasılığı 1'e, diğerlerini ise 0'a ayarlayabiliriz. Tek sıcak kodlama hakkında daha fazla bilgi için bu sayfaya bakın.

İzleyeceğimiz diğer metrik ise accuracy'dır. Bu metrik, sınıflandırma sorunlarında tüm tahminler arasındaki doğru tahminlerin yüzdesidir.

6. Modeli eğitme

Aşağıdaki işlevi script.js dosyanıza kopyalayın.

async function train(model, data) {
  const metrics = ['loss', 'val_loss', 'acc', 'val_acc'];
  const container = {
    name: 'Model Training', tab: 'Model', styles: { height: '1000px' }
  };
  const fitCallbacks = tfvis.show.fitCallbacks(container, metrics);
  
  const BATCH_SIZE = 512;
  const TRAIN_DATA_SIZE = 5500;
  const TEST_DATA_SIZE = 1000;

  const [trainXs, trainYs] = tf.tidy(() => {
    const d = data.nextTrainBatch(TRAIN_DATA_SIZE);
    return [
      d.xs.reshape([TRAIN_DATA_SIZE, 28, 28, 1]),
      d.labels
    ];
  });

  const [testXs, testYs] = tf.tidy(() => {
    const d = data.nextTestBatch(TEST_DATA_SIZE);
    return [
      d.xs.reshape([TEST_DATA_SIZE, 28, 28, 1]),
      d.labels
    ];
  });

  return model.fit(trainXs, trainYs, {
    batchSize: BATCH_SIZE,
    validationData: [testXs, testYs],
    epochs: 10,
    shuffle: true,
    callbacks: fitCallbacks
  });
}

Ardından, aşağıdaki kodu

run işlevi.

const model = getModel();
tfvis.show.modelSummary({name: 'Model Architecture', tab: 'Model'}, model);
  
await train(model, data);

Sayfayı yenileyin. Birkaç saniye sonra, eğitimdeki ilerleme durumunu bildiren bazı grafikler görürsünüz.

Bunu biraz daha ayrıntılı olarak inceleyelim.

Metrikleri izleme

const metrics = ['loss', 'val_loss', 'acc', 'val_acc'];

Burada hangi metrikleri izleyeceğimize karar veriyoruz. Eğitim kümesindeki kaybı ve doğruluğu, doğrulama kümesindeki kaybı ve doğruluğu (sırasıyla val_loss ve val_acc) izleyeceğiz. Aşağıda doğrulama kümesi hakkında daha fazla bilgi vereceğiz.

Verileri tensör olarak hazırlama

const BATCH_SIZE = 512;
const TRAIN_DATA_SIZE = 5500;
const TEST_DATA_SIZE = 1000;

const [trainXs, trainYs] = tf.tidy(() => {
  const d = data.nextTrainBatch(TRAIN_DATA_SIZE);
  return [
    d.xs.reshape([TRAIN_DATA_SIZE, 28, 28, 1]),
    d.labels
  ];
});

const [testXs, testYs] = tf.tidy(() => {
  const d = data.nextTestBatch(TEST_DATA_SIZE);
  return [
    d.xs.reshape([TEST_DATA_SIZE, 28, 28, 1]),
    d.labels
  ];
});

Burada iki veri kümesi oluşturuyoruz: modeli üzerinde eğiteceğimiz bir eğitim kümesi ve her dönemin sonunda modeli üzerinde test edeceğimiz bir doğrulama kümesi. Ancak doğrulama kümesindeki veriler, eğitim sırasında modele hiçbir zaman gösterilmez.

Sağladığımız veri sınıfı, görüntü verilerinden tensör elde etmeyi kolaylaştırır. Ancak bunları modele aktarabilmemiz için tensörleri modelin beklediği şekle, [num_examples, image_width, image_height, channels], dönüştürmemiz gerekir. Her veri kümesi için hem girişler (X'ler) hem de etiketler (Y'ler) bulunur.

return model.fit(trainXs, trainYs, {
  batchSize: BATCH_SIZE,
  validationData: [testXs, testYs],
  epochs: 10,
  shuffle: true,
  callbacks: fitCallbacks
});

Eğitim döngüsünü başlatmak için model.fit yöntemini çağırırız. Ayrıca, modelin her dönemden sonra kendini test etmek için hangi verileri kullanması gerektiğini (ancak eğitim için kullanmaması gerektiğini) belirtmek üzere bir validationData özelliği de iletiyoruz.

Eğitim verilerimizde iyi performans gösterip doğrulama verilerimizde iyi performans göstermiyorsak modelin eğitim verilerine fazla uyumlu ve daha önce görmediği girişleri iyi bir şekilde genelleştiremeyeceği anlamına gelir.

7. Modelimizi değerlendirme

Doğrulama doğruluğu, modelimizin daha önce görmediği verilerde ne kadar iyi performans göstereceği konusunda iyi bir tahmin sunar (bu veriler, doğrulama kümesine bir şekilde benzediği sürece). Ancak farklı sınıflardaki performansın daha ayrıntılı bir dökümünü görmek isteyebiliriz.

tfjs-vis'te bu konuda size yardımcı olabilecek birkaç yöntem vardır.

Aşağıdaki kodu script.js dosyanızın en altına ekleyin.

const classNames = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine'];

function doPrediction(model, data, testDataSize = 500) {
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const testData = data.nextTestBatch(testDataSize);
  const testxs = testData.xs.reshape([testDataSize, IMAGE_WIDTH, IMAGE_HEIGHT, 1]);
  const labels = testData.labels.argMax(-1);
  const preds = model.predict(testxs).argMax(-1);

  testxs.dispose();
  return [preds, labels];
}


async function showAccuracy(model, data) {
  const [preds, labels] = doPrediction(model, data);
  const classAccuracy = await tfvis.metrics.perClassAccuracy(labels, preds);
  const container = {name: 'Accuracy', tab: 'Evaluation'};
  tfvis.show.perClassAccuracy(container, classAccuracy, classNames);

  labels.dispose();
}

async function showConfusion(model, data) {
  const [preds, labels] = doPrediction(model, data);
  const confusionMatrix = await tfvis.metrics.confusionMatrix(labels, preds);
  const container = {name: 'Confusion Matrix', tab: 'Evaluation'};
  tfvis.render.confusionMatrix(container, {values: confusionMatrix, tickLabels: classNames});

  labels.dispose();
}

Bu kod ne işe yarıyor?

Tahmin yapar.
Doğruluk metriklerini hesaplar.
Metrikleri gösterir.

Şimdi her aşamayı yakından inceleyelim.

Tahminler yürütme

function doPrediction(model, data, testDataSize = 500) {
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const testData = data.nextTestBatch(testDataSize);
  const testxs = testData.xs.reshape([testDataSize, IMAGE_WIDTH, IMAGE_HEIGHT, 1]);
  const labels = testData.labels.argMax(-1);
  const preds = model.predict(testxs).argMax(-1);

  testxs.dispose();
  return [preds, labels];
}

Öncelikle bazı tahminler yapmamız gerekiyor. Burada 500 resim çekecek ve bu resimlerdeki rakamları tahmin edeceğiz (daha sonra daha büyük bir resim grubu üzerinde test etmek için bu sayıyı artırabilirsiniz).

Özellikle argmax işlevi, en yüksek olasılıklı sınıfın dizinini verir. Modelin her sınıf için bir olasılık çıkışı verdiğini unutmayın. Burada en yüksek olasılığı bulup tahmini bu olasılığa göre yaparız.

Ayrıca, 500 örneğin tamamı için aynı anda tahmin yapabildiğimizi de fark edebilirsiniz. TensorFlow.js'nin sağladığı vektörizasyonun gücü budur.

Sınıfa göre doğruluğu göster

async function showAccuracy() {
  const [preds, labels] = doPrediction();
  const classAccuracy = await tfvis.metrics.perClassAccuracy(labels, preds);
  const container = { name: 'Accuracy', tab: 'Evaluation' };
  tfvis.show.perClassAccuracy(container, classAccuracy, classNames);

  labels.dispose();
}

Bir dizi tahmin ve etiketle her sınıf için doğruluğu hesaplayabiliriz.

Karışıklık matrisi gösterme

async function showConfusion() {
  const [preds, labels] = doPrediction();
  const confusionMatrix = await tfvis.metrics.confusionMatrix(labels, preds);
  const container = { name: 'Confusion Matrix', tab: 'Evaluation' };
  tfvis.render.confusionMatrix(container, {values: confusionMatrix, tickLabels: classNames});

  labels.dispose();
}

Karışıklık matrisi, sınıf başına doğruluğa benzer ancak yanlış sınıflandırma kalıplarını göstermek için daha ayrıntılı bir şekilde inceler. Modelin belirli sınıf çiftleri konusunda kafasının karışıp karışmadığını görmenizi sağlar.

Değerlendirmeyi gösterme

Değerlendirmeyi göstermek için aşağıdaki kodu run işlevinizin en altına ekleyin.

await showAccuracy(model, data);
await showConfusion(model, data);

Aşağıdaki gibi bir ekran görürsünüz.

Tebrikler! Evrişimli bir nöral ağı eğittiniz.

8. Ana çıkarımlar

Giriş verileri için kategorileri tahmin etmeye sınıflandırma görevi denir.

Sınıflandırma görevleri için etiketlerin uygun şekilde gösterilmesi gerekir.

Etiketlerin yaygın gösterimleri arasında kategorilerin one-hot kodlaması yer alır.

Verilerinizi hazırlayın:

Modeli değerlendirmek için kullanabileceğiniz ve eğitim sırasında modelin hiç görmediği bazı verileri bir kenarda tutmak faydalıdır. Buna doğrulama seti denir.

Modelinizi oluşturun ve çalıştırın:

Evrişimli modellerin, görüntü görevlerinde iyi performans gösterdiği kanıtlanmıştır.
Sınıflandırma sorunlarında genellikle kayıp fonksiyonları için kategorik çapraz entropi kullanılır.
Kaybın azalıp doğruluğun arttığını görmek için eğitimi izleyin.

Modelinizi değerlendirme

Eğitildikten sonra modelinizi değerlendirmenin bir yolunu belirleyerek çözmek istediğiniz ilk sorunda ne kadar iyi performans gösterdiğini görün.
Sınıf başına doğruluk ve karışıklık matrisleri, model performansının yalnızca genel doğruluktan daha ayrıntılı bir dökümünü verebilir.