[RO] experiencias con la segunda entrega - ejercicio 3.1

[RO] experiencias con la segunda entrega - ejercicio 3.1

de Hector Cancela -
Número de respuestas: 49

 Estimadas y estimados:

para compartir las experiencias con los distintos lenguajes en la realización de estos primeros ejercicios del curso, pedimos que cada participante conteste este mensaje, indicando:

- Qué lenguaje utilizó para programar el ejercicio 3.1

- Qué tiempo de ejecución insumió el programa en la parte a para un tamaño de muestra N=1E+6

- Si realizaron corridas con otros N todavía mayores, y en ese caso cual fue el mayor N que usaron y qué tiempo insumió

- Otros comentarios (problemas de memoria, dificultades con las bibliotecas de números aleatorios, elementos que hicieron sencillo o complicado resolver la tarea).

Muchos saludos

Héctor

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Guido Adrian Pereyra -
Buenos días,
Por mi parte yo estoy haciendo los laboratorios usando python 3.13 y la ejecución para N=10**6 demoro 0.7769 segundos.
 
Estos fueron mis tiempos para las demás ejecuciones, luego de 10**9 la ejecución superaba los 60 segundos.
 
Simulaciones Tiempo (s)
10 0.0293
10**2 0.028
10**3 0.0297
10**4 0.69
10**5 0.6496
10**6 0.7769
10**7 0.8078
10**8 2.0166
10**9 21.6471
El mayor problema con el que me enfrente fue la gestión de memoria y las demoras comunes de cualquier proceso secuencial, lo que me llevo a eliminar todos los loops de mi código y usar la vectorizacion que proveen algunas librerías, como asi también la ejecución paralela para aprovechar los multiples núcleos del procesador.
Para la parte de generación de números aleatorios, distribuciones y aspectos matemáticos, descanse en las multiples librerías que tiene python que ayudan a la limpieza del código como así también reducir la posibilidad de cometer errores en los cálculos.
 
En lo personal, por fuera de lo técnico, lo que mas tiempo me esta llevando es la parte de comprender las formulas y sus parámetros para aplicarlas en el código, que específicamente en este caso teníamos el valor analítico para constatar pero no siempre es así.
 
Saludos!
 
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Matias Lopez Lapente -
Buenos días Héctor, cómo estás?

El ejercicio 3.1 lo resolví utilizando python 3.11 en un entorno de juypter, al igual que el resto de los entregables. Los tiempos de ejecución requeridos fueron tolerables, alcanzando los 20 segundos para un tamaño muestral de N = 10^6 . Aumentar un orden el tamaño de muestra insumía un poco más de tiempo: para N = 10^7 el estimador demoraba unos 4 minutos en ejecutarse por lo que decidí dejar de aumentar las iteraciones. Las librerías que estoy utilizando son numpy y random, que hasta el momento han sido más que suficientes para la resolución de los ejercicios y no me han causado complicaciones, sobre todo por la gran cantidad de documentación, que además de su fácil acceso, es súper práctica. Quizás, un punto al que deba prestarle mas atención en próximos entregables sea la optimización en los tiempos de ejecución ya que, a pesar de ser códigos sencillos, siento que tamaños no muy grandes están demorando su ejecución por encima del minuto.

En términos generales siento que las sesiones de esta unidad ayudaron mucho tanto en la comprensión del problema como en su realización, además está bueno tener a mano el Fishman por si se quiere profundizar un poco más en el tema.

Saludos y buen fin de semana!
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Mathías Rodríguez Castro -
Buenos días.
 
Buenísimo, a continuación detallo cada uno de estos aspectos.
 
Lenguaje de programación
El lenguaje que utilice fue python 3.13.
 
Tiempo de ejecución para un tamaño de muestra N = 1E+6.
El tiempo que me insumió fue de 3.620877 segundos.
 
Ejecuciones con otros N mayores y tiempo que insumió
Ejecute el programa con 1E+7 y 1E+8 con tiempos de ejecución de 40.828267 segundos y 404.728633 segundos, respectivamente.
 
Otros comentarios
Aprovecho para comentar el uso de la función random.uniform de la librería numpy hizo más sencillo resolver el problema, ya que es esta realiza la generación aleatoria de las muestras de una manera simple, cómo se explica a continuación. Esta función numpy.random.uniform(a,b,size) donde size = (nm), n indica la cantidad de puntos generados y m la dimensión de estos puntos, siendo cada una de sus coordenadas generadas en el rango [a,b] indicado. 
 
Para el caso particular del código se utilizo np.random.uniform(0,1,(n,6)) con n la cantidad de muestras que se quisiera generar.
 
Saludos,
Mathias
 
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Julián Olivera Bailon -

