Skip to main content

A deep learning library containing implementations of popular algorithms and extensions to TensorFlow and Keras.

Project description


PyPI Downloads GitHub Travis (.com) Build Status CodeQL

DeepToolKit provides implementations of popular machine learning algorithms, extensions to existing deep learning pipelines using TensorFlow and Keras, and convenience utilities to speed up the process of implementing, training, and testing deep learning models. In addition, DeepToolKit includes an inbuilt computer vision module containing implementations of facial detection and image processing algorithms.


Python Package

DeepToolKit can be installed directly from the command line:

pip install deeptoolkit

You can then work with it either by importing the library as a whole, or by importing the functionality you need from the relevant submodules.

# Complete library import.
import deeptoolkit as dtk

# Module and function imports.
from import plot_data_cluster
from deeptoolkit.blocks import SeparableConvolutionBlock
from deeptoolkit.losses import CategoricalFocalLoss

From Source

If you want to install DeepToolKit directly from source, (i.e. for local development), then first install the git source:

git clone

Then install system requirements and activate the virtual environment. A Makefile is included for installation:

make install


DeepToolKit provides a number of features to either use standalone or integrated in a deep learning model construction pipeline. Below is a high-level list of features in the module. Proper documentation is under construction.

Model Architecture Blocks: deeptoolkit.blocks

  • Generic model architecture blocks, including convolution and depthwise separable convolution blocks, implemented as tf.keras.layers.Layer objects so you can directly use them in a Keras model.
  • Applied model architecture blocks, including squeeze and excitation blocks and ResNet identity blocks.

For Example:

from tensorflow.keras.models import Model
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Input, Dense, Flatten
from deeptoolkit.blocks import ConvolutionBlock

# Construct a Keras Functional model like normal.
inp = Input((256, 256, 3))
x = ConvolutionBlock(32, kernel_size = (3, 3), activation = 'relu')(inp)
x = MaxPooling2D(pool_size = (2, 2))(x)
x = ConvolutionBlock(16, kernel_size = (3, 3), activation = 'relu')(x)
x = MaxPooling2D(pool_size = (2, 2))(x)
x = Flatten()(x)
x = Dense(1024, activation = 'relu')(x)
x = Dense(10, activation = 'relu')(x)
model = Model(inp, x)

Loss Functions: deeptoolkit.losses

  • Custom loss functions including binary and categorical focal loss, built as tf.keras.losses.Loss objects so you can use them in a Keras model training pipeline as well.

For Example:

from tensorflow.keras.optimizers import Adam
from deeptoolkit.losses import BinaryFocalLoss

# Using the model from the above example.
   optimizer = Adam(),
   loss = BinaryFocalLoss(),
   metrics = ['accuracy']

Data Processing and Visualization:

  • Data preprocessing, including splitting data into train, validation, and test sets, and shuffling datasets while keeping data-label mappings intact.
  • Data visualization, including cluster visualizations.

For Example:

import numpy as np
from import train_val_test_split

X = np.random.random(100)
y = np.random.random(100)
X_train, X_val, X_test, y_train, y_val, y_test = train_val_test_split(X, y, split = [0.6, 0.2, 0.2])

Model Evaluation: deeptoolkit.evaluation

  • Model evaluation resources, including visualization of model training metrics over time.

Computer Vision:

  • A pre-built facial detection model: A large number of modern computer vision algorithms include a facial detection component, and DeepToolKit's facial detection module provides fast and accurate face detection using OpenCV's DNN implementation. To use it, simply execute the following:
import cv2
from import FacialDetector

# Initialize detector.
detector = FacialDetector()

# Detect face from image path and save image to path.
detector.detect_face('image/path', save = 'image/save/path')

# Detect face from existing image and continue to use it.
image = cv2.imread('image/path')
annotated_image = detector.detect_face(image)

Facial Detection Cartoon


All code in this repository is licensed under the MIT License.

Issue Reporting

If you notice any issues or bugs in the library, please create an issue under the issues tab. To get started and for more information, see the issue templates.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

deeptoolkit-0.2.1.tar.gz (21.9 kB view hashes)

Uploaded Source

Built Distribution

deeptoolkit-0.2.1-py2.py3-none-any.whl (26.9 kB view hashes)

Uploaded Python 2 Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page