1.

Overview of Machine Learning

Machine Learning
Es un conjunto de técnicas para extraer información de los datos. Como usar un historial de
compras para detectar fraudes con tarjetas de crédito. Se aprenderá sobre los modelos de
clasificación. La clasificación es asignar una observación a una clase de conjuntos discreto,
como gato, perro o pingüino. Un modelo es solo una receta matemática que convierte los
datos en una de esas clases de salida.

2. Classification Workflow
2.1. Overview
Overview of the Classification Workflow
Handwriting Data
Las cartas escritas a mano se almacenaron como archivos de texto individuales. Cada
archivo está delimitado por comas y contiene cuatro columnas: una marca de tiempo, la
ubicación horizontal del lápiz, la ubicación vertical del lápiz y la presión del lápiz. La
marca de tiempo es el número de milisegundos transcurridos desde el comienzo de la
recopilación de datos. Las otras variables están en unidades normalizadas (0 a 1). Para las
ubicaciones de la pluma, 0 representa el borde inferior e izquierdo de la superficie de
escritura y 1 representa el borde superior y el derecho.

Puede usar la función de lectura para importar datos tabulares desde una hoja de cálculo o
un archivo de texto y almacenar el resultado como una tabla.
data = readtable ("myfile.xlsx");
Esto importa los datos de la hoja de cálculo myfile.xlsx y los almacena en una tabla
llamada datos.
2.2. Import Data
Puede usar la notación de puntos para referirse a cualquier variable individual dentro de una
tabla
x = mytable.Xdata;
y = mytable.Ydata;
Esto extrae la variable Xdata de la tabla mytable y almacena el resultado en una nueva
variable llamada x. Del mismo modo, la variable Ydata se extrae en y.
Los límites de eje predeterminados distorsionan la relación de aspecto de la letra. Puede
usar el comando de axis para forzar los ejes para preservar la relación de aspecto de los
datos.
Tarea
Use el axis equal para corregir la relación de aspecto de la gráfica.

2.3. Process Data

Las posiciones de la pluma para los datos de escritura a mano se miden en unidades
normalizadas (0 a 1). Sin embargo, la tableta utilizada para registrar los datos no es
cuadrada. Esto significa que una distancia vertical de 1 corresponde a 10 pulgadas, mientras
que la misma distancia horizontal corresponde a 15 pulgadas. Para corregir esto, las
unidades horizontales deben ajustarse al rango [0 1.5] en lugar de [0 1].
Puede usar la notación de puntos para extraer, modificar y reasignar variables en una tabla,
tal como lo haría con cualquier variable.
x = x + 3;
data.XVal = data.XVal + 3;
Normalizing Time
Los valores de tiempo no tienen significado físico. Representan el número de milisegundos
transcurridos desde el inicio de la sesión de recopilación de datos. Esto dificulta la
interpretación de los trazados de la posición del lápiz a través del tiempo. Una variable de
tiempo más útil sería la duración (medida en segundos) desde el comienzo de cada letra.
Puede indexar en variables en una tabla, tal como lo haría con cualquier variable.
finalX = data.XVal (end);
2.4. Extract Features
Calculating Features
¿Qué aspectos de estas letras podrían usarse para distinguir una J de una M o una V? En
lugar de utilizar las señales sin procesar, el objetivo es calcular los valores que destilan la
señal completa en unidades simples y útiles de información conocidas como características.
 Para las letras J y M, una característica simple podría ser la relación de aspecto (la
altura de la letra en relación con el ancho). Es probable que una J sea alta y estrecha,
mientras que una M es más cuadrado.
 En comparación con J y M, una V es rápida de escribir, por lo que la duración de la
señal también podría ser una característica distintiva.

Una característica es simplemente un valor calculado a partir de la señal, como su duración.

La función de range devuelve el rango de valores en una matriz. Es decir, el rango (x) es
equivalente a max (x) - min (x).
El archivo MAT featuredata.mat contiene una tabla de las características extraídas para 470
cartas escritas por una variedad de personas. Las características de la tabla tienen tres
variables: AspectRatio y Duration (las dos características calculadas en la sección anterior)
y Character (la letra conocida).
Tarea
Use la función de scatter para trazar las entidades extraídas, con relación de aspecto en el
eje horizontal y duración en el eje vertical.
scatter(features.AspectRatio,features.Duration)
No está claro si estas características son suficientes para distinguir las tres letras en el
conjunto de datos (J, M y V). La función gscatter crea un diagrama de dispersión agrupado,
es decir, un diagrama de dispersión donde los puntos se colorean de acuerdo con una
variable de agrupación.
Tarea
Use la función gscatter para crear el mismo diagrama de dispersión que antes pero
coloreado de acuerdo con la letra, que se almacena en la variable Character de la tabla de
feature.
gscatter(features.AspectRatio, features.Duration, features.Character)

Use las herramientas de figuras interactivas o las funciones xlim e ylim para ampliar los puntos de
datos cerca del origen. ¿Crees que es posible hacer un modelo razonablemente preciso que use
estas dos características para distinguir estas tres letras?
xlim([0 4])
ylim([0 1.5])
 2.5. Build a model
What is a model?

Un modelo de clasificación es una división del espacio de las variables predictoras en

regiones. A cada región se le asigna una de las clases de salida. En este ejemplo simple con
dos variables predictoras, puede visualizar estas regiones en el plano.
No existe una única forma "correcta" absoluta de dividir el plano en las clases J, M y V.
Los diferentes algoritmos de clasificación dan como resultado diferentes particiones.
Antecedentes
Una manera fácil de clasificar una observación es usar la misma clase que los ejemplos
conocidos más cercanos. Esto se llama un modelo k-vecino más cercano (kNN). Puede
ajustar un modelo kNN pasando una tabla de datos a la función fitcknn.
mdl = fitcknn (data, "ResponseVariable");
La segunda entrada es el nombre de la variable de respuesta en la tabla (es decir, la clase
que desea que prediga el modelo). La salida es una variable que contiene el modelo
ajustado.
Las características y las clases para los 470 ejemplos conocidos se almacenan en la tabla
feature, que se almacena en featuredata.mat.
Tarea
Use la función fitcknn para ajustar un modelo a los datos almacenados en features. Las
clases conocidas se almacenan en la variable llamada Character. Almacene el modelo
resultante en una variable llamada knnmodel.
knnmodel = fitcknn(features,"Character");

