Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Procesar un gran conjunto de imágenes mediante MapReduce Framework y Hadoop

En este ejemplo se muestra cómo ejecutar un algoritmo de recuento de celdas en un gran número de imágenes que usan Con MapReduce y Datastore.Image Processing Toolbox™MATLAB® MapReduce es una técnica de programación para analizar conjuntos de datos que no caben en la memoria. El ejemplo también utiliza MATLAB Parallel Server™ para ejecutar programas MapReduce paralelos en clústeres.Hadoop® En el ejemplo se muestra cómo crear un subconjunto de las imágenes para que pueda probar el algoritmo en un sistema local antes de moverlo al clúster.Hadoop

Descargar datos de muestra

Esta parte del ejemplo muestra cómo descargar el conjunto de datos BBBC005v1 de La colección Broad Bioimage Benchmark. Este conjunto de datos es un conjunto de imágenes biológicas anotados diseñado para pruebas y validación. El conjunto de imágenes proporciona ejemplos de imágenes sintéticas dentro y fuera de foco, que se pueden utilizar para la validación de métricas de foco. El conjunto de datos contiene casi 20.000 archivos. Para obtener más información, consulte este archivo .introducción al conjunto de datos

En el símbolo del sistema en un sistema Linux, utilice el comando para descargar el archivo zip que contiene el conjunto de datos BBBC.wget Antes de ejecutar este comando, asegúrese de que la ubicación de destino tiene suficiente espacio para contener el archivo zip (1,8 GB) y las imágenes extraídas (2,6 GB).

wget http://www.broadinstitute.org/bbbc/BBBC005/BBBC005_v1_images.zip

En el símbolo del sistema en un sistema Linux, extraiga los archivos del archivo zip.

unzip BBBC005_v1_images.zip

Examine los nombres de archivo de imagen de este conjunto de datos. Se construyen en un formato específico para contener información útil sobre cada imagen. Por ejemplo, el nombre de archivo indica que la imagen contiene 18 celdas ( ) y se filtró con un filtro gaussiano de paso bajo con diámetro 1 y una sigma de 0,25x de diámetro para simular el desenfoque de enfoque ( ).BBBC005_v1_images/SIMCEPImages_A05_C18_F1_s16_w1.TIFC18F1 El identifica la mancha utilizada.w1

Ver archivos de imagen y algoritmo de prueba

En este ejemplo se muestra cómo ver los archivos en el conjunto de datos BBBC y probar un algoritmo en un pequeño subconjunto de los archivos mediante la aplicación Procesador por lotes de imágenes. En el ejemplo se prueba un algoritmo simple que segmenta las celdas de las imágenes. (El ejemplo utiliza una versión modificada de este algoritmo de segmentación de celdas para crear el algoritmo de recuento de celdas utilizado en la implementación de MapReduce.)

Abra la aplicación Procesador de lotes de imágenes. En la tira Herramientas, en la pestaña Aplicaciones, en el grupo Procesamiento de imágenes y Visión de equipo, haga clic en .MATLABImage Batch Processor También puede abrir la aplicación desde la licencia de comandos mediante el comando.imageBatchProcessor

Cargue el conjunto de datos de imagen de celda en la aplicación. En la aplicación Procesador de lotes de imágenes, haga clic y desplácese hasta la carpeta en la que almacenó el conjunto de datos descargadoLoad Images

Especifique el nombre de la función que implementa el algoritmo de segmentación de celdas. Para especificar una función existente, escriba su nombre en el campo o haga clic en el icono de carpeta para examinar y seleccionar la función.Function name Para crear una nueva función de procesamiento por lotes, haga clic e introduzca el código en el archivo de plantilla abierto en el editor.NewMATLAB En este ejemplo, cree una nueva función que contenga el siguiente código de segmentación de imagen.

