Google+ Seguidores

martes, 2 de enero de 2018

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

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 Database\n====================\n\nNotes\n-----\nData Set Characteristics:\n    :Number of Instances: 150 (50 in each of three classes)\n    :Number of Attributes: 4 numeric, predictive attributes and the class\n    :Attribute Information:\n        - sepal length in cm\n        - sepal width in cm\n        - petal length in cm\n        - petal width in cm\n        - class:\n                - Iris-Setosa\n                - Iris-Versicolour\n                - Iris-Virginica\n    :Summary Statistics:\n\n    ============== ==== ==== ======= ===== ====================\n                    Min  Max   Mean    SD   Class Correlation\n    ============== ==== ==== ======= ===== ====================\n    sepal length:   4.3  7.9   5.84   0.83    0.7826\n    sepal width:    2.0  4.4   3.05   0.43   -0.4194\n    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    ============== ==== ==== ======= ===== ====================\n\n    :Missing Attribute Values: None\n    :Class Distribution: 33.3% for each of 3 classes.\n    :Creator: R.A. Fisher\n    :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n    :Date: July, 1988\n\nThis is a copy of UCI ML iris datasets.\nhttp://archive.ics.uci.edu/ml/datasets/Iris\n\nThe famous Iris database, first used by Sir R.A Fisher\n\nThis is perhaps the best known database to be found in the\npattern recognition literature.  Fisher\'s paper is a classic in the field and\nis referenced frequently to this day.  (See Duda & Hart, for example.)  The\ndata set contains 3 classes of 50 instances each, where each class refers to a\ntype of iris plant.  One class is linearly separable from the other 2; the\nlatter are NOT linearly separable from each other.\n\nReferences\n----------\n   - Fisher,R.A. "The use of multiple measurements in taxonomic problems"\n     Annual Eugenics, 7, Part II, 179-188 (1936); also in "Contributions to\n     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 System\n     Structure and Classification Rule for Recognition in Partially Exposed\n     Environments".  IEEE Transactions on Pattern Analysis and Machine\n     Intelligence, Vol. PAMI-2, No. 1, 67-71.\n   - Gates, G.W. (1972) "The Reduced Nearest Neighbor Rule".  IEEE Transactions\n     on Information Theory, May 1972, 431-433.\n   - See also: 1988 MLC Proceedings, 54-64.  Cheeseman et al"s AUTOCLASS II\n     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.

4 comentarios :
Write comentarios

Tu comentario es importante y nos motiva a seguir escribiendo...

Powered by Blogger .