def load_vae(path=None, z_size=None):
# z_size will be recovered from saved model
if z_size is None:
assert path is not None
vae = VAEController(z_size=z_size)
if path is not None:
if path.endswith('.json'):
vae.load_json(path)
else:
vae.load(path)
print("Dim VAE = {}".format(vae.z_size))
return vae
def main():
parser = argparse.ArgumentParser(description="latent space enjoy")
parser.add_argument('--log-dir',
default='',
type=str,
help='directory to load model')
parser.add_argument('-vae',
'--vae-path',
help='Path to saved VAE',
type=str,
default='')
args = parser.parse_args()
vae = VAEController()
vae.load(args.vae_path)
fig_name = "Decoder for the VAE"
# TODO: load data to infer bounds
bound_min = -10
bound_max = 10
create_figure_and_sliders(fig_name, vae.z_size)
should_exit = False
while not should_exit:
# stop if escape is pressed
k = cv2.waitKey(1) & 0xFF
if k == 27:
break
state = []
for i in range(vae.z_size):
state.append(cv2.getTrackbarPos(str(i), 'slider for ' + fig_name))
# Rescale the values to fit the bounds of the representation
state = (np.array(state) / 100) * (bound_max - bound_min) + bound_min
reconstructed_image = vae.decode(state[None])[0]
reconstructed_image = cv2.cvtColor(reconstructed_image,
cv2.COLOR_RGB2BGR)
# stop if user closed a window
if (cv2.getWindowProperty(fig_name, 0) < 0) or (cv2.getWindowProperty(
'slider for ' + fig_name, 0) < 0):
should_exit = True
break
cv2.imshow(fig_name, reconstructed_image)
# gracefully close
cv2.destroyAllWindows()
def load_vae(path=None, z_size=None):
"""
:param path: (str)
:param z_size: (int)
:return: (VAEController)
"""
# z_size will be recovered from saved model
if z_size is None:
assert path is not None
vae = VAEController(z_size=z_size)
if path is not None:
vae.load(path)
print("Dim VAE = {}".format(vae.z_size))
return vae
from jetracer.nvidia_racecar import NvidiaRacecar
from jetcam.csi_camera import CSICamera
import time
import vae
from vae.controller import VAEController
from stable_baselines import SAC
car = NvidiaRacecar()
throttle = 0.8
#path = "jetcar_weights.pkl"
path = "logs/sac/JetVae-v0_46/JetVae-v0.pkl"
input_array = np.zeros((1, 256))
try:
i = 0
v = VAEController()
v.load("logs/vae-256.pkl")
#model = keras.models.load_model(path)
model = SAC.load(path)
camera = CSICamera(width=112, height=112)
camera.running = True
print("Imported Camera! Ready to Start!")
while True:
print("Starting to read image")
image = camera.value.copy()
print("Image Read!")
#image = cv2.resize(image, (224//2, 224//2))
print(type(image))
tmp = v.encode_from_raw_image(image)
print("Got image")
input_array[0,:] = tmp
logger.configure(folder='/tmp/ddpg_carla/')
# Initialize VAE model and add it to gym environment.
# VAE does image post processing to latent vector and
# buffers raw image for future optimization.
vae = VAEController()
env.unwrapped.set_vae(vae)
# Run in test mode of trained models exist.
if os.path.exists(PATH_MODEL_DDPG + ".pkl") and \
os.path.exists(PATH_MODEL_VAE):
print("Task: test")
ddpg = DDPG.load(PATH_MODEL_DDPG, env)
vae.load(PATH_MODEL_VAE)
obs = env.reset()
while True:
action, _states = ddpg.predict(obs)
# print(action)
obs, reward, done, info = env.step(action)
if done:
env.reset()
# Run in training mode.
else:
for i in range(0, 50):
print("Task: train")
# the noise objects for DDPG
n_actions = env.action_space.shape[-1]
from vae.controller import VAEController
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--folder', help='Log folder', type=str, default='logs/recorded_data/')
parser.add_argument('-vae', '--vae-path', help='Path to saved VAE', type=str, default='')
parser.add_argument('--n-samples', help='Max number of samples', type=int, default=20)
parser.add_argument('--seed', help='Random generator seed', type=int, default=0)
args = parser.parse_args()
set_global_seeds(args.seed)
if not args.folder.endswith('/'):
args.folder += '/'
vae = VAEController()
vae.load(args.vae_path)
images = [im for im in os.listdir(args.folder) if im.endswith('.png')]
images = np.array(images)
n_samples = len(images)
for i in range(args.n_samples):
# Load test image
image_idx = np.random.randint(n_samples)
image_path = args.folder + images[image_idx]
image = cv2.imread(image_path)
image = cv2.resize(image, (112, 112))
encoded = vae.encode_from_raw_image(image)
reconstructed_image = vae.decode(encoded)[0]
