Billy ClassTime's Blog

Usando la GPU en Jupyter Notebook con red LAN

Tue, 14 Jan 2025 15:06:21 GMT

Usando la GPU en Jupyter Notebook con red LAN

¿Sabías que puedes usar la GPU de un ordenador potente mientras trabajas desde otro que no tenga GPU?

!Hoy aprenderaras hacerlo con Jupyter Notebook!

Así que prepárate para usar la potencia de tu GPU sin estar frente a la máquina que la tiene.

Todo desde otro ordenador en tu red local. ¡Vamos allá!

1: Prepara tu entorno con Anaconda

Si no tienes Anaconda instalado, ve a su página oficial y sigue las instrucciones. Una vez lo tengas, crea un entorno virtual para gestionar las dependencias:conda create -n gpu_env python=3.8

Actívalo con: conda activate gpu_env

Este paso asegura que todo se instala de forma ordenada, sin interferir con otros proyectos.

2: Instala las librerías necesarias

Ahora que tenemos el entorno, vamos a instalar CuPy para aprovechar la GPU y Jupyter Notebook:

conda install -c conda-forge cupy jupyter

Con esto, tienes todo listo para correr operaciones matemáticas en la GPU.

3: Configura Jupyter para acceso remoto

Para acceder al Notebook desde el otro ordenador, necesitamos configurar Jupyter para que acepte conexiones remotas. Genera el archivo de configuración con:

jupyter notebook --generate-config

Ahora edita el archivo jupyter_notebook_config.py (lo puedes encontrar en ~/.jupyter/ en Linux o en C:\Users\<TuUsuario>\.jupyter\ en Windows) y busca la línea:

# c.NotebookApp.ip = 'localhost'

Cámbiala a:

c.NotebookApp.ip = '0.0.0.0'

Esto permitirá que cualquier ordenador en tu red acceda a tu Jupyter Notebook.

4: Comprobar que la GPU está activa

Antes de ponernos a trabajar, vamos a asegurarnos de que CuPy está utilizando la GPU. Solo corre este pequeño código en tu notebook:

import cupy as cp

# Verifica si CuPy está usando la GPU
print("¿CuPy está usando la GPU?", cp.cuda.is_available())

Si todo está bien configurado, debería devolverte True. Si no, asegúrate de que los drivers de tu GPU y CUDA están correctamente instalados.

5: Crear la explosión de números

¡Es hora de hacer algo divertido! En tu Jupyter Notebook, escribe este código para crear una "explosión" de números, multiplicando una gran matriz en la GPU:

import cupy as cp
import time

# Crear una matriz de números aleatorios
size = 25000 #Esto es aproximadamente 6.27 GB de información
matrix = cp.random.rand(size, size)

# Multiplicación masiva
start_time = time.time()
result = cp.dot(matrix, matrix)
end_time = time.time()

print(f"Operación realizada en la GPU en {end_time - start_time} segundos.")

Aunque parece algo sencillo, la GPU hará el trabajo mucho más rápido que la CPU. ¡Siente el poder de la tecnología!

6: Acceder desde otro ordenador

Para acceder desde el otro ordenador, solo abre el navegador y escribe la IP del primer ordenador (el que tiene la GPU), por ejemplo:http://<ip-del-primer-ordenador>:8888/

Hemos utilizado otro ordenador de la LAN con el código del punto 5, que ha tardado 0.6279 segundos en mostrarnos el resultado!

Nota Final

¡Y ahí lo tienes! Usando Anaconda, un entorno virtual, y CuPy, has creado una explosión de números en la GPU, todo desde otro ordenador conectado a tu red local. Es una forma increíble de aprovechar la potencia de tu hardware y compartir recursos en tu red LAN.

Recuerda siempre verificar la configuración de red y seguridad para que todo funcione correctamente. Y si te quedas con ganas de más, explora las infinitas posibilidades que ofrece la GPU para tus proyectos.

¡Feliz programación!❤️😀

This weblog is sponsored by Billy ClassTime's Blog.

Algoritmo para factorizar N

Mon, 23 Dec 2024 15:51:27 GMT

Algoritmo para factorizar N

En este artículo, vamos a explorar un algoritmo para factorizar un número N.

La factorización de un número es un proceso fundamental en matemáticas y ciencias de la computación, ya que nos permite descomponer un número en sus factores primos o divisores. Aunque puede parecer una tarea sencilla, existen varios enfoques y optimizaciones que pueden hacerla más eficiente, especialmente cuando el número N es grande.

Análisis y Diseño del Algoritmo

Para diseñar este algoritmo, comenzamos por identificar que, en lugar de verificar todos los números hasta N, podemos reducir la búsqueda de divisores hasta la raíz cuadrada de N. Esto se debe a que si N tiene un divisor mayor que su raíz cuadrada, el otro divisor será menor, por lo que no es necesario seguir buscando más allá de ese punto.

A partir de allí, implementamos un ciclo que va desde 2 hasta la raíz cuadrada de N, dividiendo N por cada número en ese rango. Si encontramos que la división es exacta, guardamos el divisor y seguimos buscando.

Este algoritmo no solo es eficiente, sino que también es fácil de implementar. A lo largo del artículo, proporcionamos un diagrama de flujo y un pseudocódigo que ilustran claramente cada paso del proceso.

¡Vamos a profundizar en cómo podemos poner este algoritmo en práctica!

Definición de factorización (Entender el problema)

La factorización de un número es el proceso de descomponerlo en un conjunto de factores que, multiplicados entre sí, dan como resultado el número original. Estos factores pueden ser cualquier tipo de números enteros, no necesariamente primos, y pueden ser números compuestos o incluso el mismo número 1.

Cuando hablamos de factorización en un sentido amplio, podemos referirnos a todas las maneras en que un número puede expresarse como un producto de factores enteros. Pero no todas esas expresiones se consideran "factorizaciones completas" o "factorizaciones fundamentales", ya que algunas de ellas no son tan informativas desde una perspectiva matemática.

1. Factorización de un número en términos de factores enteros:

En un sentido más general, cualquier número entero positivo puede ser factorizado en productos de factores enteros. Para 12, los factores enteros de 12 serían: Es decir, estamos descomponiendo 12 en una variedad de productos de números enteros.

2. Factorización completa (o trivial):

Sin embargo, normalmente se habla de factorización completa o factorización no trivial cuando estamos buscando factores que no sean simplemente el número mismo (12) ni el 1. Si sólo tomamos las factorizaciones no triviales, entonces las posibles factorizaciones de 12 son:

3. Factorización prima:

Este es el caso más específico, donde buscamos descomponer un número en factores primos. La factorización prima de 12 es:

aquí estamos descomponiendo 12 hasta sus bloques fundamentales, que son los números primos.

¿Cómo encontrar todos los divisores de un número `N` en la factorización de números enteros y completa?

Calcular la raíz cuadrada de N:
- Calculamos la raíz cuadrada de N, solo necesitamos probar divisores hasta el valor entero de la raíz cuadrada.
- Por ejemplo, para N=45, la raíz cuadrada de 45 es aproximadamente 6.7082. Por lo tanto, solo necesitamos probar los números desde 2 hasta 6 (la raíz cuadrada entera de 45).
Probar divisores:
- Probamos todos los números desde 2 hasta la raíz cuadrada entera de N para ver si dividen exactamente a N (sin dejar residuo).
- Si encontramos que (es decir, d es un divisor y q es el cociente), entonces d y q son factores de N.
Ejemplo con 45:
- La raíz cuadrada de 45 es aproximadamente 6.7082, así que solo necesitamos probar los divisores hasta 6.
- Dividimos 45 entre los números 2,3,4,5,6:
  - 45 ÷ 2 = 22.5 (no es un divisor exacto).
  - 45 ÷ 3 = 15 (es un divisor exacto).
  - 45 ÷ 4 = 11.25 (no es un divisor exacto).
  - 45 ÷ 5 = 9 (es un divisor exacto).
  - 45 ÷ 6 = 7.5 (no es un divisor exacto).
- Los divisores que encontramos son 3 ,15, 5 y 9.
- También incluimos en la respuesta al 1 y a 45

Diagrama de flujo

Pseudo código

Start

obtain N  
calculate DivisionLimit = Floor(SquareRoot(N))  
set CurrentDivisor = 2  

repeat-until CurrentDivisor > DivisionLimit  
  if CurrentDivisor <= DivisionLimit then  
    calculate PossibleDivisor = N / CurrentDivisor  

    if PossibleDivisor == IntegerPart(N / CurrentDivisor) then  
      save CurrentDivisor and PossibleDivisor as divisors  
    else  
      calculate CurrentDivisor = CurrentDivisor + 1  
    end-if  
  else  
    calculate CurrentDivisor = CurrentDivisor + 1  
  end-if  
repeat-until wrong  

display 1, N, and the divisors found  

End

Análisis Temporal (Big O para el tiempo de ejecución)

El algoritmo implica los siguientes pasos principales:

Calcular la raíz cuadrada de N:
- Esto se puede hacer en tiempo O(log ⁡N), porque la mayoría de los métodos modernos para calcular raíces cuadradas utilizan iteraciones logarítmicas (e.g., método de Newton).
Probar divisores desde 1 hasta la raíz cuadrada entera de N
- Este es el paso más importante. El algoritmo itera desde 1 hasta la raíz cuadrada de N, es decir: lo que requiere: iteraciones.
- En cada iteración, verificamos si Nes divisible por el divisor actual (d), lo cual implica una operación O(1) (la división es una operación constante).
Por lo tanto, este paso tiene complejidad:
Registrar los pares de divisores:
- Por cada divisor dencontrado, el cociente N/d se calcula y se guarda. Esto también es una operación O(1) por divisor.
- Como máximo, encontramos la raíz cuadrada entera de Nde divisores (en pares), por lo que este paso también tiene un costo de .
En total, la complejidad temporal del algoritmo es: porque el cálculo de divisores domina el tiempo de ejecución.

