def load_model(filepath=None, config=None, item=None):
"""
Load pre-trained model
Support the model that created by sklearn.externals.joblib
Parameters
----------
filepath : string, default None
The model file name
Returns
-------
The model created by sklearn
"""
if filepath is None:
raise ValueError("The filepath is None, please check the filepath is in the config file")
if '.h5' in filepath:
keras_model = lm(filepath)
reader = FeatureReader(config)
features = reader.get_feature(dt.now())
f = features[item]
# for keras bug
v = keras_model.predict(f)
return keras_model
else:
return joblib.load(filepath)
def __init__(self, carla_client, args):
self.client = carla_client
self._carla_settings = make_carla_settings(args)
self._timer = None
self._display = None
self._main_image = None
self._mini_view_image1 = None
self._mini_view_image2 = None
self._enable_autopilot = args.autopilot
self._enable_imitation = args.imitation
self._lidar_measurement = None
self._map_view = None
self._is_on_reverse = False
self._display_map = args.map
self._city_name = None
self._map = None
self._map_shape = None
self._map_view = None
self._position = None
self._agent_positions = None
self.model = lm('./model_semseg.hdf5')
# variables to enable saving to disk
self.out_filename_format = args.out_filename_format
self.save_images_to_disk = args.save_images_to_disk
self.episode_count = 0
self.frame_count = 0
self.saver = None
self.out_dir = args.location
def init():
print("Loading model...")
model = lm(getModelPath())
print("Model loaded successfully.")
graph = tf.get_default_graph()
return graph, model
def learn_from_memory(model, is_lstm=False, clone_model=None):
""" Use replay memory to learn. Ignore s2 if s1 is terminal """
s1 = None
if is_lstm == True:
s1, a, s2, isterminal, r = memory.get_last_entry()
else:
if memory.size > batch_size:
s1, a, s2, isterminal, r = memory.get_sample(batch_size)
# lstm predict updates the state of the lstm modules
#get the current state action values. LET the lstm state get updated,
# BUT save the weights for fitting
model.save(tmp_model_savefile)
target_q = model.predict(
s1, batch_size=batch_size
) #lstm predict updates the state of the lstm modules
#lstm predict updates the state of the lstm modules
#get next state lstm values, but recover the lstm state using the clone model to hold weights
q_next = model.predict(
s2, batch_size=batch_size
) #lstm predict updates the state of the lstm modules
max_q_next = np.max(q_next, axis=1)
target_q[np.arange(target_q.shape[0]),
a] = r + discount_factor * (1 - isterminal) * max_q_next
#now recover the weights (including the memory) for fitting
model = lm(tmp_model_savefile)
model.fit(s1, target_q, batch_size=batch_size, verbose=0)
#todo test if fit changed the prediction
#AND again step the lstm forward for the next state.
_ = model.predict(s1, batch_size=batch_size)
def trainSingle(self, train, test):
# writing targets in keras readable shape
best = str(int(time.time()))
y_train = to_categorical(train["target"].values)
y_test = to_categorical(test["target"].values)
N_classes = len(y_train[0])
model_impl = getattr(keras_models, self.params["name"])
model = model_impl(len(self.variables), N_classes)
model.summary()
model.fit(
train[self.variables].values,
y_train,
sample_weight=train["train_weight"].values,
# validation_split = 0.25,
validation_data=(test[self.variables].values, y_test,
test["train_weight"].values),
batch_size=self.params["batch_size"],
epochs=self.params["epochs"],
shuffle=False,
callbacks=[
EarlyStopping(patience=self.params["early_stopping"]),
ModelCheckpoint(best + ".model",
save_best_only=True,
verbose=1)
])
print "Reloading best model"
model = lm(best + ".model")
os.remove(best + ".model")
return model
def load_model(filepath=None):
"""
Load pre-trained model
Support the model that created by sklearn.externals.joblib
Parameters
----------
filepath : string, default None
The model file name
Returns
-------
The model created by sklearn, xgboost or keras, and the model input shape
"""
if filepath is None:
raise ValueError("The filepath is None, please check the filepath is in the config file")
if '.h5' in filepath:
keras_model = lm(filepath)
feature_shape = keras_model.layers[0].input_shape
array_shape = [1] + [i for i in feature_shape[1:]]
array = np.zeros(array_shape)
# for keras bug
keras_model.predict(array)
return keras_model, feature_shape
else:
return joblib.load(filepath), None
def main(argv):
# builds model
curmodel = lm(argv[0])
datafile = argv[1]
tone = errors(curmodel, datafile)
print("Correct Prediciton: ", tone[0])
print("Missed to Right: ", tone[1])
print("Missed to Left: ", tone[2])
print("Standard Error: ", tone[3])
print("Squared Error: ", tone[4])
def trainSingle(self, train, test):
# writing targets in keras readable shape
best = str(int(time.time()))
y_train = to_categorical(train["target"].values)
y_test = to_categorical(test["target"].values)
N_classes = len(y_train[0])
model_impl = getattr(
keras_models,
self.params["name"]) # reads model defined in conf/keras_models.py
model = (len(self.variables), N_classes)
model.summary()
history = model.fit(
train[self.variables].values,
y_train,
sample_weight=train["train_weight"].values,
validation_split=0.25,
# validation_data=(test[self.variables].values, y_test, test["train_weight"].values),
batch_size=self.params["batch_size"],
epochs=self.params["epochs"],
shuffle=True,
callbacks=[
EarlyStopping(patience=self.params["early_stopping"]),
ModelCheckpoint(best + ".model",
save_best_only=True,
verbose=1)
])
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
print "plotting training"
epochs = xrange(1, len(history.history["loss"]) + 1)
plt.plot(epochs, history.history["loss"], lw=3, label="Training loss")
plt.plot(epochs,
history.history["val_loss"],
lw=3,
label="Validation loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
if not os.path.exists("plots"):
os.mkdir("plots")
plt.savefig("plots/fold_{0}_loss.png".format(best),
bbox_inches="tight")
print "Reloading best model"
model = lm(best + ".model")
os.remove(best + ".model")
return model
def load(self, filename):
with open(filename + ".dict", 'rb') as FSO:
tmp_dict = json.load(FSO)
print "Loading model from: " + filename
self.__dict__.clear()
self.__dict__.update(tmp_dict)
self.models = []
for model in tmp_dict["models"]:
self.models.append(lm(model))
def make_carla_settings(args):
"""Make a CarlaSettings object with the settings we need."""
model = lm('./model_semseg.hdf5')
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=5,
NumberOfPedestrians=30,
WeatherId=random.choice(list(range(15))),
QualityLevel=args.quality_level)
settings.randomize_seeds()
camera0 = sensor.Camera('CameraRGB')
camera0.set_image_size(WINDOW_WIDTH, WINDOW_HEIGHT)
camera0.set_position(2.0, 0.0, 1.4)
camera0.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera0)
# camera1 = sensor.Camera('CameraDepth', PostProcessing='Depth')
# # camera1.set_image_size(MINI_WINDOW_WIDTH, MINI_WINDOW_HEIGHT)
# camera1.set_image_size(WINDOW_WIDTH, WINDOW_HEIGHT)
# camera1.set_position(2.0, 0.0, 1.4)
# camera1.set_rotation(0.0, 0.0, 0.0)
# settings.add_sensor(camera1)
camera2 = sensor.Camera('CameraSemSeg',
PostProcessing='SemanticSegmentation')
# camera2.set_image_size(MINI_WINDOW_WIDTH, MINI_WINDOW_HEIGHT)
camera2.set_image_size(WINDOW_WIDTH, WINDOW_HEIGHT)
camera2.set_position(2.0, 0.0, 1.4)
camera2.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera2)
# if args.lidar:
# lidar = sensor.Lidar('Lidar32')
# lidar.set_position(0, 0, 2.5)
# lidar.set_rotation(0, 0, 0)
# lidar.set(
# Channels=32,
# Range=50,
# PointsPerSecond=100000,
# RotationFrequency=10,
# UpperFovLimit=10,
# LowerFovLimit=-30)
# settings.add_sensor(lidar)
return settings
def load(self, filename):
with open(filename + ".dict", 'rb') as FSO:
tmp_dict = json.load(FSO)
logger.debug( "Dict located in: " + filename)
self.__dict__.clear()
self.__dict__.update(tmp_dict)
self.models = []
for modelpath in tmp_dict["models"]:
logger.debug("Filename is " + filename)
logger.debug("Path in dict is " + modelpath)
modelname = os.path.basename(modelpath)
dirpath = os.path.dirname(filename)
actual_modelpath = os.path.join(dirpath, modelname)
logger.debug("Loading model from: " + actual_modelpath)
self.models.append(lm(actual_modelpath))
def __init__(self, carla_client, args):
self.client = carla_client
self._carla_settings = make_carla_settings(args)
self._timer = None
self._display = None
self._main_image = None
self._mini_view_image1 = None
self._mini_view_image2 = None
self._enable_autopilot = args.autopilot
self._enable_imitation = args.imitation
self._lidar_measurement = None
self._map_view = None
self._is_on_reverse = False
self._display_map = args.map
self._city_name = None
self._map = None
self._map_shape = None
self._map_view = None
self._position = None
self._agent_positions = None
self.model = lm('./model_semseg.hdf5')
self.img_array = None
self.count = -3
batch_size=512,
epochs=50,
class_weight='auto',
validation_data=(X_val, y_val),
callbacks=([
EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=20),
ModelCheckpoint("CNN_model.hdf5",
monitor="val_loss",
save_best_only=True)
]))
# plot loss
model = lm('CNN_model.hdf5')
plt.style.use('ggplot')
plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
plt.savefig("CNN Model loss.png")
#---------------------------- Prediction and Evaluation -------------------------------
#get the predict values
y_pred = model.predict(X_test)
threshold = 0.5
def __init__(self, load_model=False, model_path=None):
self.model = lm('duckietown_il/keras/trained_models/.h5')
self.current_image = np.zeros(expect_shape)
def __init__(
self,
wordvectors_file_vec='wiki.es.vec',
w2v_limit=None,
best_epoch=200,
mimick_weights_file='Results Yoshio/Model/run_1/model-%d.hdf5',
LSTM_HIDDEN_UNITS=150,
CHAR_VECTOR_WORD_SIZE=20,
VECTOR_WORD_SIZE=300,
DEFAULT_DICTIONARY={
'a': 1,
'b': 2,
'c': 3,
'd': 4,
'e': 5,
'f': 6,
'g': 7,
'h': 8,
'i': 9,
'j': 10,
'k': 11,
'l': 12,
'm': 13,
'n': 14,
'ñ': 15,
'o': 16,
'p': 17,
'q': 18,
'r': 19,
's': 20,
't': 21,
'u': 22,
'v': 23,
'w': 24,
'x': 25,
'y': 26,
'z': 27,
'á': 28,
'é': 29,
'í': 30,
'ó': 31,
'ú': 32,
'1': 33,
'2': 34,
'3': 35,
'4': 36,
'5': 37,
'6': 38,
'7': 39,
'8': 40,
'9': 41,
'0': 42
}):
self.wordvectors_file_vec = wordvectors_file_vec
self.w2v_limit = w2v_limit
self.best_epoch = best_epoch
self.mimick_weights_file = mimick_weights_file
self.LSTM_HIDDEN_UNITS = LSTM_HIDDEN_UNITS
self.CHAR_VECTOR_WORD_SIZE = CHAR_VECTOR_WORD_SIZE
self.VECTOR_WORD_SIZE = VECTOR_WORD_SIZE
self.DEFAULT_DICTIONARY = DEFAULT_DICTIONARY
#self.graph = tf.get_default_graph() #tf.Graph()
#self.session = tf.Session()
self.wordvectors = self.__load_vectors()
self.vocabulary = list(self.wordvectors.vocab.keys())
self.vocabulary_size = len(self.vocabulary)
self.model = self.__create_model()
self.model = lm(self.mimick_weights_file % self.best_epoch,
custom_objects={
'euclidean_distance_loss':
self.__euclidean_distance_loss
})
self.model._make_predict_function()
def load_model():
# load the pre-trained model for example in h5 format from keras
global model
model = lm("CNN_Cifar10_Model.h5")
return model
def load_model(model_path):
classifier = lm(model_path)
classifier.summary()
sequence_length = classifier.layers[1].input_shape[2]
return classifier, sequence_length
def load_model(self, model_file):
return lm(model_file)
def main(argv):
# builds the model
curmodel = lm(argv[0])
datafile = argv[1]
return update(curmodel, datafile)
def load_model(self, model_name):
self.model = lm(model_name)
def main(argv):
curmodel = lm(argv[0])
datafile = argv[1]
return update(curmodel, datafile)
def load_modal(self):
if self.soft_max:
return lm(self.modal_path)
skip_learning = True
# Create Doom instance
game = initialize_vizdoom(config_file_path)
# Action = which buttons are pressed
n = game.get_available_buttons_size()
actions = [list(a) for a in it.product([0, 1], repeat=n)]
actions = [[0, 0, 1], [0, 1, 0], [1, 0, 0]]
# Create replay memory which will store the transitions
memory = ReplayMemory(capacity=replay_memory_size)
if load_model:
print("Loading model from: ", model_savefile)
current_model = lm(model_savefile)
pass
else:
my_input, current_model = create_model(len(actions))
_, updated_model = create_model(len(actions))
print("Starting the training!")
time_start = time()
if not skip_learning:
for epoch in range(epochs):
print("\nEpoch %d\n-------" % (epoch + 1))
train_episodes_finished = 0
train_scores = []
print("Training...")
game.new_episode()
memory.reset_test_buffer()
def run_carla_client(args):
model = lm('/home/ritvik/PythonClient/model_RGB.hdf5')
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 3
frames_per_episode =900
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
# Start a new episode.
if args.settings_filepath is None:
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel=args.quality_level)
settings.randomize_seeds()
# Now we want to add a couple of cameras to the player vehicle.
# We will collect the images produced by these cameras every
# frame.
# The default camera captures RGB images of the scene.
camera0 = Camera('SemanticSegmentation',PostProcessing='Semantic Segmentation')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(800, 600)
camera1.set_position(0.30, 0, 1.30)
settings.add_sensor(camera1)
if args.lidar:
lidar = Lidar('Lidar32')
lidar.set_position(0, 0, 2.50)
lidar.set_rotation(0, 0, 0)
lidar.set(
Channels=32,
Range=50,
PointsPerSecond=100000,
RotationFrequency=10,
UpperFovLimit=10,
LowerFovLimit=-30)
settings.add_sensor(lidar)
else:
# Alternatively, we can load these settings from a file.
with open(args.settings_filepath, 'r') as fp:
settings = fp.read()
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode...')
client.start_episode(player_start)
# Iterate every frame in the episode.
for frame in range(0, frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# Print some of the measurements.
print_measurements(measurements)
# Save the images to disk if requested.
if args.save_images_to_disk:
for name, measurement in sensor_data.items():
filename = args.out_filename_format.format(episode, name, frame)
measurement.save_to_disk(filename)
if args.send_controls_from_nn:
for name,measurement in sensor_data.items():
img = measurement.return_image()
img_array = np.asarray(img)
# print("shape of img_array is " + str(np.shape(img_array)))
img_array = cv2.resize(img_array, dsize=(240, 320), interpolation=cv2.INTER_CUBIC)
# print("shape of img_array is " + str(np.shape(img_array)))
normalized_img = np.zeros((240,320,3))
normalized_img = cv2.normalize(img_array,normalized_img,0,255,cv2.NORM_MINMAX)
# print("Shape of norm_img is " + str(np.shape(normalized_img)))
normalized_img = normalized_img.reshape(1,240,320,3)
control = measurements.player_measurements.autopilot_control
if abs(float(model.predict(normalized_img,batch_size=1))) < 50.0:
control.steer = float(model.predict(normalized_img,batch_size=1))
else:
print("Entered")
print("Steer value is " + str(control.steer))
# # control.steer += random.uniform(-0.1, 0.1)
# img_array = np.asarray(img)
# np.reshape(img_array, img_array.shape + (1,))
# control.steer =float(model.predict(img_array[None,:,:,:], batch_size=1))
# print("Control steer is " + str(control.steer))
# if(abs(control.steer)<0.10):
# control.steer = 0.0
# control.throttle = 0.5
# print("Throttle value is " + str(control.throttle))
client.send_control(control)
# We can access the encoded data of a given image as numpy
# array using its "data" property. For instance, to get the
# depth value (normalized) at pixel X, Y
#
# depth_array = sensor_data['CameraDepth'].data
# value_at_pixel = depth_array[Y, X]
#
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if args.autopilot:
control = measurements.player_measurements.autopilot_control
#control.steer += random.uniform(-0.1, 0.1)
client.send_control(control)
print(str(control.steer))
print(("Testing" if skip_learning else "Training"), 'KFrames:', kframes,
'Frame Repeat:', frame_repeat)
# Create Doom instance
game = initialize_vizdoom(config_file_path)
# Action = which buttons are pressed
n = game.get_available_buttons_size()
actions = [list(a) for a in it.product([0, 1], repeat=n)]
# Create replay memory which will store the transitions
memory = ReplayMemory(capacity=replay_memory_size)
if load_model and os.path.isfile(model_savefile):
print("Loading model from: ", model_savefile)
model = lm(model_savefile)
else:
my_input, model = create_model(len(actions))
print("Starting the training!")
time_start = time()
if not skip_learning:
for epoch in range(epochs):
print("\nEpoch %d\n-------" % (epoch + 1))
train_episodes_finished = 0
train_scores = []
memory.reset_test_buffer()
print("Training...")
game.new_episode()
for learning_step in trange(learning_steps_per_epoch, leave=True):
from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession
config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
print('first run 5.2.py')
from keras import models
from keras.models import load_model as lm
from keras.preprocessing import image
m1 = lm('cats_and_dogs_small_1.h5')
img_path = '/home/wb/Pictures/abc.png'
#'/home/wb/temp/cats_and_dogs_small/train/cats/cat.45.jpg'
img = image.load_img(img_path, target_size=(150, 150))
img_tensor0 = image.img_to_array(img)
img_tensor1 = np.expand_dims(img_tensor0, axis=0)
img_tensor2 = img_tensor1 / 255
print(img_tensor2.shape)
plt.imshow(img_tensor2[0])
layer_inputs = m1.input
layer_outputs = [layer.output for layer in m1.layers[:8]]
activation_model = models.Model(inputs=layer_inputs, outputs=layer_outputs)
activations = activation_model.predict(img_tensor2)
def call_this():
print('which layer you wanna view?')
