cambios SPD 2024-10-22 15:07:47

.obsidian/community-plugins.json

@@ -5,6 +5,5 @@
   "iconic",
   "obsidian-banners",
   "obsidian-enhancing-export",
-  "obsidian-latex-suite",
   "obsidian-git"
 ]

.obsidian/workspace.json

@@ -11,14 +11,12 @@
             "id": "d8a559569207f8b1",
             "type": "leaf",
             "state": {
-              "type": "markdown",
+              "type": "image",
               "state": {
-                "file": "TERCERO/SS/SS 24-25.md",
+                "file": "TERCERO/SPD/images/Pasted image 20241022150214.png"
-                "mode": "source",
-                "source": false
               },
-              "icon": "lucide-file",
+              "icon": "lucide-image",
-              "title": "SS 24-25"
+              "title": "Pasted image 20241022150214"
             }
           }
         ]
@@ -77,8 +75,7 @@
       }
     ],
     "direction": "horizontal",
-    "width": 300,
+    "width": 300
-    "collapsed": true
   },
   "right": {
     "id": "44cf06183e1c1c7d",
@@ -175,23 +172,23 @@
       "obsidian-git:Open Git source control": false
     }
   },
-  "active": "d8a559569207f8b1",
+  "active": "a4eac8e6613b153b",
   "lastOpenFiles": [
-    "Pasted image 20241017113556.png",
+    "TERCERO/SPD/P4_SPD.md",
-    "Pasted image 20241017113522.png",
+    "TERCERO/SPD/images/Pasted image 20241022150214.png",
-    "TERCERO/SS/SS 24-25.md",
+    "TERCERO/SPD/images/Pasted image 20241022144832.png",
-    "Pasted image 20241017113508.png",
+    "TERCERO/SPD/images/Pasted image 20241022144429.png",
-    "Pasted image 20241017113506.png",
-    "Pasted image 20241017113505.png",
-    "TERCERO/SS/images/Pasted image 20241017113303.png",
-    "TERCERO/SS/images/Pasted image 20241017112904.png",
     "TERCERO/SPD/Teoría_2425.md",
-    "TERCERO/ATR1/images/Pasted image 20241014101113.png",
+    "TERCERO/SPD/images/Pasted image 20241022134454.png",
-    "TERCERO/ATR1/images/Pasted image 20241014100406.png",
+    "Imagen de WhatsApp 2024-10-22 a las 11.43.21_270060da.jpg",
-    "TERCERO/ATR1/images/Pasted image 20241014100308.png",
+    "TERCERO/IA/images/tic-tac-toe.gif",
-    "TERCERO/ATR1/images/Pasted image 20241014092122.png",
-    "TERCERO/ATR1/Teoría_2425.md",
     "TERCERO/IA/Teoría_2425.md",
+    "TERCERO/IA/images/mcts.gif",
+    "TERCERO/IA/images/mcts.png",
+    "TERCERO/IA/images/minimax-algorithm-animation.gif",
+    "TERCERO/SS/images/Pasted image 20241017113556.png",
+    "TERCERO/SS/SS 24-25.md",
+    "TERCERO/ATR1/Teoría_2425.md",
     "TERCERO/SS/SS Lab.md",
     "SEGUNDO/ADDA/Teoría_2324.md",
     "TERCERO/IA/Apuntes Julia.md",
@@ -222,7 +219,6 @@
     "SEGUNDO/SO/Untitled.md",
     "SEGUNDO/SO/Sin título.md",
     "SEGUNDO/SO/Sin título.canvas",
-    "SEGUNDO/SO/Untitled 2.md",
+    "SEGUNDO/SO/Untitled 2.md"
-    "SEGUNDO/SO/Untitled 1.md"
   ]
 }

TERCERO/IA/Teoría_2425.md

@@ -325,3 +325,47 @@ y una velocidad $v_{i}$.
 
 ![[Pasted image 20241011121847.png|400]]
 La fuerza con que las partículas son empujadas a cada dirección se basa en la atracción a $x_{i}^{pb}$ y $x^{gb}$.
