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.
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.
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/
Hola!
ResponderBorrarMuchí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
Muchas gracias por esto!!!
ResponderBorrarMe ayudó muchísimo con mi tarea