Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

squeezenet

Red neuronal convolucional SqueezeNet

  • SqueezeNet network architecture

Descripción

SqueezeNet es una red neuronal convolucional con 18 capas de profundidad. Puede cargar una versión preentrenada de la red entrenada en más de un millón de imágenes desde la base de datos [1] de ImageNet. La red preentrenada puede clasificar imágenes en 1000 categorías de objetos (por ejemplo, teclado, ratón, lápiz y muchos animales). Como resultado, la red ha aprendido representaciones ricas en características para una amplia gama de imágenes. Esta función devuelve una red SqueezeNet v1.1, que tiene una precisión similar a la de SqueezeNet v1.0 pero que requiere menos operaciones de punto flotante por predicción [3]. El tamaño de la entrada de imagen de la red es de 227 por 227. Para ver más redes preentrenadas en MATLAB®, consulte Redes neuronales profundas preentrenadas.

Puede utilizar classify para clasificar nuevas imágenes mediante el modelo SqueezeNet. Para ver un ejemplo, consulte Clasificar una imagen con SqueezeNet.

Puede volver a entrenar una red SqueezeNet para realizar una nueva tarea usando la transferencia del aprendizaje. Para ver un ejemplo, consulte Transferencia del aprendizaje interactiva usando SqueezeNet.

ejemplo

net = squeezenet devuelve una red SqueezeNet entrenada con el conjunto de datos de ImageNet.

net = squeezenet('Weights','imagenet') devuelve una red SqueezeNet entrenada con el conjunto de datos de ImageNet. Esta sintaxis es equivalente a net = squeezenet.

lgraph = squeezenet('Weights','none') devuelve la arquitectura de red de SqueezeNet sin entrenar.

Ejemplos

contraer todo

Cargue una red SqueezeNet preentrenada.

net = squeezenet
net = 

  DAGNetwork with properties:

         Layers: [68×1 nnet.cnn.layer.Layer]
    Connections: [75×2 table]

Esta función devuelve un objeto DAGNetwork.

SqueezeNet se incluye en Deep Learning Toolbox™. Para cargar otras redes, utilice funciones como googlenet para obtener los enlaces para descargar redes preentrenadas desde Add-On Explorer.

En este ejemplo se muestra cómo ajustar una red SqueezeNet preentrenada para clasificar una nueva colección de imágenes. Este proceso se denomina transferencia del aprendizaje y suele ser mucho más rápido y fácil que entrenar una nueva red, ya que permite aplicar las características aprendidas a una nueva tarea con menos imágenes de entrenamiento. Para preparar una red para la transferencia del aprendizaje de forma interactiva, utilice Deep Network Designer.

Extraer datos

En el espacio de trabajo, extraiga el conjunto de datos MathWorks Merch. Se trata de un conjunto de datos pequeño que contiene 75 imágenes de artículos promocionales de MathWorks que pertenecen a cinco clases distintas (gorra, cubo, naipes, destornillador y linterna).

unzip("MerchData.zip");

Abrir SqueezeNet en Deep Network Designer

Abra Deep Network Designer con SqueezeNet.

deepNetworkDesigner(squeezenet);

Deep Network Designer muestra una vista alejada de la totalidad de la red en el panel Designer.

Explore la gráfica de red. Para ampliarla con el ratón, utilice Ctrl + la rueda de desplazamiento. Para desplazarse, utilice las teclas de flecha o mantenga pulsada la rueda de desplazamiento y arrastre el ratón. Seleccione una capa para ver sus propiedades. Quite la selección de todas las capas para ver el resumen de la red en el panel Properties.

Importar datos

Para cargar los datos en Deep Network Designer, vaya a la pestaña Data y haga clic en Import Data > Import Image Classification Data.

En la lista Data source, seleccione Folder. Haga clic en Browse y seleccione la carpeta MerchData que ha extraído.

Divida los datos y asigne el 70% al entrenamiento y el 30% a la validación.

Especifique las operaciones de aumento que desea realizar en las imágenes de entrenamiento. Para este ejemplo, aplique una reflexión aleatoria en el eje x, una rotación aleatoria a partir del intervalo [-90,90] grados, y un reescalado aleatorio a partir del intervalo [1,2]. El aumento de datos ayuda a evitar que la red se sobreajuste y memorice los detalles exactos de las imágenes de entrenamiento.

Haga clic en Import para importar los datos en Deep Network Designer.

Visualizar datos

