Error using eig Input matrix contains NaN or Inf from images

17 views (last 30 days)
Please Help me to solve this error. I use the AT & T database which you can download from https://github.com/SilvesterHsu/ORLFaceRecognition-PCA/tree/origin/master/att_faces and divide them into training and testing (1 pgm is testing saved on directory testing_set, 2-10 is training saved on directory training_set). Validation_set is same as testing_set. Screenshot (12).png
function eigenfaces()
clear;
% Maximum size (images will be resized if larger)
image_max_width = 46;
image_max_height = 56;
% First, train the database
[database_sets, database_set_images, database_images, database_eigenfaces, database_mean_face, database_weights] = eigenfaces__train(image_max_width, image_max_height);
% Then, use the database to classify faces
eigenfaces__recognize(image_max_width, image_max_height, database_sets, database_set_images, database_images, database_eigenfaces, database_mean_face, database_weights);
% Process validation
eigenfaces__validation(image_max_width, image_max_height, database_sets, database_set_images, database_images, database_eigenfaces, database_mean_face, database_weights);
end
function [database_sets, database_set_images, database_images, database_eigenfaces, database_mean_face, database_weights]=eigenfaces__train(image_max_width, image_max_height)
disp('> Training started...');
tic();
[sets, set_images, images, image_height, image_width, image_count] = eigenfaces__load_images('training_set', image_max_width, image_max_height);
fprintf('Loaded %i images of %ix%i pixels\n', image_count, image_width, image_height);
% Normalized face vectors: GAMMA(i){n} [GAMMA(1), GAMMA(2), ...]
images_gamma = eigenfaces__normalize(images, image_height, image_width, image_count);
% Mean face vector: PSI{1}
image_psi = eigenfaces__mean(images_gamma, image_height, image_width, image_count);
% Substracted mean face vectors: PHI(i) [PHI(1), PHI(2), ...]
images_phi = eigenfaces__mean_substract(images_gamma, image_psi, image_height, image_width, image_count);
% Covariance matrix
covariance_matrix = eigenfaces__process_covariance_matrix(images_phi);
% Eigenvectors
eigenvectors = eigenfaces__process_eigenvectors(covariance_matrix, image_count);
% Eigenfaces
eigenfaces = eigenfaces__process_eigenfaces(eigenvectors);
% Weights
weights = eigenfaces__process_weights(eigenfaces, images_phi, image_count);
% Uncomment this to view first eigenfaces
%eigenfaces__util_images_show(eigenfaces(1:10, :), image_height, image_width, size(eigenfaces(1:10, :), 1));
fprintf('Processing time: %f seconds\n', toc());
disp('> Training ended.');
database_sets = sets;
database_set_images = set_images;
database_images = images;
database_eigenfaces = eigenfaces;
database_mean_face = image_psi;
database_weights = weights;
end
function eigenfaces__recognize(image_max_width, image_max_height, database_sets, database_set_images, database_images, database_eigenfaces, database_mean_face, database_weights)
disp('> Recognition started...');
tic();
[sets, set_images, images, image_height, image_width, image_count] = eigenfaces__load_images('recognition_set', image_max_width, image_max_height);
fprintf('Loaded %i images of %ix%i pixels\n', image_count, image_width, image_height);
% Proceed recognition
results_all = eigenfaces__process_recognizer(database_sets, database_set_images, database_eigenfaces, database_mean_face, database_weights, images, sets, set_images, image_height, image_width, image_count);
eigenfaces__util_recognition_show(images, database_images, sets, database_sets, results_all, image_height, image_width, image_count);
fprintf('Processing time: %f seconds\n', toc());
disp('> Recognition ended.');
end
function eigenfaces__validation(image_max_width, image_max_height, database_sets, database_set_images, database_images, database_eigenfaces, database_mean_face, database_weights)
disp('> Validation started...');
tic();
% TODO: validate the quality of implementation
% -> error rate
% -> speed per recognition unit
[sets, set_images, images, image_height, image_width, image_count] = eigenfaces__load_images('validation_set', image_max_width, image_max_height);
fprintf('Loaded %i images of %ix%i pixels\n', image_count, image_width, image_height);
% Proceed recognition
[results_all, mean_time] = eigenfaces__process_recognizer(database_sets, database_set_images, database_eigenfaces, database_mean_face, database_weights, images, sets, set_images, image_height, image_width, image_count);
% Process error ratio
error_ratio = eigenfaces__util_error_ratio(results_all, sets, database_sets, image_count);
fprintf('Mean time per recognition cycle: %f seconds\n', mean_time);
fprintf('Error ratio of: %f percent\n', error_ratio);
fprintf('Processing time: %f seconds\n', toc());
disp('> Validation ended.');
end
function [sets, set_images, images, image_height, image_width, image_count]=eigenfaces__load_images(image_set, image_max_width, image_max_height)
sets = cell(0, 1);
set_images = cell(0, 1);
images = [];
image_height = 0;
image_width = 0;
image_count = 0;
image_extension = 'pgm';
% List classes
directory_name = sprintf('./%s', image_set);
class_dirs = dir(directory_name);
class_index = find([class_dirs.isdir]);
for c = 1:length(class_index)
class_name = class_dirs(class_index(c)).name;
class_path = fullfile(directory_name, class_name);
% List images
image_files = dir(fullfile(class_path, sprintf('*.%s', image_extension)));
image_index = find(~[image_files.isdir]);
for i = 1:length(image_index)
image_count = image_count + 1;
image_name = image_files(image_index(i)).name;
image_path = fullfile(class_path, image_name);
current_image = imread(image_path);
% Convert to grayscale?
if image_extension ~= 'pgm'
current_image = rgb2gray(current_image);
end
% Resize? (if Image Processing Toolbox is available)
if size(current_image, 1) > image_max_height || size(current_image, 2) > image_max_width
current_image = eigenfaces__util_image_resize(current_image, image_max_width, image_max_height);
end
images = cat(1, images, current_image);
sets{image_count} = [class_name];
set_images{image_count} = [image_name];
[current_image_height, current_image_width] = size(current_image);
if i == 1
% First image size is reference size
image_height = current_image_height;
image_width = current_image_width;
else
% Check next images size matches that of first image (all
% images MUST have the sa~me size)
if current_image_height ~= image_height || current_image_width ~= image_width
throw(MException('MYFUN:image_size', 'Images must all have the same size'));
end
end
end
end
end
function images_gamma=eigenfaces__normalize(images, image_height, image_width, image_count)
images = eigenfaces__normalize_vector_project(images, image_height, image_width, image_count);
images_gamma = images;
end
function images_vector=eigenfaces__normalize_vector_project(images, image_height, image_width, image_count)
images_vector = zeros(image_count, image_height * image_width);
for i = 1:image_count
image_vector = images(((i - 1) * image_height + 1):(i * image_height), :);
image_vector = reshape(image_vector', image_height * image_width, 1)';
image_vector = double(image_vector);
images_vector(i, :) = image_vector;
end
end
function image_psi=eigenfaces__mean(images, image_height, image_width, image_count)
image_psi = zeros(1, image_width * image_height);
for i = 1:image_count
for c = 1:(image_width * image_height)
image_psi(1, c) = image_psi(1, c) + (images(i, c) / image_count);
end
end
end
function images_phi=eigenfaces__mean_substract(images_gamma, image_psi, image_height, image_width, image_count)
images_phi = zeros(image_count, image_height * image_width);
for i = 1:image_count
images_phi(i, :) = images_gamma(i, :) - image_psi;
end
end
function covariance_matrix=eigenfaces__process_covariance_matrix(images_phi)
covariance_matrix = cov(images_phi);
end
function [eigenvectors, eigenvalues]=eigenfaces__process_eigenvectors(covariance_matrix, image_count)
[eigenvectors, eigenvalues] = eig(covariance_matrix);

Answers (1)

Christine Tobler
Christine Tobler on 20 Dec 2019
The variable covariance_matrix contains non-finite values (either Inf meaning infinity, returned for example from 1/0, or NaN meaning not-a-number, returned for example from 0/0): The eig function throws an error because it doesn't accept these values as input, but the problem is earlier on.
Try stepping through the code, inspecting the variables, and find the first place where a variable contains the value Inf or NaN.
  1 Comment
Steven Lord
Steven Lord on 20 Dec 2019
You may want to set an error breakpoint to stop as soon as a non-finite value gets created. If you do something like preallocate with Inf or NaN and so want to stop only when eig gets called and throws an error, you can set an error breakpoint to pause on errors.
One other bit of feedback:
function eigenfaces()
clear;
I recommend getting OUT of the habit of putting clear at the start of each of your code files. If eigenfaces() accepted an input argument, that clear call would throw those inputs into the trash.

Sign in to comment.

Products


Release

R2019a

Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!