TFLite

## What conversion actually is You never train in TFLite. You train with TensorFlow or Keras, then *convert* the trained graph into a `.tflite` file, which is a FlatBuffer: a flat, memory-mappable binary containing the operator list, the tensor shapes and dtypes, and the weight buffers. FlatBuffers can be read without parsing or allocating, which is why the format was chosen for phones and microcontrollers — the runtime can mmap the file and start reading tensors immediately. ## The three entry points ``` converter = tf.lite.TFLiteConverter.from_saved_model("saved_model/") converter = tf.lite.TFLiteConverter.from_keras_model(model) converter = tf.lite.TFLiteConverter.from_concrete_functions([fn], model) ``` `from_saved_model` is preferred. A SavedModel on disk already has its variables frozen into a checkpoint and its entry points recorded as signatures, so the converter reads a stable artifact rather than re-tracing live Python objects. `from_keras_model` is convenient in a notebook but depends on the in-memory model tracing cleanly. With Keras 3 (the default Keras in TensorFlow 2.x today), the robust path is to call `model.export("saved_model/")` to write a SavedModel and then use `from_saved_model`. `from_concrete_functions` is for when you want to convert one specific traced `tf.function` signature, typically to pin input shapes. ## convert() returns bytes, not a file This trips people up in interviews and in code review: ``` tflite_model = converter.convert() # bytes with open("model.tflite", "wb") as f: f.write(tflite_model) ``` There is no `output_file` argument. `convert()` runs the MLIR-based conversion pipeline in-process and hands you the buffer. If conversion fails, it raises — most often with a message naming an operator the built-in kernel set does not implement. ## What the converter changes about your graph Conversion is not a format rename. The pipeline folds variables into constants, removes anything that only existed for training (optimizer slots, gradient ops, dropout in inference mode), constant-folds subgraphs, and fuses recognizable patterns — a convolution followed by batch normalization and a ReLU typically collapses into one fused kernel with a built-in activation. That fusion is a large part of why a `.tflite` model is faster than the same graph in TensorFlow, and it is also why the converted op list will not match your layer list one-for-one when you inspect it. Because the output is inference-only, you cannot resume training from a `.tflite` file. It is a build artifact: keep the SavedModel or the checkpoint as the source of truth and treat the `.tflite` as something you can always rebuild. ## Defaults By default the output keeps float32 weights and float32 activations, so the file is roughly the same size as the float model. Size and latency work is opt-in through `converter.optimizations`, `converter.target_spec.supported_types` and `converter.representative_dataset`. Shipping a float32 model is a perfectly valid first step: convert, confirm the numbers match your TensorFlow evaluation, and only then start quantizing, so that if accuracy moves you know which step moved it. ## Shapes and signatures A converted model records concrete input shapes. If your SavedModel signature has a dynamic batch dimension, the `.tflite` model carries a placeholder batch size (usually 1) which the runtime can resize before allocating. Fully dynamic non-batch dimensions are a common source of conversion errors, because many built-in kernels need static shapes; pinning shapes at export time with an `input_signature` on the `tf.function` avoids a class of late failures. ## The current toolchain, and what moved TensorFlow Lite was rebranded LiteRT, and the two halves moved at different times. Conversion still lives in `tf.lite`: `tf.lite.TFLiteConverter` is not deprecated and `.tflite` is still the file format. The *runtime* moved — TensorFlow's own source warns that `tf.lite.Interpreter` is deprecated in favour of the interpreter shipped in the `ai_edge_litert` package, and the old standalone `tflite-runtime` wheel has stopped shipping. So a current answer is: convert with `tf.lite.TFLiteConverter`, run with LiteRT. Candidates who say "tf.lite is dead, everything moved" are half right and get corrected. ## Metadata A `.tflite` file can carry an optional metadata blob describing input normalization, label files and model provenance, which mobile codegen tools read to produce typed wrappers. It is packed into the FlatBuffer after conversion, not produced by `convert()` itself, and it is entirely optional — a model without metadata runs fine.