TODO

ALREADY DONE:
  + Hacer paquete de R,
  + A la hora de inferir, no leer toda la imagen de golpe, hacerlo de forma ordenada e ir montando la imagen resultado poco a poco, dependiendo de si el lote entero cabe en memoria
  + on.exit() en fit_generator para cargar siempre la mejor configuración
  + Si categorize_output == TRUE, hacer class_balance por cada una de las clases.
  + "fit_with_generator" no cambia el valor de "best_loss", quizás haya que convetir "DLmodel" en un environment.
  + transform_coords para (x, y, z) entre la imagen input y la output, si la resolución fuera distinta.
  + Multi-input como lista de listas vol_layers...
  + Buscar BRATS 2015 training set
  + Block_multivalued, como las múltiples capas categóricas, pero después cada una de ellas con una capa lambda que haga el producto dot por 1:numclasses. Y una alternativa que haga argmax, pero esta última no se entrene. Debería tener la posibilidad de meter capas ocultas intermedias distintas en cada capa categórica.
  + Comenzar todo definiendo la configuración, que se usará para crear el modelo, para los generadores, al entrenar y en la inferencia.
  + Model load and save con hiperparámetros.
  + Modelo más genérico, donde una parte es el volumen 3d y la otra son las features que se extraigan de la imagen (extensión de únicamente usar las coordenadas xyz en esa otra parte)
  + Si hace falta red convolucional, se hace un layer reshape
  + Usar lo de leer las ventanas de una imagen en posiciones aleatorias
  + Siempre son dos inputs, las coordenadas y el volumen de la ventana, se unen en la primera capa densa.
  + Así se puede definir el width pero no hace falta stride
  + Clase r6 que guarde el width y tenga los métodos para entrenar dados los datos de entrenamiento e inferir una imagen entera?
  + Diferentes losses, ad hoc para cada problema. Multi-output y multi-loss. Probar loss_categorical_entropy.
  + "fit with generator" con "initial_epoch" para mantener tasas de aprendizaje y demás.
  + warning en "fit_with_generator" si ya existe el directorio donde se guarda el modelo. Recuperar al principio???
  + En get_windows_at, permitir todas las coordenadas posibles, solo se rellena con ceros cuando esté fuera de la imagen original. Así se podrá inferir la imagen completa. Lo mismo a la hora de escribir las ventanas en un nuevo volumen.
  + Si hay más clases aparte de las que se predicen, hacer que se combinen en una única clase "otras", que también se debe predecir para ayudar a clasificar mejor: esto ayudaría a la parcelación.
  + Pipeline o flujo de modelos, donde la salida de unos se utiliza como inputs para otros modelos. En definitiva, un grafo que conecta modelos y proporciona resultados.
  + Por cada nuevo output en el flow, estimar el camino hasta los inputs: habrá de cambiar la dirección en el grafo.
  + Grafo de cada red, que se pueda dibujar con graphviz o con el método que sea. Nombres a los nodos/capas autogenerados a partir de un "prefix" que se proporciona.
  + class_balance cuando se hace subset_problem y demás. Basta con hacer el map_ids a Vy al principio de create_generator_from_config.
  + gaussian kernel para config$regularize no NULL
  + map_ids e inverso para la inferencia y al hacer plot
  + Funciones de "scale". Así todos los modelos de un flujo tendrán "scale == 'none'".
  + "save_flow" y "load_flow".
  + Diferentes tipos de salida en execute_flow (guardar en nii.gz y en RDS).
  + Clonar un flujo.
  + Modo debug al ejecutar y entrenar un flujo
  + Entrada 4D. Preparar todo para volúmenes 4D como DTI o fMRI.
  + Copiar partes de un flujo.
  + Lectura de inputs y demás al ejecutar flujos más rápida.
  + which.max en 4D
  + En save_flow, resetear los outputs para no almacenar todo!!
  + reset_model en un flujo.
  + Pasar de una capa no convolucional a otra que sí sea convolucional requiere de un paso intermedio.
  + Faltan wrappers para block_downsample, block_upsample y block_unet, en "wrappers" y en "add_layers".
  + Revisar map_ids y el remap_classes que no se almacena correctamente algunas veces.
  + batch_size <- config$memory_limit / object.size(vector(mode = "double", length = sum(model %>% model_units())))  
  + Determinar número de batches cuando el modelo es convolucional.
  + layer_permute para que el inicio sea correcto.
  = Añadir batch_size en fit_with_generator como argumento.
  + batch_size calculado en inference function
  + Congelar el modelo a la hora de hacer inferencia.
  + Adaptar funciones para ancho "config$width" par.
  + Re-escribir redes densas cuando es convolucional como filters = numero de unidades, kernel_size = tamaño de la salida anterior.
  + Visualizador de modelos: keras:::keras$utils$plot_model(bet_model$model, to_file = "model.png", show_shapes = TRUE). Necesita pydot y graphviz.
  + Visualizador de activaciones en capas convolucionales
  + Adaptar para que la unidad básica sea el "DLscheme". A partir de ahí se instancia tanto el modelo como el "DLconfig". Las funciones create_generator o create_inference_function pueden aceptar DLscheme o DLconfig.
  + Actualizar flows para usar "DLscheme"
  + Después de load_model, no se mantiene el input de las coordenadas en redes convolucionales.
  + Redes convolucionales solo tienen un input
  + Gestión de memoria.
  + Actualizar ejemplos con "DLscheme"
  + Visualizar input que maximiza las activaciones de una capa.
  + Poner capas convolucionales a la salida
  + Entrenar con capas convolucionales.
  + Añadir callback_tensorboard.
  + Un historial del loss al entrenar que se pueda representar gráficamente (incluso de forma interactiva?).
  + Reescribir block_downsample y block_upsample.
  + Poner defaults para batch_normalization, dropout y activation en config.properties.
  + Sistema de logs y history dentro del DLmodel.
  + Pasar todo a clases R6.
  + DLflow$get_model(output)
  + DLflow$replace(output, with)
  + Usar data augmentation con las imágenes... Pequeños giros y/o traslaciones.
  + Datasets para los problemas online, es decir, pasar dl4ni.data a que los datasets se descarguen de forma automática de algún repositorio, como el MNIST en otros paquetes. Función get_dataset(repo_name) que descarga a alguna ubicación temporal o predefinida. Se separa cada dataset en un repositorio, si no se copian los outputs se sobreentiende que son los mismos que los inputs. Tiene que haber una carpeta de caché, como hace keras para organizar los datos que va a usar.
  + Meter en get_problem_info que si un dataset no tiene directorio de outputs, éste debe apuntar al de inputs.
  + README.md para github
  + Cambiar el factor 4 de compute_batch_size.
  + Aligerar el número de parámetros de los modelos.
  + check layer definition conformity
  + Unificar parámetros U-Net y SegNet.
  + schemes prefijados
  + meshnet
  + Error en DLmodel.fit cuando keep_best == FALSE, no se definen path y prefix.
  + prepare_for_training = FALSE en DLscheme$instantiate.
  + instantiate_autoencoder.
  + Actualizar para usar la última versión del paquete keras.