function imout = cellSegmenter(im) % A simple cell segmenter  % Otsu thresholding t  = graythresh(im); bw = im2bw(im,t);  % Show thresholding result in app imout = imfuse(im,bw);  % Find area of blobs stats = regionprops('table',bw,{'Area'});  % Average cell diameter is about 33 pixels (based on random inspection) cellArea = pi*(33/2)^2;  % Estimate cell count based on area of blobs cellsPerBlob = stats.Area/cellArea; cellCount = sum(round(cellsPerBlob)); disp(cellCount); 

Seleccione algunas imágenes que se muestran en la aplicación, con el ratón, y haga clic para ejecutar una ejecución de prueba del algoritmo.Run

Nota

Para este ejemplo, elija solo las imágenes con la mancha " ".w1 El algoritmo de segmentación funciona mejor con estas imágenes.

Examine los resultados de ejecutar el algoritmo para verificar que el algoritmo de segmentación encontró el número correcto de celdas en la imagen. Los nombres de las imágenes contienen el recuento de celdas en el número.C Por ejemplo, la imagen denominada contiene 18 celdas.SIMCEPImages_A05_C18_F1_s05_w1.TIF Compare este número con los resultados devueltos en la línea de comandos para ambas imágenes.

18  18

Pruebe su MapReduce Framework localmente: Prepare Data

En este ejemplo se muestra cómo configurar una versión de prueba pequeña en el sistema local del procesamiento a gran escala que desea realizar. Debe probar el marco de procesamiento antes de ejecutarlo en miles de archivos. Para ello, primero debe crear un almacén de datos de imagen que contenga las imágenes. MapReduce utiliza un almacén de datos para procesar datos en pequeños fragmentos que caben individualmente en la memoria. Para las pruebas locales, seleccione un subconjunto de las imágenes en el almacén de datos para facilitar un proceso de desarrollo iterativo más rápido. Una vez que haya creado el almacén de datos, convierta el subconjunto de ejemplo de imágenes en archivos de secuencia, un formato utilizado por el clúster.HadoopHadoop

Cree un archivo .ImageDatastore Dado que el algoritmo de segmentación de celdas implementado funciona mejor con la mancha del cuerpo de la celda, seleccione solo los archivos con el indicador en sus nombres de archivo.cellSegmenter.mw1

localDataFolder = '/your_data/broad_data/BBBC005_v1_images/'; w1FilesOnly     = fullfile(localDataFolder,'*w1*'); localimds       = imageDatastore(w1FilesOnly); disp(localimds); 
 ImageDatastore with properties:        Files: {              ' .../broad_data/BBBC005_v1_images/SIMCEPImages_A01_C1_F1_s01_w1.TIF';              ' .../broad_data/BBBC005_v1_images/SIMCEPImages_A01_C1_F1_s02_w1.TIF';              ' .../broad_data/BBBC005_v1_images/SIMCEPImages_A01_C1_F1_s03_w1.TIF'               ... and 9597 more              }     ReadFcn: @readDatastoreImage

Tenga en cuenta que todavía hay más de 9000 archivos en el subconjunto.

Subplanta más este ejemplo, seleccionando cada archivo 100 de los miles de archivos del conjunto de datos. Esto reduce el número de archivos a un número más manejable.

localimds.Files = localimds.Files(1:100:end); disp(localimds); 
ImageDatastore with properties:        Files: {              ' .../broad_data/BBBC005_v1_images/SIMCEPImages_A01_C1_F1_s01_w1.TIF';              ' .../broad_data/BBBC005_v1_images/SIMCEPImages_A05_C18_F1_s01_w1.TIF';              ' .../broad_data/BBBC005_v1_images/SIMCEPImages_A09_C35_F1_s01_w1.TIF'               ... and 93 more              }     ReadFcn: @readDatastoreImage

Vuelva a empaquetar el subconjunto de imágenes en archivos de secuencia.Hadoop Tenga en cuenta que este paso simplemente cambia los datos de un formato de almacenamiento a otro sin cambiar el valor de los datos. Para obtener más información acerca de los archivos de secuencia, consulte .Getting Started with MapReduce

