Let's say you want to deploy a recommender system at your company. A typical architecture [https://medium.com/nvidia-merlin/recommender-systems-not-just-recommender-models-485c161c755e] might include a set of inference servers to run your embedding and ranking models, an approximate nearest neighbor index to select a set of

This page contains a quick reference for writing Terraform configuration. For a conceptual introduction to Terraform and managing your infrastructure as code, read this blog post [https://www.jeremyjordan.me/terraform]. Disclaimer: for the most up-to-date and detailed information, check out the official Terraform

This blog post aims to provide a simple, open-source solution for monitoring ML systems. We'll discuss industry-standard monitoring tools and practices for software systems and how they can be adapted to monitor ML systems. To illustrate this, we'll use a scikit-learn model trained on

This blog post will provide an introduction to Kubernetes so that you can understand the motivation behind the tool, what it is, and how you can use it. In a follow-up post, I'll discuss how we can leverage Kubernetes to power data science workloads

Previously, I wrote about organizing machine learning projects [https://www.jeremyjordan.me/ml-projects-guide/] where I presented the framework that I use for building and deploying models. However, that framework operates on the implicit assumption that you already know generally what your model should do.

Jump to: * Overview * Evolving a hidden state over time * Common structures of recurrent networks * Bidirectionality * Limitations * Further reading Overview Previously, I've written about feed-forward neural networks [https://www.jeremyjordan.me/intro-to-neural-networks/] as a generic function approximator and convolutional neural networks [https://www.jeremyjordan.me/

Jump to: * What is nearest neighbors search? * K-d trees * Quantization * Product quantization * Handling multi-modal data * Locally optimized product quantization * Common datasets * Further reading What is nearest neighbors search? In the world of deep learning, we often use neural networks to learn representations of objects

The goal of this document is to provide a common framework for approaching machine learning projects that can be referenced by practitioners. If you build ML models, this post is for you. If you collaborate with people who build ML models, I hope that

In this post, I'll discuss an overview of deep learning techniques for object detection using convolutional neural networks [https://www.jeremyjordan.me/convolutional-neural-networks/]. Object detection is useful for understanding what's in an image, describing both what is in an image and where those objects

When evaluating a standard machine learning model, we usually classify our predictions into four categories: true positives, false positives, true negatives, and false negatives. However, for the dense prediction task of image segmentation, it's not immediately clear what counts as a "true positive" and,

In this post, I'll discuss how to use convolutional neural networks [https://www.jeremyjordan.me/convolutional-neural-networks/] for the task of semantic image segmentation. Image segmentation is a computer vision task in which we label specific regions of an image according to what's being shown.

In this post, I'll discuss commonly used architectures for convolutional networks. As you'll see, almost all CNN architectures follow the same general design principles of successively applying convolutional layers to the input, periodically downsampling the spatial dimensions while increasing the number of feature maps.

In my introductory post [https://www.jeremyjordan.me/autoencoders/] on autoencoders, I discussed various models (undercomplete, sparse, denoising, contractive) which take data as input and discover some latent state representation of that data. More specifically, our input data is converted into an encoding vector

Autoencoders are an unsupervised learning technique in which we leverage neural networks for the task of representation learning. Specifically, we'll design a neural network architecture such that we impose a bottleneck in the network which forces a compressed knowledge representation of the original input.

In previous posts, I've discussed how we can train neural networks using backpropagation [https://www.jeremyjordan.me/neural-networks-training/] with gradient descent [https://www.jeremyjordan.me/gradient-descent/]. One of the key hyperparameters to set in order to train a neural network is the learning rate

In this blog post, I'll discuss a number of considerations and techniques for dealing with imbalanced data when training a machine learning model. The blog post will rely heavily on a sklearn contributor package called imbalanced-learn [http://contrib.scikit-learn.org/imbalanced-learn/stable/] to implement

In this post, I'll discuss considerations for normalizing your data - with a specific focus on neural networks. In order to understand the concepts discussed, it's important to have an understanding of gradient descent [https://www.jeremyjordan.me/gradient-descent/]. As a quick refresher, when

When creating a machine learning model, you'll be presented with design choices as to how to define your model architecture. Often times, we don't immediately know what the optimal model architecture should be for a given model, and thus we'd like to be able