Haciendo predicciones
Habiendo construido un modelo a partir de los datos, puede usarlo para clasificar nuevas
observaciones. Esto solo requiere calcular las características de las nuevas observaciones y
determinar en qué región del espacio predictor se encuentran.
Antecedentes
La función de predict determina la clase predicha de nuevas observaciones.
predClass = predic (model, newdata)
Las entradas son el modelo entrenado y una tabla de observaciones, con las mismas
variables predictoras que se usaron para entrenar el modelo. El resultado es una matriz
categórica de la clase predicha para cada observación en newdata.
El archivo featuredata.mat contiene una tabla testdata que tiene las mismas variables que
las características. Sin embargo, las observaciones en testdata no están incluidas en las
características.
Tenga en cuenta que testdata contiene observaciones para las que se conoce la clase
correcta (almacenada en la variable Carácter). Esto proporciona una forma de probar su
modelo comparando las clases predichas por el modelo con las clases verdaderas. La
función de predict ignorará la variable Character al hacer predicciones del modelo.
Tarea
Use la función de predict con el modelo entrenado knnmodel para clasificar las letras en la
tabla testdata. Almacene las predicciones en una variable llamada predictions.
predictions = predict(knnmodel,testdata);

Opciones de algoritmo
Por defecto, fitcknn se ajusta a un modelo kNN con k = 1. Es decir, el modelo usa solo el
ejemplo más cercano conocido para clasificar una observación dada. Esto hace que el
modelo sea sensible a los valores atípicos en los datos de entrenamiento, como los
resaltados en la imagen de arriba. Es probable que las nuevas observaciones cerca de los
valores atípicos se clasifiquen erróneamente.
Puede hacer que el modelo sea menos sensible a las observaciones específicas en los datos
de entrenamiento aumentando el valor de k (es decir, use la clase más común de varios
vecinos). A menudo, esto mejorará el rendimiento del modelo en general. Sin embargo, el
rendimiento de un modelo en un conjunto de pruebas en particular depende de las
observaciones específicas en ese conjunto.

Antecedentes
Puede especificar el valor de k en un modelo kNN configurando la propiedad
"NumNeighbours" al llamar a fitcknn.
mdl = fitcknn (datos, "ResponseVariable", ...
"NumNeighbours", 10);
Tarea
Repita los comandos de las dos tareas anteriores, pero use la opción "NumNeighbours" para
cambiar el número de vecinos en el modelo a 5.
2.6. Evaluate the Model
¿Qué tan bueno es el modelo kNN? La tabla testdata incluye la clase conocida para las
observaciones de prueba. Puede comparar las clases conocidas con las predicciones del
modelo kNN para ver qué tan bien funciona el modelo con los nuevos datos.
Tarea
Utilice el operador == para comparar predictions con las clases conocidas (almacenadas en
la variable Character en la tabla testdata). Almacene el resultado en una variable llamada
iscorrect.
iscorrect = predictions == testdata.Character

1
1
1
1
0
0
1
1
1
1
Tarea
Calcule la proporción de predicciones correctas dividiendo el número de predicciones
correctas entre el número total de predicciones. Almacene el resultado en una variable
llamada accuracy. Puede usar la función de sum para determinar el número de predicciones
correctas y la función numl para determinar el número total de predicciones.
accuracy = sum(iscorrect)/numel(predictions)
0.800
En lugar de la precisión (la proporción de predicciones correctas), una métrica de uso
común para evaluar un modelo es la tasa de clasificación errónea (misclassification rate)(la
proporción de predicciones incorrectas).
Task
Use the ~= operator to determine the misclassification rate. Store the result in a variable
called misclassrate.
swrong = predictions ~= testdata.Character
misclassrate = sum(swrong)/numel(predictions)
 0
0
0
0
1
1
0
0
0
0
Misclassrate = 0.200

La precisión y la tasa de clasificación errónea dan un valor único para el rendimiento

general del modelo, pero puede ser útil ver un desglose más detallado de las clases que
confunde el modelo. Una matriz de confusión muestra el número de observaciones para
cada combinación de clase verdadera y predicha.

Una matriz de confusión se visualiza comúnmente sombreando los elementos de acuerdo

con su valor. A menudo, los elementos diagonales (las clasificaciones correctas) están
sombreados en un color y los otros elementos (las clasificaciones incorrectas) en otro color.
Puede visualizar una matriz de confusión utilizando la función de gráfico de confusión
(confusionchart).
confunsionchart (ytrue, ypred);
donde ytrue es un vector de las clases conocidas e ypred es un vector de las clases
predichas.
Tarea
Use la función confunsionchart para comparar predictions con las etiquetas conocidas
(almacenadas en la variable Character en la tabla testdata).
confusionchart(testdata.Character,predictions)

Puede ser útil investigar las características de las clases comúnmente confundidas. Intente
usar la matriz lógica de clasificaciones incorrectas para indexar en datos de prueba y
predicciones para obtener los datos para las observaciones mal clasificadas. ¿Dónde viven
estas observaciones en el espacio de características? A partir de esto, ¿puede decir por qué
estas observaciones se clasificaron erróneamente?
2.7. Review
Hacer un modelo para 13 letras
Ahora tiene un modelo simple de dos características que funciona bien para tres letras en
particular (J, M y V). ¿Podría este modelo funcionar también para todo el alfabeto? En esta
interacción, creará y probará el mismo modelo kNN que antes, pero para 13 letras (la mitad
del alfabeto inglés).
Antecedentes
El archivo MAT featuredata13letters.mat contiene una tabla (características) de las mismas
características que antes. Sin embargo, ahora los datos incluyen muestras de 13 letras
diferentes.
Tarea
Use la función gscatter para trazar las observaciones en features, con relación de aspecto en
el eje horizontal y duración en el eje vertical, coloreadas por clase (almacenadas en la
variable Character).
Los límites del eje no se evaluarán, pero es posible que desee experimentar con los límites
para ampliar la mayor parte de las observaciones.
gscatter(features.AspectRatio,features.Duration,features.Character)

Use la función fitcknn para ajustar un modelo a los datos. Establezca la propiedad
"NumNeighbours" en 5. Almacene el modelo en una variable llamada knnmodel. Use el
modelo para predecir las clases para las observaciones almacenadas en testdata. Almacene
las predicciones en una variable llamada predictions.
knnmodel = fitcknn(features,"Character","NumNeighbors",5)
predictions = predict(knnmodel,testdata)

La tabla testdata contiene las clases conocidas en la variable Character.

Tarea
Calcule la tasa de clasificación errónea del modelo y cree un gráfico de confusión.
Almacene la tasa de clasificación errónea en una variable llamada misclass.
swrong = predictions ~= testdata.Character
misclass = sum(swrong)/numel(predictions)
confusionchart(testdata.Character,predictions)
No es sorprendente que un modelo con solo dos características (elegido para distinguir tres
letras en particular) no se generalice bien para muchas letras. En las siguientes secciones
aprenderá cómo diseñar más funciones y construir mejores modelos.
 3. Importing and Preprocessing Data
