Method update

assets/main.js:1519–1608

(model)

  }

  update(model) {
    if (!model || !Array.isArray(model.layers) || model.layers.length === 0) {
      this.emptyElement.style.display = "block";
      this.summaryElement.style.display = "none";
      this.layersElement.style.display = "none";
      return;
    }

    const architecture = Array.isArray(model.architecture) ? model.architecture : [];
    const layerSummaries = model.layers.map((layer, index) => {
      const archInput = architecture[index];
      const archOutput = architecture[index + 1];
      const weightRows = Array.isArray(layer.weights) ? layer.weights : [];
      const inputSize =
        typeof archInput === "number" && Number.isFinite(archInput)
          ? archInput
          : weightRows[0]?.length ?? 0;
      const outputSizeCandidate =
        typeof archOutput === "number" && Number.isFinite(archOutput)
          ? archOutput
          : layer.biases?.length ?? 0;
      const outputSize = Number.isFinite(outputSizeCandidate) ? outputSizeCandidate : 0;

      let weightCount = 0;
      for (const row of weightRows) {
        if (row && typeof row.length === "number") {
          weightCount += row.length;
        }
      }

      const biasArray = layer.biases;
      const biasCount = typeof biasArray?.length === "number" ? biasArray.length : 0;
      const parameterCount = weightCount + biasCount;
      return {
        index,
        name: this.describeLayerName(layer.name, index),
        activation: typeof layer.activation === "string" ? layer.activation : null,
        inputSize,
        outputSize,
        weightCount,
        biasCount,
        parameterCount,
      };
    });

    const totalParameters = layerSummaries.reduce((sum, entry) => sum + entry.parameterCount, 0);
    this.summaryElement.innerHTML = "";
    this.summaryElement.appendChild(this.buildSummaryLine("Gesamtparameter", totalParameters));
    if (architecture.length > 0) {
      const firstArchitectureValue = architecture[0];
      const lastArchitectureValue = architecture[architecture.length - 1];
      const inputNodes =
        typeof firstArchitectureValue === "number" && Number.isFinite(firstArchitectureValue)
          ? firstArchitectureValue
          : layerSummaries[0]?.inputSize ?? 0;
      const lastLayer = layerSummaries[layerSummaries.length - 1];
      const outputNodes =
        typeof lastArchitectureValue === "number" && Number.isFinite(lastArchitectureValue)