+# <mark style="background: #FFF3A3A6;">TEMA 5: Búsquedas con incertidumbre</mark>
+### <mark style="background: #FFB86CA6;">Juego formal</mark>
+Un juego formal es una variante de un espacio de estados $(S,P,A,T,g,U)$ donde:
+- $S:$ es el conjunto de estados comenzando por el estado inicial $s_{o}\in S$
+- $P:$ es el conjunto de jugadores $P=\{1,\dots ,n\}$
+- $A:$ son las acciones
+- $T:$ es la función de transferencia $T:S\times A\rightarrow S$, que indica cómo cambian los estados.
+- $g:$ indica si un estado del juego es terminal (goal) $g:S\rightarrow\{true,false\}$
+- $U:$ es una función de utilidad $U:S\times P\rightarrow \rm I\! R$ de estados terminales que indica lo bueno que es un estado terminal para cada jugador.
+## <mark style="background: #ADCCFFA6;">1. Algoritmo Minimax</mark>
+Los pasos son:
+1. Generar el árbol de juego a partir del estado actual hasta llegar a un estado terminal.
+2. Se calculan los valores de la función de evaluación para  cada nodo terminal.
+3. Se evalúan los nodos superiores a partir del valor de los inferiores. Según si estos pertenecen a un nivel MAX o MIN, se elegirán los valores mínimos y máximos representando los valores del jugador y del oponente.
+4. Se repite el paso 3 hasta llegar al nodo superior (estado actual).
+5. Se selecciona la jugada-nodo directamente accesible desde el actual que maximiza el valor de la evaluación.
+![[minimax-algorithm-animation.gif]]
+El problema de esta búsqueda es que el número de estados puede ser exponencial. Si $r$ es cuántos hijos tiene cada nodo y $m$ el nivel de profundidad, la complejidad en tiempo es del orden $O(r^m)$ y en espacio del orden $O(rm)$. 
+### <mark style="background: #FFB86CA6;">Poda alfa-beta</mark>
+La idea es que cada nodo se analiza teniendo en cuenta el valor que por el momento tiene el nodo y el valor que por el momento tiene su padre, lo que determina en cada momento un intervalo $(\alpha,\beta)$ de posibles valores que podría tomar el nodo. El intervalo tiene un significado depende del nodo:
+- En nodos $MAX$: $\alpha$ es el valor del nodo actual (que tendrá ese valor o superior) y $\beta$ es el valor del padre (que tendrá ese valor o inferior).
+- En nodos $MIN$: $\beta$ es el valor del nodo actual (que tendrá ese valor o inferior) y $\alpha$ es el valor del padre (que tendrá ese valor o superior).
+La poda se produce si en algún momento $\alpha\geq\beta$ y en ese momento ya no se analizan los sucesores restantes.
+## <mark style="background: #ADCCFFA6;">2. Monte Carlo Tree Search</mark>
+### <mark style="background: #FFB86CA6;">Problema de las tragaperras múltiples</mark>
+Hay $K$ máquinas y cada una suelta una "riqueza" cada vez que se juega. Las riquezas son variables aleatorias $\{X_{i,n}:1\leq i\leq K,n~\geq 1\}$, donde $i$ es el índice de cada máquina y la $n$ la tirada.
+
+En estas condiciones una **estrategia (policy)** es un algoritmo $A$ que elige la siguiente máquina basándose en la secuencia de jugadas anteriores y los premios recibidos. Si $T_i(n)$ es el número de veces que el algoritmo $A$ ha seleccionado la máquina $i$ durante las primeras $n$ jugadas, la pérdida por no haber elegido siempre la mejor máquina posible viene dada por:
+$$
+\begin{equation}
+\mu^*n-\sum\limits_{i=1}^K{\mu_{i}E[T_{i}(n)]} 
+\end{equation}
+$$
+donde $\mu^*=max_{1\leq i\leq K}\mu_{i}$ 
+
+Se puede usar una estrategia, llamada **UCB (Upper Confidence Bound)** que construye intervalos estadísticos para cada máquina, que es esencialmente la confianza basada en la media de ganancias dentro de un radio dado por $\sqrt{\frac{2\ln{n}}{T_i(n)}}$.
+### <mark style="background: #FFB86CA6;">Aplicación a búsquedas</mark>
+
+![[mcts.png|600]]
+1. **Selección:** se realiza mientras tengamos las estadísticas necesarias para tratar cada estado alcanzado como un problema de tragaperras múltiples. Comenzando por el raíz se selecciona recursivamente el estado más urgente (de acuerdo a UCB) hasta alcanzar un estado terminal o que no está completamente extendido.
+2. **Expansión:** para cuando ya no se puede aplicar Selección. Se elige aleatoriamente una posición sucesora no visitada y se añade un nuevo estado al árbol de estadísticas.
+3. **Simulación:** partiendo del estado recién añadido se simula una partida completa, ya sea al azar o con una heurística. Se obtiene un valor (premio, recompensa, etc) que determina la utilidad de esa rama para el jugador.
+4. **Actualización:** con el estado final alcanzado de la fase anterior se actualizan las estadísticas de todas las posiciones previas visitadas durante la simulación que se ejecutó a partir del nuevo estado (incluyendo la cuenta de ganancias). 
+![[mcts.gif]]