3.1. Organization of Data Files.
Con las funciones de importación, como readtable, se proporciona el nombre de un archivo
y se obtiene los datos que contiene. Pero, cuando se crea un almacén de datos, se
proporciona la ubicación de los datos. Entonces, MATLAB mira todos los archivos de
datos de la ubicación y devuelve una variable que contiene información sobre los archivos
y el formato de su contenido. Como podrían existir muchos datos los datos no se importan
hasta que se solicita. De esta forma, se puede controlar lo que se obtiene y cuándo. La
propiedad files de un almacén de datos contiene la lista de los nombres de archivo
completos de todos los archivos de datos. Muchas veces la información sobre la
observación forma parte de la ruta o nombre del archivo. En tal caso, puede usar funciones
de cadena como extractBetween para localizar y extraer esa información.
3.2. Creating Data Store
Archivos de muestra de escritura a mano
Se recogieron muestras de cada carta de muchos voluntarios diferentes. Algunos
proporcionaron más de una muestra de cada letra. Cada muestra se guardó en un archivo
separado y todos los archivos se almacenaron en una carpeta. Los nombres de los archivos
tienen la forma
user003_B_2.txt
Este archivo contendría la segunda muestra de la letra B escrita por el voluntario designado
"usuario003".
Antecedentes
Puede usar comodines para hacer un almacén de datos para archivos o carpetas que
coincidan con un patrón particular.
ds = datastore ("data * .xlsx");
Los archivos de datos de escritura a mano tienen nombres con el formato user003_B_2.txt.
Task
Use the datastore function to make a datastore to all files containing the letter M. These
files have _M_ in their name and a .txt extension. Store the datastore in a variable called
letterds.
letterds = datastore("*_M_*.txt");

Puede usar la función read para importar los datos de un archivo en el almacén de datos.
datos = read (ds);
El uso de la función read la primera vez importará los datos del primer archivo. Usarlo por
segunda vez importará los datos del segundo archivo, y así sucesivamente.
Task
Import the data from the first file into a table called data.
data = read(letterds)
Task
Visualize the data by plotting the X variable of data on the horizontal axis and the Y
variable on the vertical axis.
plot(data.X,data.Y)

Calling the read function again imports the data from the next file in the datastore.
Task
Import and plot the data from the second file.
data = read(letterds)
plot(data.X,data.Y)
The readall function imports the data from all the files in the datastore into a single
variable.
Task
Use the readall function to import the data from all the files into a table called data.
Visualize the data by plotting Y against X.

Intente importar datos de los archivos que contienen muestras de la letra V.

Anteriormente, realizó un preprocesamiento de cada letra. Sin embargo, tenga en cuenta
que cuando usa readall, no hay una manera simple de determinar dónde terminan los datos
de un archivo y dónde comienzan los datos del siguiente archivo. ¿Qué sucede si intentas
preprocesar todas las letras juntas?
3.3. Adding a Data Transformation
Por lo general, querrá aplicar una serie de operaciones de preprocesamiento a cada muestra
de sus datos sin procesar. El primer paso para automatizar este procedimiento es crear una
función personalizada que aplique sus operaciones de preprocesamiento específicas.
Antecedentes
Puede agregar una función personalizada al final de su secuencia de comandos. Para el
preprocesamiento de datos, la función debe tomar los datos devueltos desde el almacén de
datos como entrada. Debería devolver los datos transformados como salida.
function dataout = functionName (datain)
% hacer algo con datain
dataout = ...
end
Tarea
Cree una función llamada scale al final del script que realice las siguientes operaciones:
data.Time = (data.Time - data.Time (1)) / 1000;
data.X = 1.5 * data.X;
Debido a que estos comandos modifican las variables data directamente, su función debe
usar los datos como variables de entrada y salida.
Tenga en cuenta que la tercera línea del script llama a la función de scale. Su secuencia de
comandos no se ejecutará hasta que se haya creado esta función.
También tenga en cuenta que las funciones locales deben estar al final de un script. Esto
significa que editará las secciones del script fuera de orden en esta interacción. Los
encabezados de sección muestran qué sección del script editar en cada tarea.
letterds = datastore("*_M_*.txt");
data = read(letterds);
data.Time = (data.Time - data.Time(1))/1000;
data.X = 1.5*data.X;
data = scale(data);
plot(data.X,data.Y)
axis equal
plot(data.Time,data.Y)
ylabel("Vertical position")
xlabel("Time")

Almacenes de datos transformados

Actualmente, aún necesita llamar a su función manualmente. Para automatizar la
importación y el preprocesamiento de datos, desea que su almacén de datos aplique esta
función siempre que se lean los datos. Puede hacer esto con un almacén de datos
transformado. La función transform toma un almacén de datos y una función como
entradas. Devuelve un nuevo almacén de datos como salida. Este almacén de datos
transformado aplica la función dada siempre que importa datos.

Antecedentes
Para usar una función como entrada a otra función, cree un identificador de función
agregando el símbolo @ al comienzo del nombre de la función.
transform(ds, @ myfun)
Un identificador de función es una referencia a una función. Sin el símbolo @, MATLAB
interpretará el nombre de la función como una llamada a esa función.
Tarea
Use la función de transform para crear un almacén de datos transformado llamado
preprocds. Este almacén de datos debe aplicar la función de scale a los datos a los que se
hace referencia con letterds.
preprocds = transform(letterds,@scale)

La función de escala ahora debe aplicarse automáticamente cada vez que se leen datos del
almacén de datos de preprocds.
Tarea
Use la función readall para importar todos los datos. Verifique que la función de
preprocesamiento se haya aplicado a cada archivo trazando la variable Y en función del
Time.
data = readall(preprocds)
plot(data.Time,data.Y)

Normalizando datos
La ubicación de una carta no es importante para clasificarla. Lo que importa es la forma.
Un paso de preprocesamiento común para muchos problemas de aprendizaje automático es
normalizar los datos.
Las normalizaciones típicas incluyen el desplazamiento por la media (de modo que la
media de los datos desplazados es 0) o desplazar y escalar los datos en un rango fijo (como
[-1, 1]). En el caso de las letras escritas a mano, cambiar los datos x e y para que tengan una
media 0 asegurará que todas las letras estén centradas alrededor del mismo punto.
Task
Modify the scale function to subtract the mean position from both components:
data.X = data.X - mean(data.X);
data.Y = data.Y - mean(data.Y);
Note that this will introduce a problem that will make the plot appear blank. You will fix
this in the next task. (Tenga en cuenta que esto introducirá un problema que hará que el
gráfico aparezca en blanco. Lo arreglará en la próxima tarea.)
function data = scale(data)
data.Time = (data.Time - data.Time(1))/1000;
data.X = 1.5*data.X;
data.X = data.X - mean(data.X);
data.Y = data.Y - mean(data.Y);
end