Análisis Espacial (Big O para el uso de memoria)

El algoritmo requiere almacenar los divisores encontrados y sus correspondientes pares. Analicemos esto:

Espacio para los divisores:
- En el peor caso, el número total de divisores de un número Nes aproximadamente Esto ocurre porque cada divisor menor que la raíz cuadrada de N tiene un par correspondiente mayor que la raíz cuadrada de N
Variables auxiliares:

El algoritmo utiliza variables para N, d (el divisor actual), la lista de divisores, y posiblemente otras variables para los resultados. Todas estas requieren espacio constante adicional (O(1)).

Por lo tanto, la complejidad espacial total del algoritmo es: principalmente para almacenar los divisores).

Ponemos datos al análisis temporal y espacial del Big O

Análisis temporal, número de procesos necesarios

Para calcular los divisores de:

Raíz cuadrada de N
- La raíz cuadrada entera de ⌊4530940⌋=2129 (redondeamos hacia abajo).
Iteración hasta 2129
- El algoritmo prueba cada número entero d desde 1 hasta 2129
- Para cada d
  - Se verifica si N mod d=0 (Operación de residuo)
  - Si d es un divisor, se calcula su par complementario N/d-
- En el peor caso, se realizan 2129divisiones y verificaciones del residuo.
Divisores complementarios:
- Para cada divisor d encontrado, el divisor complementario N/d también se registra si es diferente de d.
Por ejemplo, si d=1, el complemento es 4530940, y si d=2, el complemento es 2265470.
Número total de operaciones:
- En cada iteración, realizamos una división y verificamos divisibilidad. Esto resulta en operaciones.
- Cada divisor tiene un complemento, así que el número total de divisores registrados puede llegar a 2 x cantidad de divisores únicospara N = 4530940, estos divisores naturales son: en total 18 divisores, considerando complementos.

Número final de operaciones
- Operaciones de divisibilidad: 2129
- Cálculos de divisores complementarios: ≤ número de divisores naturales.
- Total: 2129 operaciones dominantes

Análisis espacial (Uso de la memoria)

Almacenamiento de divisores naturales:

Como buscamos todos los divisores, debemos guardar cada divisor d y su complemento N/d.
Si hay D divisores únicos, el almacenamiento será 2D.

En este caso, D=9, por lo que:

2D×4 bytes (por entero) =18 × 4 = 72 bytes

Variables auxiliares:

N, d, raíz cuadrada(N): 3 x 4bytes = 12bytes.

Memoria total requerida:

Divisores: 72 bytes-
Variables auxiliares: 12 bytes-
Total: 84 bytes.

Nota final

En este artículo hemos explorado un proceso simple para encontrar los divisores de un número entero N, de forma eficiente, A través del análisis previo (revisando los conceptos matemáticos al rededor de este tema), detallamos cómo utilizar la raíz cuadrada de N para establecer un límite en el cual buscar divisores. Luego, podemos ver todo el proceso de cómo dividir N por un número i (empezando desde 2) y verificar si la división produce un número entero, lo que indica que i es un divisor de N.

A lo largo de esta explicación, proporcionamos un diagrama de flujo para visualizar el proceso paso a paso, mejorando la comprensión del algoritmo. También ajustamos los nombres de las variables para hacerlos más intuitivos y alineados con el propósito de encontrar divisores de un número.

Al final hacemos el análisis temporal y espacial bajo la notación Big O, para poner datos a la eficiencia del resultado.

En el mundo de la informática, entender cómo manipular números y aplicar algoritmos sencillos como este es clave para resolver problemas más complejos.

Feliz programación! ❤️😀

This weblog is sponsored by Billy ClassTime's Blog.

Entendiendo BIG O Temporal

Sat, 30 Nov 2024 09:40:26 GMT

Entendiendo el análisis BIG O Temporal

El análisis de Big O puede parecer algo abstracto y, a veces, difícil de aplicar de inmediato, especialmente cuando no tienes mucha experiencia con ello. Afortunadamente, con práctica y un enfoque sistemático, puedes mejorar considerablemente tu capacidad para identificar la complejidad algorítmica y determinar qué tan eficiente es un código.

Estrategias y pasos prácticos para mejorar tu habilidad en el análisis de complejidad Big O y hacer que se vuelva más natural para ti:

1. Entiende los patrones comunes de complejidad temporal

Una de las primeras cosas que debes hacer es familiarizarte con los patrones más comunes de complejidad de tiempo.

Algunos ejemplos son:

O(1) - Tiempo constante: El tiempo de ejecución no depende del tamaño de la entrada. Un ejemplo clásico es el acceso a un elemento de una lista por índice.
```
def get_first_element(lst):
    return lst[0]
```
O(n) - Tiempo lineal: El tiempo de ejecución es directamente proporcional al tamaño de la entrada. Un ejemplo es recorrer una lista de tamaño n:
```
def print_elements(lst):
    for elem in lst:
        print(elem)
```

O(n^2) - Tiempo cuadrático: El tiempo de ejecución se incrementa cuadráticamente a medida que aumenta el tamaño de la entrada. Un ejemplo típico es un algoritmo de ordenación como burbuja o selección:

def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(i+1, len(arr)):
            if arr[i] > arr[j]:
                arr[i], arr[j] = arr[j], arr[i]

O(log n) - Tiempo logarítmico: El tiempo de ejecución crece logarítmicamente con el tamaño de la entrada. Un ejemplo es la búsqueda binaria:

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

O(n log n) - Tiempo logarítmico lineal: El tiempo de ejecución crece más rápido que O(n), pero no tan rápido como O(n^2). Algunos algoritmos eficientes de ordenación, como quicksort o mergesort, tienen esta complejidad.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

Si te familiarizas con estos patrones, te será mucho más fácil ver la estructura de un algoritmo y deducir su complejidad.

2. Analiza paso a paso

Cuando veas un código, intenta desglosarlo en partes más pequeñas para poder analizar su complejidad. Aquí hay una estrategia paso a paso:

Identifica las operaciones principales: ¿Cuáles son las partes del código que más tiempo podrían llevar? Por lo general, estas son las iteraciones (bucles) o las llamadas a funciones recursivas.
Cuenta las iteraciones: Mira los bucles y determina cuántas veces se ejecutan:
- Un solo bucle que recorre un conjunto de n elementos tiene O(n).
- Un bucle anidado, donde un bucle recorre n y dentro otro bucle recorre n, tiene O(n^2).
Identifica las funciones recursivas: Si el algoritmo usa recursión, como en los casos de algoritmos de divide y vencerás, observa cuántas veces se llama a la función en cada nivel de la recursión. Esto puede ayudarte a identificar si el algoritmo es O(log n), O(n log n), o incluso O(2^n) (como en el caso de ciertos algoritmos de fuerza bruta recursiva).
Suma las complejidades: Si tienes varias operaciones independientes (por ejemplo, un bucle seguido de una función), suma las complejidades. Sin embargo, si una operación tiene complejidad O(n) y la siguiente tiene complejidad O(n^2), la complejidad total será O(n^2), porque los términos de mayor orden dominan.
Considera las operaciones constantes: A veces, hay partes del código que se ejecutan solo una vez (como una asignación de valor o un cálculo constante). Estas son O(1) y no afectan significativamente la complejidad general.

3. Practica con ejemplos sencillos y luego con más complejidad

Para mejorar, la clave es practicar con ejemplos sencillos y luego ir aumentando la complejidad gradualmente. Aquí te dejo algunas ideas para mejorar tus habilidades analíticas:

Empieza con ejercicios simples:
- ¿Qué pasa si tienes un bucle que recorre una lista? ¿O si tienes dos bucles anidados?
- ¿Qué pasa si dentro de esos bucles haces una operación constante?
Haz ejercicios de análisis de algoritmos:
- Toma algoritmos comunes (por ejemplo, búsqueda lineal, búsqueda binaria, ordenación por inserción) y analiza su complejidad.
- En sitios como LeetCode, HackerRank o CodeWars, puedes encontrar problemas donde se te piden tanto las soluciones como las complejidades.
Lee y analiza el código de otros: Ver cómo otros programadores piensan sobre la complejidad te ayudará a desarrollar tu propio estilo de análisis. Además, analizar código ya optimizado te enseñará buenas prácticas.

4. Estudia ejemplos de análisis de Big O

Aquí tienes algunos ejemplos comunes de análisis de algoritmos y sus complejidades:

Búsqueda lineal (O(n)):

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

Búsqueda binaria (O(log n)):

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

Ordenación por burbuja (O(n^2)):