Puede utilizar la función para realizar esta conversión.MATLABmapreduce Debe crear una función "map" y una función "reducir" que pase a la función.mapreduce Para convertir los archivos de imagen en archivos de secuencia, la función de mapa debe ser una función sin operación.Hadoop En este ejemplo, la función de mapa simplemente guarda los datos de imagen tal como están, utilizando su nombre de archivo como clave.

function identityMap(data, info, intermKVStore)     add(intermKVStore, info.Filename, data); end 

Cree una función de reducción que convierta los archivos de imagen en un almacén de datos clave-valor respaldado por archivos de secuencia.

function identityReduce(key, intermValueIter, outKVStore)     while hasnext(intermValueIter)         add(outKVStore, key, getnext(intermValueIter));     end end 

Llamar , pasando el mapa y reducir funciones.mapreduce En el ejemplo se llama primero a la función para especificar dónde tiene lugar el procesamiento.mapreducer Para probar la configuración y realizar el procesamiento en el sistema local, especifique .0 (Cuando se ejecuta localmente, crea un almacén de datos clave-valor de nuevo por archivos MAT.)mapreduce En el código siguiente, la función especifica que la operación debe tener lugar en el sistema local.mapreducer

mapreducer(0);  matFolder = 'BBBC005_v1_subset_images_w1_mat'; localmatds = mapreduce(localimds, ...     @identityMap, @identityReduce,...     'OutputFolder', matFolder); disp(localmatds); 
******************************** *      MAPREDUCE PROGRESS      * ******************************** Map   0% Reduce   0% Map  10% Reduce   0% Map  20% Reduce   0% Map  30% Reduce   0% Map  40% Reduce   0% Map  50% Reduce   0% Map  60% Reduce   0% Map  70% Reduce   0% Map  80% Reduce   0% Map  90% Reduce   0% Map 100% Reduce   0% Map 100% Reduce  10% Map 100% Reduce  20% Map 100% Reduce  30% Map 100% Reduce  40% Map 100% Reduce  50% Map 100% Reduce  60% Map 100% Reduce  70% Map 100% Reduce  80% Map 100% Reduce  90% Map 100% Reduce 100%   KeyValueDatastore with properties:         Files: {               ' .../results_1_12-Jun-2015_10-41-25_187.mat';               ' .../results_2_12-Jun-2015_10-41-25_187.mat'               }     ReadSize: 1 key-value pairs     FileType: 'mat' 

Pruebe su MapReduce Framework localmente: ejecute el algoritmo

En este ejemplo se muestra cómo probar el marco MapReduce en el sistema local. Después de crear el subconjunto de archivos de imagen para realizar pruebas y convertirlos en un almacén de datos clave-valor, está listo para probar el algoritmo. Modifique el algoritmo de segmentación de celdas original para devolver el recuento de celdas. (La aplicación Procesador por lotes de imágenes, donde este ejemplo probó por primera vez el algoritmo, solo puede devolver imágenes procesadas, no valores como el recuento de celdas.)

Modifique la función de segmentación de celdas para devolver un recuento de celdas.

function cellCount = cellCounter(im) % A simple cell counter  % Otsu thresholding t  = graythresh(im); bw = im2bw(im,t);  % Show thresholding result in app % imout = imfuse(im,bw);  stats = regionprops('table',bw,{'Area'});  % Average cell diameter is about 33 pixels (based on random inspection) cellArea = pi*(33/2)^2;  % Estimate cell count based on area of blobs cellsPerBlob = stats.Area/cellArea; cellCount = sum(round(cellsPerBlob)); 

Cree mapas y reduzca las funciones que realizan el procesamiento deseado. En este ejemplo, cree una función de mapa que calcule el recuento de errores para una imagen específica. Esta función obtiene el recuento de celdas real para una imagen de la codificación de nombre de archivo (el número) y lo compara con el recuento de celdas devuelto por el algoritmo de segmentación.C

