feat - add 1_Introduction/basic-operation example

Author: ksachdeva

.gitignore

@@ -36,4 +36,5 @@ _release
 build
 _r*
 _d*
-tensorflow-sdk
+tensorflow-sdk
+_xdebug

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "fft": "cpp"
+    }
+}

examples/1_Introduction/CMakeLists.txt

@@ -14,7 +14,7 @@ endmacro()
 
 # here simply call the macro for every sample file (the one that contains the main)
 add_introduction(hello-world ${INTRODUCTION_SRC_PATH} hello-world)
-
+add_introduction(basic-operations ${INTRODUCTION_SRC_PATH} basic-operations)
 
 
 

examples/1_Introduction/src/basic-operations.cc

@@ -0,0 +1,142 @@
+#include <tensorflow/cc/client/client_session.h>
+#include <tensorflow/cc/ops/standard_ops.h>
+#include <tensorflow/core/framework/tensor.h>
+
+// Basic math operations using tensorflow
+
+// The sample demonstrates how to
+// - create various operations
+// - use placeholder and placeholderWithDefault
+// - use different overloads of Run method
+
+int main(int argc, char **argv) {
+
+  using namespace tensorflow;
+  using namespace tensorflow::ops;
+
+  // create a root scope
+  auto scope = Scope::NewRootScope();
+
+  // we are creating various local scopes
+  // so that a new session object is created
+  // for all the examples
+
+  {
+    // An example of doing addition
+    // on constants
+
+    ClientSession session(scope);
+
+    auto a = Const(scope, 2);
+    auto b = Const(scope, 3);
+
+    auto c = Add(scope, a, b);
+
+    std::vector<Tensor> outputs;
+    TF_CHECK_OK(session.Run({c}, &outputs));
+
+    // we know that it will be scalar
+    // we can also get the underlying data by calling flat
+    std::cout << "Underlying Scalar value -> " << outputs[0].flat<int>()
+              << std::endl;
+  }
+
+  {
+    // An example of how to supply a variable (i.e. not a constant)
+    // whose value is supplied at the time when we run the session
+
+    ClientSession session(scope);
+
+    // we will use Placeholder as the type for our variables
+    auto a = Placeholder(scope, DT_INT32);
+    auto b = Placeholder(scope, DT_INT32);
+
+    // define the add operation that takes
+    // the placeholders a and b as inputs
+    auto c = Add(scope, a, b);
+
+    std::vector<Tensor> outputs;
+
+    // we now specify the values for our placeholders
+    // note that the way Run method is called. It is quite
+    // different from previous example.
+    //
+    // Here we are using this overload of Run method
+    // Run(const FeedType& inputs, const std::vector<Output>& fetch_outputs,
+    //        std::vector<Tensor>* outputs) const;
+    //
+    //
+    // which takes FeedType (alias of std::unordered_map<Output, Input::Initializer, OutputHash>
+    // as the first argument.
+    // Note - In std::unordered_map OutputHash is optional
+    // So we just need to supply a map whose key of type "Output" and the
+    // value that respect Initializer
+    //
+    // {a,2} & {b,3} would satisfiy this requirement since type 'a' & 'b'
+    // is Output
+    
+    auto status = session.Run({
+      {
+        {a, 2},
+        {b, 3}
+      } }, {c}, &outputs);
+    
+    TF_CHECK_OK(status);
+    
+    // we know that it will be scalar
+    // we can also get the underlying data by calling flat
+    std::cout << "Underlying Scalar value -> " << outputs[0].flat<int>()
+              << std::endl;
+  }
+  
+  {
+    // This is yet another example that makes use of Placeholder however
+    // this time we want one of the placeholder to have a default value
+    //
+    // In other words, it does not need to be specified during the session
+    // execution. if you give a new value it would accept it else would use
+    // the default value
+    
+    ClientSession session(scope);
+    
+    // create an input
+    auto defaultAInput = Input(8);
+    
+    // we will use Placeholder as the type for our variables
+    auto a = PlaceholderWithDefault(scope, defaultAInput, PartialTensorShape());
+    auto b = Placeholder(scope, DT_INT32);
+    
+    // define the add operation that takes
+    // the placeholders a and b as inputs
+    auto c = Add(scope, a, b);
+    
+    std::vector<Tensor> outputs;
+    
+    // In this Run we are not specifying 'a'
+    // so its default value i.e. 8 will be used
+    auto status = session.Run({
+      {
+        {b, 3}
+      } }, {c}, &outputs);
+    
+    TF_CHECK_OK(status);
+    
+    std::cout << "Underlying Scalar value (using default placeholder value [8]) -> " << outputs[0].flat<int>()
+    << std::endl;
+    
+    // here we do specify a value for placeholder 'a' i.e. 9
+    status = session.Run({
+      {
+        {a, 9},
+        {b, 3}
+      } }, {c}, &outputs);
+    
+    TF_CHECK_OK(status);
+    
+    std::cout << "Underlying Scalar value (after supplying new value [9]) -> " << outputs[0].flat<int>()
+    << std::endl;
+    
+  }
+
+  return 0;
+}