Deep Network Designer permite realizar una inspección visual de la distribución de los datos de entrenamiento y los datos de validación en la pestaña Data. También puede visualizar observaciones aleatorias y sus etiquetas como una comprobación sencilla antes del entrenamiento. Puede ver que, en el caso de este ejemplo, hay cinco clases en el conjunto de datos.

Editar una red para la transferencia del aprendizaje

Las capas convolucionales de la red extraen características de la imagen que la última capa de aprendizaje y la capa de clasificación final utilizan para clasificar la imagen de entrada. Estas dos capas, 'conv10' y 'ClassificationLayer_predictions' en SqueezeNet, contienen información sobre cómo combinar las características que la red extrae en probabilidades de clase, un valor de pérdida y etiquetas predichas. Para volver a entrenar una red preentrenada para clasificar nuevas imágenes, hay que sustituir estas dos capas por otras adaptadas al nuevo conjunto de datos.

En la mayoría de las redes, la última capa con pesos que se pueden aprender es una capa totalmente conectada. En algunas redes, como SqueezeNet, la última capa que se puede aprender es la capa convolucional final. En este caso, sustitúyala por una nueva capa convolucional con un número de filtros igual al número de clases.

En el panel Designer, arrastre una nueva capa convolution2dLayer al lienzo. Para que coincida con la capa convolucional original, establezca FilterSize en 1,1. Cambie NumFilters por el número de clases de los nuevos datos (5 en este ejemplo).

Modifique las tasas de aprendizaje para aprender más rápido en la nueva capa que en las capas transferidas estableciendo los valores WeightLearnRateFactor y BiasLearnRateFactor en 10. Elimine la última capa convolucional 2D y conecte en su lugar la nueva capa.

Sustituya la capa de salida. Desplácese hasta el final de la biblioteca Layer Library y arrastre una nueva capa classificationLayer al lienzo. Elimine la capa de salida original y, en su lugar, conecte la capa nueva.

Comprobar la red

Para asegurarse de que la red editada está lista para entrenar, haga clic en Analyze y asegúrese de que Deep Learning Network Analyzer no detecta ningún error.

Entrenar la red

Especificar las opciones de entrenamiento. Seleccione la pestaña Training y haga clic en Training Options.

  • Para ralentizar el aprendizaje en las capas transferidas, establezca la tasa de aprendizaje inicial en un valor pequeño.

  • Especifique la frecuencia de validación para que la precisión de los datos de validación se calcule una vez por época.

  • Especifique un número pequeño de épocas. Una época es un ciclo de entrenamiento completo en el conjunto total de datos de entrenamiento. En el caso de la transferencia del aprendizaje, no es necesario entrenar durante tantas épocas.

  • Especifique el tamaño de minilote, es decir, cuántas imágenes se pueden utilizar en cada iteración. Para asegurarse de que la totalidad del conjunto de datos se utiliza durante cada época, establezca el tamaño de minilote para dividir el número de muestras de entrenamiento de manera uniforme.

Para este ejemplo, establezca InitialLearnRate en 0.0001, MaxEpochs en 8 y ValidationFrequency en 5. Dado que hay 55 observaciones, establezca MiniBatchSize en 11.

Para entrenar la red con las opciones de entrenamiento especificadas, haga clic en OK y, luego, en Train.

Deep Network Designer permite visualizar y monitorizar el progreso del entrenamiento. Después, puede editar las opciones de entrenamiento y volver a entrenar la red si lo necesita.

Exportar resultados y generar código de MATLAB

Para exportar la arquitectura de red con los pesos entrenados, vaya a la pestaña Training y seleccione Export > Export Trained Network and Results. Deep Network Designer exporta la red entrenada como la variable trainedNetwork_1 y la información del entrenamiento como la variable trainInfoStruct_1.

trainInfoStruct_1
trainInfoStruct_1 = struct with fields:
               TrainingLoss: [1×40 double]
           TrainingAccuracy: [1×40 double]
             ValidationLoss: [3.3420 NaN NaN NaN 2.1187 NaN NaN NaN NaN 1.4291 NaN NaN NaN NaN 0.8527 NaN NaN NaN NaN 0.5849 NaN NaN NaN NaN 0.4678 NaN NaN NaN NaN 0.3967 NaN NaN NaN NaN 0.3875 NaN NaN NaN NaN 0.3749]
         ValidationAccuracy: [20 NaN NaN NaN 30 NaN NaN NaN NaN 55.0000 NaN NaN NaN NaN 65 NaN NaN NaN NaN 85 NaN NaN NaN NaN 95 NaN NaN NaN NaN 95 NaN NaN NaN NaN 95 NaN NaN NaN NaN 95]
              BaseLearnRate: [1×40 double]
        FinalValidationLoss: 0.3749
    FinalValidationAccuracy: 95

