diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt
index 77da9e4d510..0f49a18a114 100644
--- a/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyFtrl.pbtxt
@@ -33,13 +33,13 @@ END
   in_arg {
     name: "l1"
     description: <<END
-L1 regulariation. Must be a scalar.
+L1 regularization. Must be a scalar.
 END
   }
   in_arg {
     name: "l2"
     description: <<END
-L2 regulariation. Must be a scalar.
+L2 regularization. Must be a scalar.
 END
   }
   in_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt
index 974f3adc196..3218ab7776c 100644
--- a/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_ApplyFtrlV2.pbtxt
@@ -33,13 +33,13 @@ END
   in_arg {
     name: "l1"
     description: <<END
-L1 regulariation. Must be a scalar.
+L1 regularization. Must be a scalar.
 END
   }
   in_arg {
     name: "l2"
     description: <<END
-L2 shrinkage regulariation. Must be a scalar.
+L2 shrinkage regularization. Must be a scalar.
 END
   }
   in_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestFeatureSplit.pbtxt b/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestFeatureSplit.pbtxt
index d48fe6b1936..661394a1cc5 100644
--- a/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestFeatureSplit.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestFeatureSplit.pbtxt
@@ -35,7 +35,7 @@ END
   in_arg {
     name: "min_node_weight"
     description: <<END
-mininum avg of hessians in a node before required for the node to be considered for splitting.
+minimum avg of hessians in a node before required for the node to be considered for splitting.
 END
   }
   out_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestGainsPerFeature.pbtxt b/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestGainsPerFeature.pbtxt
index 3f181e91ce4..ad273f7fca1 100644
--- a/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestGainsPerFeature.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_BoostedTreesCalculateBestGainsPerFeature.pbtxt
@@ -34,7 +34,7 @@ END
   in_arg {
     name: "min_node_weight"
     description: <<END
-mininum avg of hessians in a node before required for the node to be considered for splitting.
+minimum avg of hessians in a node before required for the node to be considered for splitting.
 END
   }
   out_arg {
@@ -90,4 +90,4 @@ In this manner, the output is the best split per features and per node, so that
 The length of output lists are all of the same length, `num_features`.
 The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature.
 END
-}
\ No newline at end of file
+}
diff --git a/tensorflow/core/api_def/base_api/api_def_BoostedTreesSparseCalculateBestFeatureSplit.pbtxt b/tensorflow/core/api_def/base_api/api_def_BoostedTreesSparseCalculateBestFeatureSplit.pbtxt
index 50e4a53020f..8ca52f168dd 100644
--- a/tensorflow/core/api_def/base_api/api_def_BoostedTreesSparseCalculateBestFeatureSplit.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_BoostedTreesSparseCalculateBestFeatureSplit.pbtxt
@@ -47,7 +47,7 @@ END
   in_arg {
     name: "min_node_weight"
     description: <<END
-mininum avg of hessians in a node before required for the node to be considered for splitting.
+minimum avg of hessians in a node before required for the node to be considered for splitting.
 END
   }
   out_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_CudnnRNNCanonicalToParamsV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_CudnnRNNCanonicalToParamsV2.pbtxt
index cac3674c1ae..0fc5047e0bf 100644
--- a/tensorflow/core/api_def/base_api/api_def_CudnnRNNCanonicalToParamsV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_CudnnRNNCanonicalToParamsV2.pbtxt
@@ -18,7 +18,7 @@ weights: the canonical form of weights that can be used for saving
 biases: the canonical form of biases that can be used for saving
     and restoration. They are more likely to be compatible across different
     generations.
-num_params_weigths: number of weight parameter matrix for all layers.
+num_params_weights: number of weight parameter matrix for all layers.
 num_params_biases: number of bias parameter vector for all layers.
 rnn_mode: Indicates the type of the RNN model.
 input_mode: Indicate whether there is a linear projection between the input and
diff --git a/tensorflow/core/api_def/base_api/api_def_CudnnRNNParamsToCanonicalV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_CudnnRNNParamsToCanonicalV2.pbtxt
index aa51414ba23..80e7daf51d4 100644
--- a/tensorflow/core/api_def/base_api/api_def_CudnnRNNParamsToCanonicalV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_CudnnRNNParamsToCanonicalV2.pbtxt
@@ -12,7 +12,7 @@ biases.
 num_layers: Specifies the number of layers in the RNN model.
 num_units: Specifies the size of the hidden state.
 input_size: Specifies the size of the input state.
-num_params_weigths: number of weight parameter matrix for all layers.
+num_params_weights: number of weight parameter matrix for all layers.
 num_params_biases: number of bias parameter vector for all layers.
 weights: the canonical form of weights that can be used for saving
     and restoration. They are more likely to be compatible across different
diff --git a/tensorflow/core/api_def/base_api/api_def_DebugNumericSummaryV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_DebugNumericSummaryV2.pbtxt
index 28f0271c7e8..fdeb2761cc0 100644
--- a/tensorflow/core/api_def/base_api/api_def_DebugNumericSummaryV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_DebugNumericSummaryV2.pbtxt
@@ -20,7 +20,7 @@ Supported values:
   element is a bit which is set to 1 if the input tensor has an
   infinity or nan value, or zero otherwise.
 
-  3 (CONCISE_HEALTH): Ouput a float32/64 tensor of shape [5]. The 1st
+  3 (CONCISE_HEALTH): Output a float32/64 tensor of shape [5]. The 1st
   element is the tensor_id, if provided, and -1 otherwise. The
   remaining four slots are the total number of elements, -infs,
   +infs, and nans in the input tensor respectively.
diff --git a/tensorflow/core/api_def/base_api/api_def_IsBoostedTreesEnsembleInitialized.pbtxt b/tensorflow/core/api_def/base_api/api_def_IsBoostedTreesEnsembleInitialized.pbtxt
index d54b7ef32a3..49cce634b42 100644
--- a/tensorflow/core/api_def/base_api/api_def_IsBoostedTreesEnsembleInitialized.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_IsBoostedTreesEnsembleInitialized.pbtxt
@@ -4,7 +4,7 @@ op {
   in_arg {
     name: "tree_ensemble_handle"
     description: <<END
-Handle to the tree ensemble resouce.
+Handle to the tree ensemble resource.
 END
   }
   out_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt
index a6a29b164e2..14a765b8840 100644
--- a/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrl.pbtxt
@@ -33,13 +33,13 @@ END
   in_arg {
     name: "l1"
     description: <<END
-L1 regulariation. Must be a scalar.
+L1 regularization. Must be a scalar.
 END
   }
   in_arg {
     name: "l2"
     description: <<END
-L2 regulariation. Must be a scalar.
+L2 regularization. Must be a scalar.
 END
   }
   in_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt
index a71c835b789..2a22d45a6b8 100644
--- a/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceApplyFtrlV2.pbtxt
@@ -33,13 +33,13 @@ END
   in_arg {
     name: "l1"
     description: <<END
-L1 regulariation. Must be a scalar.
+L1 regularization. Must be a scalar.
 END
   }
   in_arg {
     name: "l2"
     description: <<END
-L2 shrinkage regulariation. Must be a scalar.
+L2 shrinkage regularization. Must be a scalar.
 END
   }
   in_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt
index 45ea013ce89..1e04124c83a 100644
--- a/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_ResourceSparseApplyFtrlV2.pbtxt
@@ -45,7 +45,7 @@ END
   in_arg {
     name: "l2"
     description: <<END
-L2 shrinkage regulariation. Must be a scalar.
+L2 shrinkage regularization. Must be a scalar.
 END
   }
   in_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt b/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt
index 9247fb61b88..df924f29636 100644
--- a/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_SparseApplyFtrlV2.pbtxt
@@ -45,7 +45,7 @@ END
   in_arg {
     name: "l2"
     description: <<END
-L2 shrinkage regulariation. Must be a scalar.
+L2 shrinkage regularization. Must be a scalar.
 END
   }
   in_arg {
diff --git a/tensorflow/core/api_def/base_api/api_def_TridiagonalMatMul.pbtxt b/tensorflow/core/api_def/base_api/api_def_TridiagonalMatMul.pbtxt
index d256e1b5673..91876dc7cee 100644
--- a/tensorflow/core/api_def/base_api/api_def_TridiagonalMatMul.pbtxt
+++ b/tensorflow/core/api_def/base_api/api_def_TridiagonalMatMul.pbtxt
@@ -5,7 +5,7 @@ op {
     name: "superdiag"
     description: <<END
 Tensor of shape `[..., 1, M]`, representing superdiagonals of
-tri-diagonal matrices to the left of multiplication. Last element is ingored.
+tri-diagonal matrices to the left of multiplication. Last element is ignored.
 END
   }
   in_arg {
@@ -19,7 +19,7 @@ END
     name: "subdiag"
     description: <<END
 Tensor of shape `[..., 1, M]`, representing subdiagonals of tri-diagonal
-matrices to the left of multiplication. First element is ingored.
+matrices to the left of multiplication. First element is ignored.
 END
   }
   in_arg {
diff --git a/tensorflow/core/common_runtime/colocation_graph.cc b/tensorflow/core/common_runtime/colocation_graph.cc
index a2527b2bc2f..ab58902f415 100644
--- a/tensorflow/core/common_runtime/colocation_graph.cc
+++ b/tensorflow/core/common_runtime/colocation_graph.cc
@@ -1004,7 +1004,7 @@ void ColocationGraph::GetSoftDeviceCandidates(
 
   // Failed to find supported devices that don't violate resource devices.
   // Try finding some devices that violated resource devices.
-  // If we succceed, we will log a warning below.
+  // If we succeed, we will log a warning below.
   soft_device_name = root_member.GetSoftDeviceName();
   device_set_.FindMatchingDevices(soft_device_name, possible_devices);
   if (!possible_devices->empty()) {
diff --git a/tensorflow/core/common_runtime/constant_folding_test.cc b/tensorflow/core/common_runtime/constant_folding_test.cc
index 0992fc5a492..e621b3b5006 100644
--- a/tensorflow/core/common_runtime/constant_folding_test.cc
+++ b/tensorflow/core/common_runtime/constant_folding_test.cc
@@ -704,7 +704,7 @@ class TestTFFileSystem : public ::tensorflow::NullFileSystem {
   ::tensorflow::Tensor data_tensor_;
 };
 
-// A test TF environent that checks that the environment was used.
+// A test TF environment that checks that the environment was used.
 class TestTFEnvironment : public ::tensorflow::EnvWrapper {
  public:
   using tf_base = ::tensorflow::EnvWrapper;
diff --git a/tensorflow/core/common_runtime/dynamic_device_mgr.cc b/tensorflow/core/common_runtime/dynamic_device_mgr.cc
index 4bea08bb021..f35fa7e416a 100644
--- a/tensorflow/core/common_runtime/dynamic_device_mgr.cc
+++ b/tensorflow/core/common_runtime/dynamic_device_mgr.cc
@@ -125,7 +125,7 @@ Status DynamicDeviceMgr::AddDevices(
     if (device_map_.find(d->name()) != device_map_.end()) {
       return errors::InvalidArgument(
           "Trying to add device ", d->name(),
-          " to manager but its name conflicts with an existing deivce.");
+          " to manager but its name conflicts with an existing device.");
     }
     // Register under the (1) full name and (2) canonical name.
     for (const string& name :
diff --git a/tensorflow/core/common_runtime/dynamic_device_mgr_test.cc b/tensorflow/core/common_runtime/dynamic_device_mgr_test.cc
index 5e86be36b41..d8e6848ea93 100644
--- a/tensorflow/core/common_runtime/dynamic_device_mgr_test.cc
+++ b/tensorflow/core/common_runtime/dynamic_device_mgr_test.cc
@@ -101,7 +101,7 @@ TEST(DynamicDeviceMgrTest, AddRepeatedDeviceToMgr) {
   added_devices.emplace_back(std::move(d1));
   Status s = dm->AddDevices(std::move(added_devices));
   EXPECT_TRUE(absl::StrContains(s.error_message(),
-                                "name conflicts with an existing deivce"));
+                                "name conflicts with an existing device"));
 }
 
 TEST(DynamicDeviceMgrTest, RemoveNonExistingDeviceFromMgr) {
diff --git a/tensorflow/core/common_runtime/eager/context.h b/tensorflow/core/common_runtime/eager/context.h
index b59b0653930..eee58324cb9 100644
--- a/tensorflow/core/common_runtime/eager/context.h
+++ b/tensorflow/core/common_runtime/eager/context.h
@@ -609,7 +609,7 @@ class EagerContext : public core::RefCounted {
 
   uint64 context_id_ GUARDED_BY(remote_state_mu_);
   // The view id of an eager context should be set to 0 when context is created,
-  // and continously incremented when context with the same context_id gets
+  // and continuously incremented when context with the same context_id gets
   // updated. The view id should be consistent between master and workers.
   uint64 context_view_id_ GUARDED_BY(remote_state_mu_);
   std::vector<string> remote_contexts_;
diff --git a/tensorflow/core/common_runtime/eager/eager_executor.h b/tensorflow/core/common_runtime/eager/eager_executor.h
index 375e9a6e6a7..f8db56ccca6 100644
--- a/tensorflow/core/common_runtime/eager/eager_executor.h
+++ b/tensorflow/core/common_runtime/eager/eager_executor.h
@@ -190,7 +190,7 @@ class EagerExecutor {
   void NotifyWaiters(uint64 id) EXCLUSIVE_LOCKS_REQUIRED(node_queue_mutex_);
 
   // Starts execution of pending EagerNodes. This function loops till executor
-  // state_ is set to kShutDown. If any errors are encontered, these are set
+  // state_ is set to kShutDown. If any errors are encountered, these are set
   // inside `status_`. The loop blocks anytime there are no pending nodes, or if
   // `status_` is not ok.
   void Run();
diff --git a/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h b/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h
index a8132d3a033..daa9e8f52fb 100644
--- a/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h
+++ b/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h
@@ -34,7 +34,7 @@ class EagerOpRewrite {
 
   virtual ~EagerOpRewrite() {}
 
-  // To be implemnted by an Eager op rewrite pass.
+  // To be implemented by an Eager op rewrite pass.
   virtual Status Run(EagerOperation* orig_op,
                      std::unique_ptr<tensorflow::EagerOperation>* out_op) = 0;
 
diff --git a/tensorflow/core/common_runtime/eager/kernel_and_device.cc b/tensorflow/core/common_runtime/eager/kernel_and_device.cc
index d0d961a0055..6ba9c404097 100644
--- a/tensorflow/core/common_runtime/eager/kernel_and_device.cc
+++ b/tensorflow/core/common_runtime/eager/kernel_and_device.cc
@@ -326,7 +326,7 @@ Status KernelAndDeviceFunc::Run(
   } else {
     opts = absl::make_unique<FunctionLibraryRuntime::Options>();
     if (get_op_id_ && is_cross_process_) {
-      // If the function is a cross-process function and the remote excution
+      // If the function is a cross-process function and the remote execution
       // goes through eager service, create an eager op id for the function.
       opts->op_id = get_op_id_();
     }
diff --git a/tensorflow/core/common_runtime/executor_test.cc b/tensorflow/core/common_runtime/executor_test.cc
index 3f143c75714..36e3e2aea42 100644
--- a/tensorflow/core/common_runtime/executor_test.cc
+++ b/tensorflow/core/common_runtime/executor_test.cc
@@ -255,7 +255,7 @@ void BuildConcurrentAddAssign(Graph* g) {
   auto one = test::graph::Constant(g, V(1.0));
   // A variable holds one float.
   auto var = test::graph::Var(g, DT_FLOAT, TensorShape({}));
-  // Initilize the variable with 1.0.
+  // Initialize the variable with 1.0.
   auto init = test::graph::Assign(g, var, one);
   // Output
   auto out = test::graph::Send(g, var, "out", ALICE, kIncarnation, BOB);
diff --git a/tensorflow/core/common_runtime/function.cc b/tensorflow/core/common_runtime/function.cc
index 2140bf7f72b..614a7c3dcfa 100644
--- a/tensorflow/core/common_runtime/function.cc
+++ b/tensorflow/core/common_runtime/function.cc
@@ -1544,7 +1544,7 @@ std::vector<string> InputDevices(const Node& caller) {
   return input_devices;
 }
 
-// Place input nodes on the same device as the correspinding caller input
+// Place input nodes on the same device as the corresponding caller input
 // node. Do not specify any placement for all other nodes.
 class DefaultFunctionBodyPlacer : public InlinedFunctionBodyPlacer {
  public:
@@ -1593,7 +1593,7 @@ class SingleDeviceFunctionBodyPlacer : public InlinedFunctionBodyPlacer {
   const string caller_device_;
 };
 
-// Place input nodes on the same device as the correspinding caller input
+// Place input nodes on the same device as the corresponding caller input
 // node. Do not place output node. Place control nodes on the same device as
 // caller node. For all function body nodes overrides job, replica and task
 // parts of the device assignment to match function caller node.
diff --git a/tensorflow/core/common_runtime/function_test.cc b/tensorflow/core/common_runtime/function_test.cc
index 3e2371a686a..786f505813b 100644
--- a/tensorflow/core/common_runtime/function_test.cc
+++ b/tensorflow/core/common_runtime/function_test.cc
@@ -1312,7 +1312,7 @@ int GetConstantFoldingCounter() {
       return counter;
     }
   }
-  LOG(FATAL) << "Should have found a node that replcaed add";
+  LOG(FATAL) << "Should have found a node that replaced add";
 }
 
 TEST_F(FunctionLibraryRuntimeTest, OptimizeGraph) {
@@ -2129,7 +2129,7 @@ TEST(OptimizationTest, RemoveListArrayConverter) {
   }
 }
 
-TEST(OptimizationTest, RemoveListArrayConverter_WithContolDeps) {
+TEST(OptimizationTest, RemoveListArrayConverter_WithControlDeps) {
   auto func = FDH::Create(
       // Name
       "Test",
diff --git a/tensorflow/core/common_runtime/gpu/gpu_device.cc b/tensorflow/core/common_runtime/gpu/gpu_device.cc
index eaf16d2cc66..f57cdceb8ec 100644
--- a/tensorflow/core/common_runtime/gpu/gpu_device.cc
+++ b/tensorflow/core/common_runtime/gpu/gpu_device.cc
@@ -1837,7 +1837,7 @@ void GPUKernelTracker::RecordTerminated(uint64 queued_count) {
   // advance the completed frontier to the just-completed PendingKernel.  In
   // practice we occasionally see the termination callbacks arrive out of
   // order probably because of thread scheduling.  Eventually we may support
-  // out-of- order completion involving multple compute streams so here we
+  // out-of- order completion involving multiple compute streams so here we
   // follow a conservative approach and wait for every single callback to
   // arrive before advancing the frontier.
   while (true) {
diff --git a/tensorflow/core/common_runtime/gpu/gpu_device.h b/tensorflow/core/common_runtime/gpu/gpu_device.h
index bdecb471d95..62fbc5d8658 100644
--- a/tensorflow/core/common_runtime/gpu/gpu_device.h
+++ b/tensorflow/core/common_runtime/gpu/gpu_device.h
@@ -157,7 +157,7 @@ class BaseGPUDevice : public LocalDevice {
   int32 pending_cap_ = 0;
   bool timestamped_allocator_ = false;
 
-  // Initialize scractch buffers used by Eigen.
+  // Initialize scratch buffers used by Eigen.
   Status InitScratchBuffers();
 
   void ReinitializeDevice(OpKernelContext* context, PerOpGpuDevice* device,
diff --git a/tensorflow/core/common_runtime/gpu/gpu_id.h b/tensorflow/core/common_runtime/gpu/gpu_id.h
index f0d90228211..de405ae9de2 100644
--- a/tensorflow/core/common_runtime/gpu/gpu_id.h
+++ b/tensorflow/core/common_runtime/gpu/gpu_id.h
@@ -56,7 +56,7 @@ namespace tensorflow {
 //
 // Assuming we configure the Session to create one BaseGPUDevice per GPU
 // hardware, then setting GPUOptions::visible_device_list to "2,0" will create
-// the following mappting between TF GPU id and platform GPU id:
+// the following mapping between TF GPU id and platform GPU id:
 //
 //                  TF GPU id  ->  platform GPU ID
 //      0 (i.e. /device:GPU:0) ->  2
@@ -67,7 +67,7 @@ namespace tensorflow {
 //
 // On the other hand, if we configure it to create 2 BaseGPUDevice per GPU
 // hardware, then setting GPUOptions::visible_device_list to "2,0" will create
-// the following mappting between TF GPU id and platform GPU id:
+// the following mapping between TF GPU id and platform GPU id:
 //
 //                  TF GPU id  ->  platform GPU ID
 //      0 (i.e. /device:GPU:0) ->  2
diff --git a/tensorflow/core/common_runtime/graph_execution_state.cc b/tensorflow/core/common_runtime/graph_execution_state.cc
index 4a37bcfa40f..4c56eccdad5 100644
--- a/tensorflow/core/common_runtime/graph_execution_state.cc
+++ b/tensorflow/core/common_runtime/graph_execution_state.cc
@@ -615,7 +615,7 @@ Status GraphExecutionState::InitBaseGraph(std::unique_ptr<Graph>&& new_graph) {
                     session_options_->config.allow_soft_placement(),
                 session_options_ != nullptr &&
                     session_options_->config.log_device_placement());
-  // TODO(mrry): Consider making the Placer cancelable.
+  // TODO(mrry): Consider making the Placer cancellable.
   TF_RETURN_IF_ERROR(placer.Run());
 
   TF_RETURN_IF_ERROR(OptimizationPassRegistry::Global()->RunGrouping(
diff --git a/tensorflow/core/common_runtime/metrics.h b/tensorflow/core/common_runtime/metrics.h
index 963a12e9865..a5d43da539b 100644
--- a/tensorflow/core/common_runtime/metrics.h
+++ b/tensorflow/core/common_runtime/metrics.h
@@ -53,7 +53,7 @@ void RecordTFDataFingerprint(const string& name);
 // Records the number of independent graph changes resulting from the
 // application of a tf.data optimization.
 //
-// The `name` argument identifies the optimization (e.g. "noop_eliminiation").
+// The `name` argument identifies the optimization (e.g. "noop_elimination").
 void RecordTFDataOptimization(const string& name, int64 num_changes);
 
 // Records parsing of dense tensor features.
diff --git a/tensorflow/core/common_runtime/optimization_registry.h b/tensorflow/core/common_runtime/optimization_registry.h
index 4c8b68e18e1..03f2776ca84 100644
--- a/tensorflow/core/common_runtime/optimization_registry.h
+++ b/tensorflow/core/common_runtime/optimization_registry.h
@@ -73,7 +73,7 @@ class GraphOptimizationPass {
   string name() const { return name_; }
 
  private:
-  // The name of the opitimization pass, which is the same as the inherited
+  // The name of the optimization pass, which is the same as the inherited
   // class name.
   string name_;
 };
diff --git a/tensorflow/core/common_runtime/partitioning_utils.h b/tensorflow/core/common_runtime/partitioning_utils.h
index 1a6551ac858..1fc34186251 100644
--- a/tensorflow/core/common_runtime/partitioning_utils.h
+++ b/tensorflow/core/common_runtime/partitioning_utils.h
@@ -41,7 +41,7 @@ Status PartitionFunctionGraph(
 //
 // More specifically, this function
 //  (1) rewrites the indices of the `Arg` and `Retval` nodes placed
-//      on a particular device.  When a function is parittioned each
+//      on a particular device.  When a function is partitioned each
 //      partition, `subgraph`, get a subset of the arguments and
 //      return values. The `index` attributes of these _Arg and _Retval
 //      nodes reflect the indices of these parameters in the original
diff --git a/tensorflow/core/common_runtime/placer_test.cc b/tensorflow/core/common_runtime/placer_test.cc
index 33d1bb5413a..f1fd2574490 100644
--- a/tensorflow/core/common_runtime/placer_test.cc
+++ b/tensorflow/core/common_runtime/placer_test.cc
@@ -274,7 +274,7 @@ class PlacerTest : public ::testing::Test {
     RewriterConfig* rewriter_config = graph_opts->mutable_rewrite_options();
     rewriter_config->set_disable_meta_optimizer(true);
 
-    // Placing nested functions requires go through some PRE_PLACEMNT passes.
+    // Placing nested functions requires go through some PRE_PLACEMENT passes.
     // Currently, just the IsolateDeepOpsPass.
     GraphOptimizationPassOptions optimization_options;
     std::unique_ptr<Graph> graph_ptr(graph);
@@ -1493,7 +1493,7 @@ TEST_F(PlacerTest, TestUnknownAssignedDevice) {
 
 // Test that placement fails when an op with no registered kernels is
 // requested and no device is requested for the node
-TEST_F(PlacerTest, TestNoKernelsRegisteredWithNoRequstedDevice) {
+TEST_F(PlacerTest, TestNoKernelsRegisteredWithNoRequestedDevice) {
   Graph g(OpRegistry::Global());
   {  // Scope for temporary variables used to construct g.
     GraphDefBuilder b(GraphDefBuilder::kFailImmediately);
@@ -2286,7 +2286,7 @@ TEST_F(NestedPlacerTest, OutputTwoResources_UnassignedResource) {
    * the "second pass" as they are "sources". It assigns `r1` to GPU because it
    * is in the same group as `b`. It assigns `r2` to GPU because GPU has a
    * higher device preference. Finally, `a` is assigned to GPU because `r2` is
-   * on GPU - this test that the "second pass" heuristics respect colocaton
+   * on GPU - this test that the "second pass" heuristics respect colocation
    * groups (even when the consumer of the source, i.e. PCO is on a different
    * device).
    */
@@ -2494,7 +2494,7 @@ TEST_F(NestedPlacerTest, DuplicateInputResource_Conflict) {
    *                 r1:RESOURCE:GPU
    *
    * There is a conflict but Placer always overrides requested devices
-   * when they result in coflict due to resource edges. Which device
+   * when they result in conflict due to resource edges. Which device
    * is picked for a/r1/r2 is indeterministic.
    */
   FunctionDef func = test::function::Swap();
diff --git a/tensorflow/core/common_runtime/process_function_library_runtime.h b/tensorflow/core/common_runtime/process_function_library_runtime.h
index ee5d8bf2b16..bafce903c8b 100644
--- a/tensorflow/core/common_runtime/process_function_library_runtime.h
+++ b/tensorflow/core/common_runtime/process_function_library_runtime.h
@@ -444,7 +444,7 @@ class ProcessFunctionLibraryRuntime {
   std::unordered_map<string, FunctionLibraryRuntime::Handle> table_
       GUARDED_BY(mu_);
 
-  // Function data for instantitated remote functions.
+  // Function data for instantiated remote functions.
   std::unordered_map<FunctionLibraryRuntime::Handle,
                      std::unique_ptr<FunctionData>>
       function_data_ GUARDED_BY(mu_);
diff --git a/tensorflow/core/debug/debug_graph_utils_test.cc b/tensorflow/core/debug/debug_graph_utils_test.cc
index b3305e84a08..6a6c5cc7bca 100644
--- a/tensorflow/core/debug/debug_graph_utils_test.cc
+++ b/tensorflow/core/debug/debug_graph_utils_test.cc
@@ -126,7 +126,7 @@ TEST_F(DebugGraphUtilsTest, TestValidDebugOpNameWithMoreThanOneAttributes) {
   ASSERT_EQ("100", attributes["first_n"]);
 }
 
-TEST_F(DebugGraphUtilsTest, TestValidDebugOpNameWithMoreDuplicatettributes) {
+TEST_F(DebugGraphUtilsTest, TestValidDebugOpNameWithMoreDuplicateAttributes) {
   string debug_op_name_proper;
   std::unordered_map<string, string> attributes;
   Status s = ParseDebugOpName(
diff --git a/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.cc b/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.cc
index b9b4183ced4..24563584906 100644
--- a/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.cc
+++ b/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.cc
@@ -162,7 +162,7 @@ void EagerClusterFunctionLibraryRuntime::Run(
     remote_op->add_inputs()->Swap(&(*args)[i]);
   }
   // The remote component function should use the same op_id as its parent
-  // multi-device function's in order to get the global unqiue op_id generated
+  // multi-device function's in order to get the global unique op_id generated
   // by the master context.
   remote_op->set_id(opts.op_id.value());
   remote_op->set_is_function(true);
diff --git a/tensorflow/core/distributed_runtime/master_session.cc b/tensorflow/core/distributed_runtime/master_session.cc
index 4eeb04490a1..13ace23f8a3 100644
--- a/tensorflow/core/distributed_runtime/master_session.cc
+++ b/tensorflow/core/distributed_runtime/master_session.cc
@@ -588,7 +588,7 @@ class RunManyGraphs {
   void ReportBadStatus(const Status& s) EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     VLOG(1) << "Master received error status " << s;
     if (!cancel_issued_ && !StatusGroup::IsDerived(s)) {
-      // Only start cancelling other workers upon receiveing a non-derived
+      // Only start cancelling other workers upon receiving a non-derived
       // error
       cancel_issued_ = true;
 
diff --git a/tensorflow/core/distributed_runtime/rpc/grpc_master_service.cc b/tensorflow/core/distributed_runtime/rpc/grpc_master_service.cc
index e3f2feb2660..773b6a1bd15 100644
--- a/tensorflow/core/distributed_runtime/rpc/grpc_master_service.cc
+++ b/tensorflow/core/distributed_runtime/rpc/grpc_master_service.cc
@@ -13,7 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ==============================================================================*/
 
-// GrpcMasterService implements the RPC service MasterSerivce.
+// GrpcMasterService implements the RPC service MasterService.
 //
 // A GrpcMasterService maintains the state of live graph computation
 // sessions, each session orchestrates both local and remote devices
diff --git a/tensorflow/core/distributed_runtime/rpc/grpc_state.cc b/tensorflow/core/distributed_runtime/rpc/grpc_state.cc
index b05a54c4db4..fc3695e5461 100644
--- a/tensorflow/core/distributed_runtime/rpc/grpc_state.cc
+++ b/tensorflow/core/distributed_runtime/rpc/grpc_state.cc
@@ -24,8 +24,8 @@ const char* ToString(UntypedStreamingRPCState::Tag::TagType tag_type) {
       return "kCallStarted";
     case UntypedStreamingRPCState::Tag::TagType::kRequestWriteCompleted:
       return "kRequestWriteCompleted";
-    case UntypedStreamingRPCState::Tag::TagType::kResponseReadCommpleted:
-      return "kResponseReadCommpleted";
+    case UntypedStreamingRPCState::Tag::TagType::kResponseReadCompleted:
+      return "kResponseReadCompleted";
     case UntypedStreamingRPCState::Tag::TagType::kCallFinished:
       return "kCallFinished";
   }
@@ -43,7 +43,7 @@ void UntypedStreamingRPCState::Tag::OnCompleted(bool ok) {
     case TagType::kRequestWriteCompleted:
       streaming_state_->RequestWriteCompleted(ok);
       break;
-    case TagType::kResponseReadCommpleted:
+    case TagType::kResponseReadCompleted:
       streaming_state_->ResponseReadCompleted(ok);
       break;
     case TagType::kCallFinished:
diff --git a/tensorflow/core/distributed_runtime/rpc/grpc_state.h b/tensorflow/core/distributed_runtime/rpc/grpc_state.h
index f6246b287e3..982ea71a6ed 100644
--- a/tensorflow/core/distributed_runtime/rpc/grpc_state.h
+++ b/tensorflow/core/distributed_runtime/rpc/grpc_state.h
@@ -221,7 +221,7 @@ class UntypedStreamingRPCState : public core::RefCounted {
     enum class TagType {
       kCallStarted,
       kRequestWriteCompleted,
-      kResponseReadCommpleted,
+      kResponseReadCompleted,
       kCallFinished,
     };
 
@@ -337,7 +337,7 @@ class ExchangeQueue {
 
   // Changes the state of the exchange that is current in kRequestWriteIssued
   // state to kRequestWriteCompleted state.
-  // REQUIRES: There is an exhange in kRequestWriteIssued state.
+  // REQUIRES: There is an exchange in kRequestWriteIssued state.
   void MarkRequestWriteCompleted();
 
   // Returns the exchange at the front of the queue.
@@ -536,7 +536,7 @@ class StreamingRPCState : public UntypedStreamingRPCState {
   void MarkDoneAndCompleteExchanges(Status status) EXCLUSIVE_LOCKS_REQUIRED(mu_)
       UNLOCK_FUNCTION(mu_) {
     call_state_ = State::kDone;
-    VLOG(2) << "Ending gRPC stremaing call on the client side due to "
+    VLOG(2) << "Ending gRPC streaming call on the client side due to "
             << status.ToString();
     // Swap the exchanges_ into a temporary ExchangeQueue so that we can
     // complete all exchanges without holding mu_ in case user callback
@@ -604,7 +604,7 @@ class StreamingRPCState : public UntypedStreamingRPCState {
   // Tags are immutable. No need to guard them.
   Tag call_started_tag_{this, Tag::TagType::kCallStarted};
   Tag request_write_completed_tag_{this, Tag::TagType::kRequestWriteCompleted};
-  Tag response_read_completed_tag_{this, Tag::TagType::kResponseReadCommpleted};
+  Tag response_read_completed_tag_{this, Tag::TagType::kResponseReadCompleted};
   Tag finished_tag_{this, Tag::TagType::kCallFinished};
 };
 
diff --git a/tensorflow/core/distributed_runtime/test_utils.h b/tensorflow/core/distributed_runtime/test_utils.h
index e71bc2113ad..a93c78e62fd 100644
--- a/tensorflow/core/distributed_runtime/test_utils.h
+++ b/tensorflow/core/distributed_runtime/test_utils.h
@@ -62,7 +62,7 @@ class TestWorkerInterface : public WorkerInterface {
   }
 
   void RunGraphAsync(CallOptions* opts, RunGraphRequestWrapper* request,
-                     MutableRunGraphResponseWrapper* repsonse,
+                     MutableRunGraphResponseWrapper* response,
                      StatusCallback done) override {
     done(errors::Unimplemented("RunGraphAsync"));
   }
diff --git a/tensorflow/core/distributed_runtime/worker_interface.h b/tensorflow/core/distributed_runtime/worker_interface.h
index dcb43c372ba..9492d1cd31b 100644
--- a/tensorflow/core/distributed_runtime/worker_interface.h
+++ b/tensorflow/core/distributed_runtime/worker_interface.h
@@ -57,7 +57,7 @@ class WorkerInterface {
                                     StatusCallback done) = 0;
 
   virtual void RunGraphAsync(CallOptions* opts, RunGraphRequestWrapper* request,
-                             MutableRunGraphResponseWrapper* repsonse,
+                             MutableRunGraphResponseWrapper* response,
                              StatusCallback done) = 0;
 
   virtual void RunGraphAsync(CallOptions* opts, const RunGraphRequest* request,
diff --git a/tensorflow/core/framework/common_shape_fns.h b/tensorflow/core/framework/common_shape_fns.h
index 434948bafa2..715eb2ad018 100644
--- a/tensorflow/core/framework/common_shape_fns.h
+++ b/tensorflow/core/framework/common_shape_fns.h
@@ -338,7 +338,7 @@ inline Status BroadcastBinaryOpShapeFn(InferenceContext* c) {
 // Shape function for random operations.
 Status RandomShape(shape_inference::InferenceContext* c);
 
-// Shape function for Slice opertaions.
+// Shape function for Slice operations.
 Status SliceShape(shape_inference::InferenceContext* c);
 
 // Validates the 3 component tensors of a sparse tensor have the proper
diff --git a/tensorflow/core/framework/dataset.h b/tensorflow/core/framework/dataset.h
index 141e075b454..2255130e4af 100644
--- a/tensorflow/core/framework/dataset.h
+++ b/tensorflow/core/framework/dataset.h
@@ -493,7 +493,7 @@ class SerializationContext {
     // `input_list`.
     bool fail_if_unimplemented = true;
 
-    // Indicates whether (potentionally large) data tensors should be
+    // Indicates whether (potentially large) data tensors should be
     // serialized, or replaced with a placeholder returned in `input_list`. The
     // latter makes sense to do when performing data agnostic graph rewrites to
     // reduce the memory usage.
@@ -641,7 +641,7 @@ class IteratorBase {
     return errors::Unimplemented("RestoreInternal");
   }
 
-  // Returns the number of elements produced by this itertaor.
+  // Returns the number of elements produced by this iterator.
   int64 num_elements() const {
     if (node_) return node_->num_elements();
     return 0;
diff --git a/tensorflow/core/framework/dataset_stateful_op_whitelist.h b/tensorflow/core/framework/dataset_stateful_op_whitelist.h
index 25d7db2436a..0e4f018b73e 100644
--- a/tensorflow/core/framework/dataset_stateful_op_whitelist.h
+++ b/tensorflow/core/framework/dataset_stateful_op_whitelist.h
@@ -62,7 +62,7 @@ class WhitelistedStatefulOpRegistry {
 // Note that the state of the whitelisted ops inside functions will not be
 // saved during checkpointing, hence this should only be used if the op is
 // marked stateful for reasons like to avoid constant folding during graph
-// optimiztion but is not stateful.
+// optimization but is not stateful.
 // If possible, try to remove the stateful flag on the op first.
 // Example usage:
 //
diff --git a/tensorflow/core/framework/function.h b/tensorflow/core/framework/function.h
index 58cc1bbdaf9..0572f38c11d 100644
--- a/tensorflow/core/framework/function.h
+++ b/tensorflow/core/framework/function.h
@@ -665,7 +665,7 @@ class FunctionLibraryRuntime {
   // "handle".
   //
   // If function execution succeeds, "done" is called with OK and
-  // "*rets" is filled with the function's return values. Otheriwse,
+  // "*rets" is filled with the function's return values. Otherwise,
   // "done" is called with an error status.
   //
   // Does not take ownership of "rets".
diff --git a/tensorflow/core/framework/model.cc b/tensorflow/core/framework/model.cc
index 8de3d5aa494..f4b26ade74b 100644
--- a/tensorflow/core/framework/model.cc
+++ b/tensorflow/core/framework/model.cc
@@ -786,7 +786,7 @@ std::map<string, std::shared_ptr<Parameter>> Model::CollectTunableParameters(
 
 std::map<string, std::shared_ptr<Parameter>> Model::CollectEssentialParallelism(
     std::shared_ptr<Node> node) {
-  // Parallelism parameter is considered to be essential if the coressponding
+  // Parallelism parameter is considered to be essential if the corresponding
   // transformations's processing time is greater than essential rate times the
   // average transformation self processing time.
   constexpr double kEssentialRate = 0.3L;
diff --git a/tensorflow/core/framework/node_def_util.h b/tensorflow/core/framework/node_def_util.h
index 88adb296141..3a8d72b671e 100644
--- a/tensorflow/core/framework/node_def_util.h
+++ b/tensorflow/core/framework/node_def_util.h
@@ -158,7 +158,7 @@ class AttrSlice {
   // account.
   //
   // TODO(irving): There is a bug in this routine inherited from its
-  // OptimizerCSE::EqualAttrs precedecessor.  The same tensor attr can be
+  // OptimizerCSE::EqualAttrs predecessor.  The same tensor attr can be
   // represented in more than one way as an AttrValue, since TensorProto is
   // not 1-1.  This bug will go away once I replace everything with NodeInfo,
   // which stores a Tensor object directly.  The Scratch object will also go
diff --git a/tensorflow/core/framework/run_handler.cc b/tensorflow/core/framework/run_handler.cc
index 817ee0e73b6..52a1bfb71ce 100644
--- a/tensorflow/core/framework/run_handler.cc
+++ b/tensorflow/core/framework/run_handler.cc
@@ -205,7 +205,7 @@ class ThreadWorkSource {
       // thread pool waiting queues. Wake up threads from sub thread waiting
       // queues.
       // The waiting queues are defined at RunHandlerPool.
-      // Get the waiter_queue and coresponding mutex. Note, the thread work
+      // Get the waiter_queue and corresponding mutex. Note, the thread work
       // source may change afterwards if a new request comes or an old request
       // finishes.
       tf_shared_lock lock(run_handler_waiter_mu_);
@@ -522,7 +522,7 @@ class RunHandlerThreadPool {
 
   // Search tasks from Requets range searching_range_start to
   // searching_range_end. If there is no tasks in the search range and
-  // may_steal_blocking_work is true, then search from all reuqests.
+  // may_steal_blocking_work is true, then search from all requests.
   Task FindTask(
       int searching_range_start, int searching_range_end, int thread_id,
       int sub_thread_pool_id, int max_blocking_inflight,
@@ -596,7 +596,7 @@ Task RunHandlerThreadPool::FindTask(
   int current_index = thread_data_[thread_id].current_index;
   *task_from_blocking_queue = false;
 
-  // TODO(chaox): Chagne the search algorithm from round robin to random
+  // TODO(chaox): Change the search algorithm from round robin to random
   // walk.
   for (int i = 0; i < searching_range_end - searching_range_start; ++i) {
     if (current_index >= searching_range_end) {
diff --git a/tensorflow/core/framework/session_state.h b/tensorflow/core/framework/session_state.h
index 5d1dfaa1f91..48e06fc71d4 100644
--- a/tensorflow/core/framework/session_state.h
+++ b/tensorflow/core/framework/session_state.h
@@ -36,7 +36,7 @@ class SessionState {
   // Store a tensor in the session state.
   Status AddTensor(const string& handle, const Tensor& tensor);
 
-  // Delete a tensdor from the session state.
+  // Delete a tensor from the session state.
   Status DeleteTensor(const string& handle);
 
   int64 GetNewId();
diff --git a/tensorflow/core/framework/stats_aggregator.h b/tensorflow/core/framework/stats_aggregator.h
index 7f0380221fe..e8115a21d22 100644
--- a/tensorflow/core/framework/stats_aggregator.h
+++ b/tensorflow/core/framework/stats_aggregator.h
@@ -36,7 +36,7 @@ namespace data {
 //
 // NOTE(mrry): `StatsAggregator` is a virtual interface because we anticipate
 // that many different implementations will have the same interface. For
-// example, we have diffferent implementations in "stats_aggregator_ops.cc" for
+// example, we have different implementations in "stats_aggregator_ops.cc" for
 // simple in-memory implementation that integrates with the pull-based summary
 // API, and for the push-based `SummaryWriterInterface`, and we may add
 // implementations that work well with other custom monitoring services.
@@ -50,7 +50,7 @@ class StatsAggregator {
                               gtl::ArraySlice<double> values,
                               int64 global_step) = 0;
 
-  // TODO(shivaniagarawal): consistency in double and float usage.
+  // TODO(shivaniagrawal): consistency in double and float usage.
   // Add the given `value` as Scalar with the given `name`.
   virtual void AddScalar(const string& name, float value,
                          int64 global_step) = 0;
@@ -67,7 +67,7 @@ class StatsAggregator {
                                 int64 val) = 0;
 };
 
-// A `StatsAggregatorResource` wraps a shareable `StatsAggregator` as a resource
+// A `StatsAggregatorResource` wraps a sharable `StatsAggregator` as a resource
 // in the TensorFlow resource manager.
 //
 // NOTE(mrry): This class is separate from `StatsAggregator` in order to
diff --git a/tensorflow/core/framework/variant_op_registry.h b/tensorflow/core/framework/variant_op_registry.h
index 0a75eb5c837..4d94dcd35dd 100644
--- a/tensorflow/core/framework/variant_op_registry.h
+++ b/tensorflow/core/framework/variant_op_registry.h
@@ -332,7 +332,7 @@ Status BinaryOpVariants(OpKernelContext* ctx, VariantBinaryOp op,
                         const Variant& a, const Variant& b, Variant* out) {
   if (a.TypeId() != b.TypeId()) {
     return errors::Internal(
-        "BianryOpVariants: Variants a and b have different "
+        "BinaryOpVariants: Variants a and b have different "
         "type ids.  Type names: '",
         a.TypeName(), "' vs. '", b.TypeName(), "'");
   }
diff --git a/tensorflow/core/graph/gradients.cc b/tensorflow/core/graph/gradients.cc
index 3cf8e8b0f42..ac4fcb7c4bf 100644
--- a/tensorflow/core/graph/gradients.cc
+++ b/tensorflow/core/graph/gradients.cc
@@ -167,12 +167,12 @@ class SymbolicGradientBuilder {
 
   // A vector of output endpoints which represents backpropagated
   // gradients
-  typedef std::vector<NodeOut> BackpropedGradients;
+  typedef std::vector<NodeOut> BackproppedGradients;
 
   // backprops_ is a map from a node output to its accumulated
   // gradients.  When a node output has accumulated all its
   // gradients, we add a node which sums them up.
-  std::unordered_map<NodeOut, BackpropedGradients, NodeOutHash, NodeOutEq>
+  std::unordered_map<NodeOut, BackproppedGradients, NodeOutHash, NodeOutEq>
       backprops_;
 
   // pending[i] is count-down counter for i-th node's expected
diff --git a/tensorflow/core/graph/graph_constructor.cc b/tensorflow/core/graph/graph_constructor.cc
index 5a805520f51..39bb0514c34 100644
--- a/tensorflow/core/graph/graph_constructor.cc
+++ b/tensorflow/core/graph/graph_constructor.cc
@@ -137,7 +137,7 @@ class GraphConstructor {
     // remove this.
     bool importing;
     // If true, validates that nodes being converted have all expected attrs
-    // set and no unknonw attrs set by calling ValidateNodeDef().
+    // set and no unknown attrs set by calling ValidateNodeDef().
     // `validate_nodes` is always true when `importing` is set.
     bool validate_nodes;
     bool validate_colocation_constraints;
diff --git a/tensorflow/core/graph/graph_constructor.h b/tensorflow/core/graph/graph_constructor.h
index a7ed3d1605f..6930a57bf2e 100644
--- a/tensorflow/core/graph/graph_constructor.h
+++ b/tensorflow/core/graph/graph_constructor.h
@@ -44,7 +44,7 @@ struct GraphConstructorOptions {
   bool expect_device_spec = false;
 
   // If true, validates that nodes being converted have all expected attrs
-  // set and no unknonw attrs set by calling ValidateNodeDef().
+  // set and no unknown attrs set by calling ValidateNodeDef().
   // Setting validate_nodes without add_default_attributes, will fail if
   // the GraphDef does not have all required attributes set.
   bool validate_nodes = false;
diff --git a/tensorflow/core/graph/graph_constructor_test.cc b/tensorflow/core/graph/graph_constructor_test.cc
index bcbfe8bdd55..cf740156a40 100644
--- a/tensorflow/core/graph/graph_constructor_test.cc
+++ b/tensorflow/core/graph/graph_constructor_test.cc
@@ -3196,7 +3196,7 @@ versions {
   EXPECT_EQ(17, refiner.graph_def_version());
 }
 
-TEST_F(GraphConstructorTest, ImportGraphDef_ValidateColationConstraints) {
+TEST_F(GraphConstructorTest, ImportGraphDef_ValidateColocationConstraints) {
   GraphDef def;
   ASSERT_TRUE(protobuf::TextFormat::ParseFromString(
       "node { name: 'A' op: 'TestInput' attr { key: '_class' value { list { "
diff --git a/tensorflow/core/graph/mkl_graph_util.h b/tensorflow/core/graph/mkl_graph_util.h
index 517198d279b..22a4814f3f8 100644
--- a/tensorflow/core/graph/mkl_graph_util.h
+++ b/tensorflow/core/graph/mkl_graph_util.h
@@ -74,7 +74,7 @@ int inline GetTensorMetaDataIndex(int n, int total_tensors) {
   return DataIndexToMetaDataIndex(tidx, total_tensors);
 }
 
-// check if the control between src and dst nodes alreay exists
+// check if the control between src and dst nodes already exists
 bool inline DoesControlEdgeExist(const Node* src, const Node* dst) {
   for (const Edge* edge : src->out_edges()) {
     if (edge->IsControlEdge() && edge->dst() == dst) {
diff --git a/tensorflow/core/graph/mkl_layout_pass.cc b/tensorflow/core/graph/mkl_layout_pass.cc
index 79e0cd2bcf1..dd0f1b57876 100644
--- a/tensorflow/core/graph/mkl_layout_pass.cc
+++ b/tensorflow/core/graph/mkl_layout_pass.cc
@@ -3639,7 +3639,7 @@ const MklLayoutRewritePass::RewriteInfo*
 MklLayoutRewritePass::CheckForNodeRewrite(const Node* n) const {
   CHECK_NOTNULL(n);
 
-  // QuntizedOps may have attributes other than "T", so decoupled the check
+  // QuantizedOps may have attributes other than "T", so decoupled the check
   // with a function, CheckForQuantizedNodeRewrite(const Node*).
   const RewriteInfo* ri = CheckForQuantizedNodeRewrite(n);
   if (ri != nullptr) return ri;
@@ -3789,7 +3789,7 @@ MklLayoutRewritePass::CheckForNodeFusion(Node* a) const {
     // a.k.a. "a->b->c" matches "op1->op2->op3"
     //
 
-    // Stores the first unvisted outgoing edge of each matched node in "nodes".
+    // Stores the first unvisited outgoing edge of each matched node in "nodes".
     std::stack<EdgeSet::const_iterator> current_neighbor_stack;
     nodes.clear();
 
diff --git a/tensorflow/core/grappler/clusters/single_machine_test.cc b/tensorflow/core/grappler/clusters/single_machine_test.cc
index def80263dab..1770701033e 100644
--- a/tensorflow/core/grappler/clusters/single_machine_test.cc
+++ b/tensorflow/core/grappler/clusters/single_machine_test.cc
@@ -613,7 +613,7 @@ TEST_F(SingleMachineTest, PeakMemoryStatsNotEnabled) {
 
   TF_CHECK_OK(cluster_->Shutdown());
   cluster_.reset();
-  SingleMachine cluster(60 /* timout_s */, 3 /* num_cpu_cores */,
+  SingleMachine cluster(60 /* timeout_s */, 3 /* num_cpu_cores */,
                         0 /* num_gpus */);
 
   TF_CHECK_OK(cluster.Provision());
diff --git a/tensorflow/core/grappler/costs/graph_properties.cc b/tensorflow/core/grappler/costs/graph_properties.cc
index c3d63286c41..569c7cadeef 100644
--- a/tensorflow/core/grappler/costs/graph_properties.cc
+++ b/tensorflow/core/grappler/costs/graph_properties.cc
@@ -524,7 +524,7 @@ bool IsWhiteListedOpTypeForEvaluateNode(const string& op_type) {
           "TruncateDiv",
           "TruncateMod",
           "RealDiv",
-          // N-ary arithemtic ops
+          // N-ary arithmetic ops
           "AddN",
           // Others
           "StridedSlice",
@@ -1313,7 +1313,7 @@ class SymbolicShapeRefiner {
     return true;
   }
 
-  // Create input tensors from the NodeConext.
+  // Create input tensors from the NodeContext.
   void CreateInputTensors(NodeContext* c,
                           std::vector<Tensor>* input_tensor_vector,
                           TensorVector* inputs) {
@@ -1362,7 +1362,7 @@ class SymbolicShapeRefiner {
 
     // Input to EvaluateNode()
     TensorVector inputs;
-    // Container for temporaily created tensor object.
+    // Container for temporarily created tensor object.
     std::vector<Tensor> input_tensor_vector(ic->num_inputs());
     CreateInputTensors(c, &input_tensor_vector, &inputs);
 
diff --git a/tensorflow/core/grappler/costs/graph_properties_test.cc b/tensorflow/core/grappler/costs/graph_properties_test.cc
index 30ce22802bc..5a18179a33c 100644
--- a/tensorflow/core/grappler/costs/graph_properties_test.cc
+++ b/tensorflow/core/grappler/costs/graph_properties_test.cc
@@ -879,7 +879,7 @@ TEST_F(GraphPropertiesTest, InferRestoreOpShape) {
   EXPECT_EQ(DT_FLOAT, restorev2_prop.dtype());
   EXPECT_EQ("float: [128,256]", PropToString(restorev2_prop));
 
-  // Check input shapes of assign op are propagted correctly.
+  // Check input shapes of assign op are propagated correctly.
   const auto input_props = properties.GetInputProperties("init_restore");
   ASSERT_EQ(2, input_props.size());
   const OpInfo::TensorProperties& input_prop = input_props[1];
@@ -995,7 +995,7 @@ TEST_F(GraphPropertiesTest, SkippingValueInferenceForLargeTensors) {
   // When using aggressive_shape_inference, we run EvaluateNode() for
   // whitelisted ops and small input / output tensors. For instance, Fill op is
   // evaluated and produces output tensor value if output tensor size is smal
-  // (currently, fewer than 17 elements); otherwise we don't run EvalauteNode().
+  // (currently, fewer than 17 elements); otherwise we don't run EvaluateNode().
   // This is to avoid wasting time and memory for producing huge tensors (e.g.,
   // initializing a large table using Fill.
   {
diff --git a/tensorflow/core/grappler/costs/op_level_cost_estimator.cc b/tensorflow/core/grappler/costs/op_level_cost_estimator.cc
index fe5f12061f5..fdcb8920fea 100644
--- a/tensorflow/core/grappler/costs/op_level_cost_estimator.cc
+++ b/tensorflow/core/grappler/costs/op_level_cost_estimator.cc
@@ -868,7 +868,7 @@ int64 OpLevelCostEstimator::CountMatMulOperations(const OpInfo& op_info,
     LOG(ERROR) << "Incompatible Matrix dimensions";
     return ops;
   } else {
-    // One of k_dim and k_dim_b might be 1 (mininum dimension size).
+    // One of k_dim and k_dim_b might be 1 (minimum dimension size).
     k_dim = std::max(k_dim, k_dim_b);
   }
 
diff --git a/tensorflow/core/grappler/costs/op_level_cost_estimator.h b/tensorflow/core/grappler/costs/op_level_cost_estimator.h
index 8b3db4e6588..ad2df8fcdd5 100644
--- a/tensorflow/core/grappler/costs/op_level_cost_estimator.h
+++ b/tensorflow/core/grappler/costs/op_level_cost_estimator.h
@@ -200,7 +200,7 @@ class OpLevelCostEstimator {
   typedef std::function<Costs(const OpContext& op_context)> CostImpl;
   std::map<string, CostImpl> device_cost_impl_;
   // If true, assume compute and memory overlap; hence, the op cost is max of
-  // compute_time and memory_time, insteaf of sum of those two.
+  // compute_time and memory_time, instead of sum of those two.
   bool compute_memory_overlap_;
   std::set<string> persistent_ops_;
 
diff --git a/tensorflow/core/grappler/costs/op_level_cost_estimator_test.cc b/tensorflow/core/grappler/costs/op_level_cost_estimator_test.cc
index 136ba96c0e6..6048b3ec16d 100644
--- a/tensorflow/core/grappler/costs/op_level_cost_estimator_test.cc
+++ b/tensorflow/core/grappler/costs/op_level_cost_estimator_test.cc
@@ -521,7 +521,7 @@ class OpLevelCostEstimatorTest : public ::testing::Test {
     estimator_.compute_memory_overlap_ = value;
   }
 
-  void ValidateOpDimensionsFromImputs(const int n, const int h, const int w,
+  void ValidateOpDimensionsFromInputs(const int n, const int h, const int w,
                                       const int c, const int kx, const int ky,
                                       const int sx, const int sy,
                                       const string& data_format,
@@ -571,12 +571,12 @@ class OpLevelCostEstimatorTest : public ::testing::Test {
 TEST_F(OpLevelCostEstimatorTest, TestPersistentOpCosts) {
   OpContext op_context;
   SetCpuDevice(&op_context.op_info);
-  std::unordered_set<string> persisent_ops = {
+  std::unordered_set<string> persistent_ops = {
       "Const",       "Variable",       "VariableV2", "AutoReloadVariable",
       "VarHandleOp", "ReadVariableOp",
   };
-  // Minmum cost for all persistent ops.
-  for (const auto& op : persisent_ops) {
+  // Minimum cost for all persistent ops.
+  for (const auto& op : persistent_ops) {
     op_context.op_info.set_op(op);
     auto cost = estimator_.PredictCosts(op_context);
     EXPECT_EQ(Costs::Duration(0), cost.memory_time);
@@ -1128,10 +1128,10 @@ TEST_F(OpLevelCostEstimatorTest, OpDimensionsFromInputs) {
   for (const auto& p : paddings) {
     for (const auto& f : formats) {
       // n, h, w, c, kx, ky, sx, sy, data_format, padding.
-      ValidateOpDimensionsFromImputs(10, 20, 20, 100, 3, 3, 2, 2, f, p);
-      ValidateOpDimensionsFromImputs(10, 20, 20, 100, 1, 1, 3, 3, f, p);
-      ValidateOpDimensionsFromImputs(10, 200, 200, 100, 5, 5, 3, 3, f, p);
-      ValidateOpDimensionsFromImputs(10, 14, 14, 3840, 3, 3, 2, 2, f, p);
+      ValidateOpDimensionsFromInputs(10, 20, 20, 100, 3, 3, 2, 2, f, p);
+      ValidateOpDimensionsFromInputs(10, 20, 20, 100, 1, 1, 3, 3, f, p);
+      ValidateOpDimensionsFromInputs(10, 200, 200, 100, 5, 5, 3, 3, f, p);
+      ValidateOpDimensionsFromInputs(10, 14, 14, 3840, 3, 3, 2, 2, f, p);
     }
   }
 }
diff --git a/tensorflow/core/grappler/costs/virtual_scheduler.cc b/tensorflow/core/grappler/costs/virtual_scheduler.cc
index 4acb0b84116..7cb61b76514 100644
--- a/tensorflow/core/grappler/costs/virtual_scheduler.cc
+++ b/tensorflow/core/grappler/costs/virtual_scheduler.cc
@@ -262,7 +262,7 @@ const NodeDef* CompositeNodeManager::GetCurrNode() {
   // FirstReady for _Send and _Recv (separately),
   // Globally (among the LIFO-selected ops from each device and _Send and
   // _Recv) FirstReady,
-  // Priorty order: _Send, _Recv, and then the rest, if time_ready is equal.
+  // Priority order: _Send, _Recv, and then the rest, if time_ready is equal.
   std::vector<std::pair<const NodeDef*, Costs::Duration>> candidates;
   for (auto& ops_lifo : ops_lifo_map_) {
     if (!ops_lifo.second.Empty()) {
@@ -294,7 +294,7 @@ const NodeDef* CompositeNodeManager::GetCurrNode() {
             // Both are normal ops; use node name as tie breaker.
             return a.first->name().compare(b.first->name()) < 0;
           } else {
-            // Priortize by op type: _Send, _Recv, and normap ops.
+            // Prioritize by op type: _Send, _Recv, and normap ops.
             return a_score > b_score;
           }
         } else {
@@ -989,7 +989,7 @@ Costs VirtualScheduler::Summary() const {
     std::map<string, int64> op_to_memory;
     // First profile only persistent memory usage.
     int64 persistent_memory_usage = 0;
-    std::set<string> persisent_ops;
+    std::set<string> persistent_ops;
     for (const auto& node_port : state.persistent_nodes) {
       const auto* node = node_port.first;
       const auto port = node_port.second;
@@ -997,7 +997,7 @@ Costs VirtualScheduler::Summary() const {
           CalculateOutputSize(node_map_.at(node).output_properties, port);
       persistent_memory_usage += output_size;
       op_to_memory[node->op()] += output_size;
-      persisent_ops.insert(node->op());
+      persistent_ops.insert(node->op());
     }
     int64 max_memory_usage = persistent_memory_usage + state.max_memory_usage;
     critical_path_costs.estimated_max_memory_per_device[name] =
@@ -1076,7 +1076,7 @@ Costs VirtualScheduler::Summary() const {
                        memory_cost, intermediate_memory_cost)
                 << " (" << HumanReadableNumBytes(op_mem_usage) << " ["
                 << mem_usage_percent << "%] "
-                << (persisent_ops.count(op) > 0 ? ": persistent op)" : ")");
+                << (persistent_ops.count(op) > 0 ? ": persistent op)" : ")");
       }
     }
 
diff --git a/tensorflow/core/grappler/costs/virtual_scheduler_test.cc b/tensorflow/core/grappler/costs/virtual_scheduler_test.cc
index 29fb04640bf..ae6fab28a72 100644
--- a/tensorflow/core/grappler/costs/virtual_scheduler_test.cc
+++ b/tensorflow/core/grappler/costs/virtual_scheduler_test.cc
@@ -415,7 +415,7 @@ TEST_F(ReadyNodeManagerTest, RemoveSingleNodeCompositeNodeManager) {
   EXPECT_TRUE(manager.Empty());
 }
 
-TEST_F(ReadyNodeManagerTest, GetAndRemoveMultipleComopsiteNodeManager) {
+TEST_F(ReadyNodeManagerTest, GetAndRemoveMultipleCompositeNodeManager) {
   CompositeNodeManager manager;
   TF_EXPECT_OK(manager.Init(&node_states_));
   manager.AddNode(&node1_);
@@ -445,7 +445,7 @@ TEST_F(ReadyNodeManagerTest, GetAndRemoveMultipleComopsiteNodeManager) {
   EXPECT_TRUE(manager.Empty());
 }
 
-TEST_F(ReadyNodeManagerTest, MultiDeviceSendRecvComopsiteNodeManager) {
+TEST_F(ReadyNodeManagerTest, MultiDeviceSendRecvCompositeNodeManager) {
   CompositeNodeManager manager;
   TF_EXPECT_OK(manager.Init(&node_states_));
   // Additional nodes on kCPU1.
@@ -2966,7 +2966,7 @@ TEST_F(VirtualSchedulerTest, GraphWihtOnlyRecv) {
 }
 
 TEST_F(VirtualSchedulerTest, AddMergeSwitch) {
-  // Override scheduler_ with CompositeNodeNamager.
+  // Override scheduler_ with CompositeNodeManager.
   scheduler_ = absl::make_unique<TestVirtualScheduler>(
       /*use_static_shapes=*/true,
       /*use_aggressive_shape_inference=*/true, &composite_node_manager_,
diff --git a/tensorflow/core/grappler/graph_analyzer/sig_node.cc b/tensorflow/core/grappler/graph_analyzer/sig_node.cc
index b5cca6a5124..c71ad3100f4 100644
--- a/tensorflow/core/grappler/graph_analyzer/sig_node.cc
+++ b/tensorflow/core/grappler/graph_analyzer/sig_node.cc
@@ -89,7 +89,7 @@ void SigNode::ComputeTopoHash0() {
   topo_hash_.clear();
   last_hashed_nodes_ = next_hashed_nodes_ = node_mask_;
 
-  // TODO(babkin): include the attrbutes too, as an option.
+  // TODO(babkin): include the attributes too, as an option.
   size_t hval = std::hash<string>()(opcode());
 
   // Getting the topology of the links in to the hash early should get more
diff --git a/tensorflow/core/grappler/mutable_graph_view.h b/tensorflow/core/grappler/mutable_graph_view.h
index a09c147be6c..68946a65ab4 100644
--- a/tensorflow/core/grappler/mutable_graph_view.h
+++ b/tensorflow/core/grappler/mutable_graph_view.h
@@ -195,7 +195,7 @@ class MutableGraphView : public internal::GraphViewInternal<GraphDef, NodeDef> {
 
   // Removes control dependency `fanin_node_name` from the target node named
   // `node_name`. If the node or fanin do not exist in the graph, nothing will
-  // be modified in the graph. To remove regular fanins, use RemoveRegualrFanin.
+  // be modified in the graph. To remove regular fanins, use RemoveRegularFanin.
   //
   // If the fanin being removed doesn't exist in the node's inputs, this will
   // not result in an error and the node will not be modified.
diff --git a/tensorflow/core/grappler/mutable_graph_view_test.cc b/tensorflow/core/grappler/mutable_graph_view_test.cc
index 07818d1f526..64eb29ca934 100644
--- a/tensorflow/core/grappler/mutable_graph_view_test.cc
+++ b/tensorflow/core/grappler/mutable_graph_view_test.cc
@@ -1947,7 +1947,7 @@ TEST(MutableGraphViewTest, SwapRegularFaninsByPorts) {
                                /*to_port=*/2, /*success=*/true, error_msg,
                                {"a", "b:2", "b:2", "^c", "^d"});
 
-  // Swaping fanins at out of bounds ports.
+  // Swapping fanins at out of bounds ports.
   // Node with no regular fanins and no controls.
   error_msg =
       "MutableGraphView::SwapRegularFaninsByPorts(node_name='foo_5', "
diff --git a/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc b/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc
index 42e667422fa..d256a66aba6 100644
--- a/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/arithmetic_optimizer.cc
@@ -1044,7 +1044,7 @@ class MinimizeBroadcasts : public ArithmeticNodesGroupOptimizerStage {
       // short tree, pushing to the front will create a tall tree. We prefer to
       // get a wide tree, it minimizes the potential number of temporary tensors
       // required to keep in memory, though sometimes we can go up to prevent
-      // propagating a brodcast from leaves to the root. Example:
+      // propagating a broadcast from leaves to the root. Example:
       //
       // inputs: [s, s, s, M] (s - scalar, M - matrix)
       // @* - op with broadcast
@@ -1466,7 +1466,7 @@ class HoistCWiseUnaryChainsStage : public ArithmeticOptimizerStage {
       }
       if (NumControlOutputs(*node, *ctx().node_map) > 0) {
         // TODO(ezhulenev): Unary ops after Split might have a control path to
-        // the Split node, and we currently do not propertly handle cycles.
+        // the Split node, and we currently do not properly handle cycles.
         return false;
       }
       return num_split > 1 && !IsAlreadyOptimized(*node);
@@ -1509,7 +1509,7 @@ class HoistCWiseUnaryChainsStage : public ArithmeticOptimizerStage {
     // Follow the chains starting at each concat input or split output as long
     // as all the following conditions hold:
     //   1. The ops in all chains are the same.
-    //   2. The ops are unary elemenwise op.
+    //   2. The ops are unary elementwise op.
     //   3. The op output has only a single consumer (concat only).
     ChainLinkSet cur_tails;
     TF_RETURN_IF_ERROR(InitializeChains(root_node, &cur_tails));
diff --git a/tensorflow/core/grappler/optimizers/constant_folding.cc b/tensorflow/core/grappler/optimizers/constant_folding.cc
index 8324f403b46..95421111602 100644
--- a/tensorflow/core/grappler/optimizers/constant_folding.cc
+++ b/tensorflow/core/grappler/optimizers/constant_folding.cc
@@ -1781,7 +1781,7 @@ void ConstantFolding::ReplaceOperationWithSnapshot(
     int input_to_forward, const GraphProperties& properties, NodeDef* node,
     GraphDef* graph) {
   // If the graph contains no ops that mutate their inputs, we can
-  // use Identity insted of Snapshot.
+  // use Identity instead of Snapshot.
   if (!graph_contains_assign_or_inplace_op_) {
     ReplaceOperationWithIdentity(input_to_forward, properties, node, graph);
     return;
@@ -3138,7 +3138,7 @@ bool ConstantFolding::ConstantPushDown(GraphProperties* properties,
       ctx.left_child_is_const ? node->input(1) : node->input(0);
   VLOG(1) << "input_c = " << input_c << "\ninput_x = " << input_x;
 
-  // Now we have identified the nodes to swap, updare the nodemap accordingly.
+  // Now we have identified the nodes to swap, update the nodemap accordingly.
   node_map_->UpdateInput(node->name(), input_c, input_x);
   node_map_->AddOutput(input_c, ctx.op_child->name());
   if (input_x != input_y) {
diff --git a/tensorflow/core/grappler/optimizers/constant_folding_test.cc b/tensorflow/core/grappler/optimizers/constant_folding_test.cc
index 8bf543f914d..569f6433edb 100644
--- a/tensorflow/core/grappler/optimizers/constant_folding_test.cc
+++ b/tensorflow/core/grappler/optimizers/constant_folding_test.cc
@@ -2658,7 +2658,7 @@ TEST_F(ConstantFoldingTest, PaddingWithZeroSize) {
   test::ExpectTensorEqual<int>(tensors_expected[0], tensors[0]);
 }
 
-TEST_F(ConstantFoldingTest, SqueezeWithAllDimesionsGreaterThanOne) {
+TEST_F(ConstantFoldingTest, SqueezeWithAllDimensionsGreaterThanOne) {
   tensorflow::Scope scope = tensorflow::Scope::NewRootScope();
 
   auto in1 = ops::Variable(scope.WithOpName("in1"), {2, 3}, DT_INT32);
@@ -3379,7 +3379,7 @@ TEST_F(ConstantFoldingTest, SwitchIdenticalInputs) {
   EXPECT_EQ(1, tensors.size());
   test::ExpectTensorEqual<bool>(tensors_expected[0], tensors[0]);
 
-  // Evalute id_false when input tensor is false.
+  // Evaluate id_false when input tensor is false.
   x_t.flat<bool>()(0) = false;
   tensors_expected = EvaluateNodes(item.graph, {"id_false"}, {{"x", x_t}});
   EXPECT_EQ(1, tensors_expected.size());
@@ -3689,8 +3689,8 @@ TEST_F(ConstantFoldingTest, TrivialPack) {
   EXPECT_EQ(tensors_expected[1].shape(), tensors[1].shape());
 }
 
-// The test does not evalute the optimized and original graphs to check if their
-// outputs are the same. See b/78233179.
+// The test does not evalaute the optimized and original graphs to check if
+// their outputs are the same. See b/78233179.
 TEST_F(ConstantFoldingTest, Enter) {
   GrapplerItem item;
   AttrValue frame_name;
diff --git a/tensorflow/core/grappler/optimizers/data/latency_all_edges_test.cc b/tensorflow/core/grappler/optimizers/data/latency_all_edges_test.cc
index 7dc32084f29..8aea21b286b 100644
--- a/tensorflow/core/grappler/optimizers/data/latency_all_edges_test.cc
+++ b/tensorflow/core/grappler/optimizers/data/latency_all_edges_test.cc
@@ -40,7 +40,7 @@ TEST(LatencyAllEdgesTest, AddLatenciesAfterTensorMapPrefetch) {
   NodeDef map_node = NDef("map_node", "MapDataset",
                           {"from_tensor_node", "captured_input_node"},
                           {{"f", {}},
-                           {"Targumemts", {}},
+                           {"Targuments", {}},
                            {"output_shapes", {}},
                            {"output_types", {}}});
   NodeDef buffer_size_node = NDef("buffer_size_node", "Const", {},
diff --git a/tensorflow/core/grappler/optimizers/function_optimizer.cc b/tensorflow/core/grappler/optimizers/function_optimizer.cc
index 03f8b2955c1..c6818d4f2f6 100644
--- a/tensorflow/core/grappler/optimizers/function_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/function_optimizer.cc
@@ -1177,7 +1177,7 @@ Status InlineFunctionCalls(const GrapplerItem& item,
                            GraphDef* output_graph) {
   bool is_aggressive = opt_level == RewriterConfig::AGGRESSIVE;
   VLOG(2) << "Inline function calls: grappler_item_id=" << item.id
-          << " (aggessive_mode=" << is_aggressive << ")";
+          << " (aggressive_mode=" << is_aggressive << ")";
 
   FunctionLibraryDefinition flib_def =
       FunctionLibraryDefinition(OpRegistry::Global(), item.graph.library());
diff --git a/tensorflow/core/grappler/optimizers/layout_optimizer.cc b/tensorflow/core/grappler/optimizers/layout_optimizer.cc
index 4ce7cde6b9d..6f88f81548b 100644
--- a/tensorflow/core/grappler/optimizers/layout_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/layout_optimizer.cc
@@ -735,7 +735,7 @@ class NodeProcessor : public GraphProcessor {
     if (IsConstant(*param_node)) {
       TF_RETURN_IF_ERROR(UpdateAttrValueOfInput(param_index, permute));
     } else {
-      AddDataFormatTranformToParamInput(op, param_index, dtype);
+      AddDataFormatTransformToParamInput(op, param_index, dtype);
     }
     return Status::OK();
   }
@@ -1038,8 +1038,8 @@ class NodeProcessor : public GraphProcessor {
     return added_node;
   }
 
-  void AddDataFormatTranformToParamInput(const string& op, int input_pos,
-                                         DataType dtype) {
+  void AddDataFormatTransformToParamInput(const string& op, int input_pos,
+                                          DataType dtype) {
     string suffix = (op == "DataFormatVecPermute") ? kVecPermuteNHWCToNCHW
                                                    : kDimMapNHWCToNCHW;
     string name = LayoutOptimizerNode(
diff --git a/tensorflow/core/grappler/optimizers/memory_optimizer.cc b/tensorflow/core/grappler/optimizers/memory_optimizer.cc
index 47bde3fbfd0..4f92948fc72 100644
--- a/tensorflow/core/grappler/optimizers/memory_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/memory_optimizer.cc
@@ -1147,7 +1147,7 @@ bool SwappingPass(RewriterConfig::MemOptType optimization_level,
     // Use heuristics to figure out what needs to be swapped;
     IdentifySwappingCandidates(cluster, item, skip_list, &nodes_to_swap);
   }
-  // Look for manual annotatations in the graph.
+  // Look for manual annotations in the graph.
   for (auto& node : *item->graph.mutable_node()) {
     if (node.attr().count("_swap_to_host") != 0) {
       SwapInfo& swap_info = nodes_to_swap[&node];
diff --git a/tensorflow/core/grappler/optimizers/memory_optimizer_test.cc b/tensorflow/core/grappler/optimizers/memory_optimizer_test.cc
index 9f2e0b343b5..064c293416b 100644
--- a/tensorflow/core/grappler/optimizers/memory_optimizer_test.cc
+++ b/tensorflow/core/grappler/optimizers/memory_optimizer_test.cc
@@ -520,7 +520,7 @@ TEST_F(RelaxAllocatorConstraintsTest, SameDeviceType) {
                                   {128, 128}, DT_FLOAT);
   Output assign = ops::Assign(s.WithOpName("assign").WithDevice("/cpu:0"),
                               variable, constant);
-  // Assign and Exp run on different devies, but do not straddle a CPU:GPU
+  // Assign and Exp run on different devices, but do not straddle a CPU:GPU
   // boundary, so we can we do not need to enforce allocation in pinned memory.
   Output exp = ops::Exp(s.WithOpName("exp").WithDevice("/cpu:1"), assign);
 
diff --git a/tensorflow/core/grappler/optimizers/meta_optimizer.cc b/tensorflow/core/grappler/optimizers/meta_optimizer.cc
index 32d5380d720..da83e413ff6 100644
--- a/tensorflow/core/grappler/optimizers/meta_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/meta_optimizer.cc
@@ -737,7 +737,7 @@ Status MetaOptimizer::Optimize(Cluster* cluster, const GrapplerItem& item,
         // TPU metadata and Grappler passes could prune that away. Grappler
         // passes could also cause issues around shape inference. Since the
         // desired and existing behavior is to not optimize TPU functions with
-        // Grappler, this check preserves that. The only execption is
+        // Grappler, this check preserves that. The only exception is
         // implementation selector what is required to swap in some TPU specific
         // lowering code and is verified the work correctly on TPUs.
         ImplementationSelector implementation_selector;
diff --git a/tensorflow/core/grappler/optimizers/meta_optimizer.h b/tensorflow/core/grappler/optimizers/meta_optimizer.h
index 4d378cc8c12..18392f667b4 100644
--- a/tensorflow/core/grappler/optimizers/meta_optimizer.h
+++ b/tensorflow/core/grappler/optimizers/meta_optimizer.h
@@ -69,7 +69,7 @@ class MetaOptimizer : public GraphOptimizer {
   const RewriterConfig::CustomGraphOptimizer* GetCustomGraphOptimizerConfig(
       const string& name) const;
 
-  // Initialiaze active verifiers from the RewriterConfig toggles.
+  // Initialize active verifiers from the RewriterConfig toggles.
   void InitializeVerifiers(
       std::vector<std::unique_ptr<GraphVerifier>>* inter_optimizer_verifiers,
       std::vector<std::unique_ptr<GraphVerifier>>* post_optimization_verifiers)
diff --git a/tensorflow/core/grappler/optimizers/model_pruner.cc b/tensorflow/core/grappler/optimizers/model_pruner.cc
index 7cb96a21c5b..3c473b23f6e 100644
--- a/tensorflow/core/grappler/optimizers/model_pruner.cc
+++ b/tensorflow/core/grappler/optimizers/model_pruner.cc
@@ -299,7 +299,7 @@ Status RewriteIdentityNAndInputsOutputs(
   // Rewrite IdentityN node and associated inputs and outputs. For inputs and
   // outputs that don't lead to a terminal node, a new Identity node is created
   // and those inputs and outputs are rewritten to use the new Identity node as
-  // their outputs and inputs respectively. For the remaining nodes, the ouputs
+  // their outputs and inputs respectively. For the remaining nodes, the outputs
   // have their inputs updated with the adjusted port, from the IdentityN node
   // having less inputs.
   struct NodeOutputUpdate {
diff --git a/tensorflow/core/grappler/optimizers/model_pruner_test.cc b/tensorflow/core/grappler/optimizers/model_pruner_test.cc
index 37ca8df268e..d2624e3d842 100644
--- a/tensorflow/core/grappler/optimizers/model_pruner_test.cc
+++ b/tensorflow/core/grappler/optimizers/model_pruner_test.cc
@@ -406,7 +406,7 @@ TEST_F(ModelPrunerTest, PruningForwardsCtrlDependencies) {
 }
 */
 
-TEST_F(ModelPrunerTest, PruningPerservesFetch) {
+TEST_F(ModelPrunerTest, PruningPreservesFetch) {
   // Build a simple graph with a few trivially prunable ops.
   GrapplerItem item;
   {
@@ -445,7 +445,7 @@ TEST_F(ModelPrunerTest, PruningPerservesFetch) {
   test::ExpectTensorEqual<float>(actual_tensors[0], expected_tensors[0]);
 }
 
-TEST_F(ModelPrunerTest, PruningPerservesCrossDeviceIdentity) {
+TEST_F(ModelPrunerTest, PruningPreservesCrossDeviceIdentity) {
   GrapplerItem item;
   {
     tensorflow::Scope s = tensorflow::Scope::NewRootScope();
diff --git a/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.cc b/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.cc
index d6250427fc4..ec16de1294b 100644
--- a/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.cc
@@ -119,7 +119,7 @@ Status IsNodeOutputPortHostFriendly(const GraphView& graph,
   }
 
   // These nodes may be optimized away downstream (even if pinned to Host), we
-  // should (recusively) check their source.
+  // should (recursively) check their source.
   if (IsIdentity(node) || IsIdentityNSingleInput(node)) {
     for (const auto& fanin : graph.GetFanins(node, false)) {
       bool fanin_candidate = false;
diff --git a/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.cc b/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.cc
index ffb1083d64d..5d65067b036 100644
--- a/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.cc
+++ b/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.cc
@@ -389,7 +389,7 @@ class UnaryElementwiseRewriter : public ScopedAllocatorOptimizer::Rewriter {
     for (const InputDesc& nd : inputs) {
       if (op_set.find(nd.from_node_def->name()) != op_set.end()) {
         if (nd.output_slot != tensorflow::Graph::kControlSlot) {
-          return errors::Internal("Data edge exists bewtween ",
+          return errors::Internal("Data edge exists between ",
                                   nd.from_node_def->name(),
                                   " and another "
                                   "node in the set");
diff --git a/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer_test.cc b/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer_test.cc
index 12eefe79808..d67b8acdaa4 100644
--- a/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer_test.cc
+++ b/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer_test.cc
@@ -250,7 +250,7 @@ class ScopedAllocatorOptimizerTest : public ::testing::Test {
   }
 
   // Invokes ScopedAllocatorOptimizer on `graph_def`, then executes it and
-  // returns the outputs specifed by `output_names` in `outputs`.
+  // returns the outputs specified by `output_names` in `outputs`.
   void ExecuteGraph(const GraphDef& graph_def,
                     const std::vector<string>& output_names,
                     std::vector<Tensor>* outputs) {
diff --git a/tensorflow/core/grappler/utils/graph_view.cc b/tensorflow/core/grappler/utils/graph_view.cc
index 5b51710857b..5a9a1cd2abb 100644
--- a/tensorflow/core/grappler/utils/graph_view.cc
+++ b/tensorflow/core/grappler/utils/graph_view.cc
@@ -982,7 +982,7 @@ void MutableGraphView::FixRenamedFanouts(
   // leftover fanouts, mark their respective fanin fanout_index_ to
   // internal::kMissingIndex as an indicator so when it comes to updating or
   // removing fanins inplace, nodes with the same index don't get affected and
-  // other fanouts are accidently removed.
+  // other fanouts are accidentally removed.
   for (auto& renamed_fanout : renamed_fanouts) {
     for (auto& regular_fanouts :
          renamed_fanout.second.regular_fanouts_by_port_) {
diff --git a/tensorflow/core/grappler/utils/grappler_test.h b/tensorflow/core/grappler/utils/grappler_test.h
index dc518339905..7ac70356f2c 100644
--- a/tensorflow/core/grappler/utils/grappler_test.h
+++ b/tensorflow/core/grappler/utils/grappler_test.h
@@ -55,13 +55,13 @@ class GrapplerTest : public ::testing::Test {
   // with the same inputs and attributes. Nodes can be in different order.
   //
   // NOTE: This function uses EXPECT/ASSERT macros to check node properties
-  // equality, and adds all failuires to the current test.
+  // equality, and adds all failures to the current test.
   void CompareGraphs(GraphDef want, GraphDef got) const;
 
   // Checks if two nodes have the same name, op, inputs and attributes.
   //
   // NOTE: This function uses EXPECT/ASSERT macros to check node properties
-  // equality, and adds all failuires to the current test.
+  // equality, and adds all failures to the current test.
   void CompareNodes(const NodeDef& want, const NodeDef& got) const;
 
   // Checks if two functions are equal. Both functions must have the same set of
diff --git a/tensorflow/core/kernels/adjust_contrast_op.cc b/tensorflow/core/kernels/adjust_contrast_op.cc
index 7fa33950bb2..c13619e0e5f 100644
--- a/tensorflow/core/kernels/adjust_contrast_op.cc
+++ b/tensorflow/core/kernels/adjust_contrast_op.cc
@@ -273,7 +273,7 @@ class AdjustContrastOpv2<CPUDevice, float> : public AdjustContrastOpV2Base {
       //
       // The algorithm itself can handle size that is not power-of-two. Note
       // that in each round we sum up elements that are contiguous. So we can
-      // use their flattened structure to gain vectorinization efficiency.
+      // use their flattened structure to gain vectorization efficiency.
       do {
         int64 right_size = remaining_size / 2;
         int64 left_size = remaining_size - right_size;
@@ -324,7 +324,7 @@ class AdjustContrastOpv2<CPUDevice, float> : public AdjustContrastOpV2Base {
     // Similar to the reduction case, a straightforward implementation of this
     // does not utilize vectorization well because of the small channel size.
     // This algorithm repeatedly increases the area to be copied, and leads to
-    // much better vectorinizations in the copy.
+    // much better vectorizations in the copy.
     for (int64 i = 0; i < batch; i++) {
       // Copy over the inputs into outputs in this batch. Effectively:
       // outputs(i, :, k) = inputs(i, k). An example of how this algorithm
@@ -354,7 +354,7 @@ class AdjustContrastOpv2<CPUDevice, float> : public AdjustContrastOpV2Base {
       int64 copied = 1;
       while (copied < image_size) {
         // Repeatedly increases the number of elements to copy so they have
-        // better vectorinizations. However, the source of the copy has to be
+        // better vectorizations. However, the source of the copy has to be
         // not too large to stay in the cache.
         const int64 kMaxToCopy = 1024;
         int64 to_copy = std::min({copied, image_size - copied, kMaxToCopy});
diff --git a/tensorflow/core/kernels/batching_util/adaptive_shared_batch_scheduler.h b/tensorflow/core/kernels/batching_util/adaptive_shared_batch_scheduler.h
index b840b3ea562..b4b96675b47 100644
--- a/tensorflow/core/kernels/batching_util/adaptive_shared_batch_scheduler.h
+++ b/tensorflow/core/kernels/batching_util/adaptive_shared_batch_scheduler.h
@@ -409,7 +409,7 @@ template <typename TaskType>
 void AdaptiveSharedBatchScheduler<TaskType>::MaybeScheduleNextBatch() {
   if (batches_.empty() || in_flight_batches_ >= in_flight_batches_limit_)
     return;
-  // Non-integer limit handled probabilistially.
+  // Non-integer limit handled probabilistically.
   if (in_flight_batches_limit_ - in_flight_batches_ < 1 &&
       rand_double_(rand_engine_) >
           in_flight_batches_limit_ - in_flight_batches_) {
diff --git a/tensorflow/core/kernels/batching_util/shared_batch_scheduler.h b/tensorflow/core/kernels/batching_util/shared_batch_scheduler.h
index aa46ebf4454..a2c7cc81b54 100644
--- a/tensorflow/core/kernels/batching_util/shared_batch_scheduler.h
+++ b/tensorflow/core/kernels/batching_util/shared_batch_scheduler.h
@@ -234,7 +234,7 @@ class Queue {
   using SchedulableBatchCallback = std::function<void()>;
   Queue(const typename SharedBatchScheduler<TaskType>::QueueOptions& options,
         Env* env, ProcessBatchCallback process_batch_callback,
-        SchedulableBatchCallback schdulable_batch_callback);
+        SchedulableBatchCallback schedulable_batch_callback);
 
   // Illegal to destruct unless the queue is empty.
   ~Queue();
diff --git a/tensorflow/core/kernels/boosted_trees/quantile_ops.cc b/tensorflow/core/kernels/boosted_trees/quantile_ops.cc
index 71b06f56623..0065bdd66aa 100644
--- a/tensorflow/core/kernels/boosted_trees/quantile_ops.cc
+++ b/tensorflow/core/kernels/boosted_trees/quantile_ops.cc
@@ -104,7 +104,7 @@ class BoostedTreesCreateQuantileStreamResourceOp : public OpKernel {
   void Compute(OpKernelContext* context) override {
     // Only create one, if one does not exist already. Report status for all
     // other exceptions. If one already exists, it unrefs the new one.
-    // An epsilon value of zero could cause perfoamance issues and is therefore,
+    // An epsilon value of zero could cause performance issues and is therefore,
     // disallowed.
     const Tensor* epsilon_t;
     OP_REQUIRES_OK(context, context->input(kEpsilonName, &epsilon_t));
diff --git a/tensorflow/core/kernels/boosted_trees/quantiles/weighted_quantiles_stream.h b/tensorflow/core/kernels/boosted_trees/quantiles/weighted_quantiles_stream.h
index 20f84733a86..1e8d8d5e22d 100644
--- a/tensorflow/core/kernels/boosted_trees/quantiles/weighted_quantiles_stream.h
+++ b/tensorflow/core/kernels/boosted_trees/quantiles/weighted_quantiles_stream.h
@@ -58,7 +58,7 @@ namespace quantiles {
 // Compute: O(n * log(1/eps * log(eps * n))).
 // Memory: O(1/eps * log^2(eps * n)) <- for one worker streaming through the
 //                                      entire dataset.
-// An epsilon value of zero would make the algorithm extremely inefficent and
+// An epsilon value of zero would make the algorithm extremely inefficient and
 // therefore, is disallowed.
 template <typename ValueType, typename WeightType,
           typename CompareFn = std::less<ValueType>>
@@ -72,7 +72,7 @@ class WeightedQuantilesStream {
   explicit WeightedQuantilesStream(double eps, int64 max_elements)
       : eps_(eps), buffer_(1LL, 2LL), finalized_(false) {
     // See the class documentation. An epsilon value of zero could cause
-    // perfoamance issues.
+    // performance issues.
     QCHECK(eps > 0) << "An epsilon value of zero is not allowed.";
     std::tie(max_levels_, block_size_) = GetQuantileSpecs(eps, max_elements);
     buffer_ = Buffer(block_size_, max_elements);
diff --git a/tensorflow/core/kernels/boosted_trees/resources.cc b/tensorflow/core/kernels/boosted_trees/resources.cc
index 8217e626985..0484314f205 100644
--- a/tensorflow/core/kernels/boosted_trees/resources.cc
+++ b/tensorflow/core/kernels/boosted_trees/resources.cc
@@ -340,7 +340,7 @@ boosted_trees::Node* BoostedTreesEnsembleResource::AddLeafNodes(
         node->mutable_leaf());
   }
   node->mutable_metadata()->set_gain(candidate.gain);
-  // TODO(npononareva): this is LAYER-BY-LAYER boosting; add WHOLE-TREE.
+  // TODO(nponomareva): this is LAYER-BY-LAYER boosting; add WHOLE-TREE.
   if (logits_dimension == 1) {
     const float prev_logit_value = node->metadata().original_leaf().scalar();
     left_node->mutable_leaf()->set_scalar(prev_logit_value +
diff --git a/tensorflow/core/kernels/check_numerics_op_gpu.cu.cc b/tensorflow/core/kernels/check_numerics_op_gpu.cu.cc
index 3e417348a79..dc196af853e 100644
--- a/tensorflow/core/kernels/check_numerics_op_gpu.cu.cc
+++ b/tensorflow/core/kernels/check_numerics_op_gpu.cu.cc
@@ -55,7 +55,7 @@ __global__ void CheckNumericsKernel(const T* __restrict__ data, int size,
 }
 
 // V2 of CheckNumericsKernel for GPU.
-// Unlike CheckNumericsKernel (V1), this kernel disinguishes -Inf and +Inf.
+// Unlike CheckNumericsKernel (V1), this kernel distinguishes -Inf and +Inf.
 // The 3 elements of `abnormal_detected` are used to signify NaN, -Inf and +Inf,
 // respectively.
 template <typename T>
diff --git a/tensorflow/core/kernels/collective_nccl_broadcaster.cc b/tensorflow/core/kernels/collective_nccl_broadcaster.cc
index ceb2cfea0e2..c4081ca81c4 100644
--- a/tensorflow/core/kernels/collective_nccl_broadcaster.cc
+++ b/tensorflow/core/kernels/collective_nccl_broadcaster.cc
@@ -68,7 +68,7 @@ void NcclBroadcaster::Run(StatusCallback done) {
   {
     // When all devices at this worker have called `SignalMultiNodeReady`, the
     // `NcclManager` will enqueue the NCCL kernel on the NCCL stream.  Thus the
-    // implementation of `UnblockDepdendencies` keeps track of the number of
+    // implementation of `UnblockDependencies` keeps track of the number of
     // devices that have launched.
     profiler::TraceMe activity("Schedule", profiler::TraceMeLevel::kInfo);
     col_ctx_->col_exec->UnblockDependencies(*col_params_);
diff --git a/tensorflow/core/kernels/conv_ops_fused_impl.h b/tensorflow/core/kernels/conv_ops_fused_impl.h
index f2e1226e63c..4752a3966aa 100644
--- a/tensorflow/core/kernels/conv_ops_fused_impl.h
+++ b/tensorflow/core/kernels/conv_ops_fused_impl.h
@@ -299,7 +299,7 @@ inline int64 ConvolveScratchSize() {
   return convolve_scratch_size;
 }
 
-// Finds the best convolutiun algorithm for the given ConvLaunch (cuda
+// Finds the best convolution algorithm for the given ConvLaunch (cuda
 // convolution on the stream) and parameters, by running all possible
 // algorithms and measuring execution time.
 // TODO(ezhulenev): Move it to conv_ops_gpu.h and share with conv_ops.cc.
diff --git a/tensorflow/core/kernels/cuda_sparse.h b/tensorflow/core/kernels/cuda_sparse.h
index 6d042cf48c5..f96a9b2187c 100644
--- a/tensorflow/core/kernels/cuda_sparse.h
+++ b/tensorflow/core/kernels/cuda_sparse.h
@@ -286,7 +286,7 @@ class GpuSparse {
   //
   // **NOTE** Matrices B and C are expected to be in column-major
   // order; to make them consistent with TensorFlow they
-  // must be transposed (or the matmul op's pre/post-procesisng must take this
+  // must be transposed (or the matmul op's pre/post-processing must take this
   // into account).
   //
   // **NOTE** This is an in-place operation for data in C.
diff --git a/tensorflow/core/kernels/cwise_op_add_1.cc b/tensorflow/core/kernels/cwise_op_add_1.cc
index 6668464bac1..608fe3fa8b1 100644
--- a/tensorflow/core/kernels/cwise_op_add_1.cc
+++ b/tensorflow/core/kernels/cwise_op_add_1.cc
@@ -47,7 +47,7 @@ REGISTER_KERNEL_BUILDER(Name("AddV2")
 #if TENSORFLOW_USE_SYCL
 #define REGISTER_KERNEL(type)                          \
   REGISTER(BinaryOp, SYCL, "Add", functor::add, type); \
-  REEGISTER(BinaryOp, SYCL, "AddV2", functor::add, type);
+  REGISTER(BinaryOp, SYCL, "AddV2", functor::add, type);
 
 TF_CALL_SYCL_NUMBER_TYPES(REGISTER_KERNEL);
 
diff --git a/tensorflow/core/kernels/cwise_op_select.cc b/tensorflow/core/kernels/cwise_op_select.cc
index 54bde28ad62..af003084998 100644
--- a/tensorflow/core/kernels/cwise_op_select.cc
+++ b/tensorflow/core/kernels/cwise_op_select.cc
@@ -348,8 +348,8 @@ struct SelectScalarHandler {
   }
 };
 
-// Specilization for CPU device. Forward input to output depending on the `cond`
-// value.
+// Specialization for CPU device. Forward input to output depending on the
+// `cond` value.
 // TODO(sjhwang): Consider specializing for GPUDevice as well by using
 // GPUDevice::memcpyDeviceToHost() to fetch bool value.
 template <typename T>
diff --git a/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h b/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h
index 8cef2c07350..69119f1cca8 100644
--- a/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h
+++ b/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h
@@ -49,7 +49,7 @@ struct SimpleBinaryFunctor<GPUDevice, Functor> {
 };
 
 // Macros to explicitly instantiate kernels on GPU for multiple types
-// (T0, T1, etc.) for SimpleBiaryFunctor (e.g., functor::tanh_grad).
+// (T0, T1, etc.) for SimpleBinaryFunctor (e.g., functor::tanh_grad).
 #define DEFINE_SIMPLE_BINARY1(F, T) \
   template struct SimpleBinaryFunctor<GPUDevice, F<T> >
 #define DEFINE_SIMPLE_BINARY2(F, T0, T1) \
diff --git a/tensorflow/core/kernels/data/captured_function.cc b/tensorflow/core/kernels/data/captured_function.cc
index af51decf581..d39532c4440 100644
--- a/tensorflow/core/kernels/data/captured_function.cc
+++ b/tensorflow/core/kernels/data/captured_function.cc
@@ -910,7 +910,7 @@ Status CapturedFunction::IsMultiDevice(IteratorContext* ctx,
     const FunctionDef* fdef;
     TF_RETURN_IF_ERROR(LookupFunction(*metadata_->lib_def(), name, &fdef));
     for (const auto& node : fdef->node_def()) {
-      // Check if the op has a kernel availabe for the current device.
+      // Check if the op has a kernel available for the current device.
       if (!KernelDefAvailable(current_device_type, node)) {
         *is_multi_device = true;
         return Status::OK();
diff --git a/tensorflow/core/kernels/data/experimental/parse_example_dataset_op.cc b/tensorflow/core/kernels/data/experimental/parse_example_dataset_op.cc
index c40f8327cf1..09dd84bb402 100644
--- a/tensorflow/core/kernels/data/experimental/parse_example_dataset_op.cc
+++ b/tensorflow/core/kernels/data/experimental/parse_example_dataset_op.cc
@@ -273,12 +273,12 @@ class ParseExampleDatasetOp : public UnaryDatasetOpKernel {
       Node* input_graph_node = nullptr;
       TF_RETURN_IF_ERROR(b->AddInputDataset(ctx, input_, &input_graph_node));
 
-      Node* num_parallle_calls_node;
+      Node* num_parallel_calls_node;
       std::vector<Node*> dense_defaults_nodes;
       dense_defaults_nodes.reserve(dense_defaults_.size());
 
       TF_RETURN_IF_ERROR(
-          b->AddScalar(num_parallel_calls_, &num_parallle_calls_node));
+          b->AddScalar(num_parallel_calls_, &num_parallel_calls_node));
 
       for (const Tensor& dense_default : dense_defaults_) {
         Node* node;
@@ -336,7 +336,7 @@ class ParseExampleDatasetOp : public UnaryDatasetOpKernel {
       TF_RETURN_IF_ERROR(b->AddDataset(this,
                                        {
                                            {0, input_graph_node},
-                                           {1, num_parallle_calls_node},
+                                           {1, num_parallel_calls_node},
                                        },
                                        {{2, dense_defaults_nodes}}, attrs,
                                        output));
diff --git a/tensorflow/core/kernels/data/experimental/stats_aggregator_ops.cc b/tensorflow/core/kernels/data/experimental/stats_aggregator_ops.cc
index 25aaaac1cc6..b30cb4af95b 100644
--- a/tensorflow/core/kernels/data/experimental/stats_aggregator_ops.cc
+++ b/tensorflow/core/kernels/data/experimental/stats_aggregator_ops.cc
@@ -185,7 +185,7 @@ class StatsAggregatorImplV2 : public StatsAggregator {
       // If we create stats_aggregator twice in a program, we would end up with
       // already existing resource. In this case emitting an error if a
       // `summary_writer_resource` is present is not the intended behavior, we
-      // could either Unref the existing sumary_writer_resource or not set the
+      // could either Unref the existing summary_writer_resource or not set the
       // new resource at all.
     }
     summary_writer_interface_ = summary_writer_interface;
@@ -287,11 +287,11 @@ class StatsAggregatorSetSummaryWriterOp : public OpKernel {
     OP_REQUIRES(ctx,
                 TensorShapeUtils::IsScalar(summary_resource_handle_t.shape()),
                 errors::InvalidArgument("resource_handle must be a scalar"));
-    core::RefCountPtr<SummaryWriterInterface> sumamry_resource;
+    core::RefCountPtr<SummaryWriterInterface> summary_resource;
     OP_REQUIRES_OK(
-        ctx, LookupResource(ctx, HandleFromInput(ctx, 1), &sumamry_resource));
+        ctx, LookupResource(ctx, HandleFromInput(ctx, 1), &summary_resource));
     TF_CHECK_OK(
-        resource->stats_aggregator()->SetSummaryWriter(sumamry_resource.get()));
+        resource->stats_aggregator()->SetSummaryWriter(summary_resource.get()));
   }
 };
 
diff --git a/tensorflow/core/kernels/data/flat_map_dataset_op.cc b/tensorflow/core/kernels/data/flat_map_dataset_op.cc
index 4eeb80261a4..6d04a5b55a1 100644
--- a/tensorflow/core/kernels/data/flat_map_dataset_op.cc
+++ b/tensorflow/core/kernels/data/flat_map_dataset_op.cc
@@ -127,7 +127,7 @@ class FlatMapDatasetOp::Dataset : public DatasetBase {
           return Status::OK();
         }
         if (current_element_iterator_) {
-          // We are currently precessing a mapped element, so try to get the
+          // We are currently processing a mapped element, so try to get the
           // next subelement.
           bool end_of_element;
           TF_RETURN_IF_ERROR(current_element_iterator_->GetNext(
diff --git a/tensorflow/core/kernels/data/parallel_interleave_dataset_op.cc b/tensorflow/core/kernels/data/parallel_interleave_dataset_op.cc
index 929c7ae6ee7..ec60c5ac1f0 100644
--- a/tensorflow/core/kernels/data/parallel_interleave_dataset_op.cc
+++ b/tensorflow/core/kernels/data/parallel_interleave_dataset_op.cc
@@ -507,7 +507,7 @@ class ParallelInterleaveDatasetOp::Dataset : public DatasetBase {
       bool active GUARDED_BY(&ParallelInterleaveIterator::mu_) = false;
       // Whether the inputs and iterator have been initialized.
       bool initialized GUARDED_BY(&ParallelInterleaveIterator::mu_) = false;
-      // Whether we tried to initialize the element, but the input interator
+      // Whether we tried to initialize the element, but the input iterator
       // was exhausted so we could produce no inputs.
       bool no_input GUARDED_BY(&ParallelInterleaveIterator::mu_) = false;
       // Condition variable for communicating between current worker threads
diff --git a/tensorflow/core/kernels/data/parallel_interleave_dataset_op_test.cc b/tensorflow/core/kernels/data/parallel_interleave_dataset_op_test.cc
index 36f95931432..95a0d121f92 100644
--- a/tensorflow/core/kernels/data/parallel_interleave_dataset_op_test.cc
+++ b/tensorflow/core/kernels/data/parallel_interleave_dataset_op_test.cc
@@ -374,7 +374,7 @@ ParallelInterleaveDatasetParams ParallelInterleaveDatasetParams10() {
       /*node_name=*/kNodeName);
 }
 
-ParallelInterleaveDatasetParams LongCycleDeteriministicParams() {
+ParallelInterleaveDatasetParams LongCycleDeterministicParams() {
   auto tensor_slice_dataset_params = TensorSliceDatasetParams(
       /*components=*/{CreateTensor<tstring>(
           TensorShape{3, 3, 1}, {"a", "b", "c", "d", "e", "f", "g", "h", "i"})},
@@ -593,7 +593,7 @@ GetNextTestCases() {
                {{"a"}, {"b"}, {"c"}, {"d"}, {"e"}, {"f"}, {"g"}, {"h"}, {"i"}}),
            /*compare_order=*/false},
           {/*dataset_params=*/
-           LongCycleDeteriministicParams(),
+           LongCycleDeterministicParams(),
            /*expected_outputs=*/
            CreateTensors<tstring>(
                TensorShape{1},
diff --git a/tensorflow/core/kernels/debug_ops.h b/tensorflow/core/kernels/debug_ops.h
index 8ac9684adcc..00356778026 100644
--- a/tensorflow/core/kernels/debug_ops.h
+++ b/tensorflow/core/kernels/debug_ops.h
@@ -559,7 +559,7 @@ class DebugNumericSummaryV2Op<CPUDevice, Tin, Tout> : public OpKernel {
       output_tensor->flat<Tout>()(0) = tensor_id;
       output_tensor->flat<Tout>()(1) = num_elem;
 
-      // Accumlator value [neg_inf_count, pos_inf_count, nan_count]
+      // Accumulator value [neg_inf_count, pos_inf_count, nan_count]
       Tout fp_props[3] = {0.0, 0.0, 0.0};
       std::for_each(data, data + size, [&fp_props](const Tin& y) {
         if (TF_PREDICT_TRUE(Eigen::numext::isfinite(y))) {
@@ -588,7 +588,7 @@ class DebugNumericSummaryV2Op<CPUDevice, Tin, Tout> : public OpKernel {
       output_tensor->flat<Tout>()(3) = static_cast<Tout>(num_dims);
       output_tensor->flat<Tout>()(4) = num_elem;
 
-      // Accumlator value [neg_inf_count, pos_inf_count, nan_count, neg_count,
+      // Accumulator value [neg_inf_count, pos_inf_count, nan_count, neg_count,
       //                   zero_count, pos_count]
       Tout fp_props[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
       std::for_each(data, data + size, [&fp_props](const Tin& y) {
diff --git a/tensorflow/core/kernels/dense_update_ops.cc b/tensorflow/core/kernels/dense_update_ops.cc
index c68f1891c39..d6ac85906c0 100644
--- a/tensorflow/core/kernels/dense_update_ops.cc
+++ b/tensorflow/core/kernels/dense_update_ops.cc
@@ -98,7 +98,7 @@ typedef Eigen::SyclDevice SYCLDevice;
 
 TF_CALL_ALL_TYPES(REGISTER_KERNELS);
 TF_CALL_QUANTIZED_TYPES(REGISTER_KERNELS);
-// quint16 not included in QUANTZIED_TYPES
+// quint16 not included in QUANTIZIED_TYPES
 TF_CALL_quint16(REGISTER_KERNELS);
 #undef REGISTER_KERNELS
 
diff --git a/tensorflow/core/kernels/depthwise_conv_op.cc b/tensorflow/core/kernels/depthwise_conv_op.cc
index 7777c18ddc5..e85b6df721a 100644
--- a/tensorflow/core/kernels/depthwise_conv_op.cc
+++ b/tensorflow/core/kernels/depthwise_conv_op.cc
@@ -334,7 +334,7 @@ class DepthwiseConv2dNativeOp : public BinaryOp<T> {
     // The last dimension for filter is depth multiplier.
     const int32 depth_multiplier = filter.dim_size(3);
 
-    // The output depth is input depth x depth multipler
+    // The output depth is input depth x depth multiplier
     const int32 out_depth = in_depth * depth_multiplier;
 
     const int64 input_rows_raw = GetTensorDim(input, data_format_, 'H');
diff --git a/tensorflow/core/kernels/depthwise_conv_op.h b/tensorflow/core/kernels/depthwise_conv_op.h
index 508a25e3397..02739787934 100644
--- a/tensorflow/core/kernels/depthwise_conv_op.h
+++ b/tensorflow/core/kernels/depthwise_conv_op.h
@@ -167,7 +167,7 @@ struct DepthwiseFilterPadOp {
 
 // Copies data from local region in 'input' specified by 'out_r' and 'out_'c'
 // to 'input_buffer'. The copied data is replicated by factor
-// 'args.depth_mulitplier', and padded to vector register-width boundaries so
+// 'args.depth_multiplier', and padded to vector register-width boundaries so
 // that it is aligned for efficient traversal and vector multiply-add by the
 // depthwise kernel.
 //
diff --git a/tensorflow/core/kernels/dynamic_stitch_op.cc b/tensorflow/core/kernels/dynamic_stitch_op.cc
index 0b5e0a33379..86f9c3e4621 100644
--- a/tensorflow/core/kernels/dynamic_stitch_op.cc
+++ b/tensorflow/core/kernels/dynamic_stitch_op.cc
@@ -196,7 +196,7 @@ class DynamicStitchOpGPU : public DynamicStitchOpImplBase<T> {
 
       // data_flat index
       int32 idx = 0;
-      // sum of indices_inputs[i].NumElements() for compute indicies_flat value.
+      // sum of indices_inputs[i].NumElements() for compute indices_flat value.
       int32 base_size = 0;
       for (int i = 0; i < indices_inputs.size(); ++i) {
         auto indices_vec = indices_inputs[i].flat<int32>();
diff --git a/tensorflow/core/kernels/eigen_contraction_kernel.h b/tensorflow/core/kernels/eigen_contraction_kernel.h
index 93680f885d5..3b0dcde7a3b 100644
--- a/tensorflow/core/kernels/eigen_contraction_kernel.h
+++ b/tensorflow/core/kernels/eigen_contraction_kernel.h
@@ -431,10 +431,10 @@ struct DirectColMajorAccess {
       data = Side == Lhs ? data : data + vert_offset + horiz_offset * stride;  \
                                                                                \
       const bool is_no_op_packing = stride == rows;                            \
-      const StorageIndex adressable_mem = (stride * cols * sizeof(Scalar));    \
+      const StorageIndex addressable_mem = (stride * cols * sizeof(Scalar));   \
       const bool use_direct_access =                                           \
           is_no_op_packing || num_kernels == 1 /* used once */ ||              \
-          ((num_kernels == 2) && (adressable_mem < (256 << 10) /* 256 kb */)); \
+          ((num_kernels == 2) && (addressable_mem < (256 << 10) /* 256 kb */));\
                                                                                \
       if (use_direct_access) {                                                 \
         block->is_direct_access = true;                                        \
@@ -691,7 +691,7 @@ struct GemmKernelProvider<Eigen::QInt32, Eigen::QInt8, Eigen::QUInt8,
         /* the output mapper manually.                                      */ \
         /* WARNING(ezhulenev): This is optimized into a memset in a loop,   */ \
         /* could be much slower for small matrices. Currently this code     */ \
-        /* path used only for testing, and perormance does not matter.      */ \
+        /* path used only for testing, and performance does not matter.     */ \
         if (beta == 0.0) {                                                     \
           for (StorageIndex col = 0; col < cols; ++col) {                      \
             ResScalar* output_base = &output_mapper(0, col);                   \
diff --git a/tensorflow/core/kernels/eigen_cuboid_convolution.h b/tensorflow/core/kernels/eigen_cuboid_convolution.h
index fc65f9ef4c8..76bdc509c24 100644
--- a/tensorflow/core/kernels/eigen_cuboid_convolution.h
+++ b/tensorflow/core/kernels/eigen_cuboid_convolution.h
@@ -457,7 +457,7 @@ class TensorContractionInputMapper<
   // 'partial' packet, the elements corresponding to the row (specified through
   // rowOffset) are loaded and the rest of the elements are zero-filled into the
   // 'partial' packet. This function is called from
-  // loadPacketStandardFromSingleColumnTwoRows(). This code path is exercied
+  // loadPacketStandardFromSingleColumnTwoRows(). This code path is exercised
   // only when the packet type supports masked load and when the partial packet
   // load is available in the TensorEvaluator.
   EIGEN_DEVICE_FUNC
@@ -584,7 +584,7 @@ class TensorContractionInputMapper<
   // Load standard packet from a patch specified by the "within patch offset"
   // (patchId) and the precomputed indices of the first element of the patch.
   // This function will be called if partial packet loading is not available
-  // for the TesnorEvaluator or if the packet type does not support masked
+  // for the TensorEvaluator or if the packet type does not support masked
   // load.
   template <typename PacketT, typename TensorEvaluatorT>
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename std::enable_if<
@@ -645,7 +645,7 @@ class TensorContractionInputMapper<
   // Load standard packet from a patch specified by the "within patch offset"
   // (patchId) and the precomputed indices of the first element of the patch.
   // This function will be called if partial packet loading is available for
-  // the TesnorEvaluator and if the packet type supports masked load.
+  // the TensorEvaluator and if the packet type supports masked load.
   // The only difference between this and the other case is that if the packet
   // to load is split across two rows (but in same column), then in this case
   // instead of going to the slow (element-by-element) load, we load two packets
diff --git a/tensorflow/core/kernels/eigen_spatial_convolutions-inl.h b/tensorflow/core/kernels/eigen_spatial_convolutions-inl.h
index 62fd19a85f5..c8e7c6147aa 100644
--- a/tensorflow/core/kernels/eigen_spatial_convolutions-inl.h
+++ b/tensorflow/core/kernels/eigen_spatial_convolutions-inl.h
@@ -363,7 +363,7 @@ class TensorContractionInputMapper<
   // the elements corresponding to the column (specified through colOffset) are
   // loaded and the rest of the elements are zero-filled into the 'partial'
   // packet. This function is called from loadPacketStandardFromTwoColumns().
-  // This code path is exercied only when the packet type supports masked load
+  // This code path is exercised only when the packet type supports masked load
   // and when the partial packet load is available in the TensorEvaluator.
   EIGEN_DEVICE_FUNC
   EIGEN_ALWAYS_INLINE Packet loadPartialPacketStandard(
@@ -476,7 +476,7 @@ class TensorContractionInputMapper<
   // Load standard packet from a patch specified by the "within patch offset"
   // (patchId) and the precomputed indices of the first element of the patch.
   // This function will be called if partial packet loading is not available
-  // for the TesnorEvaluator or if the packet type does not support masked
+  // for the TensorEvaluator or if the packet type does not support masked
   // load.
   template <typename PacketT, typename TensorEvaluatorT>
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename std::enable_if<
@@ -518,7 +518,7 @@ class TensorContractionInputMapper<
   // Load standard packet from a patch specified by the "within patch offset"
   // (patchId) and the precomputed indices of the first element of the patch.
   // This function will be called if partial packet loading is available for
-  // the TesnorEvaluator and if the packet type supports masked load.
+  // the TensorEvaluator and if the packet type supports masked load.
   // The only difference between this and the other case is that if the packet
   // to load is split across two columns, then in this case instead of going to
   // the slow (element-by-element) load, we load two packets - each containing
diff --git a/tensorflow/core/kernels/eigen_volume_patch.h b/tensorflow/core/kernels/eigen_volume_patch.h
index 80ab745bfec..bb71919838b 100644
--- a/tensorflow/core/kernels/eigen_volume_patch.h
+++ b/tensorflow/core/kernels/eigen_volume_patch.h
@@ -565,7 +565,7 @@ struct CustomTensorEvaluator {
 
   Dimensions m_dimensions;
 
-  // Parameters passed to the costructor.
+  // Parameters passed to the constructor.
   Index m_plane_strides;
   Index m_row_strides;
   Index m_col_strides;
diff --git a/tensorflow/core/kernels/gather_functor_batched.h b/tensorflow/core/kernels/gather_functor_batched.h
index ee94fdf6690..5b61448bdae 100644
--- a/tensorflow/core/kernels/gather_functor_batched.h
+++ b/tensorflow/core/kernels/gather_functor_batched.h
@@ -155,7 +155,7 @@ struct GatherFunctorBatchedCPU {
   } while (0)
 
     // TODO(rmlarsen): Investigate whether these specializations are still
-    // needed and, if yes, whether the slice sizes are apropriate.
+    // needed and, if yes, whether the slice sizes are appropriate.
     if (slice_size == 10)
       CALL(10);
     else if (slice_size == 20)
diff --git a/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h b/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h
index 24c23f1f900..e1e6472d363 100644
--- a/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h
+++ b/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h
@@ -118,7 +118,7 @@ struct GatherFunctorBatched<GPUDevice, T, Index> {
         params.data(), indices.data(), out.data(),
         outer_size, gather_dim_size, indices_size, slice_size, out_size));
     // TODO(fpmc): enable indices validation on GPU.
-    // Right now checking for indicies out of bound in the kernel would
+    // Right now checking for indices out of bound in the kernel would
     // require copying code between GPU/CPU, and thus slow.
     return -1;
   }
diff --git a/tensorflow/core/kernels/gather_functor_gpu.cu.h b/tensorflow/core/kernels/gather_functor_gpu.cu.h
index 0a3ecea8b5f..1cadee41a88 100644
--- a/tensorflow/core/kernels/gather_functor_gpu.cu.h
+++ b/tensorflow/core/kernels/gather_functor_gpu.cu.h
@@ -105,7 +105,7 @@ struct GatherFunctor<GPUDevice, T, Index> {
           out.data(), gather_dim_size, indices_size, slice_size, out_size));
     }
     // TODO(fpmc): enable indices validation on GPU.
-    // Right now checking for indicies out of bound in the kernel would
+    // Right now checking for indices out of bound in the kernel would
     // require copying code between GPU/CPU, and thus slow.
     return -1;
   }
diff --git a/tensorflow/core/kernels/gpu_utils.h b/tensorflow/core/kernels/gpu_utils.h
index 72f4a25596a..51cee491058 100644
--- a/tensorflow/core/kernels/gpu_utils.h
+++ b/tensorflow/core/kernels/gpu_utils.h
@@ -238,7 +238,7 @@ void LogFusedConvForwardAutotuneResults(
     se::StreamExecutor* stream_exec, absl::Span<const AutotuneResult> results);
 
 // Returns the best algorithms for the config, one is the fastest, the other is
-// other is fastest with 0 scracth space. Unsuccessful autotuning results are
+// other is fastest with 0 scratch space. Unsuccessful autotuning results are
 // allowed and ignored.
 Status BestCudnnConvAlgorithm(absl::Span<const AutotuneResult> results,
                               se::dnn::AlgorithmConfig* algo);
diff --git a/tensorflow/core/kernels/hexagon/hexagon_ops_definitions.cc b/tensorflow/core/kernels/hexagon/hexagon_ops_definitions.cc
index 8e517dc93c2..c14a74e0bc1 100644
--- a/tensorflow/core/kernels/hexagon/hexagon_ops_definitions.cc
+++ b/tensorflow/core/kernels/hexagon/hexagon_ops_definitions.cc
@@ -98,7 +98,7 @@ enum class HexagonOpsDefinitions::SupportedOpType {
   ADD_F,
   MUL_F,
   MINIMUM_F,
-  MAXIMAM_F,
+  MAXIMUM_F,
 
   REQUANTIZE_32_TO_8,
   REQUANTIZE_32_TO_8_REF,
@@ -234,7 +234,7 @@ enum class HexagonOpsDefinitions::SupportedOpType {
   ADD_F,
   MUL_F,
   MINIMUM_F,
-  MAXIMAM_F,
+  MAXIMUM_F,
 
   REQUANTIZE_32_TO_8,
   REQUANTIZE_32_TO_8_REF,
diff --git a/tensorflow/core/kernels/hinge-loss.h b/tensorflow/core/kernels/hinge-loss.h
index b12910d27da..c90f7b8cb3a 100644
--- a/tensorflow/core/kernels/hinge-loss.h
+++ b/tensorflow/core/kernels/hinge-loss.h
@@ -43,7 +43,7 @@ class HingeLossUpdater : public DualLossUpdater {
                             const double example_weight,
                             const double current_dual, const double wx,
                             const double weighted_example_norm) const final {
-    // Intutitvely there are 3 cases:
+    // Intuitively there are 3 cases:
     // a. new optimal value of the dual variable falls within the admissible
     // range [0, 1]. In this case we set new dual to this value.
     // b. new optimal value is < 0. Then, because of convexity, the optimal
diff --git a/tensorflow/core/kernels/logistic-loss.h b/tensorflow/core/kernels/logistic-loss.h
index 5f1b117f338..54738a55ecc 100644
--- a/tensorflow/core/kernels/logistic-loss.h
+++ b/tensorflow/core/kernels/logistic-loss.h
@@ -43,7 +43,7 @@ class LogisticLossUpdater : public DualLossUpdater {
     return 0.5 * (1 + tanh(x)) / label;
   }
 
-  // Dual of logisitic loss function.
+  // Dual of logistic loss function.
   // https://en.wikipedia.org/wiki/Convex_conjugate
   double ComputeDualLoss(const double current_dual, const double example_label,
                          const double example_weight) const final {
diff --git a/tensorflow/core/kernels/loss_test.cc b/tensorflow/core/kernels/loss_test.cc
index 9209ed2ab72..cc5e1cd9cc7 100644
--- a/tensorflow/core/kernels/loss_test.cc
+++ b/tensorflow/core/kernels/loss_test.cc
@@ -213,7 +213,7 @@ TEST(HingeLoss, ConvertLabel) {
 TEST(HingeLoss, ComputeUpdatedDual) {
   HingeLossUpdater loss_updater;
   // For the two tests belows, y*wx=1 after the update which is a
-  // non-differetiable point of the hinge loss and TestComputeUpdatedDual
+  // non-differentiable point of the hinge loss and TestComputeUpdatedDual
   // cannot be used. Check value of the dual variable instead.
   EXPECT_NEAR(0.507,
               loss_updater.ComputeUpdatedDual(
diff --git a/tensorflow/core/kernels/matmul_op.cc b/tensorflow/core/kernels/matmul_op.cc
index 91ea7a84d78..148540a3d82 100644
--- a/tensorflow/core/kernels/matmul_op.cc
+++ b/tensorflow/core/kernels/matmul_op.cc
@@ -122,7 +122,7 @@ struct LaunchMatMulBase {
   static void launch(
       OpKernelContext* ctx, const Tensor& a, const Tensor& b,
       const Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1>& dim_pair,
-      std::vector<AlgorithmType>* algorithms, bool use_aututone, Tensor* out) {
+      std::vector<AlgorithmType>* algorithms, bool use_autotune, Tensor* out) {
 #ifndef TENSORFLOW_USE_SYCL
     // An explicit vector-matrix multiply is much better optimized than an
     // implicit one and this is a bottleneck during non-batched inference.
diff --git a/tensorflow/core/kernels/mkl_aggregate_ops.cc b/tensorflow/core/kernels/mkl_aggregate_ops.cc
index 139389d71e1..21be643eaa5 100644
--- a/tensorflow/core/kernels/mkl_aggregate_ops.cc
+++ b/tensorflow/core/kernels/mkl_aggregate_ops.cc
@@ -180,7 +180,7 @@ class MklAddNOp : public OpKernel {
 
       // Create memory descriptor for MKL-DNN.
       // If all input in Tensorflow format, create block memory descriptor,
-      // else convet TF format to MKL memory descriptor
+      // else convert TF format to MKL memory descriptor
       for (int src_idx = 0; src_idx < num_inputs; ++src_idx) {
         MklDnnShape src_mkl_shape;
         GetMklShape(ctx, src_idx, &src_mkl_shape);
diff --git a/tensorflow/core/kernels/mkl_conv_grad_filter_ops.cc b/tensorflow/core/kernels/mkl_conv_grad_filter_ops.cc
index 71d59fb7971..52a24e18f2e 100644
--- a/tensorflow/core/kernels/mkl_conv_grad_filter_ops.cc
+++ b/tensorflow/core/kernels/mkl_conv_grad_filter_ops.cc
@@ -501,7 +501,7 @@ class MklConvCustomBackpropFilterOp
           dilations, padding_left, padding_right,
           TFPaddingToMklDnnPadding(this->padding_));
 
-      // MKL-DNN allocates large buffers when a conv gradient filter primtive is
+      // MKL-DNN allocates large buffers when a conv gradient filter primitive is
       // created. So we don't cache conv backward primitives when the env
       // variable TF_MKL_OPTIMIZE_PRIMITIVE_MEMUSE is set to true.
       bool do_not_cache = MklPrimitiveFactory<T>::IsPrimitiveMemOptEnabled();
diff --git a/tensorflow/core/kernels/mkl_conv_grad_input_ops.cc b/tensorflow/core/kernels/mkl_conv_grad_input_ops.cc
index cf0683ffd4c..a162dbb364e 100644
--- a/tensorflow/core/kernels/mkl_conv_grad_input_ops.cc
+++ b/tensorflow/core/kernels/mkl_conv_grad_input_ops.cc
@@ -447,8 +447,8 @@ class MklConvCustomBackpropInputOp
           TFPaddingToMklDnnPadding(this->padding_));
 
       // We don't cache those primitives if the environment variable
-      // TF_MKL_OPTIMIZE_PRIMITIVE_MEMUSE is true and if primitve descriptor
-      // includes potentialy large buffers. MKL-DNN allocates buffers
+      // TF_MKL_OPTIMIZE_PRIMITIVE_MEMUSE is true and if primitive descriptor
+      // includes potentially large buffers. MKL-DNN allocates buffers
       // in the following cases
       //   1. Legacy CPU without AVX512/AVX2, or
       //   2. 1x1 convolution with stride != 1
diff --git a/tensorflow/core/kernels/mkl_conv_ops.cc b/tensorflow/core/kernels/mkl_conv_ops.cc
index a7cc178bf86..70197278fa7 100644
--- a/tensorflow/core/kernels/mkl_conv_ops.cc
+++ b/tensorflow/core/kernels/mkl_conv_ops.cc
@@ -834,7 +834,7 @@ class MklConvOp : public OpKernel {
       pad_right = paddings[7];
     }
     // Create padding arrays for MKL-DNN convolutions.
-    // MKL-DNN uses asymetric padding.
+    // MKL-DNN uses asymmetric padding.
     padding_left = {static_cast<int>(pad_top), static_cast<int>(pad_left)};
     padding_right = {static_cast<int>(pad_bottom), static_cast<int>(pad_right)};
   }
@@ -857,7 +857,7 @@ class MklConvOp : public OpKernel {
 
   // This method is for the base class MklConvOp, which handles the
   // floating point implementation of Conv. The quantized conv implementations
-  // will use overidden versions of this method.
+  // will use overridden versions of this method.
   virtual void ExtendConvFwdParams(OpKernelContext* context,
                                    MklConvFwdParams& params) {
     // Create a string from data types of input, filter, bias, and output.
diff --git a/tensorflow/core/kernels/mkl_conv_ops.h b/tensorflow/core/kernels/mkl_conv_ops.h
index 4e6f64c56b0..4c3cac70956 100644
--- a/tensorflow/core/kernels/mkl_conv_ops.h
+++ b/tensorflow/core/kernels/mkl_conv_ops.h
@@ -455,7 +455,7 @@ class MklDnnConvUtil {
     // Tensorflow output is in data_format order.
     //     Conv2D: NHWC or NCHW
     //     Conv3D: NDHWC or NCDHW
-    // MKL-DNN uses asymetric padding.
+    // MKL-DNN uses asymmetric padding.
     TensorShape out_shape =
         is_conv2d
             ? ShapeFromFormat(data_format_, out_batch, out_rows, out_cols,
diff --git a/tensorflow/core/kernels/mkl_qmatmul_op.cc b/tensorflow/core/kernels/mkl_qmatmul_op.cc
index 1ee01bfa85c..324101fdd41 100644
--- a/tensorflow/core/kernels/mkl_qmatmul_op.cc
+++ b/tensorflow/core/kernels/mkl_qmatmul_op.cc
@@ -62,7 +62,7 @@ limitations under the License.
 // where, 1 denotes a row vector matching the outermost dim of Wf32.
 //
 // The QuantizedMatMulWithBias op calculates 32bit integer output as below:
-//  - with SCALE activation quantizaiton:
+//  - with SCALE activation quantization:
 //    Xs32 = Au8 * Ws8 + 1' * Bs32
 //         = Qa * Qw * Af32 * Wf32  + Qa * Qw * 1' * Bf32
 //         = Qa * Qw * (Af32 * Wf32 + 1' * Bf32) = Qa * Qw * Xf32,
diff --git a/tensorflow/core/kernels/mkl_qmatmul_op_test.cc b/tensorflow/core/kernels/mkl_qmatmul_op_test.cc
index 038d875ff5e..10cce07be34 100644
--- a/tensorflow/core/kernels/mkl_qmatmul_op_test.cc
+++ b/tensorflow/core/kernels/mkl_qmatmul_op_test.cc
@@ -45,7 +45,7 @@ class ConvMklToTF : public OpsTestBase {
   template <typename T>
   void ConvertMKL2TF(DataType dtype, const Tensor& first, const Tensor& second,
                      Tensor& output) {
-    // TO-DO : Has to be moved to common uitility file
+    // TO-DO : Has to be moved to common utility file
     // Create an MKL to TF conversion node and execute it
     TF_EXPECT_OK(NodeDefBuilder("mkl_to_tf_op", "_MklToTf")
                      .Input(FakeInput(dtype))     // Input
diff --git a/tensorflow/core/kernels/mkl_relu_op.cc b/tensorflow/core/kernels/mkl_relu_op.cc
index d20b72d879a..a2cbd5e3019 100644
--- a/tensorflow/core/kernels/mkl_relu_op.cc
+++ b/tensorflow/core/kernels/mkl_relu_op.cc
@@ -120,7 +120,7 @@ class MklEltwiseFwdPrimitive : public MklPrimitive {
     std::shared_ptr<memory> src_mem;
     std::shared_ptr<memory> dst_mem;
 
-    // desc & prmitive desc
+    // desc & primitive desc
     std::shared_ptr<mkldnn::eltwise_forward::desc> fwd_desc;
     std::shared_ptr<EltwiseFwdPd> fwd_pd;
 
@@ -561,9 +561,13 @@ class MklReluOpBase : public OpKernel {
       MklEltwiseFwdPrimitive<T>* eltwise_fwd =
           MklEltwiseFwdPrimitiveFactory<T>::Get(fwdParams);
 
+<<<<<<< HEAD
       auto eltwise_fwd_pd = eltwise_fwd->GetEltwiseFwdPd();
 
       // Check if src needs to be reordered
+=======
+      // prepare for execution
+>>>>>>> minor spelling tweaks
       const T* src_data = src_tensor.flat<T>().data();
       if (IS_SRC_REORDER_NEEDED(src_md, eltwise_fwd_pd, eltwise_fwd)) {
         src.SetUsrMem(src_md, &src_tensor);
diff --git a/tensorflow/core/kernels/neon/depthwiseconv_float.h b/tensorflow/core/kernels/neon/depthwiseconv_float.h
index 0d5a42bf10d..5e12d913963 100644
--- a/tensorflow/core/kernels/neon/depthwiseconv_float.h
+++ b/tensorflow/core/kernels/neon/depthwiseconv_float.h
@@ -450,33 +450,33 @@ void FloatDepthwiseConvAccumRow(int stride, int input_depth, int input_width,
   for (int filter_x = 0; filter_x < filter_width; ++filter_x) {
     // For the current (filter_x, filter_y) point in the filter,
     // compute the boundaries of the corresponding output row segment.
-    int out_x_loop_start_unclampled = 0;
-    int out_x_loop_end_unclampled = 0;
+    int out_x_loop_start_unclamped = 0;
+    int out_x_loop_end_unclamped = 0;
     if (kAllowStrided) {
       if (stride == 2) {
-        out_x_loop_start_unclampled = (pad_width - filter_x + 1) / 2;
-        out_x_loop_end_unclampled =
+        out_x_loop_start_unclamped = (pad_width - filter_x + 1) / 2;
+        out_x_loop_end_unclamped =
             (pad_width + input_width - filter_x + 1) / 2;
       } else if (stride == 4) {
-        out_x_loop_start_unclampled = (pad_width - filter_x + 3) / 4;
-        out_x_loop_end_unclampled =
+        out_x_loop_start_unclamped = (pad_width - filter_x + 3) / 4;
+        out_x_loop_end_unclamped =
             (pad_width + input_width - filter_x + 3) / 4;
       } else {
-        out_x_loop_start_unclampled =
+        out_x_loop_start_unclamped =
             (pad_width - filter_x + stride - 1) / stride;
-        out_x_loop_end_unclampled =
+        out_x_loop_end_unclamped =
             (pad_width + input_width - filter_x + stride - 1) / stride;
       }
     } else {
-      out_x_loop_start_unclampled = pad_width - filter_x;
-      out_x_loop_end_unclampled = pad_width + input_width - filter_x;
+      out_x_loop_start_unclamped = pad_width - filter_x;
+      out_x_loop_end_unclamped = pad_width + input_width - filter_x;
     }
     // The kernel will have to iterate on the segment of the
     // output row that starts at out_x_loop_start and out_x_loop_end.
     const int out_x_loop_start =
-        std::max(out_x_buffer_start, out_x_loop_start_unclampled);
+        std::max(out_x_buffer_start, out_x_loop_start_unclamped);
     const int out_x_loop_end =
-        std::min(out_x_buffer_end, out_x_loop_end_unclampled);
+        std::min(out_x_buffer_end, out_x_loop_end_unclamped);
 
     float* acc_buffer_ptr =
         acc_buffer + (out_x_loop_start - out_x_buffer_start) * output_depth;
diff --git a/tensorflow/core/kernels/pooling_ops_common.h b/tensorflow/core/kernels/pooling_ops_common.h
index ef7f0cefc09..2aa1d0b6de0 100644
--- a/tensorflow/core/kernels/pooling_ops_common.h
+++ b/tensorflow/core/kernels/pooling_ops_common.h
@@ -605,7 +605,7 @@ void SpatialAvgPool(OpKernelContext* context, Tensor* output,
   // NOTE: Constants in calculation below were estimated based on benchmarking.
   // Nanoseconds/work_unit for benchmarks ranged from 0.01 to 0.001, and
   // so the factor 0.01 (i.e. 1/100) with a max of 10000, was chosen to limit
-  // the work unit cost to an operating range in which it emperically performed
+  // the work unit cost to an operating range in which it empirically performed
   // best.
   const int64 work_unit_cost = std::max(int64{10000}, work_unit_size / 100);
   const DeviceBase::CpuWorkerThreads& worker_threads =
diff --git a/tensorflow/core/kernels/quantized_resize_bilinear_op.cc b/tensorflow/core/kernels/quantized_resize_bilinear_op.cc
index 59e33d1ac31..4da56cde547 100644
--- a/tensorflow/core/kernels/quantized_resize_bilinear_op.cc
+++ b/tensorflow/core/kernels/quantized_resize_bilinear_op.cc
@@ -39,7 +39,7 @@ template <typename T_SCALE>
 struct InterpolationCache {
   std::vector<int64> lower;  // Lower source index used in the interpolation
   std::vector<int64> upper;  // Upper source index used in the interpolation
-  // 1-D linear iterpolation scale (see:
+  // 1-D linear interpolation scale (see:
   // https://en.wikipedia.org/wiki/Bilinear_interpolation)
   std::vector<float> lerp;
   std::vector<T_SCALE> ilerp;
diff --git a/tensorflow/core/kernels/quantized_resize_bilinear_op_test.cc b/tensorflow/core/kernels/quantized_resize_bilinear_op_test.cc
index a7931cb4510..6e359b08f31 100644
--- a/tensorflow/core/kernels/quantized_resize_bilinear_op_test.cc
+++ b/tensorflow/core/kernels/quantized_resize_bilinear_op_test.cc
@@ -395,7 +395,7 @@ void RunBenchmarkResizeBilinearTwoDims() {
 }  // namespace tensorflow
 
 #define RUN_TEST(t) \
-  TEST(QuantizationResizeBilenarTest, t) { tensorflow::t(); }
+  TEST(QuantizationResizeBilinearTest, t) { tensorflow::t(); }
 
 RUN_TEST(TestResizeBilinearOneDim);
 RUN_TEST(TestResizeBilinearTwoDims);
diff --git a/tensorflow/core/kernels/random_op_cpu.h b/tensorflow/core/kernels/random_op_cpu.h
index cf8594e4752..0e24bc3a54b 100644
--- a/tensorflow/core/kernels/random_op_cpu.h
+++ b/tensorflow/core/kernels/random_op_cpu.h
@@ -68,7 +68,7 @@ struct FillPhiloxRandom {
         ctx, false,
         errors::Internal(
             "Default `FillPhiloxRandom` implementation should not be executed. "
-            "The cause of this error is probabily that `FillPhiloxRandom` does "
+            "The cause of this error is probably that `FillPhiloxRandom` does "
             "not support this device or random distribution yet."));
   }
 };
diff --git a/tensorflow/core/kernels/record_yielder.h b/tensorflow/core/kernels/record_yielder.h
index 4efef6c4366..84a035deee3 100644
--- a/tensorflow/core/kernels/record_yielder.h
+++ b/tensorflow/core/kernels/record_yielder.h
@@ -38,7 +38,7 @@ namespace tensorflow {
 //   2) each record is yielded only once within every epoch;
 //   3) the order in which records are yielded is highly randomized.
 //   4) the peak memory usage is roughly avg record size *
-//      (opts.bufsize + opts.parellelism * 16).
+//      (opts.bufsize + opts.parallelism * 16).
 //
 // Usage example:
 //   RecordYielder::Options opts;
diff --git a/tensorflow/core/kernels/remote_fused_graph_execute_utils.cc b/tensorflow/core/kernels/remote_fused_graph_execute_utils.cc
index 5e01f4d2d33..b57d6163cac 100644
--- a/tensorflow/core/kernels/remote_fused_graph_execute_utils.cc
+++ b/tensorflow/core/kernels/remote_fused_graph_execute_utils.cc
@@ -510,7 +510,7 @@ RemoteFusedGraphExecuteUtils::AddOutputTensorShapeTypeByTensorShapeMap(
         tensor_shape_map->emplace(node_name,
                                   std::make_pair(j, std::make_pair(dt, ts)));
       } else {
-        return errors::InvalidArgument("Graph contains unknow shapes");
+        return errors::InvalidArgument("Graph contains unknown shapes");
       }
     }
   }
diff --git a/tensorflow/core/kernels/resize_bicubic_op.cc b/tensorflow/core/kernels/resize_bicubic_op.cc
index 64a7e400af1..48bd1986b7b 100644
--- a/tensorflow/core/kernels/resize_bicubic_op.cc
+++ b/tensorflow/core/kernels/resize_bicubic_op.cc
@@ -169,22 +169,22 @@ class CachedInterpolationCalculator {
                      const int64 x_3) {
     // We use 2 hands and walk through, copying from one to another where
     // we already have values.
-    // Invariant, new_indicies_hand <= cached_values_hand
+    // Invariant, new_indices_hand <= cached_values_hand
     const std::array<int64, 4> new_x_indices{{x_0, x_1, x_2, x_3}};
     int cached_values_hand = 0;
-    int new_indicies_hand = 0;
+    int new_indices_hand = 0;
     while (cached_values_hand < 4) {
-      if (indexes_[cached_values_hand] == new_x_indices[new_indicies_hand]) {
-        if (new_indicies_hand < cached_values_hand) {
-          indexes_[new_indicies_hand] = indexes_[cached_values_hand];
+      if (indexes_[cached_values_hand] == new_x_indices[new_indices_hand]) {
+        if (new_indices_hand < cached_values_hand) {
+          indexes_[new_indices_hand] = indexes_[cached_values_hand];
         }
         cached_values_hand++;
-        new_indicies_hand++;
+        new_indices_hand++;
       } else {
         cached_values_hand++;
       }
     }
-    switch (new_indicies_hand) {
+    switch (new_indices_hand) {
       case 0:
         indexes_[0] = x_0;
         TF_FALLTHROUGH_INTENDED;
@@ -198,7 +198,7 @@ class CachedInterpolationCalculator {
         indexes_[3] = x_3;
         break;
     }
-    return new_indicies_hand;
+    return new_indices_hand;
   }
 
  private:
diff --git a/tensorflow/core/kernels/resize_bilinear_op.cc b/tensorflow/core/kernels/resize_bilinear_op.cc
index 3cf13a2fd54..57c39d1ce53 100644
--- a/tensorflow/core/kernels/resize_bilinear_op.cc
+++ b/tensorflow/core/kernels/resize_bilinear_op.cc
@@ -71,7 +71,7 @@ namespace {
 struct CachedInterpolation {
   int64 lower;  // Lower source index used in the interpolation
   int64 upper;  // Upper source index used in the interpolation
-  // 1-D linear iterpolation scale (see:
+  // 1-D linear interpolation scale (see:
   // https://en.wikipedia.org/wiki/Bilinear_interpolation)
   float lerp;
 };
@@ -311,7 +311,7 @@ struct ResizeBilinearGrad<CPUDevice, T> {
 
     // Each resized output pixel was computed as a weighted average of four
     // input pixels. Here we find the four input pixel locations that
-    // contributed to each output pixel and propgate the gradient at the output
+    // contributed to each output pixel and propagate the gradient at the output
     // pixel location to each of those four input pixel locations in the same
     // proportions that they originally contributed to the output pixel.
     // Here is the forward-propagation pseudo-code, for reference:
diff --git a/tensorflow/core/kernels/resource_variable_ops.cc b/tensorflow/core/kernels/resource_variable_ops.cc
index 80ca00388ff..6a1cf9e570c 100644
--- a/tensorflow/core/kernels/resource_variable_ops.cc
+++ b/tensorflow/core/kernels/resource_variable_ops.cc
@@ -720,7 +720,7 @@ class ResourceGatherOp : public OpKernel {
   }
 
  private:
-  // Add the batch offset derrived from params to each batch of indices.
+  // Add the batch offset derived from params to each batch of indices.
   // Example: batch_dims = 1, indices = [[0, 1, 2], [0, 1, 2]]
   // If indexing into a params dimension of size 4, then the indices will become
   // [0, 1, 2, 4, 5, 6]
diff --git a/tensorflow/core/kernels/rnn/gru_ops.cc b/tensorflow/core/kernels/rnn/gru_ops.cc
index fbeaf3c7810..8735e57c529 100644
--- a/tensorflow/core/kernels/rnn/gru_ops.cc
+++ b/tensorflow/core/kernels/rnn/gru_ops.cc
@@ -341,11 +341,11 @@ class GRUBlockCellGradOp : public OpKernel {
                                            TensorShape({batch_size, cell_size}),
                                            &d_h_prevr_tensor));
 
-    Tensor d_x_component_1_h_prev_compenent_1;
+    Tensor d_x_component_1_h_prev_component_1;
     OP_REQUIRES_OK(ctx, ctx->allocate_temp(
                             DataTypeToEnum<T>::v(),
                             TensorShape({batch_size, input_size + cell_size}),
-                            &d_x_component_1_h_prev_compenent_1));
+                            &d_x_component_1_h_prev_component_1));
 
     Tensor d_x_component_2_h_prevr;
     OP_REQUIRES_OK(ctx, ctx->allocate_temp(
@@ -365,7 +365,7 @@ class GRUBlockCellGradOp : public OpKernel {
         d_c_bar_tensor->matrix<T>(), d_r_bar_u_bar_tensor->matrix<T>(),
         d_r_bar_tensor.matrix<T>(), d_u_bar_tensor.matrix<T>(),
         d_h_prevr_tensor.matrix<T>(),
-        d_x_component_1_h_prev_compenent_1.matrix<T>(),
+        d_x_component_1_h_prev_component_1.matrix<T>(),
         d_x_component_2_h_prevr.matrix<T>());
   }
 };
diff --git a/tensorflow/core/kernels/roll_op.cc b/tensorflow/core/kernels/roll_op.cc
index 06e5ae1ff87..120dd9681ff 100644
--- a/tensorflow/core/kernels/roll_op.cc
+++ b/tensorflow/core/kernels/roll_op.cc
@@ -166,7 +166,7 @@ void DoRoll(const OpKernelContext* context, const int64 num_elements,
   };
   // Shard
   auto worker_threads = context->device()->tensorflow_cpu_worker_threads();
-  // 15 - expiramentally determined with float and bool types
+  // 15 - experimentally determined with float and bool types
   const int cost_per_element = 15 * sizeof(T);  // rough estimate
   Shard(worker_threads->num_threads, worker_threads->workers, num_elements,
         cost_per_element, std::move(work));
@@ -210,11 +210,11 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
     out_ptr += start;
 
     // array of indices for each dimension
-    // indicies = [i, j, k, l, m, n]
-    gtl::InlinedVector<int, 4> indicies(num_dims);
+    // indices = [i, j, k, l, m, n]
+    gtl::InlinedVector<int, 4> indices(num_dims);
     // the offset needed to make all inner non-shifting dimensions become 0
     int64 remainder_offset = 0;
-    // initialize indicies
+    // initialize indices
     for (int i = 0; i < num_dims; i++) {
       // stride is the number of indices over in the flattened tensor
       // you need to skip in order to make it over to an adjacent element
@@ -222,7 +222,7 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
       const int64 stride = dim_range[i] / dim_size[i];
       const int shift = dim_size[i] - threshold[i];
       const int indx = (start / stride) % dim_size[i];
-      indicies[i] = indx;
+      indices[i] = indx;
       // calculate dimension index after the shift
       int out_indx = (indx + shift) % dim_size[i];
       if (i > isd) {
@@ -233,7 +233,7 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
       out_ptr += (out_indx - indx) * stride;
     }
     // set trailing zeroes for indices after the inner shifted dimension
-    for (int i = num_dims - 1; i > isd; i--) indicies[i] = 0;
+    for (int i = num_dims - 1; i > isd; i--) indices[i] = 0;
 
     // the number of indices in the isd dimension the next group will skip
     // to make it to the next threshold or end point
@@ -241,11 +241,11 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
     // the size of the next group
     int64 group_size = 0;
     // initialize isd_indx_skip and group_size
-    if (indicies[isd] < threshold[isd]) {
-      isd_indx_skip = threshold[isd] - indicies[isd];
+    if (indices[isd] < threshold[isd]) {
+      isd_indx_skip = threshold[isd] - indices[isd];
       group_size = isd_indx_skip * isd_stride + remainder_offset;
     } else {
-      isd_indx_skip = dim_size[isd] - indicies[isd];
+      isd_indx_skip = dim_size[isd] - indices[isd];
       group_size = isd_indx_skip * isd_stride + remainder_offset;
     }
 
@@ -265,13 +265,13 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
       // all dimensions to the left increment by 1 when a digit is carried
       // all dimensions to the right remain set to 0
       //            +1 +1 +1 +isd_indx_skip
-      // indicies = [i, j, k, l, 0, 0]
+      // indices = [i, j, k, l, 0, 0]
       //                      ^isd
       for (int j = isd; j >= 0; j--) {
         int inc = 1;
         if (j == isd) inc = isd_indx_skip;
-        const int indx = (indicies[j] + inc) % dim_size[j];
-        indicies[j] = indx;
+        const int indx = (indices[j] + inc) % dim_size[j];
+        indices[j] = indx;
         if (indx != 0) {
           if (indx == threshold[j]) {
             out_ptr -= dim_range[j];  // now wraps around
@@ -283,11 +283,11 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
       }
 
       // set isd_indx_skip and group_size for next iteration
-      if (indicies[isd] < threshold[isd]) {
-        isd_indx_skip = threshold[isd] - indicies[isd];
+      if (indices[isd] < threshold[isd]) {
+        isd_indx_skip = threshold[isd] - indices[isd];
         group_size = isd_indx_skip * isd_stride;
       } else {
-        isd_indx_skip = dim_size[isd] - indicies[isd];
+        isd_indx_skip = dim_size[isd] - indices[isd];
         group_size = isd_indx_skip * isd_stride;
       }
     }
@@ -296,7 +296,7 @@ void DoRollWithMemcpy(const OpKernelContext* context, const int64 num_elements,
   auto worker_threads = context->device()->tensorflow_cpu_worker_threads();
   const int64 ave_group_size = dim_range[isd] / 2;
   const int total_work = 2 * num_elements / std::max<int>(dim_range[isd], 1);
-  // 25000 - expiramentally determined with float and bool types
+  // 25000 - experimentally determined with float and bool types
   const int cost_per_group = 25000 * sizeof(T) * ave_group_size;
   Shard(worker_threads->num_threads, worker_threads->workers, total_work,
         cost_per_group, std::move(work));
diff --git a/tensorflow/core/kernels/sdca_internal.h b/tensorflow/core/kernels/sdca_internal.h
index 1eff4b15faa..8bdfeb1a7e5 100644
--- a/tensorflow/core/kernels/sdca_internal.h
+++ b/tensorflow/core/kernels/sdca_internal.h
@@ -208,7 +208,7 @@ class FeatureWeightsDenseStorage {
   // Nominals here are the original weight matrix.
   TTypes<const float>::Matrix nominals() const { return nominals_; }
 
-  // Delta weights durining mini-batch updates.
+  // Delta weights during mini-batch updates.
   TTypes<float>::Matrix deltas() const { return deltas_; }
 
   // Updates delta weights based on active dense features in the example and
@@ -251,7 +251,7 @@ class FeatureWeightsSparseStorage {
     return nominals_(class_id, it->second);
   }
 
-  // Delta weights durining mini-batch updates.
+  // Delta weights during mini-batch updates.
   float deltas(const int class_id, const int64 index) const {
     auto it = indices_to_id_.find(index);
     return deltas_(class_id, it->second);
diff --git a/tensorflow/core/kernels/set_kernels.cc b/tensorflow/core/kernels/set_kernels.cc
index 4532396455f..fd6c7040637 100644
--- a/tensorflow/core/kernels/set_kernels.cc
+++ b/tensorflow/core/kernels/set_kernels.cc
@@ -15,7 +15,7 @@ limitations under the License.
 
 // Ops for operating with sets. They are not checked in
 // to TensorFlow because we would first like to demonstrate successful
-// end-to-end use of these ops in eval and polush the api a bit like taking two
+// end-to-end use of these ops in eval and polish the api a bit like taking two
 // SparseTensor rather than on edense and one sparse.
 
 #define EIGEN_USE_THREADS
@@ -680,7 +680,7 @@ void SetOperationOp<T>::ComputeSparseToSparse(OpKernelContext* ctx) const {
 }
 
 // Given set1 of shape [b, n1] and data_2 of shape [b, n2], populate result
-// sparse tendor with [b, n3] values, where each row `i` contains the result of
+// sparse tensor with [b, n3] values, where each row `i` contains the result of
 // the set operation on elements from set1[i] and set2[i]. `n3` is the number
 // of elements in that result row.
 template <typename T>
diff --git a/tensorflow/core/kernels/smooth-hinge-loss.h b/tensorflow/core/kernels/smooth-hinge-loss.h
index d51f5c130e4..b472ee8cf41 100644
--- a/tensorflow/core/kernels/smooth-hinge-loss.h
+++ b/tensorflow/core/kernels/smooth-hinge-loss.h
@@ -34,7 +34,7 @@ class SmoothHingeLossUpdater : public DualLossUpdater {
                             const double example_weight,
                             const double current_dual, const double wx,
                             const double weighted_example_norm) const final {
-    // Intutitvely there are 3 cases:
+    // Intuitively there are 3 cases:
     // a. new optimal value of the dual variable falls within the admissible
     // range [0, 1]. In this case we set new dual to this value.
     // b. new optimal value is < 0. Then, because of convexity, the optimal
diff --git a/tensorflow/core/kernels/sparse/sparse_cholesky_op.cc b/tensorflow/core/kernels/sparse/sparse_cholesky_op.cc
index 3786033c98c..9a939276f0b 100644
--- a/tensorflow/core/kernels/sparse/sparse_cholesky_op.cc
+++ b/tensorflow/core/kernels/sparse/sparse_cholesky_op.cc
@@ -75,7 +75,7 @@ class CSRSparseCholeskyCPUOp : public OpKernel {
   explicit CSRSparseCholeskyCPUOp(OpKernelConstruction* c) : OpKernel(c) {}
 
   void Compute(OpKernelContext* ctx) final {
-    // Extract inputs and valididate shapes and types.
+    // Extract inputs and validate shapes and types.
     const CSRSparseMatrix* input_matrix;
     OP_REQUIRES_OK(ctx, ExtractVariantFromInput(ctx, 0, &input_matrix));
     const Tensor& input_permutation_indices = ctx->input(1);
diff --git a/tensorflow/core/kernels/sparse_sparse_binary_op_shared.cc b/tensorflow/core/kernels/sparse_sparse_binary_op_shared.cc
index 09cb2a6a71c..43dc9ae70cd 100644
--- a/tensorflow/core/kernels/sparse_sparse_binary_op_shared.cc
+++ b/tensorflow/core/kernels/sparse_sparse_binary_op_shared.cc
@@ -212,7 +212,7 @@ class SparseSparseBinaryOpShared : public OpKernel {
     // allocate_temp() would've given us aligned storage, but we do not know
     // their sizes in advance, so we couldn't use allocate_temp() anyway.
     //
-    // TODO(zongheng): measure if it's worthwile to somehow force alignment.
+    // TODO(zongheng): measure if it's worthwhile to somehow force alignment.
     using UnalignedTensorMap =
         Eigen::TensorMap<Eigen::Tensor<const T, 1, Eigen::RowMajor>,
                          Eigen::Unaligned>;
diff --git a/tensorflow/core/kernels/spectrogram.cc b/tensorflow/core/kernels/spectrogram.cc
index 7531d5d64a5..640cf7447f8 100644
--- a/tensorflow/core/kernels/spectrogram.cc
+++ b/tensorflow/core/kernels/spectrogram.cc
@@ -144,7 +144,7 @@ bool Spectrogram::ComputeSquaredMagnitudeSpectrogram(
     for (int i = 0; i < output_frequency_channels_; ++i) {
       // Similar to the Complex case, except storing the norm.
       // But the norm function is known to be a performance killer,
-      // so do it this way with explicit real and imagninary temps.
+      // so do it this way with explicit real and imaginary temps.
       const double re = fft_input_output_[2 * i];
       const double im = fft_input_output_[2 * i + 1];
       // Which finally converts double to float if it needs to.
diff --git a/tensorflow/core/kernels/stateful_random_ops.cc b/tensorflow/core/kernels/stateful_random_ops.cc
index 2b33a11dff3..02a8a932a6b 100644
--- a/tensorflow/core/kernels/stateful_random_ops.cc
+++ b/tensorflow/core/kernels/stateful_random_ops.cc
@@ -115,7 +115,7 @@ Status UpdateVariableAndFill(
   }
 }
 
-// Preconditon: input(0) is an existing resource.
+// Precondition: input(0) is an existing resource.
 template <typename Device, class Distribution>
 void StatefulRandomCompute(OpKernelContext* ctx, Distribution dist,
                            int state_input_idx, int shape_input_idx,
diff --git a/tensorflow/core/kernels/string_split_op.cc b/tensorflow/core/kernels/string_split_op.cc
index 79ffdb1b069..8b28a53ca5f 100644
--- a/tensorflow/core/kernels/string_split_op.cc
+++ b/tensorflow/core/kernels/string_split_op.cc
@@ -31,7 +31,7 @@ namespace {
 // Returns a vector of StringPieces which are valid as long as input `str`
 // is valid.
 // Note: The single character delimiter is a common case and is implemented as
-// a series of finds in the input string, making it much more effcient than
+// a series of finds in the input string, making it much more efficient than
 // SplitOnCharSet.
 template <typename Predicate>
 std::vector<StringPiece> SplitOnChar(const tstring& str, const char delim,
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl.h b/tensorflow/core/kernels/tile_ops_gpu_impl.h
index 5992bb1273c..fd1268d9a40 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl.h
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl.h
@@ -22,7 +22,7 @@ limitations under the License.
 //   #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 //   #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 //   DEFINE_TILE_OPS(NDIM)
-//   #endif  // GOGLE_CUDA
+//   #endif  // GOOGLE_CUDA
 //
 // where NDIM is an integer.
 //
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_1.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_1.cu.cc
index ec20a37b86e..ad0ed49b1af 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_1.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_1.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(1)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_2.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_2.cu.cc
index 6f6b0ba666b..38e42e28008 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_2.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_2.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(2)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_3.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_3.cu.cc
index 3a6845c60f6..e4e73eef290 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_3.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_3.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(3)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_4.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_4.cu.cc
index 9d78ff248dc..be932c089e1 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_4.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_4.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(4)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_5.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_5.cu.cc
index 096b89f2eef..8843fca883b 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_5.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_5.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(5)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_6.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_6.cu.cc
index ea876585854..21e921aa590 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_6.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_6.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(6)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_7.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_7.cu.cc
index 00b0323b6c5..7543cac6a56 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_7.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_7.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(7)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/tile_ops_gpu_impl_8.cu.cc b/tensorflow/core/kernels/tile_ops_gpu_impl_8.cu.cc
index 3d12b659e8d..7237479c619 100644
--- a/tensorflow/core/kernels/tile_ops_gpu_impl_8.cu.cc
+++ b/tensorflow/core/kernels/tile_ops_gpu_impl_8.cu.cc
@@ -16,4 +16,4 @@ limitations under the License.
 #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
 #include "tensorflow/core/kernels/tile_ops_gpu_impl.h"
 DEFINE_TILE_OPS(8)
-#endif  // GOGLE_CUDA || TENSORFLOW_USE_ROCM
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
diff --git a/tensorflow/core/kernels/unsorted_segment_join_op.cc b/tensorflow/core/kernels/unsorted_segment_join_op.cc
index f0b9388f7cf..7464e165e46 100644
--- a/tensorflow/core/kernels/unsorted_segment_join_op.cc
+++ b/tensorflow/core/kernels/unsorted_segment_join_op.cc
@@ -114,7 +114,7 @@ class UnsortedSegmentJoinOp : public OpKernel {
     OP_REQUIRES_OK(context, context->allocate_output("output", output_shape,
                                                      &output_tensor));
 
-    // Preprating flat tensors.
+    // Preparating flat tensors.
     auto output_flat = output_tensor->flat<tstring>();
     auto flat_segment_id = segment_id.flat<INDICES_TYPE>();
     auto flat_input = input.flat<tstring>();
diff --git a/tensorflow/core/lib/io/format.cc b/tensorflow/core/lib/io/format.cc
index 0c24c660a24..06819c49437 100644
--- a/tensorflow/core/lib/io/format.cc
+++ b/tensorflow/core/lib/io/format.cc
@@ -80,7 +80,7 @@ Status Footer::DecodeFrom(StringPiece* input) {
 Status ReadBlock(RandomAccessFile* file, const BlockHandle& handle,
                  BlockContents* result) {
   result->data = StringPiece();
-  result->cachable = false;
+  result->cacheable = false;
   result->heap_allocated = false;
 
   // Read the block contents as well as the type/crc footer.
@@ -126,11 +126,11 @@ Status ReadBlock(RandomAccessFile* file, const BlockHandle& handle,
         delete[] buf;
         result->data = StringPiece(data, n);
         result->heap_allocated = false;
-        result->cachable = false;  // Do not double-cache
+        result->cacheable = false;  // Do not double-cache
       } else {
         result->data = StringPiece(buf, n);
         result->heap_allocated = true;
-        result->cachable = true;
+        result->cacheable = true;
       }
 
       // Ok
@@ -150,7 +150,7 @@ Status ReadBlock(RandomAccessFile* file, const BlockHandle& handle,
       delete[] buf;
       result->data = StringPiece(ubuf, ulength);
       result->heap_allocated = true;
-      result->cachable = true;
+      result->cacheable = true;
       break;
     }
     default:
diff --git a/tensorflow/core/lib/io/format.h b/tensorflow/core/lib/io/format.h
index fd5c3470f6a..adc92697163 100644
--- a/tensorflow/core/lib/io/format.h
+++ b/tensorflow/core/lib/io/format.h
@@ -90,7 +90,7 @@ static const size_t kBlockTrailerSize = 5;
 
 struct BlockContents {
   StringPiece data;     // Actual contents of data
-  bool cachable;        // True iff data can be cached
+  bool cacheable;       // True iff data can be cached
   bool heap_allocated;  // True iff caller should delete[] data.data()
 };
 
diff --git a/tensorflow/core/lib/io/table_test.cc b/tensorflow/core/lib/io/table_test.cc
index 018fcb2b763..672fabdb496 100644
--- a/tensorflow/core/lib/io/table_test.cc
+++ b/tensorflow/core/lib/io/table_test.cc
@@ -203,7 +203,7 @@ class BlockConstructor : public Constructor {
     data_ = string(builder.Finish());
     BlockContents contents;
     contents.data = data_;
-    contents.cachable = false;
+    contents.cacheable = false;
     contents.heap_allocated = false;
     block_ = new Block(contents);
     return Status::OK();
@@ -446,7 +446,7 @@ TEST_F(Harness, ZeroRestartPointsInBlock) {
   memset(data, 0, sizeof(data));
   BlockContents contents;
   contents.data = StringPiece(data, sizeof(data));
-  contents.cachable = false;
+  contents.cacheable = false;
   contents.heap_allocated = false;
   Block block(contents);
   Iterator* iter = block.NewIterator();
diff --git a/tensorflow/core/lib/random/random_distributions.h b/tensorflow/core/lib/random/random_distributions.h
index 6f40816aedb..2da5e29cc50 100644
--- a/tensorflow/core/lib/random/random_distributions.h
+++ b/tensorflow/core/lib/random/random_distributions.h
@@ -48,7 +48,7 @@ template <typename Int>
 PHILOX_DEVICE_INLINE Int SignedAdd(Int a,
                                    typename std::make_unsigned<Int>::type b) {
   // Implementation note: both b_div_2 and b - b_div_2 are positive and
-  // representatble as Int.
+  // representable as Int.
   auto b_div_2 = b >> 1;
   return a + static_cast<Int>(b_div_2) + static_cast<Int>(b - b_div_2);
 }
diff --git a/tensorflow/core/lib/wav/wav_io.h b/tensorflow/core/lib/wav/wav_io.h
index 352359f6549..347b3528754 100644
--- a/tensorflow/core/lib/wav/wav_io.h
+++ b/tensorflow/core/lib/wav/wav_io.h
@@ -46,7 +46,7 @@ Status EncodeAudioAsS16LEWav(const float* audio, size_t sample_rate,
                              size_t num_channels, size_t num_frames,
                              T* wav_string);
 
-// Excplicit instantiations defined in wav_io.cc.
+// Explicit instantiations defined in wav_io.cc.
 extern template Status EncodeAudioAsS16LEWav<string>(const float* audio,
                                                      size_t sample_rate,
                                                      size_t num_channels,
diff --git a/tensorflow/core/ops/array_ops.cc b/tensorflow/core/ops/array_ops.cc
index 65c9510a1f2..73718061488 100644
--- a/tensorflow/core/ops/array_ops.cc
+++ b/tensorflow/core/ops/array_ops.cc
@@ -155,7 +155,7 @@ Status TransposeShapeFn(InferenceContext* c) {
   TF_RETURN_IF_ERROR(c->WithValue(perm_elems, rank, &perm_elems));
 
   // If we know the rank of the input and the value of perm, we can return
-  // all shape informantion, otherwise we can only return rank information,
+  // all shape information, otherwise we can only return rank information,
   // but no information for the dimensions.
   if (perm != nullptr) {
     std::vector<int64> data;
diff --git a/tensorflow/core/ops/array_ops_test.cc b/tensorflow/core/ops/array_ops_test.cc
index 13a61d5a42b..5d9700a6f67 100644
--- a/tensorflow/core/ops/array_ops_test.cc
+++ b/tensorflow/core/ops/array_ops_test.cc
@@ -1359,7 +1359,7 @@ TEST(ArrayOpsTest, SpaceToBatch_ShapeFn) {
   INFER_ERROR("Dimension size must be evenly divisible by 2 but is 13", op,
               "[1,10,10,3];[2,2]");
 
-  // Negative paddsings
+  // Negative paddings
   paddings = test::AsTensor<int32>({1, -2, 3, 4}, {{2, 2}});
   op.input_tensors[1] = &paddings;
   INFER_ERROR("cannot be negative", op, "[1,10,10,3];[2,2]");
@@ -1479,7 +1479,7 @@ TEST(ArrayOpsTest, BatchToSpace_ShapeFn) {
   INFER_ERROR("Negative dimension size caused by subtracting", op,
               "[4,8,8,3];[2,2]");
 
-  // Negative paddsings
+  // Negative paddings
   croppings = test::AsTensor<int32>({1, -2, 3, 4}, {{2, 2}});
   op.input_tensors[1] = &croppings;
   INFER_ERROR("cannot be negative", op, "[4,8,8,3];[2,2]");
diff --git a/tensorflow/core/ops/parsing_ops.cc b/tensorflow/core/ops/parsing_ops.cc
index b4e742ee507..ee79d9b1113 100644
--- a/tensorflow/core/ops/parsing_ops.cc
+++ b/tensorflow/core/ops/parsing_ops.cc
@@ -61,7 +61,7 @@ void AddSparseOutputShapes(int num_sparse, const ShapeHandle input_shape,
   }
 }
 
-// Adds output shapes for ragged tensors in Parse*Examle ops.
+// Adds output shapes for ragged tensors in Parse*Example ops.
 Status AddRaggedOutputShapes(int num_ragged, bool ragged_rank_2,
                              const DimensionHandle& num_examples,
                              InferenceContext* c, int* output_idx) {
diff --git a/tensorflow/core/ops/scoped_allocator_ops.cc b/tensorflow/core/ops/scoped_allocator_ops.cc
index 359b4d8756f..4bccf5b70eb 100644
--- a/tensorflow/core/ops/scoped_allocator_ops.cc
+++ b/tensorflow/core/ops/scoped_allocator_ops.cc
@@ -61,7 +61,7 @@ REGISTER_OP("_ScopedAllocatorConcat")
     .SetIsStateful()
     .SetShapeFn(shape_inference::ExplicitShape)
     .Doc(R"doc(
-Acts like a Concat Op that merges multple tensors into one, however it must
+Acts like a Concat Op that merges multiple tensors into one, however it must
 only be used in conjunction with a ScopedAllocator which is backing the memory
 of all of its input tensors so that actually it just outputs a read-only
 reference to that ScopedAllocator's backing tensor.
diff --git a/tensorflow/core/ops/stateful_random_ops.cc b/tensorflow/core/ops/stateful_random_ops.cc
index ecc570a44f3..d9e1b1aade9 100644
--- a/tensorflow/core/ops/stateful_random_ops.cc
+++ b/tensorflow/core/ops/stateful_random_ops.cc
@@ -113,7 +113,7 @@ REGISTER_OP("StatefulRandomBinomial")
       return Status::OK();
     });
 
-// Register the depracated 'StatefulStandardNormal' op. This op is a short-lived
+// Register the deprecated 'StatefulStandardNormal' op. This op is a short-lived
 // version where the 'resource' variable also contains the algorithm tag.
 // It is deprecated in favor of 'StatefulStandardNormalV2'.
 REGISTER_OP("StatefulStandardNormal")
diff --git a/tensorflow/core/ops/training_ops_test.cc b/tensorflow/core/ops/training_ops_test.cc
index 0f309c1f4e9..a9ba90bc8df 100644
--- a/tensorflow/core/ops/training_ops_test.cc
+++ b/tensorflow/core/ops/training_ops_test.cc
@@ -96,7 +96,7 @@ TEST(TrainingOpsTest, ApplyAdadelta_ShapeFn) {
   INFER_ERROR("Dimension 0 in both shapes must be equal, but are 1 and 2", op,
               "[1];[1];[1];[];[];[];[2]");
 
-  // lr, rho, and episilon must be scalars.
+  // lr, rho, and epsilon must be scalars.
   INFER_ERROR("Shape must be rank 0 but is rank 1", op, "?;?;?;[?];?;?;?");
   INFER_ERROR("Shape must be rank 0 but is rank 1", op, "?;?;?;?;[?];?;?");
   INFER_ERROR("Shape must be rank 0 but is rank 1", op, "?;?;?;?;?;[?];?");
@@ -118,7 +118,7 @@ TEST(TrainingOpsTest, SparseApplyAdadelta_ShapeFn) {
 
   TestGradAndIndicesErrorHandling(op, "?;?;?;?;?");
 
-  // lr, rho, and episilon must be scalars.
+  // lr, rho, and epsilon must be scalars.
   INFER_ERROR("Shape must be rank 0 but is rank 1", op, "?;?;?;[?];?;?;?;?");
   INFER_ERROR("Shape must be rank 0 but is rank 1", op, "?;?;?;?;[?];?;?;?");
   INFER_ERROR("Shape must be rank 0 but is rank 1", op, "?;?;?;?;?;[?];?;?");
diff --git a/tensorflow/core/platform/cloud/curl_http_request.h b/tensorflow/core/platform/cloud/curl_http_request.h
index b8e9aeb3399..af71884660a 100644
--- a/tensorflow/core/platform/cloud/curl_http_request.h
+++ b/tensorflow/core/platform/cloud/curl_http_request.h
@@ -213,7 +213,7 @@ class CurlHttpRequest : public HttpRequest {
   // Timeout for the connection phase.
   uint32 connect_timeout_secs_ = 120;  // 2 minutes
 
-  // Tiemout for the whole request. Set only to prevent hanging indefinitely.
+  // Timeout for the whole request. Set only to prevent hanging indefinitely.
   uint32 request_timeout_secs_ = 3600;  // 1 hour
 
   // Members to enforce the usage flow.
diff --git a/tensorflow/core/platform/cloud/gcs_file_system.cc b/tensorflow/core/platform/cloud/gcs_file_system.cc
index 57847d2ea38..18b7ef02b6f 100644
--- a/tensorflow/core/platform/cloud/gcs_file_system.cc
+++ b/tensorflow/core/platform/cloud/gcs_file_system.cc
@@ -126,7 +126,7 @@ constexpr char kInitialTokens[] = "GCS_INITIAL_TOKENS";
 constexpr char kAllowedBucketLocations[] = "GCS_ALLOWED_BUCKET_LOCATIONS";
 // When this value is passed as an allowed location detects the zone tensorflow
 // is running in and restricts to buckets in that region.
-constexpr char kDetectZoneSentinalValue[] = "auto";
+constexpr char kDetectZoneSentinelValue[] = "auto";
 
 Status GetTmpFilename(string* filename) {
   *filename = io::GetTempFilename("");
@@ -414,7 +414,7 @@ class GcsWritableFile : public WritableFile {
   /// \brief Constructs the writable file in append mode.
   ///
   /// tmp_content_filename should contain a path of an existing temporary file
-  /// with the content to be appended. The class takes onwnership of the
+  /// with the content to be appended. The class takes ownership of the
   /// specified tmp file and deletes it on close.
   GcsWritableFile(const string& bucket, const string& object,
                   GcsFileSystem* filesystem, const string& tmp_content_filename,
@@ -1235,7 +1235,7 @@ Status GcsFileSystem::CheckBucketLocationConstraint(const string& bucket) {
   }
 
   // Avoid calling external API's in the constructor
-  if (allowed_locations_.erase(kDetectZoneSentinalValue) == 1) {
+  if (allowed_locations_.erase(kDetectZoneSentinelValue) == 1) {
     string zone;
     TF_RETURN_IF_ERROR(zone_provider_->GetZone(&zone));
     allowed_locations_.insert(ZoneToRegion(&zone));
diff --git a/tensorflow/core/platform/denormal.cc b/tensorflow/core/platform/denormal.cc
index c510dc204f7..678a7233d51 100644
--- a/tensorflow/core/platform/denormal.cc
+++ b/tensorflow/core/platform/denormal.cc
@@ -57,7 +57,7 @@ static void SetDenormalState(bool flush_zero_mode, bool denormals_zero_mode) {
 #endif
 }
 
-static std::pair<bool, bool> GetDernormalState() {
+static std::pair<bool, bool> GetDenormalState() {
   // For now, we flush denormals only on SSE 3.  Other architectures such as ARM
   // can be added as needed.
 
@@ -74,7 +74,7 @@ static std::pair<bool, bool> GetDernormalState() {
 }
 
 ScopedRestoreFlushDenormalState::ScopedRestoreFlushDenormalState() {
-  std::tie(flush_zero_mode_, denormals_zero_mode_) = GetDernormalState();
+  std::tie(flush_zero_mode_, denormals_zero_mode_) = GetDenormalState();
 }
 
 ScopedRestoreFlushDenormalState::~ScopedRestoreFlushDenormalState() {
diff --git a/tensorflow/core/platform/hadoop/hadoop_file_system.cc b/tensorflow/core/platform/hadoop/hadoop_file_system.cc
index 091cb60e5c0..52c15e6d2ab 100644
--- a/tensorflow/core/platform/hadoop/hadoop_file_system.cc
+++ b/tensorflow/core/platform/hadoop/hadoop_file_system.cc
@@ -473,7 +473,7 @@ Status HadoopFileSystem::DeleteDir(const string& dir) {
     libhdfs()->hdfsFreeFileInfo(info, entries);
   }
   // Due to HDFS bug HDFS-8407, we can't distinguish between an error and empty
-  // folder, expscially for Kerberos enable setup, EAGAIN is quite common when
+  // folder, especially for Kerberos enable setup, EAGAIN is quite common when
   // the call is actually successful. Check again by Stat.
   if (info == nullptr && errno != 0) {
     FileStatistics stat;
diff --git a/tensorflow/core/platform/logger.h b/tensorflow/core/platform/logger.h
index 1802e4fb889..0e3cdf56113 100644
--- a/tensorflow/core/platform/logger.h
+++ b/tensorflow/core/platform/logger.h
@@ -31,7 +31,7 @@ class Logger {
   //   SetSingletonFactory.
   // * At some point in the program execution, Singleton() is called for the
   //   first time, initializing the logger.
-  // * Succeeding calls to Singleton() return the initiailized logger.
+  // * Succeeding calls to Singleton() return the initialized logger.
   using FactoryFunc = Logger* (*)();
 
   static void SetSingletonFactory(FactoryFunc factory) {
diff --git a/tensorflow/core/platform/macros.h b/tensorflow/core/platform/macros.h
index e1d83e18acc..62e5e01b3cc 100644
--- a/tensorflow/core/platform/macros.h
+++ b/tensorflow/core/platform/macros.h
@@ -57,7 +57,7 @@ limitations under the License.
 #define TF_SCANF_ATTRIBUTE(string_index, first_to_check)
 #endif
 
-// Control visiblity outside .so
+// Control visibility outside .so
 #if defined(_WIN32)
 #ifdef TF_COMPILE_LIBRARY
 #define TF_EXPORT __declspec(dllexport)
diff --git a/tensorflow/core/platform/mutex.h b/tensorflow/core/platform/mutex.h
index 16b4a992df7..b4762f636a2 100644
--- a/tensorflow/core/platform/mutex.h
+++ b/tensorflow/core/platform/mutex.h
@@ -180,7 +180,7 @@ class SCOPED_LOCKABLE mutex_lock {
 #define mutex_lock(x) static_assert(0, "mutex_lock_decl_missing_var_name");
 
 // Mimic a subset of the std::shared_lock<tensorflow::mutex> functionality.
-// Name chosen to minimise conflicts with the tf_shared_lock macro, below.
+// Name chosen to minimize conflicts with the tf_shared_lock macro, below.
 class SCOPED_LOCKABLE tf_shared_lock {
  public:
   typedef ::tensorflow::mutex mutex_type;
diff --git a/tensorflow/core/platform/platform_strings_test.cc b/tensorflow/core/platform/platform_strings_test.cc
index a4af143d58f..c8c68d95882 100644
--- a/tensorflow/core/platform/platform_strings_test.cc
+++ b/tensorflow/core/platform/platform_strings_test.cc
@@ -56,7 +56,7 @@ static int PrintStrings(const std::string file_name) {
   return rc;
 }
 
-// Return whether str[] conatins a string with prefix "macro_name="; if so,
+// Return whether str[] contains a string with prefix "macro_name="; if so,
 // set *pvalue to the suffix.
 static bool GetValue(const string_vec &str, const std::string &macro_name,
                      std::string *pvalue) {
diff --git a/tensorflow/core/platform/profile_utils/cpu_utils.h b/tensorflow/core/platform/profile_utils/cpu_utils.h
index d43abd8059b..d26f28478a5 100644
--- a/tensorflow/core/platform/profile_utils/cpu_utils.h
+++ b/tensorflow/core/platform/profile_utils/cpu_utils.h
@@ -160,7 +160,7 @@ class CpuUtils {
   };
 
   // Return cpu frequency.
-  // CAVEAT: as this method calls system call and parse the mssage,
+  // CAVEAT: as this method calls system call and parse the message,
   // this call may be slow. This is why this class caches the value by
   // StaticVariableInitializer.
   static int64 GetCycleCounterFrequencyImpl();
diff --git a/tensorflow/core/platform/rocm_rocdl_path_test.cc b/tensorflow/core/platform/rocm_rocdl_path_test.cc
index 3436dafac6d..166e99bb509 100644
--- a/tensorflow/core/platform/rocm_rocdl_path_test.cc
+++ b/tensorflow/core/platform/rocm_rocdl_path_test.cc
@@ -24,7 +24,7 @@ namespace tensorflow {
 
 #if TENSORFLOW_USE_ROCM
 TEST(RocmRocdlPathTest, ROCDLPath) {
-  VLOG(2) << "ROCm-Deivce-Libs root = " << RocdlRoot();
+  VLOG(2) << "ROCm-Device-Libs root = " << RocdlRoot();
   std::vector<string> rocdl_files;
   TF_EXPECT_OK(Env::Default()->GetMatchingPaths(
       io::JoinPath(RocdlRoot(), "*.amdgcn.bc"), &rocdl_files));
diff --git a/tensorflow/core/platform/s3/s3_file_system.cc b/tensorflow/core/platform/s3/s3_file_system.cc
index 9749fec8ee5..ed9138e5f76 100644
--- a/tensorflow/core/platform/s3/s3_file_system.cc
+++ b/tensorflow/core/platform/s3/s3_file_system.cc
@@ -398,7 +398,7 @@ std::shared_ptr<Aws::S3::S3Client> S3FileSystem::GetS3Client() {
     Aws::InitAPI(options);
 
     // The creation of S3Client disables virtual addressing:
-    //   S3Client(clientConfiguration, signPayloads, useVirtualAdressing = true)
+    //   S3Client(clientConfiguration, signPayloads, useVirtualAddressing = true)
     // The purpose is to address the issue encountered when there is an `.`
     // in the bucket name. Due to TLS hostname validation or DNS rules,
     // the bucket may not be resolved. Disabling of virtual addressing
diff --git a/tensorflow/core/platform/tracing.h b/tensorflow/core/platform/tracing.h
index 3908d40b695..5f31c725324 100644
--- a/tensorflow/core/platform/tracing.h
+++ b/tensorflow/core/platform/tracing.h
@@ -103,7 +103,7 @@ class ScopedRegion {
   }
 
   // Same as ScopedRegion(category, GetUniqueArg()), but faster if
-  // EventCollector::IsEnaled() returns false.
+  // EventCollector::IsEnabled() returns false.
   explicit ScopedRegion(EventCategory category)
       : collector_(GetEventCollector(category)) {
     if (collector_) {
@@ -112,7 +112,7 @@ class ScopedRegion {
   }
 
   // Same as ScopedRegion(category, GetArgForName(name)), but faster if
-  // EventCollector::IsEnaled() returns false.
+  // EventCollector::IsEnabled() returns false.
   ScopedRegion(EventCategory category, StringPiece name)
       : collector_(GetEventCollector(category)) {
     if (collector_) {
diff --git a/tensorflow/core/platform/windows/port.cc b/tensorflow/core/platform/windows/port.cc
index 547af76bdf6..be567ccdbbe 100644
--- a/tensorflow/core/platform/windows/port.cc
+++ b/tensorflow/core/platform/windows/port.cc
@@ -77,7 +77,7 @@ int NumTotalCPUs() {
   // the Size fields by iterating over the written-to buffer.  Since I can't
   // easily test this on Windows, I'm deferring this to someone who can!
   //
-  // If you fix this, also consider updatig GetCurrentCPU below.
+  // If you fix this, also consider updating GetCurrentCPU below.
   return NumSchedulableCPUs();
 }
 
diff --git a/tensorflow/core/profiler/g3doc/python_api.md b/tensorflow/core/profiler/g3doc/python_api.md
index 0daac655c4e..31117049353 100644
--- a/tensorflow/core/profiler/g3doc/python_api.md
+++ b/tensorflow/core/profiler/g3doc/python_api.md
@@ -113,7 +113,7 @@ opts = model_analyzer.PRINT_ALL_TIMING_MEMORY.copy()
 opts['account_type_regexes'] = ['.*']
 
 with session.Session() as sess:
-  r1, r2, r3 = lib.BuildSplitableModel()
+  r1, r2, r3 = lib.BuildSplittableModel()
   sess.run(variables.global_variables_initializer())
 
   # Create a profiler.
diff --git a/tensorflow/core/profiler/internal/gpu/cupti_tracer.cc b/tensorflow/core/profiler/internal/gpu/cupti_tracer.cc
index 8736f777da4..bf498747f00 100644
--- a/tensorflow/core/profiler/internal/gpu/cupti_tracer.cc
+++ b/tensorflow/core/profiler/internal/gpu/cupti_tracer.cc
@@ -786,7 +786,7 @@ class CudaEventRecorder {
     // Synchronize all contexts, record end events, synchronize again.
     // This scheme is an unreliable measure to associate a event with the wall
     // time. There are chances that other threads might enque kernels which
-    // delay the second synchornization.
+    // delay the second synchronization.
     TF_RETURN_IF_ERROR(Synchronize());
     for (auto &pair : context_infos_) {
       TF_RETURN_IF_ERROR(ToStatus(cuCtxSetCurrent(pair.first)));
@@ -1037,7 +1037,7 @@ class CuptiDriverApiHookWithCudaEvent : public CuptiDriverApiHook {
           auto context = scoped_cuda_context.GetContext();
           if (!dev_id) return errors::Internal("Invalid CUDA stream");
           // Because annotation are per device, therefore we need to populate
-          // annotation for each device invovled.
+          // annotation for each device involved.
           collector_->annotation_map()->Add(*dev_id, cbdata->correlationId,
                                             annotation);
           record_indices.push_back(
diff --git a/tensorflow/core/profiler/internal/gpu/cupti_tracer.h b/tensorflow/core/profiler/internal/gpu/cupti_tracer.h
index 12a61af1fa5..ecec49144b7 100644
--- a/tensorflow/core/profiler/internal/gpu/cupti_tracer.h
+++ b/tensorflow/core/profiler/internal/gpu/cupti_tracer.h
@@ -172,7 +172,7 @@ class AnnotationMap {
 
  private:
   struct PerDeviceAnnotationMap {
-    // The population/consuption of annotations might happen from multiple
+    // The population/consumption of annotations might happen from multiple
     // callback/activity api related threads.
     absl::Mutex mutex;
     // Annotation tends to be repetitive, use a hash_set to store the strings,
diff --git a/tensorflow/core/profiler/internal/tfprof_code.cc b/tensorflow/core/profiler/internal/tfprof_code.cc
index 75d1e156cce..0d1ff4f323c 100644
--- a/tensorflow/core/profiler/internal/tfprof_code.cc
+++ b/tensorflow/core/profiler/internal/tfprof_code.cc
@@ -138,7 +138,7 @@ class LocationTable {
   explicit LocationTable(FunctionTable* function_table)
       : function_table_(function_table) {}
 
-  // Returns the index of a function call localtion. If not found, adds a
+  // Returns the index of a function call location. If not found, adds a
   // location proto and returns the location index.
   uint64 GetIndex(const string& file_path, uint64 line_number,
                   const string& called_function_name,
diff --git a/tensorflow/core/profiler/internal/tfprof_node.cc b/tensorflow/core/profiler/internal/tfprof_node.cc
index d11b0ce1583..8bcec0ccafb 100644
--- a/tensorflow/core/profiler/internal/tfprof_node.cc
+++ b/tensorflow/core/profiler/internal/tfprof_node.cc
@@ -153,7 +153,7 @@ void ExecStep::AddMemoryStats(const string& dev,
   // TODO(xpan): Make this more accurate:
   // High level: Memory tracking is suspicious and requires large scale
   // clean up.
-  // Investigte the memory usage difference between CPU/GPU with OpViewTest.
+  // Investigate the memory usage difference between CPU/GPU with OpViewTest.
   //
   // 1. OpKernelConstruction::allocate_xxx is not traced. Below, we only
   //    discuss OpKernelContext-related allocations.
diff --git a/tensorflow/core/profiler/internal/tfprof_utils.cc b/tensorflow/core/profiler/internal/tfprof_utils.cc
index 0f7670f15dc..f4011fc4da9 100644
--- a/tensorflow/core/profiler/internal/tfprof_utils.cc
+++ b/tensorflow/core/profiler/internal/tfprof_utils.cc
@@ -336,7 +336,7 @@ static const char* const kResidualBytes =
     "residual bytes: The memory not de-allocated after the operation finishes.";
 static const char* const kOutputBytes =
     "output bytes: The memory that is output from the operation (not "
-    "necessarilty allocated by the operation)";
+    "necessarily allocated by the operation)";
 static const char* const kOccurrence =
     "occurrence: The number of times it occurs";
 static const char* const kInputShapes =
diff --git a/tensorflow/core/profiler/lib/profiler_session.h b/tensorflow/core/profiler/lib/profiler_session.h
index 409e23e013b..70cedb7ecd9 100644
--- a/tensorflow/core/profiler/lib/profiler_session.h
+++ b/tensorflow/core/profiler/lib/profiler_session.h
@@ -41,7 +41,7 @@ class ProfilerSession {
       const profiler::ProfilerOptions& options);
   static std::unique_ptr<ProfilerSession> Create();
 
-  // Deletes an exsiting Profiler and enables starting a new one.
+  // Deletes an existing Profiler and enables starting a new one.
   ~ProfilerSession();
 
   tensorflow::Status Status() LOCKS_EXCLUDED(mutex_);
diff --git a/tensorflow/core/profiler/profiler.cc b/tensorflow/core/profiler/profiler.cc
index 5fd3a32a680..559d85ade89 100644
--- a/tensorflow/core/profiler/profiler.cc
+++ b/tensorflow/core/profiler/profiler.cc
@@ -282,7 +282,7 @@ int Run(int argc, char** argv) {
     if (line == nullptr) {
       if (!looped) {
         absl::FPrintF(stderr,
-                      "Cannot start interative shell, "
+                      "Cannot start interactive shell, "
                       "use 'bazel-bin' instead of 'bazel run'.\n");
       }
       break;
diff --git a/tensorflow/core/profiler/protobuf/BUILD b/tensorflow/core/profiler/protobuf/BUILD
index 30289f247f3..64e9ecbc0b2 100644
--- a/tensorflow/core/profiler/protobuf/BUILD
+++ b/tensorflow/core/profiler/protobuf/BUILD
@@ -83,7 +83,7 @@ tf_proto_library(
     visibility = [":friends"],
 )
 
-# This proto is deprecating and not guarenteed to be compatible across versions.
+# This proto is deprecating and not guaranteed to be compatible across versions.
 # Please don't refer in new project unless you are double confirmed.
 tf_proto_library(
     name = "tf_stats_proto",
diff --git a/tensorflow/core/protobuf/rewriter_config.proto b/tensorflow/core/protobuf/rewriter_config.proto
index d1cdb515341..e657a184b65 100644
--- a/tensorflow/core/protobuf/rewriter_config.proto
+++ b/tensorflow/core/protobuf/rewriter_config.proto
@@ -129,7 +129,7 @@ message RewriterConfig {
   // effect on manually requested memory optimization passes in the optimizers
   // field.
   MemOptType memory_optimization = 4;
-  // A node name scope for node names which are valid outputs of recompuations.
+  // A node name scope for node names which are valid outputs of recomputations.
   // Inputs to nodes that match this scope may be recomputed (subject either to
   // manual annotation of those input nodes or to manual annotation and
   // heuristics depending on memory_optimization), but the nodes themselves will
diff --git a/tensorflow/core/protobuf/tpu/compile_metadata.proto b/tensorflow/core/protobuf/tpu/compile_metadata.proto
index 6adbfae2df7..09f802739ca 100644
--- a/tensorflow/core/protobuf/tpu/compile_metadata.proto
+++ b/tensorflow/core/protobuf/tpu/compile_metadata.proto
@@ -90,7 +90,7 @@ message TPUCompileMetadataProto {
   string session_handle = 9;
 
   // Fingerprint of guaranteed_const value. The fingerprint computation inside
-  // tpu_compile_op may be slow. The compuation can be avoided by setting the
+  // tpu_compile_op may be slow. The computation can be avoided by setting the
   // fingerprint value here.
   string guaranteed_const_fingerprint = 10;
 
diff --git a/tensorflow/core/util/bcast.h b/tensorflow/core/util/bcast.h
index 62d3968aadc..7bb8ea18ad3 100644
--- a/tensorflow/core/util/bcast.h
+++ b/tensorflow/core/util/bcast.h
@@ -76,7 +76,7 @@ class BCastList {
   // the same number of dimensions as the larger of the two inputs.
   //
   // If return_flattened_batch_indices is true, the implementation will compute
-  // for each output member of the flattened output, which batch indicies of
+  // for each output member of the flattened output, which batch indices of
   // each input correspond to it. This is disabled by default.
   explicit BCastList(const Vec (&x)[N],
                      const bool fewer_dims_optimization = true,
@@ -241,7 +241,7 @@ BCastList<N>::BCastList(const BCastList::Vec (&x)[N],
       // When N != C, we'll continue as usual. However, we might trigger the
       // next block if N == P (because we didn't update the previous state).
       // We trigger the next block if `fewer_dims_optimization` is true.
-      // This means that we did not modify and broadcast / rehshapes in this
+      // This means that we did not modify and broadcast / reshapes in this
       // block (we skipped updating, since the one dimensions can be ignored).
       // In essence, we only need to check whether the previous non-one state is
       // equal to the current non-one state.
diff --git a/tensorflow/core/util/command_line_flags_test.cc b/tensorflow/core/util/command_line_flags_test.cc
index ad8c824461a..a12ed96a17a 100644
--- a/tensorflow/core/util/command_line_flags_test.cc
+++ b/tensorflow/core/util/command_line_flags_test.cc
@@ -270,7 +270,7 @@ TEST(CommandLineFlagsTest, UsageString) {
   bool some_switch = false;
   string some_name = "something";
   // Don't test float in this case, because precision is hard to predict and
-  // match against, and we don't want a flakey test.
+  // match against, and we don't want a franky test.
   const string tool_name = "some_tool_name";
   string usage = Flags::Usage(tool_name + "<flags>",
                               {Flag("some_int", &some_int, "some int"),
diff --git a/tensorflow/core/util/debug_events_writer.h b/tensorflow/core/util/debug_events_writer.h
index 78c23e3b851..15085b9febe 100644
--- a/tensorflow/core/util/debug_events_writer.h
+++ b/tensorflow/core/util/debug_events_writer.h
@@ -153,7 +153,7 @@ class DebugEventsWriter {
   //     with.
   //   tensor_debug_mode: An integer that represents the tensor-debug mode enum.
   //   tensor_value: The value of the tensor that describes the tensor(s)
-  //     that this trace is concerned with. The sematics of this tensor value
+  //     that this trace is concerned with. The semantics of this tensor value
   //     depends on the value of `tensor_debug_mode`.
   void WriteGraphExecutionTrace(const string& tfdbg_context_id,
                                 const string& device_name,
diff --git a/tensorflow/core/util/debug_events_writer_test.cc b/tensorflow/core/util/debug_events_writer_test.cc
index 299e5c646df..925fec7add1 100644
--- a/tensorflow/core/util/debug_events_writer_test.cc
+++ b/tensorflow/core/util/debug_events_writer_test.cc
@@ -805,7 +805,7 @@ TEST_F(DebugEventsWriterTest, RegisterDeviceAndGetIdTrace) {
   }
 }
 
-TEST_F(DebugEventsWriterTest, DisableCyclicBufferBeahavior) {
+TEST_F(DebugEventsWriterTest, DisableCyclicBufferBehavior) {
   const size_t kCyclicBufferSize = 0;  // A value <= 0 disables cyclic behavior.
   DebugEventsWriter* writer =
       DebugEventsWriter::GetDebugEventsWriter(dump_root_, kCyclicBufferSize);
diff --git a/tensorflow/core/util/example_proto_fast_parsing.cc b/tensorflow/core/util/example_proto_fast_parsing.cc
index 24bdb019fa6..eb50d621b02 100644
--- a/tensorflow/core/util/example_proto_fast_parsing.cc
+++ b/tensorflow/core/util/example_proto_fast_parsing.cc
@@ -1812,7 +1812,7 @@ namespace {
 // substrings for a single feature, plus some auxiliary information derived
 // from those protos (such as the total value length).
 struct FeatureProtos {
-  // Proto substrings from each serialized SequenceExamle that correspond
+  // Proto substrings from each serialized SequenceExample that correspond
   // with this feature.  `protos_present` records whether the proto had a
   // value defined (even if that value is empty).
   std::vector<StringPiece> protos;
@@ -2133,7 +2133,7 @@ Status ExtractFeaturesFromSequenceExamples(
   return Status::OK();
 }
 
-// Populates context_fatures[k].length based on context_features[k].protos
+// Populates context_features[k].length based on context_features[k].protos
 // (for all k).
 Status GetContextFeatureLengths(const gtl::ArraySlice<tstring> example_names,
                                 FeatureProtosMap* context_features) {
@@ -2168,7 +2168,7 @@ Status GetContextFeatureLengths(const gtl::ArraySlice<tstring> example_names,
   return Status::OK();
 }
 
-// Populates sequence_fatures[k].length and sequence_features[k].num_rows based
+// Populates sequence_features[k].length and sequence_features[k].num_rows based
 // on sequence_features[k].protos (for all k).
 Status GetSequenceFeatureLengths(const gtl::ArraySlice<tstring> example_names,
                                  FeatureProtosMap* sequence_features) {
diff --git a/tensorflow/core/util/example_proto_fast_parsing.h b/tensorflow/core/util/example_proto_fast_parsing.h
index abe124e8450..762da49c11a 100644
--- a/tensorflow/core/util/example_proto_fast_parsing.h
+++ b/tensorflow/core/util/example_proto_fast_parsing.h
@@ -35,7 +35,7 @@ namespace tensorflow {
 namespace example {
 
 // FastParseExampleConfig defines how to parse features in Example.
-// Each sub-config is responsible for one feature identified with feautre_name.
+// Each sub-config is responsible for one feature identified with feature_name.
 // FastParseExampleConfig can't have two sub-configs with the same feature_name.
 // dtype identifies the type of output vector and the kind of Feature expected
 // in Example.
diff --git a/tensorflow/core/util/mkl_util.h b/tensorflow/core/util/mkl_util.h
index fb4aba3e89e..c126ef6d59c 100644
--- a/tensorflow/core/util/mkl_util.h
+++ b/tensorflow/core/util/mkl_util.h
@@ -1500,8 +1500,8 @@ class MklDnnData {
 
   /// allocate function for data buffer
   inline void AllocateBuffer(size_t size) {
-    const int64 kMemoryAlginment = 64;  // For AVX512 memory alignment.
-    allocated_buffer_ = cpu_allocator()->AllocateRaw(kMemoryAlginment, size);
+    const int64 kMemoryAlignment = 64;  // For AVX512 memory alignment.
+    allocated_buffer_ = cpu_allocator()->AllocateRaw(kMemoryAlignment, size);
   }
 
   inline void* GetAllocatedBuffer() { return allocated_buffer_; }
@@ -1923,7 +1923,7 @@ class LRUCache {
       this->lru_iterator = it;
     }
 
-    // Move construcctor
+    // Move constructor
     Entry(Entry&& source) noexcept
         : lru_iterator(std::move(source.lru_iterator)) {
       op = std::move(source.op);
@@ -1983,7 +1983,7 @@ class MklPrimitiveFactory {
             !port::TestCPUFeature(port::CPUFeature::AVX2));
   }
 
-  /// Fuction to check whether primitive memory optimization is enabled
+  /// Function to check whether primitive memory optimization is enabled
   static inline bool IsPrimitiveMemOptEnabled() {
     bool is_primitive_mem_opt_enabled = true;
     TF_CHECK_OK(ReadBoolFromEnvVar("TF_MKL_OPTIMIZE_PRIMITIVE_MEMUSE", true,
@@ -2137,7 +2137,7 @@ class MklReorderPrimitiveFactory : public MklPrimitiveFactory<T> {
   }
 };
 
-/// Fuction to find(or create) a reorder from memory pointed by
+/// Function to find(or create) a reorder from memory pointed by
 /// from to memory pointed by to, it will created primitive or
 /// get primitive from pool if it is cached.
 /// Returns the primitive.
diff --git a/tensorflow/core/util/stat_summarizer.cc b/tensorflow/core/util/stat_summarizer.cc
index 99f4c08c5c6..bac3ba66b37 100644
--- a/tensorflow/core/util/stat_summarizer.cc
+++ b/tensorflow/core/util/stat_summarizer.cc
@@ -149,9 +149,9 @@ void StatSummarizer::ProcessStepStats(const StepStats& step_stats) {
       // NOTE(fishx): We will record ops execution time twice: one as CPU
       // activity with device name "/host:CPU" and the other as TF runtime
       // activity with device name started with "/job:*". It is safe to ignore
-      // CPU activties here.
+      // CPU activities here.
       // TODO(b/138729463): Read ops execution time from CPU activities instead
-      // of runtime acitivities.
+      // of runtime activities.
       if (ds.device().find("/host:CPU") != std::string::npos) {
         continue;
       }