Cualquier cálculo (incluido el uso predeterminado de funciones como la media) que

implique NaN dará como resultado NaN. Esto es importante en el aprendizaje automático,
donde a menudo le faltan valores en sus datos. En los datos de escritura a mano, se produce
un NaN donde el escritor levantó la pluma de la tableta.
Puede usar la opción "omitnan" para tener funciones estadísticas como ignorar los valores
faltantes.
mean (x, "omitnan")
Tarea
Agregue la opción "omitnan" a las llamadas a significar en la función de scale.
function data = scale(data)
data.Time = (data.Time - data.Time(1))/1000;
data.X = 1.5*data.X;
data.X = data.X - mean(data.X,"omitnan");
data.Y = data.Y - mean(data.Y,"omitnan");
end
Intente visualizar las letras (Y contra X) para asegurarse de que estén centradas en el
origen. Verifique que el código funcione para la letra V sin ninguna modificación.
Tenga en cuenta que el tamaño de las letras no debería importar a su clasificación.
Diferentes personas tienen diferentes tamaños de escritura. ¿Puede agregar más
preprocesamiento para escalar las letras a un tamaño consistente (sin cambiar su forma)?

4. Engineering Features
Calculate features from raw signals.
4.1 Types of Signal
Los algoritmos de machine learning necesitan datos con un formato concreto: cierto
numero de observaciones, cada una de ellas con varias características. Cuando se crea un
modelo de predicción estas características son las variables de predicción: las entradas que
el modelo usa para determinar la salida.
4.2 Calculating Summary Statistics
Statistical Functions
Measures of Central Tendency
Function Description
Mean Arithmetic mean
median Median (middle) value
mode Most frequent value
trimmean Trimmed mean (mean, excluding outliers)
geomean Geometric mean
harmean Harmonic mean
Measures of Spread

Functio
n Description
range Range of values (largest – smallest)
std Standard deviation
var Variance
mad Mean absolute deviation
iqr Interquartile range (75th percentile minus 25th percentile)

Measures of Shape

Function Description
skewnes Skewness (third central moment)
s
kurtosi Kurtosis (fourth central moment)
s

moment Central moment of arbitrary order

Estadísticas descriptivas
Todas las muestras de escritura a mano se han desplazado para que tengan una media cero
tanto en posición horizontal como vertical. ¿Qué otras estadísticas podrían proporcionar
información sobre la forma de las letras? Las diferentes letras tendrán diferentes
distribuciones de puntos. Las medidas estadísticas que describen la forma de estas
distribuciones podrían ser características útiles.
Antecedentes
El archivo MAT sampleletters.mat contiene tablas b1, b2, d1, d2, m1, m2, v1 y v2 que
contienen los datos de algunos ejemplos específicos seleccionados del conjunto completo
de datos de escritura a mano.
TASK
Use the range function to calculate the aspect ratio of the letter b1 by dividing the range of
values of Y by the range of values of X. Assign the result to a variable called aratiob.
aratiob = range(b1.Y)/range(b1.X);
aratiob = 2.0952
Las letras se preprocesan para tener una media de 0 (tanto en X como en Y). La mediana es
menos sensible a los valores atípicos que la media. Comparar la media con la mediana
puede dar una idea de cuán asimétrica es una distribución.
TASK
Use the median function to calculate the median of b1.X and b1.Y. Store the results in
variables called medxb and medyb, respectively. Remember to use the "omitnan" flag.
medxb = median(b1.X,"omitnan")
medyb = median(b1.Y,"omitnan")

medxb = -0.0538
medyb = -0.0336
La dispersión de los valores se puede medir con la desviación media absoluta (MAD), la
desviación estándar y la varianza. Cada uno de estos calcula el promedio de alguna medida
de la desviación de la media.
TASK
Use the mad function to calculate the mean absolute deviation of b1.X and b1.Y. Store the
results in variables called devxb and devyb, respectively. Note that mad ignores NaNs by
default.
devxb = mad(b1.X)
devyb = mad(b1.Y)

devxb = 0.1519
devyb = 0.4195

TASK
Calculate the same statistics for some other sample letters:
The aspect ratio of v1, stored in aratiov
The median of d1.X, stored in medxd
The median of d1.Y, stored in medyd
The mean absolute deviation of m1.X, stored in devxm
The mean absolute deviation of m1.Y, stored in devym
aratiov = range(v1.Y)/range(v1.X)
medxd = median(d1.X,"omitnan")
medyd = median(d1.Y,"omitnan")
devxm = mad(m1.X)
devym = mad(m1.Y)

4.3 Finding Peaks

Task 1
Local minima and maxima are often important features of a signal. The islocalmin and
islocalmax functions take a signal as input and return a logical array the same length as the
signal.
idx = islocalmin(x);
The value of idx is true whenever the corresponding value in the signal is a local minimum.
TASK
Use the islocalmin and islocalmax functions to create two logical arrays, idxmin and
idxmax, respectively, that determine the local minima and maxima of m1.X.
load sampleletters.mat
plot(m1.Time,m1.X)
idxmin = islocalmin(m1.X)
idxmax = islocalmax(m1.X)

