Create an account or log in

Keep learning for free! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

1 Días
2 Hrs
34 Min
21 Seg

Entendiendo la aleatoriedad con Python

5/24
Resources

What is dynamic and stochastic programming?

Dynamic and stochastic programming is a technique used in the design of algorithms to solve optimization problems characterized by uncertainty and the need to make sequential decisions. This technique is fundamental in solving problems in various fields such as engineering, economics or computer science.

In this context, the professor introduces an interesting concept: the drunken path. Let's find out how this concept materializes in an object-oriented programming algorithm.

How is the drunk path implemented?

The drunkard's path algorithm is derived from a problem that simulates the random motion of a drunkard walking in a field. To understand how this concept is developed in programming, we divide the problem into three fundamental classes:

  1. Drunk: An object representing a person moving randomly.
  2. Field: An object that defines the environment or map in which the drunkard moves.
  3. Coordinate: An abstract concept that serves to define the position within the field.

How is it represented through object-oriented programming?

Object-oriented programming allows modeling the real world by creating classes and objects. In the case of the drunkard's path, the mentioned classes are configured as follows:

  • Drunk: can be imagined as an individual moving within the coordinates of a field. In addition, its characteristics can be extended to define specific behaviors, such as a "traditional drunk" that moves randomly to one of the cardinal sides.

  • Field: Functions as a map and contains the coordinate arrangements, allowing the drunk to move within it.

  • Coordinate: It is like a marker that points to the current position of the drunk within the field, similar to a pin on Google Maps.

How is the drunkard's movement implemented?

The drunkard moves randomly within the field through movements on the X and Y axes. These movements can be:

  • To the left: decrement on the X-axis.
  • To the right: increase in the X-axis.
  • Upward: increase in the Y-axis.
  • Downward: decrease in the Y-axis.

Here is a fragment of the code in Python:

class Drunk: def __init__(self): pass
 def move(self): return random.choice([(1,0), (0,1), (-1,0), (0,-1)])
class Field: def __init__(self): pass

How are these classes integrated into the main function?

To specify the behavior of the drunk and its displacements, it is necessary to define a main function, a common entry point in most programming languages:

if __name__ == '__main__': # Implementation of the drunkard's movement # Code to create instances of the classes and interact with them.

The main is in charge of managing the flow of the program: creating objects, initiating movements and recording results. Simulations can be implemented to see how the drunkard's position varies after a given number of steps.

How are the results of the simulations evaluated?

In stochastic programming, running a simulation once does not provide enough information due to its random component. Therefore, it is necessary to run multiple simulations to obtain more reliable average results.

  • Multiple Simulations: It is important to run several simulations (e.g. 100) for each defined number of steps, thus obtaining the average of the distances traveled.

  • Maximum and Minimum Distances: Evaluating the maximum and minimum distance reached by the drunkard in the different simulations provides insights on the behavior and range of movements.

In short, observing the paths and final positions graphically leads to a deeper understanding of the system behavior. Graphing tools such as Bokeh can be used to visualize the paths.

This fascinating algorithm not only symbolizes the randomness of a drunkard's path, but becomes a powerful tool for studying motion patterns and making decisions under uncertainty in dynamic programming. Keep exploring and studying, there is a world of knowledge to be discovered!

Contributions 42

Questions 4

Sort by:

Want to see more contributions, questions and answers from the community?

Muchas Gracias por acoger la petición de los alumnos y darse el tiempo de explicar y ahondar en el problema!
😃

bueno intenté hacer antes de la clase y grafiqué la posición final de 1000000 de borrachos(ningún borracho salio herido durante la prueba)

con 10 pasos:

con 100 pasos:

Siento que me perdi una clase.

off topic: me dieron ganas de una cerveza…

¿Saben qué sería interesante?
.
Ponerle a 2 borrachos y que haya dos casos:

  • que el borracho sea pana y que sigan caminando aleatoriamente, pero que haya de vez en cuando una tendencia a querer juntarse
  • que el un borracho le busque bronca al otro y el uno trate de vez en cuando de acercarse y el otro de vez en cuando de alejarse
    .
    jaja sería interesante modelar esos casos

Recomendación: vean primero las tres clases siguientes, en las que hace el ejercicio, luego vuelven y ven esta explicación, para que puedan entender el contexto.

Este vídeo explica muy bien lo que se ve en el módulo de Caminos Aleatorios.

Un artículo interesante sobre la implementación del Random Walk en Python.
https://www.geeksforgeeks.org/random-walk-implementation-python/
😃

Me perdí esta sesión en vivo, pero me alegro que se hayan tomado el tiempo de explicar mejor la simulación del borracho, que a mí me costó bastante entender

Notas de esta explicación 😄
** Entendiendo la aleatoriedad con Python.**

  • En ese código se usó el enfoque de POO 💩.
  • Se tienen 3 clases: borracho, campo y coordenada. Una subclase de borracho es borracho tradicional, el cual se puede mover aleatoriamente hacia arriba, derecha, izquierda y abajo con igual probabilidad.
  • Dado que inicia en $(0, 0)$, nos interesa conocer donde está después de $n$ pasos. Al final, para ver donde termino, podemos usar la distancia euclidiana. Dado que es aleatorio, no se aleja tanto del centro.
  • Si corremos solo la simulación una vez para cada $n$, no podríamos conocer el promedio y el comportamiento general, debemos correrlo varias veces (como si lanzáramos un dado). En el ejemplo lo hacemos 100 veces (intentos).
  • En general, en cada simulación, podemos esperar resultados diferentes, pero el promedio será siempre el mismo.

