def updatefig(*args):
     nonlocal done
     nonlocal obs
     nonlocal HORIZON
     nonlocal timestep
     rebuild, obs_torch = transform_observation(obs)
     if not done and timestep < HORIZON:
         #action, action_proba = vape.act(obs_torch)
         #action = action[0].detach().numpy()
         action = env.action_space.sample()
         action = [action[0], 0.3, 0.0]
         obs, reward, done, info = env.step(action)
         #env.render(mode='human')
         timestep += 1
     else:
         done = False
         obs = env.reset()
         timestep = 0
     c = NHWC(vape.centroids.detach().numpy())
     im.set_array(
         side_by_side(
             side_by_side(side_by_side(obs, rebuild), c[0, :, :, 0]),
             c[1, :, :, 0]))
     vape.optimize_vae(obs_torch, optimizer)
     time.sleep(0.01)
     return im,
示例#2
0
 def test1(self):
     got = side_by_side(["one", "two",], ["1","2",], 12) #12 for convenience
     expected = "\n".join(['',
         #1234567890123456789012345
         " Side-by-side comparison ",
         "____Got_____|__Expected__",
         "one         |1           ",
         "two         |2           ",])
     self.assertEqual(got, expected)
def ref_region(
    img: np.ndarray,
    selem: Any = disk(5),
    sigma: int = 3,
    opening_se: np.ndarray = np.ones((10, 10)),
    closing_se: np.ndarray = np.ones((5, 5)),
    verbose: bool = False
):
    """
    """
    
    # Perform histogram equalisation :
    _img_eq = rank.equalize(img, selem=selem)
    
    # Perform edge detection :
    _edges = canny(_img_eq, sigma=3)
    _filled = ndi.binary_fill_holes(_edges)
    
    # Morphological processing :
    _eroded = utils.closing(
        utils.opening(np.float64(_filled), opening_se), closing_se
    )
    
    if verbose:
        utils.side_by_side(img, _img_eq, title1="Original", title2="Histogram Equalised")
        #plt.title('Lol')
        utils.side_by_side(_img_eq, _filled, title1="Histogram Equalised", title2="Canny Edge Detection + Filled image")
        #plt.title('Lal')
        utils.side_by_side(_filled, _eroded, title1="Canny Edge Detection + Filled image", title2="Opening, closing")
        #plt.title('Lel')
        
    return _eroded
示例#4
0
 def updatefig(*args):
     global done
     global obs
     if not done:
         obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
         mu, _ = vape.encode(obs_torch)
         action, logp = vape.act(obs_torch)
         obs, reward, done, info = env.step(action)
         env.render(mode='human')
     else:
         done = False
         obs = env.reset()
     obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
     rebuild, mu, log_sigma, z = vape.encode_decode(obs_torch)
     rebuild = NHWC(rebuild.detach().numpy()[0])
     im.set_array(side_by_side(obs, rebuild))
     time.sleep(0.01)
     return im,
示例#5
0
 def updatefig(*args):
     nonlocal done
     nonlocal obs
     nonlocal HORIZON
     nonlocal timestep
     obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
     if not done and timestep < HORIZON:
         action, action_proba = vape.act(obs_torch)
         action = action[0].detach().numpy()
         obs, reward, done, info = env.step(action)
         env.render(mode='human')
         timestep += 1
     else:
         done = False
         obs = env.reset()
         timestep = 0
     rebuild = vape.encode_decode(obs_torch)
     rebuild = NHWC(rebuild.detach().numpy()[0])
     im.set_array(side_by_side(obs, rebuild))
     vape.optimize_vae(obs_torch, optimizer)
     time.sleep(0.01)
     return im,
示例#6
0
 def updatefig(*args):
     global done
     global obs
     if not done:
         if policy:
             obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
             mu, _ = vae.encode(obs_torch)
             action, action_proba = policy.act(mu.detach().numpy())
             action = action[0]
         else:
             action = env.action_space.sample()
             action = [action[0], 0.3, 0.0]
         obs, reward, done, info = env.step(action)
         env.render(mode='human')
     else:
         done = False
         obs = env.reset()
     obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
     mu, log_sigma, z, rebuild = vae(obs_torch)
     rebuild = NHWC(rebuild.detach().numpy()[0])
     im.set_array(side_by_side(obs, rebuild))
     time.sleep(0.01)
     return im,
