Görüntülerin Bir Sınıflandırmasını Sınıflara Göre Sınıflandırma

Question

Bir dizi resim almam ve bunları sınıflandırma ihtiyacım var.

Sorun şu ki, bu resimler hakkında hiçbir bilgim yok. Bu yüzden bulabildiğim kadar çok tanımlayıcı kullanmayı planlıyorum ve sonra sadece bana verilen tanımlayıcıları tanımlamak için bir PCA yapıyorum.

Eğer yardımcı olursa, çok fazla veri noktasında denetimli öğrenim yapabilirim. Ancak resimlerin birbirine bağlı olma şansı var. Anlamı, her bir Görüntüdeki bilgilerle dizildiğini umduğum halde, Image X'den Image X + 1'e bir gelişme olabilir.

Sorum şunlardır: Python kullanırken

1. Bunu nasıl iyi yapacağım? (İlk olarak hızın konu dışı olduğu bir kavram kanıtı yapmak istiyorum). Hangi kütüphaneleri kullanmalıyım?
2. Resim için örnek var mı? Bu tür bir sınıflandırma var mı? Bir grup tanımlayıcının kullanılması ve PCA ile pişirilmesi örneği. Bu bölüm benim için çok korkutucu, dürüst olmak gerekirse. Python'un benim için böyle bir şey yapması gerektiğini düşünmeme rağmen.

Düzenleme: http://scikit-image.org/ orada bazı tanımlayıcılar var gibi: Ben şu anda bunun için dışarı çalışıyorum düzgün bir kit bulduk. Otomatik özellik çıkarımı yapmanın bir yolu var mıdır ve özellikleri hedef sınıflandırma için tanımlayıcı güce göre sıralar mı? PCA otomatik olarak sıralama yapabilmelidir.

Düzenleme 2: Verilerin depolanması için şimdi biraz daha rafine edilmiş bir çerçevem ​​var. Fat sistemini bir veritabanı olarak kullanacağım. Her sınıfın birleşiminin bir örneği için bir klasörüm olacak. Yani eğer bir resim sınıf 1 ve 2'ye aitse, bu görüntüleri içeren bir klasör img12 olacaktır. Bu şekilde, her sınıf için sahip olduğum veri miktarını daha iyi kontrol edebilirim.

Düzenleme 3: Python için yapmak istediklerimi yapan bir libary (sklearn) örneği buldum. elle yazılmış rakamların tanınmasıyla ilgilidir. Veri kümemi bununla birlikte kullanabileceğim bir şeye dönüştürmeye çalışıyorum.

import pylab as pl 

# Import datasets, classifiers and performance metrics 
from sklearn import datasets, svm, metrics 

# The digits dataset 
digits = datasets.load_digits() 

# The data that we are interested in is made of 8x8 images of digits, 
# let's have a look at the first 3 images, stored in the `images` 
# attribute of the dataset. If we were working from image files, we 
# could load them using pylab.imread. For these images know which 
# digit they represent: it is given in the 'target' of the dataset. 
for index, (image, label) in enumerate(zip(digits.images, digits.target)[:4]): 
    pl.subplot(2, 4, index + 1) 
    pl.axis('off') 
    pl.imshow(image, cmap=pl.cm.gray_r, interpolation='nearest') 
    pl.title('Training: %i' % label) 

# To apply an classifier on this data, we need to flatten the image, to 
# turn the data in a (samples, feature) matrix: 
n_samples = len(digits.images) 
data = digits.images.reshape((n_samples, -1)) 

# Create a classifier: a support vector classifier 
classifier = svm.SVC(gamma=0.001) 

# We learn the digits on the first half of the digits 
classifier.fit(data[:n_samples/2], digits.target[:n_samples/2]) 

# Now predict the value of the digit on the second half: 
expected = digits.target[n_samples/2:] 
predicted = classifier.predict(data[n_samples/2:]) 

print("Classification report for classifier %s:\n%s\n" 
     % (classifier, metrics.classification_report(expected, predicted))) 
print("Confusion matrix:\n%s" % metrics.confusion_matrix(expected, predicted)) 

for index, (image, prediction) in enumerate(
     zip(digits.images[n_samples/2:], predicted)[:4]): 
    pl.subplot(2, 4, index + 5) 
    pl.axis('off') 
    pl.imshow(image, cmap=pl.cm.gray_r, interpolation='nearest') 
    pl.title('Prediction: %i' % prediction) 

pl.show() 

Answer 1

Bir resmi bir piksel vektörüne dönüştürebilir ve bu vektör üzerinde PCA gerçekleştirebilirsiniz. Bu, tanımlayıcıları manuel olarak bulmaya çalışmaktan daha kolay olabilir. Python'da numPy ve sciPy'yi kullanabilirsiniz.Örneğin :