Task 2
Local minima and maxima are defined by computing the prominence of each value in the
signal. The prominence is a measure of how a value compares to the other values around it.
You can obtain the prominence value of each point in a signal by obtaining a second output
from islocalmin or islocalmax.
[idx,p] = islocalmin(x);
TASK
Determine the prominence values for islocalmin(m1.X). Store the result in a variable called
prom. Plot the prominence as a function of the Time variable of m1.
plot(m1.Time,m1.X)
hold on
plot(m1.Time(idxmin),m1.X(idxmin),"o")
plot(m1.Time(idxmax),m1.X(idxmax),"s")
hold off
[idx,prom] = islocalmin(m1.X)
plot(m1.Time,prom)
By default, islocalmin and islocalmax find points with any prominence value above 0. This
means that a maximum is defined as any point that is larger than the two values on either
side of it. For noisy signals you might want to consider only minima and maxima that have
a prominence value above a given threshold.
idx = islocalmin(x,"MinProminence",threshvalue)
When choosing a threshold value, note that prominence values can range from 0 to
range(x).
TASK
Recalculate idxmin and idxmax for m1.X using a minimum prominence threshold of 0.1.
Copy the plotting code from task 1 to visualize the result.
idxmin = islocalmin(m1.X,"MinProminence",0.1)
idxmax = islocalmax(m1.X,"MinProminence",0.1)
Puede pasar idxmin a las funciones nnz o sum para contar el número de mínimos. Intente
calcular el número de mínimos y máximos locales en diferentes señales. ¿Podría ser esta
una característica útil para distinguir entre letras?
4.4 Computing Derivatives
Approximating Velocity
Un aspecto importante de detectar letras escritas en una tableta es que hay información útil
en el ritmo y el flujo de cómo se escriben las letras. Para describir la forma de las señales a
través del tiempo, puede ser útil conocer la velocidad de la pluma o, de manera equivalente,
la pendiente de la gráfica de posición a través del tiempo.
Los datos sin procesar registrados de la tableta solo tienen posición (no velocidad) a través
del tiempo, por lo que la velocidad debe calcularse a partir de los datos sin procesar. Con
puntos de datos discretos, esto significa estimar la velocidad utilizando una aproximación
de diferencia finita
v=Δx/Δt

Background
The diff function calculates the difference between successive elements of an array. That is,
if y = diff(x), then y1=x2−x1, y2=x3−x2, and so on. Note that y will be one element shorter
than x.
TASK
Use the diff function to find the differences between the elements of m2.X. Store the result
in a variable called dX. Similarly, find the differences between the elements of m2.Time
and store the result in a variable called dT.
load sampleletters.mat
plot(m2.Time,m2.X)
grid
dX = diff(m2.X);
dT = diff(m2.Time);
Task 2
TASK
Calculate the approximate derivative of m2.X by dividing dX by dT. Remember to use the
array division operator. Store the result in a variable called dXdT.
dXdT = dX./dT
Task 3
Recall that the output from the diff function is one element shorter than the input.
TASK
Plot dXdT as a function of m2.Time, excluding the final value. Recall that you can use the
end keyword to refer to the last element in an array.
plot(m2.Time(1:end-1),dXdT)
Task 4
TASK
Calculate the approximate derivative of m2.Y. Store the result in a variable called dYdT.
Calculate the maximum values of both dXdT and dYdT. Store the results in variables called
maxdx and maxdy, respectively.
You might want to leave off the semicolons so that you can see the values of maxdx and
maxdy.
dY = diff(m2.Y);
dYdT = dY./dT;
maxdx = max(dXdT) = 4.2971
maxdy = max(dYdT) = Inf
Task 5
Due to limits on the resolution of the data collection procedure, the data contains some
repeated values. If the position and the time are both repeated, then the differences are both
0, resulting in a derivative of 0/0 = NaN. However, if the position values are very slightly
different, then the derivative will be Inf (nonzero divided by 0).
Note that max ignores NaN but not Inf because Inf is larger than any finite value. However,
for this application, both NaN and Inf can be ignored, as they represent repeated data.
You can use the standardizeMissing function to convert a set of values to NaN (or the
appropriate missing value for nonnumeric data types).
xclean = standardizeMissing(x,0);
Here, xclean will be the same as x (including any NaNs), but will have NaN wherever x
had the value 0.
Debido a los límites en la resolución del procedimiento de recopilación de datos, los datos
contienen algunos valores repetidos. Si la posición y el tiempo se repiten, las diferencias
son ambas 0, lo que resulta en una derivada de 0/0 = NaN. Sin embargo, si los valores de
posición son muy diferentes, entonces la derivada será Inf (no cero dividida por 0).
Tenga en cuenta que max ignora NaN pero no Inf porque Inf es mayor que cualquier valor
finito. Sin embargo, para esta aplicación, tanto NaN como Inf pueden ignorarse, ya que
representan datos repetidos.
Puede usar la función standardizeMissing para convertir un conjunto de valores a NaN (o el
valor que falta apropiado para los tipos de datos no numéricos).
xclean = standardizeMissing (x, 0);
Aquí, xclean será el mismo que x (incluidos los NaN), pero tendrá NaN donde x tenga el
valor 0.
TASK
Use the standardizeMissing function to modify dYdT so that all values of Inf are now NaN.
dYdT = standardizeMissing(dYdT,Inf)
maxdy = max(dYdT)

Try calculating the derivatives of different sample letters. Note that a negative value
divided by zero will result in -Inf. You can pass a vector of values to standardizeMissing to
deal with multiple missing values at once.
xclean = standardizeMissing(x,[-Inf 0 Inf]);
4.5 Calculating Correlations
Measuring Similarity
The pair of signals on the left have a significantly different shape to the pair of signals on
the right. However, the relationship between the two signals in each pair is similar in both
cases: in the blue regions, the upper signal is increasing while the lower signal is
decreasing, and vice versa in the yellow regions. Correlation attempts to measure this
similarity, regardless of the shape of the signal.

Background
For the first half of the letter V, the horizontal and vertical positions have a strong negative
linear correlation: when the horizontal position increases, the vertical position decreases
proportionally. Similarly, for the second half, the positions have a strong positive
correlation: when the horizontal position increases, the vertical position also increases
proportionally.
The corr function calculates the linear correlation between variables.
C = corr(x,y);

TASK
Use the corr function to calculate the linear correlation between v2.X and v2.Y. Store the
result in a variable called C.
load sampleletters.mat
plot(v2.X,v2.Y,"o-")
C = corr(v2.X,v2.Y) = NaN

Task 2
Because both variables contain missing data, C is NaN. You can use the "Rows" option to
specify how to avoid missing values.
C = corr(x,y,"Rows","complete");
TASK
Recalculate the correlation between v2.X and v2.Y, this time with the "Rows" option set to
"complete". Store the result in C.
C = corr(v2.X,v2.Y,"rows","complete") = 0.6493
Task 3
The correlation coefficient is always between -1 and +1.
 A coefficient of -1 indicates a perfect negative linear correlation
 A coefficient of +1 indicates a perfect positive linear correlation
 A coefficient of 0 indicates no linear correlation