function mapImageToMisCountError(data, ~, intermKVStore)  % Extract the image im = data.Value{1};  % Call the cell counting algorithm actCount = cellCounter(im);  % The original file name is available as the key fileName = data.Key{1}; [~, name] = fileparts(fileName); % Extract expected cell count and focus blur from the file name strs = strsplit(name, '_'); expCount  = str2double(strs{3}(2:end)); focusBlur = str2double(strs{4}(2:end));  diffCount = abs(actCount-expCount);  % Note: focus blur is the key add(intermKVStore, focusBlur, diffCount);  end 

Cree una función de reducción que calcule el error medio en el recuento de celdas para cada valor de foco.

function reduceErrorCount(key, intermValueIter, outKVStore)  focusBlur = key;  % Compute the sum of all differences in cell count for this value of focus % blur count = 0; totalDiff = 0; while hasnext(intermValueIter)     diffCount = getnext(intermValueIter);     count = count +1;     totalDiff = totalDiff+diffCount; end  % Average meanDiff = totalDiff/count;  add(outKVStore, focusBlur, meanDiff); end 

Ejecute el trabajo en su sistema local.mapreduce

focusErrords = mapreduce(localmatds, @mapImageToMisCountError, @reduceErrorCount);  % Gather the result focusErrorTbl = readall(focusErrords); disp(focusErrorTbl); averageErrors = cell2mat(focusErrorTbl.Value);
******************************** *      MAPREDUCE PROGRESS      * ******************************** Map   0% Reduce   0% Map  10% Reduce   0% Map  20% Reduce   0% Map  30% Reduce   0% Map  40% Reduce   0% Map  50% Reduce   0% Map  75% Reduce   0% Map 100% Reduce   0% Map 100% Reduce  13% Map 100% Reduce  25% Map 100% Reduce  38% Map 100% Reduce  50% Map 100% Reduce  63% Map 100% Reduce  75% Map 100% Reduce  88% Map 100% Reduce 100%     Key      Value       ___    _________       1     [ 0.8333]      4     [ 0.6667]      7     [ 0.5000]     10     [ 0.5000]     14     [ 0.5000]     17     [ 0.5000]     20     [ 0.5000]     23     [ 0.3333]     26     [ 0.8333]     29     [ 0.8333]     32     [      3]     35     [      7]     39     [12.3333]     42     [17.3333]     45     [18.3333]     48     [23.8333] 

Inspeccione los resultados en el subconjunto. El algoritmo de recuento de celdas simple utilizado aquí se basa en el área promedio de una celda o un grupo de celdas. El aumento del desenfoque de enfoque difunde los límites de las celdas y, por lo tanto, el área. El resultado esperado es que el error suba con el aumento del desenfoque de enfoque. Trazar los resultados.

bar(focusErrorTbl.Key, averageErrors); ha = gca; ha.XTick = sort(focusErrorTbl.Key); ha.XLim  = [min(focusErrorTbl.Key)-2 max(focusErrorTbl.Key)+2]; title('Cell counting result on a test data set'); xlabel('Focus blur'); ylabel('Average error in cell count'); 

Ejecute MapReduce Framework en un clústerHadoop

En este ejemplo se muestra cómo cargar todos los datos de imagen en el sistema de archivos De Hadoop y ejecutar el marco MapReduce en un clúster.Hadoop

Cargue los datos de imagen en el sistema de archivos mediante los siguientes comandos de shell.Hadoop Para ejecutar este comando, reemplace por la ubicación del equipo.your_data

hadoop fs -mkdir /user/broad_data/ hadoop fs -copyFromLocal /your_data/broad_data/BBBC005_v1_images /user/broad_data/BBBC005_v1_images

Configure el acceso a la MATLAB Parallel Server Clúster. Para ejecutar este comando, reemplace por la ubicación del equipo.'your/hadoop/install'

setenv('HADOOP_HOME','/your/hadoop/install'); cluster = parallel.cluster.Hadoop; cluster.HadoopProperties('mapred.job.tracker') = 'hadoop01glnxa64:54311'; cluster.HadoopProperties('fs.default.name') = 'hdfs://hadoop01glnxa64:54310'; disp(cluster); % Change mapreduce execution environment to point to the remote cluster mapreducer(cluster); 

