Jump To

• Core Functions
  • activation_layer(ip, activation, *args)
  • conv2D(ip, filters, kernel_size, activation, padding="same", pool_size=(2, 2))
  • fully_connected_layer(ip, units, activation, dropout)
  • build_model(ip=Input(shape=(IMG_WIDTH, IMG_WIDTH, 3)), activation="relu", dropout=0.5, hidden_activation="lrelu")
  • predict(model, data, steps=None, threshold=0.5)
  • make_prediction(model_path, data_dir, threshold=0.5, batch_size=64, return_probs=False, return_report=False)
• Helper Functions
  • get_loaded_model(path)
  • get_activation_model(model, conv_idx)
  • evaluate_model(model, test_data_dir, batch_size=64)
  • get_classification_report(true, preds, output_dict=False)
  • save_model_history(history, filename)

Core Functions

activation_layer(ip, activation, *args)

[source]

Function to obtain an activation layer with the given input.

It initializes a ReLU, ELU or LeakyReLU activation layer with the given input layer based on activation. This function can be used in place of the activation keyword argument in all Keras layers to mix-match activations for different layers and easily use ELU and LeakyReLU, which otherwise need to be imported separately.

Example Usage

Here, we create a convolutional layer with 8 kernels of size 3 x 3 each, which takes 256 x 256 x 3 images as its input and uses a ReLU activation.

from tensorflow.keras import Input
from tensorflow.keras.layers import Conv2D
from mesonet.model import activation_layer

# Create input layer
ip = Input(shape=(256, 256, 3))
# Create convolutional layer
layer = Conv2D(filters=8, kernel_size=(3, 3))(ip)
# Add ReLU activation
layer = activation_layer(layer, 'relu')

conv2D(ip, filters, kernel_size, activation, padding="same", pool_size=(2, 2))

[source]

Function to obtain a convolutional “block”. A convolutional block is defined as a set of layers where the first layer is a convolutional layer. The entire set of layers is (in this order):

• tf.keras.layers.Conv2D - Convolutional layer.
• tf.keras.layers.ReLU, tf.keras.layers.ELU or tf.keras.layers.LeakyReLU - Activation layer.
• tf.keras.layers.BatchNormalization - Batch normalization layer.
• tf.keras.layers.MaxPooling2D - Max pooling layer.

It feeds the given input to the convolutional layer and then successively feeds the outputs of one layer to the layer below it, thus encapsulating the entire convolutional operation applied in the original MesoNet paper and providing a reusable way to replicate the same operation multiple times.

Note: The stride value for the Conv2D layer is always the default value of 1.

Example Usage

Here, we build a complete TensorFlow model with 3 convolutional blocks, each with 16 filters of size 3 x 3 and ReLU activation, and one fully-connected layer with 16 neurons.

from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Conv2D, Dense
from mesonet.model import conv2D

# Create input layer
ip = Input(shape=(256, 256, 3))
layer = ip

# Add the 3 convolutional layers with a simple loop
for i in range(3):
    layer = conv2D(layer, filters=16, kernel_size=3, 'relu')

# Add the fully-connected layer
layer = Dense(16)(layer)
# Add an output layer
op_layer = Dense(1, activation='sigmoid')(layer)

# Create model
model = Model(ip, op_layer)

fully_connected_layer(ip, units, activation, dropout)

[source]

Function to obtain an fully-connected “block”. A fully-connected block is defined as a set of layers where the first layer is a fully-connected (dense) layer. The entire set of layers is (in this order):

• tf.keras.layers.Dense - Fully-connected layer.
• tf.keras.layers.ReLU, tf.keras.layers.ELU or tf.keras.layers.LeakyReLU - Activation layer.
• tf.keras.layers.Dropout - Dropout layer.

It feeds the given input to the dense layer and then successively feeds the outputs of one layer to the layer below it, thus encapsulating the entire hidden layer operation applied in the original MesoNet paper and providing a reusable way to replicate the same operation multiple times.

Example Usage

Here, we build a simple fully-connected network with a 1024-neuron input layer, 3 ReLU-activated hidden layers with 64, 16 and 8 neurons respectively, and an output layer with a sigmoid activation. A dropout of 0.5 is applied to each hidden layer.

from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Dense
from mesonet.model import fully_connected_layer

ip = Input(shape=(1, 1024))

neurons = [64, 16, 8]
layer = ip
for x in neurons:
    layer = fully_connected_layer(layer, x, 'relu', 0.5)

op_layer = Dense(1, activation='sigmoid')(layer)

