Kenhuang Academy
  • English

      • TensorFlow Introduction

      What is TensorFlow?

      TensorFlow is an open-source machine learning framework developed by Google, first released in 2015. It is one of the most popular deep learning frameworks in the world today, widely used in research and production environments.

      import tensorflow as tf
print(f"TensorFlow version: {tf.__version__}")

# Create a simple tensor
hello = tf.constant('Hello, TensorFlow!')
print(hello)

      TensorFlow History

      Development Timeline

      • 2011: Google begins developing the DistBelief system internally
      • November 2015: TensorFlow 0.5.0 open-source release
      • February 2017: TensorFlow 1.0 release with stable API
      • October 2019: TensorFlow 2.0 release with major architecture improvements
      • May 2021: TensorFlow 2.5 introduces more optimizations
      • Present: Continuous rapid development and version updates

      Important Milestones

      • TensorFlow 1.x: Based on static computational graphs, requires explicit session management
      • TensorFlow 2.x: Introduced Eager Execution, more Pythonic
      • Keras Integration: Keras became TensorFlow's high-level API
      • TensorFlow Lite: Mobile and embedded device support
      • TensorFlow.js: Browser and Node.js support

      Core Features

      1. Flexible Architecture

      # TensorFlow supports multiple abstraction levels
import tensorflow as tf

# Low-level operations
a = tf.constant([1, 2, 3])
b = tf.constant([4, 5, 6])
c = tf.add(a, b)

# High-level API (Keras)
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

print(f"Low-level operation result: {c}")
print(f"Model structure: {model.summary()}")

      2. Cross-Platform Support

      • Operating Systems: Linux, macOS, Windows
      • Hardware: CPU, GPU, TPU
      • Mobile: Android, iOS (TensorFlow Lite)
      • Web: Browsers (TensorFlow.js)
      • Embedded: Microcontrollers (TensorFlow Micro)

      3. Production Ready

      # TensorFlow provides complete production toolchain
import tensorflow as tf

# Model saving
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='softmax')
])
model.save('my_model')

# Model serving
# TensorFlow Serving can directly deploy models
# tf.saved_model.save(model, 'serving_model')

      4. Powerful Ecosystem

      • TensorFlow Extended (TFX): End-to-end machine learning platform
      • TensorBoard: Visualization tools
      • TensorFlow Hub: Pre-trained model library
      • TensorFlow Datasets: Standard datasets
      • TensorFlow Probability: Probabilistic programming

      TensorFlow vs Other Frameworks

      FeatureTensorFlowPyTorchKerasJAX
      Learning DifficultyMediumMediumEasyHard
      FlexibilityVery HighVery HighMediumVery High
      Production DeploymentExcellentGoodDepends on TFAverage
      Community SupportExcellentExcellentGoodAverage
      Industrial ApplicationsVery WidespreadWidespreadWidespreadEmerging

      Application Areas

      1. Computer Vision

      # Image classification example
import tensorflow as tf

# Use pre-trained model
model = tf.keras.applications.ResNet50(
    weights='imagenet',
    include_top=True
)

# Image preprocessing
preprocess = tf.keras.applications.resnet50.preprocess_input
decode_predictions = tf.keras.applications.resnet50.decode_predictions

      Application Scenarios:

      • Image classification and recognition
      • Object detection and tracking
      • Image segmentation
      • Face recognition
      • Medical image analysis

      2. Natural Language Processing

      # Text processing example
import tensorflow as tf

# Text vectorization
vectorizer = tf.keras.utils.text_dataset_from_directory(
    'text_data',
    batch_size=32,
    validation_split=0.2,
    subset='training',
    seed=123
)

# Pre-trained model
import tensorflow_hub as hub
embed = hub.load("https://tfhub.dev/google/universal-sentence-encoder/4")

      Application Scenarios:

      • Machine translation
      • Sentiment analysis
      • Question answering systems
      • Text summarization
      • Chatbots

      3. Speech Processing

      Application Scenarios:

      • Speech recognition
      • Speech synthesis
      • Audio classification
      • Music generation

      4. Recommendation Systems

      # Recommendation system example
