keras-hub-nightly 0.19.0.dev202412120352__py3-none-any.whl → 0.19.0.dev202412140350__py3-none-any.whl

keras_hub/src/models/image_segmenter_preprocessor.py

@@ -23,7 +23,8 @@ class ImageSegmenterPreprocessor(Preprocessor):
         is set to `True` this will be resized to input image shape else will be
         passed through unaltered.
     - `sample_weight`: (Optional) Will be passed through unaltered.
-    - `resize_output_mask` bool: If set to `True` the output mask will be resized to the same size as the input image. Defaults to `False`.
+    - `resize_output_mask` bool: If set to `True` the output mask will be
+      resized to the same size as the input image. Defaults to `False`.
 
     The layer will output either `x`, an `(x, y)` tuple if labels were provided,
     or an `(x, y, sample_weight)` tuple if labels and sample weight were
@@ -77,7 +78,6 @@ class ImageSegmenterPreprocessor(Preprocessor):
             x = self.image_converter(x)
 
         if y is not None and self.image_converter and self.resize_output_mask:
-
             y = keras.layers.Resizing(
                 height=(
                     self.image_converter.image_size[0]

keras_hub/src/models/llama/llama_backbone.py

@@ -34,17 +34,18 @@ class LlamaBackbone(Backbone):
         num_layers (int): The number of transformer layers.
         num_query_heads (int): The number of query attention heads for
             each transformer.
-        hidden_dim (int): The size of the transformer encoding and pooling layers.
-        intermediate_dim (int): The output dimension of the first Dense layer in a
-            three-layer feedforward network for each transformer.
-        num_key_value_heads (int): The number of key and value attention heads for
-            each transformer.
-        rope_max_wavelength (int, optional): The maximum angular wavelength of the
-            sine/cosine curves, for rotary embeddings. Defaults to `10000`.
-        rope_scaling_factor (float, optional): The scaling factor for calculation
-            of roatary embedding. Defaults to `1.0`.
-        layer_norm_epsilon (float, optional): Epsilon for the layer normalization
-            layers in the transformer decoder. Defaults to `1e-6`.
+        hidden_dim (int): The size of the transformer encoding and pooling
+            layers.
+        intermediate_dim (int): The output dimension of the first Dense layer in
+            a three-layer feedforward network for each transformer.
+        num_key_value_heads (int): The number of key and value attention heads
+            for each transformer.
+        rope_max_wavelength (int, optional): The maximum angular wavelength of
+            the sine/cosine curves, for rotary embeddings. Defaults to `10000`.
+        rope_scaling_factor (float, optional): The scaling factor for
+            calculation of roatary embedding. Defaults to `1.0`.
+        layer_norm_epsilon (float, optional): Epsilon for the layer
+            normalization layers in the transformer decoder. Defaults to `1e-6`.
         dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
             for model computations and weights. Note that some computations,
             such as softmax and layer normalization, will always be done at
@@ -190,7 +191,8 @@ class LlamaBackbone(Backbone):
 
         Example:
         ```
-        # Feel free to change the mesh shape to balance data and model parallelism
+        # Feel free to change the mesh shape to balance data and model
+        # parallelism
         mesh = keras.distribution.DeviceMesh(
             shape=(1, 8),
             axis_names=('batch', 'model'),
@@ -210,12 +212,16 @@ class LlamaBackbone(Backbone):
            llama_model = keras_hub.models.LlamaCausalLM.from_preset()
         ```
 
-        To see how the layout map was applied, load the model then run (for one decoder block):
+        To see how the layout map was applied, load the model then run
+        (for one decoder block):
         ```
         embedding_layer = llama_model.backbone.get_layer("token_embedding")
         decoder_block_1 = llama_model.backbone.get_layer('transformer_layer_0')
         for variable in embedding_layer.weights + decoder_block_1.weights:
-            print(f'{variable.path:<58}  {str(variable.shape):<16}  {str(variable.value.sharding.spec)}')
+            print(
+                f'{variable.path:<58}  {str(variable.shape):<16}  '
+                f'{str(variable.value.sharding.spec)}'
+            )
         ```
 
         Args:
@@ -230,22 +236,24 @@ class LlamaBackbone(Backbone):
             for all the model weights.
         """
         # The weight path and shape of the Llama backbone is like below
-        # token_embedding/embeddings                                  (128256, 2048)
+        # token_embedding/embeddings                              (128256, 2048)
         # repeat block for decoder
-        # transformer_layer_0/self_attention/query/kernel             (2048, 32, 64)
-        # transformer_layer_0/self_attention/key/kernel               (2048, 8, 64)
-        # transformer_layer_0/self_attention/value/kernel             (2048, 8, 64)
-        # transformer_layer_0/self_attention/attention_output/kernel  (32, 64, 2048)
-        # transformer_layer_0/self_attention_layernorm/scale          (2048,)
-        # transformer_layer_0/feedforward_intermediate_dense/kernel   (2048, 8192)
-        # transformer_layer_0/feedforward_gate_dense/kernel           (2048, 8192)
-        # transformer_layer_0/feedforward_output_dense/kernel         (8192, 2048)
-        # transformer_layer_0/feedforward_layernorm/scale             (2048,)
+        # transformer_layer_0/self_attention/query/kernel         (2048, 32, 64)
+        # transformer_layer_0/self_attention/key/kernel           (2048, 8, 64)
+        # transformer_layer_0/self_attention/value/kernel         (2048, 8, 64)
+        # transformer_layer_0/self_attention/attention_output/kernel
+        #                                                         (32, 64, 2048)
+        # transformer_layer_0/self_attention_layernorm/scale      (2048,)
+        # transformer_layer_0/feedforward_intermediate_dense/kernel
+        #                                                         (2048, 8192)
+        # transformer_layer_0/feedforward_gate_dense/kernel       (2048, 8192)
+        # transformer_layer_0/feedforward_output_dense/kerne      (8192, 2048)
+        # transformer_layer_0/feedforward_layernorm/scale         (2048,)
 
         if not isinstance(device_mesh, keras.distribution.DeviceMesh):
             raise ValueError(
-                "Invalid device_mesh type. Expected `keras.distribution.Device`,"
-                f" got {type(device_mesh)}"
+                "Invalid device_mesh type. Expected "
+                f"`keras.distribution.Device`, got {type(device_mesh)}"
             )
         if model_parallel_dim_name not in device_mesh.axis_names:
             raise ValueError(

keras_hub/src/models/llama3/llama3_backbone.py

@@ -24,17 +24,18 @@ class Llama3Backbone(LlamaBackbone):
         num_layers (int): The number of transformer layers.
         num_query_heads (int): The number of query attention heads for
             each transformer.
-        hidden_dim (int): The size of the transformer encoding and pooling layers.
-        intermediate_dim (int): The output dimension of the first Dense layer in a
-            three-layer feedforward network for each transformer.
-        num_key_value_heads (int): The number of key and value attention heads for
-            each transformer.
-        rope_max_wavelength (int, optional): The maximum angular wavelength of the
-            sine/cosine curves, for rotary embeddings. Defaults to `10000`.
-        rope_scaling_factor (float, optional): The scaling factor for calculation
-            of roatary embedding. Defaults to `1.0`.
-        layer_norm_epsilon (float, optional): Epsilon for the layer normalization
-            layers in the transformer decoder. Defaults to `1e-6`.
+        hidden_dim (int): The size of the transformer encoding and pooling
+            layers.
+        intermediate_dim (int): The output dimension of the first Dense layer in
+            a three-layer feedforward network for each transformer.
+        num_key_value_heads (int): The number of key and value attention heads
+            fo each transformer.
+        rope_max_wavelength (int, optional): The maximum angular wavelength of
+            the sine/cosine curves, for rotary embeddings. Defaults to `10000`.
+        rope_scaling_factor (float, optional): The scaling factor for
+            calculation of roatary embedding. Defaults to `1.0`.
+        layer_norm_epsilon (float, optional): Epsilon for the layer
+            normalization layers in the transformer decoder. Defaults to `1e-6`.
         dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
             for model computations and weights. Note that some computations,
             such as softmax and layer normalization, will always be done at

keras_hub/src/models/llama3/llama3_causal_lm.py

@@ -1,9 +1,9 @@
 from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.llama.llama_causal_lm import LlamaCausalLM
 from keras_hub.src.models.llama3.llama3_backbone import Llama3Backbone
 from keras_hub.src.models.llama3.llama3_causal_lm_preprocessor import (
     Llama3CausalLMPreprocessor,
 )
-from keras_hub.src.models.llama.llama_causal_lm import LlamaCausalLM
 
 
 @keras_hub_export("keras_hub.models.Llama3CausalLM")

keras_hub/src/models/mistral/mistral_backbone.py

@@ -38,22 +38,23 @@ class MistralBackbone(Backbone):
         num_layers (int): The number of transformer layers.
         num_query_heads (int): The number of query attention heads for
             each transformer.
-        hidden_dim (int): The size of the transformer encoding and pooling layers.
-        intermediate_dim (int): The output dimension of the first Dense layer in a
-            three-layer feedforward network for each transformer.
-        num_key_value_heads (int): The number of key and value attention heads for
-            each transformer.
-        rope_max_wavelength (int, optional): The maximum angular wavelength of the
-            sine/cosine curves, for rotary embeddings. Defaults to `10000`.
-        rope_scaling_factor (float, optional): The scaling factor for calculation
-            of roatary embedding. Defaults to `1.0`.
-        layer_norm_epsilon (float, optional): Epsilon for the layer normalization
-            layers in the transformer decoder. Defaults to `1e-6`.
+        hidden_dim (int): The size of the transformer encoding and pooling
+            layers.
+        intermediate_dim (int): The output dimension of the first Dense layer
+            in a three-layer feedforward network for each transformer.
+        num_key_value_heads (int): The number of key and value attention heads
+            for each transformer.
+        rope_max_wavelength (int, optional): The maximum angular wavelength of
+            the sine/cosine curves, for rotary embeddings. Defaults to `10000`.
+        rope_scaling_factor (float, optional): The scaling factor for
+            calculation of roatary embedding. Defaults to `1.0`.
+        layer_norm_epsilon (float, optional): Epsilon for the layer
+            normalization layers in the transformer decoder. Defaults to `1e-6`.
         sliding_window (int, optional): The sliding window for the mistral
-            attention layers. This controls the maximum cache size for the attention
-            layers in each transformer decoder. Only `sliding_window` number of tokens
-            are saved in the cache and used to generate the next token.
-            Defaults to `512`.
+            attention layers. This controls the maximum cache size for the
+            attention layers in each transformer decoder. Only `sliding_window`
+            number of tokens are saved in the cache and used to generate the
+            next token. Defaults to `512`.
         dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
             for model computations and weights. Note that some computations,
             such as softmax and layer normalization, will always be done at

keras_hub/src/models/mistral/mistral_causal_lm.py

@@ -28,9 +28,9 @@ class MistralCausalLM(CausalLM):
 
     Args:
         backbone: A `keras_hub.models.MistralBackbone` instance.
-        preprocessor: A `keras_hub.models.MistralCausalLMPreprocessor` or `None`.
-            If `None`, this model will not apply preprocessing, and inputs
-            should be preprocessed before calling the model.
+        preprocessor: A `keras_hub.models.MistralCausalLMPreprocessor` or
+            `None`. If `None`, this model will not apply preprocessing, and
+            inputs should be preprocessed before calling the model.
     """
 
     backbone_cls = MistralBackbone

keras_hub/src/models/mistral/mistral_transformer_decoder.py

@@ -215,7 +215,8 @@ class MistralTransformerDecoder(keras.layers.Layer):
         # Mistral uses a banded attention mask if sliding window is not None
         if self.sliding_window is not None:
             # Below is a workaround for `ops.triu` for Keras 2.
-            # TODO(tirthasheshpatel): Use `ops.triu` once Keras 2 support is removed.
+            # TODO(tirthasheshpatel): Use `ops.triu` once Keras 2 support is
+            # removed.
             # causal_mask = ops.triu(causal_mask, k=-self.sliding_window)
             i = ops.arange(output_length)[:, None] + cache_update_index
             j = ops.arange(input_length)[None, :]

keras_hub/src/models/mit/mit_backbone.py

@@ -43,8 +43,8 @@ class MiTBackbone(FeaturePyramidBackbone):
             https://github.com/DavidLandup0/deepvision/tree/main/deepvision/models/classification/mix_transformer)
 
         Args:
-            layerwise_depths: The number of transformer encoders to be used per layer in the
-                network.
+            layerwise_depths: The number of transformer encoders to be used per
+                layer in the network.
             num_layers: int. The number of Transformer layers.
             layerwise_num_heads: list of integers, the number of heads to use
             in the attention computation for each layer.
@@ -58,7 +58,8 @@ class MiTBackbone(FeaturePyramidBackbone):
             image_shape: optional shape tuple, defaults to (None, None, 3).
             hidden_dims: the embedding dims per hierarchical layer, used as
                 the levels of the feature pyramid.
-            patch_sizes: list of integers, the patch_size to apply for each layer.
+            patch_sizes: list of integers, the patch_size to apply for each
+                layer.
             strides: list of integers, stride to apply for each layer.
 
         Examples:

keras_hub/src/models/mit/mit_layers.py

@@ -80,7 +80,8 @@ class HierarchicalTransformerEncoder(keras.layers.Layer):
             `LayerNormalization` layers. Defaults to `1e-06`
         sr_ratio: integer, the ratio to use within
             `SegFormerMultiheadAttention`. If set to > 1, a `Conv2D`
-             layer is used to reduce the length of the sequence. Defaults to `1`.
+            layer is used to reduce the length of the sequence.
+            Defaults to `1`.
     """
 
     def __init__(

keras_hub/src/models/mobilenet/mobilenet_backbone.py

@@ -47,11 +47,11 @@ class MobileNetBackbone(Backbone):
                 of filters in each layer.
             - If `depth_multiplier` > 1.0, proportionally increases the number
                 of filters in each layer.
-            - If `depth_multiplier` = 1, default number of filters from the paper
-                are used at each layer.
+            - If `depth_multiplier` = 1, default number of filters from the
+                paper are used at each layer.
         input_num_filters: number of filters in first convolution layer
-        output_num_filters: specifies whether to add conv and batch_norm in the end,
-            if set to None, it will not add these layers in the end.
+        output_num_filters: specifies whether to add conv and batch_norm in the
+            end, if set to None, it will not add these layers in the end.
             'None' for MobileNetV1
         input_activation: activation function to be used in the input layer
             'hard_swish' for MobileNetV3,
@@ -365,7 +365,7 @@ def apply_depthwise_conv_block(
     batch normalization and relu6 activation.
 
     Args:
-        x: Input tensor of shape `(rows, cols, channels)
+        x: Input tensor of shape `(rows, cols, channels)`
         filters: Integer, the dimensionality of the output space
             (i.e. the number of output filters in the pointwise convolution).
         depth_multiplier: controls the width of the network.
@@ -383,8 +383,8 @@ def apply_depthwise_conv_block(
         block_id: Integer, a unique identification designating the block number.
 
     Input shape:
-        4D tensor with shape: `(batch, rows, cols, channels)` in "channels_last"
-        4D tensor with shape: `(batch, channels, rows, cols)` in "channels_first"
+        4D tensor with shape `(batch, rows, cols, channels)` in "channels_last"
+        4D tensor with shape `(batch, channels, rows, cols)` in "channels_first"
     Returns:
         Output tensor of block.
     """

keras_hub/src/models/opt/opt_causal_lm.py

@@ -171,8 +171,8 @@ class OPTCausalLM(CausalLM):
         Args:
             token_ids: a dense int Tensor with shape `(batch_size, max_length)`.
             cache: a dense float Tensor, the cache of key and value.
-            cache_update_index: int, or int Tensor. The index of current inputs in the
-                whole sequence.
+            cache_update_index: int, or int Tensor. The index of current inputs
+                in the whole sequence.
 
         Returns:
             A (logits, hidden_states, cache) tuple. Where `logits` is the

keras_hub/src/models/pali_gemma/pali_gemma_backbone.py

@@ -68,8 +68,8 @@ class PaliGemmaBackbone(Backbone):
             `hidden_dim / num_query_heads`. Defaults to `True`.
         use_post_ffw_norm: boolean. Whether to normalize after the feedforward
             block. Defaults to `False`.
-        use_post_attention_norm: boolean. Whether to normalize after the attention
-            block. Defaults to `False`.
+        use_post_attention_norm: boolean. Whether to normalize after the
+            attention block. Defaults to `False`.
         attention_logit_soft_cap: `None` or int. Soft cap for the attention
             logits. Defaults to `None`.
         final_logit_soft_cap: `None` or int. Soft cap for the final logits.
@@ -300,7 +300,9 @@ class PaliGemmaBackbone(Backbone):
                 "final_logit_soft_cap": self.final_logit_soft_cap,
                 "attention_logit_soft_cap": self.attention_logit_soft_cap,
                 "sliding_window_size": self.sliding_window_size,
-                "use_sliding_window_attention": self.use_sliding_window_attention,
+                "use_sliding_window_attention": (
+                    self.use_sliding_window_attention
+                ),
                 "layer_norm_epsilon": self.layer_norm_epsilon,
                 "dropout": self.dropout,
             }

keras_hub/src/models/pali_gemma/pali_gemma_vit.py

@@ -61,7 +61,7 @@ class PaliGemmaVitEmbeddings(keras.layers.Layer):
 
 class PaliGemmaVitAttention(keras.layers.Layer):
     """
-    Adapted from https://github.com/huggingface/transformers/blob/main/src/transformers/models/clip/modeling_clip.py # noqa: E501
+    Adapted from https://github.com/huggingface/transformers/blob/main/src/transformers/models/clip/modeling_clip.py
     """
 
     def __init__(
@@ -120,7 +120,7 @@ class PaliGemmaVitAttention(keras.layers.Layer):
 
     def _transpose_for_scores(self, tensor, batch_size):
         """
-        Adapted from https://github.com/huggingface/transformers/blob/8e164c5400b7b413c7b8fb32e35132001effc970/src/transformers/models/bert/modeling_tf_bert.py#L252 # noqa: E501
+        Adapted from https://github.com/huggingface/transformers/blob/8e164c5400b7b413c7b8fb32e35132001effc970/src/transformers/models/bert/modeling_tf_bert.py#L252
         """
         # [batch_size, seq_len, all_head_dim] ->
         # [batch_size, seq_len, num_heads, head_dim]

keras_hub/src/models/phi3/phi3_decoder.py

@@ -53,7 +53,6 @@ class Phi3Decoder(keras.layers.Layer):
         self.kernel_initializer = keras.initializers.get(kernel_initializer)
 
     def build(self, decoder_sequence_shape):
-
         # Pre-attention layernorm.
         self.pre_attention_layernorm = Phi3LayerNorm(
             epsilon=self.layer_norm_epsilon,

keras_hub/src/models/phi3/phi3_rotary_embedding.py

@@ -43,7 +43,7 @@ class Phi3SuScaledRotaryEmbedding(RotaryEmbedding):
         max_sequence_length=4096,
         pretraining_sequence_length=4096,
         max_wavelength=10000,
-        **kwargs
+        **kwargs,
     ):
         super().__init__(max_wavelength=max_wavelength, **kwargs)
         self.max_sequence_length = max_sequence_length

keras_hub/src/models/preprocessor.py

@@ -161,12 +161,12 @@ class Preprocessor(PreprocessingLayer):
         Examples:
         ```python
         # Load a preprocessor for Gemma generation.
-        preprocessor = keras_hub.models.GemmaCausalLMPreprocessor.from_preset(
+        preprocessor = keras_hub.models.CausalLMPreprocessor.from_preset(
             "gemma_2b_en",
         )
 
         # Load a preprocessor for Bert classification.
-        preprocessor = keras_hub.models.BertTextClassifierPreprocessor.from_preset(
+        preprocessor = keras_hub.models.TextClassifierPreprocessor.from_preset(
             "bert_base_en",
         )
         ```

keras_hub/src/models/retinanet/feature_pyramid.py

@@ -9,8 +9,9 @@ class FeaturePyramid(keras.layers.Layer):
     """A Feature Pyramid Network (FPN) layer.
 
     This implements the paper:
-        Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan,
-        and Serge Belongie. Feature Pyramid Networks for Object Detection.
+        Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He,
+        Bharath Hariharan, and Serge Belongie.
+        Feature Pyramid Networks for Object Detection.
         (https://arxiv.org/pdf/1612.03144)
 
     Feature Pyramid Networks (FPNs) are basic components that are added to an

keras_hub/src/models/retinanet/prediction_head.py

@@ -7,8 +7,8 @@ class PredictionHead(keras.layers.Layer):
     """A head for classification or bounding box regression predictions.
 
     Args:
-        output_filters: int. The umber of convolution filters in the final layer.
-            The number of output channels determines the prediction type:
+        output_filters: int. The umber of convolution filters in the final
+            layer. The number of output channels determines the prediction type:
                 - **Classification**:
                     `output_filters = num_anchors * num_classes`
                     Predicts class probabilities for each anchor.

keras_hub/src/models/retinanet/retinanet_backbone.py

@@ -42,7 +42,8 @@ class RetinaNetBackbone(FeaturePyramidBackbone):
 
     Raises:
         ValueError: If `min_level` is greater than `max_level`.
-        ValueError: If `backbone_max_level` is less than 5 and `max_level` is greater than or equal to 5.
+        ValueError: If `backbone_max_level` is less than 5 and `max_level` is
+            greater than or equal to 5.
     """
 
     def __init__(
@@ -57,7 +58,6 @@ class RetinaNetBackbone(FeaturePyramidBackbone):
         dtype=None,
         **kwargs,
     ):
-
         # === Layers ===
         if min_level > max_level:
             raise ValueError(

keras_hub/src/models/retinanet/retinanet_image_converter.py

@@ -15,7 +15,7 @@ class RetinaNetImageConverter(ImageConverter):
         offset=None,
         norm_mean=[0.485, 0.456, 0.406],
         norm_std=[0.229, 0.224, 0.225],
-        **kwargs
+        **kwargs,
     ):
         super().__init__(**kwargs)
         self.image_size = image_size

keras_hub/src/models/retinanet/retinanet_object_detector.py

@@ -14,7 +14,7 @@ from keras_hub.src.models.retinanet.retinanet_backbone import RetinaNetBackbone
 from keras_hub.src.models.retinanet.retinanet_label_encoder import (
     RetinaNetLabelEncoder,
 )
-from keras_hub.src.models.retinanet.retinanet_object_detector_preprocessor import (
+from keras_hub.src.models.retinanet.retinanet_object_detector_preprocessor import (  # noqa: E501
     RetinaNetObjectDetectorPreprocessor,
 )
 
@@ -54,10 +54,8 @@ class RetinaNetObjectDetector(ImageObjectDetector):
             ground truth boxes and classes into training targets. It matches
             ground truth boxes to anchors based on IoU and encodes box
             coordinates as offsets. If `None`, a default encoder is created.
-            See the
-            `keras_hub.src.models.retinanet.retinanet_label_encoder.RetinaNetLabelEncoder`
-            class for details. If None, a default encoder is created with
-            standard parameters.
+            See the `RetinaNetLabelEncoder` class for details. If None, a
+            default encoder is created with standard parameters.
                 - `anchor_generator`: Same as the model's.
                 - `bounding_box_format`:  Same as the model's
                    `bounding_box_format`.
@@ -74,7 +72,8 @@ class RetinaNetObjectDetector(ImageObjectDetector):
         pre_logits_num_conv_layers: int. The number of convolutional layers in
             the head before the logits layer. These convolutional layers are
             applied before the final linear layer (logits) that produces the
-            output predictions (bounding box regressions, classification scores).
+            output predictions (bounding box regressions,
+            classification scores).
         preprocessor: Optional. An instance of
             `RetinaNetObjectDetectorPreprocessor`or a custom preprocessor.
             Handles image preprocessing before feeding into the backbone.

keras_hub/src/models/retinanet/retinanet_presets.py

@@ -5,7 +5,8 @@ backbone_presets = {
     "retinanet_resnet50_fpn_coco": {
         "metadata": {
             "description": (
-                "RetinaNet model with ResNet50 backbone fine-tuned on COCO in 800x800 resolution."
+                "RetinaNet model with ResNet50 backbone fine-tuned on COCO in "
+                "800x800 resolution."
             ),
             "params": 34121239,
             "path": "retinanet",

keras_hub/src/models/roberta/roberta_backbone.py

@@ -23,8 +23,8 @@ class RobertaBackbone(Backbone):
 
     The default constructor gives a fully customizable, randomly initialized
     RoBERTa encoder with any number of layers, heads, and embedding
-    dimensions. To load preset architectures and weights, use the `from_preset()`
-    constructor.
+    dimensions. To load preset architectures and weights, use the
+    `from_preset()` constructor.
 
     Disclaimer: Pre-trained models are provided on an "as is" basis, without
     warranties or conditions of any kind. The underlying model is provided by a

keras_hub/src/models/roberta/roberta_presets.py

@@ -5,7 +5,8 @@ backbone_presets = {
         "metadata": {
             "description": (
                 "12-layer RoBERTa model where case is maintained."
-                "Trained on English Wikipedia, BooksCorpus, CommonCraw, and OpenWebText."
+                "Trained on English Wikipedia, BooksCorpus, CommonCraw, and "
+                "OpenWebText."
             ),
             "params": 124052736,
             "path": "roberta",
@@ -16,7 +17,8 @@ backbone_presets = {
         "metadata": {
             "description": (
                 "24-layer RoBERTa model where case is maintained."
-                "Trained on English Wikipedia, BooksCorpus, CommonCraw, and OpenWebText."
+                "Trained on English Wikipedia, BooksCorpus, CommonCraw, and "
+                "OpenWebText."
             ),
             "params": 354307072,
             "path": "roberta",

keras_hub/src/models/roberta/roberta_text_classifier.py

@@ -38,9 +38,9 @@ class RobertaTextClassifier(TextClassifier):
     Args:
         backbone: A `keras_hub.models.RobertaBackbone` instance.
         num_classes: int. Number of classes to predict.
-        preprocessor: A `keras_hub.models.RobertaTextClassifierPreprocessor` or `None`. If
-            `None`, this model will not apply preprocessing, and inputs should
-            be preprocessed before calling the model.
+        preprocessor: A `keras_hub.models.RobertaTextClassifierPreprocessor` or
+            `None`. If `None`, this model will not apply preprocessing, and
+            inputs should be preprocessed before calling the model.
         activation: Optional `str` or callable. The activation function to use
             on the model outputs. Set `activation="softmax"` to return output
             probabilities. Defaults to `None`.

keras_hub/src/models/sam/sam_backbone.py

@@ -9,8 +9,8 @@ class SAMBackbone(Backbone):
     """A backbone for the Segment Anything Model (SAM).
 
     Args:
-        image_encoder: `keras_hub.models.ViTDetBackbone`. A feature extractor for
-            the input images.
+        image_encoder: `keras_hub.models.ViTDetBackbone`. A feature extractor
+            for the input images.
         prompt_encoder: `keras_hub.layers.SAMPromptEncoder`. A Keras layer to
             compute embeddings for points, box, and mask prompt.
         mask_decoder: `keras_hub.layers.SAMMaskDecoder`. A Keras layer to

keras_hub/src/models/sam/sam_image_segmenter.py

@@ -200,17 +200,18 @@ class SAMImageSegmenter(ImageSegmenter):
     def _add_placeholder_prompts(self, inputs):
         """Adds placeholder prompt inputs for a call to SAM.
 
-        Because SAM is a functional subclass model, all inputs must be specified in
-        calls to the model. However, prompt inputs are all optional, so we have to
-        add placeholders when they're not specified by the user.
+        Because SAM is a functional subclass model, all inputs must be specified
+        in calls to the model. However, prompt inputs are all optional, so we
+        have to add placeholders when they're not specified by the user.
         """
         inputs = inputs.copy()
 
         # Get the batch shape based on the image input
         batch_size = ops.shape(inputs["images"])[0]
 
-        # The type of the placeholders must match the existing inputs with respect
-        # to whether or not they are tensors (as opposed to Numpy arrays).
+        # The type of the placeholders must match the existing inputs with
+        # respect to whether or not they are tensors (as opposed to Numpy
+        # arrays).
         zeros = ops.zeros if ops.is_tensor(inputs["images"]) else np.zeros
 
         # Fill in missing inputs.

keras_hub/src/models/sam/sam_layers.py

@@ -170,8 +170,8 @@ class TwoWayMultiHeadAttention(keras.layers.Layer):
         key_dim: int. Size of each attention head for query, key, and
             value.
         intermediate_dim: int. Number of hidden dims to use in the mlp block.
-        skip_first_layer_pos_embedding: bool. A boolean indicating whether to skip the
-            first layer positional embeddings.
+        skip_first_layer_pos_embedding: bool. A boolean indicating whether to
+            skip the first layer positional embeddings.
         attention_downsample_rate: int, optional. The downsample rate to use
             in the attention layers. Defaults to 2.
         activation: str, optional. The activation for the mlp block's output
@@ -296,7 +296,9 @@ class TwoWayMultiHeadAttention(keras.layers.Layer):
                 "num_heads": self.num_heads,
                 "key_dim": self.key_dim,
                 "intermediate_dim": self.intermediate_dim,
-                "skip_first_layer_pos_embedding": self.skip_first_layer_pos_embedding,
+                "skip_first_layer_pos_embedding": (
+                    self.skip_first_layer_pos_embedding
+                ),
                 "attention_downsample_rate": self.attention_downsample_rate,
                 "activation": self.activation,
             }

keras_hub/src/models/sam/sam_prompt_encoder.py

@@ -57,7 +57,7 @@ class SAMPromptEncoder(keras.layers.Layer):
         input_image_size=(1024, 1024),
         mask_in_channels=16,
         activation="gelu",
-        **kwargs
+        **kwargs,
     ):
         super().__init__(**kwargs)
         self.hidden_size = hidden_size
@@ -305,7 +305,9 @@ class SAMPromptEncoder(keras.layers.Layer):
         return {
             "prompt_sparse_embeddings": sparse_embeddings,
             "prompt_dense_embeddings": dense_embeddings,
-            "prompt_dense_positional_embeddings": prompt_dense_positional_embeddings,
+            "prompt_dense_positional_embeddings": (
+                prompt_dense_positional_embeddings
+            ),
         }
 
     def get_config(self):