def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(0, len(arr) - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

Merge sort (O(n log n)):

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0

        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

5. Herramientas y recursos adicionales

Visualizadores de Big O: Hay herramientas como Big-O Calculator (en línea) o visualizadores de complejidad que te pueden ayudar a entender cómo cambian las complejidades con el tamaño de la entrada.
Cursos: Si tienes tiempo, hay excelentes recursos en plataformas como Coursera o edX, o incluso videos en YouTube, que explican el análisis de la complejidad y te guían a través de ejemplos prácticos.

Notal Final:

Familiarízate con las complejidades más comunes.
Desglosa el código paso a paso y cuenta cuántas veces se ejecutan las operaciones.
Practica mucho con ejercicios, lee y analiza código.
Aumenta gradualmente la dificultad y usa herramientas de análisis si es necesario.
No te preocupes por las fluctuaciones al principio; lo importante es acostumbrarte al proceso y seguir practicando.

Al principio puede parecer difícil, pero con práctica, ¡serás capaz de identificar la complejidad de casi cualquier

¡Feliz programación!❤️😀

This weblog is sponsored by Billy ClassTime's Blog.

Entendiendo BIG O espacial

Sat, 30 Nov 2024 07:35:54 GMT

Entendiendo el análisis BIG O espacial

El análisis de la complejidad espacial es tan importante como el análisis temporal, y tiene que ver con cuánta memoria (o espacio) consume un algoritmo en función de la entrada. Al igual que con la complejidad temporal, se mide en notación Big O y se analiza la forma en que el uso de la memoria crece con el tamaño de los datos de entrada.

Enfoque general para analizar la complejidad espacial

Identifica las estructuras de datos utilizadas: Las estructuras de datos como listas, diccionarios, conjuntos, pilas, colas, matrices, etc., ocupan diferentes cantidades de memoria según su tamaño. Si un algoritmo usa estructuras de datos dinámicas que pueden crecer, esto afecta directamente su complejidad espacial.
Considera el espacio adicional utilizado: Algunas operaciones pueden requerir espacio adicional. Por ejemplo, si tienes una lista y haces una copia de ella, estarás usando O(n) espacio adicional.
Observa las variables temporales: A veces las variables que se crean dentro de las funciones o los bucles pueden ocupar espacio adicional, aunque esto no siempre se refleja en la complejidad Big O si la cantidad de espacio utilizado no depende del tamaño de la entrada.
Recursión: En algoritmos recursivos, la memoria adicional utilizada por la pila de llamadas también debe ser considerada. La profundidad de la recursión es un factor importante para entender la complejidad espacial de estos algoritmos.

1. Entiende los patrones comunes de complejidad espacial

Al igual que con la complejidad temporal, existen patrones comunes en el análisis de la complejidad espacial que puedes aprender para reconocer rápidamente la complejidad de diferentes algoritmos y estructuras de datos. Aquí te explico algunos de los patrones más frecuentes que te ayudarán a analizar la complejidad espacial de manera más efectiva:

1. Espacio constante O(1)

La complejidad espacial O(1) significa que el algoritmo usa una cantidad constante de memoria, independientemente del tamaño de la entrada.

Operaciones sobre datos simples: Si un algoritmo solo maneja variables simples (como enteros, cadenas, flotantes) y no crea nuevas estructuras de datos cuya memoria dependa del tamaño de la entrada, entonces tiene una complejidad espacial O(1).

Ejemplo:
```
def sum_two_numbers(a, b):
    return a + b
```
En este caso, el algoritmo utiliza una cantidad fija de memoria, independientemente de los valores de a y b, por lo que su complejidad espacial es O(1).
No hay estructuras de datos dinámicas: Si no estás usando colecciones como listas, diccionarios o sets, ni haciendo recursión, la memoria utilizada es constante.

2. Espacio lineal O(n)

La complejidad espacial O(n) ocurre cuando el espacio utilizado crece proporcionalmente al tamaño de la entrada. Esto sucede cuando el algoritmo necesita almacenar una cantidad de información que depende del tamaño de los datos de entrada.

Listas y arrays: Si el algoritmo crea una lista o array de tamaño n, donde n es el tamaño de la entrada, el espacio será O(n).

Ejemplo:
```
def create_list(n):
    lst = [0] * n  # Lista de tamaño n
    return lst
```
Aquí, el espacio utilizado es O(n) porque creamos una lista con n elementos.
Diccionarios, sets y otras colecciones: Si el algoritmo utiliza un diccionario o un set para almacenar n elementos, su complejidad espacial también será O(n).

Ejemplo:
```
def create_dict(n):
    d = {}
    for i in range(n):
        d[i] = i * 2  # Creación de un diccionario de tamaño n
    return d
```
El espacio utilizado por el diccionario d es O(n), ya que contiene n pares clave-valor.
Copias de listas: Si el algoritmo crea una copia completa de una lista o conjunto de datos de tamaño n, el espacio será O(n).
```
def copy_list(lst):
    return lst.copy()  # O(n) espacio
```

3. Espacio cuadrático O(n^2)

La complejidad espacial O(n^2) ocurre cuando el algoritmo crea una estructura de datos que crece cuadráticamente con respecto al tamaño de la entrada. Esto suele suceder cuando trabajas con matrices o cuando una estructura de datos tiene dos dimensiones.

Matrices: Si el algoritmo utiliza una matriz de tamaño n x n, el espacio utilizado será O(n^2).

Ejemplo:
```
def create_matrix(n):
    return [[0] * n for _ in range(n)]  # Matriz de tamaño n x n
```
En este caso, el espacio utilizado es O(n^2) porque la matriz tiene n filas y n columnas, lo que da lugar a n * n elementos.
Matriz de adyacencia: En gráficos representados por matrices de adyacencia, donde cada vértice está conectado a otros vértices, el espacio ocupado será O(n^2), especialmente cuando el número de vértices (n) es grande.

4. Espacio logarítmico O(log⁡ n)

La complejidad espacial O(log n) ocurre con algoritmos recursivos donde la profundidad de la recursión crece logarítmicamente con respecto al tamaño de la entrada. Esto sucede principalmente en algoritmos que dividen el problema en subproblemas más pequeños, como en los algoritmos de divide y vencerás.

Recursión: Un ejemplo típico es la búsqueda binaria, que utiliza una pila de recursión cuyo tamaño es proporcional a log(n).

Ejemplo:

def binary_search(arr, target, left, right):
    if left > right:
        return -1
    mid = (left + right) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] < target:
        return binary_search(arr, target, mid + 1, right)
    else:
        return binary_search(arr, target, left, mid - 1)

En este caso, la pila de recursión crece a medida que la entrada se divide por la mitad en cada llamada recursiva. El espacio utilizado es O(log n) debido a la profundidad de la recursión.

5. Espacio O(n log ⁡n)

Algunos algoritmos que usan la técnica de divide y vencerás tienen una complejidad espacial de O(n log n). Esto suele ocurrir cuando el algoritmo necesita almacenar o crear subestructuras a medida que divide y fusiona datos.

Algoritmos de ordenación como Merge Sort: Este algoritmo requiere espacio adicional para las sublistas que se fusionan. Aunque la complejidad temporal es O(n log n), la complejidad espacial también es O(n) debido al espacio utilizado para almacenar las sublistas durante la fusión.

Ejemplo de Merge Sort:
```
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = merge_sort(arr[:mid])
        right_half = merge_sort(arr[mid:])
        return merge(left_half, right_half)
    return arr
```
Aquí, aunque el algoritmo tiene O(n log n) en cuanto a complejidad temporal, también utiliza O(n) espacio adicional para almacenar las sublistas a medida que se dividen y se fusionan.

6. Espacio exponencial O(2^n)

La complejidad espacial O(2^n) aparece cuando el espacio utilizado crece exponencialmente con el tamaño de la entrada, lo cual es común en problemas donde se evalúan todas las combinaciones posibles de una entrada.

Algoritmos recursivos de fuerza bruta: Algoritmos como la búsqueda en el árbol de decisiones o ciertos enfoques de programación dinámica pueden generar subproblemas que se resuelven repetidamente, llevando a una complejidad espacial exponencial.

Ejemplo (fuerza bruta):
```
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
```
Aunque este ejemplo es recursivo y tiene una complejidad temporal de O(2^n), la memoria utilizada para mantener la pila de recursión también puede crecer exponencialmente.

Patrones comunes de complejidad espacial

O(1): Espacio constante. No se crean estructuras de datos que dependen del tamaño de la entrada.
O(n): Espacio lineal. Se crean listas, diccionarios, sets, o cualquier estructura que dependa del tamaño de la entrada.
O(n^2): Espacio cuadrático. Se crean matrices o estructuras de datos de dos dimensiones.
O(log n): Espacio logarítmico. Usado por algoritmos recursivos donde la profundidad de la recursión es logarítmica.
O(n log n): Espacio logarítmico lineal. Común en algoritmos de divide y vencerás como Merge Sort.
O(2^n): Espacio exponencial. Aparece en algoritmos de fuerza bruta o cuando se evalúan todas las combinaciones posibles de una entrada.

Estrategias prácticas para evaluar la complejidad espacial

A continuación poder ver algunos pasos y estrategias prácticas para analizar la complejidad espacial de un algoritmo:

1. Analizar las estructuras de datos utilizadas

Las estructuras de datos como listas, diccionarios, conjuntos, matrices, etc., ocupan diferentes cantidades de memoria. Si un algoritmo utiliza una lista de tamaño n, su complejidad espacial será O(n). Si crea una copia de esa lista, entonces estará utilizando O(2n) espacio, pero generalmente esto se simplifica a O(n).

Ejemplo de uso de espacio en listas:

def create_list(n):
    lst = []
    for i in range(n):
        lst.append(i)  # Crea una lista de tamaño n
    return lst

Aquí, la complejidad espacial es O(n) porque estamos creando una lista de tamaño n.

Ejemplo de uso de espacio en diccionarios:

def create_dict(n):
    d = {}
    for i in range(n):
        d[i] = i * 2  # Crea un diccionario de tamaño n
    return d

En este caso, el espacio utilizado por el diccionario también es O(n).

2. Considerar las variables temporales

