Lesson 4

Welcome to today's lesson on the essential aspect of Tensorflow: **Defining datasets using tensors**. As you know, one major use of Tensorflow lies in the domain of machine learning. One fundamental knowledge you need to have is handling datasets for your machine learning models, more specifically how to define them using tensors. Let's get our hands dirty with some code!

While programming, we use different data types to represent and process the information that our program needs. Similarly, in machine learning, we handle vast amounts of data. This data needs to be represented in a way the machine learning model can effectively use.

It's crucial to understand this manual process of defining datasets with TensorFlow tensors. However, in practical applications, especially when training models with TensorFlow, much of this conversion and data handling can be automated. TensorFlow has the capability to automatically convert numpy arrays and other data formats into tensors when fed into the model. This automation significantly streamlines the process, allowing us to focus more on model architecture and less on data formatting complexities.

Understanding both the manual process gives you a deeper insight into how TensorFlow manages data. It equips you with the knowledge to debug or modify data preprocessing steps if needed and appreciate the convenience TensorFlow offers in handling datasets within models.

Let's take a look at some python code to generate Tensorflow tensors using numpy arrays and how we can define a dataset with these tensors.

Let's assume you have some data stored as numpy arrays, and you want to convert it into tensors. How do you go about doing it?

The `tf.constant()`

function in Tensorflow comes to your rescue. It creates a constant tensor from a tensor-like object. "Tensor-like" refers to any type of data that can be converted into a tensor — in our case, numpy arrays.

Look at the code snippet below:

Python`1import tensorflow as tf 2import numpy as np 3 4# Define a simple array as input data 5X = np.array([ 6 [1.0, 2.0], 7 [2.0, 1.0], 8 [3.0, 4.0], 9 [4.0, 3.0] 10]) 11 12# Define the target outputs for our dataset 13y = np.array([0, 1, 0, 1]) 14 15# Convert X and y into TensorFlow tensors 16X_tensor = tf.constant(X, dtype=tf.float32) 17y_tensor = tf.constant(y, dtype=tf.int32) 18 19# Print tensors 20print("X_tensor:\n", X_tensor) 21print("y_tensor:\n", y_tensor)`

Here, `X`

and `y`

are numpy arrays. We're using `tf.constant()`

to convert these arrays into Tensorflow tensors `X_tensor`

and `y_tensor`

. You'll notice we also specify `dtype=tf.float32`

for `X_tensor`

. This is the data type for the elements of the resulting tensor. Since numpy array `X`

contained floating point numbers, we set the dtype to `tf.float32`

. For `y_tensor`

, we set the dtype to `tf.int32`

because `y`

contained integer values.

The output of the above code will be:

Plain text`1X_tensor: 2 tf.Tensor( 3[[1. 2.] 4 [2. 1.] 5 [3. 4.] 6 [4. 3.]], shape=(4, 2), dtype=float32) 7 8y_tensor: 9 tf.Tensor([0 1 0 1], shape=(4,), dtype=int32)`

This output illustrates the tensor versions of our numpy arrays. The shapes of the tensors `(4, 2)`

for `X_tensor`

and `(4,)`

for `y_tensor`

indicate the dimensions of our datasets, perfectly formatted for use in TensorFlow models.

Congratulations, you've just learned how to define a dataset using tensors in TensorFlow. You've seen how to convert numpy arrays (the common data format while working with machine learning models) into TensorFlow tensors using the `tf.constant()`

function.

Now, let's put these newly gained knowledge to test. In the next set of exercises, you'll be asked to create datasets using TensorFlow. Your understanding and skills for handling tensors will be greatly enhanced through them!

Remember, the only way to learn to code is to code. So, get ready to dive headfirst into practice!