# TensorFlow — Open Source Machine Learning Framework for Everyone

> TensorFlow is an end-to-end open-source machine learning platform by Google. It provides a comprehensive ecosystem for building and deploying ML models across research, production, mobile, edge, and web — with Keras as its high-level API.

## Install

Save as a script file and run:

# TensorFlow — Open Source Machine Learning Framework for Everyone

## Quick Use
```bash
# Install TensorFlow
pip install tensorflow

# Quick demo
python3 -c "
import tensorflow as tf
print(f'TensorFlow version: {tf.__version__}')
print(f'GPU available: {len(tf.config.list_physical_devices("GPU")) > 0}')

# Simple model
model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mse')
model.fit([1,2,3,4], [2,4,6,8], epochs=50, verbose=0)
print(f'Prediction for 5: {model.predict([5])[0][0]:.1f}')
"
```

## Introduction
TensorFlow is the most widely deployed machine learning framework in the world. Created by Google Brain, it powers ML systems at Google, DeepMind, and thousands of companies globally. From research prototyping to production serving at scale, TensorFlow provides tools for every stage of the ML lifecycle.

With over 195,000 GitHub stars, TensorFlow is one of the most starred repositories on GitHub. It supports training on CPUs, GPUs, and TPUs, deployment on servers, mobile devices (TensorFlow Lite), browsers (TensorFlow.js), and embedded systems.

## What TensorFlow Does
TensorFlow provides the computational backbone for machine learning. It handles tensor operations, automatic differentiation, model building (via Keras), distributed training, model optimization, and deployment. Its ecosystem includes tools for data pipelines (tf.data), model serving (TF Serving), and experiment tracking (TensorBoard).

## Architecture Overview
```
[TensorFlow Ecosystem]
        |
+-------+-------+-------+
|       |       |       |
[Keras]  [tf.data] [TensorBoard]
High-level Data     Visualization
model API pipelines & monitoring
        |
[TensorFlow Core]
Tensor operations,
automatic differentiation,
graph execution
        |
+-------+-------+-------+
|       |       |       |
[CPU]   [GPU]   [TPU]   [Custom]
Intel   NVIDIA  Google  Hardware
ARM     AMD     Cloud   accelerators
        |
[Deployment]
TF Serving | TF Lite | TF.js
Server      Mobile    Browser
```

## Self-Hosting & Configuration
```python
import tensorflow as tf
from tensorflow import keras

# Build a CNN for image classification
model = keras.Sequential([
    keras.layers.Conv2D(32, 3, activation="relu", input_shape=(28, 28, 1)),
    keras.layers.MaxPooling2D(),
    keras.layers.Conv2D(64, 3, activation="relu"),
    keras.layers.MaxPooling2D(),
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dropout(0.5),
    keras.layers.Dense(10, activation="softmax")
])

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)

# Load data and train
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train[..., None] / 255.0
x_test = x_test[..., None] / 255.0

model.fit(x_train, y_train, epochs=5, validation_split=0.1,
          callbacks=[keras.callbacks.TensorBoard(log_dir="./logs")])

# Save and serve
model.save("my_model.keras")
# Or export for TF Serving:
# tf.saved_model.save(model, "serving_model/1/")
```

## Key Features
- **Keras API** — intuitive high-level API for building and training models
- **Multi-Platform** — train on CPU, GPU, and TPU with the same code
- **TF Serving** — production model serving with versioning and A/B testing
- **TF Lite** — optimized inference for mobile and embedded devices
- **TF.js** — run models directly in the browser
- **TensorBoard** — visualization for training metrics, graphs, and profiling
- **tf.data** — efficient data loading and preprocessing pipelines
- **Distributed Training** — multi-GPU and multi-node training strategies

## Comparison with Similar Tools
| Feature | TensorFlow | PyTorch | JAX | MXNet | PaddlePaddle |
|---|---|---|---|---|---|
| Creator | Google | Meta | Google | Apache | Baidu |
| Ease of Use | High (Keras) | High | Moderate | Moderate | High |
| Production Deploy | Excellent | Good | Limited | Good | Good |
| Mobile/Edge | TF Lite | ExecuTorch | N/A | Limited | Paddle Lite |
| Browser | TF.js | Via ONNX | N/A | N/A | N/A |
| Research Adoption | High | Very High | Growing | Low | Regional |
| Industry Adoption | Very High | High | Growing | Declining | Regional |

## FAQ
**Q: TensorFlow vs PyTorch — which should I learn?**
A: PyTorch is dominant in research and increasingly popular in industry. TensorFlow excels in production deployment (TF Serving, TF Lite, TF.js). Many companies use both — PyTorch for research, TensorFlow for deployment. Learning either is valuable.

**Q: Is TensorFlow 1.x still used?**
A: TensorFlow 2.x (with Keras as the default API) is the current standard. TF 1.x code can be migrated using the tf.compat.v1 module, but new projects should use TF 2.x exclusively.

**Q: How do I use GPU acceleration?**
A: Install the GPU version: pip install tensorflow[and-cuda]. TensorFlow automatically detects and uses available NVIDIA GPUs. No code changes needed — just install the right package.

**Q: Can TensorFlow train large language models?**
A: Yes, though PyTorch is more common for LLM training. TensorFlow powers many models at Google including Gemini. For LLM inference, consider TensorFlow Lite or export to ONNX.

## Sources
- GitHub: https://github.com/tensorflow/tensorflow
- Documentation: https://www.tensorflow.org
- Created by Google Brain team
- License: Apache-2.0

---
Source: https://tokrepo.com/en/workflows/3465a6fd-3701-11f1-9bc6-00163e2b0d79
Author: Script Depot