import scipy.io 
from numpy import * 
#every row in the *.mat file is 256*256 numbers representing gray scale values 
#for each pixel in an image. i.e. if XTrain.mat has 1000 lines than each line 
#will be made up of 256*256 numbers and there would be 1000 images in the file. 
#The following loads the image into a sciPy matrix where each row is a vector 
#of length 256*256, representing an image. This code will need to be switched 
#out if you have a different method of storing images. 
Xtrain = scipy.io.loadmat('Xtrain.mat')["Xtrain"] 
Ytrain = scipy.io.loadmat('Ytrain.mat')["Ytrain"] 
Xtest = scipy.io.loadmat('Xtest.mat')["Xtest"] 
Ytest = scipy.io.loadmat('Ytest.mat')["Ytest"] 
learn(Xtest,Xtrain,Ytest,Ytrain,5) #this lowers the dimension from 256*256 to 5 

def learn(testX,trainX,testY,trainY,n): 
    pcmat = PCA(trainX,n) 
    lowdimtrain=mat(trainX)*pcmat #lower the dimension of trainX 
    lowdimtest=mat(testX)*pcmat #lower the dimension of testX 
    #run some learning algorithm here using the low dimension matrices for example 
    trainset = []  

    knnres = KNN(lowdimtrain, trainY, lowdimtest ,k) 
    numloss=0 
    for i in range(len(knnres)): 
     if knnres[i]!=testY[i]: 
      numloss+=1 
    return numloss 

def PCA(Xparam, n): 
    X = mat(Xparam) 
    Xtranspose = X.transpose() 
    A=Xtranspose*X 
    return eigs(A,n) 

def eigs(M,k): 
    [vals,vecs]=LA.eig(M) 
    return LM2ML(vecs[:k]) 

def LM2ML(lm): 
    U=[[]] 
    temp = [] 
    for i in lm: 
     for j in range(size(i)): 
      temp.append(i[0,j]) 
     U.append(temp) 
     temp = [] 
    U=U[1:] 
    return U 

Eğer k-en yakın komşu kullanılan olabilir imajınızı sınıflandırmak amacıyla. yani en yakın görüntüyü bulursanız ve resminizi en yakın resimle en çok oyu kullanarak etiketleyebilirsiniz. Örneğin:

def KNN(trainset, Ytrainvec, testset, k): 
    eucdist = scidist.cdist(testset,trainset,'sqeuclidean') 
    res=[] 
    for dists in eucdist: 
     distup = zip(dists, Ytrainvec) 
     minVals = [] 
    sumLabel=0; 
    for it in range(k): 
     minIndex = index_min(dists) 
     (minVal,minLabel) = distup[minIndex] 
     del distup[minIndex] 
     dists=numpy.delete(dists,minIndex,0) 
     if minLabel == 1: 
      sumLabel+=1 
     else: 
      sumLabel-=1 
     if(sumLabel>0): 
      res.append(1) 
     else: 
      res.append(0) 
    return res 

Answer 2

Ben doğrudan soru cevap vermeyeceğim biliyorum: Burada

i sklearn kullanarak bulundu örnektir. Ama görüntüler büyük ölçüde değişir: uzaktan algılama, nesneler, sahneler, fMRI, biyomedikal, yüzler, vs ... Kategorizasyonunuzu biraz daraltıp bize bildirirseniz yardımcı olur.

Hangi tanımlayıcıları biliyorsunuz? Kullandığım kodun çoğu (bilgisayar vizyon topluluğunun yanı sıra) Python'da değil MATLAB'dadır, ancak benzer kodların mevcut olduğundan eminim (pycv modülü & http://www.pythonware.com/products/pil/). MIT: http://people.csail.mit.edu/jxiao/SUN/'daki insanlardan en son teknolojiye sahip olan bu tanımlayıcı karşılaştırmayı deneyin: GIST, HOG ve SIFT'e bakmayı deneyin, bunları analiz etmek için ne yaptığınıza bağlı olarak oldukça standarttır: sırasıyla sahneler, nesneler veya noktalar .

Answer 3

Birincisi, ithalat kütüphaneleri ve ayıklamak resimler

from sklearn import datasets  
%matplotlib inline 
import sklearn as sk 
import numpy as np 
import matplotlib.pyplot as plt 
digits = datasets.load_digits() 
X_digits = digits.data 
y_digits = digits.target 
ind4 = np.where(y_digits==4) 
ind5= np.where(y_digits==5) 
plt.imshow(X_digits[1778].reshape((8,8)),cmap=plt.cm.gray_r) 

Answer 4

sonra bu özelliği kullanmak:

xx = np.arange (64)

def feature_11 (xx) :

( ) 0 feature_11 (X_digits [1778])

sonra LDA kullanımı:

sklearn.discriminant_analysis içe LinearDiscriminantAnalysis gelen

clf = LinearDiscriminantAnalysis()

ind_all = np.arange (0, len (y_digits))

np.random.shuffle (ind_all)

ind_training = ind_all [0 int (0.8 * len (ind_all))] 012.

ind_test = ind_all [int (0.8 * len (ind_all)):]

clf.fit (X_digits [ind_training] y_digits [ind_training])

y_predicted = clf.predict (X_digits [ind_test ])

plt.subplot (211)

plt.stem (y_predicted)

plt.subplot (212)

plt.stem (y_digits [ind_test], 'r')

plt.stem (y_digits [ind_test] - y_predicted, 'r')

toplamı (y_predicted == y_digits [ind_test])/len (y_predicted)