TERCERO/SPD/P4_SPD.md

@@ -0,0 +1,86 @@
+# <mark style="background: #FF5582A6;">ASM / C</mark>
+### a) ¿Qué hace el código?
+Recorre el array `arrayx` (empezando por la posición 1) de tamaño `N_ITER` almacenando en la posición `i - 1` la suma del elemento `i` más el `i + 1` entre la constante `f11`.
+### b) ¿Cómo se puede escribir en alto nivel?
+```C
+#define N_ITER 25
+
+float arrayx[N_ITER];
+const float f11 = 21.0;
+
+for(int i = 1; i < N_ITER; i++)
+{
+	arrayx[i - 1] = ( arrayx[i] + arrayx[i + 1] ) / f11; 
+}
+```
+### c) ¿Son paralelizables directamente?
+Sí porque no hay dependencias reales.
+```C
+#define N_ITER 25
+
+float arrayx[N_ITER];
+const float f11 = 21.0;
+
+for(int i = 5; i < N_ITER; i+=5)
+{
+	arrayx[i - 1] = ( arrayx[i] + arrayx[i + 1] ) / f11;
+	arrayx[i - 2] = ( arrayx[i + 1] + arrayx[i + 2] ) / f11;
+	arrayx[i - 3] = ( arrayx[i + 2] + arrayx[i + 3] ) / f11;
+	arrayx[i - 4] = ( arrayx[i + 3] + arrayx[i + 4] ) / f11;
+	arrayx[i - 5] = ( arrayx[i + 4] + arrayx[i + 5] ) / f11; 
+}
+```
+### d) Como la BTB predice siempre tomado ¿cuándo acierta?
+La BTB acertará en todas las iteraciones del bucle excepto en la última porque predice salto tomado y no debería tomarlo porque el bucle ha acabado.
+![[Pasted image 20241022134454.png]]
+### e) Si la BTB de un GPP es muy sofisticada ¿acertará en los saltos?
+...
+# <mark style="background: #D2B3FFA6;">Visual Studio</mark>
+La función más paralelizable es **`pp4()`** ya que sólo tiene una operación de cada tipo (**`LD, SF, ADDF, SLTI, ADDI`**) y no hay saltos condicionales en el bucle.
+```C
+double pp4()
+{
+	int i;
+	for (i = 0; i<N_ITER; i++)	{
+		a[i] = a[i] + 8.0;
+	}
+	return a[N_ITER - 1];
+}
+```
+
+La función que más se parece (parecer en términos de mismo tipo de instrucciones) es **`pp2()`**.
+```C
+double pp2()
+{
+	int i;
+	for (i = 0; i<N_ITER; i++)	{
+		a[i] = 3.14 / sqrt(b[i]+c[i]);
+	}
+	return a[N_ITER - 1];
+}
+```
+
+### <mark style="background: #FFB8EBA6;">Máquina en la que se ejecuta el código real:</mark>
+
+![[Pasted image 20241022144429.png|400]]
+
+### <mark style="background: #FFB8EBA6;">Comparativa</mark>
+
+| `pp2()`                                                                                                                                | `nuestro`                                                                                                                                                                             |
+| -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| double pp2()<br>{<br>	int i;<br>	for (i = 0; i<N_ITER; i++)	{<br>		a[i] = 3.14 / sqrt(b[i]+c[i]);<br>	}<br>	return a[N_ITER - 1];<br>} | # define N_ITER 25<br><br>float arrayx[N_ITER];<br>const float f11 = 21.0;<br><br>for(int i = 1; i < N_ITER; i++)<br>{<br>	arrayx[i - 1] = ( arrayx[i] + arrayx[i + 1] ) / f11; <br>} |
+| Este código tiene:<br>- 2x LDF<br>- 1x STF<br>- 1x ADDF<br>- 1x DIVF<br>- 1x constante                                                 | Nuestro código tiene:<br>- 2x LDF<br>- 1x STF<br>- 1x ADDF<br>- 1x DIVF<br>- 1x constante                                                                                             |
+|                                                                                                                                        |                                                                                                                                                                                       |
+### <mark style="background: #FFB8EBA6;">Duración de CPI en los bucles</mark>
+
+| Release                              | Debug                                |
+| ------------------------------------ | ------------------------------------ |
+| ![[Pasted image 20241022144832.png]] | ![[Pasted image 20241022150214.png]] |
+
+(Todo para config1 y config2)
+1. CPI (supertomasim)
+2. CPI (reordenado). Cambiar escalaridad (m=1, m=grande).
+3. Identificar CPI_bloq
+5. GFLOPS (o MIPS)
+6. CPI (pp2 pp4) y Ac
+7. Cronograma