WIP:
  = Comentarios y documentación en todas las funciones
  = Importar modelo keras externo, deduciendo su configuración... Así ampliamos el "model zoo"...
  = create_generator, create_inference_function, configuration... Cambiar lo necesario para inputs/outputs 4D.
  = Limpiar utils4ni a una versión mínima con lo que necesita d4ni
  = dl4ni: mage intensity augmentation. Add noise and change contrast.
  = Encoder y decoder con sus funciones de inferencia. Misma función de inferencia, pero los inputs y outputs se procesarán de forma distinta según encoder, decoder o modelo.
  = keras_warmup <- load_keras y más.
  = Seleccionar ventanas de la imagen usando una máscara.
  = Raise memory limit a un modelo, no desde el esquema. (Not enough memory to train the model, raise the memory limit?)
  = Cambiar set_trainability a freeze_weights, unfreeze_weights en la última versión de keras.
  = multiwidth.
  = build_model en el flow, para acompañar a train_output.
  = model$memory_size()
  = TESTS. Comenzar por los genéricos que cubran mucho y seguir por otros más específicos.
  = suppressPackageStartupMessages para todos los paquetes que se cargan.
  = width distinto en cada dimensión
  = Cambiar RESNET.
  = Calcular output_width a partir de si el modelo es convolucional y del tamaño de la salida de la última capa.
  = Generar nombres de forma automática en create_model_from_config.
  = Cambiar el input de un modelo convolucional para que acepte una imagen entera?
  = CLF da problemas si las dimensiones no son las adecuadas en capas convolucionales. Chequear.
  = Mejoras de velocidad en create_generator_from_config.
  = Función "is_keras_object" para comprobar que algo es un tensor de tensorflow.
  = infer_probability_map normalizando por la suma de todas las componentes. Así tendríamos la salida 4D directamente.
  = Incluir "tumor_detection" en el flow. Podría usar las features que usan los de ANTs y Árboles.
  = Se puede hacer otro flow para la transformación a FLAIR usando "only_brain" y "segmentation".
  
