
Este curso está formado por los vídeos de la lista de reproducción [Análisis de Datos](https://youtube.com/playlist?list=PLkgbkukKg_NqW81jVUAxNRPSHbCK6np0K) del Canal de Youtube. A continuación encontrarás los contenidos del curso:

- **Python**: En este primer tema aprenderás a utilizar el lenguaje de programación Python.
- **Numpy**: Seguiremos aprendiendo a usar la librería para computación numérica Numpy.
- **Pandas**: La librería Pandas te permitirá manejar grandes volúmenes de datos para su análisis.
- **Matplotlib**: Terminamos aprendiendo a utilizar la librería Matplotlib, para generar visualizaciones y gráficas con Python.


En este curso aprenderás a utilizar Python y las librerías más usadas para análisis de datos.

Análisis de Datos (YT)

Python

Numpy

Pandas

En este tema aprendermos a usar Matplotlib

Matplotlib


Este es el primer video del curso en la que aprenderemos a utilizar `Python` para el **análisis de datos**. O lo que es lo mismo, herramientas para manipular, procesar, limpiar y extraer información a partir de imágenes, texto, series temporales o tablas. En esta serie aprenderemos a manejarnos con la sintaxis básica de `Python` que luego combinaremos con algunas librerías orientadas al análisis de datos dentro del gran ecosistema existente. Los motivos que convierten a `Python` en el lenguaje ideal para el análisis de datos son básicamente su **facilidad de uso** y el gran **ecosistema** de librerías que existe enfocado a este tarea en concreto y que podemos utilizar de forma sencilla.

Además, `Python` no solo sirve para el análisis de datos sino que también se puede utilizar para implementar servidores [web](https://flask.palletsprojects.com/en/1.1.x/) e incluso hacer [juegos](https://www.pygame.org/wiki/GettingStarted). Otra de las grandes ventajas que `Python` ofrece es que puede utilizarse como capa de integración para código optimizado escrito en otros lenguajes como C o C++. Esto hace que `Python` sea un lenguaje muy versátil, ya que podemos utilizar su sintaxis sencilla para definir la estructura de nuestros programas y, de ser necesario, optimizar algunas partes implementándolas en lenguajes de bajo nivel como C, C++ o CUDA (así es como están implementadas librerías de Deep Learning como `Tensorflow` o `Pytorch`). Existen varios lenguajes alternativos a `Python` para el análisis de datos, algunos ejemplos son `R` o `MATLAB`, muy utilizados en la industria.

Las principales librerías de análisis de datos en `Python` que vamos a ver son las siguientes:

- `Numpy` es la librería que utilizamos para **cálculo numérico**, ya que nos provee de estructuras de datos y algoritmos con implementaciones optimizadas y eficientes.
- `Pandas` provee de estructuras de datos de alto nivel para trabajar con **datos tabulares** de forma rápida y sencilla.
- Utilizaremos `Matplotlib` para generar gráficas y **visualizaciones** de nuestros datos.

Entrando en el mundo del `Machine Learning`:

- Utilizaremos `Scikit-Learn` para entrenar modelos de clasificación, regresión o clustering.
- Por último, librerías como `Tensorflow` o `Pytorch` nos proveerán de todo lo necesario para definir y entrenar **redes neuronales** para `Deep learning`.

En este video te enseñaré cómo instalar `Python` y algunas de las diferentes herramientas que podemos utilizar a la hora de hacer nuestros programas. En los próximos video nos adentraremos en la sintaxis del lenguaje y cómo trabajar con las diferentes librerías mencionadas.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/001_python/post.ipynb).



En el video anterior hablamos sobre `Python` y su aplicación al campo del análisis de datos. Aprendimos a instalarlo y vimos diferentes herramientas que podemos utilizar para trabajar con él, desde _scripts_ en un editor de texto como `VSCode` hasta _notebooks_ en `Jupyter` o `Google Colab`.

En este video vamos a introducir la sintaxis básica de `Python` para entender conceptos esenciales de programación así como la mecánica del lenguaje. `Python` es un lenguaje diseñado con el objetivo de ser simple y explícito, asemejándose lo máximo posible al concepto de _pseudocódigo_.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/002_python_basico/post.ipynb).



En este video vamos a ver los distintos tipos de estructuras de datos que podemos encontrar en `Python`y que podemos aprovechar para nuestros proyectos. Librerías como `Numpy` o `Pandas`, de las cuales hablaremos más adelante, están diseñadas para aportar funcionalidad extra estas estructuras de datos. Las diferentes estructuras de las que hablaremos son: `tuplas`, `listas`, `dicts` y `sets`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/003_python_data_structures/post.ipynb).



Las `funciones` es la principal herramienta que nos ofrece `Python` a la hora de organizar nuestro código permitiendo también su reutilización. Como norma general, si te encuentras escribiendo el mismo código o una funcionalidad similar varias veces es muy probable que necesites un `función`. Esta `función` incluiría el código y cuando necesitamos ejectuarla la invocamos, enviando de manera opcional diferentes `argumentos` y recuperando el resultado devuelto por la `función`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/004_python_funciones/post.ipynb).



En el video anterior hablamos sobre `funciones`, una manera que tenemos para organizar nuestro código permitiendo su reutilización y robustez. Una `función` admite una serie de argumentos que utilizará para llevar a cabo una tarea determinada y, opcionalmente, devolver un resultado. En muchas ocasiones, esta aproximación es suficiente. Sin embargo, en otras ocasiones, necesitaremos un extra de funcionalidad que conseguiremos usando una `clase`. Como ya vimos anteriormente, en `Python` todo son `objetos`. La mayoría de estos objetos tienen `métodos` y `atributos`. Los `métodos` son `funciones` asociadas a un objeto en particular que nos van a permitir interactuar con sus `atributos`, otros objetos asicioados al objeto principal. Al definir una `clase` seremos capaces de crear nuestros propios `objetos`, con sus `métodos` y `atributos`. Además, gracias a la `herencia` seremos capaces de definir nuevos `objetos` a partir de otros aprovechando sus `mètodos` y `atributos` y añadiendo aquello que sea necesario en cada momento. Así pues, el uso de `clases` extiende la idea de reutilización y robustez de código que vimos en las `funciones` añadiendo un extra de funcionalidad.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/005_python_clases/clases.ipynb).



En videos anteriores hemos visto cómo manejarnos con la sintaxis básica de `Python`, desde los conceptos más básicos como crear variables o control de flujo hasta conceptos más avanzados como `clases`, pasando también por diferentes estructuras de datos y `funciones`. Estos conceptos forman el núcleo del lenguaje. Aún así, al trabajar con `Python`, tenemos muchas otras características y funcionalidad que podemos aprovechar para el análisis de datos sin necesidad de recurrir a librerías externas. Algunos ejemplos incluyen: trabajar con archivos (IO), acceder a funcionalidad del sistema operativo, operaciones matemáticas comunes, comprimir o descomprimir archivos, y un larguísimo etcétera. Esta funcionalidad viene implementada en diferentes `módulos` en lo que se conoce como la librería estándar de `Python`, o `STL` (_STandard Library_). En este post vamos a ver algunos de los módulos más utilizados en el análisis de datos. Puedes ver una lista completa de todos los `módulos` disponibles [aquí](https://docs.python.org/3/library/index.html).

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/006_python_stl/python_stl.ipynb).



`NumPy` (_Numerical Python_) es uno de los `módulos` más importantes y, probablemente, el más utilizado en el campo del cálculo numérico en el ecosistema de `Python`. En videos anteriores hemos visto como utilizar diferentes estructuras de datos en `Python` y otros `módulos` que nos ofrecen funciones matemáticas, cómo el módulo `math`. `NumPy` extiende esta funcionalidad en el campo del cálculo numérico de la siguiente manera:

- Ofrece el objeto `ndarray`, similar a una lista de `Python` pero optimizada para el cálculo numérico. Nos referiremos a este objeto como `array` de `NumPy`, o simplemente `array`.
- Implementa funciones matemáticas que pueden trabajar directamente sobre `arrays` sin tener que implementar bucles.
- Proporciona funciones para leer/escribir datos a archivos de manera optimizada.
- Permite aplicaciones de álgebra lineal, generación de números aleatorios y transformadas de Fourier.