model = Model(ip, op_layer)

build_model(ip=Input(shape=(IMG_WIDTH, IMG_WIDTH, 3)), activation="relu", dropout=0.5, hidden_activation="lrelu")

[source]

Function to obtain a model exactly replicating the architecture in the paper.

See the model schematic here.

It acts as a shortcut function to directly obtain a model with the same architecture as the paper and start training it, while also allowing you to modify the shape of the input, the activations and the dropout. Use this if you don’t want to create your own variant with a different architecture.

Example Usage

When called with no arguments, the function gives you the exact model used in the paper. To verify this, you can call the .summary() method on the returned tf.keras.Model instance.

from mesonet.model import build_model

meso = build_model()
meso.summary()

predict(model, data, steps=None, threshold=0.5)

[source]

Function to make predictions on data. Can only handle a model with a sigmoid activation at the output layer.

It calls the .predict() method on the given model to obtain the predicted sigmoid probabilities for the data, and then classifies them into the positive (1) or the negative class (0) based on the threshold. The function is agnostic to the actual class labels.

make_prediction(model_path, data_dir, threshold=0.5, batch_size=64, return_probs=False, return_report=False)

[source]

Function to obtain predictions from a saved model using data from a directory.

It uses the predict() function to make predictions using the given model on the data loaded from a directory. Instead of returning 1 or 0 as the classes, it replaces 1 and 0 with the corresponding label (e.g. real and deepfake). Optionally, it can return the predicted probabilities and also generates a ROC report (using sklearn.metrics.classification_report).

It is useful when you have more user-facing tasks such as displaying the results in a window. In fact, the prediction sub-command of the CLI uses this function to do its work.

Example Usage

Here, we make predictions on data stored in the directory data/test using a model saved as model.hdf5. We also want a classification report and so, set return_report to True.

from mesonet.model import make_prediction

preds, report = make_prediction('model.hdf5', 'data/test', return_report=True)

Helper Functions

get_loaded_model(path)

[source]

Function to load a saved model from a H5 file or .pd folder.

It takes the given path and uses tf.keras.models.load_model to load the saved model at the path as a tf.keras.Model instance.

Note: The returned model is NOT compiled.

Example Usage

If a model is saved in a file called model.hdf5, it can be loaded as:

from mesonet.model import get_loaded_model

model = get_loaded_model('model.hdf5')

get_activation_model(model, conv_idx)

[source]

Function to obtain the “activation model” of a trained model.

An activation model is defined as a model which has the same input as the trained model and whose output consists of the output of least one convolutional layer of the trained model. Since this outputs are obtained after an activation function is applied on the convolution, hence the name.

It automatically detects all the convolutional layers present in the trained model, selects the specified ones from among them and creates a new tf.keras.Model instance which has the same input(s) as the trained model and the outputs of the selected convolutional layers.

When you make predictions using this model, the result will be a list with as many Numpy arrays as the number of convolutional layers selected, each array corresponding to the output of a layer.

It is useful for visualizing the convolutional layers as images.

Note: If you create an activation model with a single layer, you get a single Numpy array containing the output of that layer (not a list) when making predictions.

Example Usage

The following obtains a model using build_model, trains it and then obtains an activation model with the first and last convolutional layers as the outputs. Note that since there are four convolutional layers in the original MesoNet architecture, the index of the last convolutional layer is 3.

from mesonet.model import build_model, get_activation_model

model = build_model()
# Code to train the model
...
# Create activation model
activation_model = get_activation_model(model, [0, 3])

evaluate_model(model, test_data_dir, batch_size=64)

[source]

Function to obtain evaluation metrics on a trained model.

It loads the data from the given directory and uses the .evaluate() method to obtain the evaluation metrics (as used when training the model) of the given trained model.

For information on the expected directory structure, check the documentation for the data module.

Example Usage

Here, we load a model saved at model.hdf5 using get_loaded_model() and then use evaluate_model() on data located in data/test to obtain the evaluation metrics.

from mesonet.module import get_loaded_model, evaluate_model

model = get_loaded_model('model.hdf5')
metrics = evaluate_model(model, 'data/test')

get_classification_report(true, preds, output_dict=False)

[source]

Function to obtain an ROC report for a set of predictions.

It uses sklearn.metrics.classification_report() to obtain the recall, precision and F1-scores, returning them as a string or a dictionary.

save_model_history(history, filename)

[source]

Function to dump a model’s history into a pickle file.

This is useful in scenarios where you want to generate plots even after you have terminated the current session.

Back to top