TODO:
  - Meter el info del problema en el config.
  - "save_model" y "load_model" con la posibilidad de guardar comprimido.
  - Reshape a la salida de la red para que tenga dimensiones (output_width ^ 3, num_classes) sobre la que se aplica softmax.
  - Error checking en todas las funciones con respecto a los argumentos de entrada (del tipo correcto, de la existencia de archivos...)
  - Tratar de inferir tanto el scale como el scale_y según el tipo de problema
  - GAN
  - En "graph_from_model", que se calcule un layout o que se le pueda pasar un layout para su plot.
  - default_block <- function(num_layers, initial_units, last_units, type = c("dense", "conv")).
  - Construir un grafo por cada path independiente desde cada input hasta el knot, y se usa para distribuir los nodos del grafo y pintarlo.
  - En get_problem_info, poner "problem_description" y un "verbose".
  - En get_problem_info, preparar para "autoencoder", donde el last_layer_info podrá ser usado como decoder (o parte de él).
  - Adaptar get_problem_info para problemas de clasificación o regresión donde solo hay una salida (por imagen): para el registro de la imagen, para clasificar sujetos en grupos...
  - Viñetas y README.md
  - Layers operations, como select_layers (by_name, by_index)...
  - Al hacer grafo, renombrar capas, y usar esta función al generar el modelo. En la configuración (y en la info del problema) almacenar el nombre de la carpeta de los inputs ("T1", "FLAIR") que después se usará para renombrar las capas.
  - verbose para la función de "fit_with_generator"
  - Más tipos de bloques: block_clf, block_resnet, block_unet, block_smooth (como last layer y extended), block_crop, block_downsample, block_upsample...con sus wrappers.
  - Extended Model cuando last_layer tiene type multivalued o similar, se le añade una más (que habrá que gestionar en la inference function), por ejemplo haciendo argmax o un layer_dot con un tensor constante...
  - App shiny (playground) para hacer el entrenamiento, definir la configuración, crear modelos o aplicarlos, con la posibilidad de usar un widget para visualizar imágenes 3d.
  - Manipulación de redes. 
  - pad_sequence con lstm para hacer modelos sobre la imagen al completo.
  - Generación de textos a partir de las imágenes completas: empezar con output \in\{"axial", "coronal", "sagital"\} e ir complicando el modelo.
  - Autoencoder para la parcelación. Si podemos representar una parcelación por número entre -1 y 1 por ejemplo, podemos hacer que eso sea la salida de la red para que Mapee una ventana de la imagen original a la codificación de la parcelación
  - Mapeo de T1 a Flair...
  - Cálculo de la matriz de transformación homogénea del registro afín, usando la parte central de una imagen, y varias LSTM o similar para hacer regresión sobre las componentes de la matriz.
  - Reinforcement learning para clasificación, primero de una red que intenta aprender la clasificación al estilo Flappy Bird y después redes enfrentadas que luchen por ver cuál lo hace mejor y aprendan una de la otra.
  - Regresión para calcular el grosor cortical
  - Un sistema completo de procesamiento de imagen estructural con Deep Learning, desde la corrección de la inhomogeneidad, BET, segmentación, parcelación, orientación a espacio MNI, y cuantificación de volumen y grosor.
  - Y cálculo de lesiones.
  - Prepararlo todo para problemas más generales (clasificación de imágenes de sujetos en varios grupos, super resolución, multimodalidad...)
  - Viñetas y demos por cada problema.
  - Lstm para procesar la imagen entera??