El núcleo de `Numpy` está implementado en C, ofreciendo _bindings_ en `Python` para interactuar con él. Esto se traduce en que `NumPy` es más rápido que el equivalente en puro `Python`. Muchas otras librerías para el análisis de datos están construidas sobre `NumPy`, utilizando los `ndarrays` como la estructura de datos básica debido a su eficiencia. Para ilustrar esta propiedad vamos a calcular el tiempo necesario para llevar a cabo la misma operación en puro `Python` en comparación con `arrays` de `NumPy`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/007_numpy/numpy.ipynb).



En el video anterior hemos introducido `NumPy` y varias de sus características principales. La principal ventaja que ofrece `NumPy` es la velocidad superior respecto a `Python` en aplicaciones que requieren estructuras de datos numéricas que podemos expresar en forma de vectores, matrices o tensores. Parte de esta mejora viene del hecho que usando `NumPy` podemos llevar a cabo muchos tipos de procesado de datos mediante expresiones concisas aplicadas sobre `arrays` que de otra forma requerirían _loops_. La práctica de sustituir _loops_ por expresiones basadas en `arrays` se conoce como `vectorización`, que junto al `broadcasting` forman la base de la programación orientada a array (_Array-Oriented Programming_). En este post vamos a explicar estos conceptos para poder sacar el máximo provecho de `NumPy` y así obtener varios ordenes de magnitud en el _speedup_ de nuestro código en `Python`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/008_numpy_aop/numpy_aop.ipynb).



La librería `Pandas` proporciona estructuras de datos y herramientas de análisis de datos fáciles de usar y optimizadas. De la misma forma que en `Numpy` el objeto principal era el `ndarray`, el objeto principal en `Pandas` es el `DataFrame`, que puede considerarse como una tabla alojada en memoria (como una hoja de cálculo de Excel, con nombres de columna y etiquetas de fila). Muchas funciones disponibles en Excel están disponibles mediante programación, como crear tablas dinámicas, calcular columnas basadas en otras columnas, hacer gráficos, etc. `Pandas` se construye por encima de `Numpy`, por lo que podremos aprovechar mucha de la funcionalidad y nomenclatura ya conocemos. La principal diferencia es que con `Pandas` vamos a poder trabajar con datos heterogéneos, mientras que en `Numpy` necesitamos que nuestras estructuras de datos sean siempre del mismo tipo para poder llevar a cabo operaciones. Para poder empezar a trabajar con `Pandas` simplemente tenemos que importarlo como cualquier otra librería.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/019_pandas/pandas.ipynb).



En el video anterior hemos visto una introducción a la librería de análisis de datos `Pandas`. Esta librería nos ofrece el objeto `DataFrame` que podemos usar para estructurar datos de manera tabular y llevar a cabo operaciones para el análisis de estos datos. En este video vamos a explicar funcionalidad esencial de esta librería que nos hará la vida más fácil.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/020_pandas_funcionalidad/pandas_funcionalidad.ipynb).



En videos anteriores hemos visto cómo trabajar con `Pandas` para manipular datos tabulares de diferentes maneras, aunque nos hemos centrado en datos de tipo numérico ya que son el tipo de datos que necesitamos para entrenar nuestros modelos de `Machine Learning`. Sin embargo, muchos datos no están en formato numérico, y en este video vamos a ver como `Pandas` nos puede ayudar a la hora de trabajar con este tipo de datos, en concreto hablaremos sobre datos de tipo temporal y categóricos.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/021_pandas_temporal_categorical/pandas_temporal_categorical.ipynb).



