Red neuronal clasificadora de nebulosas.

Para este proyecto se crearon dos códigos: El primero corresponde al código comentado en el anexo 3 y el segundo se encuentra en la liga del anexo 2. La utilidad del primer programa es dar valores específicos e indicar si los datos corresponden a una nebulosa región H-II. El segundo programa sirve para  graficar cada valor ingresado, mismo que a la vez es diferenciando por su color en la clasificación: Las nebulosas región H-II se representan de color amarrillo y los otros tipos de nebulosas de color morado. También se grafica la asertividad en una gráfica por separado, en la cual los puntos de color azul corresponde a todos los valores correctos.


                           Fig. [1] Gráfica de datos clasificados (izquierda) y gráfica de la asertividad del código (derecha).

 Tensorflow se utilizó en ambos códigos, mientras que Scikit-learn sólo en el segundo.Tensorflow es una librería de uso libre que provee herramientas para el desarrollo de inteligencia artificial, en específico de redes neuronales. Scikit-learn también es una herramienta de inteligencia artificial, sólo que ésta se auxilia de la biblioteca matplotlib de python para poder graficar.

Para el primer programa se creó una red neuronal profunda de tres entradas de datos, representadas cada una como entradas de una matriz. Las entradas son en base a las relaciones establecidas anteriormente con las líneas de emisión: log , log   y  log (cada relación  es una entrada). Como salidas se tiene 1 si los datos corresponden a estrellas tipo OB y por lo tanto a regiones H-II o 0 si corresponde la información a otro tipo de nebulosas.

La base de datos utilizada para este proyecto es “3 Million Models Database (3MdB)”, la cual contiene una gran cantidad de datos relacionados a todo tipo de nebulosas. A partir de ésta, que se encuentra en formato MySQL, se crearon archivos en formato csv (representa datos en forma de tabla) con los datos de las líneas de emisión y la relación de la temperatura de las estrellas, expresada como fOB (sus valores corresponden a 1 ó 0). Los archivos sirven para el entrenamiento de la red neuronal y el examen (“test”).

Como salida de datos se tiene 1 ó 0, ya que sólo se utilizaron datos de extremos, es decir, los valores intermedios de la razón de líneas de emisión que corresponden a los valores de la temperatura como 0.4 ó 0.9 no fueron tomados en cuenta.

            Ambos códigos se corrieron en un entorno virtual en la terminal de Ubuntu (Linux). El resultado de un caso particular con el primer programa, al introducir dos matrices de datos, corresponde a la Fig. 7.3. De acuerdo a la imagen de abajo, la información de ambas matrices no corresponde a una nebulosa región H-II, ya que son igual a 0 (array [0], dtype = object).

Fig. [2] Resultado de datos.
               Al correr el segundo código se obtienen gráficas en formato pdf que corresponden a las figura 8.1, 8.2 y 8.4. En las gráficas de abajo se observa que entre más veces vuelva a ejecutarse el entrenamiento de la red neuronal (los “steps” indica el número de veces que se ejecuta el entrenamiento), menor grado de error tendrá el programa en sus resultados.


                          Fig. [3] Diagramas de asertividad con índice de propagación (barras verticales).


            La asertividad de los programas después  de ejecutarlos varias veces es aproximadamente del 96.44%, tomando en cuenta alrededor de 2500 datos evaluados. La asertividad puede ser mejorada volviendo a correr el programa varias veces y aumentado la base de datos del entrenamiento. El límite de máxima asertividad se alcanza con los 300 steps, es decir, si se corre 300 ó 1000 veces su eficiencia es la misma.

Anexo 1.

El siguiente link es para seguir los pasos y poder descargar Tensorflow: https://www.tensorflow.org/install/ . Además los siguientes links son para revisar los turoriales de Tensorflow y enteder cómo funciona este software, así como aprender a hacer códigos: https:https://www.tensorflow.org/get_started/ y   https://www.tensorflow.org/tutorials/

Para encontrar información de la base de datos utilizada en este proyecto se puede aceder al siguiente link: https://sites.google.com/site/mexicanmillionmodels/ . Para tener acceso a ella deberás enviarle un correo al Dr. Morriset, el cual viene en la misma página del link.

      
Anexo 2. 

           Los archivos correspondientes a cada código así como el código mismo se pueden derscargar del siguiente link al solictar acceso a ellos. Una vez confrimado el acceso se les notificará con un correo: https://drive.google.com/drive/folders/1a7S_C-A3SKVCQw7JQta0oG8diN7vYWog

Si se desea ejecutar el código se deberán tener los archivos de datos de entrenamiento y del test en la misma carpeta donde se ejecuta el programa, para el programa pueda localizarlos.


Anexo 3. 

#Importa las librerias necesarias con comandos para poder correr el programa.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os

#Numpy es una biblioteca de python que contiene operaciones complejas, en este código la usas para manejar matrices.

