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.

Procese 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 mediante 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 MATLABParallel Server™ 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 trasladarlo 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 de referencia de la amplia Bioimage. Este conjunto de datos es un conjunto de imágenes biológicas anotado diseñado para pruebas y validación. El conjunto de imágenes proporciona ejemplos de imagen sintética en y fuera de foco, que se pueden usar 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.Introducción al conjunto de datos

En el prompt del sistema en un sistema Linux, utilice el comando de 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 prompt del sistema en un sistema Linux, extraiga los archivos del archivo zip.

unzip BBBC005_v1_images.zip

Examine los nombres de archivo de imagen en 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 de paso bajo Gaussiano con diámetro 1 y un Sigma de 0,25 x de diámetro para simular el desenfoque de foco ().BBBC005_v1_images/SIMCEPImages_A05_C18_F1_s16_w1.TIFC18F1 Identifica la Mancha utilizada.w1

Ver archivos de imagen y algoritmo de prueba

Este ejemplo muestra cómo ver los archivos en el conjunto de datos de 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 celda para crear el algoritmo de recuento de celdas utilizado en la implementación de MapReduce.)

Abra la aplicación procesador por lotes de imágenes. En la franja de 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 el comando Lisene mediante el comando.imageBatchProcessor

Cargue el conjunto de datos de imagen de celda en la aplicación. En la aplicación procesador por lotes de imágenes, haga clic y navegue 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 su código en el archivo de plantilla abierto en el editor.NewMATLAB Para este ejemplo, cree una nueva función que contenga el siguiente código de segmentación de imágenes.

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

Seleccione algunas imágenes mostradas en la aplicación, usando el ratón, y haga clic para ejecutar una prueba de su 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 la ejecución de su algoritmo para verificar que su 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 con nombre 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.

Pruebe el marco de trabajo de MapReduce localmente: preparar datos

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 para que contenga las imágenes. MapReduce utiliza un datastore para procesar datos en pequeños trozos que encajan 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 muestras de imágenes en archivos de secuencia, un formato utilizado por el clúster.HadoopHadoop

Crear un.ImageDatastore Debido a que el algoritmo de segmentación de células implementado en funciona mejor con la mancha del cuerpo de la célula, seleccione sólo 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.

Subconjunto de este ejemplo más, seleccionando cada archivo 100th de los miles de archivos en el conjunto de datos. Esto lleva 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 sobre los archivos de secuencia, consulte.Introducción a MapReduce (MATLAB)

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 Map debe ser una función sin op.Hadoop En este ejemplo, la función Map simplemente guarda los datos de imagen tal cual, 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 de clave-valor respaldado por archivos de secuencia.

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

Llama, pasa tu mapa y reduce las funciones.mapreduce El ejemplo primero llama a la función para especificar dónde tiene lugar el procesamiento.mapreducer Para probar la configurarla y realizar el procesamiento en el sistema local, especifique.0 (Cuando se ejecuta localmente, crea un almacén de datos de clave-valor de vuelta por MAT-files.)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 el marco de trabajo de MapReduce localmente: Ejecute el algoritmo

En este ejemplo se muestra cómo probar el marco de trabajo de MapReduce en el sistema local. Después de crear el subconjunto de archivos de imagen para las pruebas y convertirlos a un almacén de datos de 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ó primero el algoritmo, solo puede devolver imágenes procesadas, no valores como el número 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)); 

Crear mapas y reducir las funciones que realizan el procesamiento deseado. Para este ejemplo, cree una función de mapa que calcule el recuento de errores de una imagen específica. Esta función obtiene el recuento real de celdas de una imagen a partir de la codificación del nombre de archivo (el número) y la 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 de desenfoque de foco difunde los límites de la celda y, por tanto, el área. El resultado esperado es que el error aumente con el desenfoque de foco. Graficar 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 el marco de trabajo de MapReduce 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 de trabajo de MapReduce en un clúster.Hadoop

Cargue los datos de imagen en el sistema de archivos mediante los siguientes comandos de Shell.Hadoop

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 al MATLABParallel Server Clúster.

setenv('HADOOP_HOME','/mathworks/AH/hub/apps_PCT/LS_Hadoop_hadoop01glnxa64/hadoop-2.7.1/'); 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); 
Hadoop with properties:                   HadoopInstallFolder: '/mathworks/AH/hub/apps_PCT/LS_Hadoop_hadoop01glnxa64/hadoop-2.7.1/'              HadoopConfigurationFile: ''                   SparkInstallFolder: ''                     HadoopProperties: [2x1 containers.Map]                      SparkProperties: [0x1 containers.Map]                    ClusterMatlabRoot: '/your_cluster...'              RequiresOnlineLicensing: 0                        LicenseNumber: ''                      AutoAttachFiles: 1                        AttachedFiles: {}                      AdditionalPaths: {} 

Convierta todos los datos de imagen en archivos de secuencia.Hadoop Esto es similar a lo que hizo en su sistema local al convertir un subconjunto de las imágenes para la creación de prototipos. Puede reutilizar el mapa y reducir las funciones que usó 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 de trabajo 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