import tensorflow as tf
import tensorflow_recommenders as tfrs

class RankingModel(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.rating_model = tf.keras.Sequential([
            tf.keras.layers.Dense(256, activation="relu"),
            tf.keras.layers.Dense(64, activation="relu"),
            tf.keras.layers.Dense(1)
        ])
    
    def call(self, features):
        return self.rating_model(features)

      5. Time Series Prediction

      # Time series model
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.LSTM(50, return_sequences=True),
    tf.keras.layers.LSTM(50),
    tf.keras.layers.Dense(1)
])

      TensorFlow Ecosystem

      Core Components

      # TensorFlow core components example
import tensorflow as tf

# 1. Tensor operations
tensor = tf.constant([[1, 2], [3, 4]])

# 2. Automatic differentiation
with tf.GradientTape() as tape:
    x = tf.Variable(3.0)
    y = x ** 2
    grad = tape.gradient(y, x)

# 3. Keras high-level API
model = tf.keras.Sequential()

# 4. Data pipeline
dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5])

      Extension Tools

      TensorBoard

      # Visualization tools
import tensorflow as tf

# Create log directory
log_dir = "logs/"
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir=log_dir, 
    histogram_freq=1
)

# Use during training
# model.fit(x_train, y_train, callbacks=[tensorboard_callback])

      TensorFlow Hub

      # Pre-trained model library
import tensorflow_hub as hub

# Load pre-trained model
module = hub.load("https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4")

# Use pre-trained features
features = module(images)

      TensorFlow Datasets

      # Standard datasets
import tensorflow_datasets as tfds

# Load dataset
(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['train', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True,
)

      Major Improvements in TensorFlow 2.x

      1. Eager Execution

      # TensorFlow 2.x enables Eager Execution by default
import tensorflow as tf

# Immediate execution, no session needed
a = tf.constant([1, 2, 3])
b = tf.constant([4, 5, 6])
c = a + b
print(c)  # Output result immediately

      2. Simplified API

      # More concise API design
import tensorflow as tf

# Simpler model definition
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10)
])

# Compile and train
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

      3. Better Debugging Experience

      # Easier to debug
import tensorflow as tf

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        predictions = model(x, training=True)
        loss = loss_fn(y, predictions)
    
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    
    return loss

# Can directly print and debug

      Why Choose TensorFlow?

      1. Industrial-Grade Maturity

      • Production validated by major companies like Google
      • Complete MLOps toolchain
      • Strong deployment capabilities

      2. Rich Ecosystem

      • Large number of pre-trained models
      • Comprehensive tools and libraries
      • Active community support

      3. Cross-Platform Capabilities

      • From servers to mobile devices
      • From cloud to edge computing
      • Unified development experience

      4. Continuous Innovation

      • Keeping up with academic frontiers
      • Rapid integration of new technologies
      • Regular updates and improvements

      Learning Path Recommendations

      Beginner Path

      1. Basic Concepts: Tensors, computational graphs, automatic differentiation
      2. Keras API: Using high-level APIs
      3. Classic Models: Basic models like CNN, RNN
      4. Practical Projects: Complete specific application projects

      Advanced Path

      1. Custom Components: Custom layers, loss functions, optimizers
      2. Distributed Training: Multi-GPU and multi-machine training
      3. Model Deployment: TensorFlow Serving, TensorFlow Lite
      4. Performance Optimization: Model optimization and acceleration techniques

      Professional Path

      1. Research-Oriented: Implementation of latest papers
      2. Engineering-Oriented: Building large-scale systems
      3. Product-Oriented: End-to-end solutions

      Summary

      TensorFlow is a powerful deep learning framework with a complete ecosystem. It's not only suitable for research and experimentation but also the top choice for industrial applications. Through this tutorial, you will master:

      1. Basic Skills: TensorFlow core concepts and basic operations
      2. Practical Capabilities: Building and training various deep learning models
      3. Engineering Excellence: Model deployment and production best practices
      4. Innovative Thinking: Ability to use TensorFlow to solve real-world problems

      Let's begin this exciting TensorFlow learning journey!