Seguimos nuestro viaje en la exploración de las librerías para `análisis de datos` que el ecosistema de `Python` nos ofrece. Hasta ahora hemos visto cómo empezar a trabajar con `Python` y las librerías de `Numpy` y `Pandas`. A esta lista agregamos la librería de visualización [Matplotlib](https://matplotlib.org/), la cual exploramos en detalle en este video y que nos va a permitir crear gráficos de calidad que podemos usar para comunicar nuestros descubrimientos, hipótesis y conclusiones.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/022_matplotlib/matplotlib.ipynb).



Este curso está formado por los vídeos de la lista de reproducción [Deep Learning](https://youtube.com/playlist?list=PLkgbkukKg_NpdJPhhHbemaWHNQCY-lmh1) del Canal de Youtube. A continuación encontrarás los contenidos del curso:

- **Fundamentos Matemáticos**: En este tema aprenderemos los conceptos más útiles de álgebra lineal, probabilidad y cálculo numérico a la hora de diseñar y entrenar redes neuronales.
- **El Perceptrón**: Seguiremos viendo nuestro primer algoritmo de inteligencia artificial, el Perceptrón.
- **El Perceptrón Multicapa**: En este tema extenderemos nuestro Perceptrón para resolver problemas más complicados.
- **Frameworks**: Aquí hablaremos de qué es un framework de redes neuronales y las diferentes alternativas que encontramos hoy en día.
- **Entrenamiento de Redes Neuronales**: En este tema veremos diferentes aspectos relacionados con el entrenamiento de redes neuronales. Acabaremos desarrollando una _receta_ de entrenamiento que nos será muy útil en la mayoría de situaciones.
- **Redes Recurrentes**: En este tema aprenderemos a utilizar redes recurrentes.
- **Redes Convolucionales**: Aquí veremos qué son las redes convolucionales, cómo funcionan y qué tipo de tareas pueden resolver.
- **GANs**: Acabmos el curso hablando sobre _GANs_, redes neuronales generativas.


En este curso aprenderás sobre los concepto fundamentales del Deep Learning.

Deep Learning (YT)

En este tema veremos los fundamentos del deep learning

Fundamentos

El Perceptrón

En este tema hablaremos del Perceptrón Multicapa.

El Perceptrón Multicapa

Frameworks

En este tema hablaremos de cómo entrenar redes neuronales.

Entrenando Redes Neuronales

En este tema hablaremos de redes neuronales recurrentes.

Redes Neuronales Recurrentes

En este tema hablaremos de cómo entrenar redes neuronales convolucionales.

Redes Neuronales Convolucionales

GANs


## Álgebra Lineal

El `álgebra lineal` es una rama de las matemáticas utilizada en muchos campos de la ciencia y la ingeniería, incluyendo la `Inteligencia Artificial`. Un buen entendimiento de álgebra lineal es esencial para trabajar con la mayoría de algoritmos de `Machine Learning`, y sobretodo algoritmos de `Deep Learning`. En este video vamos a ver los conceptos de álgebra lineal más importante en el desarrollo de algoritmos de IA, omitiendo muchos conceptos interesantes pero no esenciales para nuestras aplicaciones.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/009_algebra_lineal/algebra_lineal.ipynb).

## Recursos

Aquí encontrarás links con recursos para aprender más.

Libros:

- The Matrix Cookbook (Petersen y Pedersen, 2006)
- Deep Learning (Goodfellow, Bengio y Courville, 2016)

Cursos Online:

- [MIT, 2010](https://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/)
- [FastAI](https://github.com/fastai/numerical-linear-algebra)

Youtube:

- [3Blue1Brown](https://www.youtube.com/watch?v=kjBOesZCoqc&list=PL0-GT3co4r2y2YErbmuJw2L5tW4Ew2O5B)

Posts:

- Nuestro [blog](https://juansensio.com/blog/009_algebra_lineal)
- [explained.ai](https://explained.ai/matrix-calculus/index.html)



En ocasiones, a la hora de resolver un problema matemático, podemos derivar una fórmula que provee de una descripción simbólica de la solución. Sin embargo, en muchos otros casos como la mayoría de algoritmos de `Machine Learning` y `Deep Learning`, esto no es posible y la solución solo puede aproximarse mediante técnicas iterativas con unos requisitos de cómputo que aumentan con el tamaño del problema. Es por este motivo que necesitamos súper-ordenadores con miles y miles de procesadores para resolver problemas como predicción meteorológica, diseño de nuevos medicamentos o entrenar grandes `redes neuronales`. Algunas operaciones que tienen lugar durante este proceso iterativo son la resolución de sistemas de ecuaciones lineales o la `optimización` de variables dadas unas restricciones, por poner algunos ejemplos. El campo de las matemáticas que se dedica al estudio de la resolución de este tipo de problemas es el `cálculo numérico`.

Puedes encontrar el código del video [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/011_calculo/calculo.ipynb).



La teoría de la `probabilidad` es la rama de las matemáticas que se encarga de la representación de fenómenos aleatorios o inciertos. En aplicaciones de `Inteligencia Artificial` se usa de dos formas. En primer lugar, las leyes de la probabilidad nos indican la manera en que nuestros sistemas de IA deberían razonar, de manera que diseñamos nuestros algoritmos para aproximar diferentes expresiones derivadas a partir de estas leyes. En segundo lugar, utilizamos probabilidad y `estadística` para analizar el comportamiento teórico de estos algoritmos. Si bien la probabilidad nos ayuda a llevar a cabo razonamientos en presencia de incertidumbre, la teoría de la `información` nos permite cuantificar la cantidad de incertidumbre en una distribución probabilística.

Puedes encontrar el código del video [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/010_probabilidad/probabilidad.ipynb).

## Recursos

- _Probability Theory: The Logic of Science_ (Jaynes, 2003)
- _Deep Learning_ (Goodfellow, Bengio y Courville, 2016)



En este video vamos a implementar nuestro primer algoritmo de IA. el `Perceptrón`. El `Perceptrón` es la unidad de computación básica utilizada en las redes neuronales, aunque también puede usarse por si solo como algoritmo de IA en algunos casos. Está inspirado en el funcionamiento de las neuronas biológicas, y fue propuesto en 1957 por Frank Rosenblatt.

![](https://camo.githubusercontent.com/0e620aed5352f0795b454bbfb440c91137b16914/68747470733a2f2f636f6d707363693639376c2e6769746875622e696f2f6173736574732f6e6e312f6e6575726f6e2e706e67)

Una neurona está compuesta de un cuerpo celular que contiene el núcleo y la mayoría de los componentes complejos de la célula, muchas extensiones ramificadas llamadas dendritas y una extensión muy larga llamada axón. Cerca de su extremidad, el axón se divide en ramas llamadas telodendria, y en la punta de estas ramas encontramos estructuras minúsculas llamadas terminales sinápticas (o simplemente sinapsis), que están conectadas a las dendritas o cuerpos celulares de otras neuronas. Las neuronas biológicas producen impulsos eléctricos cortos llamados potenciales de acción (o simplemente señales) que viajan a lo largo de los axones y hacen que las sinapsis liberen señales químicas llamadas neurotransmisores. Cuando una neurona recibe una cantidad suficiente de estos neurotransmisores en unos pocos milisegundos, dispara sus propios impulsos eléctricos. Aunque las neuronas individuales parecen comportarse de manera bastante simple, pueden conectarse a miles de otras neuronas formando redes complejas que pueden realizar tareas complejas.

El `Perceptrón` es una versión simplificada de la neurona que calcula la suma ponderada de todas sus entradas y después aplica una `función de activación` para dar el resultado

$$

\hat{y} = f(\mathbf{w} \cdot \mathbf{x}) = f(w_0 + w_1 x_1 + ... + w_m x_m)


$$

dónde $\hat{y}$ es la salida del `Perceptrón`, $\mathbf{w}$ son sus parámetros (también llamados los pesos), $\mathbf{x}$ son las entradas y $f$ es la función de activación. A continuación puedes ver un espuema del `Perceptrón`, puedes compararlo con el esquema de la neurona biológica para evaluar sus parecidos y diferencias.

![perceptron](https://www.researchgate.net/profile/Shibani_Singh2/publication/321141639/figure/fig2/AS:572731935727616@1513561342872/Schematic-of-Rosenblatts-perceptron.png)

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/012_perceptron1/perceptron1.ipynb).



En el video anterior hemos aprendido a utilizar el algoritmo de descenso por gradiente para el `Perceptrón` usando como función de pérdida el error medio cuadrático (_MSE_), el cual se implementa de la forma siguiente:

1. Calcular la salida del modelo, $\hat{y}$.
2. Calcular la derivada de la función de pérdida con respecto a los parámetros del modelo, $\frac{\partial MSE}{\partial w} = \frac{2}{N} \frac{\partial \hat{y}}{\partial w} (\hat{y} - y) $ dónde $\frac{\partial \hat{y}}{\partial w} = x$.
3. Actualizar los parámetros, $w \leftarrow w - \eta \frac{\partial MSE}{\partial w}$, dónde $\eta$ es el _learning rate_.
4. Repetir hasta converger.

Inicializaremos nuestro modelo con unos valores aleatorios para los pesos, e iremos actualizando sus valores de manera iterativa en la dirección de pendiente negativa de la función de pérdida. Como puedes ver hay varios `hyperparámetros` en el proceso de optimización que van a afectar el proceso de optimización. Éstos son:

- Inicialización de los pesos
- Valor escogido del _learning rate_
- Datos utilizados para el cálculo del gradiente

En este video veremos cómo afecta al proces de optimización la elección de diferentes valores para estos parámetros.

> 💡 Llamamos `hyperparámetros` a todos aquellos parámetros que influyen en el resultado de la optimización pero que no son resultados de la misma (como los valores iniciales, _learning rate_, etc), mientras que los `parámetros` serían los resultados de la optimización (los pesos del modelo).

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/013_perceptron2/perceptron2.ipynb).



En este vídeo vamos a ver una nueva aplicación del `Perceptrón`: la `clasificación binaria`. En esta tarea nuestro objetivo es dar como resultado si una muestra pertenece a una clase en particular o no a partir de sus características.

> 💡 Para el problema de regresión lineal usamos el ejemplo de predicción de precios de inmuebles a partir de características como el número de habitaciones o los metros cuadrados. En el caso de clasificación binaria podemos pensar en un sistema de ayuda al diagnóstico médico en el que nuestro modelo tiene que decirnos si un paciente tiene una enfermedad o no a partir de valores como su edad, peso, temperatura, síntomas, etc.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/014_clasificacion_binaria/clasificacion_binaria.ipynb).



En el vídeo anterior vimos cómo utilizar el `Perceptrón` para la tarea de clasificación binaria. Para ello utilizamos una función de activación de tipo `step` (que nos da una salida de $0$ ó $1$) y entrenamos el `Perceptrón` mediante el algoritmo de descenso por gradiente utilizando el error medio cuadrático (MSE) como función de pérdida. Sin embargo, en ocasiones no estamos interesados simplemente en conocer si un elemento en particular pertenece a una clase o no, si no también el grado de confianza con el que nuestro modelo da cada predicción. Para ello necesitamos que nuestro `Perceptrón` sea capaz de dar una `probabilidad` a la salida.

Como ya vimos en el video de `probabilidad`, esta salida será un valor entre $0$ y $1$ (a diferencia del anterior modelo en el que la salida era $0$ ó $1$) siendo $0$ la absoluta certeza de que el elemento en cuestión no pertenece a la clase que nos interesa y $1$ la absoluta certeza de que sí pertenece. Un valor intermedio indicará una menor seguridad por parte del modelo (podemos utilizar esta información para mejorar el algoritmo añadiendo más datos similares). Un valor de $0.5$ indicará que nuestro modelo no tiene ni la más remota idea de cómo clasificar el elemento utilizado como entrada. Este modelo también se conoce por el nombre de `regresión logística` y vamos a ver cómo se define, su implementación y proceso de entrenamiento.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/015_logistic_regression/logistic_regression.ipynb).



En este video vamos a ver algunas de las métricas más utilizadas en clasificación binaria (aunque pueden extenderse también a clasificación en varias clases). Estas métricas nos van a ser muy útiles para caracterizar el desempeño de nuestros modelos y comparar diferentes modelos entre sí para, por ejemplos, utilizar el mejor.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/016_metricas_clasificacion/metricas_clasificacion.ipynb).



La arquitectura de `Perceptrón` que hemos visto hasta ahora nos ha permitido llevar a cabo dos tipos de tareas: regresión lineal y clasificación binaria. En este post vamos a mejorar la implementación de nuestro modelo para ser capaces de utilizarlo en la tarea de clasificación en varias clases. En primer lugar, vamos a revisar la arquitectura del `Perceptrón`. Hasta ahora, nuestro modelo era capaz de recibir una serie de entradas y dar como resultado una única salida.

![](https://www.researchgate.net/profile/Shibani_Singh2/publication/321141639/figure/fig2/AS:572731935727616@1513561342872/Schematic-of-Rosenblatts-perceptron.png)

La idea es la siguiente: si un `Perceptrón` es capaz de clasificación binaria (identificar una clase en particular de entre el resto), podemos utilizar tantos perceptrones como clases tengamos. En esta configuración, cada `Perceptrón` tendrá el objetivo de identificar una de las clases en particular del resto.

![](https://camo.githubusercontent.com/bcb4c2d2684739dd367e6e61d96102bb8ba28cd8/68747470733a2f2f6a6c6565776562626c6f672e66696c65732e776f726470726573732e636f6d2f323031372f30332f736f666d61782d72656772657373696f6e2e6a70673f773d36333326683d353237)

En esta nueva implementación, tendremos tantas salidas como clases (podemos usarlo también para regresión, cada salida correspondería a cada una de las magnitudes de interés). Calculamos la salida del modelo de la misma manera que en el caso del `Perceptrón` de una sola salida. La diferencia es que en la última capa aplicaremos una función de activación de tipo `softmax`. Esto nos dará como resultado una distribución de probabilidad sobre todas las clases. Finalmente, asignaremos aquella clase que tenga la probabilidad más alta.

$$
 \hat{y} = \underset{k}{\arg\max} \ \ \sigma(\mathbf{w} \cdot \mathbf{x})\_k
$$

En el caso del `Perceptrón` con una sola salida, nuestros pesos estaban representados por un vector de longitud igual al número de entradas (más uno si tenemos en cuenta el _bias_). Ahora, al tener varias salidas, los pesos estarán representados por una matriz (puedes ver el vector anterior como una matriz de una sola columna). Este modelo también se conoce por el nombre de `Softmax Regression`.

> 💡 Puedes aprender sobre la función `softmax` en el video sobre `probabilidad`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/017_clasificacion_multiclase/clasificacion_multiclase.ipynb).



Como ya sabemos, el `Perceptrón` está inspirado en el funcionamiento de las neuronas biológicos. Sin embargo, nuestros cerebros están formados por trillones (entre 100 y 1000) de conexiones entre neuronas. Así pues, si queremos conseguir modelos más "inteligentes" necesitamos conectar `Perceptrones` en capas consecutivas capaces de representar distribuciones de datos no lineales. Esta arquitectura se conoce con el nombre de `Perceptrón Multicapa`, o _Multilayer Perceptron_ en inglés (MLP), y es la arquitectura básica de las `redes neuronales`.

![](https://www.researchgate.net/profile/Mohamed_Zahran6/publication/303875065/figure/fig4/AS:371118507610123@1465492955561/A-hypothetical-example-of-Multilayer-Perceptron-Network.png)

Como puedes ver en la figura, un MLP no es más que una secuencia de `Perceptrones`, las salidas de los cuales son a la vez las entradas para la siguiente capa (así hasta llegar a la salida). En el caso de un MLP de dos capas, podemos calcular la salida de la primera capa como

$$
\mathbf{h}_1 = f_1(\mathbf{w}_1 \cdot \mathbf{x})
$$

donde $\mathbf{h}_1$ es el estado oculto, _hidden state_ en inglés, de la primera capa. Como puedes ver la expresión es la misma que la que usamos en el modelo `Perceptrón`, en el que $\mathbf{w}_1$ son los pesos de la primera capa y $\mathbf{x}$ las entradas. Si ahora consideramos $\mathbf{h}_1$ como las entradas de la siguiente capa, podemos encontrar la salida como

$$
\hat{y} = f_2(\mathbf{w}_2 \cdot \mathbf{h}_1) = f_2(\mathbf{w}_2 \cdot f_1(\mathbf{w}_1 \cdot \mathbf{x}))
$$

en la que simplemente hemos vuelto a aplicar la misma expresión. Puedes intuir que si tenemos más capas, simplemente repetiremos la expresión para cada capa, usando las salidas de una capa como entradas de la siguiente de manera recurrente hasta llegar a la salida. Una vez obtenido este valor, podemos entrenar nuestro MLP usando el algoritmo de `backpropagation`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/023_mlp_backprop/mlp_backprop.ipynb).



En el videos anterior hemos introducido el modelo de `Perceptrón Multicapa`, o MLP, la arquitectura de red neuronal más básica basada en el `Perceptron`. Hemos visto cómo calcular la salida de un MLP de dos capas a partir de unas entradas y cómo encontrar los pesos óptimos para una tarea de regresión. En este post vamos a mejorar la implementación de nuestro MLP de dos capas para que sea capaz también de llevar a cabo tareas de clasificación.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/024_mlp_clasificacion/mlp_clasificacion.ipynb).



En el video anterior completamos una implementación del Perceptrón Multicapa capaz de llevar a cabo tareas de `regresión` y `clasificación`. Sin embargo, esta implementación tiene muchas limitaciones. Por ejemplo, sólo sirve para un perceptrón multicapa con una capa oculta con funciones de activación de tipo `relu`, entre otras. Aún así, programar todos los elementos envueltos en un arquitectura en concreto es muy útil para entender qué está pasando dentro de la `red neuronal` en todo momento. En este post vamos a mejorar la implementación para resolver estas limitaciones, haciendo nuestro propio framework inspirado en [Pytorch](https://pytorch.org/).

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/025_mlp_framework/mlp_framework.ipynb).



En el video anterior desarrollamos nuestro propio framework de redes neuronales, un conjunto de clases de `Python` que nos permiten resolver problemas con la arquitectura conocida como `Perceptrón Multicapa`. Si bien nuestro framework es funcional y flexible, requiere que implementemos nueva funcionalidad cada vez que queramos probar algo nuevo. De la misma manera, nuestra implementación no es en ningún caso óptima. Es por este motivo que, hoy en día, la mayoría de investigadores e ingenieros utilizan frameworks desarrollados por terceros para llevar a cabo sus proyectos. Esto mismo es lo que haremos nosotros de ahora en adelante, y en este post vamos a ver algunos de los frameworks más utilizados para poder escoger uno.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/026_frameworks/frameworks.ipynb).



Hasta ahora hemos presentado la mayoría de conceptos fundamentales necesarios para entender cómo funciona una `red neuronal`, implementando desde cero los algoritmos que necesitamos para el diseño y entrenamiento de estos modelos. Sin embargo, de ahora en adelante utilizaremos la librería de `redes neuronales` [Pytorch](https://pytorch.org/), la cual hemos introducido en los posts anteriores. A pesar de que ya conocemos cómo entrenar modelos simples de `Perceptrón Multicapa` en tareas de regresión y clasificación, es posible que no obtengas los resultados deseados (al menos comparados con resultados que puedes encontrar en otras referencia). En los próximos vídeos nos vamos a centrar en técnicas concretas que van a permitirnos entrenar los mejores modelos posibles, terminando con una "receta" que podemos utilizar en nuestros proyectos. En este post empezamos viendo técnicas de división de datos necesarias para entrenar y validar nuestras `redes neuronales` de forma correcta.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/030_data_splitting/data_splitting.ipynb).



Como hemos visto en el video anterior, cuando entrenamos `redes neuronales` corremos el riesgo de hacer _overfitting_ a los datos de entrenamiento, lo cual se traducirá en una mala _performance_ de nuestro modelo cuando le demos datos que no ha visto durante el entrenamiento, no sabrá generalizar. La mejor manera de saber si nuestro modelo sufre de este problema, es observar las curvas de entrenamiento. En este video veremos varias técnicas de `regularización` que nos permiten reducir el problema del _overfitting_.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/031_regularization/regularization.ipynb).



En este video vamos a ver algunas técnicas que podemos aplicar durante el entrenamiento de nuestras `redes neuronales` para acelerar el proceso de optimización y, potencialmente, obtener mejores resultados de los que hemos sido capaces de obtener hasta ahora. Compararemos estas técnicas en el mismo problema utilizado en el video anterior, la clasificación de imágenes con el dataset CIFAR10.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/032_optimization/optimization.ipynb).



En los videos anteriores hemos introducido muchos conceptos que nos pueden ayudar a la hora de entrenar redes neuronales de manera efectiva, consiguiendo buenas prestaciones. En este video vamos a presentar una receta sencilla que puedes seguir para empezar a entrenar tus redes aplicando las prácticas más comunes con el objetivo de minimizar la posibilidad de introducir errores en el proceso.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/033_receta_entrenamiento/receta_entrenamiento.ipynb).



