diff --git a/Android.mk b/Android.mk
index 3e2494d..3d69a04 100644
--- a/Android.mk
+++ b/Android.mk
@@ -134,8 +134,8 @@
         src/armnn/Optimizer.cpp \
         src/armnn/Runtime.cpp \
         src/armnn/SerializeLayerParameters.cpp \
-        src/armnn/SubGraph.cpp \
-        src/armnn/SubGraphSelector.cpp \
+        src/armnn/SubgraphView.cpp \
+        src/armnn/SubgraphViewSelector.cpp \
         src/armnn/InternalTypes.cpp \
         src/armnn/Layer.cpp \
         src/armnn/LoadedNetwork.cpp \
@@ -242,7 +242,7 @@
         src/armnn/test/GraphTests.cpp \
         src/armnn/test/GraphUtils.cpp \
         src/armnn/test/RuntimeTests.cpp \
-        src/armnn/test/SubGraphTests.cpp \
+        src/armnn/test/SubgraphViewTests.cpp \
         src/armnn/test/TensorTest.cpp \
         src/armnn/test/NetworkTests.cpp \
         src/armnn/test/InstrumentTests.cpp \
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 233ef3c..297cbcd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -294,7 +294,7 @@
     src/armnn/Instrument.hpp
     src/armnn/InternalTypes.cpp
     src/armnn/InternalTypes.hpp
-    src/armnn/ISubGraphConverter.hpp
+    src/armnn/ISubgraphViewConverter.hpp
     src/armnn/JsonPrinter.cpp
     src/armnn/JsonPrinter.hpp
     src/armnn/Layer.cpp
@@ -335,10 +335,10 @@
     src/armnn/SerializeLayerParameters.hpp
     src/armnn/StaticRangeVisitor.cpp
     src/armnn/StaticRangeVisitor.hpp
-    src/armnn/SubGraph.cpp
-    src/armnn/SubGraph.hpp
-    src/armnn/SubGraphSelector.cpp
-    src/armnn/SubGraphSelector.hpp
+    src/armnn/SubgraphView.cpp
+    src/armnn/SubgraphView.hpp
+    src/armnn/SubgraphViewSelector.cpp
+    src/armnn/SubgraphViewSelector.hpp
     src/armnn/Tensor.cpp
     src/armnn/TypesUtils.cpp
     src/armnn/Utils.cpp
@@ -435,7 +435,7 @@
         src/armnn/test/QuantizerTest.cpp
         src/armnn/test/RuntimeTests.cpp
         src/armnn/test/RuntimeTests.hpp
-        src/armnn/test/SubGraphTests.cpp
+        src/armnn/test/SubgraphViewTests.cpp
         src/armnn/test/TensorHelpers.hpp
         src/armnn/test/TensorTest.cpp
         src/armnn/test/TestInputOutputLayerVisitor.cpp
diff --git a/src/armnn/Graph.cpp b/src/armnn/Graph.cpp
index be0dd5f..335f195 100644
--- a/src/armnn/Graph.cpp
+++ b/src/armnn/Graph.cpp
@@ -4,7 +4,7 @@
 //
 
 #include "Graph.hpp"
-#include "SubGraph.hpp"
+#include "SubgraphView.hpp"
 #include "LayersFwd.hpp"
 
 #include <armnn/Utils.hpp>
@@ -298,88 +298,88 @@
     }
 }
 
-void Graph::SubstituteSubGraph(std::unique_ptr<SubGraph> subGraph, IConnectableLayer* substituteLayer)
+void Graph::SubstituteSubgraph(std::unique_ptr<SubgraphView> subgraph, IConnectableLayer* substituteLayer)
 {
-    BOOST_ASSERT(subGraph != nullptr);
+    BOOST_ASSERT(subgraph != nullptr);
     BOOST_ASSERT(substituteLayer != nullptr);
 
-    ReplaceSubGraphConnections(*subGraph, substituteLayer);
-    EraseSubGraphLayers(*subGraph);
+    ReplaceSubgraphConnections(*subgraph, substituteLayer);
+    EraseSubgraphLayers(*subgraph);
 }
 
-void Graph::SubstituteSubGraph(std::unique_ptr<SubGraph> subGraph, const SubGraph& substituteSubGraph)
+void Graph::SubstituteSubgraph(std::unique_ptr<SubgraphView> subgraph, const SubgraphView& substituteSubgraph)
 {
-    BOOST_ASSERT(subGraph);
+    BOOST_ASSERT(subgraph);
 
-    ReplaceSubGraphConnections(*subGraph, substituteSubGraph);
-    EraseSubGraphLayers(*subGraph);
+    ReplaceSubgraphConnections(*subgraph, substituteSubgraph);
+    EraseSubgraphLayers(*subgraph);
 }
 
-void Graph::ReplaceSubGraphConnections(const SubGraph& subGraph, IConnectableLayer* substituteLayer)
+void Graph::ReplaceSubgraphConnections(const SubgraphView& subgraph, IConnectableLayer* substituteLayer)
 {
     BOOST_ASSERT(substituteLayer != nullptr);
 
     // Create a new sub-graph with only the given layer, using
     // the given sub-graph as a reference of which parent graph to use
-    SubGraph substituteSubGraph(subGraph, substituteLayer);
-    ReplaceSubGraphConnections(subGraph, substituteSubGraph);
+    SubgraphView substituteSubgraph(subgraph, substituteLayer);
+    ReplaceSubgraphConnections(subgraph, substituteSubgraph);
 }
 
