How to use

getVertexName

method

in

org.deeplearning4j.nn.graph.vertex.GraphVertex

for (int i = 0; i < indices.length; i++) {
  GraphVertex cv = vertices[indices[i].getVertexIndex()];
  String inputName = cv.getVertexName();
        LayerInfo info = model.getLayerInfoByName(vertex.getVertexName());
        if (info == null)
          info = getLayerInfo(vertex.getLayer(), x, currentY, 121);
        info.setName(vertex.getVertexName());
        if (model.getLayerInfoByName(vertex.getVertexName()) == null) {
          x++;
          model.addLayer(info);

for (int i = 0; i < indices.length; i++) {
  GraphVertex cv = vertices[indices[i].getVertexIndex()];
  String inputName = cv.getVertexName();
        LayerInfo info = model.getLayerInfoByName(vertex.getVertexName());
        if (info == null)
          info = getLayerInfo(vertex.getLayer(), x, currentY, 121);
        info.setName(vertex.getVertexName());
        if (model.getLayerInfoByName(vertex.getVertexName()) == null) {
          x++;
          model.addLayer(info);

GraphVertex current = vertices[currVertexIdx];
String name = current.getVertexName();
String[] classNameArr = current.getClass().toString().split("\\.");
String className = classNameArr[classNameArr.length - 1];

private void copyOrigParamsToSubsetGraph() {
  for (GraphVertex aVertex : unFrozenSubsetGraph.getVertices()) {
    if (!aVertex.hasLayer())
      continue;
    aVertex.getLayer().setParams(origGraph.getLayer(aVertex.getVertexName()).params());
  }
}

if (applyFrozen && allFrozen.contains(gv.getVertexName())) {
  if (gv.hasLayer()) {
    for (int j = 0; j < inputs.length; j++) {
      int inputVertexIdx = inputs[j].getVertexIndex();
      String alsoFreeze = origGraph.getVertices()[inputVertexIdx].getVertexName();
      allFrozen.add(alsoFreeze);
  if (gv.hasLayer()) {
    if (gv.getLayer() instanceof FrozenLayer) {
      allFrozen.add(gv.getVertexName());
        for (int j = 0; j < inputs.length; j++) {
          int inputVertexIdx = inputs[j].getVertexIndex();
          String alsoFrozen = origGraph.getVertices()[inputVertexIdx].getVertexName();
          allFrozen.add(alsoFrozen);
String gvName = gv.getVertexName();
  for (int j = 0; j < inputs.length; j++) {
    int inputVertexIdx = inputs[j].getVertexIndex();
    String inputVertex = origGraph.getVertices()[inputVertexIdx].getVertexName();
    if (allFrozen.contains(inputVertex)) {
      frozenInputVertices.add(inputVertex);

  if (layerVariables != null) {
    for (String s : layerVariables) {
      variables.add(gv.getVertexName() + "_" + s);
verticesMap.put(gv.getVertexName(), gv);
String vertexName = gv.getVertexName();
List<String> vertexInputNames;
vertexInputNames = vertexInputs.get(vertexName);
String vertexName = gv.getVertexName();
int vertexIndex = gv.getVertexIndex();
List<String> vertexInputNames;
String vertexName = gv.getVertexName();

private void copyParamsFromSubsetGraphToOrig() {
  for (GraphVertex aVertex : unFrozenSubsetGraph.getVertices()) {
    if (!aVertex.hasLayer())
      continue;
    origGraph.getVertex(aVertex.getVertexName()).getLayer().setParams(aVertex.getLayer().params());
  }
}

INDArray input = inputs[current.getVertexIndex()];
layerActivations.put(current.getVertexName(), input);
  layerActivations.put(current.getVertexName(), out);
} else {
  out = current.doForward(training);

/**
 * Pretrain network with multiple inputs and/or outputs
 */
public void pretrain(MultiDataSetIterator iter) {
  if (!configuration.isPretrain())
    return;
  if (flattenedGradients == null) {
    initGradientsView();
  }
  //Assume here that all layers are pretrainable layers
  for (int i = 0; i < topologicalOrder.length; i++) {
    if (!vertices[i].hasLayer())
      continue;
    if (vertices[i].getLayer() instanceof IOutputLayer)
      continue; //Don't pretrain output layer
    if (!vertices[i].getLayer().isPretrainLayer())
      continue; //Skip layers that aren't pretrainable
    pretrainLayer(vertices[i].getVertexName(), iter);
  }
}

String layerName = vertices[topologicalOrder[i]].getVertexName();
int range = layer.numParams();
if (range <= 0)
if (allFrozen.contains(gv.getVertexName())) {
  if (gv.hasLayer()) {
    gv.setLayerAsFrozen();
    String layerName = gv.getVertexName();
    LayerVertex currLayerVertex = (LayerVertex) newConfig.getVertices().get(layerName);
    Layer origLayerConf = currLayerVertex.getLayerConf().getLayer();
    for (int j = 0; j < inputs.length; j++) {
      int inputVertexIdx = inputs[j].getVertexIndex();
      String alsoFreeze = vertices[inputVertexIdx].getVertexName();
      allFrozen.add(alsoFreeze);

if (vertex instanceof LayerVertex) {
  final int numParams = vertex.getLayer().numParams();
  System.out.println("Number of parameters in layer " + vertex.getVertexName() + ": " + numParams);
  totalNumParams += numParams;

int thisOutputNumber = configuration.getNetworkOutputs().indexOf(current.getVertexName());
if (current.getLayer() instanceof IOutputLayer) {
  IOutputLayer outputLayer = (IOutputLayer) current.getLayer();
  if ((externalEpsilons == null || externalEpsilons.length == 0)
          && labels[thisOutputNumber] != null) {
    throw new DL4JException("Layer \"" + current.getVertexName() + "\" of type "
            + current.getLayer().getClass().getSimpleName()
            + " is set as network output "
for (Map.Entry<String, INDArray> entry : map.entrySet()) {
  String origName = entry.getKey();
  String newName = current.getVertexName() + "_" + origName;
  tempList.addFirst(new Triple<>(newName, entry.getValue(),
          g.flatteningOrderForVariable(origName)));

@Override
public ComputationGraph clone() {
  ComputationGraph cg = new ComputationGraph(configuration.clone());
  cg.init(params().dup(), false);
  if (solver != null) {
    //If  solver is null: updater hasn't been initialized -> getUpdater call will force initialization, however
    ComputationGraphUpdater u = this.getUpdater();
    INDArray updaterState = u.getStateViewArray();
    if (updaterState != null) {
      cg.getUpdater().setStateViewArray(updaterState.dup());
    }
  }
  cg.listeners = this.listeners;
  for (int i = 0; i < topologicalOrder.length; i++) {
    if (!vertices[topologicalOrder[i]].hasLayer())
      continue;
    String layerName = vertices[topologicalOrder[i]].getVertexName();
    if (getLayer(layerName) instanceof FrozenLayer) {
      cg.getVertex(layerName).setLayerAsFrozen();
    }
  }
  return cg;
}

layerActivations.put(current.getVertexName(), input);
  layerActivations.put(current.getVertexName(), out);

int idx = configuration.getNetworkOutputs().indexOf(current.getVertexName());
outputs[idx] = out;