केरास सटीकता

Question

नहीं बदलती है मेरे पास कुछ हजार ऑडियो फ़ाइलें हैं और मैं केरास और थेनो का उपयोग करके उन्हें वर्गीकृत करना चाहता हूं। अब तक, मैंने 28x28 स्पेक्ट्रोग्राम उत्पन्न किए हैं (बड़ा शायद बेहतर है, लेकिन मैं इस बिंदु पर एल्गोरिदम काम करने की कोशिश कर रहा हूं) प्रत्येक ऑडियो फ़ाइल के और छवि को मैट्रिक्स में पढ़ा। तो अंत में मुझे छवि वर्गीकरण के लिए नेटवर्क में फ़ीड करने के लिए यह बड़ी छवि मैट्रिक्स मिलती है।

एक ट्यूटोरियल में मैं इस mnist वर्गीकरण कोड मिला:

import numpy as np 

from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers.core import Dense 
from keras.utils import np_utils 

batch_size = 128 
nb_classes = 10 
nb_epochs = 2 

(X_train, y_train), (X_test, y_test) = mnist.load_data() 

X_train = X_train.reshape(60000, 784) 
X_test = X_test.reshape(10000, 784) 
X_train = X_train.astype("float32") 
X_test = X_test.astype("float32") 
X_train /= 255 
X_test /= 255 

print(X_train.shape[0], "train samples") 
print(X_test.shape[0], "test samples") 

y_train = np_utils.to_categorical(y_train, nb_classes) 
y_test = np_utils.to_categorical(y_test, nb_classes) 

model = Sequential() 

model.add(Dense(output_dim = 100, input_dim = 784, activation= "relu")) 
model.add(Dense(output_dim = 200, activation = "relu")) 
model.add(Dense(output_dim = 200, activation = "relu")) 
model.add(Dense(output_dim = nb_classes, activation = "softmax")) 

model.compile(optimizer = "adam", loss = "categorical_crossentropy") 

model.fit(X_train, y_train, batch_size = batch_size, nb_epoch = nb_epochs, show_accuracy = True, verbose = 2, validation_data = (X_test, y_test)) 
score = model.evaluate(X_test, y_test, show_accuracy = True, verbose = 0) 
print("Test score: ", score[0]) 
print("Test accuracy: ", score[1]) 

इस कोड को चलाता है, और मैं परिणाम की उम्मीद के रूप में मिलती है: लेकिन जब

(60000L, 'train samples') 
(10000L, 'test samples') 
Train on 60000 samples, validate on 10000 samples 
Epoch 1/2 
2s - loss: 0.2988 - acc: 0.9131 - val_loss: 0.1314 - val_acc: 0.9607 
Epoch 2/2 
2s - loss: 0.1144 - acc: 0.9651 - val_loss: 0.0995 - val_acc: 0.9673 
('Test score: ', 0.099454972004890438) 
('Test accuracy: ', 0.96730000000000005) 

इस बिंदु सब कुछ पूरी तरह से चलाता है अप करने के लिए, मैं अपने डेटासेट में उपरोक्त एल्गोरिदम लागू करता हूं, सटीकता फंस जाती है।

मेरे कोड इस प्रकार है:

import os 

import pandas as pd 

from sklearn.cross_validation import train_test_split 

from keras.models import Sequential 
from keras.layers.convolutional import Convolution2D, MaxPooling2D 
from keras.layers.core import Dense, Activation, Dropout, Flatten 
from keras.utils import np_utils 

import AudioProcessing as ap 
import ImageTools as it 

batch_size = 128 
nb_classes = 2 
nb_epoch = 10 


for i in range(20): 
    print "\n" 
# Generate spectrograms if necessary 
if(len(os.listdir("./AudioNormalPathalogicClassification/Image")) > 0): 
    print "Audio files are already processed. Skipping..." 
else: 
    print "Generating spectrograms for the audio files..." 
    ap.audio_2_image("./AudioNormalPathalogicClassification/Audio/","./AudioNormalPathalogicClassification/Image/",".wav",".png",(28,28)) 

# Read the result csv 
df = pd.read_csv('./AudioNormalPathalogicClassification/Result/result.csv', header = None) 

df.columns = ["RegionName","IsNormal"] 

bool_mapping = {True : 1, False : 0} 

nb_classes = 2 