-void Graph::ReplaceSubGraphConnections(const SubGraph& subGraph, const SubGraph& substituteSubGraph)
+void Graph::ReplaceSubgraphConnections(const SubgraphView& subgraph, const SubgraphView& substituteSubgraph)
 {
-    BOOST_ASSERT_MSG(!substituteSubGraph.GetLayers().empty(), "New sub-graph used for substitution must not be empty");
+    BOOST_ASSERT_MSG(!substituteSubgraph.GetLayers().empty(), "New sub-graph used for substitution must not be empty");
 
-    const SubGraph::Layers& substituteSubGraphLayers = substituteSubGraph.GetLayers();
-    std::for_each(substituteSubGraphLayers.begin(), substituteSubGraphLayers.end(), [&](Layer* layer)
+    const SubgraphView::Layers& substituteSubgraphLayers = substituteSubgraph.GetLayers();
+    std::for_each(substituteSubgraphLayers.begin(), substituteSubgraphLayers.end(), [&](Layer* layer)
     {
         BOOST_ASSERT_MSG(std::find(m_Layers.begin(), m_Layers.end(), layer) != m_Layers.end(),
                          "Substitute layer is not a member of graph");
     });
 
-    const SubGraph::InputSlots& subGraphInputSlots = subGraph.GetInputSlots();
-    const SubGraph::OutputSlots& subGraphOutputSlots = subGraph.GetOutputSlots();
+    const SubgraphView::InputSlots& subgraphInputSlots = subgraph.GetInputSlots();
+    const SubgraphView::OutputSlots& subgraphOutputSlots = subgraph.GetOutputSlots();
 
-    unsigned int subGraphNumInputSlots = boost::numeric_cast<unsigned int>(subGraphInputSlots.size());
-    unsigned int subGraphNumOutputSlots = boost::numeric_cast<unsigned int>(subGraphOutputSlots.size());
+    unsigned int subgraphNumInputSlots = boost::numeric_cast<unsigned int>(subgraphInputSlots.size());
+    unsigned int subgraphNumOutputSlots = boost::numeric_cast<unsigned int>(subgraphOutputSlots.size());
 
-    const SubGraph::InputSlots& substituteSubGraphInputSlots = substituteSubGraph.GetInputSlots();
-    const SubGraph::OutputSlots& substituteSubGraphOutputSlots = substituteSubGraph.GetOutputSlots();
+    const SubgraphView::InputSlots& substituteSubgraphInputSlots = substituteSubgraph.GetInputSlots();
+    const SubgraphView::OutputSlots& substituteSubgraphOutputSlots = substituteSubgraph.GetOutputSlots();
 
-    BOOST_ASSERT(subGraphNumInputSlots == substituteSubGraphInputSlots.size());
-    BOOST_ASSERT(subGraphNumOutputSlots == substituteSubGraphOutputSlots.size());
+    BOOST_ASSERT(subgraphNumInputSlots == substituteSubgraphInputSlots.size());
+    BOOST_ASSERT(subgraphNumOutputSlots == substituteSubgraphOutputSlots.size());
 
     // Disconnect the sub-graph and replace it with the substitute sub-graph
 
     // Step 1: process input slots
-    for (unsigned int inputSlotIdx = 0; inputSlotIdx < subGraphNumInputSlots; ++inputSlotIdx)
+    for (unsigned int inputSlotIdx = 0; inputSlotIdx < subgraphNumInputSlots; ++inputSlotIdx)
     {
-        InputSlot* subGraphInputSlot = subGraphInputSlots.at(inputSlotIdx);
-        BOOST_ASSERT(subGraphInputSlot);
+        InputSlot* subgraphInputSlot = subgraphInputSlots.at(inputSlotIdx);
+        BOOST_ASSERT(subgraphInputSlot);
 
-        IOutputSlot* connectedOutputSlot = subGraphInputSlot->GetConnection();
+        IOutputSlot* connectedOutputSlot = subgraphInputSlot->GetConnection();
         BOOST_ASSERT(connectedOutputSlot);
-        connectedOutputSlot->Disconnect(*subGraphInputSlot);
+        connectedOutputSlot->Disconnect(*subgraphInputSlot);
 
-        IInputSlot* substituteInputSlot = substituteSubGraphInputSlots.at(inputSlotIdx);
+        IInputSlot* substituteInputSlot = substituteSubgraphInputSlots.at(inputSlotIdx);
         BOOST_ASSERT(substituteInputSlot);
         connectedOutputSlot->Connect(*substituteInputSlot);
     }
 
     // Step 2: process output slots
-    for(unsigned int outputSlotIdx = 0; outputSlotIdx < subGraphNumOutputSlots; ++outputSlotIdx)
+    for(unsigned int outputSlotIdx = 0; outputSlotIdx < subgraphNumOutputSlots; ++outputSlotIdx)
     {
-        OutputSlot* subGraphOutputSlot = subGraphOutputSlots.at(outputSlotIdx);
-        BOOST_ASSERT(subGraphOutputSlot);
+        OutputSlot* subgraphOutputSlot = subgraphOutputSlots.at(outputSlotIdx);
+        BOOST_ASSERT(subgraphOutputSlot);
 
-        OutputSlot* substituteOutputSlot = substituteSubGraphOutputSlots.at(outputSlotIdx);
+        OutputSlot* substituteOutputSlot = substituteSubgraphOutputSlots.at(outputSlotIdx);
         BOOST_ASSERT(substituteOutputSlot);
-        subGraphOutputSlot->MoveAllConnections(*substituteOutputSlot);
+        subgraphOutputSlot->MoveAllConnections(*substituteOutputSlot);
     }
 }
 
-void Graph::EraseSubGraphLayers(const SubGraph &subGraph)
+void Graph::EraseSubgraphLayers(const SubgraphView &subgraph)
 {
-    for (auto layer : subGraph.GetLayers())
+    for (auto layer : subgraph.GetLayers())
     {
         EraseLayer(layer);
     }
diff --git a/src/armnn/Graph.hpp b/src/armnn/Graph.hpp
index dd6a825..cc0ccae 100644
--- a/src/armnn/Graph.hpp
+++ b/src/armnn/Graph.hpp
@@ -24,7 +24,7 @@
 namespace armnn
 {
 
-class SubGraph;
+class SubgraphView;
 
 class Graph
 {
@@ -163,8 +163,8 @@
 
     /// Substitutes the given sub-graph with either a new layer or a new sub-graph.
     /// In either case, the given layer or all the layers in the given sub-graph must belong to this graph.
-    void SubstituteSubGraph(std::unique_ptr<SubGraph> subGraph, IConnectableLayer* substituteLayer);
-    void SubstituteSubGraph(std::unique_ptr<SubGraph> subGraph, const SubGraph& substituteSubGraph);
+    void SubstituteSubgraph(std::unique_ptr<SubgraphView> subgraph, IConnectableLayer* substituteLayer);
+    void SubstituteSubgraph(std::unique_ptr<SubgraphView> subgraph, const SubgraphView& substituteSubgraph);
 
     void InferTensorInfos();
 
@@ -217,9 +217,9 @@
     std::unordered_set<LayerBindingId> m_OutputIds;
     std::unordered_map<const Layer*, Iterator> m_PosInGraphMap;
 
-    void ReplaceSubGraphConnections(const SubGraph& subGraph, IConnectableLayer* substituteLayer);
-    void ReplaceSubGraphConnections(const SubGraph& subGraph, const SubGraph& substituteSubGraph);
-    void EraseSubGraphLayers(const SubGraph &subGraph);
+    void ReplaceSubgraphConnections(const SubgraphView& subgraph, IConnectableLayer* substituteLayer);
+    void ReplaceSubgraphConnections(const SubgraphView& subgraph, const SubgraphView& substituteSubgraph);
+    void EraseSubgraphLayers(const SubgraphView &subgraph);
 
     /// Mutable to allow sorting on const object.
     mutable LayerList m_Layers;
diff --git a/src/armnn/ISubGraphConverter.hpp b/src/armnn/ISubgraphViewConverter.hpp
similarity index 85%
rename from src/armnn/ISubGraphConverter.hpp
rename to src/armnn/ISubgraphViewConverter.hpp
index 3a6866e..1f4b4e5 100644
--- a/src/armnn/ISubGraphConverter.hpp
+++ b/src/armnn/ISubgraphViewConverter.hpp
@@ -15,10 +15,10 @@
 using CompiledBlobDeleter = std::function<void(const void*)>;
 using CompiledBlobPtr = std::unique_ptr<void, CompiledBlobDeleter>;
 
-class ISubGraphConverter
+class ISubgraphViewConverter
 {
 public:
-    virtual ~ISubGraphConverter() {}
+    virtual ~ISubgraphViewConverter() {}
 
     virtual std::vector<CompiledBlobPtr> GetOutput() = 0;
 };
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index a38bcf1..9ef0c56 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -8,7 +8,7 @@
 #include "Layer.hpp"
 #include "DeviceSpec.hpp"
 #include "Optimizer.hpp"
-#include "SubGraphSelector.hpp"
+#include "SubgraphViewSelector.hpp"
 #include "BackendSettings.hpp"
 #include "optimizations/All.hpp"
 
@@ -311,11 +311,11 @@
 
 OptimizationResult AssignBackends(OptimizedNetwork* optNetObjPtr,
                                   BackendSettings& backendSettings,
-                                  SubGraph& subGraph,
+                                  SubgraphView& subgraph,
                                   Optional<std::vector<std::string>&> errMessages)
 {
-    Graph::Iterator firstLayer = subGraph.begin();
-    Graph::Iterator lastLayer  = subGraph.end();
+    Graph::Iterator firstLayer = subgraph.begin();
+    Graph::Iterator lastLayer  = subgraph.end();
     return AssignBackends(optNetObjPtr,
                           backendSettings,
                           firstLayer,
@@ -335,7 +335,7 @@
     Graph& optGraph = optNetObjPtr->GetGraph();
 
     // Get the entire graph as a sub-graph
-    SubGraph mainSubGraph(optGraph);
+    SubgraphView mainSubgraph(optGraph);
 
     // Run backend specific optimizations
     auto const& backendRegistry = BackendRegistryInstance();
@@ -346,8 +346,8 @@
         BOOST_ASSERT(backendObjPtr);
 
         // Select sub-graphs based on backend
-        SubGraphSelector::SubGraphs subGraphs =
-                SubGraphSelector::SelectSubGraphs(mainSubGraph,
+        SubgraphViewSelector::Subgraphs subgraphs =
+                SubgraphViewSelector::SelectSubgraphs(mainSubgraph,
                                                   // Select layers assigned to the requested backend
                                                   [&backendObjPtr](const Layer& layer)
                                                   {
@@ -355,18 +355,19 @@
                                                              layer.GetType() != LayerType::Output &&
                                                              layer.GetBackendId() == backendObjPtr->GetId();
                                                   });
-        if (subGraphs.empty())
+        if (subgraphs.empty())
         {
             // No sub-graphs found, try with next selected backend
             continue;
         }
 
         // Try to optimize each sub-graph
-        for (auto& subGraph : subGraphs)
+        for (auto& subgraph : subgraphs)
         {
             // Try to optimize the current sub-graph
             bool optimizationAttempted = false;
-            SubGraph::SubGraphPtr optSubGraph = backendObjPtr->OptimizeSubGraph(*subGraph, optimizationAttempted);
+            SubgraphView::SubgraphViewPtr optSubgraph = backendObjPtr->OptimizeSubgraphView(*subgraph,
+                                                                                            optimizationAttempted);
 
             // Check if the optimization has been attempted
             if (!optimizationAttempted)
@@ -376,27 +377,27 @@
             }
 
             // Optimization attempted, check the resulting optimized sub-graph
-            if (optSubGraph)
+            if (optSubgraph)
             {
                 // Sub-graph optimized, substitute the sub-graph with the new optimized one in the main optimized graph
-                optGraph.SubstituteSubGraph(std::move(subGraph), *optSubGraph);
+                optGraph.SubstituteSubgraph(std::move(subgraph), *optSubgraph);
 
                 // Assign the current backend to the optimized sub-graph
-                std::for_each(optSubGraph->begin(), optSubGraph->end(), [&selectedBackend](Layer* l)
+                std::for_each(optSubgraph->begin(), optSubgraph->end(), [&selectedBackend](Layer* l)
                 {
                     BOOST_ASSERT(l);
                     l->SetBackendId(selectedBackend);
                 });
 
                 // Recreate the sub-graph representing the entire graph
-                mainSubGraph.Update(optGraph);
+                mainSubgraph.Update(optGraph);
             }
             else
             {
                 // An error occurred: the optimization was attempted but not performed, try different backends
                 std::stringstream warningMsg;
                 warningMsg << "Sub-graph failed to get optimized on " << backendObjPtr->GetId() << ". "
-                           << "Re-assigning backends to " << subGraph->GetLayers().size() << " layers inside sub-graph";
+                           << "Re-assigning backends to " << subgraph->GetLayers().size() << " layers inside sub-graph";
                 ReportWarning(warningMsg.str(), errMessages);
 
                 // Failed to optimize the given sub-graph, re-assign the sub-graph layers to other available backends
@@ -407,7 +408,7 @@
                 }
                 OptimizationResult reassignmentResult = AssignBackends(optNetObjPtr,
                                                                        backendSettings,
-                                                                       *subGraph,
+                                                                       *subgraph,
                                                                        errMessages);
                 if (reassignmentResult.m_Error)
                 {
diff --git a/src/armnn/NetworkUtils.cpp b/src/armnn/NetworkUtils.cpp
index 126b56b..66940e4 100644
--- a/src/armnn/NetworkUtils.cpp
+++ b/src/armnn/NetworkUtils.cpp
@@ -5,7 +5,7 @@
 
 #include "NetworkUtils.hpp"
 
-#include "SubGraphSelector.hpp"
+#include "SubgraphViewSelector.hpp"
 
 #include <armnn/Exceptions.hpp>
 
diff --git a/src/armnn/SubGraphSelector.hpp b/src/armnn/SubGraphSelector.hpp
deleted file mode 100644
index 371ba78..0000000
--- a/src/armnn/SubGraphSelector.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include "SubGraph.hpp"
-#include <functional>
-#include <memory>
-
-namespace armnn
-{
-
-class Layer;
-class Graph;
-
-class SubGraphSelector final
-{
-public:
-    using SubGraphPtr = std::unique_ptr<SubGraph>;
-    using SubGraphs = std::vector<SubGraphPtr>;
-    using LayerSelectorFunction = std::function<bool(const Layer&)>;
-
-    /// Selects subgraphs from a graph based on the selector function and the algorithm.
-    /// Since the SubGraphs object returns modifiable pointers to the input and output slots of the graph:
-    ///  1) the graph/sub-graph cannot be const
-    ///  2) the caller needs to make sure that the SubGraphs lifetime is shorter than the parent graph's
-    static SubGraphs SelectSubGraphs(Graph& graph, const LayerSelectorFunction& selector);
-    static SubGraphs SelectSubGraphs(SubGraph& subGraph, const LayerSelectorFunction& selector);
-
-private:
-    // this is a utility class, don't construct or copy
-    SubGraphSelector() = delete;
-    SubGraphSelector(const SubGraphSelector&) = delete;
-    SubGraphSelector & operator=(const SubGraphSelector&) = delete;
-};
-
-} // namespace armnn
diff --git a/src/armnn/SubGraph.cpp b/src/armnn/SubgraphView.cpp
similarity index 61%
rename from src/armnn/SubGraph.cpp
rename to src/armnn/SubgraphView.cpp
index d0fc760..23f969d 100644
--- a/src/armnn/SubGraph.cpp
+++ b/src/armnn/SubgraphView.cpp
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include "SubGraph.hpp"
+#include "SubgraphView.hpp"
 #include "Graph.hpp"
 
 #include <boost/numeric/conversion/cast.hpp>
@@ -38,56 +38,59 @@
 
 } // anonymous namespace
 
-SubGraph::SubGraph(Graph& graph)
+SubgraphView::SubgraphView(Graph& graph)
     : m_InputSlots{}
     , m_OutputSlots{}
     , m_Layers(graph.begin(), graph.end())
     , m_ParentGraph(&graph)
 {
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-SubGraph::SubGraph(Graph* parentGraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers)
+SubgraphView::SubgraphView(Graph* parentGraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers)
     : m_InputSlots{inputs}
     , m_OutputSlots{outputs}
     , m_Layers{layers}
     , m_ParentGraph(parentGraph)
 {
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-SubGraph::SubGraph(const SubGraph& referenceSubGraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers)
+SubgraphView::SubgraphView(const SubgraphView& referenceSubgraph,
+                           InputSlots&& inputs,
+                           OutputSlots&& outputs,
+                           Layers&& layers)
     : m_InputSlots{inputs}
     , m_OutputSlots{outputs}
     , m_Layers{layers}
-    , m_ParentGraph(referenceSubGraph.m_ParentGraph)
+    , m_ParentGraph(referenceSubgraph.m_ParentGraph)
 {
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-SubGraph::SubGraph(const SubGraph& subGraph)
-    : m_InputSlots(subGraph.m_InputSlots.begin(), subGraph.m_InputSlots.end())
-    , m_OutputSlots(subGraph.m_OutputSlots.begin(), subGraph.m_OutputSlots.end())
-    , m_Layers(subGraph.m_Layers.begin(), subGraph.m_Layers.end())
-    , m_ParentGraph(subGraph.m_ParentGraph)
+SubgraphView::SubgraphView(const SubgraphView& subgraph)
+    : m_InputSlots(subgraph.m_InputSlots.begin(), subgraph.m_InputSlots.end())
+    , m_OutputSlots(subgraph.m_OutputSlots.begin(), subgraph.m_OutputSlots.end())
+    , m_Layers(subgraph.m_Layers.begin(), subgraph.m_Layers.end())
+    , m_ParentGraph(subgraph.m_ParentGraph)
 {
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-SubGraph::SubGraph(SubGraph&& subGraph)
-    : m_InputSlots(std::move(subGraph.m_InputSlots))
-    , m_OutputSlots(std::move(subGraph.m_OutputSlots))
-    , m_Layers(std::move(subGraph.m_Layers))
-    , m_ParentGraph(std::exchange(subGraph.m_ParentGraph, nullptr))
+SubgraphView::SubgraphView(SubgraphView&& subgraph)
+    : m_InputSlots(std::move(subgraph.m_InputSlots))
+    , m_OutputSlots(std::move(subgraph.m_OutputSlots))
+    , m_Layers(std::move(subgraph.m_Layers))
+    , m_ParentGraph(std::exchange(subgraph.m_ParentGraph, nullptr))
 {
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-SubGraph::SubGraph(const SubGraph& referenceSubGraph, IConnectableLayer* layer)
+SubgraphView::SubgraphView(const SubgraphView& referenceSubgraph, IConnectableLayer* layer)
     : m_InputSlots{}
     , m_OutputSlots{}
     , m_Layers{boost::polymorphic_downcast<Layer*>(layer)}
-    , m_ParentGraph(referenceSubGraph.m_ParentGraph)
+    , m_ParentGraph(referenceSubgraph.m_ParentGraph)
 {
     unsigned int numInputSlots = layer->GetNumInputSlots();
     m_InputSlots.resize(numInputSlots);
@@ -103,10 +106,10 @@
         m_OutputSlots.at(i) = boost::polymorphic_downcast<OutputSlot*>(&(layer->GetOutputSlot(i)));
     }
 
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-void SubGraph::CheckSubGraph()
+void SubgraphView::CheckSubgraph()
 {
     // Check that the sub-graph has a valid parent graph
     BOOST_ASSERT_MSG(m_ParentGraph, "Sub-graphs must have a parent graph");
@@ -128,87 +131,87 @@
     });
 }
 
-void SubGraph::Update(Graph &graph)
+void SubgraphView::Update(Graph &graph)
 {
     m_InputSlots.clear();
     m_OutputSlots.clear();
     m_Layers.assign(graph.begin(), graph.end());
     m_ParentGraph = &graph;
 
-    CheckSubGraph();
+    CheckSubgraph();
 }
 
-const SubGraph::InputSlots& SubGraph::GetInputSlots() const
+const SubgraphView::InputSlots& SubgraphView::GetInputSlots() const
 {
     return m_InputSlots;
 }
 
-const SubGraph::OutputSlots& SubGraph::GetOutputSlots() const
+const SubgraphView::OutputSlots& SubgraphView::GetOutputSlots() const
 {
     return m_OutputSlots;
 }
 
-const InputSlot* SubGraph::GetInputSlot(unsigned int index) const
+const InputSlot* SubgraphView::GetInputSlot(unsigned int index) const
 {
     return m_InputSlots.at(index);
 }
 
-InputSlot* SubGraph::GetInputSlot(unsigned int index)
+InputSlot* SubgraphView::GetInputSlot(unsigned int index)
 {
     return  m_InputSlots.at(index);
 }
 
-const OutputSlot* SubGraph::GetOutputSlot(unsigned int index) const
+const OutputSlot* SubgraphView::GetOutputSlot(unsigned int index) const
 {
     return m_OutputSlots.at(index);
 }
 
-OutputSlot* SubGraph::GetOutputSlot(unsigned int index)
+OutputSlot* SubgraphView::GetOutputSlot(unsigned int index)
 {
     return m_OutputSlots.at(index);
 }
 
-unsigned int SubGraph::GetNumInputSlots() const
+unsigned int SubgraphView::GetNumInputSlots() const
 {
     return boost::numeric_cast<unsigned int>(m_InputSlots.size());
 }
 
-unsigned int SubGraph::GetNumOutputSlots() const
+unsigned int SubgraphView::GetNumOutputSlots() const
 {
     return boost::numeric_cast<unsigned int>(m_OutputSlots.size());
 }
 
-const SubGraph::Layers & SubGraph::GetLayers() const
+const SubgraphView::Layers & SubgraphView::GetLayers() const
 {
     return m_Layers;
 }
 
-SubGraph::Layers::iterator SubGraph::begin()
+SubgraphView::Layers::iterator SubgraphView::begin()
 {
     return m_Layers.begin();
 }
 
-SubGraph::Iterator SubGraph::end()
+SubgraphView::Iterator SubgraphView::end()
 {
     return m_Layers.end();
 }
 
-SubGraph::ConstIterator SubGraph::begin() const
+SubgraphView::ConstIterator SubgraphView::begin() const
 {
     return m_Layers.begin();
 }
 
-SubGraph::ConstIterator SubGraph::end() const
+SubgraphView::ConstIterator SubgraphView::end() const
 {
     return m_Layers.end();
 }
 
-SubGraph::ConstIterator SubGraph::cbegin() const
+SubgraphView::ConstIterator SubgraphView::cbegin() const
 {
     return begin();
 }
 
-SubGraph::ConstIterator SubGraph::cend() const
+SubgraphView::ConstIterator SubgraphView::cend() const
 {
     return end();
 }
diff --git a/src/armnn/SubGraph.hpp b/src/armnn/SubgraphView.hpp
similarity index 76%
rename from src/armnn/SubGraph.hpp
rename to src/armnn/SubgraphView.hpp
index cb44f8c..b211ad4 100644
--- a/src/armnn/SubGraph.hpp
+++ b/src/armnn/SubgraphView.hpp
@@ -15,15 +15,15 @@
 {
 
 ///
-/// The SubGraph class represents a subgraph of a Graph.
+/// The SubgraphView class represents a subgraph of a Graph.
 /// The data it holds, points to data held by layers of the Graph, so the
-/// the contents of the SubGraph becomes invalid when the Layers are destroyed
+/// the contents of the SubgraphView becomes invalid when the Layers are destroyed
 /// or changed.
 ///
-class SubGraph final
+class SubgraphView final
 {
 public:
-    using SubGraphPtr = std::unique_ptr<SubGraph>;
+    using SubgraphViewPtr = std::unique_ptr<SubgraphView>;
     using InputSlots = std::vector<InputSlot*>;
     using OutputSlots = std::vector<OutputSlot*>;
     using Layers = std::list<Layer*>;
@@ -31,27 +31,27 @@
     using ConstIterator = Layers::const_iterator;
 
     /// Empty subgraphs are not allowed, they must at least have a parent graph.
-    SubGraph() = delete;
+    SubgraphView() = delete;
 
     /// Constructs a sub-graph from the entire given graph.
-    SubGraph(Graph& graph);
+    SubgraphView(Graph& graph);
 
     /// Constructs a sub-graph with the given arguments and binds it to the specified parent graph.
-    SubGraph(Graph* parentGraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers);
+    SubgraphView(Graph* parentGraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers);
 
     /// Constructs a sub-graph with the given arguments and uses the specified sub-graph to get a reference
     /// to the parent graph.
-    SubGraph(const SubGraph& referenceSubGraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers);
+    SubgraphView(const SubgraphView& referenceSubgraph, InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers);
 
     /// Copy-constructor.
-    SubGraph(const SubGraph& subGraph);
+    SubgraphView(const SubgraphView& subgraph);
 
     /// Move-constructor.
-    SubGraph(SubGraph&& subGraph);
+    SubgraphView(SubgraphView&& subgraph);
 
     /// Constructs a sub-graph with only the given layer and uses the specified sub-graph to get a reference
     /// to the parent graph.
-    SubGraph(const SubGraph& referenceSubGraph, IConnectableLayer* layer);
+    SubgraphView(const SubgraphView& referenceSubgraph, IConnectableLayer* layer);
 
     /// Updates this sub-graph with the contents of the whole given graph.
     void Update(Graph& graph);
@@ -83,7 +83,7 @@
     ConstIterator cend() const;
 
 private:
-    void CheckSubGraph();
+    void CheckSubgraph();
 
     /// The list of pointers to the input slots of the parent graph.
     InputSlots m_InputSlots;
@@ -99,7 +99,7 @@
 };
 
 template <typename LayerT, typename... Args>
-LayerT* SubGraph::AddLayer(Args&&... args) const
+LayerT* SubgraphView::AddLayer(Args&&... args) const
 {
     BOOST_ASSERT(m_ParentGraph);
 
diff --git a/src/armnn/SubGraphSelector.cpp b/src/armnn/SubgraphViewSelector.cpp
similarity index 79%
rename from src/armnn/SubGraphSelector.cpp
rename to src/armnn/SubgraphViewSelector.cpp
index be51a7d..7663c31 100644
--- a/src/armnn/SubGraphSelector.cpp
+++ b/src/armnn/SubgraphViewSelector.cpp
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include "SubGraphSelector.hpp"
+#include "SubgraphViewSelector.hpp"
 #include "Graph.hpp"
 #include <boost/assert.hpp>
 #include <algorithm>
@@ -20,7 +20,7 @@
     using LayerInfoContainer = std::unordered_map<Layer*, LayerSelectionInfo>;
     static constexpr uint32_t InitialSplitId() { return 1; }
 
-    LayerSelectionInfo(Layer* layer, const SubGraphSelector::LayerSelectorFunction& selector)
+    LayerSelectionInfo(Layer* layer, const SubgraphViewSelector::LayerSelectorFunction& selector)
     : m_Layer{layer}
     , m_SplitId{0}
     , m_IsSelected{selector(*layer)}
@@ -76,8 +76,8 @@
         return m_Layer->GetType() == armnn::LayerType::Input;
     }
 
-    void CollectNonSelectedInputs(SubGraph::InputSlots& inputSlots,
-                                  const SubGraphSelector::LayerSelectorFunction& selector)
+    void CollectNonSelectedInputs(SubgraphView::InputSlots& inputSlots,
+                                  const SubgraphViewSelector::LayerSelectorFunction& selector)
     {
         for (auto&& slot = m_Layer->BeginInputSlots(); slot != m_Layer->EndInputSlots(); ++slot)
         {
@@ -94,8 +94,8 @@
         }
     }
 
-    void CollectNonSelectedOutputSlots(SubGraph::OutputSlots& outputSlots,
-                                       const SubGraphSelector::LayerSelectorFunction& selector)
+    void CollectNonSelectedOutputSlots(SubgraphView::OutputSlots& outputSlots,
+                                       const SubgraphViewSelector::LayerSelectorFunction& selector)
     {
         for (auto&& slot = m_Layer->BeginOutputSlots(); slot != m_Layer->EndOutputSlots(); ++slot)
         {
@@ -119,19 +119,19 @@
 
 } // namespace <anonymous>
 
-SubGraphSelector::SubGraphs
-SubGraphSelector::SelectSubGraphs(Graph& graph, const LayerSelectorFunction& selector)
+SubgraphViewSelector::Subgraphs
+SubgraphViewSelector::SelectSubgraphs(Graph& graph, const LayerSelectorFunction& selector)
 {
-    SubGraph subGraph(graph);
-    return SubGraphSelector::SelectSubGraphs(subGraph, selector);
+    SubgraphView subgraph(graph);
+    return SubgraphViewSelector::SelectSubgraphs(subgraph, selector);
 }
 
-SubGraphSelector::SubGraphs
-SubGraphSelector::SelectSubGraphs(SubGraph& subGraph, const LayerSelectorFunction& selector)
+SubgraphViewSelector::Subgraphs
+SubgraphViewSelector::SelectSubgraphs(SubgraphView& subgraph, const LayerSelectorFunction& selector)
 {
     LayerSelectionInfo::LayerInfoContainer layerInfo;
 
-    for (auto& layer : subGraph)
+    for (auto& layer : subgraph)
     {
         layerInfo.emplace(layer, LayerSelectionInfo{layer, selector});
     }
@@ -168,14 +168,14 @@
     }
 
     // Now each non-empty split id represents a subgraph
-    SubGraphs result;
+    Subgraphs result;
     for (auto& splitGraph : splitMap)
     {
         if (splitGraph.second.empty() == false)
         {
-            SubGraph::InputSlots inputs;
-            SubGraph::OutputSlots outputs;
-            SubGraph::Layers layers;
+            SubgraphView::InputSlots inputs;
+            SubgraphView::OutputSlots outputs;
+            SubgraphView::Layers layers;
             for (auto&& infoPtr : splitGraph.second)
             {
                 infoPtr->CollectNonSelectedInputs(inputs, selector);
@@ -184,10 +184,10 @@
             }
             // Create a new sub-graph with the new lists of input/output slots and layer, using
             // the given sub-graph as a reference of which parent graph to use
-            result.emplace_back(std::make_unique<SubGraph>(subGraph,
-                                                           std::move(inputs),
-                                                           std::move(outputs),
-                                                           std::move(layers)));
+            result.emplace_back(std::make_unique<SubgraphView>(subgraph,
+                                                               std::move(inputs),
+                                                               std::move(outputs),
+                                                               std::move(layers)));
         }
     }
 
diff --git a/src/armnn/SubgraphViewSelector.hpp b/src/armnn/SubgraphViewSelector.hpp
new file mode 100644
index 0000000..9d881fa
--- /dev/null
+++ b/src/armnn/SubgraphViewSelector.hpp
@@ -0,0 +1,38 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "SubgraphView.hpp"
+#include <functional>
+#include <memory>
+
+namespace armnn
+{
+
+class Layer;
+class Graph;
+
+class SubgraphViewSelector final
+{
+public:
+    using SubgraphViewPtr = std::unique_ptr<SubgraphView>;
+    using Subgraphs = std::vector<SubgraphViewPtr>;
+    using LayerSelectorFunction = std::function<bool(const Layer&)>;
+
+    /// Selects subgraphs from a graph based on the selector function and the algorithm.
+    /// Since the Subgraphs object returns modifiable pointers to the input and output slots of the graph:
+    ///  1) the graph/sub-graph cannot be const
+    ///  2) the caller needs to make sure that the Subgraphs lifetime is shorter than the parent graph's
+    static Subgraphs SelectSubgraphs(Graph& graph, const LayerSelectorFunction& selector);
+    static Subgraphs SelectSubgraphs(SubgraphView& subgraph, const LayerSelectorFunction& selector);
+
+private:
+    // this is a utility class, don't construct or copy
+    SubgraphViewSelector() = delete;
+    SubgraphViewSelector(const SubgraphViewSelector&) = delete;
+    SubgraphViewSelector & operator=(const SubgraphViewSelector&) = delete;
+};
+
+} // namespace armnn
diff --git a/src/armnn/layers/PreCompiledLayer.cpp b/src/armnn/layers/PreCompiledLayer.cpp
index 29b3514..963924d 100644
--- a/src/armnn/layers/PreCompiledLayer.cpp
+++ b/src/armnn/layers/PreCompiledLayer.cpp
@@ -38,7 +38,7 @@
 
 void PreCompiledLayer::ValidateTensorShapesFromInputs()
 {
-    // NOTE: since the PreCompiledLayer is an internal layer created from a valid SubGraph,
+    // NOTE: since the PreCompiledLayer is an internal layer created from a valid SubgraphView,
     // we do not need to validate its input shapes
 }
 
diff --git a/src/armnn/test/SubGraphTests.cpp b/src/armnn/test/SubgraphViewTests.cpp
similarity index 71%
rename from src/armnn/test/SubGraphTests.cpp
rename to src/armnn/test/SubgraphViewTests.cpp
index e5b444a..603bb15 100644
--- a/src/armnn/test/SubGraphTests.cpp
+++ b/src/armnn/test/SubgraphViewTests.cpp
@@ -7,8 +7,8 @@
 #include <armnn/ArmNN.hpp>
 
 #include <Graph.hpp>
-#include <SubGraph.hpp>
-#include <SubGraphSelector.hpp>
+#include <SubgraphView.hpp>
+#include <SubgraphViewSelector.hpp>
 
 #include <backendsCommon/CpuTensorHandle.hpp>
 
@@ -17,9 +17,9 @@
 namespace
 {
 
-bool AreAnySubGraphLayersPresentInGraph(const SubGraph::Layers &subGraphLayers, const Graph &graph)
+bool AreAnySubgraphLayersPresentInGraph(const SubgraphView::Layers &subgraphLayers, const Graph &graph)
 {
-    for(auto&& layer : subGraphLayers)
+    for(auto&& layer : subgraphLayers)
     {
         auto posInGraph = std::find(graph.begin(), graph.end(), layer);
         if(posInGraph != graph.end())
@@ -34,9 +34,9 @@
 //
 // this helper only works if all layers where the inputs connect to are not selected
 //
-SubGraph::InputSlots CreateInputsFrom(const std::vector<Layer*>& layers)
+SubgraphView::InputSlots CreateInputsFrom(const std::vector<Layer*>& layers)
 {
-    SubGraph::InputSlots result;
+    SubgraphView::InputSlots result;
     for (auto&& layer : layers)
     {
         for (auto&& it = layer->BeginInputSlots(); it != layer->EndInputSlots(); ++it)
@@ -50,9 +50,9 @@
 //
 // this helper only works if all layers where the outputs connect to are not selected
 //
-SubGraph::OutputSlots CreateOutputsFrom(const std::vector<Layer*>& layers)
+SubgraphView::OutputSlots CreateOutputsFrom(const std::vector<Layer*>& layers)
 {
-    SubGraph::OutputSlots result;
+    SubgraphView::OutputSlots result;
     for (auto && layer : layers)
     {
         for (auto&& it = layer->BeginOutputSlots(); it != layer->EndOutputSlots(); ++it)
@@ -67,12 +67,12 @@
 // this takes the inputs, outputs and layers as a copy and the move these copies into the
 // resulting subgraph, so the pass bay value is intentional
 //
-SubGraphSelector::SubGraphPtr CreateSubGraphFrom(Graph& graph,
-                                                 SubGraph::InputSlots&& inputs,
-                                                 SubGraph::OutputSlots&& outputs,
-                                                 SubGraph::Layers&& layers)
+SubgraphViewSelector::SubgraphViewPtr CreateSubgraphViewFrom(Graph& graph,
+                                                             SubgraphView::InputSlots&& inputs,
+                                                             SubgraphView::OutputSlots&& outputs,
+                                                             SubgraphView::Layers&& layers)
 {
-    return std::make_unique<SubGraph>(&graph, std::move(inputs), std::move(outputs), std::move(layers));
+    return std::make_unique<SubgraphView>(&graph, std::move(inputs), std::move(outputs), std::move(layers));
 }
 
 template <typename T, typename Iterator>
@@ -84,13 +84,13 @@
 }
 
 template <typename T>
-void CompareVectors(const std::vector<T> & result, const std::vector<T> & expected)
+void CompareVectors(const std::vector<T>& result, const std::vector<T>& expected)
 {
     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
 }
 
-void CompareSubGraphs(SubGraphSelector::SubGraphPtr & result,
-                      SubGraphSelector::SubGraphPtr & expected)
+void CompareSubgraphViews(SubgraphViewSelector::SubgraphViewPtr& result,
+                          SubgraphViewSelector::SubgraphViewPtr& expected)
 {
     // expect both to be valid subgraphs
     BOOST_TEST((result.get() != nullptr));
@@ -127,7 +127,7 @@
 
 } // namespace <anonymous>
 
-BOOST_AUTO_TEST_SUITE(SubGraphSubstitution)
+BOOST_AUTO_TEST_SUITE(SubgraphSubstitution)
 
 BOOST_AUTO_TEST_CASE(SingleInputSingleOutput)
 {
@@ -147,25 +147,25 @@
     convLayer2->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     // Construct sub-graph
-    SubGraphSelector::SubGraphPtr subGraph = CreateSubGraphFrom(graph,
-                                                                CreateInputsFrom({convLayer1}),
-                                                                CreateOutputsFrom({convLayer2}),
-                                                                {});
+    SubgraphViewSelector::SubgraphViewPtr subgraph = CreateSubgraphViewFrom(graph,
+                                                                            CreateInputsFrom({convLayer1}),
+                                                                            CreateOutputsFrom({convLayer2}),
+                                                                            {});
 
     // Save sub-graph connections for comparison after substitution
-    IOutputSlot* subGraphInputConn = subGraph->GetInputSlot(0)->GetConnection();
-    IInputSlot* subGraphOutputConn = subGraph->GetOutputSlot(0)->GetConnection(0);
+    IOutputSlot* subgraphInputConn = subgraph->GetInputSlot(0)->GetConnection();
+    IInputSlot* subgraphOutputConn = subgraph->GetOutputSlot(0)->GetConnection(0);
 
     // Construct dummy pre-compiled layer
     PreCompiledDescriptor preCompiledDescriptor(1, 1);
     Layer* const preCompiledLayer = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
 
     // Substitute sub-graph with pre-compiled layer
-    graph.SubstituteSubGraph(std::move(subGraph), preCompiledLayer);
+    graph.SubstituteSubgraph(std::move(subgraph), preCompiledLayer);
 
     // Check that connections are correct after substitution
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subGraphInputConn);
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subGraphOutputConn);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subgraphInputConn);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subgraphOutputConn);
 }
 
 BOOST_AUTO_TEST_CASE(MultiInputSingleOutput)
@@ -195,29 +195,29 @@
     mergerLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     // Construct sub-graph
-    SubGraphSelector::SubGraphPtr subGraph = CreateSubGraphFrom(graph,
-                                                                CreateInputsFrom({convLayer1, convLayer2}),
-                                                                CreateOutputsFrom({mergerLayer}),
-                                                                {});
+    SubgraphViewSelector::SubgraphViewPtr subgraph = CreateSubgraphViewFrom(graph,
+                                                                            CreateInputsFrom({convLayer1, convLayer2}),
+                                                                            CreateOutputsFrom({mergerLayer}),
+                                                                            {});
 
     // Save sub-graph connections for comparison after substitution
-    IOutputSlot* subGraphInputConn1 = subGraph->GetInputSlot(0)->GetConnection();
-    IOutputSlot* subGraphInputConn2 = subGraph->GetInputSlot(1)->GetConnection();
+    IOutputSlot* subgraphInputConn1 = subgraph->GetInputSlot(0)->GetConnection();
+    IOutputSlot* subgraphInputConn2 = subgraph->GetInputSlot(1)->GetConnection();
 
-    IInputSlot* subGraphOutputConn = subGraph->GetOutputSlot(0)->GetConnection(0);
+    IInputSlot* subgraphOutputConn = subgraph->GetOutputSlot(0)->GetConnection(0);
 
     // Construct dummy pre-compiled layer
     PreCompiledDescriptor preCompiledDescriptor(2, 1);
     Layer* const preCompiledLayer = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
 
     // Substitute sub-graph with pre-compiled layer
-    graph.SubstituteSubGraph(std::move(subGraph), preCompiledLayer);
+    graph.SubstituteSubgraph(std::move(subgraph), preCompiledLayer);
 
     // Check that connections are correct after substitution
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subGraphInputConn1);
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(1).GetConnection(), subGraphInputConn2);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subgraphInputConn1);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(1).GetConnection(), subgraphInputConn2);
 
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subGraphOutputConn);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subgraphOutputConn);
 }
 
 BOOST_AUTO_TEST_CASE(SingleInputMultiOutput)
@@ -245,29 +245,29 @@
     mergerLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     // Construct sub-graph
-    SubGraphSelector::SubGraphPtr subGraph = CreateSubGraphFrom(graph,
-                                                                CreateInputsFrom({splitterLayer}),
-                                                                CreateOutputsFrom({convLayer1, convLayer2}),
-                                                                {});
+    SubgraphViewSelector::SubgraphViewPtr subgraph = CreateSubgraphViewFrom(graph,
+                                                                            CreateInputsFrom({splitterLayer}),
+                                                                            CreateOutputsFrom({convLayer1, convLayer2}),
+                                                                            {});
 
     // Save sub-graph connections for comparison after substitution
-    IOutputSlot* subGraphInputConn1 = subGraph->GetInputSlot(0)->GetConnection();
+    IOutputSlot* subgraphInputConn1 = subgraph->GetInputSlot(0)->GetConnection();
 
-    IInputSlot* subGraphOutputConn1 = subGraph->GetOutputSlot(0)->GetConnection(0);
-    IInputSlot* subGraphOutputConn2 = subGraph->GetOutputSlot(1)->GetConnection(0);
+    IInputSlot* subgraphOutputConn1 = subgraph->GetOutputSlot(0)->GetConnection(0);
+    IInputSlot* subgraphOutputConn2 = subgraph->GetOutputSlot(1)->GetConnection(0);
 
     // Construct dummy pre-compiled layer
     PreCompiledDescriptor preCompiledDescriptor(1, 2);
     Layer* const preCompiledLayer = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
 
     // Substitute sub-graph with pre-compiled layer
-    graph.SubstituteSubGraph(std::move(subGraph), preCompiledLayer);
+    graph.SubstituteSubgraph(std::move(subgraph), preCompiledLayer);
 
     // Check that connections are correct after substitution
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subGraphInputConn1);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subgraphInputConn1);
 
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subGraphOutputConn1);
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(1).GetConnection(0), subGraphOutputConn2);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subgraphOutputConn1);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(1).GetConnection(0), subgraphOutputConn2);
 }
 
 BOOST_AUTO_TEST_CASE(MultiInputMultiOutput)
@@ -297,31 +297,31 @@
     mergerLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     // Construct sub-graph
-    SubGraphSelector::SubGraphPtr subGraph = CreateSubGraphFrom(graph,
-                                                                CreateInputsFrom({convLayer1, convLayer2}),
-                                                                CreateOutputsFrom({convLayer1, convLayer2}),
-                                                                {});
+    SubgraphViewSelector::SubgraphViewPtr subgraph = CreateSubgraphViewFrom(graph,
+                                                                            CreateInputsFrom({convLayer1, convLayer2}),
+                                                                            CreateOutputsFrom({convLayer1, convLayer2}),
+                                                                            {});
 
     // Save sub-graph connections for comparison after substitution
-    IOutputSlot* subGraphInputConn1 = subGraph->GetInputSlot(0)->GetConnection();
-    IOutputSlot* subGraphInputConn2 = subGraph->GetInputSlot(1)->GetConnection();
+    IOutputSlot* subgraphInputConn1 = subgraph->GetInputSlot(0)->GetConnection();
+    IOutputSlot* subgraphInputConn2 = subgraph->GetInputSlot(1)->GetConnection();
 
-    IInputSlot* subGraphOutputConn1 = subGraph->GetOutputSlot(0)->GetConnection(0);
-    IInputSlot* subGraphOutputConn2 = subGraph->GetOutputSlot(1)->GetConnection(0);
+    IInputSlot* subgraphOutputConn1 = subgraph->GetOutputSlot(0)->GetConnection(0);
+    IInputSlot* subgraphOutputConn2 = subgraph->GetOutputSlot(1)->GetConnection(0);
 
     // Construct dummy pre-compiled layer
     PreCompiledDescriptor preCompiledDescriptor(2, 2);
     Layer* const preCompiledLayer = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
 
     // Substitute sub-graph with pre-compiled layer
-    graph.SubstituteSubGraph(std::move(subGraph), preCompiledLayer);
+    graph.SubstituteSubgraph(std::move(subgraph), preCompiledLayer);
 
     // Check that connections are correct after substitution
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subGraphInputConn1);
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(1).GetConnection(), subGraphInputConn2);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subgraphInputConn1);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(1).GetConnection(), subgraphInputConn2);
 
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subGraphOutputConn1);
-    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(1).GetConnection(0), subGraphOutputConn2);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subgraphOutputConn1);
+    BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(1).GetConnection(0), subgraphOutputConn2);
 }
 
 BOOST_AUTO_TEST_CASE(EraseReplacedLayers)
