Análisis DATASET
Servicio Nacional de Aprendizaje SENA
Martha Yaneth Rodríguez Distrito Capital Gestión Documental
Wolfan Ferney Guevara Monrroy Distrito Capital Talento Humano GTH
Gina Patricia Sánchez Santos Distrito Capital Talento Humano GTH
Miguel Ángel Montenegro Castillo Distrito Capital Gestión Documental
Fanor Andrés Ortiz Orjuela Guaviare Gestión Administrativa
Docente: Jairo Acosta Solano
fecha 02 de septiembre de 2020
Colombia
Pasos a seguir:
1. Instalación del software weka.
2. Dataset [Link] descargado
3. Iniciaremos con la aplicación del algoritmo I3D:
a. Para el dataset car se aplicó en primera instancia el algoritmo I3D, el cual nos
muestra que
tenemos: Instancias correctamente clasificadas 1544 con un porcentaje de 89.35%, con un
porcentaje de instancias erróneamente clasificadas de un 3.53% para un total de 61 instancias
el dataset contiene 1728 instancias y 7 atributos.
El tiempo de entrenamiento del modelo fue de 0.03 segundos.
Su matriz de confusión está dada por:
b. Aplicando el algoritmo J48 tendremos lo siguiente:
Tenemos obviamente las mismas instancias y los mismos atributos analizados con este algoritmo,
pero, en cuanto a las Instancias correctamente clasificadas 1594 con un porcentaje de 92.36%, con
un porcentaje de instancias erróneamente clasificadas de un 7.63% para un total de 132 instancias
Y su matriz de confusión asociada viene dada por:
Por tanto, el algoritmo que más funcional es para este dataset es el J48 dado que nos muestra un
mejor porcentaje de clasificación correcta de instancias de 92.36% sobre el I3D que muestra un
89.35%, pero así mismo el porcentaje erróneo de clasificación de instancias en el J48 también es
mayor que en el I3D.
Para la construcción del árbol tendremos lo siguiente:
La presentación es poco funcional del árbol debido al mismo formato del programa weka.
Árbol en texto de weka:
=== Run information ===
Scheme: [Link].J48 -C 0.25 -M 2
Relation: car
Instances: 1728
Attributes: 7
preciocompra
mantenimiento
puertas
personas
altura-neumatico
seguridad
compra
Test mode: 10-fold cross-validation
=== Classifier model (full training set) ===
J48 pruned tree
------------------
seguridad = bajo: inaccesible (576.0)
seguridad = medio
| personas = 2: inaccesible (192.0)
| personas = 4
| | preciocompra = muy-alto
| | | mantenimiento = muy-alto: inaccesible (12.0)
| | | mantenimiento = alto: inaccesible (12.0)
| | | mantenimiento = medio
| | | | altura-neumatico = pequeno: inaccesible (4.0)
| | | | altura-neumatico = medio: inaccesible (4.0/2.0)
| | | | altura-neumatico = grande: accesible (4.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: inaccesible (4.0)
| | | | altura-neumatico = medio: inaccesible (4.0/2.0)
| | | | altura-neumatico = grande: accesible (4.0)
| | preciocompra = alto
| | | altura-neumatico = pequeno: inaccesible (16.0)
| | | altura-neumatico = medio
| | | | puertas = 2: inaccesible (4.0)
| | | | puertas = 3: inaccesible (4.0)
| | | | puertas = 4: accesible (4.0/1.0)
| | | | puertas = 5-mas: accesible (4.0/1.0)
| | | altura-neumatico = grande
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: accesible (4.0)
| | | | mantenimiento = medio: accesible (4.0)
| | | | mantenimiento = bajo: accesible (4.0)
| | preciocompra = medio
| | | mantenimiento = muy-alto
| | | | altura-neumatico = pequeno: inaccesible (4.0)
| | | | altura-neumatico = medio: inaccesible (4.0/2.0)
| | | | altura-neumatico = grande: accesible (4.0)
| | | mantenimiento = alto
| | | | altura-neumatico = pequeno: inaccesible (4.0)
| | | | altura-neumatico = medio: inaccesible (4.0/2.0)
| | | | altura-neumatico = grande: accesible (4.0)
| | | mantenimiento = medio: accesible (12.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: accesible (4.0)
| | | | altura-neumatico = medio: accesible (4.0/2.0)
| | | | altura-neumatico = grande: bien (4.0)
| | preciocompra = bajo
| | | mantenimiento = muy-alto
| | | | altura-neumatico = pequeno: inaccesible (4.0)
| | | | altura-neumatico = medio: inaccesible (4.0/2.0)
| | | | altura-neumatico = grande: accesible (4.0)
| | | mantenimiento = alto: accesible (12.0)
| | | mantenimiento = medio
| | | | altura-neumatico = pequeno: accesible (4.0)
| | | | altura-neumatico = medio: accesible (4.0/2.0)
| | | | altura-neumatico = grande: bien (4.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: accesible (4.0)
| | | | altura-neumatico = medio: accesible (4.0/2.0)
| | | | altura-neumatico = grande: bien (4.0)
| personas = mas
| | altura-neumatico = pequeno
| | | preciocompra = muy-alto: inaccesible (16.0)
| | | preciocompra = alto: inaccesible (16.0)
| | | preciocompra = medio
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: inaccesible (4.0)
| | | | mantenimiento = medio: accesible (4.0/1.0)
| | | | mantenimiento = bajo: accesible (4.0/1.0)
| | | preciocompra = bajo
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: accesible (4.0/1.0)
| | | | mantenimiento = medio: accesible (4.0/1.0)
| | | | mantenimiento = bajo: accesible (4.0/1.0)
| | altura-neumatico = medio
| | | preciocompra = muy-alto
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: inaccesible (4.0)
| | | | mantenimiento = medio: accesible (4.0/1.0)
| | | | mantenimiento = bajo: accesible (4.0/1.0)
| | | preciocompra = alto
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: accesible (4.0/1.0)
| | | | mantenimiento = medio: accesible (4.0/1.0)
| | | | mantenimiento = bajo: accesible (4.0/1.0)
| | | preciocompra = medio: accesible (16.0/5.0)
| | | preciocompra = bajo
| | | | mantenimiento = muy-alto: accesible (4.0/1.0)
| | | | mantenimiento = alto: accesible (4.0)
| | | | mantenimiento = medio: bien (4.0/1.0)
| | | | mantenimiento = bajo: bien (4.0/1.0)
| | altura-neumatico = grande
| | | preciocompra = muy-alto
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: inaccesible (4.0)
| | | | mantenimiento = medio: accesible (4.0)
| | | | mantenimiento = bajo: accesible (4.0)
| | | preciocompra = alto
| | | | mantenimiento = muy-alto: inaccesible (4.0)
| | | | mantenimiento = alto: accesible (4.0)
| | | | mantenimiento = medio: accesible (4.0)
| | | | mantenimiento = bajo: accesible (4.0)
| | | preciocompra = medio
| | | | mantenimiento = muy-alto: accesible (4.0)
| | | | mantenimiento = alto: accesible (4.0)
| | | | mantenimiento = medio: accesible (4.0)
| | | | mantenimiento = bajo: bien (4.0)
| | | preciocompra = bajo
| | | | mantenimiento = muy-alto: accesible (4.0)
| | | | mantenimiento = alto: accesible (4.0)
| | | | mantenimiento = medio: bien (4.0)
| | | | mantenimiento = bajo: bien (4.0)
seguridad = alto
| personas = 2: inaccesible (192.0)
| personas = 4
| | preciocompra = muy-alto
| | | mantenimiento = muy-alto: inaccesible (12.0)
| | | mantenimiento = alto: inaccesible (12.0)
| | | mantenimiento = medio: accesible (12.0)
| | | mantenimiento = bajo: accesible (12.0)
| | preciocompra = alto
| | | mantenimiento = muy-alto: inaccesible (12.0)
| | | mantenimiento = alto: accesible (12.0)
| | | mantenimiento = medio: accesible (12.0)
| | | mantenimiento = bajo: accesible (12.0)
| | preciocompra = medio
| | | mantenimiento = muy-alto: accesible (12.0)
| | | mantenimiento = alto: accesible (12.0)
| | | mantenimiento = medio
| | | | altura-neumatico = pequeno: accesible (4.0)
| | | | altura-neumatico = medio: accesible (4.0/2.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: bien (4.0)
| | | | altura-neumatico = medio: bien (4.0/2.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | preciocompra = bajo
| | | mantenimiento = muy-alto: accesible (12.0)
| | | mantenimiento = alto
| | | | altura-neumatico = pequeno: accesible (4.0)
| | | | altura-neumatico = medio: accesible (4.0/2.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | | mantenimiento = medio
| | | | altura-neumatico = pequeno: bien (4.0)
| | | | altura-neumatico = medio: bien (4.0/2.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: bien (4.0)
| | | | altura-neumatico = medio: bien (4.0/2.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| personas = mas
| | preciocompra = muy-alto
| | | mantenimiento = muy-alto: inaccesible (12.0)
| | | mantenimiento = alto: inaccesible (12.0)
| | | mantenimiento = medio: accesible (12.0/1.0)
| | | mantenimiento = bajo: accesible (12.0/1.0)
| | preciocompra = alto
| | | mantenimiento = muy-alto: inaccesible (12.0)
| | | mantenimiento = alto: accesible (12.0/1.0)
| | | mantenimiento = medio: accesible (12.0/1.0)
| | | mantenimiento = bajo: accesible (12.0/1.0)
| | preciocompra = medio
| | | mantenimiento = muy-alto: accesible (12.0/1.0)
| | | mantenimiento = alto: accesible (12.0/1.0)
| | | mantenimiento = medio
| | | | altura-neumatico = pequeno: accesible (4.0/1.0)
| | | | altura-neumatico = medio: muy-bien (4.0/1.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: bien (4.0/1.0)
| | | | altura-neumatico = medio: muy-bien (4.0/1.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | preciocompra = bajo
| | | mantenimiento = muy-alto: accesible (12.0/1.0)
| | | mantenimiento = alto
| | | | altura-neumatico = pequeno: accesible (4.0/1.0)
| | | | altura-neumatico = medio: muy-bien (4.0/1.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | | mantenimiento = medio
| | | | altura-neumatico = pequeno: bien (4.0/1.0)
| | | | altura-neumatico = medio: muy-bien (4.0/1.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
| | | mantenimiento = bajo
| | | | altura-neumatico = pequeno: bien (4.0/1.0)
| | | | altura-neumatico = medio: muy-bien (4.0/1.0)
| | | | altura-neumatico = grande: muy-bien (4.0)
Number of Leaves : 131
Size of the tree : 182
Time taken to build model: 0.06 seconds
=== Stratified cross-validation ===
=== Summary ===
Correctly Classified Instances 1596 92.3611 %
Incorrectly Classified Instances 132 7.6389 %
Kappa statistic 0.8343
Mean absolute error 0.0421
Root mean squared error 0.1718
Relative absolute error 18.3833 %
Root relative squared error 50.8176 %
Total Number of Instances 1728
4. Aplique igualmente el algoritmo apropiado para generar reglas de clasificación en el
mismo conjunto de datos.
Con el algoritmo J48 con los valores por defecto de weka
Regla PRISM:
Con la regla JRip:
Con la regla PART:
Por lo tanto, la regla más adecuada para trabajar con el algoritmo J48 es la regla PART dado que:
las instancias correctamente clasificadas son 1655 95.7755 % y
Las instancias incorrectamente clasificadas son 73 4.2245 %
5. Por último, entrene el modelo con el algoritmo de Redes Neuronales Multilayer
Perceptron.
.
.
.
.
.
Scheme: [Link] -L 0.3 -M 0.2 -N 500 -V 0 -S 0 -E 20 -H
a
Datast: car
Instancias: 1728
Atributos: 7
Nodos 16
Clases:
Class inaccesible
Input
Node 0
Class accesible
Input
Node 1
Class bien
Input
Node 2
Class muy-bien
Input
Node 3
Clasificación de la red neuronal de forma correcta: 1720 99.537 %
Clasificación de la red neuronal de forma incorrecta: 8 0.463 %
Características de la red neuronal:
Grafica de la red neuronal
Entrenamiento de la red neuronal
Error de 0.0000487
Momentum 0.2
Taza de aprendizaje 0.3
Numero de iteraciones 500
Aumentando el número de iteraciones a 2500
El error disminuye a 0.0000078
Preguntas
1. Haga una descripción de las características principales del Dataset, Utilizando el algoritmo
mejor destacado para este dataset podemos destacar lo siguiente:
a. Número total de instancias del dataset 1728
b. Número total de instancias correctamente clasificadas 1596 92.36%
c. Número total de instancias erróneamente clasificadas 132 7.63%
d. La clase del dataset compra
e. El tiempo de entrenamiento 0.06 segundos
f. Numero de niveles (hojas) 131
g. Tamaño del árbol en niveles 182
h. Características de análisis del algoritmo J48
i. Opciones del algoritmo J48
j. Atributo de mayor ganancia seguridad
k. Visualización de todos los atributos incluyendo la clase
2. Cuáles fueron los tiempos de entrenamiento de cada uno de los algoritmos utilizados,
indicando el mejor y peor tiempo.
Tiempo de entrenamiento para el algoritmo I3D 0.03 segundos
Tiempo de entrenamiento para algoritmo J48 0.06 segundos
El mejor tiempo es el de I3D
3. Qué modelo clasifica correctamente el mayor número de instancias, ¿cree apropiado
hacer uso de este modelo para clasificar instancias nuevas?
El modelo que clasifica el mayor número de instancias es el algoritmo J48 con un total de 1596
instancias, contra 1544 del I3D.
Si es apropiado utilizar este algoritmo para instancias nuevas dado que su rata de instancias
correctamente clasificadas es de 92.36%, pero se debe tener en cuenta que el porcentaje de
instancias incorrectamente clasificadas es más alto en el algoritmo J48 que en el algoritmo I3D.
4. Adjunte al final del entregable las salidas de entrenamiento y validación de cada uno de
los modelos entrenados.
Salida Algoritmo I3D
Salida algoritmo J48
La presentación es poco funcional del árbol debido al mismo formato del programa weka.
5. Opcional: Si hizo cambios en los valores por defecto de los modelos indique se este
cambio mejoró la precisión de la clasificación.
Si en e algoritmo J48 en el factor de confianza se varió a un máximo de 0.99, lo cual nos arroja un
resultado de 1627 instancias correctamente clasificadas con un porcentaje de 94.15%, pero así
mismo las instancias incorrectamente clasificadas fueron 101 para un porcentaje de 5.84%
6. Opcional: Puede probar otros modelos diferentes a los tratados en clase e incluirlos en su
análisis
a. Con el algoritmo decision stump el resultado es el siguiente:
Las instancias correctamente clasificadas bajan y las incorrectamente clasificadas aumentan
sustancialmente
b. Para el algoritmo Hoeffding tree las instancias correctamente clasificadas y las no
clasificadas adecuadamente, se ubican en un punto medio entre el J48 y el decision stump,
pero aun presentan valores poco fiables.
c. Pero el algoritmo LMT, excede los márgenes anteriormente mencionados dado que la
cantidad de instancias correctamente clasificadas llega a un máximo de 1707 con un
porcentaje de 98.78% y las instancias incorrectamente clasificadas llegan a un total de 21
con un porcentaje de un 1.21%
Lo cual indica que el algoritmo que más adecuado entre los analizados es el algoritmo LMT dado
que sus rangos exceden en instancias correctamente clasificadas (1707), y las incorrectamente
clasificadas es el más bajo de todos os algoritmos con 21 instancias.
