{
  "source_file": "0930",
  "source_platform": "Hashnode",
  "author": "Wesley Kambale",
  "title_listed": "TensorFlow v FLAX: A Comparison of Frameworks",
  "keywords": "",
  "domain": "机器学习",
  "content_type": "深度技术解析",
  "is_paid_flag": "否",
  "url": "https://kambale.dev/tensorflow-v-flax",
  "publish_date": "2023-06-12",
  "corpus_stage": "",
  "notes": "",
  "id": "b111fd87c76e",
  "collected_at": "2026-10-02T14:11:33",
  "title": "TensorFlow v FLAX: The Framework to Use",
  "body_markdown": "TensorFlow v FLAX: A Comparison of Frameworks\nA comprehensive comparison between TensorFlow and FLAX deep learning frameworks\nUpdated\nJuly 18, 2023\n•\n10\nmin read\n•\nView as Markdown\nW\nWesley Kambale\nI'm a Machine Learning Engineer passionate about building production-ready ML systems for the African market.\nWith experience in TensorFlow, Keras, and Python-based workflows, I help teams bridge the gap between machine learning research and real-world deployment—especially on resource-constrained devices.\nI'm also a Google Developer Expert in AI. I regularly speak at tech conferences including PyCon Africa, DevFest Kampala, DevFest Nairobi and more and also write technical articles on AI/ML here.\nPart of series\nMachine Learning\nIntroduction\nTensorFlow and FLAX are two popular frameworks that have gained significant traction in the deep learning community. In this article, we will explore and compare TensorFlow and FLAX, focusing on their features, functionality, advantages, and use cases.\nWhat is TensorFlow\nTensorFlow, developed by Google, is a widely adopted open-source framework for building machine learning and deep learning models. It provides a comprehensive ecosystem of tools, libraries, and resources to simplify the development and deployment of AI models. TensorFlow utilizes a dataflow graph paradigm, where computations are represented as a graph of nodes and edges.\nWhat is FLAX\nFLAX, developed by Google Research, is a new deep learning framework that aims to provide a more flexible and transparent approach to model development. It is built on top of JAX, a composable and high-performance library for numerical computing. FLAX follows a functional programming style and emphasizes code simplicity and modularity.\nKey Features of TensorFlow\nEase of Use:\nTensorFlow provides a high-level API that enables users to quickly build and deploy models with minimal code.\nFlexibility:\nIt supports a wide range of use cases, including computer vision, natural language processing, and reinforcement learning.\nScalability:\nTensorFlow offers distributed computing capabilities, allowing models to be trained on multiple devices or across a cluster of machines.\nModel Visualization:\nTensorFlow includes TensorBoard, a powerful visualization tool for monitoring and debugging models.\nPre-Trained Models and Transfer Learning:\nIt provides a vast collection of pre-trained models and supports transfer learning, allowing users to leverage pre-existing knowledge in their models.\nKey Features of FLAX\nModularity:\nFLAX promotes a modular and functional approach to model building, making it easier to reason about the code and modify model components.\nAutomatic Differentiation:\nFLAX leverages JAX's automatic differentiation capabilities, which enable efficient computation of gradients for optimization algorithms.\nResearch-Focused:\nFLAX is designed with research in mind, offering flexibility and extensibility to experiment with new model architectures and training techniques.\nDebugging and Profiling:\nFLAX integrates with JAX's profiling tools, making it easier to diagnose performance bottlenecks and optimize model training.\nReproducibility:\nFLAX enforces deterministic execution by default, ensuring that experiments can be easily reproduced.\nSummary of Key Features\nTensorFlow\nFLAX\nEase of Use\nModularity\nFlexibility\nAutomatic Differentiation\nScalability\nResearch-Focused\nModel Visualization\nDebugging and Profiling\nPre-Trained Models and Transfer Learning\nReproducibility\nFunctionality\nNow let's dive deeper into the comparison between TensorFlow and FLAX across various dimensions:\nCompatibility and Integration\nTensorFlow is compatible with a wide range of hardware and software platforms. It supports CPUs, GPUs, and TPUs, making it suitable for various deployment scenarios. TensorFlow integrates well with other popular libraries and frameworks, such as Keras, TensorFlow Probability, and TensorFlow Data.\nFLAX, being built on top of JAX, inherits JAX's compatibility with accelerators like GPUs and TPUs. It integrates seamlessly with other JAX libraries and can take advantage of JAX's automatic differentiation and GPU acceleration capabilities.\nTensorFlow - Using TensorFlow with GPUs and TPUs:\nimport\ntensorflow\nas\ntf\n# Check available devices\nprint(tf.config.list_physical_devices())\n# Use GPU for computation\nwith\ntf.device(\n'/GPU:0'\n):\n# TensorFlow operations\n# Use TPU for computation\nresolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu=\n'grpc://ip_address:8470'\n)\ntf.config.experimental_connect_to_cluster(resolver)\ntf.tpu.experimental.initialize_tpu_system(resolver)\nstrategy = tf.distribute.TPUStrategy(resolver)\nwith\nstrategy.scope():\n# TensorFlow operations\nFLAX - Using JAX and FLAX with GPUs and TPUs:\nimport\njax\nimport\njax.numpy\nas\njnp\n# Check available devices\nprint(jax.devices())\n# Use GPU for computation\ndevice = jax.devices(\n'gpu'\n)[\n0\n]\njax.jit(function, device=device)\n# Use TPU for computation\ndevice = jax.devices(\n'tpu'\n)[\n0\n]\njax.jit(function, device=device)\nMaturity and Stability\nTensorFlow has been in development for several years and has reached a high level of maturity and stability. It has a proven track record in large-scale production deployments and is backed by a major technology company like Google.\nFLAX, being a newer framework, is still evolving and may undergo more frequent updates and changes. While this provides opportunities for innovation and rapid development, it may also mean that certain features or optimizations are still under development.\nTensorFlow - Stability and production readiness:\nimport\ntensorflow\nas\ntf\n# Use TensorFlow for production-grade projects\nmodel = tf.keras.Sequential([\n    tf.keras.layers.Dense(\n64\n, activation=\n'relu'\n),\n    tf.keras.layers.Dense(\n10\n, activation=\n'softmax'\n)\n])\n# Train and evaluate the model\nmodel.compile(optimizer=\n'adam'\n, loss=\n'sparse_categorical_crossentropy'\n, metrics=[\n'accuracy'\n])\nmodel.fit(train_dataset, epochs=\n10\n, validation_data=val_dataset)\nFLAX - Innovations and rapid development:\nimport\nflax\nfrom\nflax\nimport\nlinen\nas\nnn\n# Use FLAX for research and experimental projects\nclass\nMyModel\n(\nnn.Module\n):\nhidden_dim: int\ndef\nsetup\n(\nself\n):\nself.dense = nn.Dense(self.hidden_dim)\n        self.output = nn.Dense(\n10\n)\ndef\n__call__\n(\nself, inputs\n):\nx = nn.relu(self.dense(inputs))\nreturn\nself.output(x)\n\nmodel = MyModel(hidden_dim=\n64\n)\n# Train and evaluate the model\noptimizer = flax.optim.Adam(learning_rate=\n0.001\n).create(model)\nfor\nbatch\nin\ndataset:\n    optimizer = optimizer.train_step(batch)\nModel Development\nTensorFlow provides two main APIs for model development: the high-level Keras API and the lower-level TensorFlow API. The Keras API offers a user-friendly interface for building and training models with minimal code. On the other hand, the TensorFlow API provides more flexibility and control over the model architecture and training process.\nFLAX, being built on top of JAX, follows a functional programming style. It promotes a modular approach to model development, allowing users to define models as composable functions. This design makes it easier to reason about the code, modify model components, and experiment with new architectures.\nMaking a simple feed-forward neural network in TensorFlow using the Keras API:\nimport\ntensorflow\nas\ntf\n\nmodel = tf.keras.Sequential([\n# Add a dense layer with 64 units and ReLU activation\ntf.keras.layers.Dense(\n64\n, activation=\n'relu'\n),\n# Add a dense layer with 10 units (output layer)\ntf.keras.layers.Dense(\n10\n)  \n])\nMaking the same feed-forward neural network in FLAX:\nfrom\nflax\nimport\nlinen\nas\nnn\nclass\nFeedForward\n(\nnn.Module\n):\nhidden_dim: int\ndef\nsetup\n(\nself\n):\n# Define a dense layer with hidden_dim units\nself.dense = nn.Dense(self.hidden_dim)\n# Define an output layer with 10 units\nself.output = nn.Dense(\n10\n)\ndef\n__call__\n(\nself, inputs\n):\n# Apply ReLU activation to the dense layer\nx = nn.relu(self.dense(inputs))\n# Return the output\nreturn\nself.output(x)\nTraining and Optimization\nBoth TensorFlow and FLAX support various optimization algorithms, such as stochastic gradient descent (SGD), Adam, and RMSprop. TensorFlow provides a wide range of pre-built optimizers, while FLAX allows users to define custom optimizers easily.\nTensorFlow uses the concept of eager execution by default, which allows for immediate computation and easy debugging. FLAX, on the other hand, follows a more functional style and separates the model definition from the training loop, which can provide better optimization and performance.\nTraining a model in TensorFlow:\n# Define an Adam optimizer with learning rate 0.001\noptimizer = tf.keras.optimizers.Adam(learning_rate=\n0.001\n)\n# Define the loss function\nloss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=\nTrue\n)\nfor\ninputs, labels\nin\ndataset:\nwith\ntf.GradientTape()\nas\ntape:\n    logits = model(inputs)\n# Compute the loss\nloss = loss_fn(labels, logits)\n# Compute the gradients\ngrads = tape.gradient(loss, model.trainable_variables)\n# Update the model parameters\noptimizer.apply_gradients(zip(grads, model.trainable_variables))\nTraining the same model in FLAX:\n# Define an Adam optimizer with learning rate 0.001\noptimizer = flax.optim.Adam(learning_rate=\n0.001\n)\n# Define the loss function\nloss_fn = flax.nn.logits_cross_entropy_loss\ndef\ntrain_step\n(\noptimizer, batch\n):\ndef\nloss_fn\n(\nmodel\n):\nlogits = model(batch[\n'inputs'\n])\n# Compute the loss\nloss = loss_fn(labels=batch[\n'labels'\n], logits=logits)\nreturn\nloss.mean()\n# Compute the gradient function\ngrad_fn = jax.grad(loss_fn)\n# Compute the gradients\ngrad = grad_fn(optimizer.target)\n# Update the model parameters\noptimizer = optimizer.apply_gradient(grad)\nreturn\noptimizer\nfor\nbatch\nin\ndataset:\n# Perform a training step\noptimizer = train_step(optimizer, batch)\nDistributed Training\nBoth TensorFlow and FLAX provide support for distributed training across multiple devices or machines. TensorFlow offers the\ntf.distribute.Strategy\nAPI, which allows users to distribute training across multiple GPUs or machines seamlessly. FLAX, being built on top of JAX, inherits JAX's built-in support for distributed computing.\nDistributed training in TensorFlow using\ntf.distribute.Strategy\n:\n# Create a MirroredStrategy for synchronous training across multiple GPUs\nstrategy = tf.distribute.MirroredStrategy()\nwith\nstrategy.scope():\n# Create the model within the strategy's scope\nmodel = create_model()  \n  optimizer = tf.keras.optimizers.Adam()\n# Train the model\nmodel.fit(train_dataset, epochs=\n10\n, validation_data=val_dataset)\nDistributed training in FLAX using\njax.pmap\n:\nmodel = create_model()\noptimizer = flax.optim.Adam(learning_rate=\n0.001\n)\n@jax.pmap\ndef\ntrain_step\n(\noptimizer, batch\n):\ndef\nloss_fn\n(\nmodel\n):\nlogits = model(batch[\n'inputs'\n])\n# Compute the loss\nloss = loss_fn(labels=batch[\n'labels'\n], logits=logits)\nreturn\nloss.mean()\n# Compute the gradient function\ngrad_fn = jax.grad(loss_fn)\n# Compute the gradients\ngrad = grad_fn(optimizer.target)\n# Update the model parameters\noptimizer = optimizer.apply_gradient(grad)\nreturn\noptimizer\nfor\nbatch\nin\ndataset:\n# Perform a training step\noptimizer = train_step(optimizer, batch)\nModel Serving and Deployment\nTensorFlow provides robust tools for model serving and deployment. TensorFlow Serving allows you to serve trained models over a network, making it easier to integrate models into production systems. TensorFlow also supports TensorFlow Lite, which enables the deployment of models on mobile and edge devices with optimized performance.\nFLAX, being a research-focused framework, does not have built-in tools specifically designed for model serving and deployment. However, FLAX models can be exported and deployed using other frameworks or custom deployment pipelines.\nTensorFlow - Serving a trained model using TensorFlow Serving:\nimport\ntensorflow\nas\ntf\nfrom\ntensorflow_serving.apis\nimport\npredict_pb2\nfrom\ntensorflow_serving.apis\nimport\nprediction_service_pb2_grpc\n# Create a gRPC channel to connect to the TensorFlow Serving server\nchannel = tf.grpc.insecure_channel(\n'localhost:8500'\n)\nstub = prediction_service_pb2_grpc.PredictionServiceStub(channel)\n# Create a request for inference\nrequest = predict_pb2.PredictRequest()\nrequest.model_spec.name =\n'my_model'\nrequest.model_spec.signature_name =\n'serving_default'\nrequest.inputs[\n'input'\n].CopyFrom(tf.make_tensor_proto(input_data))\n# Send the request and get the response\nresponse = stub.Predict(request)\noutput_data = tf.make_ndarray(response.outputs[\n'output'\n])\nFLAX - Exporting a trained model for deployment using a custom pipeline:\nfrom\nflax\nimport\nserialization\n# Export the FLAX model\nmodel_params = model.params\nserialized_model = serialization.to_bytes(model_params)\n# Save the serialized model to a file\nwith\nopen(\n'model.flax'\n,\n'wb'\n)\nas\nf:\n    f.write(serialized_model)\n# Deploy the exported model using a custom deployment pipeline\n# ... (Implementation depends on the deployment setup)\nLearning Curve\nTensorFlow has a gentle learning curve, especially when using the Keras API, which provides a high-level abstraction for model development. Its extensive documentation and broad community support make it easier for beginners to get started.\nFLAX, with its functional programming style and modular approach, may have a steeper learning curve, especially for those who are new to JAX or functional programming concepts. However, it offers a deeper level of control and flexibility for advanced users and researchers.\nTensorFlow - Easy learning curve with Keras API:\nimport\ntensorflow\nas\ntf\n# Define a model using the Keras API\nmodel = tf.keras.Sequential([\n    tf.keras.layers.Dense(\n64\n, activation=\n'relu'\n),\n    tf.keras.layers.Dense(\n10\n, activation=\n'softmax'\n)\n])\n# Compile and train the model\nmodel.compile(optimizer=\n'adam'\n, loss=\n'sparse_categorical_crossentropy'\n, metrics=[\n'accuracy'\n])\nmodel.fit(train_dataset, epochs=\n10\n, validation_data=val_dataset)\nFLAX - Steeper learning curve with functional programming style:\nimport\njax\nfrom\njax\nimport\nnumpy\nas\njnp\n# Define a model using FLAX with functional programming style\n@jax.jit\ndef\nmodel\n(\nparams, inputs\n):\ndense = flax.nn.Dense(inputs.shape[\n-1\n], features=\n64\n)\n    x = dense.initialize_carry(jax.random.PRNGKey(\n0\n), inputs)\n    x = flax.nn.relu(x)\n    output = flax.nn.Dense(x.shape[\n-1\n], features=\n10\n).initialize_carry(jax.random.PRNGKey(\n0\n), x)\nreturn\noutput\n# Train the model\noptimizer = flax.optim.Adam(learning_rate=\n0.001\n).create(model.params)\nfor\nbatch\nin\ndataset:\n    optimizer = optimizer.train_step(batch)\nEcosystem and Community\nTensorFlow has a mature and extensive ecosystem with a wide range of libraries, tools, and resources. It offers TensorFlow Hub for sharing and discovering pre-trained models, TensorFlow Serving for deploying models in production, and TensorFlow Lite for running models on mobile and edge devices.\nFLAX is a relatively new framework and its ecosystem is still growing. However, FLAX benefits from JAX's ecosystem, which includes libraries for distributed computing, automatic differentiation, and GPU acceleration.\nIndustry Adoption\nTensorFlow - Widely adopted in the industry:\nTensorFlow in Production:\nhttps://www.tensorflow.org/guide/production\nTensorFlow Success Stories:\nhttps://www.tensorflow.org/stories\nFLAX - Growing adoption in research and cutting-edge projects:\nFLAX GitHub Showcase:\nhttps://github.com/google/flax#showcase\nFLAX Research Papers and Publications:\nhttps://github.com/google/flax#research-papers-and-publications\nCommunity and Documentation\nTensorFlow - Accessing TensorFlow's extensive documentation and resources:\nTensorFlow Official Website:\nhttps://www.tensorflow.org/\nTensorFlow GitHub Repository:\nhttps://github.com/tensorflow/tensorflow\nTensorFlow Tutorials:\nhttps://www.tensorflow.org/tutorials\nTensorFlow Community:\nhttps://www.tensorflow.org/community\nFLAX - Accessing JAX and FLAX documentation and resources:\nJAX Official Website:\nhttps://jax.readthedocs.io/\nJAX GitHub Repository:\nhttps://github.com/google/jax\nJAX Tutorials:\nhttps://jax.readthedocs.io/en/latest/notebooks.html\nFLAX GitHub Repository:\nhttps://github.com/google/flax\nFLAX Community:\nhttps://github.com/google/flax#community\nConclusion\nTensorFlow and FLAX are powerful frameworks for building and training machine learning and deep learning models. TensorFlow provides a rich set of features, and an extensive ecosystem, and is widely adopted in both research and industry. On the other hand, FLAX offers a more flexible and functional approach to model development, making it well-suited for research and experimentation.\nThe choice between TensorFlow and FLAX depends on the specific requirements of your project. TensorFlow is a great choice for developers who value a mature ecosystem, ease of use, and extensive community support. FLAX is a good fit for researchers and developers who prefer a functional programming style, modularity, and flexibility.\nUltimately, both frameworks have their strengths and use cases, and choosing the right one depends on your specific needs and preferences. Good luck at choosing one!\n#\ntensorflow\n#\ndeep-learning\n#\nmachine-learning\n#\nflax",
  "metadata": {
    "title": "TensorFlow v FLAX: The Framework to Use",
    "description": "A comprehensive comparison between TensorFlow and FLAX deep learning frameworks",
    "keywords": null,
    "author": null,
    "og:title": "TensorFlow v FLAX: The Framework to Use",
    "og:description": "A comprehensive comparison between TensorFlow and FLAX deep learning frameworks",
    "og:url": "https://kambale.dev/tensorflow-v-flax",
    "og:site_name": "Wesley Kambale",
    "og:image": "https://cdn.hashnode.com/res/hashnode/image/upload/v1689702149799/7bcf2b84-436d-427f-9d53-29d1ef874f31.png",
    "og:image:width": "1200",
    "og:image:height": "630",
    "og:type": "article",
    "twitter:card": "summary_large_image",
    "twitter:creator": "https://twitter.com/WesKambale",
    "twitter:title": "TensorFlow v FLAX: The Framework to Use",
    "twitter:description": "A comprehensive comparison between TensorFlow and FLAX deep learning frameworks",
    "twitter:image": "https://cdn.hashnode.com/res/hashnode/image/upload/v1689702149799/7bcf2b84-436d-427f-9d53-29d1ef874f31.png",
    "article:published_time": "2023-06-12T19:47:11.927Z",
    "article:modified_time": "2023-07-18T17:42:53.806Z",
    "article:author": "https://kambale.dev/@kambale"
  },
  "paywall": {
    "listed_paid": false,
    "detected": false,
    "marker": "",
    "public_only": false,
    "policy": "付费/会员内容只保留页面公开可见部分，不绕过付费墙"
  },
  "crawl": {
    "success": true,
    "status_code": 200,
    "error": ""
  },
  "code_blocks": [
    {
      "file": "attachments/b111fd87c76e/code/body-000.txt",
      "chars": 493,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-001.txt",
      "chars": 265,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-002.txt",
      "chars": 398,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-003.txt",
      "chars": 538,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-004.txt",
      "chars": 243,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-005.txt",
      "chars": 434,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-006.txt",
      "chars": 551,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-007.txt",
      "chars": 695,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-008.txt",
      "chars": 348,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-009.txt",
      "chars": 599,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-010.txt",
      "chars": 687,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-011.txt",
      "chars": 364,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-012.txt",
      "chars": 387,
      "language": "text"
    },
    {
      "file": "attachments/b111fd87c76e/code/body-013.txt",
      "chars": 551,
      "language": "text"
    }
  ],
  "images": [
    {
      "status": "ok",
      "url": "https://cdn.hashnode.com/res/hashnode/image/upload/v1689702149799/7bcf2b84-436d-427f-9d53-29d1ef874f31.png",
      "bytes": 131248,
      "reused": true,
      "local_path": "attachments/b111fd87c76e/images/000.png",
      "src": "https://cdn.hashnode.com/res/hashnode/image/upload/v1689702149799/7bcf2b84-436d-427f-9d53-29d1ef874f31.png",
      "alt": "TensorFlow v FLAX: A Comparison of Frameworks",
      "downloaded": true
    }
  ],
  "audio": [],
  "videos": [],
  "links": [
    {
      "href": "https://kambale.dev/tensorflow-v-flax.md",
      "label": "View as Markdown",
      "type": "a"
    },
    {
      "href": "https://hashnode.com/@kambale",
      "label": "W",
      "type": "a"
    },
    {
      "href": "https://twitter.com/WesKambale",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://linkedin.com/in/WesKambale",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://kambale.dev/series/ml-series",
      "label": "Part of series Machine Learning",
      "type": "a"
    },
    {
      "href": "https://www.tensorflow.org/guide/production",
      "label": "https://www.tensorflow.org/guide/production",
      "type": "a"
    },
    {
      "href": "https://www.tensorflow.org/stories",
      "label": "https://www.tensorflow.org/stories",
      "type": "a"
    },
    {
      "href": "https://github.com/google/flax",
      "label": "https://github.com/google/flax#showcase",
      "type": "a"
    },
    {
      "href": "https://www.tensorflow.org/",
      "label": "https://www.tensorflow.org/",
      "type": "a"
    },
    {
      "href": "https://github.com/tensorflow/tensorflow",
      "label": "https://github.com/tensorflow/tensorflow",
      "type": "a"
    },
    {
      "href": "https://www.tensorflow.org/tutorials",
      "label": "https://www.tensorflow.org/tutorials",
      "type": "a"
    },
    {
      "href": "https://www.tensorflow.org/community",
      "label": "https://www.tensorflow.org/community",
      "type": "a"
    },
    {
      "href": "https://jax.readthedocs.io/",
      "label": "https://jax.readthedocs.io/",
      "type": "a"
    },
    {
      "href": "https://github.com/google/jax",
      "label": "https://github.com/google/jax",
      "type": "a"
    },
    {
      "href": "https://jax.readthedocs.io/en/latest/notebooks.html",
      "label": "https://jax.readthedocs.io/en/latest/notebooks.html",
      "type": "a"
    },
    {
      "href": "https://kambale.dev/tag/tensorflow",
      "label": "# tensorflow",
      "type": "a"
    },
    {
      "href": "https://kambale.dev/tag/deep-learning",
      "label": "# deep-learning",
      "type": "a"
    },
    {
      "href": "https://kambale.dev/tag/machine-learning",
      "label": "# machine-learning",
      "type": "a"
    },
    {
      "href": "https://kambale.dev/tag/flax",
      "label": "# flax",
      "type": "a"
    }
  ],
  "repair_version": 2,
  "repaired_at": "2026-10-14T10:50:51Z",
  "source_url": "https://kambale.dev/tensorflow-v-flax",
  "papers": [],
  "actual_video_files": [],
  "body_chars": 17170,
  "expected_body_images": 1,
  "discovery_status": "ok",
  "delivery_status": "ok",
  "missing_reason": "",
  "raw_html": "attachments/b111fd87c76e/pages/source.html",
  "local_html": "attachments/b111fd87c76e/pages/article.html",
  "body_base_path": "attachments/b111fd87c76e/pages/",
  "body_markdown_path": "attachments/b111fd87c76e/pages/article.md"
}