9º Hora

8º Hora

7º Hora

6º Hora

5º hora

4º Hora

3º Hora

2º Hora

1º Hora

7ª hora Open Course

En las imágenes anteriores, introducimos el concepto de movimiento a nuestro código para el cálculo de probabilidades de posición y localización de nuestro robot.

Aquí tenemos que si consideramos cíclico el espacio donde se mueve nuestro robot, tendremos que además de la probabilidad de localización, tendremos la probabilidad de movimiento. tendremos que calcular la probabilidad de encontrarse en un punto como hemos hecho antes, dos veces, una antes de desplazarse y otra después.

Para ello un vector ( 0  0  0  1  0) con Velocidad=1 , encontramos que después de nuestro primer calculo tendrá la siguiente forma ( 0  0  0  0.6 0), en el siguiente paso ( 0.6  0  0  0.6  0.6); en el siguiente ( 0.06  0  0  0.06  0.48) y en el último paso (0.1  0  0  0.1  0.8). En este punto, sabemos que el robot estará en el último punto con una probabilidad de un 0.8.

5 y 6ª Hora Open Course

Por 4 vez, abajo explico lo poco que se aprecia la fotografía.

Ahora, en este punto, sabemos donde está nuestro robot con una precisión simple.
Así que actualizaremos la medida con la corrección para que se adecue a una distribución de probabilidad. Además incluiremos un segundo factor donde verificaremos la posición de nuestro robot. Y añadiremos el concepto de movimiento a nuestra función,


Integración en python:

p=[0.2 , 0.2 , 0.2 , 0.2 , 0.2]

world=["green" , "red" , "red" , "green" , "green" ]

#Z="red" 

measurements=["red" , "green"]
pHit=0.6

pMiss=0.2

def loc(p , Z):
  q=[]
  for i in range(len(p)):
       hit=(measurements==world[i])
       q.append(p[i]*(hit*pHit+(1-hit)*pMiss))

  k=sum(q)
  for i in range(len(q)):
       q[i]=q[i]*k

return q

for i in range(measurements)

   p=loc(p,measurements[i])
print p

3ª y 4ª Hora Open Course

De nuevo, aquí la explicación de lo de arriba.

El curso prosigue con la integración de las funciones de localización y movimiento.

Integración en python de la función de localización :

p=[0.2 , 0.2 , 0.2 , 0.2 , 0.2]

world=["green" , "red" , "red" , "green" , "green" ]
Z="red"
pHit=0.6

pMiss=0.2

def loc(p , Z):
  q=[]
  for i in range(len(p)):
       hit=(Z==world[i])
       q.append(p[i]*(hit*pHit+(1-hit)*pMiss))
return q

2ª Hora Open Course

Como en la anterior publicación, os explicaré las notas.

Aquí, he gastado más de la hora dado que desconocía el uso del lenguaje python. En esta hora, en el curso se propone hacer la integración de la primera parte de la entrada anterior. Hasta este punto calculamos las probabilidades directas de que nuestro robot este en un sitio u otro. ahora calcularemos esa misma probabilidad en una distribución diferente. Para ello multiplicamos las celdas de nuestro vector por un numero bajo, si nuestro robot no está ahí; por un número alto si creemos que se encuentra en esa posición. De esta manera, si tenemos un vector ( 0  1  0  0)

tras esta modificación tendremos ( 0  0.6  0  0).
Este vector modificado, no lo podemos considerar útil para la estadística dado que la probabilidad de sus partes no suma uno. Para rectificar este error que hemos creado, dividimos todo por la suma de las componentes del vector. 

La integración en python:

n=input("longitud del vector de posiciones")

for i in range(n):

    #p[i]=input("color de la casilla [rojo / verde]")

    P[i]=1.0/n

print P

La integración en C++: (código insertarle en main { } )

int n=0;

printf("Cuan largo quieres que sea el vector de posiciones? :  ")

scanf("%d", n);

printf("\n\n\n");

double *p;

for(int i=0; i<n;i++){
      int* p=new int[i];
      p[i]=1.0/n
}

1ªHora Open Course

Dado que al escanear mis apuntes no he podido recogerlos con mayor calidad, os explico las notas recogidas.


En las notas que he tomado durante la primera hora del curso, he destacado la información sobre la localización autónoma del robot,
En esta primera hora, se nos explicaba como un robot puede encontrarse a si mismo.
Uno de los ejemplos que ponen es el uso de gps, el cual tiene ciertas taras, como la inexactitud a una escala tan baja como la que opera un coche autónomo. Para eso usan lasers y ciertos sensores.
Mediante estadística resaltamos ciertas ares y definimos una función (similar a la física cuántica, donde también definimos la posibilidad de encontrar un átomo, pero de menor complejidad ).
De esta manera obtenemos una función que se vera modificada por el movimiento, donde encontraremos una probabilidad de estar, por ejemplo, en un cuadro rojo frente a la de estar en uno verde. Es decir, si hay 5 casillas, dos de color rojo y 3 de color verde, la probabilidad de estar en una de ellas será 0.2 o un 20%. De igual manera, al avanzar una casilla tendremos que habrá un 80% de probabilidades de estar en la casilla siguiente, un 10% de seguir en la que estamos y un 10% de haber avanzado un poco de más y continuar en la casilla siguiente a la que queríamos.

primeras 7h de open course

​

 drive-download-20180504T200906Z-001.zip

​

2h

1h

5º Hora Open Course

4º Hora Open Course

3º Hora Open Course

2º Hora Open Course

1º Open Course

HORA 6 DIMA

HORA 9 OPEN COURSE