También puede generar código de MATLAB, que recrea la red y las opciones de entrenamiento utilizadas. Vaya a la pestaña Training y seleccione Export > Generate Code for Training. Examine el código de MATLAB para aprender a preparar los datos de forma programática para el entrenamiento, a crear la arquitectura de red y a entrenar la red.

Clasificar una imagen nueva

Cargue una nueva imagen para clasificarla con la red entrenada.

I = imread("MerchDataTest.jpg");

Deep Network Designer cambia el tamaño de las imágenes durante el entrenamiento de forma que coincidan con el tamaño de entrada de la red. Para ver el tamaño de entrada de la red, vaya al panel Designer y seleccione imageInputLayer (primera capa). El tamaño de entrada de la red es de 227 por 227.

Cambie el tamaño de la imagen de prueba de forma que coincida con el tamaño de entrada de la red.

I = imresize(I, [227 227]);

Clasifique la imagen de prueba con la red entrenada.

[YPred,probs] = classify(trainedNetwork_1,I);
imshow(I)
label = YPred;
title(string(label) + ", " + num2str(100*max(probs),3) + "%");

En este ejemplo se muestra cómo ajustar una red neuronal convolucional SqueezeNet preentrenada para clasificar una nueva colección de imágenes.

SqueezeNet se ha entrenado con más de un millón de imágenes y puede clasificarlas en 1000 categorías de objetos (como teclado, taza de café, lápiz y muchos animales). La red ha aprendido representaciones ricas en características para una amplia gama de imágenes. La red toma una imagen como entrada y, a continuación, emite una etiqueta para el objeto en la imagen junto con las probabilidades para cada una de las categorías de objetos.

La transferencia del aprendizaje se suele usar en aplicaciones de deep learning. Se puede usar una red preentrenada como punto de partida para aprender una nueva tarea. Ajustar una red con transferencia del aprendizaje suele ser más rápido y fácil que entrenarla con pesos inicializados al azar de cero. Puede transferir de forma rápida las características aprendidas a una nueva tarea con menos imágenes de entrenamiento.

Cargar datos

Descomprima y cargue las nuevas imágenes como un almacén de datos de imágenes. imageDatastore etiqueta de forma automática las imágenes basándose en los nombres de las carpetas y almacena los datos como un objeto ImageDatastore. Un almacén de datos de imágenes permite almacenar un gran volumen de datos de imágenes, incluidos los que no caben en la memoria, y leer eficazmente lotes de imágenes durante el entrenamiento de una red neuronal convolucional.

unzip('MerchData.zip');
imds = imageDatastore('MerchData', ...
    'IncludeSubfolders',true, ...
    'LabelSource','foldernames');

Divida los datos en conjuntos de datos de entrenamiento y de validación. Utilice el 70% de las imágenes para el entrenamiento y el 30% para la validación. splitEachLabel divide el almacén de datos de images en dos nuevos almacenes de datos.

[imdsTrain,imdsValidation] = splitEachLabel(imds,0.7,'randomized');

Este pequeño conjunto de datos ahora contiene solo 55 imágenes de entrenamiento y 20 imágenes de validación. Visualice algunas imágenes de muestra.

numTrainImages = numel(imdsTrain.Labels);
idx = randperm(numTrainImages,16);

I = imtile(imds, 'Frames', idx);

figure
imshow(I)

Figure contains an axes object. The axes object contains an object of type image.

Cargar una red preentrenada

Cargue la red neuronal SqueezeNet preentrenada.

net = squeezenet;

Utilice analyzeNetwork para obtener una visualización interactiva de la arquitectura de la red e información detallada sobre sus capas.

analyzeNetwork(net)

La primera capa, la de entrada de imágenes, requiere imágenes de entrada de un tamaño de 227 por 227 por 3, donde 3 es el número de canales de color.

inputSize = net.Layers(1).InputSize
inputSize = 1×3

   227   227     3

Sustituir capas finales

Las capas convolucionales de la red extraen características de la imagen que la última capa de aprendizaje y la capa de clasificación final utilizan para clasificar la imagen de entrada. Estas dos capas, 'conv10' y 'ClassificationLayer_predictions' en SqueezeNet, contienen información sobre cómo combinar las características que la red extrae en probabilidades de clase, un valor de pérdida y etiquetas predichas. Para volver a entrenar una red preentrenada para clasificar nuevas imágenes, hay que sustituir estas dos capas por otras adaptadas al nuevo conjunto de datos.