@@ -344,40 +344,43 @@
     graph.AddLayer<OutputLayer>(0, "output");
 
     // Construct sub-graph
-    SubGraphSelector::SubGraphPtr subGraph = CreateSubGraphFrom(graph,
-                                                                {},
-                                                                {},
-                                                                {splitterLayer, convLayer1, convLayer2, mergerLayer});
+    SubgraphViewSelector::SubgraphViewPtr subgraph = CreateSubgraphViewFrom(graph,
+                                                                            {},
+                                                                            {},
+                                                                            {splitterLayer,
+                                                                             convLayer1,
+                                                                             convLayer2,
+                                                                             mergerLayer});
 
     // Construct dummy pre-compiled layer
     PreCompiledDescriptor preCompiledDescriptor(0, 0);
     Layer* const preCompiledLayer = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
 
     // Save sub-graph layers for later verification
-    const SubGraph::Layers subGraphLayers = subGraph->GetLayers();
+    const SubgraphView::Layers subgraphLayers = subgraph->GetLayers();
 
     // Substitute sub-graph with pre-compiled layer
-    graph.SubstituteSubGraph(std::move(subGraph), preCompiledLayer);
+    graph.SubstituteSubgraph(std::move(subgraph), preCompiledLayer);
 
     // Check that the layers belonging to the sub-graph have been erased from the graph after substitution
