Error using eig Input matrix contains NaN or Inf from images

Question

Iin Dinariyah 2019-12-20

0
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/497488-error-using-eig-input-matrix-contains-nan-or-inf-from-images

评论： Steven Lord 2019-12-20

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);
    

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

请先登录，再进行评论。

请先登录，再回答此问题。

Answer 1

Christine Tobler 2019-12-20

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/497488-error-using-eig-input-matrix-contains-nan-or-inf-from-images#answer_407225

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 个评论
显示 -1更早的评论隐藏 -1更早的评论

Steven Lord 2019-12-20

在 MATLAB Online 中打开

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.

请先登录，再进行评论。

Error using eig Input matrix contains NaN or Inf from images

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

回答（1 个）

1 个评论
显示 -1更早的评论隐藏 -1更早的评论

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

Error using eig Input matrix contains NaN or Inf from images

0 个评论 显示 -2更早的评论隐藏 -2更早的评论

回答（1 个）

1 个评论 显示 -1更早的评论隐藏 -1更早的评论

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

1 个评论
显示 -1更早的评论隐藏 -1更早的评论