Spaces:
Sleeping
Sleeping
import json | |
import numpy as np | |
import tensorflow as tf | |
import os | |
# Convert the variables to the correct data type | |
# Load the variables from the JSON file | |
# Get the directory of the current file (preprocess_coordinates_data.py) | |
current_directory = os.path.dirname(os.path.abspath(__file__)) | |
# Construct the path to variables.json | |
json_file_path = os.path.join(current_directory, 'variables.json') | |
with open(json_file_path, 'r') as json_file: | |
variables_dict = json.load(json_file) | |
MAX_PHRASE_LENGTH = variables_dict['MAX_PHRASE_LENGTH'] | |
PAD_TOKEN = variables_dict['PAD_TOKEN'] | |
N_UNIQUE_CHARACTERS = variables_dict['N_UNIQUE_CHARACTERS'] | |
# Read Character to Ordinal Encoding Mapping. | |
character_to_prediction = os.path.join(current_directory, 'character_to_prediction_index.json') | |
with open(character_to_prediction) as json_file: | |
ORD2CHAR = json.load(json_file) | |
# Output Predictions to string | |
def outputs2phrase(outputs, ORD2CHAR): | |
""" | |
Convert output sequence to a human-readable phrase by mapping | |
each output to a corresponding character. | |
Parameters: | |
outputs (np.array): A sequence of model output, | |
can be 1D (sequence of character IDs) | |
or 2D (sequence of one-hot encodings). | |
ORD2CHAR (dict): A mapping from character IDs to characters. | |
Returns: | |
str: The converted phrase. | |
""" | |
ORD2CHAR = {int(k): v for k, v in ORD2CHAR.items()} # Convert keys to integers | |
if outputs.ndim == 2: | |
outputs = np.argmax(outputs, axis=1) | |
return ''.join([ORD2CHAR.get(s, '') for s in outputs]) | |
def predict_phrase(batch_frames, model): | |
""" | |
Use a pre-trained model to predict a phrase from a batch of frame sequences. | |
Parameters: | |
batch_frames (np.array): A batch of frame sequences. | |
model (tf.keras.Model): The pre-trained model to use for prediction. | |
Returns: | |
tf.Tensor: One-hot encoding of the predicted phrase. | |
""" | |
batch_frames = tf.convert_to_tensor(batch_frames) | |
phrase = tf.fill([batch_frames.shape[0], MAX_PHRASE_LENGTH], PAD_TOKEN) | |
phrase = tf.cast(phrase, tf.int32) # Cast phrase to int32 initially | |
for idx in tf.range(MAX_PHRASE_LENGTH): | |
# Predict Next Token | |
outputs = model({ | |
'frames': batch_frames, | |
'phrase': phrase, | |
}) | |
phrase = tf.where( | |
tf.range(MAX_PHRASE_LENGTH)[None, :] < idx + 1, | |
tf.argmax(outputs, axis=-1, output_type=tf.int32), | |
phrase, | |
) | |
# one-hot encode the outputs | |
outputs_one_hot = tf.one_hot(phrase, depth=N_UNIQUE_CHARACTERS) | |
return outputs_one_hot | |
# # Assuming sequence is your array of shape (128, 164) | |
# sequence = processed_sequence._shape(1, *processed_sequence.shape) # reshapes sequence to (1, 128, 164) | |
# | |
# # Now you can feed sequence to your prediction function | |
# pred_phrase_one_hot = predict_phrase(sequence) | |
# | |
# # Convert the one-hot encoded prediction to a string | |
# # Remember the output is one-hot encoded so we need to convert it to integers first | |
# pred_phrase = outputs2phrase(tf.argmax(pred_phrase_one_hot, axis=-1).numpy()) | |
# | |
# print(pred_phrase) | |