<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jorge MF on Medium]]></title>
        <description><![CDATA[Stories by Jorge MF on Medium]]></description>
        <link>https://medium.com/@jorgemf?source=rss-8c45699c1f1e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*gaa1QQ70tpBFIi-ss4ANOA.png</url>
            <title>Stories by Jorge MF on Medium</title>
            <link>https://medium.com/@jorgemf?source=rss-8c45699c1f1e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 14:32:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jorgemf/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Medicina Personalizada: redefinidiendo el tratramiento del cáncer con Deep Learning]]></title>
            <link>https://medium.com/@jorgemf/medicina-personalizada-redefinidiendo-el-tratramiento-del-cancer-con-deep-learning-2cc39157f265?source=rss-8c45699c1f1e------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cc39157f265</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[tensorport]]></category>
            <category><![CDATA[tensorflow]]></category>
            <category><![CDATA[classification]]></category>
            <category><![CDATA[nlp]]></category>
            <dc:creator><![CDATA[Jorge MF]]></dc:creator>
            <pubDate>Mon, 20 Nov 2017 02:43:23 GMT</pubDate>
            <atom:updated>2018-01-19T12:39:27.365Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M-KEcCMc1Li9kFIv95SMxQ.jpeg" /></figure><blockquote>Este artículo fue publicado originalmente en inglés en <a href="https://medium.com/@jorgemf/personalized-medicine-redefining-cancer-treatment-with-deep-learning-f6c64a366fff">https://medium.com/@jorgemf/personalized-medicine-redefining-cancer-treatment-with-deep-learning-f6c64a366fff</a><br><br>Puedes encontrar el código fuente del projecto en GitHub: <a href="https://github.com/jorgemf/kaggle_redefining_cancer_treatment">https://github.com/jorgemf/kaggle_redefining_cancer_treatment</a></blockquote><blockquote><a href="https://jorgemf.github.io/">Jorge Muñoz Fuentes</a> es un investigador de Inteligencia Artificial y Aprendizaje Automático que trabaja para varias startups de San Francisco y actualmente forma parte del grupo de expertos, y es fundador, de <a href="http://serendeepia.com/">Serendeepia</a></blockquote><blockquote>Nota: este trabajo ha sido soportado economicamente por <a href="http://goodailab.com/">Good AI Lab</a> y todos los modelos han sido entrenados en su plataforma <a href="https://tensorport.com/">TensorPort</a></blockquote><h3>Introducción</h3><p>En este artículo queremos mostraros como aplicar deep learning a un dominio donde no somos expertos. Usualmente utilizar información del dominio de un problema ayuda a que los algoritmos funcionen mejor, pero este no es nuestro caso. Vamos a crear un modelo de deep learning para una competicón de kaggle titulada: “<a href="https://www.kaggle.com/c/msk-redefining-cancer-treatment">Personalized Medicine: Redefining Cancer Treatment</a>”.</p><p>El objetivo de la competición es clasificar un documento, un paper científico, en el tipo de mutación que contribuye al crecimiento del tumor. Para ello contamos con informacin sobre el gen y la variante. Actualmente la interpretación de las mutaciones genéticas se hace de forma manual, y es una tarea que consume muchos recursos.</p><p>Vamos a abordar este problema como un problema de clasificación de textos del dominio de artículos médicos. Es importante resaltar el dominio específico aquí, ya que probablemente ,no podamos adaptar otros modelos de clasificación de texto a nuestro dominio específico debido al vocabulario utilizado.</p><p>Otro desafío importante al que nos enfrentamos con este problema es que el conjunto de datos solo contiene 3322 muestras para el entrenamiento. Por lo general, los algoritmos de deep learning tienen cientos de miles de ejemplos para el entrenamiento. Por ello, tendremos que mantener nuestro modelo simple o hacer algún tipo de aumento de datos para incrementar el ñumero de ejemplos de entrenamiento.</p><p>En las siguientes secciones, veremos algoritmos relacionados con la clasificación de textos, incluidos los algoritmos que no son de deep learning. Después, describiremos el conjunto de datos y las modificaciones realizadas antes del entrenamiento. Continuaremos con la descripción de los experimentos y sus resultados. Y finalmente, las conclusiones y un apéndice de cómo reproducir los experimentos en TensorPort.</p><h3>Algoritmos utilizados para la clasificación de texto</h3><h4>Modelos tradicionales, no pertenecientes a deep learning</h4><p>Los métodos tradicionales para la clasificación de textos están basados en <a href="https://es.wikipedia.org/wiki/Modelo_bolsa_de_palabras">bag of words</a> (conjuntos de palabras) y <a href="https://es.wikipedia.org/wiki/N-grama">n-grams</a> (conjuntos ordenados de palabras). En ambos casos, un conjunto de palabras del texto original se usa para entrenar un clasificador simple, como podría ser <a href="https://en.wikipedia.org/wiki/Xgboost">xgboost</a>, el cuál es muy popular en las competiciones de Kaggle.</p><p>Existen varaciones de estos algoritmos, como por ejemplo <a href="https://es.wikipedia.org/wiki/Tf-idf">TF-idf</a> (term frequency-inverse document frequency, o frecuencia de término — frecuencia inversa de documento), el cuál intenta descubrir que palabras son más importantes para cada tipo de documento.</p><h4>Word2Vec</h4><p><a href="https://arxiv.org/abs/1301.3781">Word2Vev</a> no es un algoritmo para la clasificación de texto, sino un algoritmo para calcular representaciones vectoriales de palabras de conjuntos de datos muy grandes. La peculiaridad de word2vec es que las palabras que comparten un contexto común en el texto son vectores ubicados en el mismo espacio. Por ejemplo, los países estarían cerca el uno del otro en el espacio vectorial. Otra propiedad de este algoritmo es que algunos conceptos están codificados como vectores. Por ejemplo, el género está codificado como un vector de tal manera que la siguiente ecuación es verdadera: “rey — macho + hembra = reina”, el resultado de las operaciones matemáticas es un vector muy cercano a “reina”.</p><p>Usando las representaciones de palabras proporcionadas por Word2Vec, podemos aplicar operaciones matemáticas a las palabras y, por lo tanto, podemos usar algoritmos como <a href="https://arxiv.org/abs/1301.2785v1">Support Vector Machines (SVM)</a> o los algoritmos de aprendizaje profundo que veremos más adelante.</p><p>Hay dos maneras de entrenar un modelo de Word2Vec: <a href="https://arxiv.org/abs/1301.3781">Continuous Bag-of-Words, también conocido como CBOW, y Skip-Gram</a>. Dado el contexto de una palabra, generalmente sus palabras adyacentes, podemos predecir la palabra con el contexto (CBOW) o predecir el contexto con la palabra (Skip-Gram). Ambos algoritmos son similares, pero Skip-Gram parece producir <a href="http://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf">mejores resultados para grandes conjuntos de datos</a>.</p><p>Además del contexto lineal que describimos anteriormente, se puede utilizar otro tipo de contexto como <a href="https://levyomer.files.wordpress.com/2014/04/dependency-based-word-embeddings-acl-2014.pdf">contextos basado en dependencias.</a></p><h4>Doc2Vec</h4><p><a href="https://arxiv.org/abs/1405.4053">Doc2Vector</a> o Paragraph2Vector es una variación de Word2Vec que se puede usar para clasificación de textoa. Este algoritmo intenta corregir la debilidad de los algoritmos tradicionales que no consideran el orden de las palabras y su semántica.</p><p>Este algoritmo es similar a Word2Vec, también aprende las representaciones de vectores de las palabras al mismo tiempo que aprende la representación vectorial del documento. Considera el documento como parte del contexto de las palabras. Una vez que entrenamos el algoritmo, podemos obtener el vector de nuevos documentos haciendo el mismo proceso de entranamiento en estos documentos nuevos pero con las codificaciones de palabras fijadas, de modo que solo aprenda el vector de los documentos. Luego, podemos aplicar un algoritmo de clustering o encontrar el documento más cercano en el conjunto de entranamiento para hacer una predicción.</p><h4>Modelos de Deep Learning</h4><p>Los modelos de Deep Learning se han aplicado con éxito a diferentes problemas relacionados con el texto, como la <a href="https://arxiv.org/abs/1609.08144">traducción de textos</a> o el <a href="https://arxiv.org/abs/1710.03203">análisis de sentimientos</a>. Estos modelos parecen ser capaces de extraer información semántica que no era accesible con otras técnicas.</p><p>Las <a href="https://en.wikipedia.org/wiki/Recurrent_neural_network">redes neuronales recurrentes (RNN)</a> generalmente se utilizan en problemas que requieren <a href="http://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf">transformar una secuencia de entrada en una secuencia de salida </a>o en una distribución de probabilidad (como es la clasificación de textos). Las RNN por lo general usa <a href="http://www.bioinf.jku.at/publications/older/2604.pdf">celdas de memoria a largo plazo (Long Shor Term memory o LSTM)</a> o las <a href="https://arxiv.org/abs/1412.3555">recientes unidades repetidas con compuerta (Gated Recurrent Units o GRU)</a>. Por ejemplo, algunos autores han usado células LSTM en un c<a href="https://arxiv.org/abs/1703.01898">lasificador de texto generativo y discriminativo</a>.</p><p>Las redes neuronales convolucionales (CNN) se usan mucho en la <a href="https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf">clasificación de imágenes</a> debido a sus propiedades para extraer características, pero también se han aplicado al <a href="https://arxiv.org/abs/1703.03091">procesamiento del lenguaje natural (NLP)</a>. Algunos autores los aplicaron a una <a href="http://www.iro.umontreal.ca/~lisa/pointeurs/ir0895-he-2.pdf">secuencia de palabras</a> y otros a una <a href="http://papers.nips.cc/paper/5782-character-level-convolutional-networks-for-text-classification.pdf">secuencia de caracteres</a>. Las CNN también se han usado junto con células LSTM, por ejemplo, en el <a href="https://arxiv.org/abs/1511.08630">modelo C-LSMT para la clasificación de texto</a>.</p><p>CNN no es la única idea tomada desde la clasificación de imágenes. La idea de las <a href="https://arxiv.org/abs/1512.03385">conexiones residuales para la clasificación de imágenes (ResNet)</a> también se ha aplicado a las secuencias en <a href="https://www.aclweb.org/anthology/D16-1093">aprendizaje residual recurrente para la clasificación de secuencias</a>. Las convoluciones separables en profundiad (depthwise separable convolutions) utilizadas en <a href="https://arxiv.org/abs/1610.02357">Xception</a> también se han aplicado en la traducción de texto en <a href="https://arxiv.org/abs/1706.03059">Convoluciones separables de profundidad para la traducción automática neuronal.</a></p><p>Las RNN suelen ser lentas para secuencias largas con tamaños de lotes pequeños, ya que la entrada de una celda depende de la salida de otra, lo que limita su paralelismo. Para resolver este problema, <a href="https://arxiv.org/abs/1611.01576">se crearon redes neuronales cuasi recurrentes (Quasi-Recurrent Neural Networks o QRNN)</a>. Estas alternan capas convolucionales con un agrupamiento recurrente.</p><p>Recientemente, algunos autores han incluido la atención en sus modelos. El mecanismo de atención parece ayudar a la red a enfocarse en las partes importantes y obtener mejores resultados. En <a href="https://arxiv.org/abs/1706.03762">Atención es todo lo que necesitas</a>, los autores utilizan únicamente la atención para realizar la traducción. Otro ejemplo es la red <a href="http://www.aclweb.org/anthology/D/D16/D16-1024.pdf">LSTM basada en la atención para la clasificación de sentimiento interlingüístico</a>.</p><p>Los modelos jerárquicos también se han utilizado para la clasificación de texto, como en <a href="https://arxiv.org/abs/1709.08267">HDLTex: Aprendizaje profundo jerárquico para la clasificación de texto</a> donde HDLTex emplea arquitecturas de aprendizaje profundo jerárquicas para proporcionar una comprensión especializada en cada nivel de la jerarquía de documentos.</p><p>En las <a href="https://www.cs.cmu.edu/~diyiy/docs/naacl16.pdf">redes de atención jerárquica (HAN) para la clasificación de documentos</a>, los autores utilizan el mecanismo de atención junto con una estructura jerárquica basada en palabras y oraciones para clasificar documentos.</p><h3>Conjunto de datos</h3><p>El conjunto de datos se puede encontrar en <a href="https://www.kaggle.com/c/msk-redefining-cancer-treatment/data">https://www.kaggle.com/c/msk-redefining-cancer-treatment/data</a>. Contiene básicamente el texto de un documento, el gen relacionado con la mutación y la variante. Un texto puede tener múltiples genes y variantes, por lo que tendremos que agregar esta información a nuestros modelos de alguna manera.</p><p>Una de las cosas que debemos hacer primero es limpiar el texto. Como es de papers científicos tiene muchas referencias y cosas que no son relevantes para la tarea. Lo segundo que notamos del conjunto de datos es que las variantes parecen seguir algún tipo de patrón. Aunque, podríamos estar equivocados en nuestra suposición sobre el patrón, transformaremos las variaciones en una secuencia de símbolos para permitir que el algoritmo descubra estos patrones en los símbolos, si es que existe. Obtendríamos mejores resultados entendiendo mejor las variantes y cómo codificarlas correctamente.</p><p>Al comienzo de la competencia de Kaggle, el conjunto de datos de prueba contenía 5668 muestras, mientras que el entranamiento solo tenía 3321. La razón era que la mayoría de las muestras de prueba eran falsas para no extraer ninguna información de ellas. Más tarde en la competencia, este conjunto de pruebas se hizo público con sus clases reales y solo contenía 987 muestras. Usaremos el conjunto de datos de prueba de la competición como nuestro conjunto de datos de validación en los experimentos. Cada muestra de entrenamiento se clasifica en una de las 9 clases, que están muy desbalanceadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QSJPf-fELzSi4QHbVu-CIA.png" /></figure><h4>Preprocesado</h4><p>Probablemente, la tarea más importante de esta competición es cómo modelar el texto para aplicar un clasificador. Como no tenemos un conocimiento profundo del dominio, vamos a mantener la transformación de los datos lo más simple posible y permitiremos que el algoritmo de Deep Learning haga todo el trabajo duro por nosotros. Pero, muy probablemente, los resultados mejorarían con un mejor modelo para extraer características del conjunto de datos.</p><p>Hacemos varias cosas para limpiar los datos:</p><ul><li>Eliminar las referencias bibliográficas como “Author et al. 2007” o “[1,2]”. También elminados las referencias a figuras o tablas como “Figure 3A” o “Table 4”.</li><li>Añadimos un espacio alrededor de los símbolos: “.”, “,”, “?”, “(“, “0”, etc.</li><li>Remplazamos los números por símbolos. Si el número es inferior a 0.001 es un símbolo, si esta entre 0.001 y 0.01 es otro símbolo, etc.</li><li>Modificamos todas las variantes que hay en el texto por una secuencia de símbolos, donde cada símbolo es un caracter de la variante (con algunas excepciones).</li></ul><p>Otro enfoque es utilizar una biblioteca como <a href="http://www.nltk.org/">nltk</a>, que maneja la mayoría de los casos para dividir el texto, aunque no eliminará cosas como las referencias típicas a tablas, figuras o documentos.</p><h4>Aumentación de datos</h4><p>Nuestro conjunto de datos es muy limitado para un algoritmo de Deep Learning, solo contamos con 3322 muestras de entrenamiento. Para evitar el sobreajuste necesitamos aumentar el tamaño del conjunto de datos e intentar simplificar el modelo de Deep Learning.</p><p>La mejor forma de aumentar los datos es usar humanos para reformular oraciones, lo cual es un enfoque poco realista en nuestro caso. Otra forma es reemplazar palabras o frases con sus sinónimos, pero estamos en un dominio muy específico donde la mayoría de las palabras clave son términos médicos sin sinónimos, por lo que no vamos a utilizar este enfoque.</p><p>Como tenemos textos muy largos, lo que vamos a hacer es eliminar partes del texto original para crear nuevos ejemplos de entranamiento. Seleccionamos un par o frases aleatorias del texto y las eliminamos para crear el nuevo texto de entranamiento.</p><p>Para mejorar el modelo de Word2Vec y agregar cierta información externa, vamos a usar las definiciones de los genes en la Wikipedia. Nuestra hipótesis es que las fuentes externas deberían contener más información sobre los genes y sus mutaciones que no están en los resúmenes del conjunto de datos. Podríamos agregar más fuentes externas de información que puedan mejorar nuestro modelo de Word2Vec, al igual que otros documentos de investigación relacionados con el tema. Dejamos esto para futuras mejoras fuera del alcance de este artículo.</p><h3>Experimentos</h3><p>Al igual que en la competición, vamos a utilizar la <a href="https://www.kaggle.com/wiki/LogLoss">pérdida logarítmica multi-clase (multi-class logarithmic loss)</a> tanto para el entrenamiento como para la validación.</p><p>Si quisiéramos utilizar alguno de los modelos en la vida real, sería interesante analizar la <a href="https://es.wikipedia.org/wiki/Curva_ROC">curva roc</a> para todas las clases antes de tomar cualquier decisión. En el alcance de este artículo, también analizaremos brevemente la precisión de los modelos.</p><p>A continuación, vamos a ver la configuración de entrenamiento para todos los modelos. Los parámetros se seleccionaron después de algunas pruebas, solo mostramos aquí los que funcionaron mejor al entrenar los modelos.</p><h4>Word2Vec</h4><p>Utilizamos el modelo Word2Vec como la transformación inicial de las palabras en vectores para el resto de los modelos, excepto el modelo Doc2Vec.</p><p>Utilizamos un contexto lineal y un <a href="https://arxiv.org/abs/1301.3781">skip-gram con muestreo negativo</a>, ya que obtiene mejores resultados para conjuntos de datos pequeños con palabras poco frecuentes. El contexto es generado por las 2 palabras adyacentes a la palabra objetivo y 2 palabras aleatorias de un conjunto de palabras que están hasta una distancia 6 de la palabra objetivo. Donde las palabras más infrecuentes tienen más probabilidad de ser incluidas en el contexto establecido. El tamaño del vocabulario es 40000 y el tamaño de los vectores es 300 para todos los modelos. También utilizamos 64 ejemplos negativos para calcular el valor de pérdida.</p><p>Entrenamos el modelo para 2 iteraciones con un tamaño de lote de 128. La tasa de aprendizaje es de 0.01 con un decaimiento de 0.9 cada 100000 pasos.</p><h4>Doc2Vec</h4><p>Usamos una configuración similar a la de Word2Vec para la fase de entrenamiento. Para predecir si el vector de documento pertenece a una u otra clase, utilizamos 3 capas completamente conectadas de tamaños: 600, 300 y 75; con una capa de dropout con una probabilidad de 0.85 para mantener la conexión. Todas las capas usan una función relu como activación excepto la última que usa softmax para las probabilidades finales. Esta red de predicción está entrenada durante 10000 iteraciones con un tamaño de lote de 128. La tasa de aprendizaje es de 0.01 con una decaimiento de 0.95 cada 2000 pasos.</p><h4>GRU — 3 capas</h4><p>El primer modelo RNN que vamos a probar es un modelo RNN básico con 3 capas de 200 celdas GRU cada capa</p><p>Entrenamos el modelo para 10 iteraciones con un tamaño de lote de 24 y una tasa de aprendizaje de 0.001 con un decaimiento de 0.85 cada 1000 pasos. Con estos parámetros, algunos modelos que probamos se sobreajustaron entre las iteraciones 11 y 15. Estos parámetros se usan en el resto de los modelos de Deep Learning.</p><p>Usamos este modelo para probar cómo la duración de las secuencias afecta el rendimiento. Probamos secuencias con las primeras 1000, 2000, 3000, 5000 y 10000 palabras. Tambien queremos comprobar como afecta añadir la última parte del texto, lo que creemos que son las conclusiones del documento. Por lo que también probamos este modelo con las primeras y últimas 3000 palabras.</p><p>El resultado de la red RNN se concatena con los vectores del gen y la variante. Esta capa concatenada es seguida por una capa completamente conectada con 128 neuronas ocultas y activación relu y otra capa completamente conectada con una activación de softmax para la predicción final. En el caso del modelo con las primeras y las última palabras, ambas salidas se concatenan y se usan como entrada para la primera capa completamente conectada junto con el gen y la variante. Esta configuración se usa para todos los modelos de RNN para hacer la predicción final, excepto en los que digamos algo diferente.<br>La combinación de las primeras y las últimas palabras obtuvo los mejores resultados, como veremos a continuación, y fue la configuración utilizada para el resto de los modelos.</p><p>El algoritmo de optimización es RMSprop con los valores predeterminados en TensorFlow para todos los algoritmos siguientes.</p><h4>GRU Bidireccional</h4><p>Este modelo solo contiene dos capas de 200 celdas GRU, una con el orden normal de las palabras y la otra con el orden inverso. Este es un modelo GRU bidireccional con 1 capa.</p><h4>GRU + CNN</h4><p>Este modelo es una capa de CNN con 50 filtros y un tamaño de kernel de 5 que procesa la secuencia antes de alimentar a una RNN de una capa con 200 celdas GRU.</p><h4>HAN</h4><p>Este modelo se basa en el modelo de <a href="https://www.cs.cmu.edu/~diyiy/docs/naacl16.pdf">redes de atención jerárquica (HAN)</a> para la clasificación de documentos, pero hemos reemplazado el vector de contexto por los vetores de la variante y el gen. Esto es, en lugar de aprender el vector de contexto como en el modelo original, proporcionamos la información de contexto que ya tenemos.</p><p>Como este modelo usa el gen y la variación en el vector de contexto de la atención, no usamos la misma capa completamente conectada para hacer las predicciones que en los otros modelos. En su lugar usamos una capa simple completamente conectada con una función de activación de softmax. Para la entrada usamos un máximo de 150 oraciones con 40 palabras por oración (máximo de 6000 palabras), los huecos se rellenan con ceros.</p><h3>Resultados</h3><h4>Resultados de la competición</h4><p>Como punto de referencia aquí, mostramos algunos resultados de algunos competidores que hicieron pública su kernel. Estos son los granos:</p><ul><li><a href="https://www.kaggle.com/reiinakano/basic-nlp-bag-of-words-tf-idf-word2vec-lstm">Bag of Words, TF-IDF, Word2Vec, LSTM</a></li><li><a href="https://www.kaggle.com/the1owl/redefining-treatment-0-57456">XGBoost</a></li></ul><p>Los resultados de esos algoritmos se muestran en la siguiente tabla. En el caso de estos experimentos, el conjunto de validación fue seleccionado del conjunto de entrenamiento inicial.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HOdw1xX5QDmkgF0WAAvQsg.png" /></figure><p>En general, la clasificación pública de la competición muestra mejores resultados que los resutlados de la validación. Esto podría deberse a un sesgo en el conjunto de datos de la clasificación pública. Una distribución diferente de las clases en el conjunto de datos podría explicar este sesgo, pero cuando analizamos este conjunto de datos cuando se publicó, vimos que la distribución de las clases era similar.</p><p>Analizando los algoritmos, el modelo de Deep Learning basado en células LSTM no parece obtener buenos resultados en comparación con los otros algoritmos. Pero como explicó uno de los autores de esos resultados, el modelo LSTM parece tener una distribución en la matriz de confusión mejor en comparación con los otros algoritmos. Concluye que valió la pena seguir analizando el modelo LSTM y usar secuencias más largas para obtener mejores resultados. Veremos más adelante en otros experimentos que las secuencias más largas no condujeron a mejores resultados.</p><h4>Modelos de Deep Learning</h4><p>Primero, quisimos analizar cómo la longitud del texto afectó a la funció de pérdida de los modelos con una simple red GRU de 3 capas con 200 neuronas ocultas por capa. También verificamos si la añadir las conclusionse del texto mejora en algo los resultados. Agregamos los pasos por segundo para comparar la velocidad que los algoritmos entrenados. Usamos 3 GPUs Nvidia k80 para el entrenamiento. Los resultados están en la siguiente tabla:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Kk_Ix-9MbnOxU_6aqAyLQ.png" /></figure><p>Los resultados son muy similares para todos los casos, pero el experimento con menos palabras obtiene mejores valores para la función de perdida, mientras que el experimento con más palabras obtiene la mejor precisión en el conjunto de validación. En todos los casos, el número de pasos por segundo es inversamente proporcional al número de palabras en la entrada. Más palabras requieren más tiempo por paso.</p><p>Para comparar diferentes modelos, decidimos usar el modelo con 3000 palabras que también usaba las últimas palabras. Este es el modelo más grande que cabe en la memoria en nuestras GPU. Estos son los resultados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*KTQMWQpS0W_OTohsf_GTrQ.png" /></figure><p>Parece que el modelo bidireccional y el modelo CNN funcionan de forma muy similar al modelo base. El modelo HAN parece obtener los mejores resultados con un buen valor en la función de perdida y tambíen con un buen valor de precisión, aunque el modelo Doc2Vec supera estos números. El modelo HAN es mucho más rápido que los otros modelos debido al uso de secuencias más cortas para las capas GRU.</p><p>En la siguiente imagen mostramos cómo las vectores de los documentos en doc2vec se mapean en un espacio 3d donde cada clase se representa con un color diferente. No apreciamos una agrupación clara de las clases, independientemente de que fuera el mejor algoritmo en nuestras pruebas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OCEFTQyXiUZ0y1LMT5D-bA.png" /></figure><h4>Cuaderno Jupyter</h4><p>Al igual que en el modelo anterior, pero con una forma diferente de aplicar la atención, creamos un kernel en kaggle para la competición: <a href="https://www.kaggle.com/jorgemf/rnn-gru-bidirectional-attentional-context">RNN + GRU + bidireccional + Contexto atencional</a>. La red se entrenó durante 4 iteraciones con los conjuntos de entrenamiento y validación y envió los resultados a Kaggle. Utilizamos los conjuntos de entrenamiento y validación para aumentar el conjunto de entrenamiento final y obtener mejores resultados. Las 4 iteraciones fueron elegidas porque en experimentos anteriores el modelo estaba sobreajustado después de la 4ª iteración. Obtuvo 0,93 en la clasificación pública y 2,8 en la clasificación privada.</p><p>La matriz de confusión muestra una relación entre las clases 1 y 4 y también entre las clases 2 y 7. Las clases 3, 8 y 9 tienen tan pocos ejemplos en los conjuntos de datos (menos de 100 en el conjunto de entranamiento) que el modelo no logró aprendelos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/306/1*DRjjnYARE0pa5yHOWynnEA.png" /></figure><h3>Discusión</h3><p>Dados los resultados observamos que los modelos de que no son de Deep Learning funcionan mejor. Esto puede ser debido al problema de las RNN a generalizar con secuencias largas y la capacidad de los métodos de que no son de Deep Learning para extraer información más relevante independientemente de la longitud del texto. El modelo jerárquico puede obtener mejores resultados que otros modelos de Deep Learning debido a su estructura en capas jerárquicas que podrían extraer mejor información.</p><p>El número de ejemplos para el entrenamiento no es suficiente para los modelos de Deep Learning y el ruido en los datos podría hacer que los algoritmos se sobreajusten al conjunto de entrenamiento y no extraigan la información correcta entre todo el ruido.</p><h3>Conclusiones</h3><p>La competición de Kaggle tuvo 2 etapas debido a que el conjunto de prueba inicial se hizo público e hizo que la competición fuera irrelevante ya que cualquiera podía enviar las predicciones perfectas. Es por eso que el conjunto de prueba inicial se hizo público y se creó un nuevo conjunto con los documentos publicados durante los últimos 2 meses de la competición. Esto lleva a un conjunto de datos más pequeños para la validación, alrededor de 150 muestras, que deben distribuirse entre la clasificación pública y la clasificación privada. Cuando la tabla de clasificación privada se hizo pública, todos los modelos obtuvieron resultados realmente malos. Casi todos los modelos aumentaron la pérdida alrededor de 1.5–2 puntos. El gran aumento en la pérdida significa dos cosas. En primer lugar, el nuevo conjunto de datos de prueba contenía información nueva que los algoritmos no aprendieron con el conjunto de datos de entranamiento y no pudieron hacer las predicciones correctas. Esto es normal ya que los nuevos artículos intentan enfoques novedosos a los problemas, por lo que es casi completamente imposible para un algoritmo predecir estos enfoques novedosos. En segundo lugar, el conjunto de datos de entranamiento era pequeño y contenía una gran cantidad de texto por ejemplo, por lo que era fácil sobreajustar los modelos.</p><p>Independientemente de que el modelo de aprendizaje profundo muestre peores resultados en el conjunto de validación, el nuevo conjunto de pruebas en la competición probó que la clasificación de textos para documentos científicos es una tarea muy difícil y que incluso buenos modelos con los datos disponibles actualmente podrían ser completamente inútiles con nuevos datos. A medida que la investigación evoluciona, los investigadores toman nuevos enfoques para abordar problemas que no pueden predecirse. Con una muestra más grande de documentos, podríamos crear mejores clasificadores para este tipo de problemas y esto es algo que vale la pena explorar en el futuro. Estos nuevos clasificadores podrían ser capaces de encontrar datos comunes en la investigación que podrían ser útiles, no solo para clasificar trabajos, sino también para liderar nuevos enfoques de investigación.</p><h3>Apéndice: como reproducir los experimentos en TensorPort</h3><p>Este proyecto requiere Python 2 para ser ejecutado.</p><h4>Configuración inicial</h4><p>Instalamos <a href="https://tensorport.com/">TensorPort</a> primero:</p><pre>pip install --upgrade tensorport<br>pip install --upgrade git-lfs <br>tport login</pre><p>Ahora asignamos los directorios del proyecto a variables de entorno. También añadimos otros variables que usaremos más adelante. Modifica los valores por los correctos en tu caso:</p><pre>export PROJECT=kaggle-redefining-cancer-treatment<br>export DATASET=kaggle-redefining-cancer-treatment-data<br>export PROJECT_DIR=/home/jorge/projects/$PROJECT<br>export TPORT_USER=jorgemf</pre><p>Clona el respositorio e instala las dependencias para el projecto:</p><pre>git clone git@github.com:jorgemf/kaggle_redefining_cancer_treatment.git $PROJECT_DIR<br>cd $PROJECT_DIR<br>pip install -r requirements.txt</pre><p>Modifica el repositorio de datos, para ello tienes que modificar la variable DIR_GENERATED_DATA en src/configuration.py. Modifica$TPORT_USER y $DATASET por los valorse usados anteriormente.</p><pre>DIR_GENERATED_DATA = get_data_path(dataset_name=&#39;$TPORT_USER/$DATASET&#39;,<br>                                   local_root=DIR_DATA,<br>                                   local_repo=&#39;generated&#39;)</pre><p>Confirma los cambios:</p><pre>git commit -m &quot;Updated the data repository&quot;</pre><h4>Procesado de datos</h4><pre>mkdir -p $PROJECT_DIR/data/generated</pre><p>Primero necesitas descargar los datos en el directorio$PROJECT_DIR/data , los puedes encontrar en la <a href="https://www.kaggle.com/c/msk-redefining-cancer-treatment/data">página de Kaggle de la competición</a>. Descomprime los datos en el mismo directorio que los has descargado.</p><p>Ahora procesemos los datos y generemos los conjuntos de datos. Esto lleva un tiempo.</p><pre>python -m src.preprocess_data<br>python -m src.w2v.word2vec_process_data<br>python -m src.rnn.text_classification_process_data<br>python -m src.d2v.doc2vec_process_data<br>python -m src.preprocess_data_stage2</pre><h4>Word2Vec</h4><p>Necesitamos los vectores de word2vec para la mayoría de los experimentos. En este caso, lo ejecutamos localmente ya que no requiere demasiados recursos y puede finalizar en un par de horas.</p><pre>python -m src.w2v.word2vec_train</pre><h4>Subir el repositorio y los datos a los servidores de TensorPort</h4><p>Necesitamos subir los datos y el projecto a TensorPort para poderlos usar en la plataforma. Usamos $PROJECT como el nombre del proyecto y $DATASET como nombre del conjunto de datos en TensorPort.</p><pre>tport create project --name $PROJECT<br>git push tensorport master<br>cd data/generated/<br>git init<br>git-lfs track word2vec/* text_classification/*<br>git add .gitattributes word2vec/* text_classification/* <br>git commit -m &quot;update data&quot;<br>tport create dataset --name $DATASET<br>git push tensorport master<br>cd $PROJECT_DIR</pre><p>Tenga en cuenta que no todos los datos se cargan, solo los generados en los pasos anteriores para word2vec y la clasificación de texto. Doc2vec solo se ejecuta localmente en la computadora mientras que los modelos de Deep Learning se ejecutan en TensorPort.</p><h4>Experimentos con 3-capas GRU usando las primeras y últimas palabras</h4><p><strong>Primeras 1000 palabras</strong></p><p>En src/configuration.py modifica los siguientes valores:</p><pre>MAX_WORDS = 1000 <br>USE_END_SEQUENCE = False</pre><p>y confirma los cambios:</p><pre>git commit -m &quot;MAX_WORDS=1000 and USE_END_SEQUENCE=False&quot;<br>git push tensorpot master</pre><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;simple-1000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_simple&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>First 2000 words</strong></p><p>En src/configuration.py modifica los siguientes valores:</p><pre>MAX_WORDS = 2000 <br>USE_END_SEQUENCE = False</pre><p>y confirma los cambios:</p><pre>git commit -m &quot;MAX_WORDS=2000 and USE_END_SEQUENCE=False&quot;<br>git push tensorpot master</pre><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;simple-2000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_simple&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>First 3000 words</strong></p><p>En src/configuration.py modifica los siguientes valores:</p><pre>MAX_WORDS = 3000 <br>USE_END_SEQUENCE = False</pre><p>y confirma los cambios:</p><pre>git commit -m &quot;MAX_WORDS=3000 and USE_END_SEQUENCE=False&quot;<br>git push tensorpot master</pre><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;simple-3000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_simple&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>First 5000 words</strong></p><p>En src/configuration.py modifica los siguientes valores:</p><pre>MAX_WORDS = 5000 <br>USE_END_SEQUENCE = False</pre><p>y confirma los cambios:</p><pre>git commit -m &quot;MAX_WORDS=5000 and USE_END_SEQUENCE=False&quot;<br>git push tensorpot master</pre><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;simple-5000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_simple&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>First 10000 words</strong></p><p>En src/configuration.py modifica los siguientes valores:</p><pre>MAX_WORDS = 10000 <br>USE_END_SEQUENCE = False</pre><p>y confirma los cambios:</p><pre>git commit -m &quot;MAX_WORDS=10000 and USE_END_SEQUENCE=False&quot;<br>git push tensorpot master</pre><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;simple-10000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_simple&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>First 3000 words + Last 3000 words</strong></p><p>En src/configuration.py modifica los siguientes valores:</p><pre>MAX_WORDS = 3000 <br>USE_END_SEQUENCE = True</pre><p>y confirma los cambios:</p><pre>git commit -m &quot;MAX_WORDS=3000 and USE_END_SEQUENCE=True&quot;<br>git push tensorpot master</pre><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;simple-with_end-3000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_simple&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p>Usaremos esta última configuración para el resto de modelos.</p><h4>Experiments with different models</h4><p><strong>Doc2Vec</strong></p><p>Este experimento también lo ejecutamos en local, ya que requiere una cantidad de recusos similar a Word2Vec.</p><p>Primero, generamos los vectors con el conjunto de entranamiento:</p><pre>python -m src.d2v.doc2vec_train_word_embeds</pre><p>Segundo, generamos el modelo para predecir las classes dados los vectores:</p><pre>python -m src.d2v.doc2vec_train_doc_prediction</pre><p>Tercero, generamos los vectors de los documentos para el conjunto de datos de validación:</p><pre>python -m src.d2v.doc2vec_train_eval_word_embeds train_val</pre><p>Finalmente, evaluamos los vectores de los documentos con el modelo de predicción creado en el segundo paso:</p><pre>python -m src.d2v.doc2vec_eval_doc_prediction val</pre><p><strong>Bidirectional GRU</strong></p><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;bidirectional-gru-with_end-3000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_bidirectional&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>CNN + GRU</strong></p><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;cnn-with_end-3000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_cnn&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><p><strong>HAN</strong></p><p>Lanza un proceso en TensorPort. Necesitas selecionar el último commit (número 0). El último proceso worker es usado para la validación del modelo. Puedes comprobar los resultados de la validación en los logs de la plataforma.</p><pre>tport run --name &quot;han-with_end-3000&quot; --project &quot;$TPORT_USER/$PROJECT&quot; --datasets &quot;$TPORT_USER/$DATASET&quot; --package-path &quot;src.rnn&quot; --module &quot;text_classification_model_han&quot; --python-version 2 --tf-version &quot;1.2.0&quot; --requirements &quot;requirements.txt&quot; --distributed --worker-replicas 4 --worker-type &quot;p2.xlarge&quot; --ps-replicas 4 --ps-type &quot;t2.small&quot; --time-limit &quot;24h00m&quot;</pre><blockquote>Este artículo fue publicado originalmente en inglés en <a href="https://medium.com/@jorgemf/personalized-medicine-redefining-cancer-treatment-with-deep-learning-f6c64a366fff">https://medium.com/@jorgemf/personalized-medicine-redefining-cancer-treatment-with-deep-learning-f6c64a366fff</a></blockquote><blockquote>Puedes encontrar el código fuente del projecto en GitHub: <a href="https://github.com/jorgemf/kaggle_redefining_cancer_treatment">https://github.com/jorgemf/kaggle_redefining_cancer_treatment</a></blockquote><blockquote>Nota: este trabajo ha sido soportado economicamente por <a href="http://goodailab.com/">Good AI Lab</a> y todos los modelos han sido entrenados por tu plataforma <a href="https://tensorport.com/">TensorPort</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cc39157f265" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Making your Android app faster]]></title>
            <link>https://medium.com/@jorgemf/making-your-android-app-faster-735328eaba25?source=rss-8c45699c1f1e------2</link>
            <guid isPermaLink="false">https://medium.com/p/735328eaba25</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Jorge MF]]></dc:creator>
            <pubDate>Tue, 08 Nov 2016 22:58:42 GMT</pubDate>
            <atom:updated>2016-11-11T12:20:57.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*ZtvCVj8VxV3AuBQGLZYpMA.png" /></figure><p>During the last years I has been working in different apps and spend some time developing my own app. I learnt a lot about Android and about the user experience. Now it is time to give something in return to the great Android community.</p><p>Users are expecting the apps to be responsive and fast, they never say it but when an app is laggy or takes few seconds to load everybody complains. This post is about technical hints to make your app fast and responsive, and it really pays off in terms of user experience.</p><p>What I am going to describe are not just only ideas, I have applied all of them into my app <a href="https://play.google.com/store/apps/details?id=com.livae.apphunt.app">AppHunt</a>. So you can check what I am talking about instead of believing in what I say.</p><h3>1. Startup time</h3><p>Users are impatient, when they are opening an app they want it to be open even before they click the icon of the app. This time is important because taking a few seconds to start an app only leads to set the user in a bad mood. No one wants a user in a bad mood before using your app.</p><p>The startup time is about initializing your app and load everything you need before start showing data. So basically what you should do is to <strong>load less things in the startup time</strong>.</p><p>There are some libraries that helps you to write less boilerplate code with some syntactic sugar. I am talking mostly about <a href="https://android-arsenal.com/tag/28">dependency injection libraries</a>. They do it so well because they use reflection in order to understand the code and <a href="http://stackoverflow.com/questions/435553/java-reflection-performance"><strong>reflection is really slow</strong></a>. Fortunately, lately most of those libraries are moving to code generation instead of reflection to solve this issue.</p><p>If you are using <a href="https://developer.android.com/guide/topics/providers/content-providers.html"><strong>content providers</strong></a>, the first time a user opens your app those providers <strong>need to be initialized</strong>. The more providers you have and the more complex database creating script you have the more time it is going to take. It is not a big deal as you most probably need them but they add to your startup time.</p><p>Resources also takes time to load. You can <strong>reduce the size of your bitmaps </strong>so they load faster. Also, don’t forget to add all the <a href="https://developer.android.com/guide/practices/screens_support.html">screen densities</a> for your resources, that will save time to Android because it doesn’t have to scale them on the fly.</p><p>It is very common to notify the servers when a user opens the app, synchronize some data with the sever as the user profile or collect data the app will need later. All these things are done in background processes and they usually are initialized in the application class because it is the starting point in every app. The problem with this background jobs is that they will use the network connection and next network requests will be affected. So it is a good idea to <strong>delay a few seconds the initialization of the background processes</strong>, the resources will be free to load the first screen faster.</p><p>No matter what you do, the initialization of the app is going to take some time and you cannot do anything about it. For example, the support libraries are becoming heavier with every version and the activities takes longer to load. It is easy to notice it in old devices. You cannot make things faster but you can make the user feel everything is fast. Although I am not a big fan of <a href="https://material.google.com/patterns/launch-screens.html"><strong>launch screens</strong></a> they help (if they are <a href="https://www.bignerdranch.com/blog/splash-screens-the-right-way/">done correctly</a>). Instead, of showing a white screen you can use the startup time to show your logo and make some branding. This way the user is not seeing a blank square in the mobile but seeing the awesome logo of the app they are about to use.</p><p><em>You write you app once but users are going to open it millions of time, so keep it in mind. Load only what you need to show some data to the user.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*HEBIssl1eZRTZVw12COjTA.gif" /><figcaption>Example of startup time. Launcher screen, background process delayed, initial data loaded fast.</figcaption></figure><h3>2. Loading data</h3><p>Most apps need to load data from a remote serve before they can show anything to the user. This means that after waiting for the app to start now the user has to wait until you make a http request to get the data, parse it and show it. You need this to be really fast.</p><p><em>The faster things are the things you don’t have to do.</em></p><h4>2.1. Cache</h4><p>A cache means that you have the data closer, you don’t need to make a http request because you already have the data. You can use a memory cache which will be cleaned up every time the user starts the app, a persistent cache as the SQLite database in Android or a mix of both. Ideally you will have a mix of both, don’t use only memory because <a href="http://stackoverflow.com/questions/18675557/what-is-the-maximum-amount-of-ram-an-app-can-use">there are mobiles that do not have a lot of memory</a> and heavy users fill it very quickly and they start facing out of memory errors, which are a pain.</p><p>When the user opens the app you may want to show the data you already had in your SQLite database. But this solution has other problems. First, the data is probably going to be outdated and it is very likely the user has seen it before. Users like fresh content, otherwise they are unhappy. Second, after showing this old data the user may start to scroll or interact with it and you are going to interrupt his actions changing all the data in a blink. This is bad, really bad. Some apps, like Digg, do this and it is very frustrating. Don’t do it.</p><p>It is a good idea to <strong>load data that the user may need later in advance</strong>. For example, if the app is showing a list of items you can assume the user is going to click in some of those items because he wants to see more about them. So when you make a http requests to get a list of items, you can store more information about those items and not just what the list shows. When the user goes to the detailed view of the image you should first load the data you have cached before, then make the http request for the additional data you need and finally update the view with the all the data. A more concrete example: you show a feed with items like Facebook, the user clicks in an element and you fill the detailed view with the data you already had and then make a http request to get the comments of that item. As the comments are usually at the bottom of the screen they probably will be loaded before the user even look at them.</p><p>Another common case where <strong>you can load the data in advance are the notifications</strong>. If a user receive a notification you can assume he is going to click on it. When the app receives a notification, before showing it to the user, you can make the http requests you need to load all the data related with the notification. When the user clicks in the notification the data will be in the cache already, ready to be displayed.</p><p>If your app is going to use images from the network, then you need to use a library like <a href="http://square.github.io/picasso/">picasso</a> or <a href="https://github.com/bumptech/glide">glide</a>. They do caching and work pretty well.</p><p>A typical case for cache is when the user rotates the device and the activity is recreated. You probably don’t need to make the http request again, you can load the data from the cache. Some developers like to use a retained fragment, a singleton or other ways of memory cache. But Android has already a <strong>loader manager</strong> which handles the lifecycle of activity and fragments. It requires more code as you have to create data providers, but it is usually a good idea to use providers for data anyway. <a href="https://medium.com/google-developers/making-loading-data-on-android-lifecycle-aware-897e12760832#.7ekniw15r">Android loaders are the best way to load data</a>.</p><p>Finally, and not less important, <strong>don’t forget the cache in the server side</strong>. If the data you are showing the the users in the first screen is the same for all of them you definitely need a cache in the server for this data. Without going in a lot of details, usually in the server side is a good idea to sacrifice a bit of freshness in the data in exchange of speed. You can cache the requests for 5 minutes and assume the data wont change in those 5 minutes, or invalidate the cache when you know it changes.</p><p>There is a technique that I haven’t used but it is a good idea for caching between the servers and the app: <strong>the entity tags</strong> or <a href="https://en.wikipedia.org/wiki/HTTP_ETag">etags</a>. An etag is basically a fingerprint of the data. When you make a request to the server it returns the data and the etag. Next time you make the same request to the server you send the etag. The server will compare the etag you have sent with the last etag of the data you are requesting, if both etags are the same it means the data hasn’t changed. As you already have the data in the cache of the app the server doesn’t have to send anything and you can display the data to the user faster. If the etags are different the server sends back the new data and the new etag.</p><h4>2.2. Network requests</h4><p>Cache is mostly related with the networks requests, so when you have a miss in the cache you want the request to be fast. In the case of http requests you must assume the worst conditions, which usually are the opposite of what you see when you are testing your app to your local server. Don’t spend all your development time faking a 2G connection, but try it from time to time to get a feeling of what a user may experience. There are a lot of Android users in India with slow connections and you don’t want to lose such a huge growing market.</p><p>In general <strong>the less data you request the better</strong>. It is going to take less time for the server to retrieve the data from the database, less time to process it, less time using the network and less time to parse it in the app. Obviously less data per request means more requests to get the data, so you have to find a good balance between small requests and less requests. For example, the web page of Facebook loads one item of your feed very quickly and them loads more items. As the first item takes a big space in your screen you feel it is fast. I suggest you to do something similar for your app, try to load chunks of data that fill the screen and not more, then load the rest of the data in other requests.</p><p>In addition to the previous example, if you are showing a feed you can <strong>start making the request for the next page of data before you reach the last item</strong> of data in the list. Users usually scroll slowly while they read the content so a couple of items before the last one in your list you can start making the requests to load the next page and append the next data to the list. If the requests are fast it feels like a real infinite scrolling for the user.</p><p>I am assuming most network request for the data are http requests against a REST API. <a href="https://http2.github.io/faq/">There are important differences between http1 and http2</a>. In case of apps you should know that <strong>http2 allows you to reuse connections</strong> and keep them alive longer. Reusing http connections is a really important if your requests are small as you can reuse TCP connections and avoid the overhead of starting the connection. I recommend you to to use use <a href="http://square.github.io/okhttp/">okhttp3</a> and take a look to its documentation as it supports http2 as protocol.</p><p>If images are part of your app they are probably going to be your bigger network requests. So try to compress them with <a href="https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/image-optimization#selecting_the_right_image_format">web friendly formats</a> (jpg, png, webp, etc) and <strong>don’t request full size images</strong>. The screen resolutions of phones are very dense, you probably wont need the same resolution for the image and users wont notice you are displaying images with less resolution.</p><p>If you are in control of the REST API for the app there are a lot of things you can do here too. I think it is very important to <strong>keep your endpoints simple and fast</strong>. The API should do a lot of things, just get the data and serve it to the app. One thing you can do to same some bandwidth is to send only the data the app will need and no more, you can <strong>removed fields of your objects not relevant for the request</strong>. You can also avoid to send the same object twice in the same http requests. For example, if you are requesting a feed of items and per every item you add the user related, it is probably you are going to add the same user to different items in the same request. You can only send the first one and the id of the user in the rest of items. Then in your app, if you are using a content provider, a sql to load the data it is very easy to get the data in the format you want.</p><p>If your app is a bit complex you probably have user authentication and you server will have to check the user to create a response. For example, the request could be to like an item in the feed, the server needs to know who is the user performing the action. If you send the user id in the requests then you have a security hole, a malicious user can create those requests and fake likes. You can fix this by storing a session id for the user that only the user and the server knows, so other users cannot like content in his name. But a session id means that the server has to make a call to the database to get the user id in order to save the like. You are adding some overhead to improve the security of your API. One way to solved this is using <a href="https://jwt.io/introduction/"><strong>signed tokens</strong></a>. Instead of storing in the app the session id you store the signed token, which contains the information you may need per requests as the user id or the user profile. The token is signed by the server, so instead of making a call to the database the server only needs to verify the signature of the token and get the data it needs from it. You have security in your app without a lot of overhead. Bearing in mind that you probably need this for a lot of requests, they will save you a lot of time at the end.</p><h4>2.3. Parse the data</h4><p>Once you have made the http request you have the data in raw format in the http response body and you need to parse it before doing anything with it. Probably after parsing it you need to save it in you cache, in memory or in the sql database, and finally you can bind it to your layout.</p><p>Ideally you would only have the deal with the data the user is going to see. If you are <strong>processing data the user is not going to see in the screen then you are wasting resources and making the user to wait longer</strong>. That is why small requests, with the required fields and without repeated content make the process of parsing data faster.</p><p>After parsing the http response you could bind it directly to the layouts but as the cache it is very important you need to store in it first. If you are using the SQLite database as the cache you better do <strong>bulk inserts</strong>. A bulk insert means all the rows you insert in the database are treated as a single sql transaction. If you insert the rows one by one you are going to have a big overhead because every row is going to be a sql transaction.</p><p>I am going to make a small break here, because storing the data in the SQLite database is slower than binding it directly in the layout. But there are some advantage of storing the data in the SQLite database: you can use cursors which are memory friendly (good for endless lists), you can perform relational algebra to request your data (for example joining two tables, the feed and the users) and you can user content loaders.</p><p>Once the data is in the database you need to tell to the activity that it needs to update the data. You should do this in the same thread that made the http requests. Try to avoid broadcasts intents as they are usually slow and add a great delay.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*GHrdrIcyYjyFMnKKJS1Bxw.gif" /><figcaption>Example of endless list. Data is loaded in pages of 10 items, 3 items before the next page starts.</figcaption></figure><h3>3. Layouts</h3><p>The network request has finished and now the data is ready to be displayed. Now the layouts are in charge of keeping with a good user experience. Binding the data to the layouts should be a straight forward process, the problems here lies on the time the interface spends rendering the layouts. You want it to be small to keep at least 30 fps all the time. If views stay still the user wont notice the rendering issues, but he will do if the content scrolls, like in endless lists.</p><p>The best layouts are the <a href="https://developer.android.com/training/custom-views/index.html"><strong>custom views</strong></a> you can create to show your data in a very efficient way. But custom views means more time of development and more time to maintain or modify them. When creating your layouts try to keep them simple and <strong>avoid nesting views</strong>. A nested view means those pixels are going to be painted again, you can end up easily painting the same pixels 4 or 5 times and decreasing the frame rate.</p><p><em>Android has a lot of tools to measure the frame rate and the overdraw for the nested views, use them.</em></p><h3>4. Animations</h3><p>Using animations for speed and responsiveness is a bit counter intuitive. If your goal is to make the app fast why would you add animations? The response is simple, <strong>your app doesn’t only have to be fast it has to feel it is fast</strong> and not laggy, and animations are a good way for this. For example, it is better to show a loading indicator moving when you are doing a network requests that showing an still indicator. The user will sense something is happening and he has to wait a little, if he doesn’t see movement he is going to think the app is laggy and it can be a frustrating experience.</p><p>Animations also help to <strong>mask network requests in </strong><a href="https://developer.android.com/training/material/animations.html#Transitions"><strong>activity transitions</strong></a>. If you use a share element transition you can start the http requests when the activity is created while the animation is still running. Don’t make the animations longer than 300 milliseconds or the user will get tired of them after some time seeing them. Use those milliseconds to introduce the activity and to get the data you need, and don’t forget a loading indicator in case the http requests takes longer than the animation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*tDNBM_EphDrVOzqth5pWmQ.gif" /><figcaption>Example of activity enter transition. Comments are loaded when the animation starts.</figcaption></figure><h3>5. Ads</h3><p>The monetization is the only way to make apps survive in the long term. So you also have to pay special attention to them, without any type of revenue the development of the app will stop. But without users to click on those ads they worth nothing. Users are more important than ads, and so <strong>showing the data is more important than showing ads</strong>.</p><p>The data always has to be loaded before the ads, but it is a good idea to start the request to get the ads just after starting the request to get the data. Even if you are not going to show the ad immediately you can have it in cache to show it when appropriate. If you are using native ads embedded in the content, as in the middle of a list, you can hide the view of the ad and make it visible when you have the data to fill the view. In this case nothing will be show if the ad requests fails, or if the user leaves the activity first. You should also be carefull with ads in the the middle of a list as the views are recycled and the users scroll fast. It is better to show the same ad than to load new ads when the user scroll because every new ad is a new http requests and the app can reach a point where is making so many http requests for ads that other requests have to wait.</p><p>Try to cache ads and don’t wait until you need them to make the http requets. If an ad takes few seconds more to load than the data users might left the activity before the ad is even visible. And <strong>if the users don’t see the ads they hardly are going to click on them</strong>.</p><h3>Summary</h3><ol><li>Startup time<br>- load less things in the startup<br>- reflection is really slow<br>- providers need to be initialized, be aware<br>- reduce the size of your bitmaps<br>- delay a few seconds background processes for synchronization with the server<br>- use launch screens</li><li>Loading data<br>2.1. Cache<br>- load data that the user may need later in advance<br>- use the loader manager<br>- don’t forget the cache in the server side<br>- etags<br>2.2. Network requets<br>- the less data you request the better<br>- start making the request for the next page of data before you reach the last item<br>- http2<br>- don’t request full size images<br>- keep your endpoints simple and fast<br>- removed fields of your objects not relevant for the request<br>- use signed tokens for user authentication<br>2.3. Parse data<br>- processing data the user is not going to see in the screen then you are wasting resources and making the user wait longer<br>- bulk inserts</li><li>Layouts<br>- custom views<br>- avoid nesting views<br>- use the android tools for the frame rate and overdraw</li><li>Animations<br>- your app doesn’t only have to be fast it has to feel it is fast<br>- mask networks requests with activity transitions</li><li>Ads<br>- data is more important than ads<br>- load the ads before needed if possible<br>- if the users don’t see the ads they hardly are going to click on them</li></ol><p><em>I will appreciate any comment to improve this post or suggestion to write a new one. Contact me in apphunt@livae.com</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/80/1*b_llUhZMExhETlM9aAi6Ww.png" /></figure><p><strong><em>If you are a developer you may consider to share your app in </em></strong><a href="https://play.google.com/store/apps/details?id=com.livae.apphunt.app"><strong><em>AppHunt</em></strong></a><strong><em>.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=735328eaba25" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>