Buenas,

Para los entregables he estado usando el lenguaje Odin.

Los tiempos de ejecucion para el ejercicio 3.1 fueron:

# Replicaciones Tiempo (ms)
$10^6$ 33.21
$10^7$ 322.28
$10^8$ 3,109.60
$10^9$ 31,441.13

Hasta ahora el mayor problema que me he encontrado en la implementación son los errores o torpezas que cometo al programar. De todas formas la implementación suele ser lo mas fácil, las dificultades más grandes las he encontrado en la caracerización del problema y la interpretación de los resultados.

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Federico Méndez Zugarramurdi -

Hola a todos,

Comparto mi experiencia con el ejercicio:

  • Lenguaje usado: Python 3.10 (con NumPy y argparse).

  • Tiempo para N = 1,000,000: 2.6247 segundos.

  • Mayor N probado y tiempo:

    • Para N = 10,000, el tiempo fue 0.0272 segundos.

    • Para N = 1,000,000, el tiempo fue 2.6247 segundos.

  • Comentarios:

    • No tuve problemas de memoria.

    • NumPy ayudó bastante con la generación de números aleatorios y operaciones vectorizadas.

    • El mayor cuello de botella fue la cantidad de chequeos dentro del bucle.

    • La versión de la parte a es más lenta que la parte b porque tiene más restricciones a verificar.

Saludos,
Federico

PD: no sé por qué me aparece calificación mínima:- al final del mensaje.

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Nicolás Adriano Mayora Roth -
Buenas, yo usé el lenguaje Rust y a continuación están los tiempos de ejecución para distintos N:

10e4 -> 604.345µs
10e6 -> 40.710ms
10e9 -> 38.752s

Gracias a que Rust es un lenguaje con abstracciones sin costo, se logra tener un buen rendimiento con una implementación relativamente simple y directa. Lo que más me complicó, sorprendentemente, fue proveer una semilla al RNG, dado que la documentación estaba un tanto desactualizada, pero no fue difícil de resolver.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Santiago Imelio Viera -
Buenas tardes, yo utilicé C. Para N=1E+6 replicaciones llevó 0.1286 segundos. No realicé experimentos con un N mayor ni tampoco enfrenté ninguna dificultad a la hora de correr los experimentos.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de German Ouviña Troche -
Buenas a todos! Mi experiencia hasta ahora ha sido la siguiente:

  • Lenguaje: Python 3.12
  • Tiempo de ejecución para N=1E+6: Alrededor de 12 segundos con un enfoque iterativo, alrededor de 1 segundo con un enfoque vectorial (uso NumPy para la generacion de variables aleatorias, como otros compañeros ya mencionaron la biblioteca está optimizada para operaciones vectoriales y ejecuta muchísimo más rápido)
  • Tiempo de ejecución para Ns mayores: Para N=1E+7, el enfoque iterativo aumentó considerablemente a alrededor de 100 segundos, mientras que el enfoque vectorial si no me equivoco siguió en el órden de un par de segundos. 
  • Otros comentarios: En la entrega anterior me esforcé más en la comparación de los dos enfoques, en esta entrega me limité a seguir con el enfoque iterativo porque me resulta más natural siguiendo los algoritmos del teórico y tiene la ventaja de no tener que preocuparme por la memoria. Me pasó que con N=1E+8 o N=1E+9, el programa crasheaba por problemas de memoria (no invertí tiempo en optimizar esto, podría estar bueno intentarlo). Estoy intentando usar float64 en vez de float32 para tener mayor precisión numérica, eso tampoco ayuda a nivel memoria. Me interesa ver como otros han tratado estos temas, especialmente aquellos que también usaron un enfoque vectorial :)
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Bruno Emanuel Gandos Telis -
Buenas tardes.
- Lenguaje de programación: Utilicé python en su versión 3.12.3.
- Tiempos de ejecución: Para N = 1000000 insumió un tiempo de 5.395396 segundos.
- Corridas con N mayores: No se realizaron.
- Otros comentarios: Utilicé las librerías numpy y time. Numpy me facilitó el manejo de funciones optimizadas, como por ejemplo np.linalg.norm para la norma de un vector, np.sqrt para la raíz cuadrada como también la estructura np.ndarray. Time fue útil para calcular el tiempo de ejecución de las rutinas.

Saludos,
Bruno.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Martin Dante Francia Camacho -
Buenas tardes.
Comparto mi experiencia.

Lenguaje de programación: Estoy utilizando Python 3.13. Para este ejercicio trabajé con las bibliotecas numpy y time.

Tiempo de ejecución:
n = 10^6 -> 0,139s
n = 10^7 -> 1,64s
Probe n^8 y paso más de 1 minuto ejecutando. Interrumpí para seguir en lo que estaba.
 