En videos anteriores hemos cubierto muchísimos temas relacionados con `redes neuronales`, sin embargo en todos los ejemplos y aplicaciones hemos usado siempre la misma `arquitectura` de red neuronal: el `Perceptrón Multicapa` (MLP), un modelo del que hemos hablado extensivamente.

![](https://www.researchgate.net/profile/Mohamed_Zahran6/publication/303875065/figure/fig4/AS:371118507610123@1465492955561/A-hypothetical-example-of-Multilayer-Perceptron-Network.png)

En este modelo tenemos una serie de capas, cada capa formada por un número determinado de `perceptrones` (o neuronas artificiales, la unidad básica que forma las `redes neuronales` de la que también hemos hablado en gran cantidad en posts anteriores). Si bien este modelo es muy útil y potente, lo hemos utilizado por ejemplo para clasificar imágenes, existen otras aplicaciones para las cuales esta arquitectura se ve limitada. Una familia de aplicaciones en las que nuestro `MLP` no será muy efectivo es aquellas en las que tratemos con `datos secuenciales`, como por ejemplo `series temporales` o aplicaciones de `lenguaje` en las que nuestros datos están organizados en secuencias de longitud variable. En este video vamos a introducir una nueva `arquitectura` diseñada específicamente para tratar con datos secuenciales: las `redes neuronales recurrentes` (RNNs).

![](https://miro.medium.com/max/2544/1*aIT6tmnk3qHpStkOX3gGcQ.png)

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/034_rnn_intro/rnn_intro.ipynb).



En el [video anterior hemos introducido la arquitectura de `red neuronal recurrente`, útil para aplicaciones en las que trabajamos con datos secuenciales como, por ejemplo, series temporales. Encontramos series temporales en multitud de aplicaciones como financieras (previsión de ventas en empresa, evolución acciones en bolsa, ...), médicas (evolución síntomas paciente, predicción de mortalidad, ...), y muchas otras.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/035_rnn_forecast/rnn_forecast.ipynb).



En los vídeos anteriores hemos aprendido sobre `redes neuronales recurrentes` y cómo podemos aplicarlas para tareas con datos secuenciales, como por ejemplo predicción de series temporales. El tipo de redes recurrentes que hemos visto nos han sido útiles para resolver los casos sencillos que hemos visto, pero tienen problemas para trabajar con secuencias muy largas (varios centenares de instantes temporales). Para ello, ciertas mejoras se han desarrollado que alivian este problema. En este post vamos a hablar de algunas de estas mejores que puedes aplicar a tus problemas en caso que tus redes recurrentes simples no funcionen bien.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/036_rnn_mejoras/rnn_mejoras.ipynb).