A menudo las variables locales o temporales no influyen significativamente en la complejidad espacial si no dependen de n. Sin embargo, si estás usando listas, diccionarios u otras estructuras de datos dentro de un bucle, puedes terminar utilizando espacio adicional que crece con el tamaño de la entrada.

Por ejemplo:

def process_data(n):
    result = []
    for i in range(n):
        temp = i * 2  # Esta es una variable temporal, espacio constante O(1)
        result.append(temp)
    return result

En este caso, temp es una variable temporal cuyo espacio es O(1) (constante). Sin embargo, el result sigue ocupando O(n) espacio, ya que es una lista de tamaño n.

3. Analiza la recursión

Cuando un algoritmo utiliza recursión, debes considerar el espacio adicional que ocupa la pila de recursión. La complejidad espacial de un algoritmo recursivo depende de cuántas llamadas recursivas se apilan antes de llegar a la base del caso.

Ejemplo de recursión:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

En este caso, la pila de recursión se acumula hasta que llega a la base (cuando n == 0), por lo que la complejidad espacial es O(n), ya que tenemos n niveles de recursión.

Ejemplo con recursión más eficiente:

def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

Aquí, factorial_iterative utiliza O(1) espacio, ya que no hay recursión y solo se usan algunas variables temporales.

4. Considera el espacio en los algoritmos de divide y vencerás

Los algoritmos de tipo divide y vencerás suelen tener un alto impacto en el espacio debido a las llamadas recursivas. Por ejemplo, el algoritmo de merge sort tiene una complejidad espacial de O(n) debido al uso adicional de espacio para fusionar las sublistas, aunque la complejidad temporal es O(n log n).

Ejemplo de merge sort:

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    return merge(left, right)  # La fusión de las sublistas usa espacio adicional

Aquí, el merge consume espacio O(n) debido a las copias temporales que se crean durante la fusión de las sublistas.

5. Sumar el espacio utilizado por diferentes partes del algoritmo

Al igual que con la complejidad temporal, cuando tienes varias operaciones independientes (por ejemplo, bucles, recursión, llamadas a funciones), debes sumar las complejidades espaciales.

Sin embargo, si tienes varios bloques de código que se ejecutan de forma independiente, la complejidad espacial generalmente está dominada por el término más alto.

Ejemplo:

def example(n):
    arr = [0] * n  # O(n)
    dict1 = {i: i*2 for i in range(n)}  # O(n)
    return arr, dict1

Aquí, tenemos O(n) para el arreglo arr y O(n) para el diccionario dict1, por lo que la complejidad espacial total sigue siendo O(n) (porque ambos términos están sumando el mismo espacio).

6. Ejercicios para practicar análisis espacial

Ejercicios para mejorar tu capacidad de análisis espacial:

Listas:
- ¿Qué pasa con la complejidad espacial si tienes una lista de listas (es decir, una matriz)?
- ¿Y si haces una copia de esa lista?
Diccionarios:
- ¿Qué pasa si usas un diccionario con claves grandes, como cadenas de texto muy largas?
Recursión:
- Analiza la complejidad espacial de varios algoritmos recursivos y compáralos con sus versiones iterativas.
Algoritmos de ordenación:
- ¿Cuál es la complejidad espacial de quick sort versus merge sort?

Aspectos claves de la complejidad espacial:

Identifica las estructuras de datos: ¿Cuánto espacio ocupa la lista, diccionario, conjunto, etc., en función del tamaño de la entrada?
Variables temporales: Analiza si las variables locales son constantes o dependen de n.
Recursión: Si el algoritmo es recursivo, cuenta cuántos niveles de recursión se necesitan y qué espacio utiliza la pila.
Divide y vencerás: Considera el espacio adicional requerido para fusionar datos en algoritmos como merge sort.
Suma de complejidades: Si hay varias partes independientes, toma la complejidad espacial dominante.

Consejos prácticos:

Practica con ejemplos pequeños y luego avanza hacia ejemplos más complejos.
Usa comentarios para registrar cuántas variables temporales o estructuras de datos adicionales estás usando en tu análisis.
Haz comparaciones entre diferentes enfoques: recursivo vs. iterativo, uso de listas vs. diccionarios, etc.

Al igual que con la complejidad temporal, el análisis espacial mejora con la práctica, así que mientras más analices y resuelvas problemas, más natural será para ti identificar el uso de memoria en los algoritmos.

Herramientas y recursos adicionales

Aunque no hay tantas herramientas para el análisis de la complejidad espacial como las que existen para el análisis de la complejidad temporal, existen algunas herramientas y enfoques que pueden ayudarte a medir el uso de memoria de un programa y entender su complejidad espacial.

1. Herramientas de perfilado de memoria en Python

Aunque no es una calculadora de Big O per se, puedes usar herramientas de perfilado de memoria para medir cuánto espacio (memoria) utiliza tu código durante su ejecución. Esto te permite observar cómo cambia el uso de memoria en función del tamaño de la entrada.

A. `memory_profiler`

Una de las bibliotecas más populares para medir el uso de memoria en Python es memory_profiler. Esta herramienta permite seguir el uso de memoria de una función a lo largo de su ejecución.

Instalación:
```
pip install memory-profiler
```
Uso básico:

Aquí tienes un ejemplo de cómo usar memory_profiler para medir el uso de memoria de una función:
```
from memory_profiler import profile

@profile
def my_function():
    a = [1] * (10**6)  # Crea una lista grande
    b = [2] * (2 * 10**7)  # Crea otra lista aún más grande
    del b  # Elimina la lista
    return a

if __name__ == "__main__":
    my_function()
```
- Para ejecutar este código y ver el uso de memoria, debes correrlo con el siguiente comando:
```
python -m memory_profiler your_script.py
```
El resultado mostrará el uso de memoria de cada línea de la función y te ayudará a identificar dónde se produce el mayor consumo.

B. `tracemalloc`

La librería tracemalloc es otra opción para medir el consumo de memoria. Se incluye con Python desde la versión 3.4, y se puede utilizar para monitorear el uso de memoria a nivel de objeto, proporcionando un rastreo más detallado de la memoria utilizada.

Uso básico:

import tracemalloc

tracemalloc.start()

def my_function():
    a = [1] * (10**6)
    b = [2] * (2 * 10**7)
    del b
    return a

my_function()

snapshot = tracemalloc.take_snapshot()
for stat in snapshot.statistics('lineno'):
    print(stat)

Esto te muestra cuánto espacio se está utilizando por las líneas de código que se ejecutan, lo que te da una buena idea del uso de memoria y puedes usarlo para hacer una aproximación de la complejidad espacial.

2. Calculadoras automáticas de complejidad Big O (Limitadas para análisis espacial)

Aunque las herramientas anteriores son útiles para medir el uso real de memoria en tiempo de ejecución, actualmente no existe una herramienta única que calcule directamente la complejidad espacial en Big O de manera automática, como ocurre con el análisis de la complejidad temporal. Sin embargo, algunas herramientas y enfoques pueden ayudarte a estimar la complejidad espacial de un programa de manera indirecta:

A. `Big-O Calculator` (limitada a la complejidad temporal)

Enfoque: Algunas calculadoras en línea, como la Big-O Calculator, pueden ayudarte a obtener una estimación de la complejidad temporal de un algoritmo, pero no calculan la complejidad espacial directamente. Estas herramientas se basan en el análisis estático de código y no pueden medir el uso de memoria real.

Ejemplo: Big-O Calculator

B. Análisis Manual con la ayuda de Herramientas de Medición de Memoria

Aunque no hay una herramienta automática para Big O espacial, una práctica común es hacer un análisis manual de la complejidad espacial en función del comportamiento observado con las herramientas de medición de memoria (como memory_profiler o tracemalloc).
Puedes estudiar el comportamiento del consumo de memoria en función del tamaño de la entrada para hacer estimaciones del orden de la complejidad.

3. Enfoques Comunes para Evaluar la Complejidad Espacial Manualmente

Si bien no hay una calculadora directa de Big O espacial, hay enfoques establecidos que puedes usar para evaluar la complejidad espacial de manera manual:

Revisa las estructuras de datos:
- Si usas listas, diccionarios, conjuntos, matrices, etc., evalúa cómo su tamaño cambia con respecto a la entrada. Por ejemplo, una lista que almacena n elementos tiene una complejidad espacial de O(n).
Recursión:
- Si tu algoritmo es recursivo, evalúa cuántos niveles de recursión se pueden apilar antes de llegar al caso base. La memoria utilizada por la pila de recursión contribuye a la complejidad espacial. Si el algoritmo recursivo tiene una profundidad de recursión de n, entonces la complejidad espacial será O(n).
Matrices y estructuras 2D:
- Si creas una matriz de tamaño n x n, la complejidad espacial será O(n^2). Si usas una matriz dispersa, es posible que puedas reducir el espacio al considerar sólo las celdas no vacías.
Espacio adicional por copias:
- Si tu algoritmo hace una copia de una lista o conjunto de datos, el espacio utilizado será proporcional al tamaño de la entrada, es decir, O(n).

4. Enfoques en Lenguajes y Herramientas de Bajo Nivel

En lenguajes como C o C++, donde el control sobre la memoria es más explícito, es más fácil usar herramientas de análisis como Valgrind o gperftools para medir el uso de memoria de los programas. Sin embargo, en Python y otros lenguajes de alto nivel, las herramientas mencionadas como memory_profiler y tracemalloc son las opciones más comunes.

5. Algunas Alternativas y Recursos Útiles