Comentarios
Utilicé random.uniform(0,1,(n,6)) para la generación aleatoria de números como el compañero Mathías Rodríguez. Vengo de R y estoy aprovechando el curso para aprender sobre la marcha Python. El código me resulta más simple de seguir que en R, pero como buen programador de cabotaje que soy, extraño correr el programa línea a línea.
En la tarea grupal mi compañero hizo el trabajo con R y los tiempos de ejecución son similares. Viendo los resultados hasta ahora, muy interesantes las posibilidades de los MMC.

Saludos, Martín.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Joaquín Amado Loppacher -
Buenos días,

- Lenguaje Python 3.10
- Librerías numpy y time

Tiempos:

- N = 10^4 --> 221ms
- N = 10^6 --> 14s 6ms
- N = 10^7 --> 2m 16s 650ms

Otros comentarios:

Si bien no tuve muchas dificultades para llegar a esta solución, viendo comentarios de otros compañeros noto que mi solución tiene lugares donde mejorar en cuanto a la optimización de los tiempos. Por ejemplo podría utilizar concurrencia (tendría que analizar si surgen nuevos posibles problemas, como por ejemplo condiciones de carrera) o utilizar un lenguaje de más bajo nivel.

La mayor ventaja que yo noto con python es la cantidad de documentación que hay. La librería numpy se hace muy fácil de utilizar.

Saludos,
Joaquín
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Enrique Martin Munne Carullo -
Hola a todos,

- Utilicé Python 3.13.2 en un entorno de Jupyter Lab.
- Para 10E6 insumió 11.26 s y para 10E7 144.95 s
- Mi enfoque fue iterativo y viendo los comentarios de otros compañeros veo que debería intentar un enfoque vectorial para mejorar los tiempos. Tengo curiosidad también por los comentarios que hacen de la paralelización. En mi caso cuando corro la rutina y veo la carga del procesador, observo que no sube prácticamente nada por lo que entiendo que la máquina tiene recursos ociosos, pero no se cómo aprovecharlos.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Juan Ricardo Demczylo Batista -
Buenas, para la resolución de la parte a del ejercicio 3.1 usé el lenguaje c++, usando la función drand48() para generar los números aleatorios.
Para N = 10^6 hubo un tiempo de ejecución de 175 milisegundos y para 10^8 de 17353 milisegundos, con respecto a problemas de memoria no hubo ninguno, tampoco dificultades con la generación de números aleatorios.

Saludos.
En respuesta a Juan Ricardo Demczylo Batista

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Gustavo Martin Ferres Gianoni -
Buenas, para mi implementación use lenguaje Python 3.12, junto con las bibliotecas random, para sortear los números aleatorios, y time, para obtener los tiempos de ejecución para las diferentes iteraciones.

Para un tamaño de muestra de N=1E+6, el tiempo de ejecución fue de 1.9938 segundos.

Personalmente, no hubieron problemas de memoria, ni tampoco dificultades con la generación de números aleatorios, gracias a la biblioteca random, que justamente es la biblioteca que hace mas sencilla la tarea.

Saludos,
Gustavo.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Gonzalo Caricot Layera -
Buenas tardes, en mi caso utilicé Python para implementar lo solicitado, y utilicé las librerías sys, time y numpy.

Respecto a los tiempos de ejecución:
Tiempo insumido para cada N
- Caso N=1E+6: 2.543085813522339 segundos
- Caso N=1E+7: 27.333949089050293 segundos
- Caso N=1E+8: 294.88608980178833 segundos


No tuve problemas de memoria.
A la hora de generar una semilla tampoco fue dificil gracias a la utilización de la librería numpy.
El análisis de estos tiempos de ejecución se logró mediante la librería time.
Finalmente, se puede pasar un tamaño muestral por parámetros usando la librería sys.


Saludos,
Gonzalo
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Nadia Martinez Petrone -
Buenas tardes, yo estoy usando Python 3.12. Para n=10^6 me llevó 5.1154 segundos y para n=10^7 ya me llevó 52.7046 segundos y no seguí probando con n más grandes.
Se me hizo bastante simple el uso de numpy para generar las variables aleatorias y realizar operaciones numéricas y no me he encontrado con problemas de memoria.
Quizá como dijeron otros compañeros, la mayor dificultad que he tenido fue en entender las fórmulas para poder utilizarlas en el código.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Enzo Faliveni Alzueta -
Hola! Para el ejercicio 3.1 usé Python 3.11 con numpy en una instancia AWS m5.2xlarge.