Convierta todos los datos de imagen en archivos de secuencia.Hadoop Esto es similar a lo que hizo en el sistema local cuando convirtió un subconjunto de las imágenes para crear prototipos. Puede reutilizar el mapa y reducir las funciones que utilizó anteriormente.

% Use the internal Hadoop cluster ingested with Broad Institute files broadFolder = 'hdfs://hadoop01glnxa64:54310/user/broad_data/BBBC005_v1_images';  % Pick only the 'cell body stain' (w1) files for processing w1Files = fullfile(broadFolder, '*w1*.TIF');  % Create an ImageDatastore representing all these files imageDS = imageDatastore(w1Files);  % Specify the output folder. seqFolder = 'hdfs://hadoop01glnxa64:54310/user/datasets/images/broad_data/broad_sequence';  % Convert the images to a key-value datastore. seqds = mapreduce(imageDS, @identityMap, @identityReduce,'OutputFolder', seqFolder); 

Ejecute el algoritmo de recuento de celdas en todo el conjunto de datos almacenado en el sistema de archivos mediante el marco MapReduce.Hadoop El único cambio de la versión local ahora es que las ubicaciones de entrada y salida están en el sistema de archivos.Hadoop

% Output location for error count. output = 'hdfs://hadoop01glnxa64:54310/user/broad_data/BBBC005_focus_vs_errorCount'; tic; focusErrords = mapreduce(seqds, @mapImageToMisCountError, @reduceErrorCount,...     'OutputFolder',output); toc % Gather result focusErrorTbl = readall(focusErrords); disp(focusErrorTbl); averageErrors = cell2mat(focusErrorTbl.Value);  % Plot bar(focusErrorTbl.Key, averageErrors); ha = gca; ha.XTick = sort(focusErrorTbl.Key); ha.XLim  = [min(focusErrorTbl.Key)-2 max(focusErrorTbl.Key)+2]; title('Cell counting result on the entire data set'); xlabel('Focus blur'); ylabel('Average error in cell count'); 
Parallel mapreduce execution on the Hadoop cluster: ******************************** *      MAPREDUCE PROGRESS      * ******************************** Map   0% Reduce   0% Map   7% Reduce   0% Map  10% Reduce   0% Map  12% Reduce   0% Map  20% Reduce   0% Map  23% Reduce   0% Map  25% Reduce   0% Map  28% Reduce   0% Map  30% Reduce   0% Map  32% Reduce   0% Map  33% Reduce   0% Map  38% Reduce   0% Map  41% Reduce   0% Map  43% Reduce   0% Map  48% Reduce   0% Map  50% Reduce   0% Map  51% Reduce   5% Map  53% Reduce   7% Map  55% Reduce  10% Map  56% Reduce  11% Map  58% Reduce  11% Map  62% Reduce  12% Map  64% Reduce  12% Map  65% Reduce  12% Map  67% Reduce  16% Map  69% Reduce  16% Map  71% Reduce  16% Map  74% Reduce  17% Map  75% Reduce  17% Map  76% Reduce  17% Map  79% Reduce  20% Map  83% Reduce  23% Map  85% Reduce  24% Map  88% Reduce  24% Map  92% Reduce  24% Map  94% Reduce  25% Map  96% Reduce  28% Map  97% Reduce  29% Map 100% Reduce  66% Map 100% Reduce  69% Map 100% Reduce  78% Map 100% Reduce  87% Map 100% Reduce  96% Map 100% Reduce 100% Elapsed time is 227.508109 seconds.     Key      Value       ___    _________       4     [ 1.1117]      7     [ 1.0983]     10     [ 1.0500]     14     [ 0.9317]     17     [ 0.8650]     20     [ 0.7583]     23     [ 0.6050]     26     [ 1.0600]     29     [ 1.5750]     32     [ 4.0633]     42     [18.9267]     48     [26.2417]      1     [ 1.0083]     35     [ 7.5650]     39     [13.2383]     45     [20.5500] 

Consulte también

|

Temas relacionados