In this case, there is only a moderate correlation because the calculation has been
performed on the entire signal. It may be more informative to consider the two halves of the
signal separately.
TASK
Use concatenation ([ ]) to make a matrix M with four columns: the first half (elements 1 to
11) of v2.X, the first half of v2.Y, the second half (elements 12 to 22) of v2.X, the second
half of v2.Y.
M = [v2.X(1:11) v2.Y(1:11) v2.X(12:22),v2.Y(12:22)]
Task 4
To calculate the correlation between each pair of several variables, you can pass a matrix to
the corr function, where each variable is a column of the matrix.
M = [x y z];
C = corr(M);
TASK
Use the corr function to calculate the correlations between the columns of M. Store the
result in a variable called Cmat. Don't forget to ignore missing values
Cmat = corr(M,"rows","complete")
The output Cmat is a 4-by-4 matrix of the coefficients of correlation between each pairwise
combination of the columns of M. That is, Cmat(j,k) is the correlation of M(:,j) and M(:,k).
The matrix is symmetric because the correlation between x and y is the same as the
correlation between y and x. The diagonal elements are always equal to 1, because a
variable is always perfectly correlated with itself.
Which variables are highly correlated? Remember that the first two columns of M are the
horizontal and vertical positions of the first half of the signal; the last two columns are the
second half of the signal. Are the correlation coefficients what you expect? Try calculating
the same correlations for v2 and for some other sample letters. Could the correlation
coefficients be useful features to distinguish between letters?
4.6 Automating Feature Extraction: (1/2) Creating a Feature Extraction Function
Custom Preprocessing Functions
Once you have determined the features you want to extract, you will need to apply the
appropriate calculations to every sample in your data set. The first step to automating this
procedure is to make a custom function that takes the data as input and returns an array of
features as output.

Background
Currently the script calculates six features for a given letter (stored in the variable letter).
The six features are stored in six separate variables.
You can use the table function to combine separate variables into a table.
T = table(x,y,z);
TASK
Use the table function to make a table from the features stored in the variables aratio,
numXmin, numYmax, avgdX, avgdY, and corrXY. Store the result in a variable called feat.
load sampleletters.mat
letter = b1;
aratio = range(letter.Y)/range(letter.X)
idxmin = islocalmin(letter.X,"MinProminence",0.1);
numXmin = nnz(idxmin)
idxmax = islocalmax(letter.Y,"MinProminence",0.1);
numYmax = nnz(idxmax)
dT = diff(letter.Time);
dXdT = diff(letter.X)./dT;
dYdT = diff(letter.Y)./dT;
avgdX = mean(dXdT,"omitnan")
avgdY = mean(dYdT,"omitnan")
corrXY = corr(letter.X,letter.Y,"rows","complete")
featurenames = ["AspectRatio","NumMinX","NumMinY","AvgU","AvgV","CorrXY"];
feat = table(aratio,numXmin,numYmax,avgdX,avgdY,corrXY)

Task 2
By default, the table constructed with the table function has default variable names. To
make a table with more useful names, use the 'VariableNames' option.
T = table(x,y,z,'VariableNames',["X","Y","Z"]);
Typically you can use either single or double quotes to specify option names. However,
because strings can represent data for your table, you need to use single quotes when
specifying the 'VariableNames' option.
TASK
Recreate the table of features, feat, but with the table variable names stored in the array
featurenames.
feat =
table(aratio,numXmin,numYmax,avgdX,avgdY,corrXY,'VariableNames',featurenames)
Task 3
TASK
At the end of the script, add a local function called extract that takes a single variable,
letter, as input and returns a table of features, feat, as output. Copy the code from the
beginning of the script and from task 2 to make the body of the function. Test your function
by calling it with b2 as input. Store the result in a variable called featB2.
function feat = extract(letter)
aratio = range(letter.Y)/range(letter.X);
idxmin = islocalmin(letter.X,"MinProminence",0.1);
numXmin = nnz(idxmin);
idxmax = islocalmax(letter.Y,"MinProminence",0.1);
numYmax = nnz(idxmax);
dT = diff(letter.Time);
dXdT = diff(letter.X)./dT;
dYdT = diff(letter.Y)./dT;
avgdX = mean(dXdT,"omitnan");
avgdY = mean(dYdT,"omitnan");
corrXY = corr(letter.X,letter.Y,"rows","complete");
featurenames = ["AspectRatio","NumMinX","NumMinY","AvgU","AvgV","CorrXY"];
feat =
table(aratio,numXmin,numYmax,avgdX,avgdY,corrXY,'VariableNames',featurenames);
end
featB2 = extract(b2)
You can now call extract on any of the sample letters. Because the resulting tables always
have the same size and variable names, you can vertically concatenate them into one table
of features.
(2/2) Extracting Features from Multiple Data Files
Transformed Datastores
To automate your feature extraction, you want your datastore to apply your extraction
function whenever the data is read. As with preprocessing, you can do this with a
transformed datastore.

Task 1
Background

From the raw data, you will typically need to apply both preprocessing and feature
extraction functions. You can apply the transform function repeatedly to add any number of
transformations to the datastore to the raw data.
The script currently applies the scale function to the files in the datastore letterds. The
transformed datastore is stored in the variable preprocds.
TASK
Use the transform function to apply the extract function to the datastore preprocds. Store
the result in a variable called featds.
letterds = datastore("*.txt");
preprocds = transform(letterds,@scale)
featds = transform(preprocds,@extract)
Task 2
TASK
Use the readall function to read, preprocess, and extract features from all the data files.
Store the result in a variable called data.
There are 12 files and the extract function calculates six features for each. Hence, data
should be a 12-by-6 table.
Visualize the imported data by making a scatter plot of AspectRatio on the x-axis and
CorrXY on the y-axis.
data = readall(featds)
scatter(data.AspectRatio,data.CorrXY)
Task 3
The letters that the data represents are given in the data file names, which are of the form
usernnn_X_n.txt. Note that the letter name appears between underscore characters (_X_).
You can use the extractBetween function to extract text that occurs between given strings.
extractedtxt = extractBetween(txt,"abc","xyz")
If txt is the string array ["hello abc 123 xyz","abcxyz","xyzabchelloxyzabc"], then
extractedtxt will be [" 123 ","","hello"].
TASK
Use the extractBetween function to obtain the known letter names from the file names by
looking for text between two underscore characters (_). Store the result in a variable called
knownchar. Recall that the file names are stored in the Files property of the datastore
letterds.
knownchar=extractBetween(letterds.Files,"_","_")
Task 4
For classification problems, you typically want to represent the known label as a categorical
variable. You can use the categorical function to convert an array to categorical type.
xcat = categorical(x)
By default, the unique values in x will be used to define the set of categories.
TASK
Use the categorical function to make knownchar categorical.
knownchar = categorical(knownchar)
Task 5
It is convenient to have the known classes associated with the training data. Recall that you
can create new variables in a table by assigning to a variable using dot notation.
T.newvar = workspacevar
TASK
Add knownchar to the table data as a new variable called Character.
Use the gscatter function to make a grouped scatter plot of AspectRatio on the x-axis and
CorrXY on the y-axis, grouped by Character.
data.Character = knownchar
gscatter(data.AspectRatio,data.CorrXY,data.Character)