示例#7
0
def main():
    # Parse arguments
    parser = argparse.ArgumentParser(description='REINFORCE using PyTorch')
    # Logging
    parser.add_argument('--alias',
                        type=str,
                        default='base',
                        help="""Alias of the model.""")
    parser.add_argument('--render_interval',
                        type=int,
                        default=100,
                        help='interval between rendered epochs (default: 100)')
    # Learning parameters
    parser.add_argument('--gamma',
                        type=float,
                        default=0.99,
                        help='discount factor (default: 0.99)')
    parser.add_argument('--lr',
                        type=float,
                        default=0.01,
                        help='learning rate (default: 0.01)')

    parser.add_argument('--no-cuda',
                        action='store_true',
                        default=False,
                        help='Enables CUDA training')
    parser.add_argument('--eb',
                        type=int,
                        default=1,
                        help='episode batch (default: 1)')
    parser.add_argument('--episodes',
                        type=int,
                        default=10000,
                        help='simulated episodes (default: 10000)')
    parser.add_argument('--policy',
                        type=str,
                        default=None,
                        help="""Policy checkpoint to restore.""")
    parser.add_argument('--seed',
                        type=int,
                        default=42,
                        help='random seed (default: 42)')
    parser.add_argument('--horizon',
                        type=int,
                        default=1000,
                        help='horizon (default: 1000)')
    parser.add_argument('--baseline',
                        action='store_true',
                        help='use the baseline for the REINFORCE algorithm')
    args = parser.parse_args()
    # Check cuda
    args.cuda = not args.no_cuda and torch.cuda.is_available()
    device = torch.device("cuda" if args.cuda else "cpu")
    # Initialize environment
    env = gym.make('CarRacing-v0')
    env = CropCarRacing(env)
    env = ResizeObservation(env, (32, 32, 3))
    env = Scolorized(env, weights=[0.0, 1.0, 0.0])
    env = NormalizeRGB(env)
    env.seed(args.seed)
    torch.manual_seed(args.seed)
    print("Env final goal:", env.spec.reward_threshold)
    # Create the alias for the run
    alias = '%s_%s' % (args.alias, time.time())
    # Use alias for checkpoints
    checkpoint_best_filename = 'policy_weights/' + alias + '_best.torch'
    checkpoint_final_filename = 'policy_weights/' + alias + '_final.torch'
    if not os.path.exists('weights/'):
        os.makedirs('weights/')
    # Tensorboard writer
    writer = SummaryWriter('logs/' + alias)
    # Create VAE policy
    vape = VAEPolicy()
    optimizer = optim.Adam(vape.parameters(), lr=1e-04)

    # Animation of environment
    obs = env.reset()
    obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
    rebuild = vape.encode_decode(obs_torch)
    rebuild = NHWC(rebuild.detach().numpy()[0])

    fig1 = plt.figure()
    if len(obs.shape) == 3 and (obs.shape[-1] == 1):
        im = plt.imshow(side_by_side(obs, rebuild), cmap="Greys")
    else:
        im = plt.imshow(side_by_side(obs, rebuild))
    done = False
    HORIZON = 200
    timestep = 0

    # Setting animation update function
    def updatefig(*args):
        nonlocal done
        nonlocal obs
        nonlocal HORIZON
        nonlocal timestep
        obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
        if not done and timestep < HORIZON:
            action, action_proba = vape.act(obs_torch)
            action = action[0].detach().numpy()
            obs, reward, done, info = env.step(action)
            env.render(mode='human')
            timestep += 1
        else:
            done = False
            obs = env.reset()
            timestep = 0
        rebuild = vape.encode_decode(obs_torch)
        rebuild = NHWC(rebuild.detach().numpy()[0])
        im.set_array(side_by_side(obs, rebuild))
        vape.optimize_vae(obs_torch, optimizer)
        time.sleep(0.01)
        return im,

    # Start animation
    ani = animation.FuncAnimation(fig1, updatefig, interval=50, blit=True)
    plt.show()
    # Close env and writer
    env.close()
    writer.close()
mangueras_segmentadas = {
    key: auto_segment(mangueras[key], verbose=False, groups=2, skew=None) for key in mangueras.keys()
}


# Aquí segmentamos automáticamente la región de la manguera, gracias al gran contraste que existe entre éste nuestro ente de interés y el fondo (muy claro el primero, oscuro el segundo).
# 
# Usamos la función que diseñamos : ```auto_segment()```

# In[13]:


for nombre in mangueras.keys():
    utils.side_by_side(
        mangueras[nombre], mangueras_segmentadas[nombre], 
        title1=nombre, title2=f"{nombre} : manguera segmentada"
    )


# Aquí podemos observar las imágenes con su respectiva máscara de segmentación.

# In[14]:


region_ref1 = {
    key: auto_segment(mangueras[key], groups=3) for key in mangueras.keys()
}