En la Parte A, con 1 millón de muestras, el código tardó 3.67 segundos (no está vectorizado, solo usa un for loop, así que el tiempo escala linealmente si aumentara N). El uso de numpy hizo muy sencilla la generación de números aleatorios y las operaciones, y no hubo problemas de memoria (al no estar vectorizado, no se acumulaban arrays gigantes).

Como comentario adicional la validación en la Parte B para mi simulación resulto con un error relativo de solo 1.7% frente al valor analítico!

Saludos,
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Santiago Daniel Burgueño Paysse -
Buenas, comparto mi experiencia:

Usé Python versión 3.11.5

Para la Parte A con n = 10^6 el tiempo de ejecución me dio 0,08060 segundos.
Tambien para esa parte lo corrí con n = 10^8 (no lo incluí en el informe) y me dio 4,3176 segundos.

Comentarios: Usé NumPy para vectorizar todas las operaciones, lo cual me ayudó a mantener tiempos bajos. Usar bucles for me aumentaba bastante los tiempos.
Tuve que recurrir a las diapositivas varias veces para verificar fórmulas, pseudocodigo y demás para no perderme. Más allá de esto último, no tuve mayores inconvenientes.
Saludos!
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Martin Sebastian Piñeyro Olivera -
Buenas!

Por mi parte utilicé Python 3.11.9 como lenguaje de programación.
En la parte a y con una muestra de n = 106, el tiempo de ejec. fue de 9,6540 segundos.
A modo de probar el programa se experimentó con n = 107, cuyo tiempo de ejecución fue de 141.1190 segundos, lo que evidenció un comportamiento exponencial en el tiempo al ir aumentando el exponente de 10 en cada input del programa. Sin dudas esto representa un punto de mejora ya que no utilicé vectores de Numpy.
 
Personalmente no experimenté problemas de memoria, ni dificultades para emplear las bibliotecas del lenguaje.
El uso de las distribuciones pertenecientes al módulo "random" de Numpy permitieron simplificar la resolución de la tarea.
 
Saludos!!
Martín.
 
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Marco Nicolás Zunino Correa -

Lenguaje: Python 3.12 con Jupyter Notebook

Con un n=10^6 me demoró unos 3 segundos, creo haberlo probado hasta 10^7 (~30s) pero no consideré necesario probar con más muestras, ya que asumo una proporcionalidad directa entre muestras y tiempo. Vengo utilizando iteraciones con 'for' según los seudocódigos planteados en el curso, pero viendo la reducción en tiempo que comentan en los otros mensajes voy a probar las funciones de numpy.

Como dificultad, me resultó molesto esperar que el programa termine de ejecutarse sin saber cuánto más duraría. Para la próxima pretendo incorporar algo de retroalimentación del progreso del programa, como ir mostrando el porcentaje de muestras procesadas sobre el tamaño muestral total.

Saludos,

Marco.

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Ignacio Fourcade Hernandez -
Buenas noches.
- Lenguaje de programación: Utilicé python en su versión 3.12.3.
- Tiempos de ejecución: Para N = 1E+6 insumió un tiempo de 4.2625 segundos.
- No realicé pruebas con N mayores.
- Otros comentarios: En general, la biblioteca NumPy me pareció muy completa, ya que proporciona herramientas para generar números aleatorios, calcular raíces cuadradas y determinar distancias entre puntos, entre muchas otras funciones que pueden ser útiles a lo largo del curso.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Carlos Martinez -
¡Hola!

En mi caso utilicé Python 3.13 en Jupyter Lab. Hice dos implementaciones, ambas son utilizando for loops y no NumPy (la verdad no lo pensé ja!). Una es secuencial en una función única y la otra es paralelizada utilizando una librería llamada Pathos, en particular utilizo una funcionalidad llamada ProcessPool.

El hardware que estoy usando es un Apple M2 Max.

En la implementación secuencial ejecuté experimentos con 10^7 y 10^8 muestras, y obtuve estos resultados:

image.png
En resumen, aproximadamente 0.92s para 10^6 muestras y 92.4s para 10^8 muestras.
 
Con la implementación paralelizada, fui un paso mas y corrí también para 10^9 muestras. Los resultados, usando un ProcessPool de 4 hilos, son los siguientes:

image%20%281%29.png
Se ve como los tiempos que son comparables con la implementación single-threaded se dividen más o menos entre 4. 
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Enrique Galasso Gonzalez -

Buenaaas!! Voy con las respuestas:

- Qué lenguaje utilizó para programar el ejercicio 3.1

Estoy utilizando lenguaje C, compilando con Apple clang version 16.0.0.

(target: arm64-apple-darwin24.3.0)

- Qué tiempo de ejecución insumió el programa en la parte a para un tamaño de muestra N=1E+6

Para ese tamaño de muestra el tiempo de ejecución fue de 0.073652 seg.

- Si realizaron corridas con otros N todavía mayores, y en ese caso cual fue el mayor N que usaron y qué tiempo insumió

# Replicaciones Tiempo de ejecución (seg)
106 0,074767
107 0,701496
108 6,961277
109 69,555272
1010 695,412471

- Otros comentarios (problemas de memoria, dificultades con las bibliotecas de números aleatorios, elementos que hicieron sencillo o complicado resolver la tarea).

En un ppio me había olvidado de establecer la semilla (con srand y la hora del sistema) para el uso de rand. Esto provocaba que las simulaciones fueran siempre las mismas. 

Lo otro que me complicó un poco fue implementar la función para verificar si el punto pertenecía o no a la región R. 

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Lucia Coudet Meas -

Hola buen día,

Para resolver el ejercicio usé Rstudio version 4.4.3 (2025-02-28).

Para el caso de n=10^6 el tiempo de ejecución insumido fue de  6.79032 segundos.

Como comentario, la primer entrega la había realizado utilizando un for loop, y tuve problemas con la memoria para ejecutar iteraciones mayores a 10^4. En esta entrega y alineado a los pseudo códigos que están en las ppt, opté por usar un while loop en lugar del for loop, y no tuve problemas de ejecución.

Sds

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Rafael Mosteiro Crosa -
Buenas tardes:

En mi caso para la entrega utilicé el software R 4.2.2, a partir del interfaz RStudio. La estrategia en el código fue realizar los cálculos vectorizados, y de esta forma, obtuve un tiempo de resolución de 1.15, 5.22 y 51.99 segundos para tamaños de la muestra 10^6, 10^7 y 10^8 respectivamente.

Probé para 10^9 y encontré un problema de memoria, al no poder almacenar un vector de tamaño tan grande. No me preocupé en resolverlo dado que no hacía al ejercicio, pero entiendo que por más que la vectorización sea más "eficiente" en términos de tiempo, se pierde eficiencia en términos de memoria respecto a alguna otra estrategia iterativa. Asimismo, dado que en el trabajo grupal utilizaremos Python, transcribiendo este código a dicho lenguaje de programación da tiempos de ejecución sustancialmente menores.

La mayor dificultad que encontré (encuentro) en la realización del ejercicio, es la de comprender primero el problema a resolver con el fin de traducirlo a código.

Saludos.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Nicolas Sniadover Frutos -

Buenas tardes,

 

- El lenguaje utilizado RStudio - Build 563

 

Corridas y duración:

  1. Cantidad de simulaciones = 10^4, duración de ejecución: 0.088515 segundos
  2. Cantidad de simulaciones = 10^6, duración de ejecución: 5.79342 segundos
  3. Cantidad de simulaciones = 10^7, duración de ejecución: 46.65581 segundos

 

Comentario:

Los tiempo corresponden cuando lo corro en I5 12450H con 2.0 GH, comento esto  porque cuando ejecute en otro PC mas viejito los tiempos aumentaron bastante.

 

Saludos,

Nicolás

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Joaquin Alfonso Becerra Camarero -

Buenas noches,
Yo use Python 3.10.6 porque si bien no es un lenguaje tan eficiente como puede ser uno de más bajo nivel, la libreria numpy que use al igual que varios compañeros facilitó bastante las cosas. Correr la parte A con N=1E+6 me tardó 0m 8s 41ms y no noté problemas de memoria pero se que el codigo podría ser optimizado.

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Maria Luciana Martinez Dinardi -
Hola, cómo están?
Para resolver el ejercicio, asi como para el resto de las entregas, estoy usando Python 3.12.5.
Para calcular el volumen estimado con n = 10^6 =1000000 demoró 1.521 seg
No realicé pruebas para n mayores y tampoco tuve problemas de memoria.
Por el momento no he tenido dificultades para generar los numero aleatorios, he utilizado para todos los casos la libreria random, con random.uniform() para generar valores aleatorios uniformes.
Lo que me ha costado mas o llevado mas tiempo para implementar los laboratorios es entender el teórico y encontrar las ecuaciones exactas para pasarlas a código.
Los seudocódigos que hay en algunos de los teóricos han sido de gran ayuda.

Gracias
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Paula Abbona Santos -
Buenas!

- Lenguaje de programación: python versión 3.11.10
- Tiempos de ejecución: Para N = 1E+6 insumió un tiempo de 10.6197 segundos
- No fue necesario realizar pruebas con N mayores
- Otros comentarios: En general, coincido con los compañeros sobre las facilidades de la biblioteca Numpy.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Juan Pablo Díaz Maurtua -
Buenas, yo utilizé R. El tiempo de ejecución para tamaño de muestra N=1E+6 fue de 4.77 s. No usé una muestra mayor.
Usar el lenguaje R facilita mucho las tareas del curso, ya que tiene nativamente funciones para sortear números aleatorios y otros procesos necesarios.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Juan Luciano Garrido Vidal -
Buenas!

Comparto los resultados que obtuve.

N = 1e+4: 0.0038 segundos
N = 1e+6: 0.4976 segundos
N = 1e+7: 6.446093 segundos

La implementación se realizó de forma vectorizada. No se presentaron problemas de memoria en las ejecuciones realizadas. Tampoco hubo dificultades con las bibliotecas de generación de números aleatorios en R.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Dardo Marcel Fernandez Soarez De Lima -

Buenas, para realizar el programa de la entrega utilice R 4.4.3 sobre Radian en windows.

Para la muestra de tamaño N=1E+6 insumio un tiempo de 3.17 segundos, no probe con N mayores.

El resolver la tarea fue bastante sencillo ya que R contiene funciones nativas para probabilidad y estadistica por lo que no es necesario importar librerias.

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Marcos Alexis Revetria Derquin -
Buenas tardes!

Yo realicé el laboratorio con C++, con un enfoque iterativo, obteniendo un tiempo de ejecución de alrededor 13s para 10^6 y superando los 60s para 10^7. Aunque encontré formas de optimizarlo para reducir el tiempo considerablemente. Viendo los comentarios de otras personas, no tenia idea que el enfoque vectorizado fuera tan eficiente. Siempre creí que las operaciones con vectores usaban de forma implícita una iteración, y que por tanto eran equivalentes a usar un for , pero investigando pude ver que funcionan de manera diferente! xD Por otro lado, no tuve ningún tipo de problema con el ejercicio, afortunadamente me resultó sencillo.

Saludos!
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Julián Peña -
Buenas.

- El lenguaje utilizado fue Octave.
- Para la ejecución con N = 1E+6 se insumió 20.1618 segundos.
- Como no se pedía la ejecución con N mayor, no se hizo la prueba.
- No tuve inconvenientes a la hora de ejecutar el programa. La generación de números aleatorios fue sencilla, ya que Octave tiene librerías que se encargan de esto.

Saludos
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Luciano Dario Capretti Pino -
Buenas tardes.

A continuación detallo cada uno de estos aspectos.

Lenguaje de programación
python 3

Tiempo de ejecución para un tamaño de muestra N = 1E+6.
El tiempo requerido fue de 0.2170 segundos.

Ejecuciones con otros N's
Replicaciones  Tiempo (s)
10 0.0030
1E+2. 0.0000
1E+3. 0.0000
1E+4. 0.0020
1E+5. 0.0270
1E+6. 0.2170
1E+7. 10.2602


Otros comentarios 
La libreria numpy es de gran utilidad ya que permite simplificar en pocas lineas y muy entendible tareas muy laboriosas (en cantidad de lineas y complejidad).


Saludos,
Luciano
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Felipe Miranda Torres De La Llosa -
Buenas tardes,
Comparto mi experiencia con el ejercicio:

Como lenguaje use Python 3.12. Además, para este ejercicio use las bibliotecas numpy y time.
El tiempo de ejecución para N = 1,000,000 fue de 8.8134 segundos, y no realicé corridas para valores mayores de N.

Comentarios:
Use la función random.uniform de la librería numpy para generar la muestra (np.random.uniform(0,1,6)), lo que me permitió generar fácilmente los puntos de (0,1)^6, donde cada componente sigue una distribución U(0,1).
No experimenté problemas de memoria, ni dificultades al usar las bibliotecas del lenguaje.
La versión de la primera parte demoro más tiempo en ejecutar que en la de la segunda parte, por las restricciones que se tiene que verificar en la parte a (en la parte b se eliminaron todas las restricciones, menos la pertenencia a la hiperesfera).
En lo personal creo que este ejercicio ayudo mucho a la comprensión de la sesión 3, y una vez interiorizados los conceptos, la implementación en código no fue demasiado compleja.

Saludos,
Felipe
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Facundo Nicolás Diaz Chagas -
Buenas.
En mi caso utilicé C++, el tiempo de ejecución para N=1E+6 fue de 2580ms.
Solo hice las pruebas solicitadas en la letra y no hubo complicaciones.
Para generar los números aleatorios utilicé Mersenne Twister (mt19937).
Saludos!
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Pablo Gabriel Fialco Goldsztajn -
El lenguaje que utilicé para programar el ejercicio 3.1 fue Python 3.12.7.

El tiempo de ejecución para un tamaño de muestra N = 1E+6 fue de 1,446 segundos en el equipo utilizado.