Extraiga la gráfica de capas a partir de la red entrenada.

lgraph = layerGraph(net); 

Busque los nombres de las dos capas que ha de sustituir. Puede hacerlo manualmente o puede utilizar la función de soporte findLayersToReplace para encontrar estas capas automáticamente.

[learnableLayer,classLayer] = findLayersToReplace(lgraph);
[learnableLayer,classLayer] 
ans = 
  1x2 Layer array with layers:

     1   'conv10'                            2-D Convolution         1000 1x1x512 convolutions with stride [1  1] and padding [0  0  0  0]
     2   'ClassificationLayer_predictions'   Classification Output   crossentropyex with 'tench' and 999 other classes

En la mayoría de las redes, la última capa con pesos que se pueden aprender es una capa totalmente conectada. En algunas redes, como SqueezeNet, la última capa que se puede aprender es una capa convolucional de 1 por 1. En este caso, sustitúyala por una nueva capa convolucional con un número de filtros igual al número de clases. Para que el aprendizaje sea más rápido en las capas nuevas que en las capas transferidas, aumente los valores de WeightLearnRateFactor y BiasLearnRateFactor en la capa convolucional.

numClasses = numel(categories(imdsTrain.Labels))
numClasses = 5
newConvLayer =  convolution2dLayer([1, 1],numClasses,'WeightLearnRateFactor',10,'BiasLearnRateFactor',10,"Name",'new_conv');
lgraph = replaceLayer(lgraph,'conv10',newConvLayer);

La capa de clasificación especifica las clases de salida de la red. Sustituya la capa de clasificación por una nueva sin etiquetas de clase. trainNetwork establece automáticamente las clases de salida de la capa en el momento del entrenamiento.

newClassificatonLayer = classificationLayer('Name','new_classoutput');
lgraph = replaceLayer(lgraph,'ClassificationLayer_predictions',newClassificatonLayer);

Entrenar la red

La red requiere imágenes de entrada de un tamaño de 227 por 227 por 3, pero las imágenes de los almacenes de datos de imágenes tienen diferentes tamaños. Utilice un almacén de datos de imágenes aumentado para cambiar automáticamente el tamaño de las imágenes de entrenamiento. Especifique operaciones de aumento adicionales para realizar en las imágenes de entrenamiento: voltear aleatoriamente las imágenes de entrenamiento a lo largo del eje vertical y trasladarlas aleatoriamente hasta 30 píxeles horizontal y verticalmente. El aumento de datos ayuda a evitar que la red se sobreajuste y memorice los detalles exactos de las imágenes de entrenamiento.

pixelRange = [-30 30];
imageAugmenter = imageDataAugmenter( ...
    'RandXReflection',true, ...
    'RandXTranslation',pixelRange, ...
    'RandYTranslation',pixelRange);
augimdsTrain = augmentedImageDatastore(inputSize(1:2),imdsTrain, ...
    'DataAugmentation',imageAugmenter);

Para cambiar el tamaño de las imágenes de validación de forma automática sin realizar más aumentos de datos, utilice un almacén de datos de imágenes aumentadas sin especificar ninguna operación adicional de preprocesamiento.

augimdsValidation = augmentedImageDatastore(inputSize(1:2),imdsValidation);

Especifique las opciones de entrenamiento. Para la transferencia del aprendizaje, mantenga las características de las primeras capas de la red preentrenada (los pesos de las capas transferidas). Para ralentizar el aprendizaje en las capas transferidas, establezca la tasa de aprendizaje inicial en un valor pequeño. En el paso anterior, aumentó los factores de la tasa de aprendizaje de la capa convolucional para acelerar el aprendizaje en las nuevas capas finales. Esta combinación de ajustes de la tasa de aprendizaje da como resultado un aprendizaje rápido solo en las capas nuevas y un aprendizaje más lento en las demás. Al realizar la transferencia del aprendizaje, no es necesario entrenar durante tantas épocas. Una época es un ciclo de entrenamiento completo en el conjunto total de datos de entrenamiento. Especifique el tamaño del minilote como 11 para que en cada época se consideren todos los datos. El software valida la red cada iteración de ValidationFrequency durante el entrenamiento.