for col in df: 
    if(col == "RegionName"): 
     a = 3  
    else: 
     df[col] = df[col].map(bool_mapping) 

y = df.iloc[:,1:].values 

y = np_utils.to_categorical(y, nb_classes) 

# Load images into memory 
print "Loading images into memory..." 
X = it.load_images("./AudioNormalPathalogicClassification/Image/",".png") 

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0) 

X_train = X_train.reshape(X_train.shape[0], 784) 
X_test = X_test.reshape(X_test.shape[0], 784) 
X_train = X_train.astype("float32") 
X_test = X_test.astype("float32") 
X_train /= 255 
X_test /= 255 

print("X_train shape: " + str(X_train.shape)) 
print(str(X_train.shape[0]) + " train samples") 
print(str(X_test.shape[0]) + " test samples") 

model = Sequential() 


model.add(Dense(output_dim = 100, input_dim = 784, activation= "relu")) 
model.add(Dense(output_dim = 200, activation = "relu")) 
model.add(Dense(output_dim = 200, activation = "relu")) 
model.add(Dense(output_dim = nb_classes, activation = "softmax")) 

model.compile(loss = "categorical_crossentropy", optimizer = "adam") 

print model.summary() 

model.fit(X_train, y_train, batch_size = batch_size, nb_epoch = nb_epoch, show_accuracy = True, verbose = 1, validation_data = (X_test, y_test)) 
score = model.evaluate(X_test, y_test, show_accuracy = True, verbose = 1) 
print("Test score: ", score[0]) 
print("Test accuracy: ", score[1]) 

AudioProcessing.py

import os 
import scipy as sp 
import scipy.io.wavfile as wav 
import matplotlib.pylab as pylab 
import Image 

def save_spectrogram_scipy(source_filename, destination_filename, size): 
    dt = 0.0005 
    NFFT = 1024  
    Fs = int(1.0/dt) 
    fs, audio = wav.read(source_filename) 
    if(len(audio.shape) >= 2): 
     audio = sp.mean(audio, axis = 1) 
    fig = pylab.figure()  
    ax = pylab.Axes(fig, [0,0,1,1])  
    ax.set_axis_off() 
    fig.add_axes(ax) 
    pylab.specgram(audio, NFFT = NFFT, Fs = Fs, noverlap = 900, cmap="gray") 
    pylab.savefig(destination_filename) 
    img = Image.open(destination_filename).convert("L") 
    img = img.resize(size) 
    img.save(destination_filename) 
    pylab.clf() 
    del img 

def audio_2_image(source_directory, destination_directory, audio_extension, image_extension, size): 
    nb_files = len(os.listdir(source_directory)); 
    count = 0 
    for file in os.listdir(source_directory): 
     if file.endswith(audio_extension):   
      destinationName = file[:-4] 
      save_spectrogram_scipy(source_directory + file, destination_directory + destinationName + image_extension, size) 
      count += 1 
      print ("Generating spectrogram for files " + str(count) + "/" + str(nb_files) + ".") 

ImageTools.py

import os 
import numpy as np 
import matplotlib.image as mpimg 
def load_images(source_directory, image_extension): 
    image_matrix = [] 
    nb_files = len(os.listdir(source_directory)); 
    count = 0 
    for file in os.listdir(source_directory): 
     if file.endswith(image_extension): 
      with open(source_directory + file,"r+b") as f: 
       img = mpimg.imread(f) 
       img = img.flatten()     
       image_matrix.append(img) 
       del img 
       count += 1 
       #print ("File " + str(count) + "/" + str(nb_files) + " loaded.") 
    return np.asarray(image_matrix) 

तो मैं इसके बाद के संस्करण कोड और recieve चलाएँ:

Audio files are already processed. Skipping... 
Loading images into memory... 
X_train shape: (2394L, 784L) 
2394 train samples 
1027 test samples 
-------------------------------------------------------------------------------- 
Initial input shape: (None, 784) 
-------------------------------------------------------------------------------- 
Layer (name)     Output Shape     Param # 
-------------------------------------------------------------------------------- 
Dense (dense)     (None, 100)     78500 
Dense (dense)     (None, 200)     20200 
Dense (dense)     (None, 200)     40200 
Dense (dense)     (None, 2)      402 
-------------------------------------------------------------------------------- 
Total params: 139302 
-------------------------------------------------------------------------------- 
None 
Train on 2394 samples, validate on 1027 samples 
Epoch 1/10 
2394/2394 [==============================] - 0s - loss: 0.6898 - acc: 0.5455 - val_loss: 0.6835 - val_acc: 0.5716 
Epoch 2/10 
2394/2394 [==============================] - 0s - loss: 0.6879 - acc: 0.5522 - val_loss: 0.6901 - val_acc: 0.5716 
Epoch 3/10 
2394/2394 [==============================] - 0s - loss: 0.6880 - acc: 0.5522 - val_loss: 0.6842 - val_acc: 0.5716 
Epoch 4/10 
2394/2394 [==============================] - 0s - loss: 0.6883 - acc: 0.5522 - val_loss: 0.6829 - val_acc: 0.5716 
Epoch 5/10 
2394/2394 [==============================] - 0s - loss: 0.6885 - acc: 0.5522 - val_loss: 0.6836 - val_acc: 0.5716 
Epoch 6/10 
2394/2394 [==============================] - 0s - loss: 0.6887 - acc: 0.5522 - val_loss: 0.6832 - val_acc: 0.5716 
Epoch 7/10 
2394/2394 [==============================] - 0s - loss: 0.6882 - acc: 0.5522 - val_loss: 0.6859 - val_acc: 0.5716 
Epoch 8/10 
2394/2394 [==============================] - 0s - loss: 0.6882 - acc: 0.5522 - val_loss: 0.6849 - val_acc: 0.5716 
Epoch 9/10 
2394/2394 [==============================] - 0s - loss: 0.6885 - acc: 0.5522 - val_loss: 0.6836 - val_acc: 0.5716 
Epoch 10/10 
2394/2394 [==============================] - 0s - loss: 0.6877 - acc: 0.5522 - val_loss: 0.6849 - val_acc: 0.5716 
1027/1027 [==============================] - 0s 
('Test score: ', 0.68490593621422047) 
('Test accuracy: ', 0.57156767283349563) 

मैंने नेटवर्क को बदलने की कोशिश की, और अधिक युग जोड़ते हुए, लेकिन मुझे हमेशा वही परिणाम मिलता है जो कोई फर्क नहीं पड़ता। मुझे समझ में नहीं आता कि मुझे एक ही परिणाम क्यों मिल रहा है।

किसी भी मदद की सराहना की जाएगी। धन्यवाद।

संपादित करें: मुझे एक गलती मिली जहां पिक्सेल मान सही ढंग से नहीं पढ़े गए थे। मैं नीचे के रूप में ImageTools.py तय:

import os 
import numpy as np 
from scipy.misc import imread 

def load_images(source_directory, image_extension): 
    image_matrix = [] 
    nb_files = len(os.listdir(source_directory)); 
    count = 0 
    for file in os.listdir(source_directory): 
     if file.endswith(image_extension): 
      with open(source_directory + file,"r+b") as f: 
       img = imread(f)     
       img = img.flatten()       
       image_matrix.append(img) 
       del img 
       count += 1 
       #print ("File " + str(count) + "/" + str(nb_files) + " loaded.") 
    return np.asarray(image_matrix) 

अब मैं वास्तव में ग्रेस्केल पिक्सेल मान 0 से 255 के लिए मिलता है, तो अब मेरी 255 से विभाजित समझ में आता है। हालांकि, मुझे अभी भी एक ही परिणाम मिल गया है।

Answer 1

सबसे संभावित कारण यह है कि अनुकूलक आपके डेटासेट के लिए उपयुक्त नहीं है। प्रलेखन से Keras optimizers की एक सूची यहां दी गई है।

मुझे सलाह है कि आप पहले डिफ़ॉल्ट पैरामीटर मानों के साथ एसजीडी आज़माएं। यदि यह अभी भी काम नहीं करता है, तो सीखने की दर 10 तक विभाजित करें। यदि आवश्यक हो तो कुछ बार करें। यदि आपकी सीखने की दर 1e-6 तक पहुंच जाती है और यह अभी भी काम नहीं करती है, तो आपको एक और समस्या है।

model.compile(loss = "categorical_crossentropy", optimizer = "adam") 

इस के साथ

:

सारांश में, इस लाइन की जगह

opt = SGD(lr=0.01) 
model.compile(loss = "categorical_crossentropy", optimizer = opt) 

