TensorFlow 2 Basics

Steps:

1. Download and install Python from python.org
2. Verify installation by running python --version in your terminal

Steps:

1. Install virtualenv: pip install virtualenv
2. Create a new environment: virtualenv tf_env
3. Activate the environment:
   • Windows: tf_env\Scripts\activate
   • macOS/Linux: source tf_env/bin/activate

Steps:

1. Install TensorFlow: pip install tensorflow
2. For GPU support: pip install tensorflow-gpu
3. Verify installation:

   import tensorflow as tf
   print(tf.__version__)
   print("GPU Available:", tf.config.list_physical_devices('GPU'))

Common Problems and Solutions:

• CUDA/GPU Issues:

  Ensure you have compatible NVIDIA drivers and CUDA toolkit installed

• Version Conflicts:

  Use virtual environments to isolate TensorFlow installations

• Memory Issues:

  Configure GPU memory growth to prevent out-of-memory errors

  gpus = tf.config.list_physical_devices('GPU')
  if gpus:
      for gpu in gpus:
          tf.config.experimental.set_memory_growth(gpu, True)

Using the CIFAR-10 Dataset:

import tensorflow as tf
from tensorflow.keras import datasets, layers, models

# Load and preprocess the CIFAR-10 dataset
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# Normalize pixel values to be between 0 and 1
train_images, test_images = train_images / 255.0, test_images / 255.0

# Define class names
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']

Creating a Convolutional Neural Network:

A Convolutional Neural Network (CNN) is a specialized type of neural network designed for processing grid-like data, such as images. CNNs use convolutional layers that apply filters to detect features like edges, textures, and patterns in the input data. These layers are followed by pooling layers that reduce the spatial dimensions, making the network more efficient and helping it focus on the most important features. The network then uses fully connected layers to make the final classification decision.

# Create the convolutional base
model = models.Sequential([
    # First convolutional layer
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    
    # Second convolutional layer
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    # Third convolutional layer
    layers.Conv2D(64, (3, 3), activation='relu'),
    
    # Dense layers
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10)  # Output layer with 10 classes
])

Training Process:

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

# Train the model
history = model.fit(train_images, train_labels, epochs=10,
                    validation_data=(test_images, test_labels))

Making Predictions:

# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f'\nTest accuracy: {test_acc}')

# Make predictions
predictions = model.predict(test_images)

# Get the predicted class for the first test image
predicted_class = tf.argmax(predictions[0])
print(f'Predicted class: {class_names[predicted_class]}')
print(f'Actual class: {class_names[test_labels[0][0]]}')

Tips for Better Results:

• Data Augmentation:

  Use image augmentation to increase training data variety

  data_augmentation = tf.keras.Sequential([
      layers.RandomFlip("horizontal"),
      layers.RandomRotation(0.1),
      layers.RandomZoom(0.1),
  ])

• Transfer Learning:

  Use pre-trained models for better performance

  base_model = tf.keras.applications.MobileNetV2(
      input_shape=(32, 32, 3),
      include_top=False,
      weights='imagenet'
  )

• Model Checkpointing:

  Save model weights during training

  checkpoint_path = "training_1/cp.ckpt"
  cp_callback = tf.keras.callbacks.ModelCheckpoint(
      filepath=checkpoint_path,
      save_weights_only=True,
      verbose=1
  )

Simple Linear Regression Example:

import tensorflow as tf
import numpy as np

# Generate synthetic data
X = np.linspace(0, 10, 100)
y = 2 * X + 1 + np.random.normal(0, 1, 100)

# Create a simple linear regression model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(1, input_shape=[1])
])

# Compile the model
model.compile(optimizer='sgd', loss='mean_squared_error')

# Train the model
model.fit(X, y, epochs=100, verbose=0)

# Test the model
test_X = np.array([5.0, 7.5, 10.0])
predictions = model.predict(test_X)
print("Predictions:", predictions)

Polynomial Regression Example:

# Generate non-linear data
X = np.linspace(-5, 5, 100)
y = X**3 - 2*X**2 + X + np.random.normal(0, 2, 100)

# Create a non-linear regression model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=[1]),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(1)
])

# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')

# Train the model
model.fit(X, y, epochs=200, verbose=0)

# Test the model
test_X = np.array([-2.0, 0.0, 2.0])
predictions = model.predict(test_X)
print("Predictions:", predictions)

Common Evaluation Metrics:

from sklearn.metrics import mean_squared_error, r2_score

# Make predictions on test data
y_pred = model.predict(X)

# Calculate metrics
mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)

print(f"Mean Squared Error: {mse:.4f}")
print(f"R-squared Score: {r2:.4f}")

Tips for Better Regression Models:

• Data Preprocessing:

  Normalize or standardize your features for better performance

  from sklearn.preprocessing import StandardScaler
  
  scaler = StandardScaler()
  X_scaled = scaler.fit_transform(X.reshape(-1, 1))

• Cross-Validation:

  Use k-fold cross-validation to assess model performance

  from sklearn.model_selection import KFold
  
  kf = KFold(n_splits=5)
  for train_index, test_index in kf.split(X):
      X_train, X_test = X[train_index], X[test_index]
      y_train, y_test = y[train_index], y[test_index]

• Regularization:

  Use L1/L2 regularization to prevent overfitting

  model = tf.keras.Sequential([
      tf.keras.layers.Dense(64, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.01)),
      tf.keras.layers.Dense(1)
  ])