Pertanyaan saya terkait dengan postingan ini dan saya sudah juga mencoba mengimplementasikan solusi dari di sini dan di sini. Di bawah ini saya juga mencoba mengimplementasikan kode sesuai dengan solusi ini (implementasi/output saya tidak benar). Kode saya adalah sebagai berikut, menggunakan data kertas, batu, gunting:

!wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/rps.zip \
    -O /tmp/rps.zip
  
!wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/rps-test-set.zip \
    -O /tmp/rps-test-set.zip

import os
import zipfile

local_zip = '/tmp/rps.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/tmp/')
zip_ref.close()

local_zip = '/tmp/rps-test-set.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/tmp/')
zip_ref.close()

rock_dir = os.path.join('/tmp/rps/rock')
paper_dir = os.path.join('/tmp/rps/paper')
scissors_dir = os.path.join('/tmp/rps/scissors')

print('total training rock images:', len(os.listdir(rock_dir)))
print('total training paper images:', len(os.listdir(paper_dir)))
print('total training scissors images:', len(os.listdir(scissors_dir)))

rock_files = os.listdir(rock_dir)
print(rock_files[:10])

paper_files = os.listdir(paper_dir)
print(paper_files[:10])

scissors_files = os.listdir(scissors_dir)
print(scissors_files[:10])

import tensorflow as tf
import keras_preprocessing
from keras_preprocessing import image
from keras_preprocessing.image import ImageDataGenerator

TRAINING_DIR = "/tmp/rps/"
training_datagen = ImageDataGenerator(
      rescale = 1./255,
        rotation_range=40,
      width_shift_range=0.2,
      height_shift_range=0.2,
      shear_range=0.2,
      zoom_range=0.2,
      horizontal_flip=True,
      fill_mode='nearest')

VALIDATION_DIR = "/tmp/rps-test-set/"
validation_datagen = ImageDataGenerator(rescale = 1./255)

train_generator = training_datagen.flow_from_directory(
    TRAINING_DIR,
    target_size=(150,150),
    class_mode='categorical',
  batch_size=126
)

validation_generator = validation_datagen.flow_from_directory(
    VALIDATION_DIR,
    target_size=(150,150),
    class_mode='categorical',
  batch_size=126
)

model = tf.keras.models.Sequential([
    # Note the input shape is the desired size of the image 150x150 with 3 bytes color
    # This is the first convolution
    tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(150, 150, 3)),
    tf.keras.layers.MaxPooling2D(2, 2),
    # The second convolution
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # The third convolution
    tf.keras.layers.Conv2D(128, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # The fourth convolution
    tf.keras.layers.Conv2D(128, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    # Flatten the results to feed into a DNN
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.5),
    # 512 neuron hidden layer
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dense(3, activation='softmax')
])


model.summary()

model.compile(loss = 'categorical_crossentropy', optimizer='rmsprop', metrics=[tf.keras.metrics.Recall()])

history = model.fit(train_generator, epochs=25, steps_per_epoch=20, validation_data = validation_generator, verbose = 1, validation_steps=3)

model.save("rps.h5")

Output menunjukkan model dengan fit yang cukup tinggi. Sekarang saya ingin menguji ini lagi melengkapi data baru: (Harap dicatat, sayangnya, ini bernama data "validasi")

import shutil
import glob
import numpy as np
import os as os

!wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/rps-validation.zip \
    -O /tmp/rps-validation-set.zip

local_zip = '/tmp/rps-validation-set.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/tmp/rps-validation-set')
zip_ref.close()

os.mkdir("/tmp/rps-validation-set/paper/")
os.mkdir("/tmp/rps-validation-set/rock/")
os.mkdir("/tmp/rps-validation-set/scissors/")

dest_dir = "/tmp/rps-validation-set/paper"
for file in glob.glob(r'/tmp/rps-validation-set/paper*.png'):
    print(file)
    shutil.move(file, dest_dir)

dest_dir = "/tmp/rps-validation-set/rock"
for file in glob.glob(r'/tmp/rps-validation-set/rock*.png'):
    print(file)
    shutil.move(file, dest_dir)

dest_dir = "/tmp/rps-validation-set/scissors"
for file in glob.glob(r'/tmp/rps-validation-set/scissors*.png'):
    print(file)
    shutil.move(file, dest_dir)

!rm -r /tmp/rps-validation-set/.ipynb_checkpoints

new_DIR = "/tmp/rps-validation-set/"
new_datagen = ImageDataGenerator(rescale = 1./255)

new_generator = new_datagen.flow_from_directory(
    new_DIR,
    target_size=(150,150),
    class_mode='categorical',
  batch_size=126
)