Try modifying extract to change the features being calculated from the data. Check that you
can rerun the script to obtain a new version of the table data.
5 Classification Models
5.1 Training and Testing Data
Un modelo simple a uno complejo dado que se puede dar un sobre ajuste y sus resultados
son un poco peores al momento de clasificar nuevos datos.
5.2 Machine Learning Models
Obtener un modelo de entrenamiento a partir de los datos.
“Machine” porque es una máquina (ordenador) que sigue una receta. “Learning” porque el
modelo que resulta depende de los datos de entrenamiento utilizados. El ordenador a
aprendido de los datos.

5.3 Handwriting Features

The MAT-file letterdata.mat contains the table traindata which represents feature data for
2906 samples of individual letters. There are 25 features, including statistical measures,
correlations, and maxima/minima for the position, velocity, and pressure of the pen.
Task 1
Your training data can introduce biases in your model. How are the 26 letters of the
alphabet distributed in the handwriting training data?
Task
Use the histogram function to make a histogram of the known letter classes (stored in the
Character variable of the table traindata).
load letterdata.mat
traindata

histogram(traindata.Character)
Task 2
A boxplot is a simple way to visualize multiple distributions.
boxplot(x,c)
This creates a plot where the boxes represent the distribution of the values of x for each of
the classes in c. If the values of x are typically significantly different for one class than
another, then x is a feature that can distinguish between those classes. The more features
you have that can distinguish different classes, the more likely you are to be able to build an
accurate classification model from the full data set.
Task
Use the boxplot function to make a boxplot of the values of the MADX feature (mean
absolute deviation of the horizontal position) for each letter. The known letter classes are
stored in the variable called Character.

Use the command classificationLearner to open the Classification Learner app.

Select traindata as the data to use.
The app should correctly detect Character as the response variable to predict.
Choose the default validation option.
Select a model and click the Train button.
Try a few of the standard models with default options. See if you can achieve at least 80%
accuracy.
Note that SVMs work on binary classification problems (i.e. where there are only two
classes). To make SVMs work on this problem, the app is fitting many SVMs. These
models will therefore be slow to train.
Similarly, ensemble methods work by fitting multiple models. These will also be slow to
train.

5.4 Making Predictions

