Python e inteligencia artificial
¡Este es el curso de Python donde no solo te vas a convertir en un programador de Python, si no que también vas a entender y a usar la inteligencia artificial!
¿Tienes curiosidad sobre la inteligencia artificial? ¿Te gustaría saber qué es? ¿Te gustaría crear tu propia inteligencia artificial? ¡Estás en el lugar adecuado! En este curso vas a ser capaz de crear diferentes modelos para generalizar los datos. Además construiremos varios proyectos con los cuales aprenderás Python.
Además pulsando aquí, o con este enlace (https://discord.gg/wfWbzDYpc8), podrás acceder al servidor de discord donde, aparte de comunicarte con el profesor para preguntar dudas, tendrás ejercicios extra, más proyectos, foros...
Proyectos
Durante el curso se construirán varios programas y se llevarán a cabo varios proyectos. Estos serán:
- Programa para detectar números primos: Para entender las bases de Python.
- Programa para mostrar los múltiplos de un número: Para entender los bucles en Python.
- Programa para mostrar los divisores de un número: Para entender las condiciones en Python.
- Programa para crear una terminal: Para entender las bases de Python.
- Programa para crear listas enlazadas: Para aprender a usar la programación orientada a objetos.
- Programa para manejar datos: Para aprender a usar pandas, numpy y mejorar nuestro entendimiento de las clases en Python
- Inteligencia artificial basada en Naive Bayes: Para entender los modelos basados en naive bayes y mejorar nuestro uso de la librería numpy.
- Inteligencia artificial basada en K-NN: Para entender los modelos basados en K-NN y mejorar nuestro uso de la librería numpy.
- Inteligencia artificial basada en Redes neuronales: Para entender los modelos basados en las redes neuronales, mejorar nuestro uso de la librería numpy.
- Notebook comparando SKLearn y nuestra implementación.
- Programas que implementen con y sin recursividad diferentes estructuras de datos.
- Funciones que implementen los algoritmos de ordenación merge sort y quick sort.
- Funciones que implementen los algoritmos de búsqueda Breadth first search (BFS) y Depth first search (DFS).
Desbloquea Todo el Contenido
Accede a cursos ilimitados, ejercicios premium y certificaciones oficiales
- Ordenador capaz de ejecutar Visual Studio Code y que soporte Python 3.9. (Mi recomendación es Windows 10, Windows 11, Mac OS y Ubuntu 18 o superior)
- Ganas de aprender.
- Este curso es para todos los niveles. No hace falta que sepas nada de programación, inteligencia artificial, o ciencia de datos.
- Para aquellos que quieran aprender Python
- Para aquellos que quieran reforzar su conocimiento de la inteligencia artificial.
- Para aquellos en búsqueda de oportunidades laborales en el mundo de la tecnología.
- Mi principal objetivo es que tras el curso seas capaz de crear programas con Python y puedas crear una inteligencia artificial
- Tras el curso tengas una base sólida de lo que es la programación, permitiéndote aprender otros lenguajes de programación con facilidad.
- Aprendas a usar sockets e hilos.
- Aprendas a usar la librería Pandas.
- Aprendas a usar la librería Numpy.
- Aprendas a usar la librería SKLearn.
- Aprendas a usar Notebooks.
- Comprenderás los modelos actuales que usan aprendizaje automático. Estos son: Naive Bayes, K-NN y Redes neuronales.
- Comprenderás las estructuras de datos más usadas como la pila, cola y los árboles binarios.
- Comprenderás cómo funcionan los algoritmos de ordenación como merge sort y quick sort.
- Comprenderás cómo funcionan los algoritmos de búsqueda como Breadth first search (BFS) y Depth first search (DFS).
¿Quién soy?
0 horas 2 minutos 2 segundos
¿Cómo usar discord?
0 horas 6 minutos 19 segundos
Instalar anaconda
0 horas 1 minutos 33 segundos
Instalar VSCode
0 horas 2 minutos 31 segundos
¿Qué son las variables?
0 horas 5 minutos 32 segundos
Practicando con enteros
0 horas 3 minutos 19 segundos
Practicando con decimales
0 horas 1 minutos 48 segundos
Practicando con strings
0 horas 3 minutos 42 segundos
Operaciones
0 horas 4 minutos 19 segundos
Listas
0 horas 8 minutos 17 segundos
Diccionarios
0 horas 5 minutos 41 segundos
Ejercicio
0 horas 7 minutos 4 segundos
if
0 horas 4 minutos 56 segundos
Comparaciones
0 horas 3 minutos 52 segundos
Puertas lógicas
0 horas 5 minutos 8 segundos
Asignación condicional
0 horas 2 minutos 43 segundos
Bucle while
0 horas 4 minutos 45 segundos
Bucle for
0 horas 3 minutos 8 segundos
Break y continue
0 horas 5 minutos 0 segundos
Ejercicio. Múltiplos
0 horas 4 minutos 45 segundos
Ejercicio. Divisores
0 horas 4 minutos 59 segundos
Ejercicio. Primos
0 horas 9 minutos 3 segundos
Base de la terminal
0 horas 4 minutos 29 segundos
Comando para operar
0 horas 4 minutos 33 segundos
Manejar errores
0 horas 1 minutos 33 segundos
Guardar datos en un diccionario
0 horas 5 minutos 21 segundos
Guardar y cargar datos en un archivo
0 horas 7 minutos 30 segundos
Sentencia with
0 horas 3 minutos 13 segundos
Cast
0 horas 3 minutos 50 segundos
Guardar comandos
0 horas 2 minutos 54 segundos
Funciones y scope
0 horas 8 minutos 20 segundos
Scope
0 horas 4 minutos 24 segundos
Return
0 horas 6 minutos 29 segundos
¿Qué es una clase?
0 horas 2 minutos 20 segundos
Creamos una clase
0 horas 2 minutos 40 segundos
Atributos y constructor
0 horas 8 minutos 45 segundos
Métodos
0 horas 1 minutos 38 segundos
Atributos estáticos
0 horas 3 minutos 4 segundos
Herencia
0 horas 5 minutos 13 segundos
Ejercicio. Nodo
0 horas 7 minutos 35 segundos
Ejercicio. Lista
0 horas 3 minutos 55 segundos
Filter, map y lambdas
0 horas 7 minutos 52 segundos
Listas por comprensión
0 horas 3 minutos 6 segundos
Diccionarios por comprensión
0 horas 6 minutos 0 segundos
Comprensiones condicionales
0 horas 3 minutos 26 segundos
Datos
0 horas 1 minutos 59 segundos
Pandas
0 horas 6 minutos 5 segundos
Adaptamos los datos
0 horas 3 minutos 36 segundos
Matplotlib
0 horas 5 minutos 27 segundos
Notebook
0 horas 5 minutos 3 segundos
Escribiendo un notebook
0 horas 5 minutos 4 segundos
Ejemplo SKLearn
0 horas 4 minutos 27 segundos
Atributos discretos y continuos
0 horas 6 minutos 12 segundos
Clase datos, atributos discretos
0 horas 10 minutos 45 segundos
Diccionario para valores discretos
0 horas 9 minutos 38 segundos
Numpy, datos
0 horas 10 minutos 4 segundos
Resumen
0 horas 7 minutos 57 segundos
Probabilidad de las clases
0 horas 11 minutos 15 segundos
Matriz de probabilidad condicional
0 horas 5 minutos 23 segundos
Probabilidad condicional de atributos discretos
0 horas 18 minutos 18 segundos
Media y varianza
0 horas 7 minutos 8 segundos
Casificamos
0 horas 10 minutos 57 segundos
Error
0 horas 4 minutos 26 segundos
Como implementar KNN
0 horas 5 minutos 46 segundos
Clase clasificador
0 horas 2 minutos 55 segundos
Creando la clase KNN
0 horas 2 minutos 48 segundos
Contando número de clases
0 horas 0 minutos 59 segundos
Funciones de distancia
0 horas 5 minutos 59 segundos
Calculando la distancia
0 horas 7 minutos 0 segundos
K más cercanos
0 horas 6 minutos 7 segundos
Obtenemos la clase más alta
0 horas 7 minutos 27 segundos
¿Qué es una red neuronal?
0 horas 8 minutos 14 segundos
Diagrama de clases
0 horas 5 minutos 24 segundos
Clase red neuronal
0 horas 9 minutos 57 segundos
Clase capa
0 horas 6 minutos 26 segundos
Clase neurona
0 horas 7 minutos 33 segundos
Clase conexión y test
0 horas 8 minutos 15 segundos
Método str
0 horas 8 minutos 36 segundos
Función sigmoide
0 horas 3 minutos 41 segundos
Algoritmo de retropropagación
0 horas 9 minutos 18 segundos
Delta salida
0 horas 8 minutos 4 segundos
Delta capas ocultas
0 horas 8 minutos 53 segundos
Incremento pesos
0 horas 6 minutos 21 segundos
Tests con puertas lógicas
0 horas 5 minutos 30 segundos
Métodos entrenar y clasificar
0 horas 9 minutos 39 segundos
Comparando modelos
0 horas 7 minutos 19 segundos
SKLearn
0 horas 13 minutos 9 segundos
¿Qué son los sockets?
0 horas 3 minutos 44 segundos
Creando el servidor
0 horas 8 minutos 54 segundos
Creando el cliente
0 horas 3 minutos 28 segundos
Hilos
0 horas 6 minutos 45 segundos
Trabajos con Python y Django
0 horas 2 minutos 0 segundos
Introducción
0 horas 1 minutos 3 segundos
Concepto de la cola
0 horas 1 minutos 36 segundos
Añadir elementos a una cola
0 horas 8 minutos 42 segundos
Quitar elementos de una cola
0 horas 4 minutos 5 segundos
Cola funciones recursivas
0 horas 5 minutos 30 segundos
Añadir elementos a una cola (clases)
0 horas 5 minutos 17 segundos
Eliminar elementos de una lista (clase)
0 horas 3 minutos 51 segundos
Concepto de la Pila
0 horas 2 minutos 35 segundos
Pila con bucles
0 horas 5 minutos 36 segundos
Pila con funciones recursivas
0 horas 4 minutos 6 segundos
Pila (clases)
0 horas 4 minutos 2 segundos
Concepto árbol binario
0 horas 1 minutos 47 segundos
Creamos un árbol binario
0 horas 7 minutos 37 segundos
Heaps
0 horas 3 minutos 19 segundos
Max heaps
0 horas 3 minutos 34 segundos
AVL
0 horas 4 minutos 12 segundos
Árbol binario representado en un array
0 horas 7 minutos 33 segundos
Explicación del algoritmo merge sort
0 horas 4 minutos 43 segundos
Complejidad de merge sort
0 horas 1 minutos 10 segundos
Código merge sort
0 horas 10 minutos 31 segundos
Explicación del algoritmo quick sort
0 horas 4 minutos 27 segundos
Complejidad de Quick sort
0 horas 4 minutos 55 segundos
Código Quick sort
0 horas 8 minutos 39 segundos
Heap
0 horas 1 minutos 18 segundos
Creamos la clase
0 horas 6 minutos 49 segundos
Heapify up
0 horas 8 minutos 12 segundos
Heapify down
0 horas 9 minutos 26 segundos
Arreglo heapify down
0 horas 1 minutos 40 segundos
Insertar y pop
0 horas 5 minutos 30 segundos
Arreglo pop
0 horas 1 minutos 33 segundos
Algoritmos de búsqueda
0 horas 3 minutos 5 segundos
Algoritmo BFS
0 horas 2 minutos 16 segundos
Implementamos BFS
0 horas 6 minutos 48 segundos
Algoritmo DFS
0 horas 2 minutos 24 segundos
Implementamos DFS
0 horas 2 minutos 1 segundos