Deep Lake (Deep Learning)

---

Deep Lake is a system or repository of data resembling data lakes, where the raw data includes images, videos, audio, and other unstructured data. Deep Lake allows conversion of the raw data into a deep learning-native format (NumPy-like arrays, also known as tensors). The data can then be easily manipulated and streamed to a machine learning model training process across the network. As sucg, Deep Lake retains the same properties of data lakes, such as data version control, SQL queries, ingesting data with ACID transactions, and visualizing terabyte-scale datasets for analytical workloads. One notable difference of a deep lake is its focus on storing complex unstructured data in a deep learning-native format, and the ability to stream Deep Lake datasets over the network to (a) be queried, (b) visualized in-browser, or (c) used with machine learning frameworks such as PyTorch, TensorFlow or JAX, as well as various MLOps tools. Deep Lake can also be used as a vector database for Large Language Model training, as well as developing artificial intelligence applications with LangChain.

A Deep Lake can be used locally (on organisation's premises) or "in the cloud" (using cloud services from vendors such as Amazon or Google).

Background

The term has been used by Assaf Pinhasi and Activeloop to refer to an architectural blueprint for managing deep learning data. Deep Lake was released on September 30, 2022.

Features

Deep Lake has the following features:

Dataset version control

Typical data lakes offer time travel, or a linear timeline of changes that happened to the dataset. However, time traveling does not solve for multiple versions of the same asset, such as multiple annotations from different data annotators (specialists codifying machine learning datasets). In contrast, Deep Lake enables git-like dataset version control, which resolves this issue.

In-browser visualization engine

Deep Lake enables users to visualize their complex datasets alongside the metadata (such as bounding boxes, masks, annotations, etc.).

Rapid queries with Tensor Query language

Thanks to the underlying data format, Deep Lake enables users query their datasets with complex queries also involving NumPy-like array manipulations, as well as standard SQL operations and expressions, including arithmetic, or logical composition.

SELECT images [100:500, 100:500], boxes + ARRAY[-100, -100, 0, 0] 
WHERE contains(categories, 'bicycle') and weather == 'raining' 
ORDER BY AOI(boxes, prediction) desc
LIMIT 1000

The above query, for instance, would allow a user to build a dataset of 1,000 images and labels where it was “raining”, and there were “bicycles” captured on the camera.

Materialize

Materialization of a dataset transforms the "virtual view" into deep learning-ready tensorial format. It also enables efficient data streaming from Deep Lake directly to the GPU.

Streaming data loader

Data loaders, are the pieces of software in charge of moving data from where data is stored into GPUs while training machine learning models. Upon running a query such as the one mentioned above, a user may save the materialized dataset and then stream it to a machine learning model.

An example of streaming for CIFAR-100 could be:

$ pip3 install deeplake #installs deeplake

import deeplake
from torchvision import datasets, transforms, models

dataset_path = 'hub://activeloop/cifar100-train'
ds = deeplake.load(dataset_path) # Returns a Deep Lake Dataset but does not download data locally

tform = transforms.Compose([
    transforms.ToPILImage(), # Must convert to PIL image for subsequent operations to run
    transforms.RandomRotation(20), # Image augmentation
    transforms.ToTensor(), # Must convert to pytorch tensor for subsequent operations to run
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
])

#PyTorch Dataloader
dataloader= ds.pytorch(batch_size = 16, num_workers = 2, 
    transform = {'images': tform, 'labels': None}, shuffle = True)
    
cifar100_pytorch = ClassificationDataset(ds_train, transform = tform) #
dataloader_pytroch = DataLoader(dataset_pt, batch_size = 16, num_workers = 2, shuffle = True)

Deep Lake Performance against alternatives

In an independent survey and benchmarking of open-source data loaders by Ofeidis et al., 2022, such as TorchData, Webdataset, Squirrel, PyTorch, FFCV, as well as its previous version, Activeloop Hub, Deep Lake data loader was shown to be highly performant against its alternatives. Deep Lake demonstrated loading speed over the public internet is naturally slower than from a local disk, some libraries, such as Deep Lake, showed "remarkable results" (only a 13% increase in time compared to loading from a local disk). Deep Lake also outperformed alternatives for networked loading, whilst FFCV led the pack for multi-GPU training.

Criticism

An alternative to Deep Lake would be to extend standard approaches such as Parquet or Arrow formats to support deep learning data. This could be beneficial due to the ability of existing analytical tools including Spark or Kafka. However, proponents of Deep Lake argue that those tools are optimized for tabular, time-series, and event stream processing and will break with complex, unstructured data.

References

This article "Deep Lake (Deep Learning)" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:Deep Lake (Deep Learning). Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

📰 Article(s) of the same category(ies)

• Old Bradwell United F.C.
• 1974 Eastwood District Council election
• Litmus (Mozilla)
• MANDELBARTH
• Fantoo
• Angry Young Man (film)
• Win Chadha

---