Temática
Big Data
Tiempo de lectura
3 minutos
¿Qué es el Big Data?
Aplicaciones
Formación
Salidas profesionales
El futuro del Big Data
El Big Data es uno de los temas más relevantes en el ámbito tecnológico en la actualidad. Este término se refiere a la gran cantidad de datos que se generan a diario y que son analizados para extraer información valiosa, mediante el uso de tecnologías que permiten su gestión y análisis de forma masiva. Los datos provienen de diversas fuentes, como las redes sociales, los dispositivos móviles, los sensores, entre otros. La capacidad de procesar y analizar esta información, en muchos casos en tiempo real, es lo que hace que el Big Data sea tan importante actualmente.
En este artículo Alejandro Vaca (Data Scientist en Instituto de Ingeniería del Conocimiento (IIC)) nos va a hablar sobre la importancia del Big Data y su recorrido hasta el día de hoy.
El impacto del Big Data en nuestras vidas es innegable. Muchas de las aplicaciones que utilizamos en nuestro día a día, desde redes sociales hasta aplicaciones de transporte o compras en línea, se basan en el análisis de grandes cantidades de datos para personalizar su oferta y mejorar la experiencia del usuario. Por ejemplo, cuando utilizamos una aplicación de transporte, el Big Data se utiliza para analizar las rutas más eficientes y predecir el tiempo de llegada con precisión.
Otro ejemplo es el sector de la salud, donde el análisis de datos masivos permite a los profesionales médicos personalizar los tratamientos y las intervenciones para cada paciente, lo que se traduce en mejores resultados y una mayor eficacia. También es posible detectar patrones y tendencias en el comportamiento de los pacientes, lo que puede ayudar a prevenir enfermedades y mejorar la atención médica.
Formarse en el ámbito del Big Data es fundamental para poder aprovechar al máximo su potencial. Actualmente existen numerosos cursos, grados, diplomas y programas de postgrado enfocados en el análisis de datos masivos, lo que permite a los profesionales adquirir habilidades y conocimientos específicos para trabajar en este campo. Es importante mencionar que el Big Data no sólo requiere habilidades técnicas, sino también habilidades de análisis y pensamiento crítico para poder extraer información valiosa de los datos. Un centro de excelencia en este sentido es Datahack, un centro de formación especializado en el ámbito del Big Data y el Data Science.
El campo del Big Data ofrece múltiples salidas profesionales, ya que es una herramienta fundamental en diversos ámbitos, como la salud, el comercio electrónico, la seguridad, la educación, entre otros. En el comercio electrónico, el Big Data se utiliza para analizar el comportamiento de los consumidores y personalizar las recomendaciones de productos y servicios. En la seguridad, el Big Data se utiliza para analizar grandes cantidades de información de seguridad y predecir posibles amenazas y riesgos. En la educación, el Big Data se utiliza para analizar los resultados de los estudiantes y personalizar la enseñanza para adaptarse a las necesidades de cada uno.
La importancia del Big Data continuará creciendo en el futuro próximo. Cada vez se generan más datos y se espera que en los próximos años se produzca un aumento exponencial en la cantidad de información que se recopila. Además, la capacidad de analizar y procesar grandes cantidades de datos se está volviendo cada vez más importante en el mundo empresarial y gubernamental. Por lo tanto, es fundamental que los profesionales se formen en el campo del Big Data, pues el impacto y la presencia de estas tecnologías en la vida de las personas irá en aumento.
En conclusión, el Big Data es un tema de gran relevancia en la actualidad y su importancia continuará creciendo en el futuro. Formarse en este ámbito ofrece numerosas oportunidades profesionales y permite aprovechar al máximo su potencial para mejorar diversas áreas de la sociedad. Además, el Big Data tiene un impacto directo en nuestras vidas y en la forma en que interactuamos con el mundo que nos rodea. Desde las aplicaciones móviles hasta la atención médica personalizada, el análisis de grandes cantidades de datos nos permite tomar mejores decisiones y mejorar nuestra calidad de vida.
Alejandro Vaca (Data Scientist en Instituto de Ingeniería del Conocimiento (IIC))
Atrévete a formarte con nuestro Máster Experto en Data Science y Big Data
Una formación 100% online y adaptada a ti para que te conviertas en un especialista en Inteligencia de Negocio
¡Si te ha gustado el contenido de este artículo no te olvides de suscribirte a la newsletter!
Qué mejor forma para celebrar el #díadelamujer, que juntar a tres profesionales del sector para que nos hablen de la importancia de las mujeres en el ámbito tecnológico.
No pierdas la oportunidad de escuchar testimonios de profesionales ¡Seguro que te inspiran! La mujer un dato por descubrir Acompáñanos en este #webinargratuito y aprendamos de experiencias y casos reales de mujeres en este sector. Este webinar se realizará en formato mesa redonda, donde las ponentes hablaran en base a una serie de temas y responderán preguntas.
En este evento se resumirá en:
No dejes escapar esta oportunidad e infórmate junto a verdaderos profesionales del Big Data.
Lourdes Hernández Vozmediano
CEO datahack
Cristabel Talavera
Customer Engineer en Google
Rus María Mesas Jávega
Data scientist en Telefónica
¡Anímate y escucha testimonios de grandes profesionales!
¿Qué tienes que hacer para asistir a este #webinargratuito? Muy sencillo. Únicamente tendrás que registrarte desde este evento y esperar al día 7 de marzo (se realizará desde LinkedIn Live por lo que se deberá acceder a la plataforma de LinkedIn a la hora del evento).
🔵 Esta sesión será online en directo y desde la plataforma de LinkedIn Live.
🔵 Este formulario es para apuntarte a la sesión online.
🔵 Durante la sesión podrás preguntar todas las dudas que tengas al ponente y las irá respondiendo. No te quedes con ninguna duda.
🔵 Al registrarte recibirás un enlace en tu email con el que podrás conectarte a la sesión online.
La teoría de grafos busca representar de forma visual conjuntos de datos abstractos en formas de nodos o vértices y la unión o relaciones que estas pueden tener con otros nodos a través de aristas.
Comprende desde cero la Teoría de grafos aplicada a un caso real "El caso de Twitter"
Gracias a esta teoría se puede aprovechar al máximo el potencial de las redes sociales. Así comprender las relaciones, preferencias y similitudes entre los usuarios, todo esto lo podrá aprender de la mano de Rafa Ibáñez Usach (Senior Product Expert - Indra)
En el ejercicio práctico podremos analizar una red de una red social, en este caso, Twitter. Obtendremos datos de #Twitter y los analizaremos con una herramienta de análisis de grafos midiendo la relación entre los distintos usuarios de Twitter.
En este evento se resumirá en:
No dejes escapar esta oportunidad e infórmate junto a verdaderos profesionales del Big Data.
Rafa Ibáñez Usach
Senior Product Expert - Indra
¡Anímate y realiza este caso práctico para desarrollar tus capacidades en Excel!
¿Qué tienes que hacer para asistir a este #webinargratuito? Muy sencillo. Únicamente tendrás que registrarte desde este evento y esperar al día 22de febrero (se realizará desde LinkedIn Live por lo que se deberá acceder a la plataforma de LinkedIn a la hora del evento).
🔵 Esta sesión será online en directo y desde la plataforma de LinkedIn Live.
🔵 Este formulario es para apuntarte a la sesión online.
🔵 Durante la sesión podrás preguntar todas las dudas que tengas al ponente y las irá respondiendo. No te quedes con ninguna duda.
🔵 Al registrarte recibirás un enlace en tu email con el que podrás conectarte a la sesión online.
¡Ser un dummy en 2023 no es tendencia! Deja de serlo con nuestro webinar gratuito: Google Colab para dummies
Da tus primeros pasos en Google Colab Google Colab para dummies
Google Colab es una plataforma de código abierto para escribir y ejecutar Python desde nuestro navegador en lugar de necesitar software específico. Tanto si lo anterior te resulta familiar como si no, este evento es para ti.
Angel Conde Manjon Senior Partner Solutions Architect – Data & Analytics en Amazon Web Services (AWS) se encargará de explicar desde cero la plataforma, así podrás comprender cómo funciona y como aplicarla a casos reales.
En este evento se resumirá en:
No dejes escapar esta oportunidad e infórmate junto a verdaderos profesionales del Big Data.
Angel Conde Manjon
Senior Partner Solutions Architect – Data & Analytics en Amazon Web Services (AWS)
¡Anímate y realiza este caso práctico para desarrollar tus capacidades en Excel!
¿Qué tienes que hacer para asistir a este #webinargratuito? Muy sencillo. Únicamente tendrás que registrarte desde este evento y esperar al día 31 de enero (se realizará desde LinkedIn Live por lo que se deberá acceder a la plataforma de LinkedIn a la hora del evento).
🔵 Esta sesión será online en directo y desde la plataforma de LinkedIn Live.
🔵 Este formulario es para apuntarte a la sesión online.
🔵 Durante la sesión podrás preguntar todas las dudas que tengas al ponente y las irá respondiendo. No te quedes con ninguna duda.
🔵 Al registrarte recibirás un enlace en tu email con el que podrás conectarte a la sesión online.
En este artículo creado por Pablo Sainz de Vicuña, profesor de visualización de datos en el master de Big Data &Analytics de datahack, conoceremos de su propia mano la herramienta Tableau:
Tableau es una herramienta de visualización de datos líder del mercado que se caracteriza por su fácil aprendizaje, es muy sencillo comenzar a extraer información con ella y representar los datos de forma eficiente. Además permite jugar con los datos de origen pudiendo crear tus propios campos calculados, dicho código también resulta bastante sencillo de codificar y de aprender
Me gustaría compartir un proyecto que realicé cuando comencé a trabajar con Tableau que me dio la oportunidad de combinar dos de mis aficiones, el Golf y la Visualización de datos. Seguro que todos habéis oído hablar de un torneo de Golf en el que el premio es una chaqueta verde, pues bien, este torneo es el más prestigioso del mundo y se llama Masters de Augusta.
Mi idea consistía en crear un cuadro de mando que nos permitiese explorar la clasificación así como los jugadores, los hoyos y los golpes realizados. Una idea ambiciosa por dos grandes motivos, primero, mi desconocimiento de la herramienta, la había utilizado en el master y poco más, y segundo, de donde sacaría los datos.
El primero de los problemas se podía solventar a base de trabajo, investigación y perseverancia, el segundo…es más complicado, estuve buscando bases de datos pero nunca encontré nada que se asemejara a los que buscaba por lo que si quería llevar a cabo mi proyecto tendría que conseguir los datos por mí mismo. Para ello podía ponerme a escribir los datos a mano, algo imposible e ineficiente, o podía utilizar una de las técnicas que aprendí durante el master, web scrapping, esta técnica consiste en sacar la información de una página web aprovechando el código HTML de la misma.
Visité la página oficial del torneo y comprobé que podía extraer toda la información de ella, por ejemplo, la siguiente imagen muestra la clasificación:
Y su código es el siguiente:
Podemos ver que esta página tiene una estructura que podemos aprovechar y llegar al dato que necesitamos, si nos fijamos en la línea sombreada en azul aparece el nombre del jugador en la segunda línea de la clasificación, así como sus valores en las líneas siguientes.
Localizada la fuente de datos ahora tocaba empezar a trabajar, no soy ningún experto en la programación pero si algo había aprendido durante el master de datahack era a investigar. Encontré una librería que nunca había utilizado de web scrapping llamada “Selenium” y comencé a hacer pruebas en un notebook de jupyter utilizando python como lenguaje. Pronto empecé a ver resultados satisfactorios ya que obtuve mucha información rápidamente.
Este es es script que utilicé para obtener los jugadores:
En él se puede ver que primero buscaba el listado de jugadores para después recorrer este listado con cada jugador y obtener sus datos (Player ID, Nombre, Altura, Peso, Edad, Pais, Descripción y Mejor resultado).
También aprovechamos la web para descargar las imágenes de los jugadores y de los hoyos para poder utilizarlas en nuestro cuadro de mando.
Más sencillo resultó el script para extraer la información de los hoyos:
Para cada hoyo obtenemos su Número, Nombre, Par (golpes con los que se debería hacer el hoyo), Distancia y Descripción.
Por último faltaba obtener cada golpe realizado por cada jugador, este script requirió más trabajo ya que el código resultaba más complejo, su tiempo de ejecución era muy elevado y afinarlo fue bastante tedioso, pero finalmente logré el dataset que buscaba:
De cada golpe obtuve el PlayerID, Ronda, Golpe, Distancia, Unidad de distancia, Distancia al hoyo, Unidad de distancia al hoyo, X, Y, X Origen, Y Origen. ¡Ya tenía todo lo necesario para representarlo en Tableau!
Lo primero al entrar en Tableau es crear la fuente de datos, en este caso resultó bastante sencilla debida a la labor previa que hicimos con la extracción en Python.
Simplemente unimos la tabla principal Golpes con Jugadores y Hoyos.
Utilizando la función de pivotar en la fuente de datos conseguimos juntar los puntos X e Y de origen y destino en una misma medida pudiéndolos diferenciar mediante una dimensión Origen/Destino. Esto iba a resultar imprescindible para el gráfico principal del dashboard, el shottracker.
SHOT TRACKER
La construcción del gráfico principal resultó bastante compleja, una vez resuelto el problema de unificar el origen y destino de las coordenadas en la fuente la construcción del gráfico no resulta demasiado compleja.
La hoja está compuesta por un gráfico de puntos y un gráfico de líneas en eje doble con la ronda en color, el tiro en texto, el jugador y el hoyo en detalle.
Lo que faltaba era conseguir cambiar la imagen del hoyo dinámicamente en función de la selección realizada. Para ello encontré una solución que consistía en editar las imágenes en segundo plano del el menú de Mapa.
Una vez dentro se creaban todas las imágenes una a una incluyendo un filtro personalizado en el que seleccionábamos el hoyo correspondiente.
Conseguir esta hoja me llevó una enorme labor de investigación para replicar todos los efectos deseados.
CLASIFICACIÓN
A simple vista no parece una gráfica muy compleja. Es un mapa de calor que cuenta los golpes por ronda de cada jugador. La dificultad vino de conseguir que ese cálculo fuese correcto, en esa etapa no sabía manejar las expresiones en nivel de detalle que ofrece Tableau, estas expresiones son parecido a subconsultas que se pueden hacer a la fuente de datos original para fijar el valor en una dimensión. Son unos de los conceptos más complejos de Tableau y comprenderlos lleva su tiempo, pero necesitaba utilizarlos así que tocaba de nuevo investigar y probar hasta conseguir el resultado deseado, finalmente lo conseguí con un campo calculado que a día de hoy tardaría segundos en hacer pero que en aquel momento me pudo llevar un par de días de prueba y error.
Para conseguir el color también necesite otros campos calculados:
PANEL DE JUGADOR SELECCIONADO
En función del jugador que se selecciona en el panel de clasificación cambia el panel del jugador con su nombre y su foto.
Este efecto requiere un trabajo bastante laborioso por detrás, primero hay que tener todas las imágenes guardadas en una carpeta dentro de la siguiente ruta:
C:\Users\My_User\Documents\Mi Repositorio de Tableau\Formas
Al reiniciar Tableau veremos que si creamos un gráfico de formas nos ofrece las que están dentro de la carpeta recién creada. Después hay que asignar manualmente cada foto a cada jugador.
Crear la gráfica es sencillo ya que únicamente requiere incluir los jugadores en Forma y mediante una acción de filtro en el dashboard conseguimos ver únicamente el jugador seleccionado.
En el tooltip del jugador podemos ver otros cálculos interesantes como la máxima distancia del drive y su promedio.
El número de greenes cogidos, se considera el número de golpes que se deberían dar para llegar al Green, en un par 4 serían dos golpes; para calcular esto nos basamos en las unidades que nos ofrece el dataset:
Si el golpe tiene una distancia en yardas es un golpe desde fuera de Green, mientras que si están en pies o pulgadas es un Putt.
Siguiendo esta lógica también se calcula el número de putts por ronda realizados. Una vez construidas las hojas monté todo en el dashboard de incluí las acciones de filtro necesarias para que todo respondiese correctamente.
Creo que lo más interesante de este proyecto es lo mucho que aprendí de Tableau partiendo desde cero, buscando ejemplos que me sirviesen a mi dashboard, utilizando fórmulas que nunca había realizado, queriendo crear gráficas que no sabía hacer, y pudiendo juntar dos de mis pasiones todo se hace más fácil.
Pablo Sainz de Vicuña Data Analyst Senior en Inetum • Profesor Visualización en datahack school •
¡Si te ha gustado el contenido de este artículo no te olvides de suscribirte a la newsletter!
En este artículo creado por José Manuel Sanz Candales , vamos a conocer qué es el DLR.
Los gestores de las redes eléctricas de transporte y distribución deben tener en cuenta los valores de capacidad de sus líneas eléctricas para cumplir con las normas establecidas al respecto. Tradicionalmente se han utilizado valores constantes estacionales, pero el avance de la tecnología está haciendo evolucionar estos valores hacia el cálculo dinámico de la capacidad de las líneas (DLR).
El DLR (Dynamic Line Rating) se basa en la estimación en tiempo real de la capacidad de las líneas de transporte de energía eléctrica (CdT), en función de distintas variables medibles (condiciones climáticas, medidas de temperatura del conductor en tiempo real, flecha del vano, etc.) así como su previsión para períodos futuros. En contraposición se encuentra el uso de una CdT estacional, con variables climatológicas fijas en cada estación, que, por lo general, resulta más conservadora, y que es la que se ha venido utilizando de manera generalizada en la actualidad.
Simplificadamente, hacer DLR consiste en predecir o calcular la intensidad máxima que puede transportar una línea en un periodo de tiempo determinado, atendiendo al valor de ciertas variables ambientales instantáneas, respetando en todo momento los límites térmicos de la instalación, y, en consecuencia, garantizando las distancias de seguridad establecidas en los reglamentos, sin provocar en la instalación ni una degradación ni un envejecimiento prematuro, al ser siempre las condiciones de funcionamiento coherentes con límites técnicos, como puede ser el fenómeno de recocido en los materiales.
La CdT de una línea aérea vendrá marcada por el vano (tramo entre dos apoyos consecutivos) que primero incumpla los límites mencionados anteriormente. En consecuencia, operar líneas con DLR significa estimar y monitorizar las condiciones de la línea a lo largo de todo su trazado, realizar un tratamiento de la información para determinar la intensidad máxima admisible en cada instante, así como establecer modelos de previsión que permitan predecir los valores estimados de capacidad de transporte para las próximas horas u otros horizontes de más largo plazo.
Para disponer de una predicción de capacidad de transporte, es necesario disponer de predicciones de variables medioambientales. De estas variables, la que más impacto tiene por su variabilidad e influencia es el viento. Obtener previsiones de viento con precisión suficiente es complejo y la Inteligencia Artificial puede ser de gran ayuda en este ámbito. Adicionalmente, dado que el viento es uno de los mayores problemas de la red de transporte en cuanto a averías graves por caída de torres y conductores, una estimación precisa y con antelación suficiente, ayudará también tanto en la optimización del diseño de apoyos como para predecir posibles afecciones por cambio en condiciones ambientales o de comportamiento de las supuestas en históricos.
Para entrenar estos modelos de IA, se requiere disponer de datos históricos de estaciones meteorológicas que recojan los valores reales en determinados puntos de las líneas eléctricas. Adicionalmente, la recepción de los datos de dichas estaciones meteorológicas en tiempo real (mediante uso de IoT) en los sistemas de predicción, permite utilizarlas para realizar predicciones más precisas en los primeros horizontes (< 6 horas) utilizando, por ejemplo, Redes Neuronales Recurrentes.
Jose Manuel Sanz Candales
Científico de Datos - Departamento de Modelos para la Operación del Sistema en Red Eléctrica
¡Si te ha gustado el contenido de este artículo no te olvides de suscribirte a la newsletter!
¿Sabéis lo que darían los Reyes Magos o Papa Noel por ordenar todas las listas de regalos en una hoja Excel? ¡Tú puedes!, no pierdas la oportunidad y ordena todas tus compras de la mano del mejor aliado, el análisis de datos.
¡En este nuevo webinar te ayudamos con tus compras de navidad! ¿Cuánto de vas a gastar esta navidad?
Excel nos ayuda a extraer información a partir de grandes cantidades de datos, por ello a través de esta herramienta racionalizaremos nuestro presupuesto disponible para optimizar nuestras compras.
¿Empleas demasiado tiempo en Amazon buscando la opción más económica para una lista de productos? Hugo Hernández (Consultor de Data Mining en datahack) nos mostrará a partir de un Dataset las distintas combinaciones de artículos de Amazon de acuerdo a nuestro presupuesto.
En este evento se resumirá en:
Ponencia de Hugo Hernández
Ponencia de Hugo Hernández
No dejes escapar esta oportunidad e infórmate junto a verdaderos profesionales del Big Data.
Hugo Hernández
Consultor de Data Mining en datahack
¡Anímate y realiza este caso práctico para desarrollar tus capacidades en Excel!
¿Qué tienes que hacer para asistir a este #webinargratuito? Muy sencillo. Únicamente tendrás que registrarte desde este evento y esperar al día 15 de diciembre (se realizará desde LinkedIn Live por lo que se deberá acceder a la plataforma de LinkedIn a la hora del evento).
🔵 Esta sesión será online en directo y desde la plataforma de LinkedIn Live.
🔵 Este formulario es para apuntarte a la sesión online.
🔵 Durante la sesión podrás preguntar todas las dudas que tengas al ponente y las irá respondiendo. No te quedes con ninguna duda.
🔵 Al registrarte recibirás un enlace en tu email con el que podrás conectarte a la sesión online.
Los datos nunca se quedan quietos, al igual que la red de aviones que sobrepasan nuestras cabezas todos los días en infinidad de momentos. Las personas siempre intentamos encontrar las mejores soluciones a nuestros problemas o necesidades, pero ¿Sabíais que el análisis de datos es nuestro mejor aliado en estas ocasiones?
¡En este nuevo webinar te lo demostramos! ¿Quieres saber cómo viaja un Data Scientist?
El análisis de datos tiene infinitas aplicaciones, en este webinar podremos aprender una de ellas, cómo optimizar las búsquedas de vuelos directos mediante Python.
¿Te has pasado horas buscando las mejores combinaciones de vuelos para llegar a tu destino? Jorge López Lázaro (Senior-Expert Data Scientist en BBVA) se encargará de explicar mediante este caso de uso, cómo solucionar estos problemas con Python.
En este evento se resumirá en:
Ponencia de Jorge López Lázaro
Ponencia de Jorge López Lázaro
No dejes escapar esta oportunidad e infórmate junto a verdaderos profesionales del Big Data.
Jorge López Lázaro
Senior-Expert Data Scientist en BBVA
¡Anímate y realiza este caso práctico para desarrollar tus capacidades en Python!
¿Qué tienes que hacer para asistir a este #webinargratuito? Muy sencillo. Únicamente tendrás que registrarte desde este evento y esperar al día 29 (se realizará desde LinkedIn Live por lo que se deberá acceder a la plataforma de LinkedIn a la hora del evento).
🔵 Esta sesión será online en directo y desde la plataforma de LinkedIn Live.
🔵 Este formulario es para apuntarte a la sesión online.
🔵 Durante la sesión podrás preguntar todas las dudas que tengas al ponente y las irá respondiendo. No te quedes con ninguna duda.
🔵 Al registrarte recibirás un enlace en tu email con el que podrás conectarte a la sesión online.
En este artículo creado por Rafael Garrote Hernández, vamos a conocer más a fondo el Snowflake.
El ecosistema de almacenes de datos está en continuo crecimiento y cada poco oímos de un nuevo miembro de la familia. En este caso quiero hablaros de Snowflake, que recoge la tradición de las bases de datos específicas para crear un data Warehouse y la actualiza para adecuarse a los tiempos que imperan, haciéndola nativa al cloud, con capacidades para gestionar grandes volúmenes de datos y con capacidades de procesamiento en streaming.
Snowflake, como su propio nombre indica, es una base de datos pensada para albergar los modelos de datos dimensionales tradicionales de un data warehouse, copo de nieve, data mart, pero además permite adecuarse a las necesidades para crear modelos más actuales como data vaults o data hubs. Sus principales características son que está diseñada para trabajar de forma nativa en los principales proveedores de infraestructura y que separa la capa de almacenamiento de datos de la capa de procesamiento de datos. Son precisamente estas dos características las que hacen que Snowflake pueda gestionar volúmenes de datos mucho más grandes que sus predecesoras. Vamos a ver sus características más en detalle.
Arquitectura
Snowflake está diseñada en una arquitectura con tres capas; la capa de almacenamiento que se encarga de persistir el dato y gestionar las micro particiones, una capa de procesamiento de datos independiente al resto organizada en clusters aislados de máquinas que trabajan sobre el conjunto de datos y por último la capa de servicios cloud entre los que encontramos la autorización, la gestión de la infraestructura, gestión de metadatos, control de accesos, seguridad y parseo y optimización de consultas.
Almacenamiento de datos
Como capa de almacenamiento Snowflake utiliza el sistema de almacenamiento del proveedor de infraestructura, AWS S3, Azure Blob Storage y Google Cloud Storage respectivamente. De esta manera, podemos utilizar estos almacenamientos como capa de staging desde la que cargar los datos de forma sencilla en Snowflake.
Permite almacenar tanto datos estructurados como semiestructurados y con soporte nativo para formatos abiertos de datos: JSON, XML, CSV, Avro, Parquet, ORC, etc.
El almacenamiento está orientado a columnas lo que la hace idónea para ejecutar trabajos de tipo analítico tradicionales de un data warehouse y además permite particionado de las tablas.
Y por último es transaccional y ACID, dos características muy valiosas y que no encontramos en todos los competidores.
Micro Particionado
Snowflake basa su almacenamiento en lo que él denomina micro particiones que gestiona de forma automática y transparente para el usuario. Las tablas se particionan de forma transparente utilizando el orden de carga o inserción de los datos creando particiones de 50 a 500 MB.
Para esas consultas que necesitan más rendimiento o para gestionar volúmenes de datos más grandes, Snowflake nos permite modificar el comportamiento por defecto del micro particionado y gestionar estas particiones para optimizar las consultas sobre conjuntos de datos más grandes especificando la clave de particionado con la cláusula CLUSTER BY tanto al crear la tabla como al modificarla. De esta manera podremos indicar qué campo o campos queremos utilizar como clave de particionado para crear unas particiones acordes al patrón de acceso al dato optimizando por tanto el rendimiento de las consultas.
Time travel
El almacenamiento de datos de Snowflake permite indicar un tiempo de retención a los datos entre 1 y 90 días, de tal forma que se puede consultar el estado de los datos en un punto anterior en el tiempo, por ejemplo, antes de que hayan sido modificados o borrados. También permite clonar o recuperar tablas en un punto en concreto en el pasado, incluso si se han borrado.
Adicionalmente al tiempo de retención del time travel, se le puede indicar a Snowflake un tiempo adicional de como máximo 7 días, en los que guardará los datos de las tablas para poder recuperarse de fallos eventuales. Estos datos sólo son recuperables por Snowflake y no se pueden consultar hasta su recuperación. Este tiempo de fail-safe empieza a contar justo después de que termine el tiempo de retención del time travel.
Capa de computación
Como se ha indicado antes, la capa de procesamiento está separada de la capa de almacenamiento y consta de uno o varios clusters de máquinas encargados de realizar las tareas de cómputo sobre los datos. Estos clusters se denominan Virtual Warehouses y podemos crear tantos como necesitemos. Idealmente crearemos uno por tipología de procesos que realicemos sobre los datos. Por ejemplo podemos tener un Virtual Warehouse para realizar las tareas de ETL y otro para los procesos de ciencia de datos. De esta manera garantizamos los recursos necesarios para cada uno de estos procesos ya que los Virtual Warehouses no comparten recursos entre sí.
Estos clusters se pueden configurar para que crezcan o decrezcan de forma elástica según la demanda de carga en cada momento y además se pueden auto suspender y reiniciar según las necesidades para hacer una correcta gestión de los recursos y del coste de la infraestructura.
Snowflake no sólo está pensada para ejecutar sentencias de consulta, sino que al igual que sus predecesoras, permite realizar procesos de Extracción Carga y Transformación (ELT) para realizar las transformaciones de los datos e integrarlos en el modelo dimensional creado. Para ello permite encadenar las sentencias para ejecutarlas en un orden específico y bajo ciertas condiciones.
Cada sentencia SQL es una tarea o task y estas task se pueden encadenar formando un árbol de ejecución. Este árbol representa el pipeline de ejecución de una ELT. Una Task se puede programar para ser ejecutada de forma periódica o como consecuencia de una Task anterior. Esto que permite encadenar Task en función del resultado anterior en lo que se denomina Tasks condicionales.
Adquisición o ingesta de datos
Para ingestar datos en Snowflake, esta hace uso del almacenamiento de datos nativo del cloud, así por ejemplo en AWS S3, dejaríamos los ficheros con el dato en bruto a ingestar en un bucket de S3. Indicaremos a snowflake que use ese bucket como staging, creamos la tabla que alojará estos datos y le decimos a Snowflake que copie los datos del staging a la tabla. Una vez que los datos ya están en Snowflake podemos crear los pipelines necesarios para transformar e integrar el dato según nuestras necesidades.
Además de este procesamiento de datos por lotes o en batch, Snowflake provee de un mecanismo para la ingesta de datos en streaming y/o tiempo real que denomina Snowpipe.
Snowpipe permite quedarse escuchando un fichero de la capa de almacenamiento de la infraestructura, por ejemplo AWS S3 y cada nueva inserción en este fichero, automáticamente se insertarla en la tabla de destino. Otra opción es utilizar el conector de Kafka que permite conectar Snowflake a Kafka para consumir los mensajes que se vayan almacenando en los topics de Kafka.
Junto con estos mecanismos de ingesta en streaming, Snowflake dispone de un conjunto de operaciones de ventana para poder realizar operaciones de transformación y cálculo en streaming.
A parte de todas estas funcionalidades Snowflake provee las siguientes capacidades:
Por todo lo que hemos visto en este artículo Snowflake moderniza los sistemas de bases de datos tradicionales para data Warehouses, actualizándose a las necesidades actuales del mercado convirtiéndose en una tendencia al alza sobre todo si se busca una alternativa que te independice del proveedor de infraestructura considerándola una alternativa a tener en cuenta a la hora de diseñar nuestro sistema informacional.
¡Si te ha gustado el contenido de este artículo no te olvides de suscribirte a la newsletter!
En este artículo creado por Héctor Escaso Gil, vamos a crear una red neuronal que nos sirva de clasificador de imágenes para algunas de las razas que habitan la tierra media.
Vamos a crear un dataset de imágenes de 5 razas del universo Tolkien: Orcos, Elfos, Enanos, Hobbits y Magos.
El principal problema que tenemos, es que contamos con un reducido número de imágenes, unas 200 de cada raza. Para solucionar esto, vamos a utilizar dos técnicas:
Transfer Learning -> Entrenar con tan pocas imágenes es un problema, ya que el modelo tiene pocos ejemplos para su aprendizaje, por lo que utilizaremos la red neuronal preentrenada “mobilenet_2”. Eliminaremos la capa de salida e incluiremos una nueva que se adapte a nuestro modelo.
Data Augmentation -> Aunque contemos con una red preentrenada muy potente, necesitamos entrenar la última capa. Así que utilizaremos esta técnica con la generaremos un mayor número de imágenes para nuestro entrenamiento.
Una vex hayamos entrenado nuestro modelo haremos algunas predicciones usando imágenes de prueba.
Comencemos con el ejercicio
1. Creación del dataset
Para crear nuestro dataset, vamos a buscar las imágenes directamente en google. Haremos una búsqueda por cada una de las razas y nos descargaremos todas las imágenes fácilmente con la extensión de Chrome Download All Images.
Tras esto limpiaremos nuestras imágenes, eliminando duplicados y borrando las que no nos sirvan para nuestro entrenamientos. Yo he seleccionado exactamente 200 por cada raza.
2. Descarga y preparación de los datos
Os dejo las imágenes que he utilizado en mi repositorio.
Tengo las imágenes en el drive, así que permito acceder a mis archivos desde colab.
from google.colab import drive
drive.mount('/content/drive')Mounted at /content/driveTras esto, entro en cada carpeta y descomprimo los archivos zip
!unzip /content/drive/MyDrive/ClasificadorImagenes/Elfos.zip
!unzip /content/drive/MyDrive/ClasificadorImagenes/Enanos.zip
!unzip /content/drive/MyDrive/ClasificadorImagenes/Magos.zip
!unzip /content/drive/MyDrive/ClasificadorImagenes/Orcos.zip
!unzip /content/drive/MyDrive/ClasificadorImagenes/Hobbits.zipRevisamos que la descarga haya sido correcta, mostrando el número de imágenes en cada carpeta.
#Mostrar cuantas imagenes tengo de cada categoria
!ls /content/Elfos | wc -l
!ls /content/Magos | wc -l
!ls /content/Orcos | wc -l
!ls /content/Hobbits | wc -l
!ls /content/Enanos | wc -l 200
200
200
200
200Una vez comprobado que la descarga ha sido correcta, elimino la conexión con drive.
drive.flush_and_unmount()Vamos a ver alguna imágenes a ver qué pinta tienen.
# Utilizaremos pyplot
import os
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
plt.figure(figsize=(15,15))
carpeta = '/content/Hobbits'
imagenes = os.listdir(carpeta)
for i, nombreimg in enumerate(imagenes[:25]):
plt.subplot(5,5,i+1)
imagen = mpimg.imread(carpeta + '/' + nombreimg)
plt.imshow(imagen)
Instalamos 2 librerías que vamos a necesitar.
!pip install split-folders
!pip install pytest-shutilVamos a utilizar la librería splitfolders para separar nuestras imágenes en train, test y validación. Esta librería coge todas las carpetas que haya y crea 3 carpetas nuevas por cada una de ellas con la proporción de imágenes que le indiquemos.
Como tenemos la carpeta “sample_data” que se genera automáticamente y no la necesitamos, la vamos a eliminar previamente.
import shutil
shutil.rmtree('/content/sample_data') # Eliminamos la carpeta sample_dataTras esto, hacemos la división de las imágenes entre train, validation y test.
import splitfolders
splitfolders.ratio('/content', output = "dataset", ratio=(0.78, 0.2, 0.02)) # Haremos copia de la imágenes y las dividiremos en 3 carpetas dentro de "dataset".Copying files: 1003 files [00:00, 5322.86 files/s]Comprobamos una carpeta para ver que se haya realizado correctamente.
!ls /content/dataset/train/Elfos | wc -l
!ls /content/dataset/val/Elfos | wc -l
!ls /content/dataset/test/Elfos | wc -l 156
40
4Se ha creado un archivo .config en cada una de las carpetas. Los eliminamos porque sino aparecerían como una clase más e interferiría en el entrenamiento.
!rm -rf /content/dataset/train/.config
!rm -rf /content/dataset/val/.config
!rm -rf /content/dataset/test/.config3. Data Augmentation
Está técnica se basa en la creación de nuevas imágenes partiendo de los datos antiguos con los que contamos. En este caso haciendo zoom de las imágenes, reescalandolas, realizando un flip horizontal, etc…
Vamos a utilizar ImageDataGenerator para crear nuestros generadores de imágenes para los sets de entrenamiento y validación, aunque en la validación lo único que haremos será reescalar las imágenes.
#Aumento de datos con ImageDataGenerator
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import numpy as np
#Crear el dataset generador
train_datagen = ImageDataGenerator(
rescale=1. / 255,
rotation_range = 30,
width_shift_range = 0.25,
height_shift_range = 0.25,
shear_range = 15,
zoom_range = [0.5, 1.5],
#validation_split = 0.2 -> En este caso no modificamos las imágenes de validación.
)
validation_datagen = ImageDataGenerator(rescale=1. / 255)
#Generadores para sets de entrenamiento y pruebas
data_gen_train = train_datagen.flow_from_directory('/content/dataset/train', target_size=(224,224),
batch_size=32, shuffle=True)
data_gen_val = validation_datagen.flow_from_directory('/content/dataset/val', target_size=(224,224),
batch_size=32, shuffle=True)
Found 780 images belonging to 5 classes.
Found 200 images belonging to 5 classes.Vamos a imprimir unas imágenes aleatorias para ver como funciona nuestro generador.
#Imprimir 10 imagenes del generador de entrenamiento
for imagen, etiqueta in data_gen_train:
for i in range(10):
plt.subplot(2,5,i+1)
plt.xticks([])
plt.yticks([])
plt.imshow(imagen[i])
break
plt.show()
4. Creación del modelo
Lo primero que vamos a hacer es buscar en tensorflow hub la red mobilenet_2. En este caso nos facilitan las cosas y tenemos la red ya empaquetada pero sin la capa de salida. Es el modo “feature_vector”.
La descargamos
import tensorflow as tf
import tensorflow_hub as hub
url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4"
mobilenetv2 = hub.KerasLayer(url, input_shape=(224,224,3))Para no desaprovechar el entrenamiento que se ha realizado con esta red, congelamos todas las capas entrenadas.
mobilenetv2.trainable = FalseCreamos nuestro modelo con la red que nos hemos descargado añadiendo una capa densa de salida, de 5 neuronas, con activación softmax que es la que se suele utilizar en los casos de clasificación.
modelo = tf.keras.Sequential([
mobilenetv2,
tf.keras.layers.Dense(5, activation='softmax')
])Vemos el resumen del modelo que hemos creado.
modelo.summary()Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
keras_layer (KerasLayer) (None, 1280) 2257984
dense (Dense) (None, 5) 6405
=================================================================
Total params: 2,264,389
Trainable params: 6,405
Non-trainable params: 2,257,984
_________________________________________________________________Compilamos nuestro modelo. Utilizamos el optimizador adam, para la función de pérdida seleccionamos categorical_crossentropy y por último como métrica accuracy.
modelo.compile(
optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy']
)Antes de entrenar nuestro modelo definimos un par de callbacks para intentar afinar nuestro modelo.
Incluimos EarlyStopping para que al pasar más de 8 epochs sin que la función de pérdida disminuya, el entrenamiento se detenga. También incluimos ReduceLROPlateau para que modifique la tasa de aprendizaje pero en este caso en 4 epochs.
from keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint, Callback
early_stop = EarlyStopping(monitor='val_loss', patience=8, verbose=1, min_delta=1e-4)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=4, verbose=1, min_delta=1e-4)
callbacks_list = [early_stop, reduce_lr] Entrenamos nuestro modelo durante 50 épocas.
#Entrenar el modelo
EPOCAS = 50
historial = modelo.fit(
data_gen_train,
epochs= EPOCAS,
batch_size= 32,
validation_data= data_gen_val,
callbacks= callbacks_list
)Epoch 1/50
25/25 [==============================] - 29s 553ms/step - loss: 1.6465 - accuracy: 0.3064 - val_loss: 1.2034 - val_accuracy: 0.4800 - lr: 0.0010
Epoch 2/50
25/25 [==============================] - 13s 517ms/step - loss: 1.2504 - accuracy: 0.4962 - val_loss: 0.9545 - val_accuracy: 0.6400 - lr: 0.0010
Epoch 3/50
25/25 [==============================] - 13s 518ms/step - loss: 1.0655 - accuracy: 0.5564 - val_loss: 0.8287 - val_accuracy: 0.6900 - lr: 0.0010
Epoch 4/50
25/25 [==============================] - 16s 654ms/step - loss: 0.9625 - accuracy: 0.6333 - val_loss: 0.7622 - val_accuracy: 0.7300 - lr: 0.0010
Epoch 5/50
25/25 [==============================] - 13s 521ms/step - loss: 0.8724 - accuracy: 0.6641 - val_loss: 0.7374 - val_accuracy: 0.7200 - lr: 0.0010
Epoch 6/50
25/25 [==============================] - 13s 517ms/step - loss: 0.8747 - accuracy: 0.6474 - val_loss: 0.6525 - val_accuracy: 0.7600 - lr: 0.0010
Epoch 7/50
25/25 [==============================] - 13s 515ms/step - loss: 0.8304 - accuracy: 0.6603 - val_loss: 0.6433 - val_accuracy: 0.7600 - lr: 0.0010
Epoch 8/50
25/25 [==============================] - 13s 525ms/step - loss: 0.7791 - accuracy: 0.7192 - val_loss: 0.6277 - val_accuracy: 0.7800 - lr: 0.0010
Epoch 9/50
25/25 [==============================] - 13s 529ms/step - loss: 0.7142 - accuracy: 0.7500 - val_loss: 0.6079 - val_accuracy: 0.7850 - lr: 0.0010
Epoch 10/50
25/25 [==============================] - 13s 518ms/step - loss: 0.6840 - accuracy: 0.7321 - val_loss: 0.6077 - val_accuracy: 0.7550 - lr: 0.0010
Epoch 11/50
25/25 [==============================] - 13s 513ms/step - loss: 0.7069 - accuracy: 0.7282 - val_loss: 0.5746 - val_accuracy: 0.7950 - lr: 0.0010
Epoch 12/50
25/25 [==============================] - 13s 523ms/step - loss: 0.6649 - accuracy: 0.7500 - val_loss: 0.5767 - val_accuracy: 0.8000 - lr: 0.0010
Epoch 13/50
25/25 [==============================] - 13s 521ms/step - loss: 0.6841 - accuracy: 0.7474 - val_loss: 0.5574 - val_accuracy: 0.7850 - lr: 0.0010
Epoch 14/50
25/25 [==============================] - 13s 519ms/step - loss: 0.6286 - accuracy: 0.7705 - val_loss: 0.5336 - val_accuracy: 0.8000 - lr: 0.0010
Epoch 15/50
25/25 [==============================] - 13s 519ms/step - loss: 0.6390 - accuracy: 0.7628 - val_loss: 0.5323 - val_accuracy: 0.8100 - lr: 0.0010
Epoch 16/50
25/25 [==============================] - 13s 517ms/step - loss: 0.6009 - accuracy: 0.7833 - val_loss: 0.5202 - val_accuracy: 0.8050 - lr: 0.0010
Epoch 17/50
25/25 [==============================] - 13s 520ms/step - loss: 0.6138 - accuracy: 0.7718 - val_loss: 0.5191 - val_accuracy: 0.8000 - lr: 0.0010
Epoch 18/50
25/25 [==============================] - 13s 521ms/step - loss: 0.6067 - accuracy: 0.7833 - val_loss: 0.5235 - val_accuracy: 0.8250 - lr: 0.0010
Epoch 19/50
25/25 [==============================] - 13s 520ms/step - loss: 0.5915 - accuracy: 0.7821 - val_loss: 0.5250 - val_accuracy: 0.8250 - lr: 0.0010
Epoch 20/50
25/25 [==============================] - 13s 518ms/step - loss: 0.5729 - accuracy: 0.7987 - val_loss: 0.5177 - val_accuracy: 0.8000 - lr: 0.0010
Epoch 21/50
25/25 [==============================] - 13s 517ms/step - loss: 0.5508 - accuracy: 0.7962 - val_loss: 0.5142 - val_accuracy: 0.8000 - lr: 0.0010
Epoch 22/50
25/25 [==============================] - 13s 527ms/step - loss: 0.5802 - accuracy: 0.7885 - val_loss: 0.5322 - val_accuracy: 0.8000 - lr: 0.0010
Epoch 23/50
25/25 [==============================] - 13s 513ms/step - loss: 0.5815 - accuracy: 0.7974 - val_loss: 0.5090 - val_accuracy: 0.8050 - lr: 0.0010
Epoch 24/50
25/25 [==============================] - 15s 614ms/step - loss: 0.5397 - accuracy: 0.8064 - val_loss: 0.5141 - val_accuracy: 0.8200 - lr: 0.0010
Epoch 25/50
25/25 [==============================] - 13s 531ms/step - loss: 0.5252 - accuracy: 0.8103 - val_loss: 0.5360 - val_accuracy: 0.8150 - lr: 0.0010
Epoch 26/50
25/25 [==============================] - 13s 524ms/step - loss: 0.5526 - accuracy: 0.7910 - val_loss: 0.4965 - val_accuracy: 0.8250 - lr: 0.0010
Epoch 27/50
25/25 [==============================] - 13s 517ms/step - loss: 0.5777 - accuracy: 0.7756 - val_loss: 0.4837 - val_accuracy: 0.8150 - lr: 0.0010
Epoch 28/50
25/25 [==============================] - 13s 521ms/step - loss: 0.5323 - accuracy: 0.8000 - val_loss: 0.5096 - val_accuracy: 0.8150 - lr: 0.0010
Epoch 29/50
25/25 [==============================] - 13s 516ms/step - loss: 0.5434 - accuracy: 0.7923 - val_loss: 0.5274 - val_accuracy: 0.8100 - lr: 0.0010
Epoch 30/50
25/25 [==============================] - 13s 512ms/step - loss: 0.5127 - accuracy: 0.8141 - val_loss: 0.5095 - val_accuracy: 0.8250 - lr: 0.0010
Epoch 31/50
25/25 [==============================] - ETA: 0s - loss: 0.4902 - accuracy: 0.8269
Epoch 31: ReduceLROnPlateau reducing learning rate to 0.00010000000474974513.
25/25 [==============================] - 13s 517ms/step - loss: 0.4902 - accuracy: 0.8269 - val_loss: 0.5002 - val_accuracy: 0.8400 - lr: 0.0010
Epoch 32/50
25/25 [==============================] - 13s 516ms/step - loss: 0.4964 - accuracy: 0.8167 - val_loss: 0.4903 - val_accuracy: 0.8500 - lr: 1.0000e-04
Epoch 33/50
25/25 [==============================] - 13s 508ms/step - loss: 0.4725 - accuracy: 0.8333 - val_loss: 0.4877 - val_accuracy: 0.8250 - lr: 1.0000e-04
Epoch 34/50
25/25 [==============================] - 13s 507ms/step - loss: 0.4926 - accuracy: 0.8385 - val_loss: 0.4862 - val_accuracy: 0.8400 - lr: 1.0000e-04
Epoch 35/50
25/25 [==============================] - ETA: 0s - loss: 0.4591 - accuracy: 0.8269
Epoch 35: ReduceLROnPlateau reducing learning rate to 1.0000000474974514e-05.
25/25 [==============================] - 13s 515ms/step - loss: 0.4591 - accuracy: 0.8269 - val_loss: 0.4869 - val_accuracy: 0.8300 - lr: 1.0000e-04
Epoch 35: early stoppingParece que tras 35 épocas la función de pérdida no disminuye, por lo que el entramiento se detiene.
Vamos a ver gráficamente como se han comportado la función de pérdida y el accuracy con datos de entrenamiento y validación.
#Graficas de precisión
acc = historial.history['accuracy']
val_acc = historial.history['val_accuracy']
loss = historial.history['loss']
val_loss = historial.history['val_loss']
rango_epocas = range(35)
plt.figure(figsize=(8,8))
plt.subplot(1,2,1)
plt.ylim(0, 1)
plt.plot(rango_epocas, acc, label='Precisión Entrenamiento')
plt.plot(rango_epocas, val_acc, label='Precisión Pruebas')
plt.legend(loc='lower right')
plt.title('Precisión de entrenamiento y pruebas')
plt.subplot(1,2,2)
plt.ylim(0, 1)
plt.plot(rango_epocas, loss, label='Pérdida de entrenamiento')
plt.plot(rango_epocas, val_loss, label='Pérdida de pruebas')
plt.legend(loc='upper right')
plt.title('Pérdida de entrenamiento y pruebas')
plt.show()
Podemos ver que el modelo se comporta correctamente, llegando a una accuracy de 0.85 con los datos de validación. El modelo nos puede servir.
5. Predicciones
Lo primero que vamos a ver es la etiqueta que se ha asignado a cada una de las razas.
data_gen_train.class_indices{'Elfos': 0, 'Enanos': 1, 'Hobbits': 2, 'Magos': 3, 'Orcos': 4}from PIL import Image
import cv2
dicc= data_gen_train.class_indices
for raza in list(dicc.keys()):
test = '/content/dataset/test/' + raza + '/'
lista = os.listdir('/content/dataset/test/'+ raza + '/')
for img in lista:
plt.imshow(mpimg.imread(test + img))
img = Image.open(test + str(img))
img = np.array(img).astype(float)/255
img = cv2.resize(img, (224,224))
prediccion = modelo.predict(img.reshape(-1, 224, 224, 3))
print("La imagen es de " + raza + " y el modelo predice: ", list(dicc.keys())[list(dicc.values()).index(np.argmax(prediccion[0], axis=-1))])
plt.show()1/1 [==============================] - 1s 720ms/step
La imagen es de Elfos y el modelo predice: Magos
1/1 [==============================] - 0s 19ms/step
La imagen es de Elfos y el modelo predice: Hobbits
1/1 [==============================] - 0s 19ms/step
La imagen es de Elfos y el modelo predice: Elfos
1/1 [==============================] - 0s 20ms/step
La imagen es de Elfos y el modelo predice: Elfos
1/1 [==============================] - 0s 19ms/step
La imagen es de Enanos y el modelo predice: Enanos
1/1 [==============================] - 0s 20ms/step
La imagen es de Enanos y el modelo predice: Enanos
1/1 [==============================] - 0s 20ms/step
La imagen es de Enanos y el modelo predice: Elfos
1/1 [==============================] - 0s 19ms/step
La imagen es de Enanos y el modelo predice: Enanos
1/1 [==============================] - 0s 19ms/step
La imagen es de Hobbits y el modelo predice: Hobbits
1/1 [==============================] - 0s 20ms/step
La imagen es de Hobbits y el modelo predice: Hobbits
1/1 [==============================] - 0s 20ms/step
La imagen es de Hobbits y el modelo predice: Hobbits
1/1 [==============================] - 0s 21ms/step
La imagen es de Hobbits y el modelo predice: Hobbits
1/1 [==============================] - 0s 25ms/step
La imagen es de Magos y el modelo predice: Enanos
1/1 [==============================] - 0s 23ms/step
La imagen es de Magos y el modelo predice: Magos
1/1 [==============================] - 0s 22ms/step
La imagen es de Magos y el modelo predice: Magos
1/1 [==============================] - 0s 22ms/step
La imagen es de Magos y el modelo predice: Magos
1/1 [==============================] - 0s 21ms/step
La imagen es de Orcos y el modelo predice: Orcos
1/1 [==============================] - 0s 22ms/step
La imagen es de Orcos y el modelo predice: Orcos
1/1 [==============================] - 0s 21ms/step
La imagen es de Orcos y el modelo predice: Orcos
1/1 [==============================] - 0s 24ms/step
La imagen es de Orcos y el modelo predice: Orcos
Vemos que las predicciones son bastante acertadas.
Ahora vamos a jugar un poco más con nuestro modelo, y vamos a realizar predicciones con imágenes completamente distintas del dataset original.
Así en cada raza tenemos:
Descargamos las imágenes de drive.
from google.colab import drive
drive.mount('/content/drive')!unzip /content/drive/MyDrive/ClasificadorImagenes/Predict.zipArchive: /content/drive/MyDrive/ClasificadorImagenes/Predict.zip
inflating: Predict/Elfo.jpg
inflating: Predict/Enano.jpg
inflating: Predict/hobbit.jpg
inflating: Predict/mago.jpg
inflating: Predict/orco.jpg Realizamos las predicciones, a ver si nuestro modelo es capaz de identificarlas.
test = '/content/Predict/'
lista = os.listdir('/content/Predict/')
for img in lista:
plt.imshow(mpimg.imread(test + img))
img = Image.open(test + str(img))
img = np.array(img).astype(float)/255
img = cv2.resize(img, (224,224))
prediccion = modelo.predict(img.reshape(-1, 224, 224, 3))
print("El modelo predice:", list(dicc.keys())[list(dicc.values()).index(np.argmax(prediccion[0], axis=-1))])
plt.show()1/1 [==============================] - 0s 21ms/step
El modelo predice: Orcos
1/1 [==============================] - 0s 19ms/step
El modelo predice: Enanos
1/1 [==============================] - 0s 28ms/step
El modelo predice: Hobbits
1/1 [==============================] - 0s 21ms/step
El modelo predice: Hobbits
1/1 [==============================] - 0s 19ms/step
El modelo predice: Magos
Hemos tenido un buen resultado, solo ha fallado al identificar al Elfo, quizás un duende de navidad se asemeja más a un hobbit.
Por último, vamos a ver en qué raza me ubica el modelo.
plt.imshow(mpimg.imread('/content/drive/MyDrive/foto_hector.jfif'))
img = Image.open('/content/drive/MyDrive/foto_hector.jfif')
img = np.array(img).astype(float)/255
img = cv2.resize(img, (224,224))
prediccion = modelo.predict(img.reshape(-1, 224, 224, 3))
print("El modelo predice:", list(dicc.keys())[list(dicc.values()).index(np.argmax(prediccion[0], axis=-1))])
plt.show()
1/1 [==============================] - 0s 43ms/step
El modelo predice: Hobbits6. Guardar el modelo
Creamos la carpeta para poder exportarla a donde queramos.
!mkdir -p carpeta_salida/modelo_razasGuardamos el modelo.
modelo.save('carpeta_salida/modelo_razas')Hacemos un zip de la carpeta para poder transportarlo.
!zip -r modelo_razas.zip /content/carpeta_salida/modelo_razas/ adding: content/carpeta_salida/modelo_razas/ (stored 0%)
adding: content/carpeta_salida/modelo_razas/saved_model.pb (deflated 92%)
adding: content/carpeta_salida/modelo_razas/variables/ (stored 0%)
adding: content/carpeta_salida/modelo_razas/variables/variables.data-00000-of-00001 (deflated 8%)
adding: content/carpeta_salida/modelo_razas/variables/variables.index (deflated 78%)
adding: content/carpeta_salida/modelo_razas/keras_metadata.pb (deflated 81%)
adding: content/carpeta_salida/modelo_razas/assets/ (stored 0%)Este sería el final del proyecto, espero haya explicado bien las distintas técnicas empleadas.
¡Si te ha gustado el contenido de este artículo no te olvides de suscribirte a la newsletter!