print(new_generator.class_indices)
print(new_generator.classes)
print(new_generator.num_classes)

print(train_generator.class_indices)
print(train_generator.classes)
print(train_generator.num_classes)

model.evaluate(new_generator)

classes = model.predict(new_generator)
model.predict(new_generator)
np.argmax(model.predict(new_generator), axis=-1)
print(classes)

# output from here on:
print("model evaluate output ", model.evaluate(new_generator))
print("train_generator classes: ", train_generator.classes)
print("new_generator classes:   ", new_generator.classes)
print("train_generator class indices:   ",train_generator.class_indices)
print("new_generator class indices:     ",new_generator.class_indices)
print("model prediction ", model.predict_classes(new_generator))
print("actual values/labels    ", new_generator.labels)
print("filenames ", new_generator.filenames)

print("\n manually predict first 4 single paper images: \n ")

path = "/tmp/rps-validation-set/paper/paper-hires1.png"
img = image.load_img(path, target_size=(150, 150))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)

images = np.vstack([x])
classes = model.predict(images, batch_size=10)
print(path)
print(classes)

path = "/tmp/rps-validation-set/paper/paper-hires2.png"
img = image.load_img(path, target_size=(150, 150))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)

images = np.vstack([x])
classes = model.predict(images, batch_size=10)
print(path)
print(classes)

path = "/tmp/rps-validation-set/paper/paper1.png"
img = image.load_img(path, target_size=(150, 150))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)

images = np.vstack([x])
classes = model.predict(images, batch_size=10)
print(path)
print(classes)

path = "/tmp/rps-validation-set/paper/paper2.png"
img = image.load_img(path, target_size=(150, 150))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)

images = np.vstack([x])
classes = model.predict(images, batch_size=10)
print(path)
print(classes)

print("\n trying different solution \n")
predictions = model.predict(new_generator)       
predictions = np.argmax(predictions, axis=-1) #multiple categories
label_map = (train_generator.class_indices)
label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
predictions = [label_map[k] for k in predictions]

print("predictions adjusted ", predictions)
print("actual values    ", new_generator.labels)

Output yang relevan untuk masalah saya adalah sebagai berikut (dari # output from here on: aktif):

enter image description here

Pertama saya memeriksa kinerja dengan model.evaluate, mengingat tinggi dan kehilangan rendah menunjukkan kepada saya bahwa prediksi (hampir) sempurna sehingga saya berharap tidak ada perbedaan antara nilai/label asli dan kelas yang diprediksi.

Saya sekarang ingin memeriksa/memvisualisasikannya dengan menunjukkan prediksi terhadap nilai/label input yang sebenarnya.

Saya tidak memahami hal berikut:

1.) Setiap kali saya menjalankan print("model prediction ", model.predict_classes(new_generator)), jadi model.predict_classes hasilnya berbeda:

exp

Mengapa? Saya memiliki model yang diperbaiki dan saya memasukkan beberapa nilai sehingga saya berharap prediksinya stabil. Hal yang sama berlaku untuk print(model.predict(new_generator)), jadi setiap kali saya menjalankannya, outputnya berbeda.

2.) Prediksi tidak sesuai dengan nilai sebenarnya. Saya tidak mengerti mengapa dan bagaimana saya dapat mencapai apa yang saya inginkan, untuk mencocokkan prediksi dengan nilai yang sesuai dan memeriksa di mana perbedaannya. Saya pikir mungkin urutannya berbeda dan memang dalam postingan ini tidak menyebutkannya dan dua solusi disediakan. Solusi dengan menghapus rescaling di imagegenerator bukanlah solusi yang baik di mata saya. Saya mencoba menyesuaikan solusi yang diusulkan berikut:

import numpy as np
predictions = model.predict_generator(self.test_generator)
predictions = np.argmax(predictions, axis=-1) #multiple categories

label_map = (train_generator.class_indices)
label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
predictions = [label_map[k] for k in predictions]

Ke kode saya (lihat blok kode "mencoba solusi berbeda"):

Keluaran:

imp

Tapi ini salah/implementasi saya salah.

Saya juga mencoba yang berikut ini dari utas ini:

from glob import glob
class_names = glob("/tmp/rps-validation-set/*") # Reads all the folders in which images are present
class_names = sorted(class_names) # Sorting them
name_id_map = dict(zip(class_names, range(len(class_names))))

Tapi ini tidak membantu.