Mi novena y última hora corresponde con un ejercicio de programación, por lo que no adjunto fotos.

No se por qué al enviar el correo las tabulaciones del código desaparecen

# Write a function 'kalman_filter' that implements a multi-

# dimensional Kalman Filter for the example given

from math import *

class matrix:

# implements basic operations of a matrix class

def __init__(self, value):

self.value = value

self.dimx = len(value)

self.dimy = len(value[0])

if value == [[]]:

self.dimx = 0

def zero(self, dimx, dimy):

# check if valid dimensions

if dimx < 1 or dimy < 1:

raise ValueError, "Invalid size of matrix"

else:

self.dimx = dimx

self.dimy = dimy

self.value = [[0 for row in range(dimy)] for col in range(dimx)]

def identity(self, dim):

# check if valid dimension

if dim < 1:

raise ValueError, "Invalid size of matrix"

else:

self.dimx = dim

self.dimy = dim

self.value = [[0 for row in range(dim)] for col in range(dim)]

for i in range(dim):

self.value[i][i] = 1

def show(self):

for i in range(self.dimx):

print(self.value[i])

print(' ')

def __add__(self, other):

# check if correct dimensions

if self.dimx != other.dimx or self.dimy != other.dimy:

raise ValueError, "Matrices must be of equal dimensions to add"

else:

# add if correct dimensions

res = matrix([[]])

res.zero(self.dimx, self.dimy)

for i in range(self.dimx):

for j in range(self.dimy):

res.value[i][j] = self.value[i][j] + other.value[i][j]

return res

def __sub__(self, other):

# check if correct dimensions

if self.dimx != other.dimx or self.dimy != other.dimy:

raise ValueError, "Matrices must be of equal dimensions to subtract"

else:

# subtract if correct dimensions

res = matrix([[]])

res.zero(self.dimx, self.dimy)

for i in range(self.dimx):

for j in range(self.dimy):

res.value[i][j] = self.value[i][j] - other.value[i][j]

return res

def __mul__(self, other):

# check if correct dimensions

if self.dimy != other.dimx:

raise ValueError, "Matrices must be m*n and n*p to multiply"

else:

# multiply if correct dimensions

res = matrix([[]])

res.zero(self.dimx, other.dimy)

for i in range(self.dimx):

for j in range(other.dimy):

for k in range(self.dimy):

res.value[i][j] += self.value[i][k] * other.value[k][j]

return res

def transpose(self):

# compute transpose

res = matrix([[]])

res.zero(self.dimy, self.dimx)

for i in range(self.dimx):

for j in range(self.dimy):

res.value[j][i] = self.value[i][j]

return res

# Thanks to Ernesto P. Adorio for use of Cholesky and CholeskyInverse functions

def Cholesky(self, ztol=1.0e-5):

# Computes the upper triangular Cholesky factorization of

# a positive definite matrix.

res = matrix([[]])

res.zero(self.dimx, self.dimx)

for i in range(self.dimx):

S = sum([(res.value[k][i])**2 for k in range(i)])

d = self.value[i][i] - S

if abs(d) < ztol:

res.value[i][i] = 0.0

else:

if d < 0.0:

raise ValueError, "Matrix not positive-definite"

res.value[i][i] = sqrt(d)

for j in range(i+1, self.dimx):

S = sum([res.value[k][i] * res.value[k][j] for k in range(self.dimx)])

if abs(S) < ztol:

S = 0.0

try:

res.value[i][j] = (self.value[i][j] - S)/res.value[i][i]

except:

raise ValueError, "Zero diagonal"

return res

def CholeskyInverse(self):

# Computes inverse of matrix given its Cholesky upper Triangular

# decomposition of matrix.

res = matrix([[]])

res.zero(self.dimx, self.dimx)

# Backward step for inverse.

for j in reversed(range(self.dimx)):

tjj = self.value[j][j]

S = sum([self.value[j][k]*res.value[j][k] for k in range(j+1, self.dimx)])

res.value[j][j] = 1.0/tjj**2 - S/tjj

for i in reversed(range(j)):

res.value[j][i] = res.value[i][j] = -sum([self.value[i][k]*res.value[k][j] for k in range(i+1, self.dimx)])/self.value[i][i]

return res

def inverse(self):

aux = self.Cholesky()

res = aux.CholeskyInverse()

return res

def __repr__(self):

return repr(self.value)

########################################

# Implement the filter function below

def kalman_filter(x, P):

for n in range(len(measurements)):

# measurement update

z=matrix([[measurements[n]]])

y=z-H*x

S=H*P*H.transpose()+R

K=P*H.transpose()*S.inverse()

x=x+(K*y)

P=(I-K*H)*P

# prediction

x=F*x+u

P=F*P*F.transpose()

return x,P

############################################

### use the code below to test your filter!

############################################

measurements = [1, 2, 3]

x = matrix([[0.], [0.]]) # initial state (location and velocity)

P = matrix([[1000., 0.], [0., 1000.]]) # initial uncertainty

u = matrix([[0.], [0.]]) # external motion

F = matrix([[1., 1.], [0, 1.]]) # next state function

H = matrix([[1., 0.]]) # measurement function

R = matrix([[1.]]) # measurement uncertainty

I = matrix([[1., 0.], [0., 1.]]) # identity matrix

print(kalman_filter(x, P))

# output should be:

# x: [[3.9996664447958645], [0.9999998335552873]]

# P: [[2.3318904241194827, 0.9991676099921091], [0.9991676099921067, 0.49950058263974184]]

HORA 8 OPEN COURSE

HORA 7 OPEN COURSE