Getting Started with TensorFlow

This code provides a basic example of training a binary classification model with TensorFlow in JupyterLab. You can adapt this structure for more complex tasks by modifying the model architecture, data preparation steps, and training parameters.

Library Installation

The code starts by installing TensorFlow, a popular library for machine learning tasks.

!pip install tensorflow

Version Check

It then verifies the installed TensorFlow version using

import tensorflow as tf  
print(tf.__version__)

GPU Availability Check (Optional)

The !nvidia-smi command (assuming you have an Nvidia GPU) checks if a GPU is available and its details.

!nvidia-smi

Data Preparation

It generates 1000 samples with 10 features each using np.random.rand for the training data. Random binary labels (0 or 1) are assigned to each sample using np.random.randint. A similar approach is used to generate test data.

Model Definition

A sequential model is defined using tf.keras.models.Sequential. The model consists of three layers:

• The first layer has 64 units with a ReLU activation function and takes the input data with a shape of (10,) (10 features).
• The second layer also has 64 units with a ReLU activation.
• The output layer has 1 unit with a sigmoid activation suitable for binary classification tasks.

Model Compilation

The model is compiled using model.compile. Here, the optimizer is set to 'adam' (a popular optimization algorithm), the loss function is set to 'binary_crossentropy' (suitable for binary classification), and the 'accuracy' metric is chosen to monitor model performance during training.

Model Training

The model is trained on the prepared data using model.fit. It trains for 10 epochs (iterations over the data) with a batch size of 32 (the number of samples processed together at each step).

Model Evaluation

 After training, the model's performance on unseen data is evaluated using model.evaluate. The test accuracy is then printed using the test_acc value.

import numpy as np  
# Generate random training data  
train_data = np.random.rand(1000, 10) # 1000 samples, 10 features  
train_labels = np.random.randint(0, 2, size=(1000,)) # Binary labels  
# Define the model  
model = tf.keras.models.Sequential([  
tf.keras.layers.Dense(64, activation='relu', input_shape=(10,)),  
tf.keras.layers.Dense(64, activation='relu'),  
tf.keras.layers.Dense(1, activation='sigmoid')  
])  
# Compile the model  
model.compile(optimizer='adam',  
loss='binary_crossentropy',  
metrics=['accuracy'])  
# Train the model  
model.fit(train_data, train_labels, epochs=10, batch_size=32)  
# Generate random test data  
test_data = np.random.rand(100, 10) # 100 samples, 10 features  
test_labels = np.random.randint(0, 2, size=(100,)) # Binary labels  
# Evaluate the model  
test_loss, test_acc = model.evaluate(test_data, test_labels)  
print('Test accuracy:', test_acc)

The best way to understand and learn how to perform this function is through hands-on experience. Follow the steps below to create the sample notebook in your Syntasa environment:

1. Download the sample notebook .ipynb file from this article.
2. Create a new notebook in your Syntasa environment using the import notebook option.