और सीखने दर कई बार बदल अगर यह काम नहीं करता।

यदि यह समस्या थी, तो आपको केवल कुछ युगों के बाद होने वाली हानि को देखना चाहिए।

Answer 2

कुछ परीक्षा के बाद, मैंने पाया कि यह मुद्दा डेटा ही था।यह बहुत गंदे था क्योंकि उसी इनपुट में 2 अलग-अलग आउटपुट होते थे, इसलिए भ्रम पैदा करते थे। डेटा को साफ़ करने के बाद अब मेरी शुद्धता% 69 तक बढ़ जाती है। अभी भी अच्छा होने के लिए पर्याप्त नहीं है, लेकिन कम से कम अब मैं यहां से अपना रास्ता बना सकता हूं कि डेटा स्पष्ट है।

import os 
import sys 

import pandas as pd 
import numpy as np 

from keras.models import Sequential 
from keras.layers.convolutional import Convolution2D, MaxPooling2D 
from keras.layers.core import Dense, Activation, Dropout, Flatten 
from keras.utils import np_utils 

sys.path.append("./") 
import AudioProcessing as ap 
import ImageTools as it 


# input image dimensions 
img_rows, img_cols = 28, 28 
dim = 1 
# number of convolutional filters to use 
nb_filters = 32 
# size of pooling area for max pooling 
nb_pool = 2 
# convolution kernel size 
nb_conv = 3 

batch_size = 128 
nb_classes = 2 
nb_epoch = 200 

for i in range(20): 
    print "\n" 

## Generate spectrograms if necessary 
if(len(os.listdir("./AudioNormalPathalogicClassification/Image")) > 0): 
    print "Audio files are already processed. Skipping..." 
else: 
    # Read the result csv 
    df = pd.read_csv('./AudioNormalPathalogicClassification/Result/AudioNormalPathalogicClassification_result.csv', header = None, encoding = "utf-8") 

    df.columns = ["RegionName","Filepath","IsNormal"] 

    bool_mapping = {True : 1, False : 0} 

    for col in df: 
     if(col == "RegionName" or col == "Filepath"): 
      a = 3  
     else: 
      df[col] = df[col].map(bool_mapping) 

    region_names = df.iloc[:,0].values 
    filepaths = df.iloc[:,1].values 
    y = df.iloc[:,2].values 
    #Generate spectrograms and make a new CSV file 
    print "Generating spectrograms for the audio files..." 
    result = ap.audio_2_image(filepaths, region_names, y, "./AudioNormalPathalogicClassification/Image/", ".png",(img_rows,img_cols)) 
    df = pd.DataFrame(data = result) 
    df.to_csv("NormalVsPathalogic.csv",header= False, index = False, encoding = "utf-8") 

# Load images into memory 
print "Loading images into memory..." 
df = pd.read_csv('NormalVsPathalogic.csv', header = None, encoding = "utf-8") 
y = df.iloc[:,0].values 
y = np_utils.to_categorical(y, nb_classes) 
y = np.asarray(y) 

X = df.iloc[:,1:].values 
X = np.asarray(X) 
X = X.reshape(X.shape[0], dim, img_rows, img_cols) 
X = X.astype("float32") 
X /= 255 

print X.shape 

model = Sequential() 

model.add(Convolution2D(64, nb_conv, nb_conv, 
         border_mode='valid', 
         input_shape=(1, img_rows, img_cols))) 

model.add(Activation('relu')) 

model.add(Convolution2D(32, nb_conv, nb_conv)) 
model.add(Activation('relu')) 
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool))) 

model.add(Dropout(0.25)) 

model.add(Flatten()) 

model.add(Dense(128)) 
model.add(Activation('relu')) 

model.add(Dropout(0.5)) 

model.add(Dense(nb_classes)) 
model.add(Activation('softmax')) 

model.compile(loss='categorical_crossentropy', optimizer='adadelta') 

print model.summary() 

model.fit(X, y, batch_size = batch_size, nb_epoch = nb_epoch, show_accuracy = True, verbose = 1) 

Answer 3

चेक बाहर इस एक

sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) 

model.compile(loss = "categorical_crossentropy", 
       optimizer = sgd, 
       metrics=['accuracy'] 
      ) 

बाहर चेक documentation

मैं MNIST