Se realizaron corridas con otros N todavía mayores. El mayor N que usé fue N = 1E+9 y el tiempo que insumió fue 28 minutos 45,54 segundos

También se realizaron corridas con diferentes semillas (12345 y 11235). Los resultados obtenidos fueron similares.

Con respecto a la memoria, no tuve problemas en el equipo utilizado. Es importante mencionar que no utilicé vectorización. Por su lado, los tiempos de ejecución fueron sensiblemente mayores que cuando comparé con una solución utilizando vectorización. Esto lo hice luego de trabajar en equipo. Si bien el consumo de memoria fue muy superior usando vectorización, no fue un impedimento en el equipo utilizado.

Para generar números aleatorios utilicé la biblioteca random. No tuve dificultades con esta biblioteca. Evalué también numpy para generar números aleatorios y los resultados fueron similares.

Considero que no tuve dificultades para resolver la tarea con los materiales disponibles. Considero que pude comprender la consigna y utilizar las ayudas ofrecidas con un esfuerzo razonable. Las principales dificultades con las que me enfrenté fueron gestionar el tiempo para procesar tanto material disponible y entender los fundamentos matemáticos de los resultados utilizados.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Eitan Ricon Coppola -
Buenas tardes Hector,

Hasta ahora he estado usando Python 3.13 para la realización de los ejercicios del curso.

Para un N=1E+6 obtuve un tiempo de ejecución de 1.9211 segundos.
Para N=1E+4 se obtuvo un tiempo de ejecución de 0.01990 segundos.
Finalmente a modo practico se probo con N=1E+7 y se obtuvo un tiempo de ejecución de 19.8626 segundos.

El principal problema que se presento en este ejercicio y los anteriores fue la caracterización inicial del problema y (puntualmente para la primer entrega) la generación de números aleatorios. A parte de esto no hubo grandes problemas para la resolución de los problemas.

Saludos,
Eitan Ricon.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Carlos Martinez -
¡Hola!

Me quedé pensando en la posibilidad de usar otros lenguajes, y motivado por el compañero que usó Odín (lenguaje del que había estado mirando algunos videos y parece interesante), hice una traducción de mi implementación iterativa en Python a FORTRAN 2008.

Fue divertido :-) Si bien usé el estándard 2008 se nota que por debajo sigue siendo un dinosaurio.
 
Le puse cero esfuerzo a optimzarlo, y no implementé ningún tipo de paralelización. Los tiempos son unas 100 veces mejores que los de la implementación en Python (aclaro de nuevo, siempre comparando las versiones single-threaded). Con esto lo pude llevar a 10^9 muestras sin mayor problema. 

Los resultados:
 
❯ time ./e02_volumenes_r6
 E02 > Volumenes en R6 / MMC 2025 (FORTRAN 2008)
 (c) Carlos M. Martinez
 : N=     1000000  Vol:   9.6890004351735115E-003  | Var:    9.5951335765676049E-009  | time:    3.63689996E-02
 : N=    10000000  Vol:   9.5244003459811211E-003  | Var:    9.4336871647726639E-010  | time:   0.229168996
 : N=   100000000  Vol:   9.4972997903823853E-003  | Var:    9.4071014866692337E-011  | time:    2.29098105
 : N=  1000000000  Vol:   9.4996821135282516E-003  | Var:    9.4094376387743317E-012  | time:    22.8977642
./e02_volumenes_r6  25.37s user 0.10s system 97% cpu 26.016 total

Saludos,
 
/Carlos
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Leonel Anibal Peña Olivet -
Buenas,

Para el ejercicio, implementé el código en Python usando la biblioteca NumPy para generar los valores aleatorios y los números pseudoaleatorios. Para asegurarme de que la semilla fuera reproducible y no quedara al azar, la fijé con entropy de SeedSequence, así no se genera sin que sepamos qué valor tomó.

El tiempo de ejecución que obtuve fue de unos 11.53 segundos para n=10^6. No probé con valores de n más grandes.

Algo que me surgió mirando otras soluciones y tiempos de ejecución es que me dio curiosidad cómo se podría mejorar el tiempo de ejecución usando ejecución en paralelo, por ejemplo, aprovechando tarjetas de video. Me pregunto si eso reduciría los tiempos totales, especialmente en casos donde hay que hacer varias ejecución del mismos código.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Emiliano Federico Viotti Donnangelo -

Buenas, respondo a continuación.

Ambiente

  • Python 3.12.0
  • numpy==2.2.4 y scipy==1.15.2
  • PC: 8 Cores físicos (doble núcleo), frecuencia 2900 MHz y 16GB de Memoria.

Tiempos de Ejecución

n Tiempo (segundos)
10⁴ 1
10⁶ 109
10⁷ 1091