Aunque las herramientas no proporcionan un análisis directo de Big O espacial, algunos recursos adicionales que te pueden ayudar a mejorar tu comprensión de la complejidad espacial incluyen:

Libros y recursos de algoritmos: Los libros como "Introduction to Algorithms" (Cormen et al.) o "The Algorithm Design Manual" (Skiena) tienen capítulos completos dedicados a la complejidad espacial.
Tutoriales y cursos en línea: Plataformas como Coursera, edX, y Udacity ofrecen cursos donde se profundiza en el análisis de complejidad temporal y espacial.

Nota Final:

Aunque no existen calculadoras automáticas de Big O espacial de la misma manera que existen herramientas para la complejidad temporal, puedes medir el uso real de memoria con herramientas como memory_profiler o tracemalloc. A partir de estos datos, puedes hacer una estimación manual de la complejidad espacial, observando patrones y cómo crece el uso de memoria con el tamaño de la entrada.

Te recomiendo practicar el análisis manual de complejidad espacial y usar herramientas de perfilado para obtener una visión más detallada del comportamiento de tu código. ¡Con práctica, se te hará cada vez más fácil identificar la complejidad espacial de los algoritmos! 😊

¡Feliz programación!❤️😀

This weblog is sponsored by Billy ClassTime's Blog.

Conda - Guia rapida para gestionar entornos en Python

Fri, 29 Nov 2024 12:15:27 GMT

Conda es un gestor de entornos y gestor de paquetes de código abierto, que permite a los usuarios instalar, actualizar y gestionar librerías y herramientas de software, además de crear entornos virtuales aislados para proyectos específicos.

Aunque Conda puede ser usado con varios lenguajes de programación (como R, Julia, Ruby, etc.), se asocia principalmente con Python porque se utiliza con frecuencia para gestionar entornos de desarrollo en proyectos científicos, de machine learning, o en cualquier área que requiera librerías como numpy, pandas, scipy, tensorflow, entre otras.

Razón principal por la que se asocia con Python:

Facilita la gestión de dependencias y versiones de librerías, ya que las librerías de Python a veces tienen dependencias complejas que deben coincidir perfectamente para evitar conflictos.
Conda permite crear entornos virtuales específicos para diferentes proyectos, lo que evita que las versiones de librerías en proyectos distintos entren en conflicto.

Creación de entornos

Crear un entorno en Conda con una versión específica de Python y librerías limpias (es decir, un entorno sin librerías preinstaladas):

Crear el entorno especificando la versión de Python:

Para crear un entorno llamado entorno_01 con Python 3.9 (puedes elegir la versión que necesites), usa el siguiente comando:
```
conda create --name mi_entorno python=3.9
```
Esto instalará la versión de Python especificada en un entorno virtual aislado. Si no deseas ninguna librería adicional, simplemente no especificas más paquetes.
Activar el entorno

Una vez creado el entorno, activa el entorno con:
```
conda activate entorno_01
```
Esto activará el entorno entorno_01 para comenzar a trabajar desde él.
Instalar librerías necesarias

Una vez activado el entorno, puedes instalar las librerías que necesites. Por ejemplo, para instalar numpy y pandas, puedes usar:
```
conda install numpy pandas
```
Exportar el entorno

Exportar el entorno mi_entorno a un archivo environment.yml:
```
conda env export --name mi_entorno > environment.yml
```
Esto generará un archivo llamado environment.yml que se usa para recrear el entorno en otro ordenador.

Revisar el archivo environment.yml: Al abrir este archivo se puede verificar que las versiones de las librerías y Python estén correctas.
Importar el entorno

Importar un entorno en otro ordenador a partir del archivo environment.yml:
- Crear el entorno desde el archivo YML en otro equipo
  - En el otro ordenador, coloca el archivo environment.yml en el directorio adecuado:
```
conda env create -f environment.yml
```
    Esto instalará todas las dependencias y recreará el entorno de forma idéntica al original.
- Activar el entorno en el nuevo equipo
  - Después de crear el entorno, activar el entorno normalmente
```
conda activate mi_entorno
```
    Ahora, el entorno esta replicado en el nuevo equipo con las mismas versiones de Python y librerías.

Conda es un gestor de entornos y paquetes asociado con Python porque facilita la gestión de dependencias y versiones.

Para crear un entorno con una versión específica de Python y librerías limpias: conda create --name mi_entorno python=3.9.

Para exportar el entorno: conda env export --name mi_entorno > environment.yml.

Para importar el entorno en otro ordenador: conda env create -f environment.yml.

This weblog is sponsored by Billy ClassTime's Blog.

Setting Up Python with Anaconda for Class: Installation and Environment Preparation

Mon, 25 Nov 2024 17:10:00 GMT

Preparing Your Python Environment Before Class Starts
Before you begin, please make sure to carefully read all the instructions. It is crucial that you follow each step precisely to ensure a smooth and correct installation of Python with Anaconda. By doing so, you'll avoid potential issues and be fully prepared to start the class without any technical difficulties. Taking the time to go through these steps thoroughly will help you set up your environment correctly and ensure you're ready to begin learning.

Installing Anaconda

1 - First, go to the Anaconda website (www.anaconda.com) and download the Anaconda installer. Choose an installer compatible with your computer’s operating system. This lecture provides an example in the Windows Sandbox.

2- Warning: Before installing Anaconda, it is recommended to uninstall any previous versions of Python. This helps avoid conflicts between different Python versions and ensures that Anaconda's Python installation doesn't overwrite or cause configuration issues. By doing so, you'll have a clean environment to work in, minimizing potential problems and ensuring smoother operation with Anaconda.

3 - After downloading and executing the anaconda installation file, follow the procedure below to install the program.

4 - At the end of the installation, of the previous step in the final window, make sure to check the box that says "Launch Anaconda Navigator." This will allow Anaconda Navigator to open automatically after the installation is complete, giving you easy access to manage environments, packages, and launch Jupyter notebooks or other tools directly from a user-friendly interface. Leaving this option checked will save you time and ensure you're ready to start working right away.

5 - Close the windows "Sign for AI coding Help"

6 - Once Anaconda Navigator is running, open it and look for the "Jupyter Notebook" option. Click on the "Launch" button next to Jupyter Notebook. This will open a new tab in your default web browser, where you can create and work with Python notebooks interactively. Jupyter Notebook is a powerful tool for writing, running, and sharing Python code, and it’s ready to use once it launches from Anaconda Navigator.

7 - The previous step will launch Jupyter Notebook in your web browser. When the Jupyter Notebook page opens, you may see a window called "Anaconda Assistant". This is the window you need to close first before to continue testing if your set up is fine and free of issues!

8 - After closing the Anaconda Assistant window, go to the File menu at the top left of the Jupyter Notebook page and select New Notebook to create a new notebook.

9 - Select the default Python 3 (ipykernel)

10 - Test the Environment

To ensure everything is set up correctly, let's test the environment, in the first cell of the new notebook, type the following code:

print("hello world")

Press Shift + Enter to execute the cell or press the play button like you can see on this picture:

If everything is working correctly, you should see the output "Hello World" displayed below the cell.

Once this is all set up and working, you’re ready to begin your classes and work with Jupyter Notebook without issues.

If you encounter any problems and are unable to get this to work, please contact your teacher via WhatsApp to report the issue. However, make sure you have followed each step carefully and that the code still doesn’t execute before reaching out for help.

11 - End. Once you have tested the environment and everything is working correctly, you can go ahead and close the Jupyter Notebook and Anaconda Navigator. Your teacher will provide further instructions on how to continue, and you'll be able to enjoy the learning process. We look forward to seeing you in class at the start of the course.

Happy coding! 👩‍💻👨‍💻

This weblog is sponsored by Billy ClassTime's Blog.

Matematicas para la Ciencia de Datos en mi Clase de IA

Fri, 15 Nov 2024 16:18:05 GMT

Matemáticas para la Ciencia de Datos en mi Clase de IA

En el segundo capítulo del curso Inteligencia Artificial, nos adentramos en los fundamentos matemáticos esenciales para la Ciencia de Datos. Comenzamos con una introducción básica a las herramientas matemáticas más importantes, como los vectores y las matrices, que son clave para procesar y analizar grandes volúmenes de datos.

A lo largo del capítulo exploramos cómo estos conceptos se aplican directamente en el campo de La Ciencia de Datos (Data Science) y el Aprendizaje Profundo (Deep Learning). La comprensión de las derivadas, por ejemplo, es esencial para entender cómo funcionan los algoritmos de optimización en el Aprendizaje Automático (Machine Learning).

Este capítulo no solo refuerza la importancia de las matemáticas en el análisis de datos, sino que también establece una base sólida para los próximos temas más avanzados en la Inteligencia Artificial

Usando Python para ilustrar estos conceptos

Vectores: Usamos numpy para crear un vector simple de tres dimensiones. Los vectores son fundamentales en ciencia de datos porque representan datos multidimensionales.

import numpy as np
import matplotlib.pyplot as plt

# 1. Vectores
# Crear un vector en Python usando numpy
vector = np.array([1, 2, 3])
print("Vector: ", vector)

Matrices: Creamos una matriz 2x2 y multiplicamos esta matriz por el vector. Esto es un ejemplo de cómo las matrices se utilizan para manipular y transformar datos.

# 2. Matrices
# Crear una matriz 2x2
matrix = np.array([[1, 2], [3, 4]])
print("\nMatriz: \n", matrix)

Derivadas:

Definimos la función:

Y su derivada:

Luego, graficamos tanto la función como su derivada para visualizar cómo cambia la pendiente de la función.