Me parece una buena idea que antes de aplicar un algoritmo se ilustre de alguna forma todos los pasos del mismo, para tener una forma visual de relacionar que está sucediendo en cada momento, buena aclaración profe.

No ha empezado el ejercicio y ya estoy emocionado.

Para que lo puedan googlear se llama Random Walk or Camino aleatorio.

Pobre borracho está peor que Forrest Gump

  • estoy construyendo un sistema que traduce automáticamente un idioma maya, hacia el idioma español.

  • he tenido que irme a entender una gran variedad de variables en la morfología del idioma maya, que afectan su sintaxis, y cómo estas dos circunstancias impiden que haya una traducción literal al español.

  • entender el problema desde el punto de vista de la computación dinámica me ayudará a generar los algoritmos que puedan descomponer eficientemente las palabras del idioma maya, para traducirlas correctamente a un idioma indoeuropeo.

  • por ejemplo:

  1. en español decimos YO TE SIGO

  2. pero en idioma maya se dice KATINTEREMBEJ

  3. si cambio cosas en la palabra maya y escribo KINATEREMBEJ

  4. el resultado en español es TU ME SIGUES

  • han desaparecido las palabras separadas

  • recuerdo a la audiencia, que los mayas inventaron el CERO Y LA NUMERACION VIGESIMAL

  • por esto necesito que mis algoritmos puedan reconocer la composición de ambos tipos de estructuras para hacerlas correlativa

  • tarea sumamente difícil

Forma más fácil de comprender las clases.

  • Borracho define cómo se mueve.

  • El campo el espacio donde se mueve.

  • coordenada es donde está.

En esta clase está explicando de forma gráfica los 2 documentos que dejó en la clase anterior llamada: “QUE SÓN LOS CAMINOS ALEATORIOS”, los archivos de la clase se llaman: -campo.py, -camino_aleatorio.py

También hice una gráfica con las posiciones finales de 10,000 borrachos y aquí les dejo su comportamiento
![](

![](

![](

Es curioso observar que aunque cada borracho de más de 10,000 pasos no pueden avanzar más de 300 pasos a la redonda

Un muy buen abordate teórico del tema. Más que de ayuda para entender qué se está haciendo.

Recordé mi clases de física computacional

Esta clase parece un parche curita. La otra persona del video no aportó nada.
Paso a la siguiente a ver si llego a algo 😉

Hice este pequeño codigo para simular el comportamiento de un borracho, retorna la posicion final y la distancia despues de x pasos.

<code> 
import random

class Borracho:

    def __init__(self):
        self.posicion = [0,0]


    def camino_borrachos(self, pasos=0):
        direccion = random.choice(["derecha","izquierda","arriba","abajo"])
        for i in range(pasos):
            direccion = random.choice(["derecha", "izquierda", "arriba", "abajo"])
            if direccion == "izquierda":
                self.posicion[0] -= 1
            elif direccion == "derecha":
                self.posicion[0] += 1
            elif direccion == "arriba":
                self.posicion[1] += 1
            elif direccion == "abajo":
                self.posicion[1] -= 1
            else:
                return None
        return self.posicion

if __name__ == "__main__":
    borrachin = Borracho()
    direccion_final = borrachin.camino_borrachos(pasos=500)
    print(direccion_final)
    distancia_final = (direccion_final[0]**2+direccion_final[1]**2)**0.5
    print("La distancia final es: ",distancia_final)

MIS APUNTES DE LA CLASE.

Hay 3 clases (objetos):

  • Borracho.
  • Campo.
  • Coordenada.
    Si lo queremos ver en términos de programación orientada a objetos; nos podemos imaginar al borracho cómo alguien que se mueve, el campo como si fuera un mapa y la coordenada como un pointer adentro de este mapa.
    Otra cosa bien interesante es que entro de la programación orientada a objetos es que nosotros podemos generar una jerarquía, y la jerarquía básicamente es como nosotros como podemos expandir cosas generales que hereden de un padre.

justo tenia un trago de ron en mis manos cuando comenzó hablar de borracho me imagine el moviéndome a diferentes coordenadas

gracias, fue bastante necesario.
Un abrazo ❤️

Están hablando el borracho y se me antojo una cerveza :V

Genial ver el proceso de análisis del problema.

Muchas Gracias por la explicación

me parece excelente explicación para que nos enseñe la parte práctica del ejercicio del camino de borrachos 😃

Con esta forma de explicar el algoritmo me dan más ganas de empezar el ejercicio! 😁

Excelente

buen video y necesario! 😃

Excelente, gracias

Que paso aqui? como que ocurrio un salto

Genial!! 😄 volví después de varios mese a este curso y al fin entendí la parte de los caminos del borracho 😃

😃

En resumen:

  1. Entre más prueba haga, más me acerco a la posibilidad de acertar
  2. Si yo hago 100 pruebas, serán diferentes a tus 100 pruebas o a la 100 pruebas del maestro, pero entre mayor sea la cantidad de pruebas nos iremos acercando

Clase abstracta jejejejej

Es una clase un poco extraña … pero me ayudo a enter un poco mas la siguiente 😅

Que buena clase. Creo que se aprovehca más si la ves en 2X porque te obliga a estar más atento que de costubre.

esto es mas facil de entender si lo piensan como un sistema entorno agente de inteligencia artificial

se entendio mejor!