TensorFlow is an open-source machine learning framework developed by Google. It is widely used for building and deploying machine learning models. Google Cloud Platform (GCP) provides a robust environment for running TensorFlow applications, offering various services that can help streamline the development, training, and deployment of machine learning models.

• TensorFlow: An open-source library for numerical computation and machine learning.
• TensorFlow Models: Pre-trained models or custom models that can be trained using TensorFlow.
• TensorFlow Serving: A flexible, high-performance serving system for machine learning models designed for production environments.

• AI Platform: A managed service that allows you to train and deploy machine learning models.
• Compute Engine: Virtual machines that can be used to run TensorFlow training jobs.
• Kubernetes Engine: Managed Kubernetes service for deploying TensorFlow models in containers.
• Cloud Storage: Scalable object storage for storing datasets and model checkpoints.
• BigQuery: A fully-managed data warehouse for analyzing large datasets.

1. Create a GCP Project:

   • Go to the GCP Console.
   • Click on the project drop-down and select "New Project".
   • Enter a project name and click "Create".

2. Enable Billing:

   • Navigate to the Billing section in the GCP Console.
   • Link a billing account to your project.

3. Enable Required APIs:

   • Go to the API Library in the GCP Console.
   • Enable the following APIs:
     • AI Platform Training & Prediction API
     • Compute Engine API
     • Kubernetes Engine API
     • Cloud Storage API

• Local Installation:

  pip install tensorflow
  

• Using AI Platform Notebooks:

  • Navigate to the AI Platform section in the GCP Console.
  • Select "Notebooks" and create a new instance.
  • Choose a TensorFlow image and configure the instance.

• Upload Data to Cloud Storage:

  gsutil cp local-file-path gs://your-bucket-name/
  

• Accessing Data in TensorFlow:

  import tensorflow as tf
  
  def load_data_from_gcs(bucket_name, file_path):
      gcs_path = f'gs://{bucket_name}/{file_path}'
      return tf.io.read_file(gcs_path)
  
  data = load_data_from_gcs('your-bucket-name', 'data.csv')
  

1. Create a Training Job:

   • Prepare a Python script for training your model.
   • Upload the script to Cloud Storage.
   • Submit a training job using the AI Platform:

     gcloud ai-platform jobs submit training job_name 
              --module-name trainer.task 
              --package-path ./trainer 
              --region us-central1 
              --python-version 3.7 
              --runtime-version 2.3 
              --job-dir gs://your-bucket-name/job-dir
     

2. Monitor the Training Job:

   • Navigate to the AI Platform section in the GCP Console.
   • Check the status of your training job.

1. Create a VM Instance:

   • Go to the Compute Engine section in the GCP Console.
   • Click "Create Instance" and configure the VM.
   • SSH into the VM and install TensorFlow.

2. Run the Training Script:

   • Upload your training script to the VM.
   • Execute the script:

     python train.py
     

1. Export the Model:

   model.save('gs://your-bucket-name/model-dir')
   

2. Create a Model on AI Platform:

   gcloud ai-platform models create model_name
   

3. Create a Model Version:

   gcloud ai-platform versions create v1 
          --model model_name 
          --origin gs://your-bucket-name/model-dir 
          --runtime-version 2.3 
          --python-version 3.7
   

4. Make Predictions:

   from google.cloud import aiplatform
   
   client = aiplatform.gapic.PredictionServiceClient()
   endpoint = client.endpoint_path(project='your-project-id', location='us-central1', endpoint='your-endpoint-id')
   
   response = client.predict(endpoint=endpoint, instances=[input_data])
   print(response)
   

1. Create a Kubernetes Cluster:

   • Navigate to the Kubernetes Engine section in the GCP Console.
   • Click "Create Cluster" and configure the cluster.

2. Deploy the Model:

   • Create a Docker image for your model.
   • Push the image to Google Container Registry.
   • Deploy the image to your Kubernetes cluster using a deployment YAML file.

1. Objective: Train a simple TensorFlow model on AI Platform and deploy it for predictions.
2. Steps:
   • Create a GCP project and set up the environment.
   • Prepare a dataset and upload it to Cloud Storage.
   • Write a training script and upload it to Cloud Storage.
   • Submit a training job on AI Platform.
   • Export the trained model to Cloud Storage.
   • Create a model and version on AI Platform.
   • Make predictions using the deployed model.

1. Training Script (train.py):

   import tensorflow as tf
   from tensorflow.keras import layers
   
   def train_model():
       # Load and preprocess data
       (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
       x_train, x_test = x_train / 255.0, x_test / 255.0
   
       # Build the model
       model = tf.keras.Sequential([
           layers.Flatten(input_shape=(28, 28)),
           layers.Dense(128, activation='relu'),
           layers.Dropout(0.2),
           layers.Dense(10)
       ])
   
       # Compile the model
       model.compile(optimizer='adam',
                     loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                     metrics=['accuracy'])
   
       # Train the model
       model.fit(x_train, y_train, epochs=5)
   
       # Evaluate the model
       model.evaluate(x_test, y_test, verbose=2)
   
       # Save the model
       model.save('gs://your-bucket-name/model-dir')
   
   if __name__ == '__main__':
       train_model()
   

2. Submit Training Job:

   gcloud ai-platform jobs submit training mnist_training 
          --module-name trainer.task 
          --package-path ./trainer 
          --region us-central1 
          --python-version 3.7 
          --runtime-version 2.3 
          --job-dir gs://your-bucket-name/job-dir
   

3. Create Model and Version:

   gcloud ai-platform models create mnist_model
   gcloud ai-platform versions create v1 
          --model mnist_model 
          --origin gs://your-bucket-name/model-dir 
          --runtime-version 2.3 
          --python-version 3.7
   

4. Make Predictions:

   from google.cloud import aiplatform
   
   client = aiplatform.gapic.PredictionServiceClient()
   endpoint = client.endpoint_path(project='your-project-id', location='us-central1', endpoint='your-endpoint-id')
   
   response = client.predict(endpoint=endpoint, instances=[input_data])
   print(response)
   

In this section, you learned how to set up TensorFlow on GCP, train a model using AI Platform, and deploy the model for predictions. You also completed a practical exercise to reinforce these concepts. In the next module, we will explore other machine learning and AI services provided by GCP.