TensorFlow Hub

TensorFlow Hub is the client library that lets TensorFlow programs load and reuse pretrained model pieces — SavedModels, and the legacy TF1 Hub format — as ordinary TensorFlow or Keras objects. Instead of training an image classifier, text encoder, or embedding model from scratch, a program can call hub.load() or wrap hub.KerasLayer() around a handle string to pull in a pretrained module and either use it directly or fine-tune it as part of a larger tf.keras.Model.

The library itself is intentionally small: a resolver layer (resolver.py, registry.py) turns a handle — a URL, a local directory, or a GCS path — into a cached local path, downloading and unpacking compressed archives as needed, and a loading layer (module_v2.py, keras_layer.py, saved_model_module.py) wraps the result as a callable or a Keras layer, bridging the differences between TF1-style hub modules and native TF2 SavedModels.

Historically, module handles pointed at tfhub.dev, Google’s public model repository. As of November 2023 that catalog moved to Kaggle Models, and tfhub.dev links now redirect there; as of March 2024 a handful of unmigrated model assets were removed outright. The tensorflow_hub package continues to be maintained as the loading mechanism — hub.load("https://tfhub.dev/...") still works against the redirected URLs — even though the model catalog it was built around now lives on a different platform.

Despite low commit activity, the package remains heavily used in practice, with roughly 290,000 weekly PyPI downloads, reflecting how much existing training code still depends on it to load models by handle.

What You Get

• hub.load(handle) — resolves a module handle (a URL, local path, or GCS path) and loads it as a TF2 SavedModel object with .variables and .signatures
• hub.KerasLayer — wraps a loaded module as a tf.keras.layers.Layer so it can be dropped straight into a Sequential or functional Keras model, with trainable fine-tuning support
• hub.resolve(handle) — resolves a handle into a local filesystem path without loading it, useful for caching and inspection
• A pluggable resolver/registry system that downloads and caches compressed module archives, or reads uncompressed modules directly from GCS, controlled via TFHUB_CACHE_DIR and TFHUB_MODEL_LOAD_FORMAT
• Compatibility shims for the deprecated TF1 Hub module format, so older hub.Module-style assets can still be loaded through the TF2 API

Common Use Cases

• Transfer learning — loading a pretrained image or text embedding model as a frozen or fine-tunable hub.KerasLayer inside a new classifier
• Feature extraction — using a pretrained encoder purely to produce fixed embeddings (image, text) for a downstream model or search index
• Reproducing published research or tutorial models that reference a specific tfhub.dev/Kaggle Models handle
• Migrating legacy TF1 Hub modules into TF2-native Keras workflows without rewriting the model itself

Under The Hood

Architecture The library separates handle resolution from model loading. registry.py and resolver.py implement a pluggable resolver chain that turns a string handle — a tfhub.dev/Kaggle URL, a gs:// path, a local directory, or a .tar.gz archive — into a local filesystem path, downloading and extracting into a cache directory controlled by TFHUB_CACHE_DIR (or reading directly from GCS when UNCOMPRESSED mode is set). module_v2.py sits on top of that resolver and calls tf.compat.v1.saved_model.load_v2() against the resolved path, tagging the result with _is_hub_module_v1 to distinguish legacy TF1 Hub modules from native TF2 SavedModels. keras_layer.py then wraps that loaded callable (or a bare handle string) as a tf.keras.layers.Layer subclass, forwarding trainable, signature, and arguments through call() so the wrapped module behaves like any other Keras layer inside a larger model. Changing the core resolution abstraction would ripple through both the low-level hub.load() path and the higher-level hub.KerasLayer path, since both depend on it for locating module files.

Tech Stack Pure Python on top of TensorFlow: install_requires lists only numpy and protobuf directly, but the package is unusable without a TensorFlow install (tensorflow itself is deliberately not pinned as a dependency, since it’s expected to already be present) and depends on tf-keras for the Keras 3-compatible layer wrapper. The build is driven by Bazel (WORKSPACE, BUILD files throughout tensorflow_hub/) rather than a standard Python build backend, with a separate setup.py under tensorflow_hub/pip_package/ used specifically to assemble the PyPI release. .proto files (image_module_info.proto, module_attachment.proto) define the on-disk metadata format for the legacy TF1 module format.