#Como ya vimos que en este sódigo se utliza el software de tensorflow de Google, se necesitta descargar la biblioteca para que se lea el programa.

import numpy as np
import tensorflow as tf

# Conjuntos de datos: Se definen las variables que contienn los archivos de datos.
NEB_TRAINING = "NEB_TRAINING.csv"

NEB_TEST = "NEB_TEST.csv"

#Función principal del programa.
def main():

print('# Cargando datos.')
#Carga los archivos con los datos de las nebulosas de acuerdo al llamado (entrenamiento o test).
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
filename=NEB_TRAINING, #Nombre del archivo de datos del entrenamiento.
target_dtype=np.int, #Target es la columna verificadora (resultado deseado).
features_dtype=np.float64) #Indica el tipo de variable que tiene las columnas de entrada de datos a estudiar.

#Se hace los mismo que el apartado de arriba, solo que ahora con el archivo de evaluación (test).
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
filename=NEB_TEST,
target_dtype=np.int,
features_dtype=np.float64)

# Especifica las columnas de datos a estudiar y declara al conjunto delas primeras 3 columnas como la constante x.
feature_columns = [tf.feature_column.numeric_column("x", shape=[3])]

Contrsuye la red neuronal de 3 capas ocultas con el tipo de red DNN (Deep Neuronal Networks) con 10 neuronas en la primera capa, 20 en la segunda y 10 en la tercera.
classifier = tf.estimator.DNNClassifier(feature_columns=feature_columns,
hidden_units=[10, 20, 10],
n_classes=2, #Clasifica 2 tipos de nebulosas.
model_dir="/tmp/neb_model") #Guarda los datos en un archivo temporal.

#tf.estimator define las operaciones que generarán información del modelo de la red neuronal.
#Define las entradas de datos del entrenamiento
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"x": np.array(training_set.data)}, #Entrada de los datos que queremos analizar.
y=np.array(training_set.target), #Entrada de los resultados que queremos obtener.
num_epochs=1, #Número de veces que corre los datos.
shuffle=True) #Ordena los datos aleatoriamente.
# Modelo de entrenamiento.
classifier.train(input_fn=train_input_fn, steps=2000) #Número de pasos para entrenar la red.

# Define las entradas de los datos de la evaluación (test).
test_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"x": np.array(test_set.data)},
y=np.array(test_set.target),
num_epochs=1,
shuffle=False)
print('define tests input')

# Evalúa la asertividad del programa.
accuracy_score = classifier.evaluate(input_fn=test_input_fn)["accuracy"]
#Imprime la asertividad del programa, , tomando 1 = 100%.
print("\nTest Accuracy: {0:f}\n".format(accuracy_score))

# Ingresas los datos de dos nebulosas (porque hay dos matrices). Los datos son de las primeras tres columnas de algún reglón del archivo NEB_TEST.  En este apartado también define la función para clasificar las nebulosas.
new_samples = np.array(
[[1.0742222007,0.4570166416,3.9231402109],
[1.9223417996,0.8726396574,5.0934708792]], dtype=np.float64)
predict_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"x": new_samples},
num_epochs=1,
shuffle=False) #No ordena los datos aleatoriamente, ya que eso sólo es necesario para el entrenamiento para que no cree relaciones falsas por el acomodo específico de datos.

#Analiza los datos y clasifica las nebulosas (1= Nebulosa región HII y 0=Otro tipo de nebulosa).
predictions = list(classifier.predict(input_fn=predict_input_fn))
predicted_classes = [p["classes"] for p in predictions]

#Imprime los resultados obtenidos de la clasificación de los dos ejemplos de datos.
print(
"New Samples, Class Predictions: {}\n"
.format(predicted_classes))
print("Si el array = [1], entonces es una nebulosa Region HII \n")
print("Si el array = [0], entonces es otro tipo nebulosa \n")

#Corre todas las operaciones contenidas en la función main (principal).
if __name__ == "__main__":
main()




Referencias:

-Fig. [1], [2] y [3] se obtuvieron al correr los códigos 1 y 2.
 - "3MdB". (2017). Morriset Christphe. 3MdB: lines. CONACyT - DGAPA-UNAM. Recuperado el 18 de octubre del 2017, de: https://sites.google.com/site/mexicanmillionmodels/the-different-tables/lines

-“Tensorflow”. (2017). Google: Tensorflow. Recuperado el 15 de diciembre del 2017, de: https://www.tensorflow.org/

Comentarios

  1. Hola!
    Muchísimas gracias por el código, tengo varios días intentando utilizar tensor flow y la verdad no encontraba algo tan claro.
    Que esté comentado y explicado de esta forma en verdad me ayudo mucho más que otros tutoriales. Muchas Gracias. Saludos! :D

    ResponderBorrar
  2. Muchas gracias por esto!!!
    Me ayudó muchísimo con mi tarea

    ResponderBorrar

Publicar un comentario