-    BOOST_CHECK(!AreAnySubGraphLayersPresentInGraph(subGraphLayers, graph));
+    BOOST_CHECK(!AreAnySubgraphLayersPresentInGraph(subgraphLayers, graph));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
 
-BOOST_AUTO_TEST_SUITE(SubGraphSelection)
+BOOST_AUTO_TEST_SUITE(SubgraphSelection)
 
-BOOST_AUTO_TEST_CASE(SubGraphForEmptyGraph)
+BOOST_AUTO_TEST_CASE(SubgraphForEmptyGraph)
 {
     Graph graph;
-    SubGraph subGraph(graph);
+    SubgraphView subgraph(graph);
 
-    BOOST_TEST(subGraph.GetInputSlots().empty());
-    BOOST_TEST(subGraph.GetOutputSlots().empty());
-    BOOST_TEST(subGraph.GetLayers().empty());
+    BOOST_TEST(subgraph.GetInputSlots().empty());
+    BOOST_TEST(subgraph.GetOutputSlots().empty());
+    BOOST_TEST(subgraph.GetLayers().empty());
 }
 
-BOOST_AUTO_TEST_CASE(SubGraphForEntireGraph)
+BOOST_AUTO_TEST_CASE(SubgraphForEntireGraph)
 {
     Graph graph;
 
@@ -390,35 +393,35 @@
                                                       "mid1");
     graph.InsertNewLayer<InputLayer>(mid1->GetInputSlot(0), 0, "input");
 
-    SubGraph subGraph(graph);
+    SubgraphView subgraph(graph);
 
-    BOOST_TEST(subGraph.GetInputSlots().empty());
-    BOOST_TEST(subGraph.GetOutputSlots().empty());
-    BOOST_TEST(subGraph.GetLayers().size() == graph.GetNumLayers());
+    BOOST_TEST(subgraph.GetInputSlots().empty());
+    BOOST_TEST(subgraph.GetOutputSlots().empty());
+    BOOST_TEST(subgraph.GetLayers().size() == graph.GetNumLayers());
 }
 
-BOOST_AUTO_TEST_CASE(NoSubGraphsForNoMatch)
+BOOST_AUTO_TEST_CASE(NoSubgraphsForNoMatch)
 {
     Graph graph;
 
     auto output = graph.AddLayer<OutputLayer>(0, "output");
     graph.InsertNewLayer<InputLayer>(output->GetInputSlot(0), 0, "input");
 
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(graph, [](const Layer &) { return false; });
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(graph, [](const Layer &) { return false; });
 
-    BOOST_TEST(subGraphs.empty());
+    BOOST_TEST(subgraphs.empty());
 }
 
-BOOST_AUTO_TEST_CASE(OneSubGraphsSelectedASingleMatch)
+BOOST_AUTO_TEST_CASE(OneSubgraphsSelectedASingleMatch)
 {
     Graph graph;
 
     auto output = graph.AddLayer<OutputLayer>(0, "output");
     graph.InsertNewLayer<InputLayer>(output->GetInputSlot(0), 0, "input");
 
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select the output layer only
             [](const Layer & l)
@@ -427,16 +430,16 @@
                 return isOutput;
             });
 
-    BOOST_TEST(subGraphs.size() == 1);
-    if (subGraphs.size() == 1)
+    BOOST_TEST(subgraphs.size() == 1);
+    if (subgraphs.size() == 1)
     {
-        auto expected = CreateSubGraphFrom(graph,
-                                           CreateInputsFrom({output}),
-                                           // outputs of 'output' will be empty
-                                           CreateOutputsFrom({output}),
-                                           {output});
+        auto expected = CreateSubgraphViewFrom(graph,
+                                               CreateInputsFrom({output}),
+                                               // outputs of 'output' will be empty
+                                               CreateOutputsFrom({output}),
+                                               {output});
 
-        CompareSubGraphs(subGraphs[0], expected);
+        CompareSubgraphViews(subgraphs[0], expected);
     }
 }
 
@@ -453,8 +456,8 @@
                                                       "mid1");
     graph.InsertNewLayer<InputLayer>(mid1->GetInputSlot(0), 0, "input");
 
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select the middle layers only
             [](const Layer & l)
@@ -463,15 +466,15 @@
                 return toSelect;
             });
 
-    BOOST_TEST(subGraphs.size() == 1);
-    if (subGraphs.size() == 1)
+    BOOST_TEST(subgraphs.size() == 1);
+    if (subgraphs.size() == 1)
     {
-        auto expected = CreateSubGraphFrom(graph,
-                                           CreateInputsFrom({mid1}),
-                                           CreateOutputsFrom({mid0}),
-                                           {mid1, mid0});
+        auto expected = CreateSubgraphViewFrom(graph,
+                                               CreateInputsFrom({mid1}),
+                                               CreateOutputsFrom({mid0}),
+                                               {mid1, mid0});
 
-        CompareSubGraphs(subGraphs[0], expected);
+        CompareSubgraphViews(subgraphs[0], expected);
     }
 }
 
@@ -527,8 +530,8 @@
     x0->GetOutputSlot(0).Connect(m4->GetInputSlot(0));
 
     // All selected 'M*' layers will be of Activation type
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select the middle layers only
             [](const Layer & l)
@@ -538,44 +541,44 @@
             });
 
     // expected results to test against
-    auto largerSubGraph = CreateSubGraphFrom(graph,
-                                             CreateInputsFrom({m1, m4}),
-                                             CreateOutputsFrom({m3, m4}),
-                                             {m1, m4, m2, m3});
+    auto largerSubgraph = CreateSubgraphViewFrom(graph,
+                                                 CreateInputsFrom({m1, m4}),
+                                                 CreateOutputsFrom({m3, m4}),
+                                                 {m1, m4, m2, m3});
 
-    auto smallerSubGraph = CreateSubGraphFrom(graph,
-                                              CreateInputsFrom({m5}),
-                                              CreateOutputsFrom({m5}),
-                                              {m5});
+    auto smallerSubgraph = CreateSubgraphViewFrom(graph,
+                                                  CreateInputsFrom({m5}),
+                                                  CreateOutputsFrom({m5}),
+                                                  {m5});
 
-    BOOST_TEST(subGraphs.size() == 2);
-    if (subGraphs.size() == 2)
+    BOOST_TEST(subgraphs.size() == 2);
+    if (subgraphs.size() == 2)
     {
         // we need to have valid subgraph pointers here
-        BOOST_TEST((subGraphs[0] != nullptr));
-        BOOST_TEST((subGraphs[1] != nullptr));
+        BOOST_TEST((subgraphs[0] != nullptr));
+        BOOST_TEST((subgraphs[1] != nullptr));
 
-        if (subGraphs[0].get() != nullptr && subGraphs[1].get() != nullptr)
+        if (subgraphs[0].get() != nullptr && subgraphs[1].get() != nullptr)
         {
             // sort the subgraphs by layer size, so it is simpler to test
-            std::sort(subGraphs.begin(), subGraphs.end(),
-                [](SubGraphSelector::SubGraphPtr & lhs, SubGraphSelector::SubGraphPtr & rhs)
+            std::sort(subgraphs.begin(), subgraphs.end(),
+                [](SubgraphViewSelector::SubgraphViewPtr & lhs, SubgraphViewSelector::SubgraphViewPtr & rhs)
                 {
                     return (lhs->GetLayers().size() < rhs->GetLayers().size());
                 }
             );
 
             // one subgraph needs to be size=1 and the other one is 4
-            BOOST_TEST(subGraphs[0]->GetLayers().size() == 1);
-            BOOST_TEST(subGraphs[1]->GetLayers().size() == 4);
+            BOOST_TEST(subgraphs[0]->GetLayers().size() == 1);
+            BOOST_TEST(subgraphs[1]->GetLayers().size() == 4);
 
-            CompareSubGraphs(subGraphs[0], smallerSubGraph);
-            CompareSubGraphs(subGraphs[1], largerSubGraph);
+            CompareSubgraphViews(subgraphs[0], smallerSubgraph);
+            CompareSubgraphViews(subgraphs[1], largerSubgraph);
         }
     }
 }
 
-BOOST_AUTO_TEST_CASE(MultipleSimpleSubGraphs)
+BOOST_AUTO_TEST_CASE(MultipleSimpleSubgraphs)
 {
     // This test case represents the scenario when we have two distinct subgraphs
     // in a simple linear network. The selected nodes are the M* and the
@@ -605,8 +608,8 @@
     graph.InsertNewLayer<InputLayer>(m1->GetInputSlot(0), 0, "x1");
 
     // All selected 'M*' layers will be of Activation type
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select the middle layers only
             [](const Layer & l)
@@ -616,38 +619,38 @@
             });
 
     // expected results to test against
-    auto largerSubGraph = CreateSubGraphFrom(graph,
-                                             CreateInputsFrom({m1}),
-                                             CreateOutputsFrom({m2}),
-                                             {m1, m2});
+    auto largerSubgraph = CreateSubgraphViewFrom(graph,
+                                                 CreateInputsFrom({m1}),
+                                                 CreateOutputsFrom({m2}),
+                                                 {m1, m2});
 
-    auto smallerSubGraph = CreateSubGraphFrom(graph,
-                                              CreateInputsFrom({m3}),
-                                              CreateOutputsFrom({m3}),
-                                              {m3});
+    auto smallerSubgraph = CreateSubgraphViewFrom(graph,
+                                                  CreateInputsFrom({m3}),
+                                                  CreateOutputsFrom({m3}),
+                                                  {m3});
 
-    BOOST_TEST(subGraphs.size() == 2);
-    if (subGraphs.size() == 2)
+    BOOST_TEST(subgraphs.size() == 2);
+    if (subgraphs.size() == 2)
     {
         // we need to have valid subgraph pointers here
-        BOOST_TEST((subGraphs[0] != nullptr));
-        BOOST_TEST((subGraphs[1] != nullptr));
+        BOOST_TEST((subgraphs[0] != nullptr));
+        BOOST_TEST((subgraphs[1] != nullptr));
 
-        if (subGraphs[0].get() != nullptr && subGraphs[1].get() != nullptr)
+        if (subgraphs[0].get() != nullptr && subgraphs[1].get() != nullptr)
         {
             // sort the subgraphs by layer size, so it is simpler to test
-            std::sort(subGraphs.begin(), subGraphs.end(),
-                [](SubGraphSelector::SubGraphPtr & lhs, SubGraphSelector::SubGraphPtr & rhs)
+            std::sort(subgraphs.begin(), subgraphs.end(),
+                [](SubgraphViewSelector::SubgraphViewPtr & lhs, SubgraphViewSelector::SubgraphViewPtr & rhs)
                 {
                     return (lhs->GetLayers().size() < rhs->GetLayers().size());
                 }
             );
 
-            BOOST_TEST(subGraphs[0]->GetLayers().size() == 1);
-            BOOST_TEST(subGraphs[1]->GetLayers().size() == 2);
+            BOOST_TEST(subgraphs[0]->GetLayers().size() == 1);
+            BOOST_TEST(subgraphs[1]->GetLayers().size() == 2);
 
-            CompareSubGraphs(subGraphs[0], smallerSubGraph);
-            CompareSubGraphs(subGraphs[1], largerSubGraph);
+            CompareSubgraphViews(subgraphs[0], smallerSubgraph);
+            CompareSubgraphViews(subgraphs[1], largerSubgraph);
         }
     }
 }
@@ -677,8 +680,8 @@
     layerM1->GetOutputSlot(0).Connect(layerM2->GetInputSlot(0));
     layerM2->GetOutputSlot(0).Connect(layerX2->GetInputSlot(0));
 
-    SubGraphSelector::SubGraphs subGraphs =
-            SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+            SubgraphViewSelector::SelectSubgraphs(
                     graph,
                     // select the activation layers M1 and M2
                     [](const Layer & l)
@@ -687,15 +690,15 @@
                         return toSelect;
                     });
 
-    BOOST_CHECK(subGraphs.size() == 1);
-    if(subGraphs.size() == 1)
+    BOOST_CHECK(subgraphs.size() == 1);
+    if(subgraphs.size() == 1)
     {
-        auto expected = CreateSubGraphFrom(graph,
-                                           CreateInputsFrom({layerM1}),
-                                           CreateOutputsFrom({layerM2}),
-                                           {layerM1, layerM2});
+        auto expected = CreateSubgraphViewFrom(graph,
+                                               CreateInputsFrom({layerM1}),
+                                               CreateOutputsFrom({layerM2}),
+                                               {layerM1, layerM2});
 
-        CompareSubGraphs(subGraphs[0], expected);
+        CompareSubgraphViews(subgraphs[0], expected);
     }
 }
 
@@ -732,8 +735,8 @@
     layerM2->GetOutputSlot(0).Connect(layerM3->GetInputSlot(1));
     layerM3->GetOutputSlot(0).Connect(layerX3->GetInputSlot(0));
 
-    SubGraphSelector::SubGraphs subGraphs =
-            SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+            SubgraphViewSelector::SelectSubgraphs(
                     graph,
                     // select Activation and Addition Layers M1, M2 and M3
                     [](const Layer & l)
@@ -743,15 +746,15 @@
                         return toSelect;
                     });
 
-    BOOST_CHECK(subGraphs.size() == 1);
-    if (subGraphs.size() == 1)
+    BOOST_CHECK(subgraphs.size() == 1);
+    if (subgraphs.size() == 1)
     {
-        auto expected = CreateSubGraphFrom(graph,
-                                           CreateInputsFrom({layerM1, layerM2}),
-                                           CreateOutputsFrom({layerM3}),
-                                           {layerM1, layerM2, layerM3});
+        auto expected = CreateSubgraphViewFrom(graph,
+                                               CreateInputsFrom({layerM1, layerM2}),
+                                               CreateOutputsFrom({layerM3}),
+                                               {layerM1, layerM2, layerM3});
 
-        CompareSubGraphs(subGraphs[0], expected);
+        CompareSubgraphViews(subgraphs[0], expected);
     }
 }
 
@@ -789,8 +792,8 @@
     layerM2->GetOutputSlot(0).Connect(layerX2->GetInputSlot(0));
     layerM3->GetOutputSlot(0).Connect(layerX3->GetInputSlot(0));
 
-    SubGraphSelector::SubGraphs subGraphs =
-            SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+            SubgraphViewSelector::SelectSubgraphs(
                     graph,
                     // select Activation and Splitter Layers M1, M2 and M3
                     [](const Layer & l)
@@ -800,15 +803,15 @@
                         return toSelect;
                     });
 
-    BOOST_CHECK(subGraphs.size() == 1);
-    if(subGraphs.size() == 1)
+    BOOST_CHECK(subgraphs.size() == 1);
+    if(subgraphs.size() == 1)
     {
-        auto expected = CreateSubGraphFrom(graph,
-                                           CreateInputsFrom({layerM1}),
-                                           CreateOutputsFrom({layerM2, layerM3}),
-                                           {layerM1, layerM2, layerM3});
+        auto expected = CreateSubgraphViewFrom(graph,
+                                               CreateInputsFrom({layerM1}),
+                                               CreateOutputsFrom({layerM2, layerM3}),
+                                               {layerM1, layerM2, layerM3});
 
-        CompareSubGraphs(subGraphs[0], expected);
+        CompareSubgraphViews(subgraphs[0], expected);
     }
 }
 
@@ -853,8 +856,8 @@
     m5->GetOutputSlot(0).Connect(x4->GetInputSlot(0));
 
 
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select Activation and Merger Layers M1, M2, M3, M4, M5
             [](const Layer & l)
@@ -865,15 +868,15 @@
             });
 
 
-    BOOST_CHECK(subGraphs.size() == 1);
-    if (subGraphs.size() == 1)
+    BOOST_CHECK(subgraphs.size() == 1);
+    if (subgraphs.size() == 1)
     {
-        auto expected = CreateSubGraphFrom(graph,
-                                           CreateInputsFrom({m1, m2}),
-                                           CreateOutputsFrom({m4, m5}),
-                                           {m1, m2, m3, m4, m5});
+        auto expected = CreateSubgraphViewFrom(graph,
+                                               CreateInputsFrom({m1, m2}),
+                                               CreateOutputsFrom({m4, m5}),
+                                               {m1, m2, m3, m4, m5});
 
-        CompareSubGraphs(subGraphs[0], expected);
+        CompareSubgraphViews(subgraphs[0], expected);
     }
 }
 
@@ -881,7 +884,7 @@
 
 BOOST_AUTO_TEST_SUITE(IntegrationTests)
 
-BOOST_AUTO_TEST_CASE(SingleSubGraph)
+BOOST_AUTO_TEST_CASE(SingleSubgraph)
 {
     // This test case represents the scenario when we have one subgraph
     // in which two layers have GpuAcc backend assigned
@@ -905,8 +908,8 @@
     convLayer2->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     // GpuAcc sub graph selector
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select the GpuAcc layers only
             [](const Layer & l){
@@ -914,39 +917,39 @@
                 return toSelect;
             });
 
-    BOOST_TEST(subGraphs.size() == 1);
-    if(subGraphs.size() == 1)
+    BOOST_TEST(subgraphs.size() == 1);
+    if(subgraphs.size() == 1)
     {
-        BOOST_TEST((subGraphs[0] != nullptr));
+        BOOST_TEST((subgraphs[0] != nullptr));
 
-        if (subGraphs[0].get() != nullptr)
+        if (subgraphs[0].get() != nullptr)
         {
-            unsigned int numInputSlots = boost::numeric_cast<unsigned int>(subGraphs[0]->GetInputSlots().size());
-            unsigned int numOutputSlots = boost::numeric_cast<unsigned int>(subGraphs[0]->GetOutputSlots().size());
+            unsigned int numInputSlots = boost::numeric_cast<unsigned int>(subgraphs[0]->GetInputSlots().size());
+            unsigned int numOutputSlots = boost::numeric_cast<unsigned int>(subgraphs[0]->GetOutputSlots().size());
 
             BOOST_TEST((numInputSlots == 1));
             BOOST_TEST((numOutputSlots == 1));
 
             // Save sub-graph connections for comparison after substitution
-            IOutputSlot* subGraphInputConn1 = subGraphs[0]->GetInputSlot(0)->GetConnection();
-            IInputSlot* subGraphOutputConn1 = subGraphs[0]->GetOutputSlot(0)->GetConnection(0);
+            IOutputSlot* subgraphInputConn1 = subgraphs[0]->GetInputSlot(0)->GetConnection();
+            IInputSlot* subgraphOutputConn1 = subgraphs[0]->GetOutputSlot(0)->GetConnection(0);
 
             // Construct dummy pre-compiled layer
             PreCompiledDescriptor preCompiledDescriptor(numInputSlots, numOutputSlots);
             Layer* const preCompiledLayer = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
 
             // Substitute sub-graph with pre-compiled layer
-            graph.SubstituteSubGraph((std::move(subGraphs[0])), preCompiledLayer);
+            graph.SubstituteSubgraph((std::move(subgraphs[0])), preCompiledLayer);
 
             // Check that connections are correct after substitution
-            BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subGraphInputConn1);
+            BOOST_CHECK_EQUAL(preCompiledLayer->GetInputSlot(0).GetConnection(), subgraphInputConn1);
 
-            BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subGraphOutputConn1);
+            BOOST_CHECK_EQUAL(preCompiledLayer->GetOutputSlot(0).GetConnection(0), subgraphOutputConn1);
         }
     }
 }
 
-BOOST_AUTO_TEST_CASE(MultipleSubGraphs)
+BOOST_AUTO_TEST_CASE(MultipleSubgraphs)
 {
     // This test case represents the scenario when we have two subgraphs
     // in which two layers have CpuAcc backend assigned
@@ -978,8 +981,8 @@
     mergerLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     // CpuAcc sub graph selector
-    SubGraphSelector::SubGraphs subGraphs =
-        SubGraphSelector::SelectSubGraphs(
+    SubgraphViewSelector::Subgraphs subgraphs =
+        SubgraphViewSelector::SelectSubgraphs(
             graph,
             // select the CpuAcc layers only
             [](const Layer & l){
@@ -987,37 +990,37 @@
                 return toSelect;
             });
 
-    BOOST_TEST(subGraphs.size() == 2);
-    if(subGraphs.size() == 2)
+    BOOST_TEST(subgraphs.size() == 2);
+    if(subgraphs.size() == 2)
     {
-        BOOST_TEST((subGraphs[0] != nullptr));
-        BOOST_TEST((subGraphs[1] != nullptr));
+        BOOST_TEST((subgraphs[0] != nullptr));
+        BOOST_TEST((subgraphs[1] != nullptr));
 
-        if (subGraphs[0].get() != nullptr && subGraphs[1].get() != nullptr)
+        if (subgraphs[0].get() != nullptr && subgraphs[1].get() != nullptr)
         {
-            //Sort subGraphs by their inputSlot size.
-            std::sort(subGraphs.begin(), subGraphs.end(),
-                      [](SubGraphSelector::SubGraphPtr & lhs, SubGraphSelector::SubGraphPtr & rhs)
+            //Sort subgraphs by their inputSlot size.
+            std::sort(subgraphs.begin(), subgraphs.end(),
+                      [](SubgraphViewSelector::SubgraphViewPtr & lhs, SubgraphViewSelector::SubgraphViewPtr & rhs)
                       {
                           return (lhs->GetInputSlots().size() < rhs->GetInputSlots().size());
                       }
             );
 
-            unsigned int numInputSlots1  = boost::numeric_cast<unsigned int>(subGraphs[0]->GetInputSlots().size());
-            unsigned int numOutputSlots1 = boost::numeric_cast<unsigned int>(subGraphs[0]->GetOutputSlots().size());
+            unsigned int numInputSlots1  = boost::numeric_cast<unsigned int>(subgraphs[0]->GetInputSlots().size());
+            unsigned int numOutputSlots1 = boost::numeric_cast<unsigned int>(subgraphs[0]->GetOutputSlots().size());
 
-            unsigned int numInputSlots2  = boost::numeric_cast<unsigned int>(subGraphs[1]->GetInputSlots().size());
-            unsigned int numOutputSlots2 = boost::numeric_cast<unsigned int>(subGraphs[1]->GetOutputSlots().size());
+            unsigned int numInputSlots2  = boost::numeric_cast<unsigned int>(subgraphs[1]->GetInputSlots().size());
+            unsigned int numOutputSlots2 = boost::numeric_cast<unsigned int>(subgraphs[1]->GetOutputSlots().size());
 
             // Save sub-graph connections for comparison after substitution
-            IOutputSlot* subGraph1InputConn  = subGraphs[0]->GetInputSlot(0)->GetConnection();
-            IInputSlot* subGraph1OutputConn1 = subGraphs[0]->GetOutputSlot(0)->GetConnection(0);
-            IInputSlot* subGraph1OutputConn2 = subGraphs[0]->GetOutputSlot(1)->GetConnection(0);
+            IOutputSlot* subgraph1InputConn  = subgraphs[0]->GetInputSlot(0)->GetConnection();
+            IInputSlot* subgraph1OutputConn1 = subgraphs[0]->GetOutputSlot(0)->GetConnection(0);
+            IInputSlot* subgraph1OutputConn2 = subgraphs[0]->GetOutputSlot(1)->GetConnection(0);
 
             // Save sub-graph connections for comparison after substitution
-            IOutputSlot* subGraph2InputConn1 = subGraphs[1]->GetInputSlot(0)->GetConnection();
-            IOutputSlot* subGraph2InputConn2 = subGraphs[1]->GetInputSlot(1)->GetConnection();
-            IInputSlot* subGraph2OutputConn  = subGraphs[1]->GetOutputSlot(0)->GetConnection(0);
+            IOutputSlot* subgraph2InputConn1 = subgraphs[1]->GetInputSlot(0)->GetConnection();
+            IOutputSlot* subgraph2InputConn2 = subgraphs[1]->GetInputSlot(1)->GetConnection();
+            IInputSlot* subgraph2OutputConn  = subgraphs[1]->GetOutputSlot(0)->GetConnection(0);
 
             PreCompiledDescriptor preCompiledDescriptor1(numInputSlots1, numOutputSlots1);
             Layer* const preCompiledLayer1 = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor1, "pre-compiled1");
@@ -1026,17 +1029,17 @@
             Layer* const preCompiledLayer2 = graph.AddLayer<PreCompiledLayer>(preCompiledDescriptor2, "pre-compiled2");
 
             // Substitute sub-graph with pre-compiled layer
-            graph.SubstituteSubGraph((std::move(subGraphs[0])), preCompiledLayer1);
-            graph.SubstituteSubGraph((std::move(subGraphs[1])), preCompiledLayer2);
+            graph.SubstituteSubgraph((std::move(subgraphs[0])), preCompiledLayer1);
+            graph.SubstituteSubgraph((std::move(subgraphs[1])), preCompiledLayer2);
 
             // Check that connections are correct after substitution
-            BOOST_CHECK_EQUAL(preCompiledLayer1->GetInputSlot(0).GetConnection(), subGraph1InputConn);
-            BOOST_CHECK_EQUAL(preCompiledLayer1->GetOutputSlot(0).GetConnection(0), subGraph1OutputConn1);
-            BOOST_CHECK_EQUAL(preCompiledLayer1->GetOutputSlot(1).GetConnection(0), subGraph1OutputConn2);
+            BOOST_CHECK_EQUAL(preCompiledLayer1->GetInputSlot(0).GetConnection(), subgraph1InputConn);
+            BOOST_CHECK_EQUAL(preCompiledLayer1->GetOutputSlot(0).GetConnection(0), subgraph1OutputConn1);
+            BOOST_CHECK_EQUAL(preCompiledLayer1->GetOutputSlot(1).GetConnection(0), subgraph1OutputConn2);
 
-            BOOST_CHECK_EQUAL(preCompiledLayer2->GetInputSlot(0).GetConnection(), subGraph2InputConn1);
-            BOOST_CHECK_EQUAL(preCompiledLayer2->GetInputSlot(1).GetConnection(), subGraph2InputConn2);
-            BOOST_CHECK_EQUAL(preCompiledLayer2->GetOutputSlot(0).GetConnection(0), subGraph2OutputConn);
+            BOOST_CHECK_EQUAL(preCompiledLayer2->GetInputSlot(0).GetConnection(), subgraph2InputConn1);
+            BOOST_CHECK_EQUAL(preCompiledLayer2->GetInputSlot(1).GetConnection(), subgraph2InputConn2);
+            BOOST_CHECK_EQUAL(preCompiledLayer2->GetOutputSlot(0).GetConnection(0), subgraph2OutputConn);
         }
     }
 }
diff --git a/src/armnnTfLiteParser/TfLiteParser.cpp b/src/armnnTfLiteParser/TfLiteParser.cpp
index 5733343..0cc6f93 100644
--- a/src/armnnTfLiteParser/TfLiteParser.cpp
+++ b/src/armnnTfLiteParser/TfLiteParser.cpp
@@ -491,15 +491,15 @@
     CHECK_MODEL(m_Model, subgraphIndex, operatorIndex);
     BOOST_ASSERT(layer != nullptr);
 
-    const auto & subGraphPtr = m_Model->subgraphs[subgraphIndex];
-    const auto & operatorPtr = subGraphPtr->operators[operatorIndex];
+    const auto & subgraphPtr = m_Model->subgraphs[subgraphIndex];
+    const auto & operatorPtr = subgraphPtr->operators[operatorIndex];
 
     BOOST_ASSERT(operatorPtr->inputs.size() > 1);
 
     uint32_t reshapedInputId = CHECKED_NON_NEGATIVE(operatorPtr->inputs[0]);
-    TensorRawPtr tensorPtr = subGraphPtr->tensors[reshapedInputId].get();
+    TensorRawPtr tensorPtr = subgraphPtr->tensors[reshapedInputId].get();
     uint32_t inputId = CHECKED_NON_NEGATIVE(operatorPtr->inputs[1]);
-    TensorRawPtr tensorPtr1 = subGraphPtr->tensors[inputId].get();
+    TensorRawPtr tensorPtr1 = subgraphPtr->tensors[inputId].get();
 
     armnn::TensorInfo reshapedTensorInfo = ToTensorInfo(tensorPtr);
     armnn::TensorInfo inputTensorInfo    = ToTensorInfo(tensorPtr1);
@@ -573,7 +573,7 @@
     }
 
     size_t subgraphIndex = 0;