En los vídeos anteriores hemos presentado varias arquitecturas diferentes de `redes neuronales`. Algunos ejemplos son el `Perceptrón Multicapa` o las `redes neuronales recurrentes`, las cuales hemos aplicado para `predicción de series temporales`. En este post vamos a presentar una nueva arquitectura de `red neuronal` conocida como `red neuronal convolucional`, especialmente diseñada para trabajar con imágenes.

Las `redes neuronales convolucionales` (CNNs) surgieron del estudio del córtex visual del cerebro y se han utilizado en el reconocimiento de imágenes desde la década de los 80. En los últimos años, gracias al aumento de la potencia computacional, la cantidad de datos de entrenamiento disponibles y los trucos ya explicados anteriormente para entrenar redes profundas, las CNNs han logrado lograr un rendimiento sobrehumano en algunas tareas visuales complejas. Este tipo de red se puede encontrar en servicios de búsqueda de imágenes, coches autónomos, sistemas de clasificación de vídeo automático y muchas otras aplicaciones. Además, las CNNs no se limitan a la percepción visual, también tienen éxito en tareas como el reconocimiento de voz y el procesamiento de datos tridimensionales.

### El córtex visual

Las neuronas del córtex visual tienen un pequeño _campo receptivo local_, lo que significa que reaccionan solo a los estímulos visuales ubicados en una región limitada del campo visual. Los campos receptivos de diferentes neuronas pueden superponerse y juntos forman el campo visual completo.