Hasta el momento no he tenido mayores inconvenientes utilizando las bibliotecas de Python.

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Francisco Javier Souza Perez -
Buenos días.
En mi caso utilicé Python versiones 3.12 y 3.7 en distintos procesadores (la maquina buena del trabajo Intel(R) Core(TM) i5-9500 CPU @ 3.00GHz) y la más vieja en casa respectivamente (Intel(R) Core(TM) i3-3110 2.4GHz).
Para N=1E+6 el tiempo en 3.12 : 4 segundos
Para N=1E+6 el tiempo en 3.7 : 8-9 segundos
Realicé corridas con N=1E+8 siendo el tiempo insumido en 3.12: 130 segundos.
Realicé corridas con N=1E+7 siendo el tiempo insumido en 3.7: 1,5hs.
Los principales problemas que tuve fueron de aprendizaje de la herramienta Python, que la estoy utilizando por primera vez, y por tanto bibliotecas y todos los aspectos de programación resultaron desafiantes.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de María Florencia Artucio Maldonado -
Buenas noches,

Para los laboraorios estoy utilizando Python 3.10.11. El tiempo de ejecución para la parte a, con n = 1E+6, fue de 2.4863181114196777 segundos. No realicé corridas con otros valores de n.

El teórico me ayudó bastante a entender el ejercicio, y los pseudocódigos de Montecarlo hicieron más fácil armar el código final.

La mayor dificultad que encontré fue tener que volver a revisar partes del teórico que creía claras, pero que al momento de implementar el ejercicio necesite repasar, pero resulto util para terminar de comprender el metodo.

Saludos!
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Rosita Janet Cortes Ruiz Diaz -

Para la resolución del ejercicio use Python. El tiempo de ejecución para n=1^6 fue casi de 8 segundos. Hice la prueba para n=1^8 sólo por probar y tuve tiempo de ejecución de 16 minutos aprox. 

El tema de tener definido el método de Monte Carlo en seudocódigo y luego poder aplicarlo resulta bueno para ver la practicidad del mismo y ayudar a entenderlo. A pesar de estar trabajando con Python en donde podría haber aprovechado los beneficios de las funciones con vectores preferí hacerlo iterativo, alineándome el seudocódigo. Luego de estas pruebas, en la práctica, y luego de entendido el método probablemente iría por esas funciones.  

En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Santiago Nahuel Herrera Di Lorenzo -
- Qué lenguaje utilizó para programar el ejercicio 3.1

Lo hice en C++, usando CUDA para correr varias instancias de la simulacion en paralelo, cada una con su propio PRNG.

- Qué tiempo de ejecución insumió el programa en la parte a para un tamaño de muestra N=1E+6

Aproximadamente 320 milisegundos, aunque la mayoria del tiempo es inicializacion de las librerias y comunicacion con la GPU. El tiempo de ejecucion escala muy bien a medida que crece N, hasta ~10^11 donde comienza a exceder ~10 segundos.

- Si realizaron corridas con otros N todavía mayores, y en ese caso cual fue el mayor N que usaron y qué tiempo insumió

N = 10^7 -> 383ms
N = 10^8 -> 418ms
N = 10^9 -> 456ms
N = 10^10 -> 1.662s
N = 10^11 -> 15.684s

- Otros comentarios (problemas de memoria, dificultades con las bibliotecas de números aleatorios, elementos que hicieron sencillo o complicado resolver la tarea).

Para poder ejecutar multiples PRNG en paralelo termine escribiendo mi propia implementacion, basada en xorwow. El seeding lo hice de forma un poco incorrecta, donde use SplitMix64 para hacer un shuffle de una variable de 64 bits (threadId<<32 | seed_dada) sin darme cuenta que solo los 32 bits bajos del resultado de SplitMix64 tienen garantias de no correlacion entre iteraciones, entonces varios de los PRNG pueden tender a generar valores similares o no perfectamente equidistribuidos.
En respuesta a Hector Cancela

Re: [RO] experiencias con la segunda entrega - ejercicio 3.1

de Alejandro Sabas Orellano Prantl -
Buenas.
Para este ejercicio utilize python 3.11 y para un tamaño de muestra de 1E+6 el tiempo que insumio fue 13.60 s. Luego probe con un tamaño de 1E+7 y el tiempo que insumio aumento considerablemente a 134.7 s por lo que deje de probar con tamaños de muestra mayores.
No experimente mayores problemas más que la dificultad de entender las formulas para codificar correctamente ya que python con su biblioteca numpy facilita mucho la resolucion del problema. Sin embargo considero que podria haber utilizado de mejor forma dichas herramientas para conseguir un programa con mejor perfomance.

Saludos,
 Alejandro.