# 3. Derivada simple usando numpy (derivada de f(x) = x^2)
# Definir la función f(x) = x^2
def f(x):
    return x**2

# Crear un array de valores de x
x_vals = np.linspace(-10, 10, 100)

# Calcular los valores de la función y su derivada (f'(x) = 2x)
y_vals = f(x_vals)
y_derivative = 2 * x_vals

# Graficar la función y su derivada
plt.figure(figsize=(8, 6))
plt.plot(x_vals, y_vals, label="f(x) = x^2", color='blue')
plt.plot(x_vals, y_derivative, label="f'(x) = 2x", color='red', linestyle='--')
plt.xlabel("x")
plt.ylabel("y")
plt.title("Función y Derivada: f(x) = x^2 y f'(x) = 2x")
plt.legend()
plt.grid(True)
plt.show()

Conclusión

El ejemplo anterior es una demostración práctica de cómo conceptos matemáticos como los vectores, las matrices y las derivadas no son solo teoría abstracta, sino herramientas fundamentales que usamos día a día en el campo de la ciencia de datos y el aprendizaje automático. Cada uno de estos elementos tiene un papel crucial cuando trabajamos con grandes volúmenes de datos y entrenamos modelos de inteligencia artificial.

Los vectores nos ayudan a representar datos multidimensionales, las matrices nos permiten manipular y transformar esos datos de manera eficiente, y las derivadas las utilizamos para entender cómo los algoritmos de optimización ajustan los parámetros de nuestros modelos para que aprendan de manera efectiva.

Así que, aunque a veces parezca que estos son solo conceptos matemáticos básicos, son la base sobre la que se construyen muchas de las herramientas que están transformando el mundo digital. ¡Durante el curso, haremos énfasis en entender estos conceptos claves.

¡Feliz programación!

This weblog is sponsored by Billy ClassTime's Blog.

El Enfoque Greedy en Algoritmos de Optimizacion

Fri, 01 Nov 2024 15:00:09 GMT

El Enfoque Greedy en Algoritmos de Optimización

En mi clase de Programación, Algoritmos y Estructuras de Datos en Python para Inteligencia Artificial exploramos el Enfoque Greedy, una técnica de diseño de algoritmos simple pero poderosa que se utiliza para resolver problemas de optimización. El principio fundamental de esta técnica es seleccionar siempre la opción que parece ser la mejor en el momento, sin considerar las consecuencias a largo plazo. Aunque esta estrategia no siempre garantiza la mejor solución global, es muy eficiente para ciertos tipos de problemas.

Un ejemplo clásico donde el Enfoque Greedy es muy útil es el problema del cambio de monedas.

Imagina que tienes diferentes denominaciones de monedas (por ejemplo, 10, 100, 200 y 500) y un monto específico que debes devolver como cambio. El algoritmo Greedy resuelve este problema de manera óptima seleccionando, en cada paso, la moneda de mayor valor disponible hasta alcanzar el monto exacto.

El proceso sigue estos tres pasos:

Selección de la moneda más grande disponible.
Comprobación de viabilidad: Si se puede dar el cambio con las monedas restantes.
Comprobación de la solución: Si se ha logrado el monto exacto, se detiene el proceso.

Para aplicar esto en programación, implementamos la función coin_change(), que calcula cuántas monedas de cada tipo se necesitan para un monto dado. Si es posible dar el cambio, el algoritmo muestra qué monedas se han utilizado; si no, indica que no es posible.

El Enfoque Greedy es ideal en escenarios donde necesitamos una solución rápida y eficiente, y la técnica de dar cambio de monedas es solo un ejemplo de su aplicación.

Si quieres saber mas de la explicación de este enfoque, y un ejemplo con Python también lo puedes consultar en mi GitHub:

Problem-Solving-with-Algorithms: El Enfoque Greedy

¡Feliz Programación!

This weblog is sponsored by Billy ClassTime's Blog.

Iniciando con Azure Open AI en mi empresa

Fri, 26 Apr 2024 19:12:52 GMT

Hoy he recibido el correo de bienvenida a Azure OpenAI, para comenzar a utilizarlo en los proyectos de mi compañía.

)

Generación de un modelo de resumen de texto

Para comprobar que todo ha quedado correcto, he creado un servicio inicial de prueba

Seleccionando ir a Azure OpenAI Studio, se abrirá lo siguiente:

![(https://billyclasstimesa.blob.core.windows.net/images/B7-12.png)

En este punto al dar Generate Azure OpenAI intentará comprender el contexto del texto y parafrasearlo de forma concisa.

Según la documentación, la precisión de la respuesta puede variar según el modelo. En este ejemplo, el modelo basado en Davinci, es adecuado para este tipo de resumen, mientras que un modelo basado en Codex no funcionaría tan bien en esta tarea en particular.

Conclusión

Para iniciar a implentar soluciones con los servicios de AI Generativa de Azure, deberá solicitar el acceso dando la susbcripción de Azure donde realizará los pagos. La url de acceso vigente a la fecha de este artículo es: Aplicar Azure OpenAI Serivice

Tras recibir el email de aceptación ya podrá comenzar a realizar los proyectos, según lo casos de uso que indico en el momento de la solicitud de acceso.

Feliz programación

This weblog is sponsored by Billy ClassTime's Blog.

Azure Functions Core Tools 4

Fri, 26 Apr 2024 16:55:19 GMT

Las azure functions core tools, han evolucionado desde que las comenzamos a utilizar para .net 4.7.

Este artóculo muestra como Instalemos la ultima versión y como la utilizamos creando una función con C# y otra conPython 3.9, desde Visual Studio Code.

Nota:

Si tienes instalado versiones anteriores de la Azure Function Core Tools, o has utilizado nmp, todas esas versiones deberán ser desinstaladas previamente antes de actualizar la versión 4.

Descargar el msi

v4.x - Windows 64 bit

v4.x - Windows 32 bit

Si quieres ver mas detalles, en el momento de crear esta entrada en el block estaba vigente el siguiente enlace en la web de Microsoft: Develope Azure Functions locally using Core Tools

Ejecutar el asistente de instalación

Prerrequisitos

En el ordenador donde se van a crear las Azure Functions, deberás tener los lenguajes que desees usar para la creación de las funciones.

python. En la carpeta destinada a crear la Azure Function en Python deberás crear un entorno virtual con la versión 3.9

pyenv global 3.9.10
py -3.9 -m venv env
.\env\Scripts\activate
py --version

Csharp En la carpeta destinada a crear tu funciones con Csharp deveras tener el SDK de .net.

Nota:

func --version esta disponible en todo el sistema, tanto para uno como otro lenguaje.

En Visual Studio Code deberás tener las extensiones de python y CSharp Instaladas.

code --list-extensions

ms-dotnettools.csharp
ms-python.python
ms-azuretools.vscode-azurefunctions

Cada una de las extensiones anteriores las puedes instalar aquí:

C# - Visual Studio Marketplace

Python - Visual Studio Marketplace

Azure Functions - Visual Studio Marketplace

También te sugiero que instales las Azure Tools para interactuar con Azure en la nube y en local.

Azure Tools - Visual Studio Marketplace

Crear la Azure Function

Python 3.9

Primero deberemos ajustar que Visual Studio Code reconozca python como lenguaje para crear la Azure Function

Seleccionamos la extensión de Azure Tools y en el WorkSpace seleccionamos Functionsy Create Function

Hemos de seguir los siguientes pasos para la creación del proyecto de Azure Function en Python.

Paso 1 seleccionar la carpeta del proyecto

Paso 2 seleccionar el modelo de programación

Paso 3 seleccionar el nombre de la función

Paso 4 seleccionar el acceso a la función

Una vez que el proyecto ha sido creado deberemos instalar la librería de Azure Function para Python

Cuando veamos la función que hemos creado su aspecto será el siguiente:

Podremos ejecutar la función directamente en la linea de comandos asi:

func start host -port 50302

o desde el Visual Studio Core con F5

Cuando ejecutemos desde el navegador podremos encontrar esta respuesta:

CSharp 12.0

Al igual que en Python antes de comenzar a trabajar con CSharp hemos de especificar el lenguaje que utilizaremos en Visual Studio Code para trabajar con las Azure Functions.

Seleccionamos de las extensiones Azure Tools y hacemos lo mismo que hicimos en el proyecto de Python

Paso 1 - Iniciamos los pasos para la creación del proyecto, seleccionando una carpeta.

Paso 2 - Entramos el nombre de la función.

Paso 3 - Damos el nombre del namespace

Paso 4 - Por último seleccionamos el acceso a la función.

Esperamos a que se cree el proyecto.

Este es el aspecto del código de la función generado por la plantilla seleccionada para esta disperador.

Seleccionamo el fichero de configuración para seleccionar el puerto.

Luego iniciamos el proyecto con F5

Abrimos un navegador y ponemos el url de la función: `http://localhost/5005/api/MyFunction

Conclusión

Las Azure Core Tools son indispensables para la elaboración de lo proyectos con las Azure Functions, disponibles para Java, .Net, Python , JavaScript, TypeScrypt, Go/Rust , y otros.

En este artículo, hemos actualizado, las Azure Tools, para que utilizarlas con Pythony .Net

This weblog is sponsored by Billy ClassTime's Blog.

Actualizando mi blog de .Net 6.0 a .Net 8.0

Thu, 21 Mar 2024 12:15:45 GMT

La fundación .Net, basandose en los criterios de Innovación Continua, Retroalimentación de la comunidad, Adaptación a cambios en el panorama tecnológico, Competencia en el mercado y Mateninimiento y soporte. Libera cada año una nueva versión de esta cája de herramientas gigante para desarrolladores de software, llamada .Net.

Caja que contiene todas las piezas necesarias para construir diferentes tipos de programas y aplicaciones para ordenadores (personales y servidores) y dispositivos móviles (telefonos, tablets, consolas de juego, IoT), proporcionando las herramientas necesarias (básicas y avanzadas) para que el software funcione correctamente.

Me he puesto la meta que todos mis proyectos (personales y de terceros) deben ser actualizados para añadir estas mejoras en donde un componente de seguridad (corregir vulnerabilidades en las piezas de código), sea parte de la política de actualización.

Hace casí tres años cambié este blog, de haberlo iniciado en WordPress para pasarlo a .Net, basado en un código open source Dasblog-core.

No realicé un fork, descargue todo el código, y a partir de allí realicé mi Blog personalizado.

Hace dos años lo migré de a .Net 6.0, ajuste CI/CD, el repositorio sigue privado en GitHub, y las canalizaciones en Azure DevOps.

Este año, iba hacer lo mismo, cuando vi un interesante video de Scott Hanselman .NET Developers should be using dotnet-outdated to update their project's references mostrando como ha sido su actualización de tres de sus proyectos personales, de .Net 6.0 a .Net 8.0. Destacando el uso de las herramientas dotnet-outdated-tool y upgrade-assistant. Diez minutos y todo estaba actualizado de .Net 6.0 a .Net 8.0.

A mi me tomo mas tiempo, puesto que mis paquetes de libreria estaban mas desactualizados y al hacerlo, las referencias a sus propiedades y las llamadas a algunos de sus métodos, ya no estaban obsoleto, generando warnings, o en desuso, generando errores.

Pero los pasos fueron los siguientes.

1- Revisando la versión de paquetes nuget y actualizarlos a las versiones mas recientes.

dotnet tool update --global dotnet-outdated-tool

Para revisar los paquetes nugets, utilizamos la herrmienta dotnet-outdated-tool

Mayor información aqui:

GitHub - dotnet-outdated/dotnet-outdated: A .NET Core global tool to display and update outdated NuGet packages in a project

Revisando la salida del dotnet-outdated

❯ dotnet-outdated
» dasblog-core
  [net6.0]
  ConsoleTables                                                             2.4.2 -> 2.6.1
  McMaster.Extensions.CommandLineUtils                   4.0.1 -> 4.1.1
  Microsoft.Extensions.Configuration                            6.0.1 -> 8.0.0
  Microsoft.Extensions.Configuration.Xml                     6.0.0 -> 8.0.0
  Microsoft.Extensions.DependencyInjection                6.0.0 -> 8.0.0
  Microsoft.Extensions.DependencyInjection.Abstractions  6.0.0 -> 8.0.1
  Microsoft.Extensions.Options                                            6.0.0 -> 8.0.2
  Microsoft.SourceLink.GitHub                                            1.1.1 -> 8.0.0

» DasBlog.Core
  [net6.0]
  Microsoft.Extensions.Options                                             6.0.0 -> 8.0.2
  Microsoft.SourceLink.GitHub                                              1.1.1 -> 8.0.0
  NetEscapades.Extensions.Logging.RollingFile                    2.4.1 -> 2.5.0
  NodaTime                                                                           3.1.2 -> 3.1.11

» DasBlog.Managers
  [net6.0]
  Microsoft.SourceLink.GitHub  1.1.1 -> 8.0.0
  NodaTime                     3.1.2 -> 3.1.11

» DasBlog.Services
  [net6.0]
  Kveer.XmlRPC                  1.2.0 -> 1.2.1
  MailKit                       3.4.1 -> 4.4.0
  Microsoft.Extensions.Options  6.0.0 -> 8.0.2
  Microsoft.SourceLink.GitHub   1.1.1 -> 8.0.0
  Quartz.AspNetCore             3.5.0 -> 3.8.1

» DasBlog.Web
  [net6.0]
  AutoMapper                                                               11.0.1 -> 13.0.1
  Microsoft.ApplicationInsights.AspNetCore                2.21.0 -> 2.22.0
  Microsoft.AspNetCore.Identity.EntityFrameworkCore         6.0.9  -> 6.0.28
  Microsoft.AspNetCore.Mvc.Razor.Extensions                      6.0.9  -> 6.0.28
  Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation      6.0.9  -> 6.0.28
  Microsoft.SourceLink.GitHub                                               1.1.1  -> 8.0.0
  Microsoft.VisualStudio.Azure.Containers.Tools.Targets        1.11.1 ->
  Microsoft.VisualStudio.Web.CodeGeneration.Design       6.0.9  -> 6.0.16
  NetEscapades.Extensions.Logging.RollingFile                   2.4.1  -> 2.5.0
  Quartz.AspNetCore                                                           3.5.0  -> 3.8.1

» newtelligence.DasBlog.Runtime
  [net6.0]
  Microsoft.SourceLink.GitHub                                            1.1.1 -> 8.0.0
  NodaTime                                                                          3.1.2 -> 3.1.11

Version color legend:
<red>   : Major version update or pre-release version. Possible breaking changes.
<yellow>: Minor version update. Backwards-compatible features added.
<green> : Patch version update. Backwards-compatible bug fixes.

You can upgrade packages to the latest version by passing the -u or -u:prompt option.
Elapsed: 00:00:03.2835635

Después de la actualización:

❯ dotnet outdated -utd
» dasblog-core
  [net8.0]
  ConsoleTables                                                             2.6.1 == 2.6.1
  McMaster.Extensions.CommandLineUtils                   4.1.1 == 4.1.1
  Microsoft.Extensions.Configuration                            8.0.0 == 8.0.0
  Microsoft.Extensions.Configuration.Xml                     8.0.0 == 8.0.0
  Microsoft.Extensions.DependencyInjection                8.0.0 == 8.0.0
  Microsoft.Extensions.DependencyInjection.Abstractions  8.0.1 == 8.0.1
  Microsoft.Extensions.Options                                     8.0.2 == 8.0.2
  Microsoft.SourceLink.GitHub                                      8.0.0 == 8.0.0

» DasBlog.Core
  [net8.0]
  Microsoft.Extensions.Options                                       8.0.2  == 8.0.2
  Microsoft.SourceLink.GitHub                                        8.0.0  == 8.0.0
  NetEscapades.Extensions.Logging.RollingFile              2.5.0  == 2.5.0
  NodaTime                                                                     3.1.11 == 3.1.11

» DasBlog.Managers
  [net8.0]
  Microsoft.SourceLink.GitHub                                       8.0.0  == 8.0.0
  NodaTime                                                                    3.1.11 == 3.1.11

» DasBlog.Services
  [net8.0]
  Kveer.XmlRPC                                                               1.2.1 == 1.2.1
  MailKit                                                                           4.4.0 == 4.4.0
  Microsoft.Extensions.Options                                       8.0.2 == 8.0.2
  Microsoft.SourceLink.GitHub                                        8.0.0 == 8.0.0
  Quartz.AspNetCore                                                       3.8.1 == 3.8.1

» DasBlog.Test.Integration
  [net8.0]
  coverlet.collector                                                           6.0.2  == 6.0.2
  Microsoft.AspNetCore.Mvc.Testing                               8.0.3  == 8.0.3
  Microsoft.NET.Test.Sdk                                                  17.9.0 == 17.9.0
  Selenium.Support                                                          4.18.1 == 4.18.1
  Selenium.WebDriver                                                      4.18.1 == 4.18.1
  xunit                                                                               2.7.0  == 2.7.0
  xunit.runner.visualstudio                                                2.5.7  == 2.5.7
  Xunit.SkippableFact                                                       1.4.13 == 1.4.13

» DasBlog.Tests.UnitTests
  [net8.0]
  Microsoft.Extensions.PlatformAbstractions                   1.1.0   == 1.1.0
  Microsoft.NET.Test.Sdk                                                  17.9.0  == 17.9.0
  Moq                                                                               4.20.70 == 4.20.70
  xunit                                                                               2.7.0   == 2.7.0
  xunit.runner.visualstudio                                                2.5.7   == 2.5.7

» DasBlog.Web
  [net8.0]
  AutoMapper                                                                    13.0.1 == 13.0.1
  Microsoft.ApplicationInsights.AspNetCore                      2.22.0 == 2.22.0
  Microsoft.AspNetCore.Identity.EntityFrameworkCore     8.0.3  == 8.0.3
  Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation  8.0.3  == 8.0.3
  Microsoft.SourceLink.GitHub                                           8.0.0  == 8.0.0
  Microsoft.VisualStudio.Web.CodeGeneration.Design     8.0.2  == 8.0.2
  NetEscapades.Extensions.Logging.RollingFile                 2.5.0  == 2.5.0
  NWebsec.AspNetCore.Middleware                                  3.0.0  == 3.0.0
  Quartz.AspNetCore                                                          3.8.1  == 3.8.1
  reCAPTCHA.AspNetCore                                                  3.0.10 == 3.0.10

» newtelligence.DasBlog.Runtime
  [net8.0]
  Microsoft.SourceLink.GitHub                                            8.0.0  == 8.0.0
  NodaTime                                                                         3.1.11 == 3.1.11

Version color legend:
<red>   : Major version update or pre-release version. Possible breaking changes.
<yellow>: Minor version update. Backwards-compatible features added.
<green> : Patch version update. Backwards-compatible bug fixes.

You can upgrade packages to the latest version by passing the -u or -u:prompt option.
Elapsed: 00:00:07.6445084

Un paquete se quedo en el camino (lo eliminé de la referencia del proyecto y del código, puesto que ya esta integrado al parecer con .Net 8.0 Microsoft.VisualStudio.Azure.Containers.Tools.Targets

Realicé mis pruebas de integración y unitarias, corigiendo todo lo que debería corregir. (Referencias a propiedades y llamadas a métodos erroneos para las nuevas versiones).

Cuando todo esto ha estado resuelto he seguido con el siguiente paso.

Nota: He utilizado estos comandos también, y revisado documentación.
dotnet list package
dotnet list package --outdated
https://learn.microsoft.com/en-us/training/modules/dotnet-dependencies/

2 - Actualizando los proyectos .net:

Para hacer esto utilizamos la herramienta upgrade-assistant

dotnet tool install -g upgrade-assistant

Una vez que esta instalada la he utilizado asi:

❯ upgrade-assistant upgrade .

La salida a este comando es esta:

 Selected options
───────────────────────────────────────────────────────────
 No options specified, follow steps below to continue


 Steps
─────────────────
 Source project
─────────────────


Which project do you want to upgrade (found 8)?

> DasBlog.CLI (DasBlog.CLI\DasBlog.CLI.csproj)
  DasBlog.Core (DasBlog.Web.Core\DasBlog.Core.csproj)
  DasBlog.Managers (DasBlog.Web.Repositories\DasBlog.Managers.csproj)
  DasBlog.Services (DasBlog.Services\DasBlog.Services.csproj)
  DasBlog.Test.Integration (DasBlog.Tests\DasBlog.Test.Integration\DasBlog.Test.Integration.csproj)
  DasBlog.Tests.UnitTests (DasBlog.Tests\UnitTests\DasBlog.Tests.UnitTests.csproj)
  DasBlog.Web (DasBlog.Web.UI\DasBlog.Web.csproj)
  newtelligence.DasBlog.Runtime (newtelligence.DasBlog.Runtime\newtelligence.DasBlog.Runtime.csproj)

  Navigation
    Exit

Se elijen cada uno de ellos, y el asistente de actualización hace su trabajo.

Al final si vemos la hitoria de git tenemos lo siguiente:

@@ -1,8 +1,7 @@
•<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework> <<---- ANTES
    <TargetFramework>net8.0</TargetFramework> ---->> DESPUES

Nota: Podeis encontrar mayor información del uso del asistente de actualización aqui:

How to install the .NET Upgrade Assistant - .NET Core | Microsoft Learn

Modernize ASP.NET Framework to ASP.NET Core with the .NET Upgrade Assistant - Training | Microsoft Learn

3 - Commit y Push para iniciar CI/CD

Al final realizando un git commit -m "Update Blog to .Net 8.0" y un git push. Todo se ha quedado en mi slot de qua en el Azure Service, he realizado el switch slot de qua production. Y desde ese momento tengo mi Blog, actualizado a .Net 8.0.

This weblog is sponsored by Billy ClassTime's Blog.

Implementando SOLID con CSharp y .Net 6.0 – 1 de 6

Fri, 19 Nov 2021 14:37:11 GMT

Tiempo de lectura · 2 minutos

Preliminares

Mucho hemos oído hablar de SOLID, y como su puesta en práctica en nuestros desarrollos nos ayudan a construir software de mayor calidad, que todo el mundo lo entienda, mantenible, flexible, ser probado con mayor facilidad, mejorando la cohesión y disminuir el acoplamiento entre sus componentes y orientado al cambio.

SOLID es un acrónimo de los primeros cinco principios de diseño orientado a objetos (OOD) de Robert C. Martin (también conocido como el tío Bob).

Nota: Si bien estos principios se pueden aplicar a varios lenguajes de programación, el código de muestra contenido en este artículo CSharp 10.

Estos principios establecen prácticas que se prestan al desarrollo de software con consideraciones de mantenimiento y ampliación a medida que crece el proyecto. La adopción de estas prácticas también puede contribuir a evitar olores de código, refactorización de código y desarrollo de software ágil o adaptativo.

SÓLID significa:

S - Principio de responsabilidad única

O - Principio abierto-cerrado

L - Principio de sustitución de Liskov

I - Principio de segregación de interfaces

D - Principio de inversión de dependencia

Como su implementación puede exceder el tiempo que quiere invertir en la lectura de este artículo, lo realizaremos por entregas.

Teoría

S – Principio de responsabilidad única

Una clase debe tener una y solo una razón para cambiar, lo que significa que una clase debe tener solo una responsabilidad.

O - Principio abierto-cerrado

Los objetos o entidades deben estar abiertos para la extensión, pero cerrados para la modificación.

Esto significa que una clase debe ser extensible sin modificar la clase misma.

L - Principio de sustitución de Liskov

Sea q(x) una propiedad demostrable sobre objetos de x de tipo T. Entonces q(y) debería ser demostrable para objetos y de tipo S donde S es un subtipo de T.

Esto significa que cada subclase o clase derivada debe ser sustituible por su clase base o padre.

I - Principio de segregación de interfaz

Nunca se debe obligar a un cliente a implementar una interfaz que no usa, o no se debe obligar a los clientes a depender de métodos que no usan, recomendables las interfaces especializadas a generales.

D - Principio de inversión de dependencia

Las entidades deben depender de abstracciones, no de concreciones. Establece que el módulo de alto nivel no debe depender del módulo de bajo nivel, sino que deben depender de abstracciones.

Este principio permite el desacoplamiento.

Conclusión

Implementar SOLID, nos ayudará a realizar software de mayor calidad, añadiendo muchas bondades a la práctica de construcción de software. Veremos en las siguientes 5 entregas mediante un caso práctico, como interiorizar SOLID y convertirlo en un hábito durante nuestros desarrollos.

This weblog is sponsored by Billy ClassTime's Blog.

Billy ClassTime's Blog

Usando la GPU en Jupyter Notebook con red LAN

Usando la GPU en Jupyter Notebook con red LAN

1: Prepara tu entorno con Anaconda

2: Instala las librerías necesarias

3: Configura Jupyter para acceso remoto

4: Comprobar que la GPU está activa

5: Crear la explosión de números

6: Acceder desde otro ordenador

Nota Final

Algoritmo para factorizar N

Algoritmo para factorizar N

Análisis y Diseño del Algoritmo

Definición de factorización (Entender el problema)

1. Factorización de un número en términos de factores enteros:

2. Factorización completa (o trivial):

3. Factorización prima:

¿Cómo encontrar todos los divisores de un número N en la factorización de números enteros y completa?

Diagrama de flujo

Pseudo código

Análisis Temporal (Big O para el tiempo de ejecución)

Análisis Espacial (Big O para el uso de memoria)

Ponemos datos al análisis temporal y espacial del Big O

Análisis temporal, número de procesos necesarios

Nota final

Entendiendo BIG O Temporal

Entendiendo el análisis BIG O Temporal

1. Entiende los patrones comunes de complejidad temporal

2. Analiza paso a paso

3. Practica con ejemplos sencillos y luego con más complejidad

4. Estudia ejemplos de análisis de Big O

5. Herramientas y recursos adicionales

Notal Final:

Entendiendo BIG O espacial

Entendiendo el análisis BIG O espacial

Enfoque general para analizar la complejidad espacial

1. Entiende los patrones comunes de complejidad espacial

1. Espacio constante O(1)

2. Espacio lineal O(n)

3. Espacio cuadrático O(n^2)

4. Espacio logarítmico O(log⁡ n)

5. Espacio O(n log ⁡n)

6. Espacio exponencial O(2^n)

Patrones comunes de complejidad espacial

Estrategias prácticas para evaluar la complejidad espacial

1. Analizar las estructuras de datos utilizadas

Ejemplo de uso de espacio en listas:

Ejemplo de uso de espacio en diccionarios:

2. Considerar las variables temporales

3. Analiza la recursión

Ejemplo de recursión:

Ejemplo con recursión más eficiente:

4. Considera el espacio en los algoritmos de divide y vencerás

Ejemplo de merge sort:

5. Sumar el espacio utilizado por diferentes partes del algoritmo

Ejemplo:

6. Ejercicios para practicar análisis espacial

Aspectos claves de la complejidad espacial:

Consejos prácticos:

Herramientas y recursos adicionales

1. Herramientas de perfilado de memoria en Python

A. memory_profiler

B. tracemalloc

2. Calculadoras automáticas de complejidad Big O (Limitadas para análisis espacial)

A. Big-O Calculator (limitada a la complejidad temporal)

B. Análisis Manual con la ayuda de Herramientas de Medición de Memoria

3. Enfoques Comunes para Evaluar la Complejidad Espacial Manualmente

4. Enfoques en Lenguajes y Herramientas de Bajo Nivel

5. Algunas Alternativas y Recursos Útiles

Nota Final:

Conda - Guia rapida para gestionar entornos en Python

Creación de entornos

Setting Up Python with Anaconda for Class: Installation and Environment Preparation

Matematicas para la Ciencia de Datos en mi Clase de IA

Matemáticas para la Ciencia de Datos en mi Clase de IA

Usando Python para ilustrar estos conceptos

Conclusión

El Enfoque Greedy en Algoritmos de Optimizacion

El Enfoque Greedy en Algoritmos de Optimización

Iniciando con Azure Open AI en mi empresa

¿Cómo encontrar todos los divisores de un número `N` en la factorización de números enteros y completa?

A. `memory_profiler`

B. `tracemalloc`

A. `Big-O Calculator` (limitada a la complejidad temporal)