![](https://mymlpics.s3.eu-de.cloud-object-storage.appdomain.cloud/visual_cortex.png)

Las neuronas de las primeras capas del córtex visual reaccionan solo ante ciertos patrones simples, como por ejemplo líneas horizontales mientras que otras reaccionan a líneas verticales (dos neuronas pueden tener el mismo campo receptivo pero reaccionan a diferentes orientaciones de línea). En las capas siguientes, las neuronas tienen campos receptivos más grandes y reaccionan a patrones más complejos, que pueden ser combinaciones de patrones de nivel inferior, construyendo de esta manera una jerarquía en diferentes capas que resultan finalmente en las formas y colores que vemos.

Basándose en estos conceptos, Yann LeCunn introdujo las CNNs en 1998 en la famosa arquitectura [LeNet-5](https://colab.research.google.com/drive/1fqxaTs-Ux9KQHyCJsToFTZwSNoHv9rKe#scrollTo=CMK6qB1EdfqC), utilizada por los bancos para reconocer de manera automática los números manuscritos en cheques para un procesamiento más rápido.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/042_cnns/cnns.ipynb).



En el video anterior hemos introducido la arquitectura de `red neuronal convolucional`, un modelo de `red neuronal` especialmente diseñado para trabajar con imágenes en tareas de visión artificial. Entre estas tareas, la más común es la de clasificación de imágenes, que consiste simplemente en asignar una categoría de entre varias a una imagen en particular. Una buena manera para medir el progreso en el campo del `Machine Learning` es a través de `benchmarks` y competiciones en los que investigadores proponen diferentes soluciones a un mismo problema, que se evalúan sobre un mismo conjunto de datos de test oculto. En el campo del `deep learning` y `computer vision`, una de estas competiciones, que hoy en día ya es un `benchmark` establecido, es la clasificación de imágenes en el dataset [Imagenet](http://www.image-net.org/challenges/LSVRC/). En 2012, la primera `red neuronal convolucional` entró en esta competición consiguiendo una mejora de 10 puntos sobre la mejor solución hasta la fecha, lo cual supuso un detonante para el campo del `deep learning`. A partir de ese momento, todas las soluciones ganadoras presentadas durante los años siguientes han sido redes convolucionales, convirtiendo a Imagenet una estupenda fuente de información para conocer los últimos avances en el campo (cuando una nueva arquitectura es diseñada, es práctica común reportar sus prestaciones en Imagenet para poder compararla con otras redes). En este post vamos a revisar algunas de las arquitecturas más conocidas que han aparecido durante los años, las cuales podremos usar para nuestras aplicaciones. Puedes conocer en detalle del progreso de este `benchmark` en [papers with code](https://paperswithcode.com/sota/image-classification-on-imagenet), donde también encontrarás artículos y código en muchísimos otros campos de aplicación.

![](https://www.researchgate.net/profile/Kien_Nguyen26/publication/321896881/figure/fig1/AS:573085821489153@1513645715549/The-evolution-of-the-winning-entries-on-the-ImageNet-Large-Scale-Visual-Recognition.png)

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/043_cnn_arquitecturas/arquitecturas.ipynb).



En videos anteriores hemos introducido la arquitectura de `red neuronal convolucional` y también hemos presentado varias arquitecturas famosas que han demostrado buenas prestaciones en multitud de tareas. Estas redes están formadas muchas capas convolucionales, algunas con más de 100 capas, lo cual significa que tienen muchos parámetros y entrenarlas desde cero puedes ser costoso. Sin embargo, existe una técnica que nos permite obtener buenos modelos con menores requisitos: el _transfer learning_. Ya hemos hablado anteriormente de esta técnica, en el contexto de modelos de lenguaje, pero la idea es la misma: utilizaremos el máximo número de capas de una red ya entrenada en otro dataset, y simplemente entrenaremos las nuevas capas que necesitemos para nuestra tarea concreta.

![](https://pennylane.ai/qml/_images/transfer_learning_general.png)

En este video vamos a ver cómo podemos utilizar una red neuronal pre-entrada en Imagenet, y adaptarla para una nueva tarea de clasificación con un pequeño dataset.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/044_cnn_transfer_learning/cnn_transfer_learning.ipynb).



GANs (_generative adversarial networks_) es una arquitectura de red neuronal propuesta en 2014 por [Ian Goodfellow](https://arxiv.org/pdf/1406.2661.pdf) y otros con el objetivo de obtener modelos capaces de generar datos realistas, principalmente imágenes. Pese a la simplicidad de la idea original, se tardó varios años en superar varias de las dificultades que presenta su entrenamiento. Hoy en día, sin embargo, se utilizan para obtener resultados espectaculares. Algunos ejemplos son:

- Generación de caras: https://www.thispersondoesnotexist.com/
- Generación de anuncios de Airbnb: https://thisrentaldoesnotexist.com/
- Super-resolución: https://www.youtube.com/watch?v=3RYNThid23g
- Colorización: https://github.com/jantic/DeOldify
- Generación de paisajes: http://nvidia-research-mingyuliu.com/gaugan
- Y muchos otros.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/051_gans/gans.ipynb).



En este video entramos en detalle en el proces de entrenamiento de una GAN.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/051_gans/gans.ipynb).



Terminamos el tema sobre GANs viendo como podemos merjorar la generación de imágenes con el uso de `redes neuronales convolucionales`.

Puedes encontra el código del vídeo [aquí](https://colab.research.google.com/github/juansensio/blog/blob/master/051_gans/gans.ipynb).



¿Cómo funciona un ordenador?, ¿qué es un algoritmo?, ¿qué es un lenguaje de programación?... Son preguntas que quizás te has planteado en algún momento. En este curso las contestaremos, y aprenderás los conceptos fundamentales de la Programación con [Python](https://www.python.org/) para ser capaz de decirle a tu ordenador qué es lo que quieres que haga. A continuación puedes ver los diferentes temas que trataremos durante el curso:

- **Introducción** 💻: Arrancaremos el curso destripando un ordenador, viendo sus diferentes partes y aprendiendo para qué sirve cada una. Aprenderemos qué significa `programar` y cómo es capaz un ordenador de representar y resolver un problema simplemente con unos y ceros. Definiremos el concepto `algoritmo` y aprenderemos para qué sirve un `lenguaje de programación`.
- **Python** 🐍: En este tema aprenderemos los conceptos básicos de la programación con `Python`. Tras ver cómo podemos instalarlo y las diferentes formas de trabajar con este lenguaje, hablaremos de variables, tipos de datos, operaciones, condicionales, bucles, funciones... Aplicaremos estos conceptos en el desarrollo de varios ejercicios y proyectos, uno de ellos será implementar el conocido `Juego de la Vida`.
- **Programación orientada a objetos** 🚗: Seguiremos aprendiendo uno de los conceptos fundamentales más interesantes de la programación: la programación orientada a objetos. Este paradigma de programación es muy utilizado, sobretodo en aplicaciones de Inteligencia Artificial. Saber definir nuestras `clases` y aprovechar la `herencia` hará que nuestro código sea más robusto y reutilizable (entre muchas otras ventajas).
- **Algoritmos y Estructuras de datos** ⚡️: Terminaremos utilizando las herramientas aprendidas en los temas anteriores para el desarrollo de algoritmos y estructuras de datos comunes, haciendo hincapié en conceptos tales como la eficiencia y viendo diferentes ejemplos de uso.

Durante todo el curso llevarás a cabo ejercicios y proyectos que te ayudarán a asentar y entender los conceptos explicados. Estos proyectos te servirán para poder demostrar al mundo tus nuevas habilidades 🚀

## ¿A quién va dirigido?

Este curso está dirigido a todas aquellas personas sin un _background_ técnico en el campo de la programación, ya sea profesionales de otros sectores buscando adquirir nuevas habilidades o estudiantes que se plantean escoger este camino profesional. Si éste es tu caso, en este curso aprenderás todo lo que necesitas para adentrarte en el apasionante campo de la programación.

## Soporte

Durante el curso, recuerda que no estás solo 🙌 Únete a nuestro [discord](https://discord.gg/dcjyB6xJD) y pregunta cualquier duda.


En este curso aprenderás los conceptos fundamentales de la Programación con Python.

Introducción a la Computación con Python

¿Cómo funciona un ordenador?,¿qué es un algoritmo?,¿qué es un lenguaje de programación?... En este tema respondemos a todas estas preguntas y más

Introducción

En este tema aprenderemos los conceptos fundamentales de la programación con el lenguaje Python.

Aplica los conocimientos adquiridos de Python mediante la implementación del Juego de la Vida.

El Juego de la Vida

En este tema aprenderemos los conceptos fundamentales de la programación orientada a objetos.

Programación Orientada a Objetos

En este tema hablaremos de algoritmos y estructuras de datos.

Algoritmos y Estructura de Datos

Proyecto Final


Bienvenid@ al curso de Introducción a al Computación con Python 🎉🎉🎉. En este video me presento y te explico los objetivos del curso.

Mi nombre es Juan, y voy a ser tu profesor durante este curso. Tengo un PhD en Ingeniería Aeronáutica, un máster en Inteligencia Artificial y desde hace ya unos años me dedico de manera profesional al desarrollo de software. Actualmente divido mi tiempo entre [SensioAI](https://juansensio.com/), creando contenido educativo sobre programación, y [EarthPulse](https://earthpulse.es/), desarrollando aplicaciones de Inteligencia Artificial usando datos de Observación de la Tierra.

En este curso aprenderás los conceptos fundamentales de la programación: ¿Cómo funciona un ordenador?,¿qué es un algoritmo?,¿qué es un lenguaje de programación?... Veremos todos estos conceptos y aprenderemos a utilizar el lenguaje de programación `Python` para el desarrollo de algoritmos y estructuras de datos que podrás utilizar en tus propias aplicaciones.

También me gustaría pedirte que compartas todo el trabajo que hagas durante el curso. Para ello, te enseñaré a tener tu código en `Github` para poder demostrarle al mundo entero tus nuevas habilidades.

Utiliza los links que te iré dejando en los vídeos para seguir aprendiendo sobre los diferentes temas de los que hablaremos, y si tienes cualquier duda únete a nuestro discord donde tanto yo como el resto de miembros de nuestra comunidad te ayudaremos a resolverlas.

## Recursos

- [CS50](https://www.youtube.com/playlist?list=PLhQjrBD2T382_R182iC2gNZI9HzWFMC_8)
- [MIT 6.0001](https://www.youtube.com/playlist?list=PLUl4u3cNGP63WbdFxL8giv4yhgdMGaZNA)



`Programar` consiste en resolver problemas utilizando ordenadores. Por lo general, un programa recibirá una entrada (o _input_) en forma de datos que serán procesados de una manera específica con el objetivo de darnos una salida (o _output_), la solución a nuestro problema.

Aprender a programar te dotará de habilidades generales para resolver problemas que podrás aplicar en todas las facetas de tu vida, no solo a la informática.



Para poder resolver un problema utilizando nuestro ordenador necesitamos ser capaces de representar nuestros datos de manera que el ordenador pueda entenderlo, procesarlo y darnos una solución. Para ello utilizamos números: el sistema universal de representación de datos.



En este video veremos cómo funciona un ordenador y cómo es capaz de procesar los ceros y unos que van a representar nuestro problema con el objetivo de darnos una solución al mismo.



En este vídeo aprendemos cómo consigue un ordenador representar y manipular texto.



En este vídeo aprendemos cómo consigue un ordenador representar y manipular imágenes y video.



Podemos definir un algoritmo como la secuencia de instrucciones que se deben llevar a cabo (normalmente por un ordenador) para resolver un problema determinado. ¿Cómo buscarías una palabra en un diccionario 📖? De manera inconsciente estás aplicando un algoritmo para conseguirlo.



El pseudocódigo es la primera herramienta que podemos (y debemos) utilizar a la hora de traducir un algoritmo a una secuencia de instrucciones para resolver un problema.



Solución al ejercicio de pseudocódigo.



Una vez definido un algoritmo, necesitamos poder traducirlo a un idioma que nuestro ordenador sea capaz de entender. Para ello, utilizamos un lenguaje de programación. Existen muchísimos lenguajes de programación, y el usar uno u otro dependerá de la aplicación que estemos desarrollando. Lenguajes como `C`, `C++` o `Python` son muy utilizados en aplicaciones de carácter numérico, como por ejemplo la Inteligencia Artificial. Otros lenguajes, como `Javascript`, se utilizan para el desarrollo de aplicaciones `web`. Aún así, los conceptos fundamentales que aprenderemos durante el curso son transversales a cualquier lenguaje de programación.



Aprendemos sobre los principales conceptos fundamentales que podemos encontrar en un lenguaje de programación, en este caso utilizando Scratch.

## Recursos

- [Scratch](https://scratch.mit.edu/).
- Tutorial [Pong](https://scratch.mit.edu/projects/editor/?tutorial=pong).



Empezamos a aprender el lenguaje de programación `Python` 🔥. Python es un lenguaje de programación flexible y fácil de aprender, funciona en cualquier sistema operativo, es gratuito y dispone de un gran ecosistema de librerías en las que encontraremos implementaciones de prácticamente cualquier cosa que necesitemos. Es el lenguaje más utilizado a día de hoy en el desarrollo de aplicaciones de Inteligencia Artificial, por lo que si te interesan este tipo de aplicaciones tener una buena base de Python te resultará muy útil.

## Recursos

- [Wikipedia](https://es.wikipedia.org/wiki/Python).
- [Python](https://www.python.org/).
- Python [Module of the Week](https://pymotw.com/3/).
- [Full Stack Python](https://www.fullstackpython.com/).
- Python [Weekly](https://www.pythonweekly.com/).



Aprende a instalar Python en tu ordenador y las diferentes alternativas a la hora de trabajar con este lenguaje de programación.

## Recursos

- [VSCode](https://code.visualstudio.com/).
- [Jupyter](https://jupyter.org/).
- [Anaconda](https://www.anaconda.com/).
- [Miniconda](https://docs.conda.io/en/latest/miniconda.html).
- Aprende más acerca de la [terminal](https://www.youtube.com/watch?v=Z56Jmr9Z34Q&list=PLyzOVJj3bHQuloKGG59rS43e29ro7I57J).



En este video haremos nuestro primer programa: el famoso `Hola, mundo`, en Python. Para ello hacemos el uso del entorno de desarrollo [Google Colab](https://colab.research.google.com/), donde podemos ejecutar nuestros notebooks de Python en servidores en la nube que Google nos ofrece de manera gratuíta.



En este video aprenderemos qué es una variable y como Python es capaz de almacenar datos en la memoria de nuestro ordenador.



Aprendemos a trabajar con `strings` (cadenas de caracteres), uno de los tipos más potentes y con mejor soporte en Python para trabajar con texto.

## Recursos

- [Strings](https://www.w3schools.com/python/python_strings.asp).
- [Métodos](https://www.w3schools.com/python/python_ref_string.asp).
- [Documentación](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str).
- [Formato](https://pyformat.info/).
- [Template](https://docs.python.org/3/library/string.html#template-strings) strings.



Vemos los diferentes tipos numéricos que Python nos ofrece y qué operaciones podemos llevar a cabo con ellos.



Mediante el uso de `condicionales` podemos ejecutar código en función de si se cumplen, o no, ciertas condiciones.

## Recursos

- Operadores [binarios](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not).
- Operadores de [comparación](https://docs.python.org/3/library/stdtypes.html#comparisons)
- [Condicionales](https://docs.python.org/3/tutorial/controlflow.html).



Solucionamos el ejercicio propuesto en el video anterior y hablamos de ciertas consideraciones que tenemos que tener en cuenta a la hora de implementar nuestros condicionales. También conocemos el operador ternario, muy útil para reducir nuestro número de líneas de código.



El uso de bucles nos permitirá ejecutar código de manera repetida, un número determinado de veces o de manera indefinida mientras o hasta que se cumpla alguna condición en concreto.



En este video aprendemos a utilizar el software de control de versión de código conocido como [git](https://git-scm.com/).



Aprendemos a sincronizar nuestros repositorios de `git` en la nube gracias al servicio [Github](https://github.com/).



Empezamos a aprender acerca de las estructuras de datos que `Python` nos ofrece para empezar a resolver problemas interesantes. En primer lugar veremos la `tupla`.

## Recursos

- [Post](https://juansensio.com/blog/003_python_estructuras)
- Estructuras de [dats](https://docs.python.org/3/tutorial/datastructures.html)
- Tipos [secuenciales](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)



La `lista` es una de las estructuras de datos más flexibles y útiles que nos ofrece Python. Podemos utilizarla para organizar nuestros datos en una secuencia sobre la cual podremos iterar, añadir o eliminar elementos.

## Recursos

- [Post](https://juansensio.com/blog/003_python_estructuras)
- Estructuras de [dats](https://docs.python.org/3/tutorial/datastructures.html)
- Tipos [secuenciales](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)



En un `dict` podremos organizar nuestros datos en conjuntos de `clave-valor`, probablemente la estructura de dato más utilizada en `Python`.

## Recursos

- [Post](https://juansensio.com/blog/003_python_estructuras)
- Estructuras de [dats](https://docs.python.org/3/tutorial/datastructures.html)
- Tipos [secuenciales](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)



Terminamos hablando sobre los `sets`, conjuntos de valores únicos.

## Recursos

- [Post](https://juansensio.com/blog/003_python_estructuras)
- Estructuras de [dats](https://docs.python.org/3/tutorial/datastructures.html)
- Tipos [secuenciales](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)



Las funciones son el principal recurso que todo lenguaje de programación nos ofrece para organizar nuestro código de manera que sea más robusto, legible y reutilizable.

## Recursos

- [Post](https://juansensio.com/blog/004_python_funciones)
- [Funciones](https://docs.python.org/3/library/functions.html)
- Más [funciones](https://www.w3schools.com/python/python_functions.asp)
- Funciones [lambda](https://www.w3schools.com/python/python_lambda.asp)



Nuestras funciones reciben `argumentos`, variables con las que querremos llevar a cabo una serie de operaciones, y devuelven `resultados`.

## Recursos

- [Post](https://juansensio.com/blog/004_python_funciones)
- [Funciones](https://docs.python.org/3/library/functions.html)
- Más [funciones](https://www.w3schools.com/python/python_functions.asp)
- Funciones [lambda](https://www.w3schools.com/python/python_lambda.asp)



Una función `lambda` nos permite definir un función en una sola línea, de manera muy concisa. Por otro lado, los `generadores` son tipos de funciones muy útiles a la hora de definir nuestros propios `iteradores`.

## Recursos

- [Post](https://juansensio.com/blog/004_python_funciones)
- [Funciones](https://docs.python.org/3/library/functions.html)
- Más [funciones](https://www.w3schools.com/python/python_functions.asp)
- Funciones [lambda](https://www.w3schools.com/python/python_lambda.asp)



Durante la ejecución de nuestro código es posible que no todo vaya siempre como esperamos. Ser capaces de anteponernos a posibles errores y responder de la manera adecuada ante ellos hará que nuestros programas sean más robustos y no se queden "colgados" cuando algo vaya mal.

## Recursos

- [Exceptions](https://docs.python.org/3/library/exceptions.html)
- [Errores](https://docs.python.org/3/tutorial/errors.html)
- Tipos de [errores](https://www.tutorialspoint.com/python/python_exceptions.htm)



Los módulos de Python nos permiten tener nuestro código separado y organizado en diferentes documentos, permitiéndonos a su vez `importar` toda la funcionalidad que necesitemos desde nuestro programa.

Puedes crear tus propios módulos, utilizar los que ya vienen implementados por defectos en `Python` (la `STL`, o librería estándar) o bien instalar cualquier módulo de terceros mediante el comando `pip install`.

En cualquier caso es muy probable que ya exista una solución a tu problema, por lo que te recomiendo que inviertas un poco de tiempo en investigar los módulos disponibles y probarlos antes de intentar implementar algo desde cero por tu cuenta.



Aquí tienes el [código](https://colab.research.google.com/drive/143wQyfQzM2T4wJgg4ns9G4Y2M0DD2HBS?usp=sharing), pero intenta hacerlo primero por tu cuenta ! 🙃



Si bien las `funciones` nos permiten organizar nuestro código y encapsular piezas de funcionalidad que podemos reutilizar, podemos ir un paso mas allá y definir nuestras propias `clases`. Esto nos permitirá instanciar objetos con `métodos` y `atributos` que lleven a cabo unas acciones determinadas con una interfaz simple.

## Recursos

- [OOP](https://en.wikipedia.org/wiki/Object-oriented_programming)
- Python [OOP](https://www.tutorialspoint.com/python/python_classes_objects.htm)



Aprendemos a definir nuestras propias clases, con sus métodos y atributos.

## Recursos

- [Clases](https://docs.python.org/3/tutorial/classes.html)



La sobrecarga de operadores nos permite definir el comportamiento de nuestros objetos al aplicarles los operadores comunes que encontramos en Python.

## Recursos

- [Data model](https://docs.python.org/3/reference/datamodel.html)
- [Sobrecargas de operadores](https://pythonprogramming.net/operator-overloading-intermediate-python-tutorial/)



Ponemos en práctica lo que hemos aprendido implementando una lista de contactos con clases.



La herencia nos permite crear clases a partir de otras, heredando todos sus métodos y atributos.

## Recursos

- [Herencia](https://docs.python.org/3/tutorial/classes.html#inheritance)
- Herencia [múltiple](https://en.wikipedia.org/wiki/Multiple_inheritance)



Mejoramos nuestra lista de contactos, utilizando la herencia para crear diferentes tipos de contactos.


Lista de Contactos (Herencia) y Proyecto final


Ahora que ya conocemos un lenguaje de programación, recuperamos los algoritmos que vimos al principio del curso para empezar a implementarlos.



La complejidad temporal de un algoritmo, notación _big O_, nos dará una idea del número de iteraciones, o tiempo, que requerirá un algoritmo para llevar a cabo una tarea determinada en el peor de los casos.



Implementamos el algoritmo de búsqueda lineal.



Implementamos el algoritmo de búsqueda binaria.



En este video visualizamos diferentes algoritmos de ordenado.



Cuando hablamos de estructuras de datos nos referimos a la manera en la que organizamos nuestros datos para poder utilizarlos de forma eficiente. Hemos visto ya algunos ejemplos de estructuras de datos que vienen implementadas en Python por defecto, como la lista o el dict, pero ahora vamos a ver otros ejemplos que nos serán muy útiles en ciertas circunstancias.

## Recursos

- [Estructuras de datos](https://www.tutorialspoint.com/python_data_structure/) en Python.



Una _linked list_ es una estructura muy similar a la lista de Python, pero más eficiente a la hora de añadir o eliminar elementos. Por contra, será menos eficiente a la hora de indexar valores.



Implementamos una _linked list_ en Python.



Un _binary search tree_ nos permite tener nuestros datos ordenados en un árbol de manera que hacer una búsqueda sea muy eficiente.



Implementamos un ejemplo de _binary search tree_ en Python.



Un grafo es un conjunto de nodos conectados entre sí que nos permite diseñar arquitecturas muy complejas, como `redes neuronales`.



Felicidades por completar el curso 🎉🎉🎉 Te propongo terminar con la implementación de un juego de [tres en raya](https://medium.com/byte-tales/the-classic-tic-tac-toe-game-in-python-3-1427c68b8874) en el que tendrás que aplicar todo lo aprendido. Una vez lo tengas terminado, me gustaría que lo compartas conmigo y el resto de la comunidad en discord, simplemente compartiendo el link a tu repositorio de Github. Como bonus, te propongo implementar el juego usando la librería [PyGame](https://www.pygame.org/news), para hacer tu juego todavía más interactivo.

Espero que hayas aprendido mucho con este curso y que puedas aplicar tus conocimientos en tu día a día. Si quieres seguir aprendiendo, te recomiendo que eches un vistazo al resto de cursos disponibles y que sigas la actividad en el canal de Youtube. No dudes en ponerte en contacto conmigo para cualquier duda.

Un saludo, y nos vemos en el siguiente curso 🙃



Este curso está formado por los vídeos de la lista de reproducción [Producción](https://youtube.com/playlist?list=PLkgbkukKg_NpZ7VlPi5WM-wcGO5K4PEeZ) del Canal de Youtube. A continuación encontrarás los contenidos del curso:

- **Git**: En este primer tema aprenderás a utilizar el sistema de control de versión `git` y la plataforma `Github`.
- **Flask**: Seguiremos aprendiendo a usar la librería de Python `Flask` para el desarrollo de servidores WEB y que nos poermitirá servir las predicciones generadas por nuestros modelos.
- **HTML**: Empezaremos a aprender como desarrollar interfaces de usuario WEB con `HTML`.
- **CSS**: Gracias a `CSS` seremos capaces de aplicar estilos a nuestras aplicaciones WEB.
- **Javascript**: Seguiremos aprendiendo el lenguaje de programación `Javascript`, que nos permitirá dotar de interactividad a nuestras aplicaciones WEB.
- **MAPP**: Terminamos el curso viendo un ejemplo de desarollo de una aplicación que utiliza una `red neuronal` para clasificar imágenes aéreas.


En este curso aprenderás a poner a trabajar tus modelos en entornos de producción.

Producción (YT)

Flask

HTML

Javascript

En este tema desarrollamos nuestra primera aplicación web con redes neuronales

MAPP


En este vídeo introducimos la herramienta de control de versión de código `git`.



`Github` es un servicio web que nos permite alamcenar nuestros repositorios de `git` y sincronizarlos entre distintas máquinas. Además, se puede integrar con numerosos servicios lo cual simplifica enormemente el manejo de nuestras aplicaciones en producción.



[Flask](https://flask.palletsprojects.com/en/1.1.x/) es una librería de `Python` que nos facilita la vida a la hora de implementar un servidor web. Como su propio nombre indica, un servidor web es un programa que es capaz de "servir" datos a través de internet. Por ejemplo, cuando vas a google.com un servidor web te sirve la página web de google, un documento `html` que tu navegador interpreta renderizando todo el texto, imágenes y links que luego ves en la pantalla. En nuestro caso, utilizaremos un servidor para ejecutar nuestra red neuronal y devolver las predicciones calculadas.



En este video aprendemos a cargar un modelo y servir predicciones usando `Flask`.



`HTML` nos permite definir la estructura semántica de nuestras aplicaciones web.



En este video aprendemos `CSS`, la tecnología que nos permitirá dotar de estilo a nuestras aplicaciones web.



`Javascript` es el lenguaje de progrmación que nos permiten ejecutar programas en un navegador web. Nos sirve, entre otras cosas, para dotar de interactividad a nuestras aplicaciones.



En este vide aprendemos los conceptos básicos de `Javascript`.



`Javascript` nos permite manipular de manera programático los elementos de nuestras aplicaciones WEB.



En este video empezamos el desarrollo de _MAPP_, nuestra aplicación web que se comunicará con el servidor `Flask`.



Implementamos la lógica de nuestra aplicación _MAPP_.



Terminamos el curso aprendiendo como podemos llevar a cabo las predicciones directamente en nuestro navegador, haciendo así inecesario nuestro servidor `Flask`.


Inteligencia Artificial desde Cero en Castellano 🚀

Análisis de Datos (YT)

Deep Learning (YT)

Introducción a la Computación con Python

Producción (YT)

Puedes empezar a aprender con mi Blog o Youtube.