# In[15]:
示例#9
0
        env = Scolorized(env, weights=[0.0, 1.0, 0.0])
        env.seed(args.seed)

    # Network creation
    VAE_class = VAEbyArch(args.arch)
    vae = VAE_class(latent_size=args.latent_size).to(device)
    # Restore checkpoint
    assert args.vae, "No checkpoint provided."
    vae.load_state_dict(torch.load(args.vae))
    vae.eval()

    if args.dataset:
        # Single observation display
        mu, log_sigma, z, rebuild = vae(dataset_torch[args.sample:args.sample+1])
        rebuild = rebuild.detach().numpy()[0]
        imshow_bw_or_rgb(side_by_side(dataset[args.sample], NHWC(rebuild)))
        plt.show()
    else:
        # Check if we use a policy
        policy = None
        if args.policy and args.vae_old:
            policy_env = VAEObservation(env, args.vae_old, arch=args.arch)
            policy = Policy(policy_env)
            policy.load_state_dict(torch.load(args.policy))
            policy.eval()
            vae_old = VAE_class(latent_size=args.latent_size).to(device)
            vae_old.load_state_dict(torch.load(args.vae_old))
            vae_old.eval()
        # Animation of environment
        obs = env.reset()
        obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
示例#10
0
 def _test(self, source, expected):
     got, ignore = pretty.consolidate_php(source, [])
     msg = side_by_side(got, expected)
     self.assertEqual(got, expected, msg)
示例#11
0
 def _test(self, source, expected):
     got, ignore = comments.standardize_comments(source, [])
     msg = side_by_side(got, expected)
     self.assertEqual(got, expected, msg)
示例#12
0
sns.distplot(intensities, kde=False, rug=True, bins=10)
plt.axvline(K, color='r')
lmap(lambda x: plt.axvline(x, color='g'), centers1)
_ = plt.title(f"Means = {centers1}, K = {K}", size=16)


# In[14]:


thresh1 = cv.threshold(img, K, 255, cv.THRESH_BINARY)[1]


# In[15]:


utils.side_by_side(img, thresh1)


# Como podemos ver, una técinca de umbralización estándar como k-medias móviles, con dos medias, da resultados muy pobres.

# In[16]:


otsu1 = cv.threshold(img,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU)[1]


# In[17]:


utils.side_by_side(img, otsu1)
示例#13
0
# In[9]:

binaria = binarise(x)
plt.imshow(binaria, cmap='gray')

# In[10]:

help(opening)

# # Opening

# In[11]:

kernel = np.ones((10, 10))
side_by_side(binaria,
             opening(binaria, kernel),
             title1='Original',
             title2=f'opening() with Kernel {kernel.shape}')

# In[12]:

kernel = np.ones((10, 10))
side_by_side(binaria,
             cv.morphologyEx(binaria, cv.MORPH_OPEN, kernel),
             title1='Original',
             title2=f'cv.MORPH_OPEN with Kernel {kernel.shape}')

# In[13]:

kernel = np.ones((2, 50))
side_by_side(binaria,
             opening(binaria, kernel),
示例#14
0
plt.imshow(x, cmap='gray')

# In[7]:

binaria = binarise(x)
plt.imshow(binaria, cmap='gray')

# In[8]:

help(cv.dilate)

# In[9]:

kernel = np.ones((10, 10))
side_by_side(binaria,
             cv.dilate(binaria, kernel),
             title1='Original',
             title2=f'Kernel {kernel.shape}')

# In[10]:

kernel = np.ones((2, 50))
side_by_side(binaria,
             cv.dilate(binaria, kernel),
             title1='Original',
             title2=f'Kernel {kernel.shape}')

# In[11]:

kernel = np.ones((50, 2))
side_by_side(binaria,
             cv.dilate(binaria, kernel),
示例#15
0
plt.imshow(x, cmap='gray')

# In[7]:

binaria = binarise(x)
plt.imshow(binaria, cmap='gray')

# In[8]:

help(cv.erode)

# In[9]:

kernel = np.ones((10, 10))
side_by_side(binaria,
             cv.erode(binaria, kernel),
             title1='Original',
             title2=f'Kernel {kernel.shape}')

# In[10]:

kernel = np.ones((2, 30))
side_by_side(binaria,
             cv.erode(binaria, kernel),
             title1='Original',
             title2=f'Kernel {kernel.shape}')

# In[11]:

kernel = np.ones((70, 2))
side_by_side(binaria,
             cv.erode(binaria, kernel),
示例#16
0
    vape = VAEPolicy()
    # Restore checkpoint
    assert args.controller, "No checkpoint provided."
    vape.load_state_dict(torch.load(args.controller))
    vape.eval()

    # Animation of environment
    obs = env.reset()
    obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
    rebuild, mu, log_sigma, z = vape.encode_decode(obs_torch)
    rebuild = NHWC(rebuild.detach().numpy()[0])

    fig1 = plt.figure()
    if len(obs.shape) == 3 and (obs.shape[-1] == 1):
        im = plt.imshow(side_by_side(obs, rebuild), cmap="Greys")
    else:
        im = plt.imshow(side_by_side(obs, rebuild))
    done = False

    # Setting animation update function
    def updatefig(*args):
        global done
        global obs
        if not done:
            obs_torch = torch.from_numpy(NCHW([obs])).float().to(device)
            mu, _ = vape.encode(obs_torch)
            action, logp = vape.act(obs_torch)
            obs, reward, done, info = env.step(action)
            env.render(mode='human')
        else: