def predict():
if request.method == 'GET':
try:
url = request.args.get('q')
app.logger.debug('url provided - %s', url)
input_tensor = transform_image(read_file(url=url))
values, indices = get_topk(input_tensor)
results = render_prediction(values, indices)
return jsonify(results=results)
except:
app.logger.debug("Error: %s", traceback.print_exc())
return jsonify("invalid image url")
elif request.method == 'POST':
try:
file = request.files['file']
app.logger.debug('file uploaded - %s', file)
url = request.form.get("url", None)
app.logger.debug('url provided - %s', url)
input_tensor = transform_image(read_file(upload=file, url=url))
values, indices = get_topk(input_tensor)
results = render_prediction(values, indices)
return jsonify(results=results)
except:
app.logger.debug("Error: %s", traceback.print_exc())
return jsonify("invalid image")
else:
app.logger.debug("Error: %s", traceback.print_exc())
return jsonify('invalid request')
def run_inference():
os.system(
'fswebcam -r 1024x768 --no-banner --scale 224x224 output.jpg -S 7 --save /home/pi/Photos/std.jpg'
) # uses Fswebcam to take picture
image = Image.open('output.jpg')
#data = np.array(image,dtype='float64')
#data=data1.reshape((1,data1.shape[2],data1.shape[0],data1.shape[1]))
#np.save( 'flamingo.npy', data)
image_data = utils.transform_image(image)
print(image_data)
flattened_data = image_data.astype(np.float32).flatten()
#np.save( 'puppi.npy',flattened_data)
print("Start Prinring Flattern")
print(flattened_data)
#run_inference(image_data)
#time.sleep(15) # this line creates a 15 second delay before repeating the loop
model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'../model-rasp3b')
batch_size = 1
channels = 3
height = width = 224
input_shape = {'input0': [batch_size, channels, height, width]}
classes = 1000
output_shape = [batch_size, classes]
device = 'cpu'
model = DLRModel(model_path, input_shape, output_shape, device)
synset_path = os.path.join(model_path, 'imagenet1000_clsidx_to_labels.txt')
with open(synset_path, 'r') as f:
synset = eval(f.read())
#image = np.load(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dog.npy')).astype(np.float32)
#input_data = {'data': image_data}
# Predict
out = model.run({'input0': flattened_data}).squeeze()
top1 = np.argmax(out)
prob = np.max(out)
print("Class: %s, probability: %f" % (synset[top1], prob))
for rep in range(4):
t1 = current_milli_time()
out = model.run({'input0': flattened_data}).squeeze()
t2 = current_milli_time()
logging.debug('done m.run(), time (ms): {}'.format(t2 - t1))
top1 = np.argmax(out[0])
logging.debug('Inference result: {}, {}'.format(top1, synset[top1]))
import resource
logging.debug(
"peak memory usage (bytes on OS X, kilobytes on Linux) {}".format(
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss))
return {'synset_id': top1, 'prediction': synset[top1], 'time': t2 - t1}
def image(self):
"""
Returns original image rescaled, rotated, shifted and amplified.
"""
print("Calculating image for parameters: {}".format(self.p))
return transform_image(self._image, self.p[0], self.p[1], self.p[2],
self.p[3], self.p[4])
def _process_image(filename, tmp_name, imgTransformationCount=5):
global AUGMENT
model_file = file_io.FileIO(filename, mode='rb')
temp_model_location = './%s.png' % tmp_name
temp_model_file = open(temp_model_location, 'wb')
temp_model_file.write(model_file.read())
temp_model_file.close()
image_data = cv2.imread(temp_model_location)
decoded = cv2.imencode('.png', image_data)[1].tostring()
height, width, _ = image_data.shape
decoded_strings = list()
decoded_strings.append(decoded)
if AUGMENT:
# Generate more images per each original image by applying random transformations.
for i in range(imgTransformationCount):
im_trans_data = utils.transform_image(image_data)
trans_decoded = cv2.imencode('.png', im_trans_data)[1].tostring()
decoded_strings.append(trans_decoded)
# Return the list of decoded strings along with height and weight of each image.
# Each transformed image is having the same shape as the original image.
return decoded_strings, height, width
def predict_from_cam():
r"""
Predict with the photo taken from your pi camera.
"""
#send_mqtt_message("Taking a photo...")
my_camera = camera.Camera()
image = Image.open(my_camera.capture_image())
image_data = utils.transform_image(image)
#send_mqtt_message("Start predicting...")
predict(image_data)
def get_prediction(image_bytes):
try:
img = transform_image(image_bytes=image_bytes)
mask = model.forward(img)
except Exception:
return 0, 'error'
with torch.no_grad():
y = torch.sigmoid(mask)
mask = y.squeeze().cpu().numpy()
return mask > .6
def main():
graph = tf.Graph()
with graph.as_default():
with gfile.FastGFile(utils.PATH_TO_MERGED_GRAPH, 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
tf.import_graph_def(graph_def, name='')
# input tensor
image_input = graph.get_tensor_by_name('image_input:0')
# output tensors
tensors = [
"class/final_result", "detect/detection_classes",
"detect/num_detections", "detect/detection_scores",
"detect/detection_boxes"
]
tensor_dict = {out: '%s:0' % out for out in tensors}
tensor_dict = {
out: graph.get_tensor_by_name(name)
for out, name in tensor_dict.items()
}
# examples
start = 1003
examples_number = 500
examples = pd.read_csv(utils.LABELLING_OUTPUT_PATH)
examples = examples.sample(frac=1).reset_index(drop=True)
examples = examples.iloc[start:start + examples_number]
# categories = pd.read_csv('categories.csv')
results = []
with tf.Session(graph=graph) as sess:
for row_id, row in examples.iterrows():
image = utils.get_images(pd.Series(row['path_to_image']))[0]
image = utils.transform_image(image)
result = sess.run(tensor_dict, {image_input: image})
result = {key: value[0] for key, value in result.items()}
classification: np.ndarray = result['class/final_result']
class_max = np.argmax(classification)
results.append((class_max, row['label']))
print(row_id, class_max, row['label'])
results = pd.DataFrame(results, columns=['result', 'all_label'])
results.to_csv('result2.csv')
# results = pd.merge(results, categories)
print(results)
def main():
graph = tf.Graph()
with graph.as_default():
with gfile.FastGFile(utils.PATH_TO_MERGED_GRAPH, 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
tf.import_graph_def(graph_def, name='')
# input tensor
image_input = graph.get_tensor_by_name('image_input:0')
# output tensors
tensors = [
"class/final_result", "detect/detection_classes",
"detect/num_detections", "detect/detection_scores",
"detect/detection_boxes"
]
tensor_dict = {out: '%s:0' % out for out in tensors}
tensor_dict = {
out: graph.get_tensor_by_name(name)
for out, name in tensor_dict.items()
}
# examples
examples_number = 32
examples = pd.read_csv(utils.LABELLING_OUTPUT_PATH)
examples = examples.sample(frac=1).reset_index(drop=True)
examples = examples.iloc[:examples_number]
examples['image'] = utils.get_images(examples['path_to_image'])
# display
utils.show_images(examples, utils.MAPPER_CLASSIFICATION)
with tf.Session(graph=graph) as sess:
for _, row in examples.iterrows():
image = utils.transform_image(row['image'])
result = sess.run(tensor_dict, {image_input: image})
result = {key: value[0] for key, value in result.items()}
detections = utils.construct_detection_df(result)
classification: np.ndarray = result['class/final_result']
classification = utils.decode_classification(classification)
print(detections)
print(classification)
image = utils.visualize_boxes_and_labels(row['image'], detections)
plt.imshow(image)
plt.show()
def ajax_test():
_, imgstring = request.data.decode("utf-8").split(',')
img = io.BytesIO(base64.b64decode(imgstring))
img = utils.transform_image(img, settings.IMAGE_WIDTH, settings.IMAGE_HEIGHT, True, 'test.png')
K.clear_session()
the_model = load_model(settings.MODEL_FILE)
result = the_model.predict(np.array([img]))
prediction = np.argmax(result)
probability = result[0][prediction]
return 'It\'s a %d (%.2f)' % (prediction, probability)
def predict_from_cam():
r"""
Predict with the photo taken from your pi camera.
"""
send_mqtt_message("Taking a photo...")
my_camera = camera.Camera()
imagebinary = my_camera.capture_image()
image = Image.open(imagebinary)
image_data = utils.transform_image(image)
send_mqtt_message("Start predicting...")
max_class, max_score = predict(image_data)
# DataEncode
image64 = base64.b64encode(imagebinary.getvalue())
image_str = image64.decode("utf-8")
send_prediction_results(image_str, max_class, float(max_score))
return imagebinary
model.save('deep_models/inception_west_train.h5')
model = load_model('deep_models/inception_west_train.h5')
#preparing data for predictions
labels_index = {0: "non-crater", 1: "crater"}
X_eval = list()
y_eval = list()
# crater part
files = os.listdir('./crater_data/test_set/crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(
transform_image('./crater_data/test_set/crater/' + files[i + 1],
input_shape))
y_eval.append(1)
# non-crater part
files = os.listdir('./crater_data/test_set/non-crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(
transform_image('./crater_data/test_set/non-crater/' + files[i + 1],
input_shape))
y_eval.append(0)
# stacking the arrays
X_eval = np.vstack(X_eval)
skp_right = sift.detect(im_right)
skp_left, sd_left = sift.compute(im_left, skp_left)
skp_right, sd_right = sift.compute(im_right, skp_right)
# Plot the keypoints on the image
keypoints_left = draw_keypoints(im_left, skp_left)
plot_image(keypoints_left, 'Keypoints on Left Image')
keypoints_right = draw_keypoints(im_right, skp_right)
plot_image(keypoints_right, 'Keypoints on Right Image')
# Adjust the descriptors to be of equal sizes
if sd_left.size < sd_right.size:
sd_right = sd_right[0:sd_left.shape[0], 0:sd_left.shape[1]]
elif sd_left.size >= sd_right.size:
sd_left = sd_left[0:sd_right.shape[0], 0:sd_right.shape[1]]
# Identify the matched pairs of points
match_points = create_matched_pairs(sd_left, sd_right, 0.5)
# Plot the matched pairs on the image
large_image = match_image_points(im_left, im_right, skp_left, skp_right, match_points, True)
plot_image(large_image, 'Matched SIFT Points')
# Transform the right image to be the same plane as left image
transformed = transform_image(im_left, im_right, skp_left, skp_right, match_points)
plot_image(transformed, 'Transformed Image')
# Stitch the left and right image to create the panorama
panorama = make_panorama(transformed, im_left)
plot_image(panorama, 'Stitched Image')
#preparing data for predictions
size = (64, 64)
X_eval = list()
y_eval = list()
#test_name = 'challenging_test_set'
test_name = 'test_set'
# crater part
files = os.listdir('./crater_data/' + test_name + '/crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(
transform_image(
'./crater_data/' + test_name + '/crater/' + files[i + 1], size))
y_eval.append(1)
# non-crater part
files = os.listdir('./crater_data/' + test_name + '/non-crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(
transform_image(
'./crater_data/' + test_name + '/non-crater/' + files[i + 1],
size))
y_eval.append(0)
# stacking the arrays
X_eval = np.vstack(X_eval)
def train_pix2pix(pathdataset: str,
pathmodel: str,
pathlogs: str,
epochs: int = 150,
learningrate: float = 2e-4,
batchsize: int = 1) -> str:
"""
Train Pix2Pix.
Args:
pathdataset (string) : Full path name to the training dataset (TFRecords file)
pathmodel (string) : Full path name to the Pix2Pix model checkpoint
pathlogs (string) : Full path name to the Tensorboard logs directory
epochs (int) : Number of training epochs
learningrate (float) : Learning rate (for generator and discriminator)
batchsize (int) : Batch size
Returns:
model (string) : Full path name to the Pix2Pix model checkpoint
"""
# ------------------------------
# In order to be able to convert
# a Python Function directly
# into a Kubeflow component,
# we need to move the python
# includes inside that python
# function.
# ------------------------------
import tensorflow as tf
import json
import time
# The below tag comment is used by a tool script from this project to automatically nest
# the python code of the imports function tagged KFP-NEST-IMPORT, just right after this tag.
# This is only usefull when using the SDK's kfp.components.func_to_container_op method,
# which allows to convert a Python function to a pipeline component and returns a factory function
#
#KFP-NEST-HERE
# ------------------------------
# Define some hyperparameters
# (Not managed as Kubeflow
# pipeline parameters)
# ------------------------------
BETA_1 = 0.5 # Exponential decay rate for the 1st moment estimates
# ------------------------------
# Get ready for Training
# ------------------------------
# Build the Pix2Pix GAN
generator = Generator()
discriminator = Discriminator()
# Set the Optimizers
generator_optimizer = tf.keras.optimizers.Adam(learningrate, BETA_1)
discriminator_optimizer = tf.keras.optimizers.Adam(learningrate, BETA_1)
# Configure the model checkpoints saving
checkpoint = tf.train.Checkpoint(
generator_optimizer=generator_optimizer,
discriminator_optimizer=discriminator_optimizer,
generator=generator,
discriminator=discriminator)
manager = tf.train.CheckpointManager(checkpoint,
directory=pathmodel,
max_to_keep=1,
checkpoint_name='ckpt')
_ = checkpoint.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
print("Model restored from {}".format(manager.latest_checkpoint))
else:
print("Initializing from scratch.")
# Configure a summary writer to collect Tensorboard logs
summary_writer = tf.summary.create_file_writer(pathlogs)
# Enable Kubeflow Pipelines UI built-in support for Tensorboard
try:
metadata = {
'outputs': [{
'type': 'tensorboard',
'source': pathlogs,
}]
}
# This works only inside Docker containers
with open('/mlpipeline-ui-metadata.json', 'w') as f:
json.dump(metadata, f)
except PermissionError:
pass
# ------------------------------
# One step Training
# nested Helper function
# ------------------------------
@tf.function # Compile function into a graph for faster execution
def train_step(input_image, target):
'''
Perform one training step
Args:
input_image : Input image
target : Output image (ground thruth)
Returns:
gen_loss : Generator loss
disc_loss : Dicriminator loss
'''
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
# Compute the Generator output
gen_output = generator(input_image, training=True)
# Compute the Discriminator output for real and generated inputs
disc_real_output = discriminator([input_image, target],
training=True)
disc_generated_output = discriminator([input_image, gen_output],
training=True)
# Computes the Generator and Discriminator losses
gen_loss = generator_loss(disc_generated_output, gen_output,
target)
disc_loss = discriminator_loss(disc_real_output,
disc_generated_output)
# Apply Gradient Descent
generator_gradients = gen_tape.gradient(gen_loss,
generator.trainable_variables)
discriminator_gradients = disc_tape.gradient(
disc_loss, discriminator.trainable_variables)
generator_optimizer.apply_gradients(
zip(generator_gradients, generator.trainable_variables))
discriminator_optimizer.apply_gradients(
zip(discriminator_gradients, discriminator.trainable_variables))
return gen_loss, disc_loss, gen_output
# ------------------------------
# TRAINING LOOP
# ------------------------------
for epoch in range(epochs):
start = time.time()
# ------------------------------
# Extract the Training Dataset
# from the TFRecords file
# ------------------------------
training_dataset = get_dataset(pathdataset, batchsize)
# ------------------------------
# Loop over the training batches
# ------------------------------
for image_features in training_dataset:
# Loop over all images in the batch
for record_idx in range(batchsize):
# ------------------------------
# Extract the individual
# features and reconstruct
# the input images to feed
# the Neural Networks
# ------------------------------
a_image, b_image, _ = decode_tfrecords_example(
image_features, record_idx)
# ------------------------------
# Perform Data Augmentation
# with the input images
# ------------------------------
a_image, b_image = transform_image(a_image, b_image)
# ------------------------------
# Perform one TRAININING STEP
# ------------------------------
gen_loss, disc_loss, gen_output = train_step(
input_image=b_image, target=a_image)
# ------------------------------
# Write tensorboard summaries
# at the end of the epoch
# ------------------------------
with summary_writer.as_default():
tf.summary.scalar('Generator loss', gen_loss, step=epoch)
tf.summary.scalar('Discriminator loss', gen_loss, step=epoch)
tf.summary.image('input_image',
b_image,
max_outputs=epoch,
step=epoch)
tf.summary.image('target_image',
a_image,
max_outputs=epoch,
step=epoch)
tf.summary.image('generated_image',
gen_output,
max_outputs=epoch,
step=epoch)
# ------------------------------
# Saving (checkpoint) the model
# every 10 epochs
# ------------------------------
if (epoch + 1) % 10 == 0:
manager.save()
# ------------------------------
# Display progression
# ------------------------------
print('Epoch {}/{} ( {:.1f} sec) gen_loss={:.6f} disc_loss={:.6f}'.
format(epoch + 1, epochs,
time.time() - start, gen_loss, disc_loss))
print("End of training")
# ------------------------------
# Write the Output of the
# Kubeflow Pipeline Component
# ------------------------------
try:
# This works only inside Docker containers
with open('/output.txt', 'w') as f:
f.write(pathmodel)
except PermissionError:
pass
return pathmodel
# load the model
cnn_classifier = keras.models.load_model('cnn_models/west_train_model_dropout.h5')
#preparing data for predictions
size = (64, 64)
X_eval = list()
y_eval = list()
# crater part
files = os.listdir('./crater_data/test_set/crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(transform_image('./crater_data/test_set/crater/' + files[i + 1], size))
y_eval.append(1)
# non-crater part
files = os.listdir('./crater_data/test_set/non-crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(transform_image('./crater_data/test_set/non-crater/' + files[i + 1], size))
y_eval.append(0)
# stacking the arrays
X_eval = np.vstack(X_eval)
cnn_pred = cnn_classifier.predict_classes(X_eval, batch_size = 32)
def run_inference():
now = datetime.now()
dt_string = now.strftime("%d/%m/%Y %H:%M:%S")
print("date and time =", dt_string)
for x in range(4):
rep = session.next()
try:
if (rep["class"] == "TPV"):
print(str(rep.lat) + "," + str(rep.lon))
locate = ("Timestamp " + dt_string + "," + " Latitude: " +
str(rep.lat) + "," + "longitudes: " + str(rep.lon))
except Exception as e:
print("Got exception " + str(e))
print(time)
#os.system('fswebcam -r 1024x768 --no-banner --scale 224x224 output.jpg -S 7 --save /home/pi/Photos/std.jpg') # uses Fswebcam to take picture
image = Image.open('output.jpg')
#data = np.array(image,dtype='float64')
#data=data1.reshape((1,data1.shape[2],data1.shape[0],data1.shape[1]))
#np.save( 'flamingo.npy', data)
image_data = utils.transform_image(image)
#print(image_data)
flattened_data = image_data.astype(np.float32).flatten()
#np.save( 'puppi.npy',flattened_data)
#print("Start Prinring Flattern")
#print(flattened_data)
#run_inference(image_data)
#time.sleep(15) # this line creates a 15 second delay before repeating the loop
model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'../model-rasp3b')
batch_size = 1
channels = 3
height = width = 224
input_shape = {'input0': [batch_size, channels, height, width]}
classes = 1000
output_shape = [batch_size, classes]
device = 'cpu'
model = DLRModel(model_path, input_shape, output_shape, device)
synset_path = os.path.join(model_path, 'imagenet1000_clsidx_to_labels.txt')
with open(synset_path, 'r') as f:
synset = eval(f.read())
#image = np.load(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dog.npy')).astype(np.float32)
#input_data = {'data': image_data}
# Predict
out = model.run({'input0': flattened_data}).squeeze()
top1 = np.argmax(out)
prob = np.max(out)
# Using for loop
for i in list:
# How to use find()
if (synset[top1].find(i) != -1):
print("Contains given substring ")
GPIO.output(12, GPIO.HIGH) # Turn on
sleep(10) # Sleep for 1 second
GPIO.output(12, GPIO.LOW) # Turn off
#sleep(10)
#else:
#print ("Doesn't contains given substring")
#print(i)
print("Class: %s, probability: %f" % (synset[top1], prob))
#while True: # Run forever
#GPIO.output(8, GPIO.HIGH) # Turn on
#sleep(10) # Sleep for 1 second
#GPIO.output(8, GPIO.LOW) # Turn off
#sleep(10)
#for rep in range(4):
#t1 = current_milli_time()
#out = model.run({'input0' : flattened_data}).squeeze()
#t2 = current_milli_time()
#logging.debug('done m.run(), time (ms): {}'.format(t2 - t1))
#top1 = np.argmax(out)
print(locate)
logging.debug('Inference result: {}, {}'.format(locate, synset[top1]))
def predict_from_image(filename):
image = Image.open(filename)
image_data = utils.transform_image(image)
#send_mqtt_message("Start predicting...")
predict(image_data)
cnn_classifier = keras.models.load_model(
'cnn_models/west_train_model_dropout.h5')
#preparing data for predictions
size = (64, 64)
X_eval = list()
y_eval = list()
# crater part
files = os.listdir('./crater_data/challenging_test_set/crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(
transform_image(
'./crater_data/challenging_test_set/crater/' + files[i + 1], size))
y_eval.append(1)
# non-crater part
files = os.listdir('./crater_data/challenging_test_set/non-crater')
files.sort()
for i in range(0, len(files) - 1):
X_eval.append(
transform_image(
'./crater_data/challenging_test_set/non-crater/' + files[i + 1],
size))
y_eval.append(0)
# stacking the arrays
X_eval = np.vstack(X_eval)
def main():
parser = argparse.ArgumentParser(
description='Parser for Predicting Face Attribute')
parser.add_argument('--model_path',
type=str,
required=True,
help='Path to model with .h5 extensions')
parser.add_argument('--image',
type=str,
required=True,
help='Image filename to be predicted')
parser.add_argument(
'--preprocessing',
type=str,
default='resnet50',
help=
'Preprocessing method to be applied for the image, vgg16, inception_v3, or resnet50'
)
parser.add_argument('--img_size',
type=int,
default=224,
help='Image filename to be predicted')
parser.add_argument('--save_image',
type=bool,
default=True,
help='Image filename to be predicted')
args = parser.parse_args()
model_path = args.model_path
preprocessing = args.preprocessing
filename = args.image
size = (args.img_size, args.img_size)
results = None
# Load model
model = load_pretrained(model_path)
# Load image
img = np.array(load_img(filename))
# Detect faces using MTCNN face detector
faces, bboxes = detect_face(img)
if faces is not None:
# Preprocess the image and expand its dimension
trans_imgs = [
transform_image(face, size, preprocessing) for face in faces
]
# Predict face attributes
preds = model.predict(np.array(trans_imgs))
# Convert the output of predict and combine with its corresponding bbox
results = convert_attribute(bboxes, preds)
# Save the output image
if args.save_image:
img = draw_outputs(img, results)
cv2.imwrite('out_{}'.format(filename), img)
print('Output image saved at out_{}'.format(filename))
print(results)
def get_screen(env):
screen = env.render(mode='rgb_array')
return utils.transform_image(screen)
def train(self,
epochs=50,
batch_size=128,
test_size=0.2,
verbose=1,
transform=1):
#Si se quiere cargar el modelo lenet5 u otro, silenciar estas 3 lineas,
#sino dara un error de compatibilidades de arquitectura.
if os.path.exists(MODEL_NAME):
self.load()
return -1
train_X, test_X, train_Y, test_Y = train_test_split(
self.X, self.y, test_size=test_size)
if verbose:
print('Training data shape : ', train_X.shape, train_Y.shape)
print('Testing data shape : ', test_X.shape, test_Y.shape)
train_X = train_X.astype('float32')
test_X = test_X.astype('float32')
# Change the labels from categorical to one-hot encoding
train_Y_one_hot = to_categorical(train_Y)
if verbose:
# Display the change for category label using one-hot encoding
print('Original label:', train_Y[0])
print('After conversion to one-hot:', train_Y_one_hot[0])
train_X, valid_X, train_label, valid_label = train_test_split(
train_X, train_Y_one_hot, test_size=test_size, random_state=13)
# print(train_X.shape)
if verbose:
print(train_X.shape, valid_X.shape, train_label.shape,
valid_label.shape)
# Data Augmentation
if transform == 1:
images_transform = []
labels_transform = []
for index, img in enumerate(train_X):
aux_list = transform_image(img)
images_transform += aux_list
labels_transform += [train_label[index] for _ in aux_list]
train_X = np.array(images_transform)
train_label = np.array(labels_transform)
self.history = self.model.fit(train_X,
train_label,
batch_size=batch_size,
epochs=epochs,
verbose=verbose,
validation_data=(valid_X, valid_label))
# guardamos la red, para reutilizarla en el futuro, sin tener que volver a entrenar
self.model.save(MODEL_NAME)
# for the other images (left and right).
indexes = np.random.randint(0, len(images['center']), 64)
for i in indexes:
# random choice of center left or right
camera_pos = np.random.choice(['center', 'left', 'right'])
img = images[camera_pos][i]
ang = angles[i]
# adjust offet according to position
if camera_pos == 'left':
ang -= OFFSET
elif camera_pos == 'right':
ang += OFFSET
# Execute transformations (rotation,shear,resize,brightness)
img, ang = utils.transform_image(img, ang, input_size=input_size)
# addition to global container
X_train.append(img)
y_train.append(ang)
# reserve a small portion for test the trained model. (0.01%)
X_train, X_test, y_train, y_test = train_test_split(np.array(X_train),
np.array(y_train),
test_size=0.001,
random_state=22)
########################################################
# Model Architecture #
########################################################
# Definition of constants