-    for (SubGraphPtr const & subgraph : m_Model->subgraphs)
+    for (SubgraphPtr const & subgraph : m_Model->subgraphs)
     {
         m_SubgraphConnections.emplace_back(subgraph->tensors.size());
 
@@ -2237,15 +2237,15 @@
 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
 
-    const auto & subGraphPtr = model->subgraphs[subgraphIndex];
-    const auto & operatorPtr = subGraphPtr->operators[operatorIndex];
+    const auto & subgraphPtr = model->subgraphs[subgraphIndex];
+    const auto & operatorPtr = subgraphPtr->operators[operatorIndex];
 
     size_t inputCount = operatorPtr->inputs.size();
     TensorRawPtrVector result(inputCount);
     for (size_t i=0; i<inputCount; ++i)
     {
         uint32_t inputId = CHECKED_NON_NEGATIVE(operatorPtr->inputs[i]);
-        result[i] = subGraphPtr->tensors[inputId].get();
+        result[i] = subgraphPtr->tensors[inputId].get();
     }
     return result;
 }
@@ -2256,8 +2256,8 @@
 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
 
-    const auto & subGraphPtr = model->subgraphs[subgraphIndex];
-    const auto & operatorPtr = subGraphPtr->operators[operatorIndex];
+    const auto & subgraphPtr = model->subgraphs[subgraphIndex];
+    const auto & operatorPtr = subgraphPtr->operators[operatorIndex];
 
     size_t outputCount = operatorPtr->outputs.size();
     TensorRawPtrVector result(outputCount);
@@ -2265,7 +2265,7 @@
     {
         uint32_t outputId = CHECKED_NON_NEGATIVE(operatorPtr->outputs[i]);
         CHECK_TENSOR(model, subgraphIndex, outputId);
-        result[i] = subGraphPtr->tensors[outputId].get();
+        result[i] = subgraphPtr->tensors[outputId].get();
     }
     return result;
 }
@@ -2274,15 +2274,15 @@
                                                                    size_t subgraphIndex)
 {
     CHECK_SUBGRAPH(model, subgraphIndex);
-    const auto & subGraphPtr = model->subgraphs[subgraphIndex];
+    const auto & subgraphPtr = model->subgraphs[subgraphIndex];
 
-    size_t inputCount = subGraphPtr->inputs.size();
+    size_t inputCount = subgraphPtr->inputs.size();
     TensorIdRawPtrVector result(inputCount);
     for (size_t i=0; i<inputCount; ++i)
     {
-        uint32_t inputId = CHECKED_NON_NEGATIVE(subGraphPtr->inputs[i]);
+        uint32_t inputId = CHECKED_NON_NEGATIVE(subgraphPtr->inputs[i]);
         CHECK_TENSOR(model, subgraphIndex, inputId);
-        result[i] = std::make_pair(inputId, subGraphPtr->tensors[inputId].get());
+        result[i] = std::make_pair(inputId, subgraphPtr->tensors[inputId].get());
     }
     return result;
 }
@@ -2291,14 +2291,14 @@
                                                                     size_t subgraphIndex)
 {
     CHECK_SUBGRAPH(model, subgraphIndex);
-    const auto & subGraphPtr = model->subgraphs[subgraphIndex];
+    const auto & subgraphPtr = model->subgraphs[subgraphIndex];
 
-    size_t outputCount = subGraphPtr->outputs.size();
+    size_t outputCount = subgraphPtr->outputs.size();
     TensorIdRawPtrVector result(outputCount);
     for (size_t i=0; i<outputCount; ++i)
     {
-        uint32_t outputId = CHECKED_NON_NEGATIVE(subGraphPtr->outputs[i]);
-        result[i] = std::make_pair(outputId, subGraphPtr->tensors[outputId].get());
+        uint32_t outputId = CHECKED_NON_NEGATIVE(subgraphPtr->outputs[i]);
+        result[i] = std::make_pair(outputId, subgraphPtr->tensors[outputId].get());
     }
     return result;
 }
@@ -2308,8 +2308,8 @@
                                                       size_t operatorIndex)
 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
-    const auto & subGraphPtr = model->subgraphs[subgraphIndex];
-    const auto & operatorPtr = subGraphPtr->operators[operatorIndex];
+    const auto & subgraphPtr = model->subgraphs[subgraphIndex];
+    const auto & operatorPtr = subgraphPtr->operators[operatorIndex];
     return operatorPtr->inputs;
 }
 
@@ -2318,8 +2318,8 @@
                                                        size_t operatorIndex)
 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
-    const auto & subGraphPtr = model->subgraphs[subgraphIndex];
-    const auto & operatorPtr = subGraphPtr->operators[operatorIndex];
+    const auto & subgraphPtr = model->subgraphs[subgraphIndex];
+    const auto & operatorPtr = subgraphPtr->operators[operatorIndex];
     return operatorPtr->outputs;
 }
 