Ketika saya secara manual memprediksi 4 gambar pertama, output dari model.predict berbeda, itu benar. [1. 0. 0] adalah output yang benar untuk semua 4 gambar. Jadi ketika saya menjalankan model.predict / model.predict_classes pada satu gambar / memberikan nama file itu benar. Namun, ketika saya menjalankannya pada generator data gambar entah bagaimana diacak?

3.) Yang tidak saya pahami adalah perbedaan antara model.predict_classes dan model.predict, keduanya:

print(model.predict_classes(new_generator))
print(model.predict(new_generator))

ex

Probabilitas yang diprediksi tidak cocok dengan kelas yang diprediksi. Misalnya sudah untuk entri pertama, probabilitas terbesar adalah 9.99e-01, namun kelas yang diprediksi adalah 1. Kemudian untuk entri kedua cocok, jadi sekali lagi probabilitas terbesar adalah 9.99e-01 dan ini sesuai dengan kelas terakhir dan diprediksi kelas memang 2. Jadi sepertinya semuanya benar-benar diacak. Ketika saya memikirkan gambar pertama milik kelas pertama, jadi [1 0 0] benar maka saya berharap bahwa probabilitas yang lebih tinggi ada di kelas pertama (sesuai dengan nilai 0) (tidak) dan kelas yang diprediksi itu adalah kelas pertama (sesuai dengan nilai 0) (tidak).

4.) Saat saya berlari

images = np.vstack([x])
classes = model.predict(images, batch_size=10)
classes2 = model.predict_classes(images, batch_size=10)
print(path)
print(classes)
print(classes2)

Saya mendapat

pr

Bagaimana cara mendapatkan probabilitas? Jadi sesuatu seperti

exam

0
Stat Tistician 1 Juli 2020, 00:48

1 menjawab

Jawaban Terbaik

Anda melakukan semua hal dengan benar kecuali satu. Saat Anda membuat generator data untuk pengujian (new_generator), Anda tidak menyetel shuffle=False. Dengan cara ini Anda tidak dapat mereproduksi hasil dengan setiap proses karena generator data akan mengacak data untuk setiap iterasi.

MEMPERBAIKI

new_generator = new_datagen.flow_from_directory(
    new_DIR,
    target_size=(150,150),
    class_mode='categorical',
  batch_size=126,
  shuffle=False
)

Dan semuanya akan berfungsi dengan baik dengan kode Anda yang ada.

Pertanyaan 0:

Metode evaluasi Dokumen

Mengembalikan nilai kerugian & nilai metrik untuk model dalam mode uji.

print("model evaluate output ", model.evaluate(new_generator))

Anda akan melihat dua skalar yang pertama adalah kerugian dan yang kedua adalah penarikan

Pertanyaan 1:

Dengan shuffle=False Anda akan mendapatkan hasil yang dapat direproduksi dengan setiap proses.

Pertanyaan 2, 3:

Lagi Dengan shuffle=False akan memperbaiki masalah. Cara yang benar untuk mencari indeks kelas dari skor probabilitas adalah sebagai berikut:

print (np.argmax(model.predict(new_generator), axis=1))

Yang dapat Anda verifikasi akan sama dengan

print (model.predict_classes(new_generator))

Pertanyaan 4:

  • model.predict akan memberi Anda probabilitas kelas
  • model.predict_classes akan memberi Anda label kelas berdasarkan kelas probabilitas tertinggi.

Hanya data kereta dan data validasi yang harus diacak untuk pengacakan. Anda tidak boleh mengacak data uji (yang Anda tidak tahu atau anggap tidak tahu) kebenaran dasarnya.

Membuat prediksi

Penambahan data yang dilakukan di pembangkit data kereta tidak diperlukan selama prediksi karena penambahan ini dilakukan secara acak untuk menghasilkan data kereta yang bervariasi. Anda dapat menggunakan kode di bawah ini untuk membuat prediksi, dengan asumsi bahwa semua gambar yang ingin Anda prediksi ada di dalam /tmp/rps-validation-set/ (sebagai gambar bukan subfolder karena Anda tidak akan mengetahui kelas gambar ini secara umum)

test_datagen = ImageDataGenerator(rescale = 1./255)
       
test_generator = test_datagen.flow_from_directory(
    "/tmp/rps-validation-set/",
    target_size=(150,150),
    class_mode=None,
  batch_size=126,
  shuffle=False
)

model.predict(test_generator)

Perhatikan bahwa karena kami menerapkan kembali transformasi penskalaan gambar tetap yang telah Anda terapkan untuk pelatihan dan validasi, tetapi lewati augmentasi gambar acak lainnya.

2
mujjiga 12 Juli 2020, 20:39