Task 1
The MAT-file letterdata.mat contains traindata, the table of data used to train the model
knnmodel. It also contains testdata which is a table of data (with the same features as
traindata) that the model has never seen before.
Recall that you can use the predict function to obtain a model's predictions for new data.
preds = predict(model,newdata)
TASK
Use the predict function to obtain the model's predictions for the test data. Store the result
in a variable called predLetter.
load letterdata.mat
traindata
knnmodel =
fitcknn(traindata,"Character","NumNeighbors",5,"Standardize",true,"DistanceW
eight","squaredinverse");
testdata

predLetter = predict(knnmodel,testdata);

Task 2
In this case, the correct classes for the test data are known. They are stored in the Character
variable of the table testdata.
TASK
Use the ~= operator to determine the misclassification rate (the number of incorrect
predictions divided by the total number of predictions). Store the result in a variable called
misclassrate.
misclassrate = sum(predLetter ~= testdata.Character)/numel(predLetter)
Task 3
The response classes are not always equally distributed in either the training or test data.
Loss is a fairer measure of misclassification that incorporates the probability of each class
(based on the distribution in the data).
loss(model,testdata)
TASK
Use the loss function to determine the test data loss for the kNN model knnmodel. Store the
result in a variable called testloss.
testloss = loss(knnmodel,testdata)
You can calculate the loss on any data set where the correct class is known. Try to
determine the loss of the original training data (traindata). This is known as the
resubstitution loss (the loss when the training data is “resubstituted” into the model). You
can calculate resubstitution loss directly with resubLoss(knnmodel).
5.5 Investigating Misclassification: : (1/2) Identifying Common Misclassifications
The Confusion Matrix
For any response class X, you can divide a machine learning model's predictions into four
groups:
 True positives (green) – predicted to be X and was actually X
 True negatives (blue) – predicted to be not X and was actually not X
 False positives (yellow) – predicted to be X but was actually not X
 False negatives (orange) – predicted to be not X but was actually X
Task 1
Background
When making a confusion chart, you can add information about the false negative and false
positive rate for each class by adding row or column summaries, respectively.
confusionchart(...,"RowSummary","row-normalized)
TASK
Recreate the confusion chart with normalized row summary information.
confusionchart(testdata.Character,predLetter,"RowSummary","row-normalized")
False Negatives

The row summary shows the false negative rate for each class. (With 26 letters, you will
need to enlarge the plot to make the values visible.) This shows which letters the kNN
model has the most difficulty identifying (i.e., the letters the model most often thinks are
something else.) This model has particular difficulty with the letter U, most often mistaking
it for M, N, or V.
Some confusions seem reasonable, such as U/V or H/N. Others are more surprising, such as
U/K. Having identified misclassifications of interest, you will probably want to look at
some the specific data samples to understand what is causing the misclassification.
Task 2
Background
You can use relational and logical operators (such as ==, ~=, &, and |) to identify
observations to study further.
TASK
Use relational and logical operators to create a logical array called falseneg that identifies
instances of the test data where the letter U was classified as something else. That is,
elements where the true class (testdata.Character) is "U" and the predicted class
(predLetter) was not "U".
falseneg = (testdata.Character == "U")&(predLetter~="U")
Task 3
Recall that the Files property of a datastore contains the file names of the original data.
Hence, when you import the data and extract the features, you can keep a record of which
data file is associated with each observation. The string array testfiles contains the file
names for the test data.
TASK
Use the logical array falseneg as an index into testfiles to determine the file names of the
observations that were incorrectly classified as the letter U. Store the result in a variable
called fnfiles.
Similarly, use falseneg as an index into predLetter to determine the associated predicted
letters. Store the result in a variable called fnpred.
fnfiles = testfiles(falseneg)
fnpred = predLetter(falseneg)

Task 4
The fourth element of fnpred is N, which is a common misclassification for the letter U.
What does this particular sample look like?
TASK
Use the readtable to import the data in the fourth element of fnfiles into a table called badU.
Visualize the letter by plotting Y against X.
badU = readtable(fnfiles(4))
plot(badU.X,badU.Y)

Think about the pen position through time for this U and for a typical N. Is it reasonable
that they could be confused with each other?
Try looking at some of the other misclassifications. You can add a title to the plot to show
what the model predicted:
title("Prediction: "+string(fnpred(4)))
5.5 Investigating Misclassifications: (2/2) Investigating Features
Task 1
Having identified examples of interest, you will typically want to examine the
corresponding features.
TASK
Use logical indexing to extract the training data for just the letters N and U. Store the result
in a table called UorN.
Similarly, extract the test data where the letter U was misclassified (i.e., the false negatives
for U). Store the result in a table called fnU
idx = (traindata.Character == "N") | (traindata.Character == "U");
UorN = traindata(idx,:)

idx = (testdata.Character == "U") & (predLetter ~= "U");

fnU = testdata(idx,:)

Task 2
Categorical variables maintain the full list of possible classes, even when only a subset are
present in the data. When examining a subset, it can be useful to redefine the set of possible
classes to only those that are in the data. The removecats function removes unused
categories.
cmin = removecats(cfull)
TASK
Use the removecats function to remove unused categories from UorN.Character. Assign the
result back to UorN.Character.
UorN.Character = removecats(UorN.Character);

Task 3
You can use curly braces ({ }) to extract data from a table into an array of a single type.
datamatrix = datatable{1:10,4:6}
This extracts the first 10 elements of variables 4, 5, and 6. If these variables are numeric,
datamatrix will be a 10-by-3 double array.
TASK
Extract the numeric feature data from UorN and fnU into matrices called UorNfeat and
fnUfeat, respectively.
Note that the last variable in both tables is the response. All other variables are the features.
UorNfeat = UorN{1:219,1:25}
fnUfeat = fnU{1:17,1:25}
Task 4
A parallel coordinates plot shows the value of the features (or “coordinates”) for each
observation as a line.
parallelcoords(data)

To compare the feature values of different classes, use the "Group" option.
parallelcoords(data,"Group",classes)
TASK
Use the parallelcoords function to plot the features in the training data (UorNfeat), grouped
by letter (UorN.Character).
parallelcoords(UorNfeat,"Group",UorN.Character)
Task 5
Because a parallel coordinates plot is just a line plot, you can add individual observations
using the regular plot function.
TASK
Use the plot function to add the values of the features for the fourth misclassified U to the
plot as a black line. (The features for the misclassified letters are stored in the matrix
fnUfeat).
hold on
plot(fnUfeat(4,:),"k")
hold off
Use the zoom tool to explore the plot. Note that N and U have similar values for many
features. Are there any features that help distinguish these letters from each other? A kNN
model uses the distance between observations, where the distance is calculated over all the
features. Does this explain why N and U are hard to distinguish, even if there are some
features that separate them?
When plotting multiple observations by groups, it can be helpful to view the median and a
range for each group, rather than every individual observation. You can use the "Quantile"
option to do this.
parallelcoords(...,"Quantile",0.2)

5.6 Improving the Model

Even if your model works well, you will typically want to look for improvements before
deploying it for use. Theoretically, you could try to improve your results at any part of the
workflow. However, collecting data is typically the most difficult step of the process, which
means you often have to work with the data you have.
If you have the option of collecting more data, you can use the insights you have gained so
far to inform what new data you need to collect.
In the handwriting example, volunteers were instructed only to write lower-case letters
“naturally”. Investigating the data set reveals that there are often discrete groups within a
particular letter, such as a block-letter style and a cursive style. This means that two quite
different sets of features can represent the same letter.
One way to improve the model would be treat these variants as separate classes. However,
this would mean having many more than 26 classes. To train such a model, you would need
to collect more samples, instruct the volunteers to write both block and cursive style, and
label the collected data accordingly.
Low accuracy in both your training and testing sets is an indication that your features do
not provide enough information to distinguish the different classes. In particular, you might
want to look at the data for classes that are frequently confused, to see if there are
characteristics that you can capture as new features.
However, too many features can also be a problem. Redundant or irrelevant features often
lead to low accuracy and increase the chance of overfitting – when your model is learning
the details of the training rather than the broad patterns. A common sign of overfitting is
that your model performs well on the training set but not on new data. You can use a
feature selection technique to find and remove features that do not significantly add to the
performance of your model.
You can also use feature transformation to perform a change of coordinates on your
features. With a technique such as Principal Component Analysis (PCA), the transformed
features are chosen to minimize redundancy and ordered by how much information they
contain.
The Classification Learner app provides an easy way to experiment with different models.
You can also try different options. For example, for kNN models, you can vary the number
of neighbors, the weighting of the neighbors based on distance, and the way that distance
is defined.
Some classification methods are highly sensitive to the training data, which means you
might get very different predictions from different models trained on different subsets of the
data. This can be harnessed as a strength by making an ensemble – training a large
number of these so-called weak learners on different permutations of the training data and
using the distribution of individual predictions to make the final prediction.
For the handwriting example, some pairs of letters (such as N and V) have many similar
features and are distinguished by only one or two key features. This means that a distance-
based method such as kNN may have difficulty with these pairs. An alternative approach is
to use an ensemble approach known as Error-Correcting Output Coding (ECOC) which
use multiple models to distinguish between different binary pairs of classes. Hence, one
model can distinguish between N and V, while another can distinguish between N and E,
and another between E and V, and so on.
When trying to evaluate different models, it is important to have an accurate measure of a
model's performance. The simplest, and computationally cheapest, way to do validation is
holdout – randomly divide your data into a training set and a testing set. This works for
large data sets. However, for many problems, holdout validation can result in the test
accuracy being dependent on the specific choice of test data.
You can use k-fold cross-validation to get a more accurate estimate of performance. In this
approach, multiple models are trained and tested, each on a different division of the data.
The reported accuracy is the average from the different models.
Accuracy is only one simple measure of the model's performance. It is also important to
consider the confusion matrix, false negative rates, and false positive rates. Furthermore,
the practical impact of a false negative may be significantly different to that of a false
positive. For example, a false positive medical diagnosis may cause stress and expense, but
a false negative could be fatal. In these cases, you can incorporate a cost matrix into the
calculation of a model's loss.

6. Conclusion
Learn next steps and give feedback on the course.
6.1 Additional Resources: (1/2) More machine learning applications
Si la salida está intentando predecir es un valor numérico, como el precio de una casa, está
usando regresión en lugar de la clasificación.
Aprendizaje supervisado: Entrena modelos con ejemplos en los que se conoce la salida
correcta
Deep Learning: Es una técnica concreta de machine learnig que utiliza redes neuronales
para extraer características y realizar predicciones.
Unsupervised Learning: Si se desea ver si hay alguna estructura o patrón en los datos.
Reinforcement Learning: Se define una recompensa y se deja que la maquina intente
distintas estrategias para ver cuanta recompensa consigue.