@@ -2420,7 +2420,7 @@
 {
     CHECK_SUBGRAPH(m_Model, subgraphIndex);
 
-    const auto & subGraphPtr = m_Model->subgraphs[subgraphIndex];
+    const auto & subgraphPtr = m_Model->subgraphs[subgraphIndex];
     for (unsigned int subgraphIndex = 0; subgraphIndex < m_SubgraphConnections.size(); ++subgraphIndex)
     {
         for (unsigned int tensorIndex = 0; tensorIndex < m_SubgraphConnections[subgraphIndex].size(); ++tensorIndex)
@@ -2428,7 +2428,7 @@
             if (m_SubgraphConnections[subgraphIndex][tensorIndex].outputSlot == nullptr &&
                 m_SubgraphConnections[subgraphIndex][tensorIndex].inputSlots.size() > 0)
             {
-                TensorRawPtr tensorPtr = subGraphPtr->tensors[tensorIndex].get();
+                TensorRawPtr tensorPtr = subgraphPtr->tensors[tensorIndex].get();
                 armnn::TensorInfo tensorInfo = ToTensorInfo(tensorPtr);
                 auto tensorAndData = CreateConstTensor(tensorPtr,
                                                        tensorInfo,
diff --git a/src/armnnTfLiteParser/TfLiteParser.hpp b/src/armnnTfLiteParser/TfLiteParser.hpp
index 929af1f..07a0f26 100644
--- a/src/armnnTfLiteParser/TfLiteParser.hpp
+++ b/src/armnnTfLiteParser/TfLiteParser.hpp
@@ -20,7 +20,7 @@
 public:
     // Shorthands for TfLite types
     using ModelPtr = std::unique_ptr<tflite::ModelT>;
-    using SubGraphPtr = std::unique_ptr<tflite::SubGraphT>;
+    using SubgraphPtr = std::unique_ptr<tflite::SubGraphT>;
     using OperatorPtr = std::unique_ptr<tflite::OperatorT>;
     using OperatorCodePtr = std::unique_ptr<tflite::OperatorCodeT>;
     using TensorPtr = std::unique_ptr<tflite::TensorT>;
diff --git a/src/armnnTfLiteParser/test/GetTensorIds.cpp b/src/armnnTfLiteParser/test/GetTensorIds.cpp
index c55b6d3..6b82bb1 100644
--- a/src/armnnTfLiteParser/test/GetTensorIds.cpp
+++ b/src/armnnTfLiteParser/test/GetTensorIds.cpp
@@ -135,13 +135,13 @@
     BOOST_CHECK_THROW(TfLiteParser::GetOutputTensorIds(nullptr, 0, 0), armnn::ParseException);
 }
 
-BOOST_FIXTURE_TEST_CASE(GetInputTensorIdsInvalidSubGraph, GetInputOutputTensorIdsFixture)
+BOOST_FIXTURE_TEST_CASE(GetInputTensorIdsInvalidSubgraph, GetInputOutputTensorIdsFixture)
 {
     TfLiteParser::ModelPtr model = TfLiteParser::LoadModelFromBinary(m_GraphBinary.data(), m_GraphBinary.size());
     BOOST_CHECK_THROW(TfLiteParser::GetInputTensorIds(model, 1, 0), armnn::ParseException);
 }
 
-BOOST_FIXTURE_TEST_CASE(GetOutputTensorIdsInvalidSubGraph, GetInputOutputTensorIdsFixture)
+BOOST_FIXTURE_TEST_CASE(GetOutputTensorIdsInvalidSubgraph, GetInputOutputTensorIdsFixture)
 {
     TfLiteParser::ModelPtr model = TfLiteParser::LoadModelFromBinary(m_GraphBinary.data(), m_GraphBinary.size());
     BOOST_CHECK_THROW(TfLiteParser::GetOutputTensorIds(model, 1, 0), armnn::ParseException);
diff --git a/src/armnnTfLiteParser/test/LoadModel.cpp b/src/armnnTfLiteParser/test/LoadModel.cpp
index ea49010..dac30ef 100644
--- a/src/armnnTfLiteParser/test/LoadModel.cpp
+++ b/src/armnnTfLiteParser/test/LoadModel.cpp
@@ -10,7 +10,7 @@
 
 using armnnTfLiteParser::TfLiteParser;
 using ModelPtr = TfLiteParser::ModelPtr;
-using SubGraphPtr = TfLiteParser::SubGraphPtr;
+using SubgraphPtr = TfLiteParser::SubgraphPtr;
 using OperatorPtr = TfLiteParser::OperatorPtr;
 
 BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
@@ -156,7 +156,7 @@
         }
     }
 
-    void CheckSubgraph(const SubGraphPtr& subgraph, size_t tensors, const std::vector<int32_t>& inputs,
+    void CheckSubgraph(const SubgraphPtr& subgraph, size_t tensors, const std::vector<int32_t>& inputs,
                        const std::vector<int32_t>& outputs, size_t operators, const std::string& name)
     {
         BOOST_CHECK(subgraph);
diff --git a/src/backends/README.md b/src/backends/README.md
index c269ea0..90eeed2 100644
--- a/src/backends/README.md
+++ b/src/backends/README.md
@@ -116,11 +116,11 @@
     virtual IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const = 0;
     virtual Optimizations GetOptimizations() const = 0;
     virtual ILayerSupportSharedPtr GetLayerSupport() const = 0;
-    virtual SubGraphUniquePtr OptimizeSubGraph(const SubGraph& subGraph, bool& optimizationAttempted) const = 0;
+    virtual SubgraphUniquePtr OptimizeSubgraph(const SubgraphView& subgraph, bool& optimizationAttempted) const = 0;
 ```
 
 Note that ```GetOptimizations()``` has been deprecated.
-The method ```OptimizeSubGraph(...)``` should be used instead to specific optimizations to a given sub-graph.
+The method ```OptimizeSubgraph(...)``` should be used instead to specific optimizations to a given sub-graph.
 
 The ArmNN framework then creates instances of the IBackendInternal interface with the help of the
 [BackendRegistry](backendsCommon/BackendRegistry.hpp) singleton.
@@ -191,7 +191,7 @@
 ## The Optimizations
 
 The backends may choose to implement backend-specific optimizations.
-This is supported through the method ```OptimizeSubGraph(...)``` to the backend interface
+This is supported through the method ```OptimizeSubgraph(...)``` to the backend interface
 that allows the backends to apply their specific optimizations to a given sub-grah.
 
 The way backends had to provide a list optimizations to the Optimizer (through the ```GetOptimizations()``` method)
diff --git a/src/backends/backendsCommon/IBackendInternal.hpp b/src/backends/backendsCommon/IBackendInternal.hpp
index 6e6d47f..108e66e 100644
--- a/src/backends/backendsCommon/IBackendInternal.hpp
+++ b/src/backends/backendsCommon/IBackendInternal.hpp
@@ -7,8 +7,8 @@
 #include <armnn/Types.hpp>
 #include <armnn/IRuntime.hpp>
 
-#include <ISubGraphConverter.hpp>
-#include <SubGraph.hpp>
+#include <ISubgraphViewConverter.hpp>
+#include <SubgraphView.hpp>
 
 #include <vector>
 
@@ -41,9 +41,9 @@
     using IMemoryManagerUniquePtr = std::unique_ptr<IMemoryManager>;
     using IMemoryManagerSharedPtr = std::shared_ptr<IMemoryManager>;
 
-    using ISubGraphConverterPtr = std::unique_ptr<ISubGraphConverter>;
+    using ISubgraphViewConverterPtr = std::unique_ptr<ISubgraphViewConverter>;
 
-    using SubGraphUniquePtr = std::unique_ptr<SubGraph>;
+    using SubgraphViewUniquePtr = std::unique_ptr<SubgraphView>;
 
     virtual IMemoryManagerUniquePtr CreateMemoryManager() const = 0;
 
@@ -52,12 +52,14 @@
 
     virtual IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const = 0;
 
-    virtual ISubGraphConverterPtr CreateSubGraphConverter(const std::shared_ptr<SubGraph>& subGraph) const = 0;
+    virtual ISubgraphViewConverterPtr CreateSubgraphViewConverter(const std::shared_ptr<SubgraphView>& subgraph)
+        const = 0;
 
     virtual Optimizations GetOptimizations() const = 0;
     virtual ILayerSupportSharedPtr GetLayerSupport() const = 0;
 
-    virtual SubGraphUniquePtr OptimizeSubGraph(const SubGraph& subGraph, bool& optimizationAttempted) const = 0;
+    virtual SubgraphViewUniquePtr OptimizeSubgraphView(const SubgraphView& subgraph, bool& optimizationAttempted)
+        const = 0;
 };
 
 using IBackendInternalUniquePtr = std::unique_ptr<IBackendInternal>;
diff --git a/src/backends/cl/ClBackend.cpp b/src/backends/cl/ClBackend.cpp
index dfa5e7c..25318ec 100644
--- a/src/backends/cl/ClBackend.cpp
+++ b/src/backends/cl/ClBackend.cpp
@@ -63,10 +63,10 @@
     return IBackendContextPtr{new ClBackendContext{options}};
 }
 
-IBackendInternal::ISubGraphConverterPtr ClBackend::CreateSubGraphConverter(
-    const std::shared_ptr<SubGraph>& subGraph) const
+IBackendInternal::ISubgraphViewConverterPtr ClBackend::CreateSubgraphViewConverter(
+    const std::shared_ptr<SubgraphView>& subgraph) const
 {
-    return ISubGraphConverterPtr{};
+    return ISubgraphViewConverterPtr{};
 }
 
 IBackendInternal::Optimizations ClBackend::GetOptimizations() const
@@ -80,13 +80,13 @@
     return layerSupport;
 }
 
-IBackendInternal::SubGraphUniquePtr ClBackend::OptimizeSubGraph(const SubGraph& subGraph,
-                                                                bool& optimizationAttempted) const
+IBackendInternal::SubgraphViewUniquePtr ClBackend::OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                                        bool& optimizationAttempted) const
 {
     // Not trying to optimize the given sub-graph
     optimizationAttempted = false;
 
-    return SubGraphUniquePtr{};
+    return SubgraphViewUniquePtr{};
 }
 
 } // namespace armnn
diff --git a/src/backends/cl/ClBackend.hpp b/src/backends/cl/ClBackend.hpp
index 8133ce4..e50c7e1 100644
--- a/src/backends/cl/ClBackend.hpp
+++ b/src/backends/cl/ClBackend.hpp
@@ -25,14 +25,14 @@
 
     IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override;
 
-    IBackendInternal::ISubGraphConverterPtr CreateSubGraphConverter(
-        const std::shared_ptr<SubGraph>& subGraph) const override;
+    IBackendInternal::ISubgraphViewConverterPtr CreateSubgraphViewConverter(
+        const std::shared_ptr<SubgraphView>& subgraph) const override;
 
     IBackendInternal::Optimizations GetOptimizations() const override;
     IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override;
 
-    IBackendInternal::SubGraphUniquePtr OptimizeSubGraph(const SubGraph& subGraph,
-                                                         bool& optimizationAttempted) const override;
+    IBackendInternal::SubgraphViewUniquePtr OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                                 bool& optimizationAttempted) const override;
 };
 
 } // namespace armnn
diff --git a/src/backends/neon/NeonBackend.cpp b/src/backends/neon/NeonBackend.cpp
index 830d637..096fe26 100644
--- a/src/backends/neon/NeonBackend.cpp
+++ b/src/backends/neon/NeonBackend.cpp
@@ -63,10 +63,10 @@
     return IBackendContextPtr{};
 }
 
-IBackendInternal::ISubGraphConverterPtr NeonBackend::CreateSubGraphConverter(
-    const std::shared_ptr<SubGraph>& subGraph) const
+IBackendInternal::ISubgraphViewConverterPtr NeonBackend::CreateSubgraphViewConverter(
+    const std::shared_ptr<SubgraphView>& subgraph) const
 {
-    return ISubGraphConverterPtr{};
+    return ISubgraphViewConverterPtr{};
 }
 
 IBackendInternal::Optimizations NeonBackend::GetOptimizations() const
@@ -80,13 +80,13 @@
     return layerSupport;
 }
 
-IBackendInternal::SubGraphUniquePtr NeonBackend::OptimizeSubGraph(const SubGraph& subGraph,
-                                                                  bool& optimizationAttempted) const
+IBackendInternal::SubgraphViewUniquePtr NeonBackend::OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                                          bool& optimizationAttempted) const
 {
     // Not trying to optimize the given sub-graph
     optimizationAttempted = false;
 
-    return SubGraphUniquePtr{};
+    return SubgraphViewUniquePtr{};
 }
 
 } // namespace armnn
diff --git a/src/backends/neon/NeonBackend.hpp b/src/backends/neon/NeonBackend.hpp
index 6347045..a2949b1 100644
--- a/src/backends/neon/NeonBackend.hpp
+++ b/src/backends/neon/NeonBackend.hpp
@@ -25,14 +25,14 @@
 
     IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override;
 
-    IBackendInternal::ISubGraphConverterPtr CreateSubGraphConverter(
-        const std::shared_ptr<SubGraph>& subGraph) const override;
+    IBackendInternal::ISubgraphViewConverterPtr CreateSubgraphViewConverter(
+        const std::shared_ptr<SubgraphView>& subgraph) const override;
 
     IBackendInternal::Optimizations GetOptimizations() const override;
     IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override;
 
-    IBackendInternal::SubGraphUniquePtr OptimizeSubGraph(const SubGraph& subGraph,
-                                                         bool& optimizationAttempted) const override;
+    IBackendInternal::SubgraphViewUniquePtr OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                                 bool& optimizationAttempted) const override;
 };
 
 } // namespace armnn
diff --git a/src/backends/reference/RefBackend.cpp b/src/backends/reference/RefBackend.cpp
index d5f5348..006f2e7 100644
--- a/src/backends/reference/RefBackend.cpp
+++ b/src/backends/reference/RefBackend.cpp
@@ -56,10 +56,10 @@
     return IMemoryManagerUniquePtr{};
 }
 
-IBackendInternal::ISubGraphConverterPtr RefBackend::CreateSubGraphConverter(
-    const std::shared_ptr<SubGraph>& subGraph) const
+IBackendInternal::ISubgraphViewConverterPtr RefBackend::CreateSubgraphViewConverter(
+    const std::shared_ptr<SubgraphView>& subgraph) const
 {
-    return ISubGraphConverterPtr{};
+    return ISubgraphViewConverterPtr{};
 }
 
 IBackendInternal::Optimizations RefBackend::GetOptimizations() const
@@ -73,13 +73,13 @@
     return layerSupport;
 }
 
-IBackendInternal::SubGraphUniquePtr RefBackend::OptimizeSubGraph(const SubGraph& subGraph,
-                                                                 bool& optimizationAttempted) const
+IBackendInternal::SubgraphViewUniquePtr RefBackend::OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                                         bool& optimizationAttempted) const
 {
     // Not trying to optimize the given sub-graph
     optimizationAttempted = false;
 
-    return SubGraphUniquePtr{};
+    return SubgraphViewUniquePtr{};
 }
 
 } // namespace armnn
diff --git a/src/backends/reference/RefBackend.hpp b/src/backends/reference/RefBackend.hpp
index 6305bf5..8658e1a 100644
--- a/src/backends/reference/RefBackend.hpp
+++ b/src/backends/reference/RefBackend.hpp
@@ -25,14 +25,14 @@
 
     IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override;
 
-    IBackendInternal::ISubGraphConverterPtr CreateSubGraphConverter(
-        const std::shared_ptr<SubGraph>& subGraph) const override;
+    IBackendInternal::ISubgraphViewConverterPtr CreateSubgraphViewConverter(
+        const std::shared_ptr<SubgraphView>& subgraph) const override;
 
     IBackendInternal::Optimizations GetOptimizations() const override;
     IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override;
 
-    IBackendInternal::SubGraphUniquePtr OptimizeSubGraph(const SubGraph& subGraph,
-                                                         bool& optimizationAttempted) const override;
+    IBackendInternal::SubgraphViewUniquePtr OptimizeSubgraphView(const SubgraphView& subgraph,
+                                                                 bool& optimizationAttempted) const override;
 };
 
 } // namespace armnn
diff --git a/tests/InferenceModel.hpp b/tests/InferenceModel.hpp
index 72c5eda..fa71b30 100644
--- a/tests/InferenceModel.hpp
+++ b/tests/InferenceModel.hpp
@@ -198,19 +198,19 @@
             network = parser->CreateNetworkFromBinary(file);
         }
 
-        unsigned int subGraphId = boost::numeric_cast<unsigned int>(params.m_SubgraphId);
+        unsigned int subgraphId = boost::numeric_cast<unsigned int>(params.m_SubgraphId);
 
         for (const std::string& inputLayerName : params.m_InputBindings)
         {
             armnnDeserializer::BindingPointInfo inputBinding =
-                parser->GetNetworkInputBindingInfo(subGraphId, inputLayerName);
+                parser->GetNetworkInputBindingInfo(subgraphId, inputLayerName);
             inputBindings.push_back(std::make_pair(inputBinding.m_BindingId, inputBinding.m_TensorInfo));
         }
 
         for (const std::string& outputLayerName : params.m_OutputBindings)
         {
             armnnDeserializer::BindingPointInfo outputBinding =
-                parser->GetNetworkOutputBindingInfo(subGraphId, outputLayerName);
+                parser->GetNetworkOutputBindingInfo(subgraphId, outputLayerName);
             outputBindings.push_back(std::make_pair(outputBinding.m_BindingId, outputBinding.m_TensorInfo));
         }