apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 33536
releaseNotes:
  - |

from fastapi import FastAPI

app = FastAPI()


@app.get("/keyword-weights/", response_model=dict[str, float])
async def read_keyword_weights():

	g, err := community.NewUndirectedLayers(friends, enemies)
	if err != nil {
		log.Fatal(err)
	}
	weights := []float64{1, -1}

	// Get the profile of internal node weight for resolutions
	// between 0.1 and 10 using logarithmic bisection.
	p, err := community.Profile(
		community.ModularMultiplexScore(g, weights, true, community.WeightMultiplex, 10, src),
		true, 1e-3, 0.1, 10,
	)
	if err != nil {
		log.Fatal(err)

      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@BoxPredictor_4/ClassPredictor/weights"
      }
    }
  }
}
node {

apiVersion: release-notes/v2
kind: bug-fix
area: networking
issue:
- 28970
releaseNotes:
- |

from typing import Dict

from fastapi import FastAPI

app = FastAPI()


@app.get("/keyword-weights/", response_model=Dict[str, float])
async def read_keyword_weights():

  let description = [{
      This pass encodes sparse weights in the model in the proper format, and adds
      Densify() op if necessary. The general algorithm is:
        1. Get list of operands (weights) of an op that can be sparse.
        2. Get list of supported block configurations of the op.
        3. Calculate random sparsity of the weight.
          3.1. If sparsity level is below the encoding threshold, keep in dense.

      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@BoxPredictor_4/ClassPredictor/weights"
      }
    }
  }
}
node {

      }
    }
  }
}
node {
  name: "MobilenetV1/Conv2d_0/weights/read"
  op: "Identity"
  input: "MobilenetV1/Conv2d_0/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@MobilenetV1/Conv2d_0/weights"
      }
    }
  }
}
node {
  name: "MobilenetV1/MobilenetV1/Conv2d_0/Conv2D"

  const bool disable_per_channel_;

  // We should distinguish weights and bias constants. Biases are specified by
  // the quantization spec or are the operands of ops with same scale spec. The
  // rest are weights.
  DenseSet<Operation*> weights_;

  // The weights require narrow_range quantization. This map collects all the
  // weight operands defined by the op quant spec. The value of each entry is