void ComputationNetwork::RenameNode(ComputationNodeBasePtr node, const std::wstring& newNodeName) { // TODO: check if new name exists m_nameToNodeMap.erase(node->NodeName()); node->SetNodeName(newNodeName); AddNodeToNet(node); }
void ComputationNetwork::AddFeatureNode(ComputationNodeBasePtr featureNode) { InvalidateCompiledNetwork(); AddNodeToNet(featureNode); AddToNodeGroup(L"feature", featureNode); }
// replace a named node by newNode of the same type under the same name, including moving over all network links // This is used in // 1. Update nodes to quantized versions. // 2. The KL-reg based adaptation to reduce feature copy (deprecated) // need to update all the mappings as well childrens. void ComputationNetwork::ReplaceNode(wstring nodeName, ComputationNodeBasePtr newNode) { ComputationNodeBasePtr oldNode = GetNodeFromName(nodeName); if (newNode->NodeName() != nodeName) // TODO: This was not tested for earlier; I hope no code depends on this. InvalidArgument("ChangeNode: newNode must have the same name as the old node."); InvalidateCompiledNetwork(); // change all nodes that have old node as input to point to the new node instead ChangeNodeInputs(oldNode, newNode); // change all inputs of this new node to share the old one's inputs for (int i = 0; i < oldNode->GetNumInputs(); i++) { newNode->SetInput(i, oldNode->GetInputs()[i]); // TODO: use AttachInput()? //oldNode->SetInput(i, nullptr); // BUGBUG: old node should no longer point into the network } // replace the node in the network RemoveNodeFromNet(oldNode); AddNodeToNet(newNode); // also update node groups for (auto groupIter : GetAllNodeGroups()) { auto& group = *groupIter; for (int i = 0; i < group.size(); i++) if (group[i] == oldNode) group[i] = newNode; } }
void ComputationNetwork::RenameNode(ComputationNodeBasePtr node, const std::wstring& newNodeName) { // make sure the new name is not already used auto iter = m_nameToNodeMap.find(newNodeName); if (iter != m_nameToNodeMap.end()) // found RuntimeError("RenameNode: Target name already exists."); InvalidateCompiledNetwork(); RemoveNodeFromNet(node); // take it out remporarily node->SetNodeName(newNodeName); // change the name AddNodeToNet(node); // and put it back }
// Inserts a newNode such that the inputNodeName serves as the input to the newNode // Prior to this call, inputNodeName should be set as the input to newNode. void ComputationNetwork::InsertNode(wstring inputNodeName, ComputationNodeBasePtr newNode, const std::set<std::wstring>& newNodeTags) { newNode->Validate(false); ComputationNodeBasePtr inputNode = GetNodeFromName(inputNodeName); InvalidateCompiledNetwork(); // change all nodes that have old node as input to point to the new node instead ChangeNodeInputs(inputNode, newNode); // insert the node in the network AddNodeToNet(newNode); // also update node groups for (auto nodeTag : newNodeTags) { AddToNodeGroup(nodeTag, newNode); } }
ComputationNodeBasePtr ComputationNetwork::CopyNode(const ComputationNetwork& fromNet, const std::wstring fromName, std::wstring toName, const CopyNodeFlags flags) { InvalidateCompiledNetwork(); if (toName == L"") toName = fromName; ComputationNodeBasePtr pFromNode = fromNet.GetNodeFromName(fromName); ComputationNodeBasePtr pToNode; // don't allow cross network child copy unless caller explicity handles children fixup if ((flags & CopyNodeFlags::copyNodeChildren) && this != &fromNet && !(flags & CopyNodeFlags::copyNodeChildrenCrossNetwork)) { LogicError("CopyNode: Copying node children across network is invalid."); } if (!NodeNameExists(toName)) { pToNode = pFromNode->Duplicate(toName, flags); AddNodeToNet(pToNode); } else { // node already exists pToNode = GetNodeFromName(toName); // same node. no copy needed if (pFromNode == pToNode) LogicError("CopyNode: You are copying the node to the same network with same node name."); else pFromNode->CopyTo(pToNode, toName, flags); // blast it over the existing node } return pToNode; }