Source: https://www.scribd.com/document/338929/kdd-lab1
Timestamp: 2017-02-21 17:02:47+00:00

Document:
kdd-lab1
BrowseInterestsBiography & MemoirBusiness & LeadershipFiction & LiteraturePolitics & EconomyHealth & WellnessSociety & CultureHappiness & Self-HelpMystery, Thriller & CrimeHistoryYoung AdultBrowse byBooksAudiobooksNews & MagazinesSheet MusicBrowse allUploadSign inJoinPráctica 1 de Minería de DatosIntroducción al Clementine
Curso de Almacenes de Datos y Minería de Datos
Departamento de Sistemas Informáticos y Computación Universidad Politécnica de Valencia en colaboración con Universidad de El Salvador
José Hernández Orallo. (jorallo@dsic.upv.es). Julio 2003
Introducción al SPSS Clementine ......................................................................................................................... 3 1.1 Sources (Orígenes)......................................................................................................................................... 4 1.2 Record Ops. (Oper. con registros) ................................................................................................................ 5 1.3 Field Ops. (Oper. con campos) ..................................................................................................................... 5 1.4 Graph (Gráficos) ............................................................................................................................................ 5 1.5 Modelling (Modelado)................................................................................................................................... 6 1.6 Output (Salida) ............................................................................................................................................... 7 2. Un Primer Ejemplo ................................................................................................................................................ 8 3. Visualización y Preparación de Datos ................................................................................................................ 15 3.1 Enunciado de un Primer Problema. Selección de Fármaco....................................................................... 15 3.2 Resolución del Problema de Selección de Fármaco .................................................................................. 15 3.3 Un Segundo Problema: Agrupación de Empleados................................................................................... 23 3.4 Resolución del Problema de Agrupación de Empleados........................................................................... 23 3.5 Un Tercer Problema: Agrupación de Empleados con Datos Erróneos y Faltantes ................................. 26 3.6 Resolución del Problema de Agrupación de Empleados con Datos Imperfectos .................................... 27 3.7 Obtención y Transformación de Datos Relacionales (ODBC) ................................................................. 42 1.
En esta primera práctica se van descubriendo paso a paso las posibilidades del Clementine.
1. Introducción al SPSS Clementine
El SPSS Clementine es una herramienta integrada de minería de datos, inicialmente de Integral Solutions Limited (ISL) y ahora de SPSS (www.spss.com). La versión 5.2.1 en inglés o la 6.0.2 en castellano, que es con las que vamos a trabajar 1 indistintamente , incluye las siguientes características: • • • Diversas fuentes de datos (ASCII, XLS u ODBC). Interfaz visual basado en procesos/flujos de datos (streams). Distintas herramientas de minería de datos: correlación, reglas de asociación (GRI, a priori), patrones secuenciales (regresión), segmentación (Kohonen, Two-step y k-means), clasificación (redes neuronales, reglas y árboles de decisión). Manipulación de datos (pick & mix, muestreo, combinación y separación). Combinación de modelos. Visualización anterior (datos). Exportación de modelos a distintos lenguajes (C, SPSS, SAS). Exportación de datos integrada a otros programas (XLS). Generación de informes.
El entorno del Clementine está basado en nodos que se van disponiendo y conectando para formar un flujo (stream), traducido por Clementine también como “ruta”. Los streams pueden dejarse en ficheros separados (.str) o se pueden organizar en proyectos (.cpj). De hecho, tanto los streams como los proyectos de minería de datos se almacenan en ficheros separados que se puede abrir, modificar, reejecutar o reorganizar, y que son independientes de las fuentes de datos. La Figura 1 muestra un ejemplo de stream con cinco nodos interconectados:
Figura 1. Un stream en Clementine.
Como se puede ver en la parte inferior de la Figura 1, el Clementine clasifica los nodos en seis categorías:
Debido a lo confuso de la traducción en castellano de la versión 6.0.2 y que además la ayuda sólo está en inglés, en lo sucesivo utilizaremos preferentemente la nomenclatura en inglés, indicando, inicialmente, también la traducción en castellano realizada por el Clementine 6.0.2. 3
Sources (Orígenes): nodos para obtener los datos de trabajo (fuentes de datos). Record Ops (Oper. con registros): operadores para modificar o combinar registros (filas) de distintas fuentes. Es decir, selecciones y combinaciones. Field Ops (Oper. con campos): operadores para modificar o combinar campos (columnas). Graphs (Gráficos): gráficas. Modelling (Modelado): tipos de modelos/patrones que puede generar Clementine Output (Salida): presentación de tablas, análisis de modelos, estadísticas, exportación de datos.
Los nodos disponibles en la versión 5.2.1 se muestran en la Figura 2:
Figura 2. Nodos disponibles en Clementine 5.2.1
No existen variaciones importantes entre la versión 5.2.1 y 6.0.2 respecto a nodos disponibles. Se clarificará dicha diferencia en la siguiente sección. En cualquier caso, este boletín se puede desarrollar indistintamente en ambas versiones. Pasemos a describir los nodos más importantes de las categorías anteriores:
1.1 Sources (Orígenes)
La siguiente tabla recoge una breve descripción de cada uno de ellos:
NOMBRE Var. File (Archivo variable) Fixed File (Archivo Fijo) ODBC Cache File SPSS Import (Import. SPSS) SAS Import (Import. SAS) User Input V5.2 V6.0 DESCRIPCIÓN Permiten leer datos de ficheros de texto que tengan un tamaño de caracteres variable por registro pero un número fijo de campos. Permiten leer datos de ficheros de texto que tengan un tamaño fijo de caracteres por campo, con lo que su uso se limita a fuentes perfectamente tabuladas. Permite obtener los datos de una base de datos a través de ODBC. A partir de ahí permite realizar consultas SQL y extraer tablas/vistas particulares. Para utilizar ficheros de caché creados por el propio Clementine utilizando el nodo File de la categoría Output. Para importar datos de un fichero en formato SPSS (paquete estadístico). Para importar datos de un fichero en formato SAS (paquete estadístico). Nodo que no se puede insertar directamente y que sustituye a otro previamente creado, permitiendo introducir los datos manualmente.
1.2 Record Ops. (Oper. con registros)
NOMBRE Select (Seleccionar) Merge (Combinar) Sample (Muestra) Balance (Equilibrar) Sort (Ordenar) Distinct (Distinguir) Aggregate (Agregar) Append (Añadir) V5.2 V6.0 DESCRIPCIÓN Permite imponer condiciones de inclusión o exclusión para las filas. Es similar a un “SELECT” en SQL. Permite combinar los datos de dos fuentes (tablas) juntando las columnas de aquellos registros que coincidan en un atributo común de clave. Es similar a una concatenación relacional (JOIN de SQL). Permite hacer un muestreo de los datos, ya sean de los N primeros, ir cogiendo salteados hasta N, o coger aleatoriamente un % de los registros. Permite aumentar o disminuir la proporción de registros que cumplen unas determinadas condiciones, lo que es útil para sobremuestrar. Ordena los registros de un stream (como un ORDER BY de SQL). Elimina los registros repetidos (como el DISTINCT de SQL pero con alguna opción más) Permite aplicar funciones agregadas (como el SUM, AVG, COUNT del SQL) Permite unir (como UNION ALL de SQL) dos o más fuentes de datos.
1.3 Field Ops. (Oper. con campos)
NOMBRE Filter (Filtrar) Derive (Derivar) Type (Tipo) Filler (Rellenar) History (Histórico) SetToFlag (Convertir a marca) V5.2 V6.0 DESCRIPCIÓN Permite eliminar campos no representativos o inservibles. También permite renombrar. Permite añadir nuevos campos derivados como combinación de otros. Permite tipar los campos (si son discretos o continuos, si son de entrada o salida, etc.). Este paso suele ser necesario para poder aplicar modelos y gráficos. También se puede utilizar para descartar datos anómalos. Permite rellenar o sustituir campos faltantes o anómalos siguiendo unas condiciones. Permite generar campos con memoria, especialmente en series (acumulados parciales, etc.) Permite generar nuevos campos como transformación de un valor discreto de n posibles valores a n nuevos campos booleanos (tipo flag).
1.4 Graph (Gráficos)
NOMBRE Plot (Gráfico) Histogram (Histograma) Distribution (Distribución) Web (Malla) Collect (Recolectar) V5.2 V6.0 DESCRIPCIÓN Permite representar la relación entre dos valores numéricos en dos dimensiones. Representa un histograma de la distribución de los datos respecto a un valor numérico. Representa un histograma de la distribución de los datos respecto a un valor no numérico. Representan la fuerza de asociaciones entre distintos valores de dos o más atributos simbólicos (no numéricos). Permite ver las asociaciones entre campos. Similar al histograma, pero muestra la distribución de un valor numérico respecto a otro.
Directd Web (Malla direccional) Multiplot (Gráf. múltiple) Evaluation Chart (Evaluación)
Genera un subconjunto de las asociaciones que muestra el nodo “Web”. En este caso, muestra sólo las conexiones entre uno o más campos “FROM” a un campo “TO”. Es un derivado del nodo Plot. Permite definir varios campos “Y” respecto a un campo “X” Variantes de los gráficos de respuesta, que permiten evaluar qué modelo se va a comportar mejor dependiendo del contexto, como los ROI (return on investment). Muy relacionado con el análisis ROC (Receiver Operating Characteristic).
1.5 Modelling (Modelado)
NOMBRE Train Net (Red) V5.2 V6.0 DESCRIPCIÓN Red neuronal multicapa con backpropagation. Dispone de muchos parámetros. Especialmente útil para problemas de clasificación e interpolación (tanto los campos de entrada como los de salida, la clase, pueden ser simbólicos o numéricos). Requiere uno y sólo un atributo “OUT”. Árbol de decisión derivado del ID3 y el C4.5 de Quinlan. Dispone de diferentes opciones. Los campos de entrada pueden ser simbólicos o numéricos, pero la clase ha de ser discreta. Requiere uno y sólo un atributo “OUT”. Redes Asociativas de Kohonen, conocidas también como Knets. Permite realizar segmentaciones (clustering). El algoritmo actúa sólo sobre los atributos definidos como IN (el resto se ignoran). El resultado es un conjunto de condiciones que separan/segmentan las instancias en dos o más grupos (clusters). Construye un modelo de regresión lineal, es decir, una función lineal de un valor numérico respecto uno o más atributos numéricos. Requiere uno y sólo un atributo “OUT”. Genera reglas de asociación orientadas de uno o más atributos (numéricos o simbólicos) o un atributo simbólico de ordenadas por support y accuracy. Método basado en el movimiento de centros. Permite realizar segmentaciones (clustering). El algoritmo actúa sólo sobre los atributos definidos como IN (el resto se ignoran). El resultado es un conjunto de condiciones que separan/segmentan las instancias en dos o más grupos (clusters). Este nodo descubre reglas de asociación en los datos, en la forma “if antecedent(s) then consequent(s)”. Se puede especificar confianza y soporte. También llamada regresión nominal. Es como la regresión lineal, pero para clasificación. Es decir, requiere uno y sólo un atributo “OUT” y debe ser discreto (nominal). Es un método de clasificación y regresión basado en árboles. La clase puede ser discreta (clasificación) o continua (regresión). Requiere uno y sólo un atributo “OUT”. Permite realizar “Principal component analysis (PCA)” o análisis factorial. Un método para segmentación (clustering). Al igual que el Kmeans, el algoritmo actúa sólo sobre los atributos definidos como IN (el resto se ignoran). El resultado es un conjunto de condiciones que separan/segmentan las instancias en dos o más grupos (clusters). Genera un conjunto de reglas de clasificación. Los campos de entrada pueden ser simbólicos o numéricos, pero la clase ha de ser discreta. Requiere uno y sólo un atributo “OUT”.
Build C5.0 (Crear C5.0) Tr. Kohonen
Regression (Reg. Lineal) GRI Train Kmeans
A Priori Log. Regression (Reg. Logística) Árbol C&R Factorial/PCA TwoStep
1.6 Output (Salida)
NOMBRE Table (Tabla) Analysis (Análisis) Set Globals (Def. Globales) Matrix (Matriz) Statistics (Estadísticos) Report (Informe) File (Archivo) SPSS Export (Export. SPSS) Quality (Calidad) ODBC Output (Salida ODBC) SPSS Procedure (Proceso SPSS) Excel Publisher Export. SAS V5.2 V6.0 DESCRIPCIÓN Muestra los datos de un stream en una tabla. Se añade a la salida de un modelo para analizar su validez. Permite calcular ciertos valores (medias, máximos, mínimos, desviaciones) que al ejecutar el nodo están disponibles para expresiones, condiciones en cualquier nodo. Genera una matriz de ocurrencias para los valores de dos campos. En cada una de las celdas se muestra la cantidad o el porcentaje de instancias con el para de valores de cada dimensión. Genera estadísticas de distribuciones de los distintos atributos. Especialmente útil para calcular correlaciones. Permite realizar informes combinando los resultados de un stream. Permite exportar a fichero, también permite exportar a ficheros cachés. Exporta a ficheros de datos con el formato SPSS. Proporciona un informe sobre la proporción de datos faltantes por campo. Permite exportar y enlazar un stream con una fuente ODBC, insertando el resultado del stream en una tabla. Permite ejecutar in situ en el Clementine un procedimiento estadístico generado en el paquete estadístico SPSS. Permite lanzar un stream al Excel. Permite exportar un modelo/condición para ser utilizado en C o a SQL. Exporta a ficheros de datos con el formato SAS.
ü ü ü ü ü ü ü ü ü ü ü ü ü
ü ü ü ü ü ü ü ü ü ü ü ü ü ü
Finalmente, la siguiente tabla resume los modelos que pueden usarse para diferentes tareas:
NOMBRE Train Net (Red) Build C5.0 (Crear C5.0) Tr. Kohonen Regression (Reg. Lineal) GRI Train Kmeans A Priori Log. Regression (Reg. Logística) Árbol C&R Factorial/PCA TwoStep Build Rule Statistics (Estadísticos)
V5.2 V6.0
PREDICTIVO Clasificación Regresión
DESCRIPTIVO Reglas asociación
Para más información sobre un nodo, pulsa en el menú “Help”à “Pointfor-help Mode” y pincha en el nodo del que requieras más información. Además de los nodos anteriores, existen nodos para los modelos, que se representan con la figura de un diamante. A partir de ahora denominaremos a estos nodos, nodos diamante, para diferenciarlos del resto.
2. Un Primer Ejemplo
Vamos a construir el stream de la Figura 1. En primer lugar, aparte del Clementine, dispones de un directorio llamado “LabKDD” con todos los ficheros de datos necesarios para realizar este boletín. En particular, en este primer ejemplo, vamos a trabajar con los datos acerca de los días que se ha podido jugar al tenis, dependiendo de diversos aspectos meteorólogicos. El objetivo es poder determinar (predecir) si hoy podremos jugar al tenis. Los datos de que disponemos están en el fichero: “..\LabKDD\PlayTennis\playtennis-evidence.txt” y son los siguientes:
Sky Sunny Sunny Overcast Rain
Temperature Hot Hot Hot Mild
Humidity High High High High
Wind Weak Strong Weak Weak
PlayTennis No No Yes Yes
Aunque no es un modelo propiamente dicho, permite calcular correlaciones. 8
Rain Rain Overcast Sunny Sunny Rain Sunny Overcast Overcast Rain
Cool Cool Cool Mild Cool Mild Mild Mild Hot Mild
Normal Normal Normal High Normal Normal Normal High Normal High
Weak Strong Strong Weak Weak Weak Strong Strong Weak Strong
Yes No Yes No Yes Yes Yes Yes Yes No
Abrimos el Clementine (para ello, ve a Inicio → Programas → Clementine 5.2.1 → Clementine). Al abrir el programa, las dos áreas de trabajo (izquierda superior y derecha superior) te aparecen en blanco (mejor en dicho en azul y gris). Lo primero que vamos a hacer es insertar un nodo fuente de datos al área de trabajo. Para ello, pincha dos veces (o pincha una vez en el nodo y después otra vez en el área de trabajo) en el nodo “Var. File” que está en la categoría “Sources” (abajo a la izquierda). Te aparecerá el nodo en el área de trabajo, como se muestra en la Figura 3:
Figura 3. Insertando el primer nodo en el área de trabajo
Para borrar un nodo, simplemente se selecciona y se pulsa la tecla “Supr”. También se puede borrar con el menú de contexto asociado a un nodo, el cual se abre pulsando el botón derecho sobre un nodo. Ahora vamos a enganchar el nodo con una fuente de datos. Para ello, pincharemos con el botón derecho sobre el nodo ”variable” file de la zona de trabajo y seleccionaremos “EDIT”. En la pantalla de edición modificaremos el nombre del fichero, el directorio donde está y la forma de importarlo (utilizando los tabuladores). Para seleccionar el fichero, simplemente pincha en “Set File”. Busca el fichero “..\LabKDD\PlayTennis\playtennis-evidence.txt” en la siguiente pantalla (Figura 4).
Figura 4. Buscando el fichero de datos
Pulsa “Set”. A continuación pincha el CheckBox “Tab”, como aparece en la siguiente Figura 5:
Figura 5. Enganchando con la fuente de datos
Además seleccionaremos “Get field names from file” para que nos coja el nombre de los atributos del propio fichero:
Figura 6. Opciones de formato para leer correctamente el fichero de datos
Pincha en OK. Para ver que carga bien los datos vamos a añadir un nodo “Table” (está en la última categoría “Output”). Una vez te aparezca en la zona de trabajo hay que enganchar los dos nodos. Aquí aparece el único gran misterio del Clementine: cómo enlazar nodos. Para enlazar dos nodos en Clementine, se han de pulsar el botón izquierdo y derecho a la vez sobre el nodo origen y arrastrar el ratón hasta el nodo destino, soltando en este momento los dos botones.
(si el ratón tiene botón del medio, también se puede utilizar este botón)
Veamos paso a paso esta delicada operación:
Figura 7. Enlazando dos nodos
Figura 8. Dos nodos enlazados
Para destruir un enlace, simplemente se pincha con el botón derecho en el enlace y aparece “Destroy Connection”. Si una vez conectados, pulsas el gran botón verde de “EXECUTE” te deberán aparecer los datos importados en una tabla:
Figura 9. Los datos se han enganchado correctamente
Como se muestra en la tabla, el problema que estábamos intentando tratar era el de ver si hoy podemos jugar al tenis. Para poder abordar este problema, hemos de decir que los campos “Sky”, “Temperature”, “Humidity”, “Wind” son predictores (es decir de entrada), mientras que el campo “Playtennis” es la clase a predecir, el resultado (es decir la salida). Para ello vamos a añadir un nodo “Type”, que se encuentra en la categoría “Field Ops”. Ahora enlazamos el nodo “playtennis-evidence...” con el nodo “type”. Vamos a editar el nodo “type”. Para ello pinchamos con el botón derecho en “type” y pinchamos en “EDIT”. Como vemos todos los nodos tienen dirección IN. Como la salida va a ser “playtennis” modificamos su dirección a OUT.
Figura 10. Tipando los atributos.
Una vez hecho esto ya estamos en disposición de intentar aprender un modelo a partir de los datos, en este caso, una función, que dados unos determinados valores de los atributos de entrada nos dé un valor para el valor de salida. Para ello añadimos un nuevo nodo “build C5.0” (está en la categoría de “Modelling”) para construir un árbol de decisión sobre los datos. Conectamos el nodo “Type” con el nodo “build C5.0”, que pasa a llamarse Playtennis.
Figura 11. Stream resultante.
Ahora ya estamos en disposición de aprender un modelo (en este caso un árbol de decisión). Para ello, cogemos carrerilla y le damos bien fuerte al gran botón verde de “EXECUTE” y a minerizar!!!! Como puedes observar, aparte de volver a mostrar la tabla con los datos de origen (pantalla que puedes cerrar para que no moleste), se ha generado un nuevo icono en el área de trabajo de la derecha, con la forma de un diamante. ¿Somos ricos? No, de momento. Pinchamos dos veces en el diamante de la derecha y nos aparece en el área de trabajo de la izquierda.
Figura 12. Modelo generado y una copia en el área de trabajo.
Ahora pinchamos con el botón derecho en el diamante que hemos copiado en el área de trabajo (el que aparece a la izquierda del todo en la Figura 12) y pinchamos en “Browse”. Se nos muestra una ventana donde podemos ver el árbol de decisión creado. En el menú “View”, pulsa “Show Instances/confidence”. Ahora tienes el árbol etiquetado como se muestra en la siguiente figura:
Figura 13. Árbol generado y su cobertura/confianza.
¿Cómo interpretramos el árbol anterior? La manera de verlo es la siguiente:
Figura 14. Árbol representado gráficamente.
Además, la Figura 13 nos muestra para cada rama cuántos ejemplos de la evidencia son cubiertos y con qué confianza (en este caso el 100% en todas las ramas). La representación lógica del árbol anterior sería: (Outlook=Sunny AND Humidity=Normal) OR (Outlook=Overcast) OR (Outlook=Rain AND Wind=Weak) Podemos verlo también en forma de reglas. Para ello, si le damos al botón derecho del ratón sobre el nodo-diamante “Playtennis” y seleccionamos “Browse”, podemos, en el menú “Generate”, generar las reglas para ese árbol de decisión, como se muestra en la siguiente figura:
Figura 15. Generando las reglas del árbol.
Esto nos genera un nuevo nodo “playtennisRS” que si lo observamos (botón derecho y “Browse”) veremos la expresión del árbol en forma de reglas. Dándole al menu “Folding” y después a “Show More” vemos:
Figura 16. Reglas del árbol
Finalmente, podemos utilizar el modelo para predecir si podemos jugar o no jugar al tenis hoy. Supongamos que tenemos, p.ej., la instancia (Sky = rain, Temperature = cool, Humidity = high, Wind = strong). Podemos ver en el árbol que la clase es NO, con lo que no jugaremos al tenis. No nos haremos ricos pero nos ahorraremos un constipado o una rinitis alérgica. Podemos grabar lo que hemos realizado en un fichero .str mediante “File à Save Stream”.
3. Visualización y Preparación de Datos
Vamos a abordar problemas más complejos e interesantes a partir de ahora.
3.1 Enunciado de un Primer Problema. Selección de Fármaco
En este caso se trata de predecir el tipo de fármaco (drug) que se debe administrar a un paciente afectado de rinitis alérgica según distintos parámetros/variables. Las variables que se recogen en los historiales clínicos de cada paciente son: • • • • • • Age: Edad Sex: Sexo BP (Blood Pressure): Tensión sanguínea. Cholesterol: nivel de colesterol. Na: Nivel de sodio en la sangre. K: Nivel de potasio en la sangre.
Hay cinco fármacos posibles: DrugA, DrugB, DrugC, DrugX, DrugY. Se han recogido los datos del medicamento idóneo para muchos pacientes en cuatro hospitales (los ficheros están en el directorio “..\LabKDD\drugs”). Se pretende, para nuevos pacientes, determinar el mejor medicamento a probar a cada uno.
3.2 Resolución del Problema de Selección de Fármaco
En primer lugar vamos a coger los datos del primer hospital, ya que al ser el de menor tamaño (200 registros), permite hacer más pruebas inicialmente. Limpiamos la zona de trabajo (Edit à Clear) o botón derecho y Clear. Los datos del fichero “drug1n” tienen cabecera, con lo que añadiremos un nodo fuente “Var. File” y al editar, indicaremos el nombre y directorio del fichero y marcaremos el checkbox para que obtenga el nombre de los atributos a partir de la primera línea del fichero:
Figura 17. Abriendo el fichero del primer hospital
Ahora añadiremos un nodo tabla y lo engancharemos con el nodo “Var. File”. Podemos ver los datos ya cargados al ejecutar la tabla, como se ve en la siguiente figura:
Figura 18. Datos del primer hospital
La primera pregunta que nos podemos hacer es ver qué fármacos son más comunes en general, para ver si todos suelen ser igualmente efectivos en términos generales. Para ello añadimos un nodo “Distribution” en la categoría “Graph” y lo enlazamos con la fuente de datos “drug1n”. La situación debe ser similar a la siguiente:
Figura 19. Primeros pasos analizando los fármacos
Si editamos el nodo “distribution”, podemos elegir el atributo por el cual vamos a representar el gráfico. Seleccionamos “drug” como el atributo para mostrar las distribuciones.
Figura 20. Pasos para visualizar la distribución de los fármacos
Ahora ya podemos ejecutar el “stream” y ver la distribución del uso de fármacos en el hospital 1.
Figura 21. Distribución de los fármacos en el hospital 1
Vemos que el fármaco más efectivo es el Y, que se administra con éxito en casi la mitad de los pacientes. Una regla vulgar sería aplicar el fármaco Y, en el caso que falle, el fármaco X, y así sucesivamente siguiendo las frecuencias de uso con éxito. Con la herramienta Clementine, seguro que lo podemos hacer mucho mejor... Apliquemos lo mismo que hemos realizado en el ejemplo anterior, intentemos generar un árbol de decisión. Construyamos y ejecutemos un stream con un nodo “Type” (donde el atributo drug se ha puesto como salida) y con un nodo C5.0. Añadamos el modelo generado al área de trabajo como se ve en la siguiente figura:
Figura 22. Realización de un modelo directamente sobre los datos
El modelo resultante es el siguiente:
Figura 23. Árbol de decisión directamente sobre los datos
Como podemos observar, el árbol tiene bastante ramas (en concreto 13). Podemos ver cuál es la precisión (accuracy) de este árbol respecto a los datos de entrenamiento. Para ello, conectamos el nodo “Type” al nodo diamante “Drug” y éste a un nuevo nodo “Analysis” de la categoría “Output”, como se ve en la siguiente figura:
Figura 24. Stream para analizar la calidad de un modelo
Si ejecutamos el nodo “analysis” (con el menú contextual pulsando el botón derecho) obtenemos los siguientes resultados:
Figura 25. Calidad del modelo generado para los datos de entrenamiento
Con lo que tenemos un 97,5% de precisión. Es decir un error de sólo el 2,5% sobre los datos de entrenamiento. Este modelo es muchísimo mejor que sí sólo nos guiamos por la distribución, que nos daría un error de más del 50%. De todas maneras, es posible hacerlo mejor... ¿pero cómo? ¿con otro tipo de algoritmo de aprendizaje, una red neuronal, p.ej.? Es posible que otros modelos (p.ej. las redes neuronales) dieran mejor resultado, pero el asunto aquí es que igual no hemos examinado suficientemente los datos de entrada. Vamos a analizar, con más detenimiento, los atributos de entrada del problema. Es posible que se puedan establecer mejores modelos si combinamos algunos atributos. Podemos analizar pares de atributos utilizando diferentes gráficos. Para comparar los atributos discretos, el gráfico “Web” suele ser conveniente. Creemos un nodo “web” y enganchemos el nodo de fuentes de datos “drug1n” con él. Al editarlo, decimos que vamos a examinar los campos (web fields) discretos (Sex, BP, Cho, Drug):
Figura 26. Relación (asociaciones) entre los atributos discretos Sex x BP x Cho x Drug
Las líneas más gruesas representan asociaciones más fuertes. No parece ver ninguna relación especial entre los distintos valores de los atributos discretos, exceptuando la clase (valor de salida “drug”), que va decreciendo la intensidad de una manera regular para los fármacos menos usuales. Estudiemos la relación que hay entre los atributos continuos y su influencia en la clase. Para ello vamos a utilizar el gráfico “plot” de la categoría “graph”. Añadamos un nodo “plot” y lo enganchamos con el node de entrada “drug1n” y comparemos el Na y el K. Para ello al editar el nodo “plot” pondremos en el X field el campo Na, en el Y field el campo K y en el Overlay field la clase Drug. Lo demás se deja por defecto, como se ve en la siguiente figura:
Figura 27. Editando un nodo Plot
El resultado al ejecutar el gráfico es el siguiente:
Figura 28. Resultado de un Plot (Na x K x Drug)
En este gráfico sí que se ven algunas características muy significativas. Parece haber una clara separación lineal entre una relación K/Na alta y una relación K/Na baja. De hecho, para las concentraciones K/Na bajas, el fármaco Y es el más efectivo de una manera clara y parece mostrarse que por encima de un cierto cociente K/Na ese medicamento deja de ser efectivo y se debe recurrir a los otros cuatro.
Podemos utilizar este conocimiento que acabamos de extraer para mejorar nuestros modelos. Hemos establecido que el medicamento a administrar depende en gran medida del cociente entre K/Na. Por tanto, vamos a realizar un nuevo modelo que utilice este cociente. Para ello, vamos a crear un nuevo atributo derivado (también llamados atributos pick & mix) mediante el nuevo nodo “Derive” de la categoría “Field Ops”, que engancharmos con el nodo drug1n.
Figura 29. Definiendo un atributo derivado
NOTA: El Clementine trabaja con el teclado americano. Las teclas más necesarias son las siguientes:
• _: está en el ? • /, *, -, +: usa el teclado numérico • < > : están en , y en . • & : está en el 7
• | : está en el > Ahora duplica (para duplicar un nodo, en el menú contextual con el botón derecho pulsamos “Duplicate”) los nodos Type y el nodo C5.0 Drug que teníamos de antes y engánchalos al stream que sale del nodo Na_to_Ka. Cambia el nombre del nodo Drug (C5.0) a Drug2, para no liarte. Para ello edita el nuevo nodo Drug y cambia el campo “Output Name”:
Figura 30. Cambiando el nombre del modelo a generar
Ahora ejecuta ese nodo y te generará un nuevo modelo “Drug2”. Añádelo al área de trabajo, engánchalo con el nodo “Copy of Type” y añade un nodo de “Analysis” como hicimos con el primer modelo. El grafo de streams resultante debe ser el de la siguiente figura:
Figura 31. Streams realizados para el problema del fármaco
Ahora, si examinamos el modelo Drug2 tenemos lo siguiente:
Figura 32. Segundo modelo que utiliza el atributo derivado Na_to_K
Modelo mucho más simple y corto que el anterior, en el que se ve la importancia del atributo que hemos creado Na_to_K. Además si analizamos su calidad con el nodo de análisis, tenemos:
Figura 33. Calidad del segundo modelo que utilizar el atributo derivado Na_to_K
Tenemos con el nuevo modelo un 100% de precisión, con lo que el modelo es mucho más fiable que antes. Ahora graba el stream en un fichero “.str”, p.ej. “drug1.str”, porque volveremos sobre este problema.
3.3 Un Segundo Problema: Agrupación de Empleados
La empresa de software para Internet “Memolum Web” quiere extraer tipologías de empleados, con el objetivo de hacer una política de personal más fundamentada y seleccionar a qué grupos incentivar. Las variables que se recogen de las fichas de los 15 empleados de la empresa en 1999 son: • • • • • • • • • Sueldo: sueldo anual en euros. Casado: si está casado o no. Coche: si viene en coche a trabajar (o al menos si lo aparca en el parking de la empresa). Hijos: si tiene hijos. Alq/Prop: si vive en una casa alquilada o propia. Sindic.: si pertenece al sindicato revolucionario de Internet Bajas/Año: media del nº de bajas por año Antigüedad: antigüedad en la empresa Sexo: H: hombre, M: mujer.
Los datos de los 15 empleados se encuentran en el directorio “..\LabKDD\empleados\empleados.txt”). Se intenta extraer grupos de entre estos quince empleados.
3.4 Resolución del Problema de Agrupación de Empleados
En primer lugar vamos a leer los datos de los empleados. Limpiamos la zona de trabajo (File à Clear) o (File à Close). Los datos del fichero “empleados” tienen cabecera y están tabulados, con lo que añadiremos un nodo fuente “Var. File” y al editar, indicaremos el nombre y directorio del fichero y marcaremos el checkbox para que obtenga el nombre de los atributos a partir de la primera línea del fichero y además marcaremos el checkbox Tab:
Figura 34. Abriendo el fichero fuente empleados.txt
A continuación añadimos un nodo “Type” y lo enganchamos. Todos los atributos deberían estar IN exceptuando el número de ejemplo, que es irrelevante y pondremos NONE, como se muestra en la siguiente figura:
Figura 35. Tipando los datos de los empleados
Ahora vamos a utilizar un algoritmo de clustering para obtener grupos sobre esta población. En primer lugar vamos a probar con tres grupos. Para ello añadimos un nodo Kmeans, lo enganchamos al nodo Type y modificamos el campo “Number of clusters” a 3, como se ve en la siguiente figura:
Figura 36. Determinando el número de clusters
Ahora podemos ejecutar el stream, obteniendo un nodo diamante Kmeans. Lo podemos añadir y enganchar al nodo Type, como se muestra en la siguiente figura:
Figura 37. Stream para el problema de los empleados
Si examinamos (Browse) el nodo diamante Kmeans vemos qué características tiene cada cluster: cluster 1 5 examples Sueldo : 226000 Casado : No -> 0.8 Sí -> 0.2 Coche : No -> 0.8 Sí -> 0.2 Hijos : 0 Alq/Prop : Alquiler -> 1.0 Sindic. : No -> 0.8 Sí -> 0.2 Bajas/Año : 8 Antigüedad : 8 Sexo : H -> 0.6 cluster 2 4 examples Sueldo : 225000 Casado : No -> 1.0 Coche : Sí -> 1.0 Hijos : 0 Alq/Prop : Alquiler -> 0.75 Prop -> 0.25 Sindic. : Sí -> 1.0 Bajas/Año : 2 Antigüedad : 8 Sexo : H -> 0.25 M -> 0.75 cluster 3 6 examples Sueldo : 188333 Casado : Sí -> 1.0 Coche : Sí -> 1.0 Hijos : 2 Alq/Prop : Alquiler -> 0.17 Prop -> 0.83 Sindic. : No -> 0.67 Sí -> 0.33 Bajas/Año : 5 Antigüedad : 8 Sexo : H -> 0.83 M -> 0.17
Si añadimos una tabla a la salida del nodo diamante Kmeans podemos observar qué ejemplos exactamente han caído en qué clúster.
Figura 38. Ejemplos agrupados por clusters.
¿Cómo interpretarías los tres grupos anteriores? Varía el número de clusters (2, 4, 5, ...) y vuelve a ejecutar el stream para cada uno de estos valores. ¿qué se puede observar? Ahora graba el stream en un fichero “.str”, p.ej. “empleados.str”, porque volvemos sobre este problema a continaucín.
3.5 Un Tercer Problema: Agrupación de Empleados con Datos Erróneos y Faltantes
La empresa de software para Internet “Memolum Web” ha aumentado vertiginosamente su plantilla en los últimos años, debido principalmente a una absorción de la compañía “Intelligent Stones” y quiere ver si las tipologías de empleados existentes siguen valiendo. Las variables que se recogen de las fichas de los 40 empleados actuales de la empresa son: • • • • • • • • • • Sueldo: sueldo anual en euros. Casado: si está casado o no. Coche: si viene en coche a trabajar (o al menos si lo aparca en el parking de la empresa). Hijos: si tiene hijos. Alq/Prop: si vive en una casa alquilada o propia. Sindic.: si pertenece al sindicato revolucionario de Internet Bajas/Año: media del nº de bajas por año Antigüedad: antigüedad en la empresa Sexo: H: hombre, M: mujer. Estudios: Obl: obligatorios, Bac: universitarios, Doc: doctorado/master bachillerato, FP: formación profesional, Uni:
Los datos de los 40 empleados se encuentran en el directorio “..\LabKDD\empleados\empleados4.txt”). El problema de estos datos es que, al haber crecido vertiginosamente la compañía y debido a la conversión de datos en la fusión, pueden tener un número significativo de datos faltantes o erróneos. Se intenta extraer grupos de entre estos quince empleados.
3.6 Resolución del Problema de Agrupación de Empleados con Datos Imperfectos
(este ejercicio es largo así que cada cierto tiempo graba el stream en un fichero “.str”, p.ej. “empleados2.str”). En primer lugar vamos a leer los datos de los empleados. Limpiamos la zona de trabajo (File à Clear) o (File à Close) y volvemos a conectar con el fichero “empleados4.txt” de manera similar al caso anterior:
Figura 39. Leyendo del fichero de datos.
Si enganchamos un nodo “Table” a la salida de este nodo, podemos ver si los datos se leen correctamente.
Figura 40. Mostrando los datos tabularmente.
Ya simplemente a primera vista vemos datos faltantes. Podemos analizar cuántos y para cuántos atributos, de una manera automática, con el nodo “Quality”. Si añadimos uno y lo conectamos con la fuente de datos tenemos: 27
Figura 41. Porcentaje de datos faltantes por campo.
Vemos que faltan valores en el campo Alq/Prop y en el campo Estudios. Ahora vamos a realizar ciertas gráficas para detectar datos anómalos. Nos interesa ver los datos numéricos, ya que en estos casos es más fácil detectar outliers. Para ello podemos añadir ciertos nodos “Plot” para comparar diferentes valores. Por ejemplo, podemos querer visualizar la antigüedad respecto al sueldo y además mostrando los estudios. Añadimos un nodo “Plot” y lo enganchamos con la fuente de datos (ver Figura 46). Si lo editamos podemos especificar que el campo X será “Sueldo”, el campo Y será “Antigüedad” y el campo de overlay será “Estudios”:
Figura 42. Configurando un nodo “Plot”.
Si lo ejecutamos tendremos la siguiente gráfica:
Figura 43. Gráfica “Plot”: Antigüedad x Sueldo [Estudios].
Parece destacar un dato cerca de los 400000€ de sueldo que parece ser un dato anómalo, dadas las características de la empresa. De modo similar podemos añadir y conectar otro nodo Plot para intentar relacionar el nº de Hijos con las Bajas mostrando el Sexo como overlay. El resultado es el siguiente.
Figura 44. Gráfica “Plot”: Hijos x Bajas/Año [Sexo].
También destaca claramente el hecho de que existe un registro con el nº de hijos negativo, lo cual es claramente un dato erróneo. Podemos añadir más Plots, por ejemplo, uno que combine “Antigüedad” x “Sueldo” y de overlay tenga el campo “Casado”
Figura 45. Gráfica “Plot”: Antigüedad x Sueldo [Casado].
Que, de momento, no nos aporta demasiada información, aparte que la antigüedad parece estar relacionada con estar casado. Elige una interpretación para esta relación: a) Los jóvenes van saltando de una empresa a otra, con lo que no obtienen antigüedad. b) La edad y el estado civil están relacionados en el total de la población por lo que esto no es más que una muestra de ello, ya que para estar más de 10 años en la empresa hay que tener por lo menos 30 años. c) Casarse envejece. d) Todas las anteriores. El stream que llevamos hasta el momento es el que se muestra en la siguiente figura:
Figura 46. Stream de los empleados con datos imperfectos.
Siguiendo con nuestro problema, hemos identificado dos campos con valores faltantes y dos registros anómalos. Ya que tenemos 40 empleados, lo más conveniente en este caso es eliminar los dos registros anómalos, pues los resultados con 38 empleados van a ser similares que con 40 (además más fiables al haber eliminado registros dudosos). Para eliminarlos, ejecutamos el nodo “Table” y pinchamos sobre los datos anómalos: en este caso el sueldo del registro 16 y los hijos del registro 18, como se muestra en la siguiente figura.
Figura 47. Marcando los datos anómalos.
Pulsando en el menú “Generate”, pulsamos la opción “Select Node (“or”)”:
Figura 48. Generando un nodo para eliminar estos registros anómalos.
Nos ha generado un nodo select con el nombre “Generated”. Enganchamos el nodo fuente con él y lo editamos, para comprobar que las condiciones se han generado bien y para modificar el modo a “Discard” (porque son los que queremos eliminar), como se muestra en la siguiente figura:
Figura 49. Modificando el nodo select para eliminar estos registros anómalos.
Podemos añadir un nodo “Table” y engancharlo con el nodo “generated” para comprobar que realmente elimina esos dos registros, resultando en 38 registros de datos. Una vez resuelto el tema de los datos anómalos vamos a ocuparnos de los datos faltantes. En primer lugar vamos a abordar el campo “Estudios”. Según se tiene conocimiento de la manera de adquirir este dato (en el momento de contratación en la empresa) es muy posible que la ausencia de valor en este campo pueda significar que el contratado no tenía estudios aparte de los elementales, dejando en blanco este campo. Por tanto, vamos a suponer que aquellos registros sin estudios van a ser realmente “Estudios obligatorios”. Para arreglarlo, y siguiendo este criterio, vamos a añadir un nodo “Filler”. No obstante, previamente debemos añadir un nodo “Type” y conectarlo al nodo “generated” (ver Figura 53). Editamos el nodo “Type” y pinchamos en la columna “Blanks” del campo “Estudios”, y luego con el botón derecho le damos a “Edit”, como se muestra en la siguiente figura:
Figura 50. Tipando los atributos blancos del campo “Estudios”.
Ahora pinchamos en el checkbox “White Space”, para que nos reconozca los valores en blanco, como se muestra en la siguiente figura:
Figura 51. Tipando los atributos blancos del campo “Estudios”.
Ahora sí que añadimos un nodo “Filler” y lo enganchamos con el nodo “Type”. Editamos el nodo “Filler” como se muestra en la siguiente figura:
Figura 52. Modificando el nodo filler para rellenar blancos con valores.
Añadimos un nodo “Table” y tenemos el stream de la siguiente figura:
Figura 53. Estado del Stream.
Si ejecutamos el último nodo “Table” podemos ver que ya no hay datos faltantes en la columna “Estudios” y que los faltantes se han rellenado con “Obl”.
Figura 54. Datos con el campo “Estudios” rellenado.
Ahora ya sólo nos queda abordar los blancos en “Alq/Prop”. Al haber tres casos con nulo en este atributo, no parece aconsejable eliminar tres registros, ya que su información puede ser valiosa. La idea es intentar rellenarlos con algún valor relativamente razonable. Una idea sería ver qué valor es más frecuente y rellenar con ese valor, pero en este caso prácticamente los dos valores tienen una frecuencia similar. Otra opción sería predecir ese valor faltante. Eso es lo que vamos a hacer. Para ello vamos a crear un clasificador para obtener este valor. En primer lugar, vamos a eliminar (momentáneamente) los tres valores blancos. Para ello, ejecutamos el último nodo “table” y seleccionamos uno de los campos que estén en blanco. Pulsamos en el menú “Generate”:
Figura 55. Generando un nodo para eliminar registros en blanco.
Nos ha generado un nodo “Generated” que enganchamos al nodo “filler”. Editamos el nodo “Generated” para que excluya estos registros nulos:
Figura 56. Configurando el nodo para eliminar registros en blanco.
Ahora añadimos un nodo “Type” a este nodo “generated” y vamos a señalar el campo “Alq/Prop” como campo de salida (OUT):
Figura 57. Tipando los datos para aprender un clasificador para el campo “Alq/Prop”.
Ahora añadimos un nodo de clasificación, por ejemplo, un “Build Rule” y lo enganchamos al nodo Type como se muestra en la siguiente figura:
Figura 58. Estado del Stream.
Ahora ejecutamos el stream y obtenemos un modelo en el área de trabajo derecha del Clementine. Si hacemos “Browse” en el nodo diamante “Alq/Prop” podemos ver cuáles son las reglas:
Figura 59. Modelo generado.
Añadimos el modelo a la zona de trabajo de la izquierda y lo enganchamos con el nodo Type de abajo, donde añadimos un nodo “analysis", como se muestra en la siguiente figura:
Figura 60. Estado del Stream.
Podemos evaluar la calidad del modelo ejecutando el nodo “analysis":
Figura 61. Análisis del modelo.
Este modelo es lo suficientemente aceptable para substituirnos los valores blancos que teníamos en ese campo. Para ello, volvemos a copiar el modelo en la zona de trabajo de la izquierda y lo enganchamos a través de un nuevo nodo Type con el filler y añadimos un nodo “Table”:
Figura 62. Estado del Stream.
Si ejecutamos la tabla, vemos que el modelo genera valores para Alq/Prop en un nuevo campo “RAlq/Prop”:
Figura 63. Campos Generados.
Por último, el campo “Estudios” sería interesante que fuera numérico en vez de simbólico. Es decir, que fuera una escala. Para ello añadimos un nodo “Derive”. Lo conectamos al nodo diamante “Alq/Prop” de arriba y lo editamos, poniendo como nombre “Vestudios” y de tipo “Set”, como se muestra en la figura:
Figura 64. Configurando un nodo “Derive”.
Ponemos el primer valor current 1 con la condición (Estudios == ‘Obl’) y le damos al botón “Add”. Así lo vamos haciendo con todos los valores siguientes, como se muestra en la siguiente tabla: CURRENT 1 2 3 4 5 CONDITION Estudios == ‘Obl’ Estudios == ‘FP’ Estudios == ‘Bac’ Estudios == ‘Uni’ Estudios == ‘Doc’
Resultando lo que se muestra en la siguiente figura:
Figura 65. Configurando un nodo “Derive”.
Podemos observar el resultado añadiendo un nodo “Table”:
Figura 66. Mostrando el campo derivado.
Por último, ya sólo nos falta quedarnos con las columnas válidas. En este caso, se trata de quedarnos con la columna Vestudios y no la vieja Estudios y en el caso de Alq/Prop con la derivada y no con la original, que tiene blancos. Para eso simplemente añadimos un nodo Filter que enganchamos con el nodo “VEstudios" y lo editamos de la siguiente manera:
Figura 67. Filtrando los campos que ya no vamos a usar.
Por fin tenemos los datos preparados para trabajar con el stream que se muestra en la siguiente figura:
Figura 68. Stream tras el proceso de limpieza de datos.
Ahora ya podemos examinar mejor los datos y realizar múltiples gráficas y tablas para analizar los datos, p.ej. los plots que ya vimos, nuevos histogramas, tablas “Matriz”, etc., como se muestra en la siguiente figura:
Figura 69. Analizando los datos mediante gráficas (sólo se muestra a partir del nodo “Filter”).
Por ejemplo, ahora la gráfica entre antigüedad y sueldo se ve mejor sin el dato anómalo de “Sueldo”. También se ven mucho mejor todas las gráfica que tienen en cuenta la edad. Ahora vamos a añadir un nodo “Type” que lo enganchamos a continuación de “filter” y ponemos la dirección de todos los campos a IN menos el campo “#Ej” que ponemos NONE. Además, para pode utilizar bien los datos, vamos a cambiar el tipo de VEstudios, que lo habíamos generado como Set y vamos a cambiarlo a Integer Value utilizando un nodo Type adicional, como se muestra en la siguiente figura:
Figura 70. Tipando los datos.
Como al VEstudios le hemos puesto el tipo manualmente, debemos indicar el rango:
Figura 71. Estableciendo el rango manualmente del campo VEstudios.
Ahora podríamos, por ejemplo, añadir un nodo “Plot” entre el “Sueldo” y los “Estudios”, cosa que no podíamos hacer antes porque Estudios no era numérico. El resultado sería el siguiente:
Figura 72. Relación entre Sueldo y Estudios.
Lo que muestra una correspondencia claramente lineal. Ahora retomemos la gráfica entre antigüedad y sueldo, que ahora se ve mejor sin el dato anómalo de “Sueldo”. Si la ejecutamos y observamos, con un poco de atención se ven dos zonas diferenciadas, una de bajo sueldo y antigüedad, donde resulta que la mayoría no están casados, y una zona de alto sueldo y antigüedad, donde resulta que la mayoría están casados. Con el ratón seleccionamos ambas regiones y con el botón derecho le podemos dar nombre. Una vez ya hayamos seleccionado estas dos zonas con el ratón podemos ir al menú “Generate” y pulsar “Derive Node (Set)”, como se muestra en la siguiente figura:
Figura 73. Generando atributos derivados utilizando regiones espaciales marcadas con el ratón.
Podemos ver que se nos genera un nuevo nodo “region”. Si lo conectamos con el último nodo Type y le añadimos un nodo “Table” podemos ver el siguiente resultado:
Figura 74. Se ha generado un nuevo campo según la “region”.
La “región7” es la de bajo sueldo y antigüedad mientras que la “región8” es la de alto sueldo y antigüedad. Ahora lo que vamos a hacer es realizar un agrupamiento en tres clusters utilizando este nuevo campo y sin utilizarlo, comparando los resultados. El stream que hay que hacer es el que se muestra en la siguiente figura:
Figura 75. Stream definitivo.
Compara los clusters que salen por cada uno de las dos vías (sin las regiones o con ellas) y comenta si los resultados son razonables. Ahora graba el stream en un fichero “.str”, p.ej. “empleados2.str”, Por último, si te quedan ganas, intenta hacer un agrupamiento de tres clusters a partir de los datos iniciales, sin la limpieza realizada y compara los resultados.
3.7 Obtención y Transformación de Datos Relacionales (ODBC)
Aunque en la mayoría de ejemplos vamos a trabajar por comodidad a partir de datos que están en ficheros, en la mayoría de aplicaciones reales los datos originales se encuentran en una base de datos. Clementine permite enlazar a través de ODBC con cualquier motor de un Sistema de Gestión de Bases de Datos (SGBD).
Pasemos a trabajar con una base de datos clásica, el ejemplo “Neptuno” en MsAccess que versa sobre una compañía de pedidos. La base de datos se encuentra en el directorio “..\LabKDD\Neptuno”. Si abres la base de datos “Neptuno.mdb”, la estructura de la base de datos es la siguiente:
Figura 76. Base de Datos Neptuno
Sin entrar en más detalles en el esquema, el problema que vamos a tratar en este caso es el de predecir el volumen de pedidos para el próximo cuatrimestre. Para ello, se ha realizado una consulta específica para esta cuestión que obtiene el total de los cargos de los pedidos por cuatrimestre. Dicha consulta (en realidad es una vista) se llama “_VentasPorCuatrimestre”:
Figura 77. Vistas de la Base de Datos
Si la ejecutamos, tenemos el siguiente resultado:
Figura 78. Ventas por Cuatrimestre
Nos interesa realizar una estimación para los cuatrimestres 1996C y 1996D. Para ello, vamos a utilizar el Clementine. Antes debemos crear una fuente ODBC en el sistema. Para ello (en Windows) vamos al Panel de 3 Control y elegimos “Fuentes de Datos ODBC” (en los laboratorios es posible que no esté el panel de control disponible. Entonces busca y lánzalo desde “Inicio → Oracle → Oracle para Windows 95 → Ms ODBC Administrator”):
Figura 79. Panel de Control
Pinchamos y, en la pestaña “DSN de Usuario” agregamos un origen “Base de Datos de Ms Access”:
En Windows 2000 está en “Panel de Control → Herramientas Administrativas → Orígenes de datos (ODBC)”. 44
Figura 80. Panel de Control
En la siguiente pantalla “Crear nuevo origen de datos”, elige “Controlador para Microsoft Access (*.mdb)” y pincha “Finalizar”. En la siguiente pantalla pincha en “Seleccionar” y selecciona el fichero “..\LabKDD\Neptuno\Neptuno.mdb”. Le daremos el nombre del origen de datos “Fuente_Neptuno” y la descripción que quieras.
Figura 81. Panel de Control
Ahora volvemos al Clementine. Limpiamos el área de trabajo y añadimos un nodo ODBC de la categoría SOURCE. Si lo editamos, y apretamos el botón “Connect” aparece otra pantalla donde podemos seleccionar la fuente “Fuente_Neptuno” y pulsa “Connect” (no hace falta ni username ni password):
Figura 82. Conectando el nodo ODBC con la Fuente ODBC
Ahora te permite seleccionar una tabla o realizar una consulta. Pulsa “Select Table/View” y selecciona “_VentasPorCuatrimestre”. Te debe aparecer lo que se muestra en la siguiente figura:
Figura 83. Conectando el nodo ODBC con la Fuente ODBC
Dale a “OK”. Ahora añade un nodo “Table” al área de trabajo y conéctalo con la fuente de datos. Ejecuta el STREAM. El resultado será el que se ve en la siguiente figura:
Figura 84. Datos conectados a través de ODBC
Ahora, en primer lugar debemos descartar los valores nulos, ya que no nos van a servir para predecir. Esto se puede hacer con un nodo “Type”. Si lo enganchamos al nodo “Fuente_Neptuno”, podemos indicar lo siguiente:
Figura 85. Tipando e indicando entrada y salida
Con la opción “DISCARD” descartamos aquellos que no sean del tipo especificado, en este caso reales. Además hemos eliminado ANYO (dirección = NONE) porque utilizaremos ORD como valor numérico para los años.
En segundo lugar, parece observarse que los datos del trimestre 1996B pueden no estar acabados y los datos del trimestre 1994C pueden ser incompletos. Lo mejor es ignorarlos. Para ello, necesitamos añadir nodos “select” para quitarlos. Existe una manera muy cómoda de hacerlo. Sobre los propios datos de la tabla que genera el nodo tabla cuando se ejecuta señalamos aquellas filas que no nos interesan, como se ve en la siguiente figura:
Figura 86. Generando una condición automáticamente
Seleccionamos el menú “Generate” à “Select Node (“Records”)”. Automáticamente nos genera un nodo “Select”. Lo conectamos al nodo “Type”. Si editamos el nodo “Generate” vemos que nos aparecen justamente las condiciones para incluir esas dos filas. Modificamos el nodo “Select” de tal manera que nos excluya los cuatrimestres que no queremos, quedando de la siguiente manera:
Figura 87. Modificando una condición
Si conectamos un nuevo nodo “Table” a la salida del nodo “Select” y éste al nodo “Type” podremos ver que ya sólo tenemos los datos que nos interesan:
Figura 88. Resultado del filtro
Ahora es el momento de obtener un modelo. En primer lugar vamos a añadir un nodo “Plot” para ver la curva de crecimiento. Lo conectamos al nodo “Select” (que se llama “Generated”). Editamos el Nodo “Plot” y en “X field” ponemos ORD, en “Y field” TOTAL, y en Overlay Field nada.
Figura 89. Editando un Plot
El resultado del Plot se ve en la siguiente figura:
Figura 90. Resultado un Plot
Vemos que se aproxima bastante a la linealidad. Por ello, vamos a aplicar un nodo “Regression” de la categoría “Modelling” y lo conectamos al nodo “Generated”. Ya podemos darle al botón verde de “Execute”. Nos aparece un nuevo modelo en la zona derecha del Clementine. Pinchamos dos veces sobre el diamante y nos aparece en la zona de trabajo. Tendremos una situación como la que sigue:
Figura 91. Stream Resultante
Por último, el modelo resultante se puede ver si se selecciona “Browse” en el nodo diamante:
Figura 92. Modelo Resultante (Ecuación lineal)
Para evaluarlo vamos a utilizar el nodo diamante y lo enganchamos a la fuente a través de un nodo type, igual que el anterior. A continuación del nodo diamante “TOTAL” añadimos un nodo “multiplot”, como se muestra en la siguiente figura:
Figura 93. Evaluando el modelo gráficamente
En el multiplot vamos a poner como variable X ORD y como variables Y vamos a poner TOTAL que es el valor real y $E-TOTAL que es el valor generado.
Figura 94. Editando el multiplot
Si lo ejecutamos tenemos el siguiente resultado:
Figura 95. Comparando la curva real con el valor predicho
Donde podemos ver que el modelo se ajusta bastante bien a la curva real. Ahora si queremos aplicarlo para cualquier valor, utilizamos un nodo “User Input”. Para ello cogemos otro nodo diamante y lo enganchamos con el nodo “generated”. Pinchamos con el botón derecho en el nodo diamante y allí pinchamos en la opción “User Input Mode”, como se ve en la siguiente figura:
Figura 96. Creando un nodo “User Input Node”
Nos ha aparecido un nuevo nodo “User Input”. Editamos el nodo “User Input” e insertamos los valores que queremos predecir (trimestres 11 y 12) y le damos a OK. Por ejemplo, lo que aparece en la siguiente figura (el 10 también lo ponemos para comparar con lo que teníamos):
Figura 97. Entrada de datos manual
Ahora desconectamos el nodo diamante “Total” del nodo “generated” (Recuerda, pinchando en el enlace con el botón derecho: “Destroy Connection”). Conectamos el nodo “User Input” con el nodo diamante “Total” y éste a su vez con un nuevo nodo Table. Ejecutamos el nodo Table y vemos lo que tenemos en la figura siguiente:
Figura 98. Utilizando el modelo para predecir los datos
Como vemos, predecimos un valor de 13440,6 para el trimestre 10 (1996B), que supusimos no terminado (y que es ligeramente superior al existente, 12495, lo que parece lógico), y unas predicciones de 14945,3 para el trimestre 11 (1996C) y una predicción de 16449.9 para el trimestre 12. Ahora podemos grabar el stream.
Sign up to vote on this titleUsefulNot usefulkdd-lab1 by anon-4773500.0 (0)EmbedDownloadDescriptionLaboratorio ClementineLaboratorio ClementineRead on Scribd mobile: iPhone, iPad and Android.Copyright: Attribution Non-Commercial (BY-NC)Download as PDF, TXT or read online from ScribdFlag for inappropriate contentShow moreShow less

References: Resolución 
 Resolución 
 Resolución 
 Resolución 
 Resolución 
 Resolución