Introducción al Machine Learning #4 - Conjuntos de Datos

Índice()

    Introducción:

    Antes que nada, les deseo un Feliz Año Nuevo a todos ustedes, espero que este año la vida nos trate lo mejor que pueda.

    Les doy la bienvenida a un nuevo articulo cuyo tema es "Introducción al Machine Learning", en el día de hoy hablaremos de los conjuntos de datos, ¿Cuales conjuntos de datos?. Pues ya te lo explico.


    En el articulo pasado hablamos sobre los algoritmos de aprendizaje, si aun no lo has visto, te recomiendo que lo hagas: http://www.pythondiario.com/2017/12/introduccion-al-machine-learning-3.html.


    Perfecto, ya conocemos los distintos algoritmos de aprendizaje, eso es una parte muy importante de conocer, ya que sabemos de que tipo es el problema y como podremos solucionarlo.


    Hoy hablaremos de datos, tener un conjunto de datos bien hecho es un factor que influye mucho en que tan bien aprenderá nuestro algoritmo.

    Conjuntos de Datos:

    El aprendizaje automático se trata de aprender las propiedades de un conjunto de datos para poder aplicarlas a nuevos datos. Esta es la razón por la cual una practica común en el aprendizaje automático es dividir los datos disponibles en dos conjuntos, uno que llamamos conjunto de entrenamiento con el cual entrenaremos a nuestro algoritmo, y otro el cual llamamos conjunto de prueba con el cual probaremos que tan bien entrenamos a nuestro algoritmo.

    Pero, como podemos dividir los datos si aun no hemos visto ningún dato?

    Entonces que esperamos, busquemos esos datos.

    Cargando los Conjuntos de Datos:

    Dentro de la libreria scikit-learn, estan disponibles una gran cantidad de conjuntos de datos, cada uno para un problema diferente. 

    Por ejemplo, tenemos el conjunto de datos Iris: El cual es un conjunto de datos introducido por Ronald Fisher, en el se encuentran contenidas 50 muestras de cada una de las especies de iris (iris setosa, iris virginica, iris versicolor). Se midió 4 rasgos de cada muestra: lo largo y lo ancho de los sépalos y pétalos, en centímetros. Este conjunto de datos es usado para problemas de clasificación.

    Que les parece un ejemplo:


    from sklearn import datasets
    
    iris = datasets.load_iris()

    Como pueden observar, hemos empezado a utilizar el modulo sklearn. Dentro del modulos datasets, podremos encontrar todos los conjuntos de datos nque scikit-learn nos proporciona. En este caso utilizamos "load_iris()" para cargar el conjunto de datos "Iris", el cual guardo en la variable "iris".


    Ahora, la variable iris contiene todos los datos, los cuales podemos manipularlos manualmente. Si utilizamos el método type() para ver que tipo de datos es nuestra variable "iris":


    type(iris)
    

    Out[6]:
    sklearn.utils.Bunch



    Como pueden observar, el tipo de datos de "iris" es Bunch. Resumiendo, el tipo Bunch es como un tipo de diccionario.


    Si utilizamos el método dir() para ver los métodos y atributos que contiene load_iris() veremos los siguiente:




    dir(iris)
    

    Out[11]:
    ['DESCR', 'data', 'feature_names', 'target', 'target_names']
    El atributo DESCR, contiene la descripción del conjunto de datos en Texto Plano:


    iris.DESCR
    

    Out[13]:
    'Iris Plants Databasen====================nnNotesn-----nData Set Characteristics:n    :Number of Instances: 150 (50 in each of three classes)n    :Number of Attributes: 4 numeric, predictive attributes and the classn    :Attribute Information:n        - sepal length in cmn        - sepal width in cmn        - petal length in cmn        - petal width in cmn        - class:n                - Iris-Setosan                - Iris-Versicolourn                - Iris-Virginican    :Summary Statistics:nn    ============== ==== ==== ======= ===== ====================n                    Min  Max   Mean    SD   Class Correlationn    ============== ==== ==== ======= ===== ====================n    sepal length:   4.3  7.9   5.84   0.83    0.7826n    sepal width:    2.0  4.4   3.05   0.43   -0.4194n    petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)n    petal width:    0.1  2.5   1.20  0.76     0.9565  (high!)n    ============== ==== ==== ======= ===== ====================nn    :Missing Attribute Values: Nonen    :Class Distribution: 33.3% for each of 3 classes.n    :Creator: R.A. Fishern    :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)n    :Date: July, 1988nnThis is a copy of UCI ML iris datasets.nhttp://archive.ics.uci.edu/ml/datasets/IrisnnThe famous Iris database, first used by Sir R.A FishernnThis is perhaps the best known database to be found in thenpattern recognition literature.  Fisher's paper is a classic in the field andnis referenced frequently to this day.  (See Duda & Hart, for example.)  Thendata set contains 3 classes of 50 instances each, where each class refers to antype of iris plant.  One class is linearly separable from the other 2; thenlatter are NOT linearly separable from each other.nnReferencesn----------n   - Fisher,R.A. "The use of multiple measurements in taxonomic problems"n     Annual Eugenics, 7, Part II, 179-188 (1936); also in "Contributions ton     Mathematical Statistics" (John Wiley, NY, 1950).n   - Duda,R.O., & Hart,P.E. (1973) Pattern Classification and Scene Analysis.n     (Q327.D83) John Wiley & Sons.  ISBN 0-471-22361-1.  See page 218.n   - Dasarathy, B.V. (1980) "Nosing Around the Neighborhood: A New Systemn     Structure and Classification Rule for Recognition in Partially Exposedn     Environments".  IEEE Transactions on Pattern Analysis and Machinen     Intelligence, Vol. PAMI-2, No. 1, 67-71.n   - Gates, G.W. (1972) "The Reduced Nearest Neighbor Rule".  IEEE Transactionsn     on Information Theory, May 1972, 431-433.n   - See also: 1988 MLC Proceedings, 54-64.  Cheeseman et al"s AUTOCLASS IIn     conceptual clustering system finds 3 classes in the data.n   - Many, many more ...n'
    En ingles, pero nada que Google traductor no resuelva.


    Luego tenemos el atributo "feature_names", el cual contiene una lista con los nombres de las características:


    iris.feature_names
    
    Out[14]:
    ['sepal length (cm)',
     'sepal width (cm)',
     'petal length (cm)',
     'petal width (cm)']



    Luego, tenemos al atributo "target_names", el cual contiene una lista con los nombres de cada tipo de flor:


    iris.target_names
    
    Out[15]:
    array(['setosa', 'versicolor', 'virginica'],
          dtype='<U10')



    Por ultimo tenemos a los atributos "data" y "target", "data" contiene todos los datos de las medidas de los tipos de flores, mientras que "taget"  contiene las etiquetas con las cuales etiquetaremos a cada conjunto de datos dentro de "data", de esta manera el algoritmo se los aprenderá los datos según su etiqueta, para luego poder predecir nuevos datos sin etiquetas, por ello, se le llama problema de clasificación, por que lo que queremos es que el algoritmo clasifique nuevos datos:


    iris.data
    
    Out[16]:
    array([[ 5.1,  3.5,  1.4,  0.2],
           [ 4.9,  3. ,  1.4,  0.2],
           [ 4.7,  3.2,  1.3,  0.2],
           [ 4.6,  3.1,  1.5,  0.2],
           [ 5. ,  3.6,  1.4,  0.2],
           [ 5.4,  3.9,  1.7,  0.4],
           [ 4.6,  3.4,  1.4,  0.3],
           [ 5. ,  3.4,  1.5,  0.2],
           [ 4.4,  2.9,  1.4,  0.2],
           [ 4.9,  3.1,  1.5,  0.1],
           [ 5.4,  3.7,  1.5,  0.2],
           [ 4.8,  3.4,  1.6,  0.2],
           [ 4.8,  3. ,  1.4,  0.1],
           [ 4.3,  3. ,  1.1,  0.1],
           [ 5.8,  4. ,  1.2,  0.2],
           [ 5.7,  4.4,  1.5,  0.4],
           [ 5.4,  3.9,  1.3,  0.4],
           [ 5.1,  3.5,  1.4,  0.3],
           ...])

    Observen, que estamos en presencia de una lista bidimensional con 150 filas y 4 columnas. Cada fila es un conjunto de medidas perteneciente a un tipo de flor. Cada columna es una característica diferente, las cuales son: sepal length (cm), sepal width (cm), petal length (cm), petal width (cm)




    iris.target
    
    Out[17]:
    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

    En "target" se encuentran 150 elementos, los primeros 50 son "0", los otros 50 son "1", y los últimos 50 son "2". Estos elementos son los elementos que etiquetaran a los conjuntos de datos dentro de "data". Los "0" representan el tipo de iris "setosa", los "1" representan al tipo de iris "versicolor", y los "2" representan a el tipo de iris "virginica". Los primeros 50 elementos (0) serán asignados a los primeros 50 conjuntos de "data", los otros 50 elementos (1) serán asignados a los otros 50 conjuntos de "data", y los últimos 50 elementos (2) serán asignados a los últimos conjuntos de "data".


    Muy bien, e hablado de asignación y clasificación, pero hay que tener en claro que todo esto sucederá al momento de entrenar el algoritmo (en el próximo articulo), por ahora estos datos son independientes.


    Resultado de imagen
    Una imagen que muestra una tabla con los atributos del conjunto de datos iris.

    Conjuntos de Entrenamiento y Conjuntos de Prueba:

    Muy bien, siguiendo con lo que habíamos hablado en el principio. Es una practica común separar nuestros datos, y es lo que haremos, de esta manera en el próximo articulo nos centraremos en los algoritmos.


    En la libreria scikit-learn, existe un modulo llamada "model_selection", el cual contiene un metodo que nos permite separar nuestros datos en conjuntos de entrenamiento y de prueba.


    from sklearn.model_selection import train_test_split
    
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target)




    Como pueden observar, definino 4 variables al mismo tiempo (x_train, x_test, y_train, y_test), y utilizamos el metodo "train_test_split()" al cual le pasamos como argumentos a "iris.data" y "iris.target". Por ejemplo si mostramos en pantalla las variables de test:


    x_test
    
    Out[23]:
    array([[ 6.3,  3.4,  5.6,  2.4],
           [ 4.7,  3.2,  1.3,  0.2],
           [ 6.9,  3.1,  5.1,  2.3],
           [ 4.6,  3.6,  1. ,  0.2],
           [ 5.4,  3.4,  1.7,  0.2],
           [ 6.1,  2.8,  4. ,  1.3],
           [ 6.9,  3.2,  5.7,  2.3],
           [ 6.8,  3.2,  5.9,  2.3],
           [ 6.4,  2.7,  5.3,  1.9],
           [ 6.5,  3.2,  5.1,  2. ],
           [ 5.7,  3. ,  4.2,  1.2],
           [ 5.2,  4.1,  1.5,  0.1],
           [ 4.8,  3.1,  1.6,  0.2],
           [ 7.9,  3.8,  6.4,  2. ],
           [ 5. ,  3.5,  1.6,  0.6],
           [ 6.3,  2.9,  5.6,  1.8],
           [ 5.7,  2.9,  4.2,  1.3],
           [ 5.8,  4. ,  1.2,  0.2],
           [ 4.9,  3. ,  1.4,  0.2],
           [ 5.5,  3.5,  1.3,  0.2],
           [ 5.7,  2.8,  4.1,  1.3],
           [ 5. ,  3.4,  1.6,  0.4],
           [ 6.3,  2.5,  5. ,  1.9],
           [ 7.7,  2.8,  6.7,  2. ],
           [ 7.2,  3.2,  6. ,  1.8],
           [ 5.6,  2.5,  3.9,  1.1],
           [ 7.6,  3. ,  6.6,  2.1],
           [ 5.1,  3.8,  1.6,  0.2],
           [ 4.6,  3.4,  1.4,  0.3],
           [ 6.4,  2.8,  5.6,  2.2],
           [ 6.7,  3. ,  5.2,  2.3],
           [ 6. ,  2.2,  4. ,  1. ],
           [ 6.3,  3.3,  4.7,  1.6],
           [ 5.4,  3.9,  1.3,  0.4],
           [ 4.8,  3.4,  1.6,  0.2],
           [ 5.8,  2.6,  4. ,  1.2],
           [ 6.7,  3.3,  5.7,  2.5],
           [ 6.5,  3. ,  5.5,  1.8]])

    y_test
    
    Out[25]:
    array([2, 0, 2, 0, 0, 1, 2, 2, 2, 2, 1, 0, 0, 2, 0, 2, 1, 0, 0, 0, 1, 0, 2, 2, 2, 1, 2, 0, 0, 2, 2, 1, 1, 0, 0, 1, 2, 2])

    Como pueden observar, el método para separar lo datos, escoge los datos al azar para luego hacer pruebas. Las variables "x" contienen los datos, las medidas de las flores, mientras que las variables "y" contiene las etiquetas.




    Bueno, creo que eso esta bien por ahora, mi objetivo era explicar lo de los datos, para luego centrar más en el entrenamiento de los algoritmos.

    Comparte tu experiencia con nosotros. Si tienes alguna duda, no dudes en preguntar.


    Mi nombre es Luis, y les deseo un Feliz Año Nuevo a todos ustedes :D.

    1. Unknown dice:

      excelente, muy bien explicado

    2. Fernando Miño dice:

      Gracias por tus buenos deseos y tu dedicación

    3. Unknown dice:

      Esta intersante y exitos este 2018 a aeguir adelñante con tus proyectos

    4. iris9112 dice:

      Muchas gracias, me fue de gran ayuda 😀

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

    Subir

    Te has suscrito correctamente al boletín

    Se produjo un error al intentar enviar tu solicitud. Inténtalo de nuevo.

    Mi Diario Python will use the information you provide on this form to be in touch with you and to provide updates and marketing.