Creating Tensors in TensorFlow with tf.constant<\/strong><\/h2>\n\n\n\nYou can create a constant tensor of n-dimension using the tf.constant() method. As mentioned earlier, the method takes in 3 key parameters, the value of the tensor, the data type, and the name of the tensor.<\/p>\n\n\n\n
tf.constant(\n value,\n dtype=None,\n shape=None,\n name='Const',\n verify_shape=False,\n)\nDocstring:\nCreates a constant tensor.\n\nThe resulting tensor is<\/strong> populated with<\/strong> values of type `dtype`, as<\/strong>\nspecified by arguments `value` and<\/strong> (optionally) `shape` <\/pre>\n\n\n\nIt is important to state the value of the tensor. The other parameters are given default values by TensorFlow. Let\u2019s say you want to create a one-dimensional tensor populated with numbers 1 to 10. You can write the following code. <\/p>\n\n\n\n
#print a rank 1, one-dimensional tensor populated from number 1 to 10\ntf.constant([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype=tf.float32)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'Const_2:0' shape=(10,) dtype=float32><\/code><\/pre>\n\n\n\nNote: The output printed is not the tensor but the tensor object, with its properties. This is because the TensorFlow object has not been run yet. We will get to how to run a tensor using the tf.Session() class later in this tutorial. <\/p>\n\n\n\n
Let\u2019s take another example. Say this time, you want to create a 3 by 3 matrix populated with a constant value, 2. We can as well use the tf.constant() method. The value argument will be given as 2 while the shape argument will be given as (3, 3). The code to do this is written below. <\/p>\n\n\n\n
#print a rank 1, 3 by 3 tensor populated with ones\ntf.constant(value=1, shape=(3, 3))<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'Const_3:0' shape=(3, 3) dtype=int32><\/code><\/pre>\n\n\n\nAnother way to go about this is to explicitly pass the matrix as the value argument. See this code below. <\/p>\n\n\n\n
tf.constant([[1, 1, 1,],\n [1, 1, 1],\n [1, 1, 1]])<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'Const_4:0' shape=(3, 3) dtype=int32><\/code><\/pre>\n\n\n\nCreating Tensors with String and Boolean Data Types<\/p>\n\n\n\n
We have been creating tensors of int and float data types. But you can also create tensors of string or Boolean dtype. <\/p>\n\n\n\n
#create TensorFlow with Boolean dtype\ntf.constant([False, True, True, False])<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'Const_7:0' shape=(4,) dtype=bool><\/code><\/pre>\n\n\n\nAs seen in the output, the tensor has a Boolean dtype. <\/p>\n\n\n\n
If we want to create a tensor with the string data type, it is as easy as writing<\/p>\n\n\n\n
#create TensorFlow with string dtype\ntf.constant(['Tensors'])<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'Const_8:0' shape=(1,) dtype=string><\/code><\/pre>\n\n\n\nCreating Special Tensors<\/strong><\/h2>\n\n\n\nExamples of special tensors are identity tensors or tensors filled with ones or zeros. Since this kind of tensor is identified by a particular format, TensorFlow has methods that can be used to create them easily. We are only required to specify the shape of the tensor we want to create. <\/p>\n\n\n\n
To create a tensor of ones, we use the tf.ones() method. It takes a compulsory parameter of the shape of the tensor to be created. To create a 1 by 10 tensor, populated with one, see the code below<\/p>\n\n\n\n
#create tensor populated with ones\ntf.ones(10)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'ones:0' shape=(10,) dtype=float32><\/code><\/pre>\n\n\n\nIf we want to create tensors with more rows and columns greater than 1, we can pass the number of rows and columns as a list. The code below creates a 3 by 3 tensor populated with ones. <\/p>\n\n\n\n
#create a 3 by 3 tensor populated with ones\ntf.ones([3, 3])<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'ones_1:0' shape=(3, 3) dtype=float32><\/code><\/pre>\n\n\n\nTo create a tensor with all elements populated with zeros, we use the tf.zeros() method. Like the tf.ones() method, this method requires the shape of the tensor passed as an argument. <\/p>\n\n\n\n
Let\u2019s see an example. To create a tensor with all elements set to zero, the code below does just that. <\/p>\n\n\n\n
#create a tensor populated with zeros\ntf.zeros(10)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'zeros_1:0' shape=(10,) dtype=float32><\/code><\/pre>\n\n\n\nFinally, let\u2019s discuss identity tensor. For those who do not know, an identity tensor is a square tensor whose diagonal elements are ones while the other elements are zeros. An important property of an identity tensor is that when an identity tensor is multiplied with a tensor, it returns the tensor itself.<\/p>\n\n\n\n
To create an identity tensor in TensorFlow, we use the tf.eye() method. Let\u2019s create a 4 by 4 identity tensor. <\/p>\n\n\n\n
#create a 4 by 4 identity tensor\ntf.eye(4)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<tf.Tensor 'eye\/TensorDiag:0' shape=(4, 4) dtype=float32><\/code><\/pre>\n\n\n\nThe Shape and Datatype of a Tensor<\/strong><\/h2>\n\n\n\nWe mentioned that a tensor is defined by three properties: its value, shape, and datatype. When you create a tensor of some given value, the shape and datatype of the tensor are guessed by the TensorFlow algorithm. <\/p>\n\n\n\n
However, if you wish to print the shape of a tensor, you can do so with the shape attribute of the tensor. Let\u2019s take an example<\/p>\n\n\n\n
#create a 2 by 3 tensor\ntensor_a = tf.constant([[1, 2, 3],\n [4, 5, 6]])\n#print the shape of the tensor\nprint(tensor_a.shape)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
TensorShape([Dimension(2), Dimension(3)])<\/code><\/pre>\n\n\n\nAs seen in the output, the tensor has 2 rows and 3 columns.<\/p>\n\n\n\n
If you wish to print the datatype for a tensor, on the other hand. You can do this with the dtype attribute of the tensor. Let\u2019s see an example. <\/p>\n\n\n\n
#create a 2 by 3 tensor\ntensor_a = tf.constant([[1, 2, 3],\n [4, 5, 6]])\n#print the datatype of the tensor\nprint(tensor_a.dtype)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
<dtype: 'int32'><\/code><\/pre>\n\n\n\nAs seen in the result, the datatype of the tensor is int32. But what if we wish to change the shape of data type of an already created tensor. How do we go about this?<\/p>\n\n\n\n
Changing the Shape of a Tensor. <\/strong><\/h2>\n\n\n\nThere may be situations where you need to change the shape of a tensor. In Convolutional Neural Networks (CNN), you will be required to shape the shape of the input data (image array) to a different shape. To change the shape of a tensor, you use the tf.reshape() method. This method takes 2 important arguments: the tensor you want to reshape and the new shape you want for the tensor. See the example below. <\/p>\n\n\n\n
#create a 2 by 3 tensor\ntensor_a = tf.constant([[1, 2, 3],\n [4, 5, 6]])\n#reshape the above tensor into a 3 by 2 tensor\ntensor_a_reshaped = tf.reshape(tensor_a, [3, 2])\n#print the shape of the reshaped tensor\nprint(tensor_a_reshaped.shape)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
(3, 2)<\/p>\n\n\n\n
Changing the Datatype of a Tensor<\/strong><\/h2>\n\n\n\nAs seen from previous examples, upon creating a tensor, TensorFlow assigns a data type automatically. You can decide to change the datatype to another one using the tf.cast() method. The tf.cast() method takes two important arguments: the tensor to cast and the new dtype. Let\u2019s see an example. <\/p>\n\n\n\n
#create a 2 by 3 tensor\ntensor_a = tf.constant([[1, 2, 3],\n [4, 5, 6]])\n#print datatype for the tensor\nprint('The dtype of the initial tensor is ', tensor_a.dtype)\n\n#change the datatype to float32\ntensor_a_changed_dtype = tf.cast(tensor_a, tf.float32)\n#print the datatype of the cast tensor\nprint('The dtype of the cast tensor is ', tensor_a_changed_dtype.dtype)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
The dtype of the initial tensor is <dtype: 'int32'>\nThe dtype of the cast tensor is <dtype: 'float32'><\/code><\/pre>\n\n\n\nRunning Operations in TensorFlow with tf.Session()<\/strong><\/h2>\n\n\n\nBefore now, we have not printed the tensors created on the terminal. When we attempt to print the tensors, it returns its properties, i.e. its name, shape, and tensor. To print a tensor or the result of any tensor operation. You need to call the tf.Session() class. The class must first be instantiated. The tensor is printed on the terminal using the run() method of the instantiated class. In the last example, we defined a tensor_a. To print the tensor_a, we write the code below.<\/p>\n\n\n\n
#create a tensor_a\ntensor_a = tf.constant([[1, 2, 3],\n [4, 5, 6]])\n\n#call the Session class\nwith tf.Session() as sess:\n result =sess.run(tensor_a)\n #print the result\n print(result)\n<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
[[1 2 3] [4 5 6]]<\/code><\/pre>\n\n\n\nNow let\u2019s get back to other methods of creating Tensors<\/p>\n\n\n\n
Creating Tensors Variables<\/strong><\/h2>\n\n\n\nWe have looked at creating tensors with tf.constant(). While it is great to use that method if the tensor value would not change, it is uncommon. To create a more dynamic tensor whose values can be used as input to another operation, we create a variable tensor. <\/p>\n\n\n\n
You can create a using the tf.Variable() class. Using this method, you must specify some initial value of the tensor of any shape and datatype. <\/p>\n\n\n\n
To run operations with the values of the created variable, you must explicitly assign the value of the tensor to the variable itself. This is done by initializing the variable. Creating a variable only store the tensor value to that variable. You can see the initialization operation as calling a variable from a saved file to be ready for use. <\/p>\n\n\n\n
To initialize the variable for an operation, the most common method to use is the global_variables_initializer() method. Note that the initializer method must be run in a session. Let\u2019s see an example where we implement this. <\/p>\n\n\n\n
#create a tensor variable\ntensor_a = tf.Variable([1, 2, -4])\n\n#initialize the variable\ninit_op = tf.global_variables_initializer()\n\n#run a graph in session\nwith tf.Session() as sess:\n #run the variable initializer in a session.\n sess.run(init_op)\n #run the tensor operation\n result = sess.run(tensor_a)\n #print the result\n print(result)<\/code><\/pre>\n\n\n\nYou could also choose to create a variable by using the tf.get_variable() method. <\/p>\n\n\n\n
tf.get_variable(name = \"\", values, dtype, initializer)\nargument\n- `name = \"\"`: Name of the variable\n- `values`: Dimension of the tensor\n- `dtype`: Type of data. Optional\n- `initializer`: How to initialize the tensor. Optional\nIf the initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.\t\t<\/code><\/pre>\n\n\n\nThis method is preferable since it doesn\u2019t necessarily take an initial value and the initializer can be specified when calling the method. The tf.Variable() class always creates a new variable while the get_variable() method checks and gets existing variables with the same parameters. If there are no existing variables with the same parameters, it creates a new variable. <\/p>\n\n\n\n
Let\u2019s say we want to create a 2 by 1 variable tensor using the tf.get_variable() method. When we call the method without defining the initializer, TensorFlow creates a tensor of random values with the defined shape. <\/p>\n\n\n\n
#creates a 2 by 1 variable tensor\nvar1 = tf.get_variable('var1', [2, 1])\n#print the tensor\nprint(var1)<\/code><\/pre>\n\n\n\nNote: The name argument is the name stored by TensorFlow while the variable name is the name stored by the Python compiler. To avoid confusion, you may use the same names in both places.<\/p>\n\n\n\n
Output:<\/p>\n\n\n\n
<tf.Variable 'var1:0' shape=(2, 1) dtype=float32_ref><\/code><\/pre>\n\n\n\nIf we wish to specify the initial values of the tensor, we can do this with the initializer parameter. For instance, setting the initializer parameter to tf.zers_initializer fills the variable with zeros. You can also pass a constant tensor as the values of the initializer parameter. This will populate the variable tensor with the values of the constant tensor. Note that when the initializer parameter is defined, we do not need to pass the shape of the variable tensor as it takes the shape of the initializer tensor.<\/p>\n\n\n\n
Let\u2019s see an example<\/p>\n\n\n\n
#create 3 by 3 constant tensor\ntensor_a = tf.constant([1, 2, 3, 4, 5, 6, 7, 8, 9])\ntensor_a = tf.reshape(tensor_a, [3, 3])\n\n#create a variable tensor whose first value is the constant tensor\nvar_tensor = tf.get_variable('var_tensor', initializer=tensor_a)\n#check the shape of the variable tensor\nvar_tensor.shape<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
TensorShape([Dimension(3), Dimension(3)])<\/code><\/pre>\n\n\n\nAs seen, even without defining the shape of the variable tensor explicitly, it takes the shape of the constant tensor. <\/p>\n\n\n\n
Creating Tensors with Placeholders<\/strong><\/h2>\n\n\n\nThe third method of creating a tensor is by using placeholders. This is done with the tf.placeholder() method. Placeholders allow you to feed the data outside of your TensorFlow graph. In other words, the data in a placeholder is not given when creating the TensorFlow graph, but rather, when running the graph in a session. <\/p>\n\n\n\n
Signature: tf.placeholder(dtype, shape=None, name=None)\narguments:\n- `dtype`: Type of data\n- `shape`: dimension of the placeholder. Optional. By default, shape of the data\n- `name`: Name of the placeholder. Optional\t\t\t\nReturns: A `Tensor` that may be used as a handle for feeding a value, but not evaluated directly.\n<\/code><\/pre>\n\n\n\nThe placeholder() method takes the data type of the data as an important parameter. The name and shape are optional parameters. When the name is not defined, TensorFlow assigns the tensor with a default name. The shape of the tensor can be determined when it is later defined in the session. <\/p>\n\n\n\n
When using placeholders, we have mentioned that the data is fed when running the session. Upon calling the session, we pass the data using the feed_dict argument. This is a dictionary whose key is the variable name of the placeholder and values, the data to be received as numbers of arrays. <\/p>\n\n\n\n
Let\u2019s take an example<\/p>\n\n\n\n
#create a placeholder tensor_a\ntensor_a = tf.placeholder(tf.float32)\n#create a tensor b\ntensor_b = 2 + tensor_a\n\n#run a session\nwith tf.Session() as sess:\n #define tensor_a to be a 0-D tensor of 5\n #run the tensoor_b\n result = sess.run(tensor_b, feed_dict={tensor_a: 5})\n #print the result\n print(result)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
7.0<\/code><\/pre>\n\n\n\nMathematical Operations in TensorFlow<\/strong><\/h2>\n\n\n\nTensorFlow can perform all the basic operations in mathematics such as addition, subtraction, multiplication, division, finding squares and square roots, exponents and so on. This is important in data manipulation. Let\u2019s list out some of the common basic operators and the required argument<\/p>\n\n\n\n
\n- tf.add(a, b): Returns a + b element-wise.<\/li>\n\n\n\n
- tf.subtract(a, b): Returns a – b element-wise.<\/li>\n\n\n\n
- tf.multiply(a, b): Returns a * b element-wise.<\/li>\n\n\n\n
- tf.div(a, b): Divides a \/ b elementwise<\/li>\n\n\n\n
- tf.pow(a, b): Computes the power of one value to another.<\/li>\n\n\n\n
- tf.sqrt(a): Computes square root of \u2018a\u2019 element-wise.<\/li>\n\n\n\n
- tf.exp(a): Computes exponential of \u2018a\u2019 element-wise.\u00a0 \\\\(b = ea\\\\).<\/li>\n<\/ol>\n\n\n\n
Let\u2019s take some examples<\/p>\n\n\n\n
#create a tensor a\ntensor_a = tf.constant([1, 2, 3])\n#create a tensor b\ntensor_b = tf.constant([-1, 4, 9])\n\n#perform element-wise addition on tensor a and b\ntensor_c = tf.add(tensor_a, tensor_b)\n#create a session\nwith tf.Session() as sess:\n #run the session \n result = sess.run(tensor_c)\n #print the result\n print(result)<\/code><\/pre>\n\n\n\nOutput:<\/p>\n\n\n\n
[ 0 6 12]<\/p>\n\n\n\n
It\u2019s almost the same procedure for other operations. If we want to find the exponential of a tensor, for instance, the code below is an example of how to accomplish that. <\/p>\n\n\n\n
#create a tensor a\ntensor_a = tf.constant([1, 2, 3], dtype=tf.float64)\n\n#perform element-wise addition on tensor a and b\ntensor_b = tf.exp(tensor_a)\n#create a session\nwith tf.Session() as sess:\n #run the session \n result = sess.run(tensor_b)\n #print the result\n print(result)<\/code><\/pre>\n\n\n\nNote: Since exponents are in decimals, the datatype cannot be set to the default int32 or any int datatype.<\/p>\n\n\n\n
Output:<\/p>\n\n\n\n
[ 2.71828183 7.3890561 20.08553692]<\/code><\/pre>\n\n\n\nConclusion<\/strong><\/h2>\n\n\n\nTo sum it all up, we started by defining what a tensor is and how they are represented in TensorFlow. <\/p>\n\n\n\n
We said that a TensorFlow program can be split into two parts, the computational graph, tensor, and session. We went on to explain the different types of ways to define a tensor with TensorFlow. <\/p>\n\n\n\n
We said that tf.constant() creates a tensor whose values remain the same. tf.variable() creates a tensor such that its values can be updated after an operation and tf.placeholders() allows you to withdraw the values and even shape of a tensor until you’re ready to run a session. <\/p>\n\n\n\n
We discussed the shape and datatype of tensors and how to change them using the tf.reshape() method and tf.cast() method respectively. <\/p>\n\n\n\n
We finally tied it all together by creating a computational graph (initial tensors) and running a session (based on some operation) to produce output results.<\/p>\n","protected":false},"excerpt":{"rendered":"
When it comes to building AI systems, TensorFlow has become ubiquitous. It has grown to become the library of choice for most machine learning and deep learning projects. Researchers, programmers, and data scientists even predict that the library will gain even more traction in the coming years. But truth be told, TensorFlow can get complex […]<\/p>\n","protected":false},"author":1,"featured_media":5580,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[498],"tags":[],"class_list":["post-5512","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-artificial-intelligence-tutorials"],"_links":{"self":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/5512","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/comments?post=5512"}],"version-history":[{"count":0,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/5512\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media\/5580"}],"wp:attachment":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media?parent=5512"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/categories?post=5512"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/tags?post=5512"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"\"](\"https:\/\/lh4.googleusercontent.com\/reUY-mmjMQ2PHXjOHP50cATzL2LH1RWYAiuYQh-3_oGyNvIVDTg-0tTgVtxwqA2eDBxOTdXqtBJZKiAM3i2dXEK4uxZ1jTAUMeL9FkYVObIpdZwC12YWigPex5zzsfkHYlr18TesexivCZjWzQ\" "\\"\\"")
![\"\"](\"https:\/\/lh5.googleusercontent.com\/iFyJf6HOxclkcZwYKrfNY9FOMiaKbqkgHKYeCbx7ZBmQnHjHGWG9rXWg_gQs_hZz-yn4LRDuWrnai8MmkKUon8WmL6hKIjFztljqWf165nwjBtFgqmqbObWZ8a53dbnlfRzRaEGM5CSrhet1Og\" "\\"\\"")
<\/figure>\n\n\n\n