Problems replicating web demo using TensorFlow Serving on Docker about what-if-tool HOT 6 OPEN

def load_byte_img(im_bytes, IMAGE_H, IMAGE_W):
        buf = BytesIO(im_bytes)
        im = np.array(Image.open(buf).resize((IMAGE_H, IMAGE_W)), dtype=np.float64) / 255.
        return np.expand_dims(im, axis=0)

def image_bytestring(path_to_image):
    with open(path_to_image, 'rb') as f:
        return f.read()


def image_example(image_string, label, extra_features=None):
    """
    taken from TensorFlow TFRecords tutorial
    :param image_string: image bytestring
    :param label: image label (integer)
    :return: tf.Example
    """
    image_shape = tf.image.decode_jpeg(image_string).shape
    feature = {
        'image/height': _int64_feature(image_shape[0]),
        'image/width': _int64_feature(image_shape[1]),
        'image/depth': _int64_feature(image_shape[2]),
        'image/label': _int64_feature(label),
        'image/encoded': _bytes_feature(image_string),
    }
    if extra_features is None:
        pass
    else:
        for k, v in extra_features.items():
            feature[k] = v
    return tf.train.Example(features=tf.train.Features(feature=feature))


def labels_to_integers(label_list):
    """
    converts a list of string labels to integer list
    :param label_list: list of labels (str)
    :return: list
    """
    mapping = {v:k for k, v in enumerate(list(set(label_list)))}
    return [mapping[i] for i in label_list]


def write_tfrecord(df, 
                   image_path_series='x_col', 
                   label_series_name='y_col', 
                   cols_to_ignore=[],  
                   outfile='images.tfrecord',
                   verbose=True):
    """
    writes TFRecord files
    :param df: pd.DataFrame with at least 2 columns containing paths to images and labels
    :param image_path_series: string naming the column with paths, default is 'x_col'
    :param label_series_name: string naming the column with labels, default is 'y_col'
    :param cols_to_ignore: list of columns from the DataFrame to not treat as features and ignore them
    :param outfile: path to output TFRecord file
    :param verbose: verbose mode, True by default
    :return: None
    """
    # truncate df, put label separately, remove non-feature columns
    cols = list(df.columns)
    
    for i in cols_to_ignore:
        cols.remove(i)
    
    sub_df = df.loc[:, cols]
    examples = []
    sub_df[label_series_name] = labels_to_integers(df[label_series_name])
    for i in sub_df.iterrows():
        series = i[1]  # underlying pd.Series
        im_bytes = image_bytestring(series[image_path_series])
        label = series[label_series_name]
        extra_feature_names = list(series.keys())
        extra_feature_names.remove(label_series_name)
        extra_feature_names.remove(image_path_series)
        series = series.loc[extra_feature_names]
        # ignore image path and label for extra features
        extra_features = dict()
        for k, ft in series.items():
            if type(ft) == int:
                val = _int64_feature(ft)
            elif type(ft) == object:
                val = _bytes_feature(ft)
            elif type(ft) == float:
                val = _float_feature(ft)
            else:
                raise ValueError('Unsupported data type!')
            extra_features[k] = val
        im_example = image_example(im_bytes, label, extra_features)
        examples.append(im_example)
        if verbose:
            print(f'Generated {len(examples)} examples')
    
    def write(outfile):
        with tf.io.TFRecordWriter(outfile) as writer:
            for example in examples:
                writer.write(example.SerializeToString())
    
    write(outfile)


def _parse_image_function(example_proto, additional_features=None):
    """
    taken from TensorFlow TFRecords tutorial
    :param example_proto: tf.Example
    :return: parsed binary data, human readable
    """
    image_feature_desc = {
            'image/height': tf.io.FixedLenFeature([], tf.int64),
            'image/width': tf.io.FixedLenFeature([], tf.int64),
            'image/depth': tf.io.FixedLenFeature([], tf.int64),
            'image/label': tf.io.FixedLenFeature([], tf.int64),
            'image/encoded': tf.io.FixedLenFeature([], tf.string),
    }
    if additional_features is None:
        pass
    else:
        for k, v in additional_features.items():
            image_feature_desc[k] = v
    # Parse the input tf.Example proto using the dictionary above.
    return tf.io.parse_single_example(example_proto, image_feature_desc)


def parse_image_dataset(raw_image_dataset):
    """
    transforms raw binary data in a tf.Dataset to human readable form
    :param raw_image_dataset: tf.Dataset with raw binary data
    :return: human readable tf.Dataset instance
    """
    return raw_image_dataset.map(_parse_image_function)


def serialize_model(model_file, model_version='1', weights_file=None):
    """
    saves model as a protobuf compatible with TensorFlow Serving
    :param model_file: path to JSON or HDF5 file with the model
    :param model_version: string specifying model version name
    :param weights_file: path to optional HDF5 file with weights
    :return: None
    """
    if weights_file is None:
        model = tf.keras.models.load_model(model_file)
    else:
        with open(model_file, 'r') as f:
            model = tf.keras.models.model_from_json(f.read())
        model.load_weights(weights_file)
    tf.saved_model.save(model, os.getcwd() + '/' + model_version)

write_tfrecord(df, 'Smiling', 'image_id', ['Unnamed: 0'])
# column 'Smiling' as labels, column 'image_id' points to files, column 'Unnamed: 0' is ignored