options = trainingOptions('sgdm', ...
    'MiniBatchSize',11, ...
    'MaxEpochs',7, ...
    'InitialLearnRate',2e-4, ...
    'Shuffle','every-epoch', ...
    'ValidationData',augimdsValidation, ...
    'ValidationFrequency',3, ...
    'Verbose',false, ...
    'Plots','training-progress');

Entrene la red formada por las capas transferidas y las nuevas. De forma predeterminada, trainNetwork usa GPU en caso de que esté disponible. Se requiere Parallel Computing Toolbox™ y un dispositivo con GPU compatible. Para obtener información sobre los dispositivos compatibles, consulte GPU Computing Requirements (Parallel Computing Toolbox). De lo contrario, trainNetwork usa una CPU. También puede especificar el entorno de ejecución con el argumento de par nombre-valor 'ExecutionEnvironment' de trainingOptions.

netTransfer = trainNetwork(augimdsTrain,lgraph,options);

Figure Training Progress (03-Apr-2023 07:58:28) contains 2 axes objects and another object of type uigridlayout. Axes object 1 with xlabel Iteration, ylabel Loss contains 14 objects of type patch, text, line. Axes object 2 with xlabel Iteration, ylabel Accuracy (%) contains 14 objects of type patch, text, line.

Clasificar imágenes de validación

Clasifique las imágenes de validación utilizando la red ajustada.

[YPred,scores] = classify(netTransfer,augimdsValidation);

Visualice cuatro imágenes de validación de muestra con etiquetas predichas.

idx = randperm(numel(imdsValidation.Files),4);
figure
for i = 1:4
    subplot(2,2,i)
    I = readimage(imdsValidation,idx(i));
    imshow(I)
    label = YPred(idx(i));
    title(string(label));
end

Figure contains 4 axes objects. Axes object 1 with title MathWorks Playing Cards contains an object of type image. Axes object 2 with title MathWorks Playing Cards contains an object of type image. Axes object 3 with title MathWorks Cube contains an object of type image. Axes object 4 with title MathWorks Cube contains an object of type image.

Calcule la precisión de la clasificación en el conjunto de validación. La precisión es la fracción de etiquetas que la red predice correctamente.

YValidation = imdsValidation.Labels;
accuracy = mean(YPred == YValidation)
accuracy = 1

Para obtener consejos para mejorar la precisión de la clasificación, consulte Deep Learning Tips and Tricks.

Lea una imagen, cambie su tamaño y clasifíquela con SqueezeNet.

Primero, cargue un modelo SqueezeNet preentrenado.

net = squeezenet;

Lea la imagen con imread.

I = imread('peppers.png');
figure
imshow(I)

Figure contains an axes object. The axes object contains an object of type image.

El modelo preentrenado requiere que el tamaño de la imagen coincida con el tamaño de entrada de la red. Determine el tamaño de entrada de la red con la propiedad InputSize de la primera capa de la red.

sz = net.Layers(1).InputSize
sz = 1×3

   227   227     3

Cambie el tamaño de la imagen para que coincida con el tamaño de entrada de la red.

I = imresize(I,sz(1:2));
figure
imshow(I)

Figure contains an axes object. The axes object contains an object of type image.

Clasifique la imagen con classify.

label = classify(net,I)
label = categorical
     bell pepper 

Muestre la imagen y el resultado de clasificación juntos.

figure
imshow(I)
title(label)

Figure contains an axes object. The axes object with title bell pepper contains an object of type image.

Este ejemplo muestra cómo extraer características de imagen aprendidas de una red neuronal convolucional preentrenada y cómo utilizar esas características para entrenar un clasificador de imágenes.

La extracción de características es la forma más rápida y sencilla de utilizar la capacidad de representación de las redes profundas preentrenadas. Por ejemplo, puede entrenar una máquina de vectores de soporte (SVM) utilizando fitcecoc (Statistics and Machine Learning Toolbox™) en las características extraídas. Como la extracción de características solo requiere una única pasada por los datos, es un buen punto de partida si no tiene una GPU con la que acelerar el entrenamiento de la red.

Cargar datos

Descomprima y cargue las imágenes de muestra como un almacén de datos de imágenes. imageDatastore etiqueta de forma automática las imágenes basándose en los nombres de las carpetas y almacena los datos como un objeto ImageDatastore. Un almacén de datos de imágenes permite almacenar un gran volumen de datos de imágenes, incluidos los que no caben en la memoria. Divida los datos en un 70% de datos de entrenamiento y un 30% de datos de prueba.

unzip("MerchData.zip");

imds = imageDatastore("MerchData", ...
    IncludeSubfolders=true, ...
    LabelSource="foldernames");

[imdsTrain,imdsTest] = splitEachLabel(imds,0.7,"randomized");

Este pequeño conjunto de datos ahora tiene 55 imágenes de entrenamiento y 20 imágenes de validación. Visualice algunas imágenes de muestra.

numImagesTrain = numel(imdsTrain.Labels);
idx = randperm(numImagesTrain,16);

I = imtile(imds,"Frames",idx);

figure
imshow(I)

Cargar una red preentrenada

Cargue una red SqueezeNet preentrenada. SqueezeNet se ha entrenado con más de un millón de imágenes y puede clasificar imágenes en 1000 categorías de objetos, por ejemplo, teclado, ratón, lápiz y muchos animales. Como resultado, el modelo ha aprendido representaciones ricas en características para una amplia gama de imágenes.

net = squeezenet;

Analice la arquitectura de red.

analyzeNetwork(net)

2022-01-07_16-31-30.png

La primera capa, la de entrada de imágenes, requiere imágenes de entrada de un tamaño de 227 por 227 por 3, donde 3 es el número de canales de color.

inputSize = net.Layers(1).InputSize
inputSize = 1×3

   227   227     3

Extraer características de imágenes

La red construye una representación jerárquica de las imágenes de entrada. Las capas más profundas contienen características de nivel más alto construidas con las características de nivel más bajo de capas anteriores. Para obtener las representaciones de las características de las imágenes de entrenamiento y de prueba, utilice activations en la capa de agrupación promedio global "pool10". Para obtener una representación de nivel más bajo de las imágenes, utilice una capa anterior de la red.

La red requiere imágenes de entrada de un tamaño de 227 por 227 por 3, pero las imágenes de los almacenes de datos de imágenes tienen diferentes tamaños. Para cambiar automáticamente el tamaño de las imágenes de entrenamiento y de prueba antes de introducirlas en la red, cree almacenes de datos de imágenes aumentados, especifique el tamaño de imagen deseado y utilice estos almacenes de datos como argumentos de entrada de activations.

augimdsTrain = augmentedImageDatastore(inputSize(1:2),imdsTrain);
augimdsTest = augmentedImageDatastore(inputSize(1:2),imdsTest);

layer = "pool10";
featuresTrain = activations(net,augimdsTrain,layer,OutputAs="rows");
featuresTest = activations(net,augimdsTest,layer,OutputAs="rows");

Extraiga las etiquetas de clase de los datos de entrenamiento y de prueba.

TTrain = imdsTrain.Labels;
TTest = imdsTest.Labels;

Ajustar el clasificador de imágenes

Utilice las características extraídas de las imágenes de entrenamiento como variables predictoras y ajuste una máquina de vectores de soporte (SVM) multiclase con fitcecoc (Statistics and Machine Learning Toolbox).

mdl = fitcecoc(featuresTrain,TTrain);

Clasificar imágenes de prueba

Clasifique las imágenes de prueba con el modelo de SVM entrenado y las características extraídas de las imágenes de prueba.

YPred = predict(mdl,featuresTest);

Muestre cuatro imágenes de prueba de muestra con etiquetas predichas.

idx = [1 5 10 15];
figure
for i = 1:numel(idx)
    subplot(2,2,i)
    I = readimage(imdsTest,idx(i));
    label = YPred(idx(i));
    
    imshow(I)
    title(label)
end

Calcule la precisión de clasificación en el conjunto de prueba. La precisión es la fracción de etiquetas que la red predice correctamente.

accuracy = mean(YPred == TTest)
accuracy = 0.9500

Esta SVM tiene una precisión alta. Si la precisión no es lo suficientemente alta utilizando la extracción de características, pruebe la transferencia del aprendizaje en su lugar.

Argumentos de salida

contraer todo

Red neuronal convolucional SqueezeNet preentrenada, devuelta como objeto DAGNetwork.

Arquitectura de red neuronal convolucional SqueezeNet sin entrenar, devuelta como objeto LayerGraph.

Referencias

[1] ImageNet. http://www.image-net.org

[2] Iandola, Forrest N., Song Han, Matthew W. Moskewicz, Khalid Ashraf, William J. Dally, and Kurt Keutzer. "SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5 MB model size." Preprint, submitted November 4, 2016. https://arxiv.org/abs/1602.07360.

[3] Iandola, Forrest N. "SqueezeNet." https://github.com/forresti/SqueezeNet.

Capacidades ampliadas

Historial de versiones

Introducido en R2018a