From 129fba4a4daa56200de207b1eae29e920f93bbf5 Mon Sep 17 00:00:00 2001 From: Ashish Kumar Singh Date: Sun, 7 Jul 2024 01:20:01 +0530 Subject: [PATCH] feat: added some more descriptions and code --- differential equation tests.ipynb | 4 +- example notebooks/ddpm flax.ipynb | 3314 ++++++++++++++++++++++++++++- flaxdiff/models/simple_unet.py | 1 - flaxdiff/schedulers/common.py | 19 +- 4 files changed, 3284 insertions(+), 54 deletions(-) diff --git a/differential equation tests.ipynb b/differential equation tests.ipynb index ab24491..228c1ea 100644 --- a/differential equation tests.ipynb +++ b/differential equation tests.ipynb @@ -65,7 +65,7 @@ } ], "source": [ - "# Simple diffusion equation for constant speed\n", + "# Simple differential equation for constant speed\n", "# dX = c dt + X0\n", "def dX(dt: float, X0: float, c: float = 1, **params) -> float:\n", " return c * dt + X0\n", @@ -104,7 +104,7 @@ } ], "source": [ - "# Simple diffusion equation for increasing speed with constant rate (constant acceleration)\n", + "# Simple differential equation for increasing speed with constant rate (constant acceleration)\n", "# dX = X0 + t * dt\n", "def dX(dt: float, X0: float, t: float, c: float = 1, **params) -> float:\n", " return X0 + t * c * dt \n", diff --git a/example notebooks/ddpm flax.ipynb b/example notebooks/ddpm flax.ipynb index 4113468..655a455 100644 --- a/example notebooks/ddpm flax.ipynb +++ b/example notebooks/ddpm flax.ipynb @@ -1,5 +1,69 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Diffusion Fundamentals\n", + "\n", + "### Diffusion and Score Based Models\n", + "\n", + "In recent years, several methods have arisen for generative modeling of data such as Variational Autoencoders (VAEs), Generative Adversarial Networks (GANs), Autoregressive models, and Normalizing Flows just to name a few. But none really broke the internet quite like the way diffusion models did. Reason being, none could generate images with the same level of quality and diversity as diffusion models. GANs did come close but they were really painful to train and were really unstable. Autoregressive models were too slow. Normalizing Flows were too computationally expensive. VAEs were too blurry. \n", + "\n", + "The idea was that trying to train a model to generate an image in a single step was too hard, so why not instead let it model it in multiple steps? There were two approaches that were proposed to do this: Score based models and diffusion models. But in both, the idea was that our data could be thought of as a special complicated distribution that we could sample from, and that we could start from a simple distribution such as a normal distribution and find a way to transform samples from this simple distribution into those from the data distribution (or as close as we can get). Therefore, its a problem of going from a random high entropy point in the input space to a low entropy point where the scale of entropy is defined as a continous mapping from the data distribution to the simple normal distribution.\n", + "\n", + "Thus we would start from a random sample from normal distribution aka some random gaussian noise, and iteratively try to find our way to gradually transform it into some sample that looks like it came from the data distribution. We do this in some defined time steps $t$. Thus we define a process of starting from a random noise sample at time $t=0$ and gradually removing the noise and finding some useful data at each time step $t$ until we reach $t=T$ where we have ideally no noise and only data left.\n", + "\n", + "The way score based models tackle this is that they train a model that, given a sample from some time step in the diffusion process, can predict how much noise is still present in it aka predict the time step in a way. Grossly oversimplified, we can basically then find the gradient of the model's output (or score) with respect to the input, and kind of do a gradient descent to remove the noise. \n", + "\n", + "And the way diffusion models work is by simply training a model that, given an intermediate noised sample, try to denoise the sample a bit at each time step. The time step itself can also be provided to the model to assist it in the process. It has been shown that both score based and diffusion principles are equivalent.\n", + "\n", + "But we need to train the model as well right? How do we do that? Well its pretty intuitive from what we have understood so far: We can simply take samples from our actual data distribution, and construct a set of samples with gradually increasing noise levels by adding gaussian noise at each time step, until we basically have a set of samples that are just noise. This gradual noising process is very similar to the process of diffusion from thermodynamics where particles move from low entropy to high entropy, hence the name. Score based models just stumbled upon the same idea independently.\n", + "\n", + "### The Diffusion Process\n", + "\n", + "The diffusion process (the forward diffusion process) can be described as a stochastic differential equation (SDE):\n", + "\n", + "$dx_t = f(t, x_t) \\, dt + g(t, x_t) \\, dW_t $\n", + "\n", + "where:\n", + "- $dx_t$ is the infinitesimal change in the data sample $x_t$ at time $t$,\n", + "- $f(t, x_t)$ is the drift term, which represents the deterministic part of the process,\n", + "- $g(t, x_t)$ is the diffusion term, which represents the stochastic part of the process,\n", + "- $dW_t$ is the infinitesimal increment of a Wiener process (or standard Brownian motion).\n", + "\n", + "Don't get overwhelmed by the math, its just a fancy way of saying that the data sample at time $t$ is a function of the data sample at time $t-1$ and some noise. The drift term is the deterministic part of the process that tells us how the data sample changes over time, and the diffusion term is the stochastic part that tells us how the noise affects the data sample. We would soon look at how we can model these terms in the form of a defined noise schedule.\n", + "\n", + "Given the above forward-time diffusion process SDE, We can also formulate the reverse-time diffusion process SDE (as found by Anderson (1982)):\n", + "\n", + "$dx_t = [f(t, x_t) - g(t, x_t)^2 \\nabla_{x_t} \\log p_t(x_t)] \\, dt + g(t, x_t) \\, d\\bar{W}_t $\n", + "\n", + "where:\n", + "- $ dx_t $ is the infinitesimal change in the data sample $ x_t $ at time $ t $,\n", + "- $ f(t, x_t) $ is the drift term from the forward process,\n", + "- $ g(t, x_t) $ is the diffusion term from the forward process,\n", + "- $ \\nabla_{x_t} \\log p_t(x_t) $ is the gradient of the log-density of the data at time $ t $,\n", + "- $ d\\bar{W}_t $ is the infinitesimal increment of a reverse-time Wiener process (or standard Brownian motion).\n", + "\n", + "Again, its nothing fancy and quite easy to understand when we will later try implementing these.\n", + "\n", + "We will thus implement our forward diffusion process via a Noise schedule and our reverse diffusion process via a Sampler, which is essentially a SDE (or ODE) solver that finds a solution to the above differential equation.\n", + "\n", + "An important thing to note is that Every reverse-time diffusion SDE has a corresponding probability flow ODE with the same marginal densities. This essentially means that we can find solutions to go from a noised sample to a denoised sample in a deterministic manner following an ODE as well. This is the difference between ancestral (like DDPM, Euler-A) and non anscestral samplers (like DDIM, Euler etc). Ancestral samplers solve the SDE, while non-ancestral samplers solve the ODE. The Probability Flow ODE is given by:\n", + "\n", + "$ \\frac{dx_t}{dt} = f(t, x_t) - \\frac{1}{2} g(t, x_t)^2 \\nabla_{x_t} \\log p_t(x_t) $\n", + "\n", + "where:\n", + "- $\\frac{dx_t}{dt}$ is the time derivative of the data sample $x_t$,\n", + "- $f(t, x_t)$ is the drift term from the forward process,\n", + "- $g(t, x_t)$ is the diffusion term from the forward process,\n", + "- $\\nabla_{x_t} \\log p_t(x_t)$ is the gradient of the log-density of the data at time $t$.\n", + "\n", + "This ODE provides a deterministic trajectory that samples from the same distribution as the original stochastic process.\n", + "\n", + "**We basically use neural networks to estimate the gradient $\\nabla_{x_t} \\log p_t(x_t)$**" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -9,9 +73,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-07-06 23:29:52.032914: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], "source": [ "import tqdm\n", "from flax import linen as nn\n", @@ -31,7 +103,8 @@ "import os\n", "from datetime import datetime\n", "from flax.training import orbax_utils\n", - "import functools" + "import functools\n", + "import numpy as np" ] }, { @@ -43,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -89,16 +162,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Data Pipeline" + "# Data Pipeline\n", + "\n", + "For simplicity, we will use the oxford flowers dataset for this notebook. We will use the tensorflow datasets library to load the dataset." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "def get_dataset(data_name=\"celeb_a\", batch_size=64, image_scale=256):\n", + "def get_dataset(data_name=\"oxford_flowers102\", batch_size=64, image_scale=256):\n", " def augmenter(image_scale=256, method=\"area\"):\n", " @tf.function()\n", " def augment(sample):\n", @@ -157,10 +232,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ + "\n", "class NoiseScheduler():\n", " def __init__(self, timesteps,\n", " dtype=jnp.float32,\n", @@ -171,44 +247,45 @@ " self.dtype = dtype\n", " self.clip_min = clip_min\n", " self.clip_max = clip_max\n", + " if type(timesteps) == int and timesteps > 1:\n", + " timestep_generator = lambda rng, batch_size, max_timesteps = timesteps: jax.random.randint(rng, (batch_size,), 0, max_timesteps)\n", + " else:\n", + " timestep_generator = lambda rng, batch_size, max_timesteps = timesteps: jax.random.uniform(rng, (batch_size,), minval=0, maxval=max_timesteps)\n", + " self.timestep_generator = timestep_generator\n", "\n", " def generate_timesteps(self, batch_size, state:RandomMarkovState) -> tuple[jnp.ndarray, RandomMarkovState]:\n", - " raise NotImplementedError\n", + " state, rng = state.get_random_key()\n", + " timesteps = self.timestep_generator(rng, batch_size, self.max_timesteps)\n", + " return timesteps, state\n", " \n", " def get_weights(self, steps):\n", " raise NotImplementedError\n", " \n", " def reshape_rates(self, rates:tuple[jnp.ndarray, jnp.ndarray], shape=(-1, 1, 1, 1)) -> tuple[jnp.ndarray, jnp.ndarray]:\n", - " alpha, sigma = rates\n", - " alpha = jnp.reshape(alpha, shape)\n", - " sigma = jnp.reshape(sigma, shape)\n", - " return alpha, sigma\n", + " signal_rates, noise_rates = rates\n", + " signal_rates = jnp.reshape(signal_rates, shape)\n", + " noise_rates = jnp.reshape(noise_rates, shape)\n", + " return signal_rates, noise_rates\n", " \n", " def get_rates(self, steps, shape=(-1, 1, 1, 1)) -> tuple[jnp.ndarray, jnp.ndarray]:\n", " raise NotImplementedError\n", " \n", " def add_noise(self, images, noise, steps) -> jnp.ndarray:\n", - " alpha, sigma = self.get_rates(steps)\n", - " return alpha * images + sigma * noise\n", + " signal_rates, noise_rates = self.get_rates(steps)\n", + " return signal_rates * images + noise_rates * noise\n", " \n", - " def remove_all_noise(self, noisy_images, noise, steps, clip_denoised=True, rates=None) -> jnp.ndarray:\n", - " alpha, sigma = self.get_rates(steps)\n", - " x_0 = (noisy_images - noise * sigma) / alpha\n", + " def remove_all_noise(self, noisy_images, noise, steps, clip_denoised=True, rates=None):\n", + " signal_rates, noise_rates = self.get_rates(steps)\n", + " x_0 = (noisy_images - noise * noise_rates) / signal_rates\n", " return x_0\n", " \n", - " def transform_inputs(self, x, steps) -> tuple[jnp.ndarray, jnp.ndarray]:\n", + " def transform_inputs(self, x, steps):\n", " return x, steps\n", " \n", - " def get_posterior_mean(self, x_0, x_t, steps):\n", - " raise NotImplementedError\n", - " \n", - " def get_posterior_variance(self, steps, shape=(-1, 1, 1, 1)):\n", - " raise NotImplementedError\n", - "\n", " def get_max_variance(self):\n", " alpha_n, sigma_n = self.get_rates(self.max_timesteps)\n", " variance = jnp.sqrt(alpha_n ** 2 + sigma_n ** 2) \n", - " return variance\n" + " return variance" ] }, { @@ -219,7 +296,7 @@ "\n", "Cosine Schedule is one of the most widely used noise schedules. Its a Variance Preserving noise schedule and can either be parameterized directly as the functions $\\alpha(t)$ and $\\sigma(t)$ defined directly as \n", "\n", - "$cos(\\dfrac{\\pi t}{2 T})$ and $sin(\\dfrac{\\pi t}{2 T})$, \n", + "$\\alpha(t) = cos(\\dfrac{\\pi t}{2 T})$ and $\\sigma(t) = sin(\\dfrac{\\pi t}{2 T})$, \n", "\n", "which is simple to understand as $sin(x)^2 + cos(x)^2 = 1$, which satisfies the variance preserving constraint, \n", "or in terms of functions depending on a $\\beta(t)$ parameter as defined in the original DDPM paper and many more places. \n", @@ -236,48 +313,92 @@ "\n", "where $x_t$ is the data sample at time $t$, $x_{t-1}$ is the previous data sample, and $\\epsilon_t$ is the Gaussian noise at time $t$. Notice that $x_t$ is phrased in terms of $x_{t-1}$ instead of the initial data sample $x_0$ as we did in the 'Noise Schedulers' section. \n", "\n", - "To convert this formulation to the type \n", + "To convert this formulation to the type we discussed above\n", + "\n", "$x_t = \\alpha_t x_0 + \\sigma_t \\epsilon_0$,\n", "\n", - "we can find that our signal rate $\\alpha_t$ and noise rate $\\sigma_t$ are given by:\n", + "we can find that our signal rate $\\alpha_t$ and noise rate $\\sigma_t$ can be defined as\n", "\n", "$\\alpha_t = \\prod_t \\sqrt{1-\\beta_t}$\n", "\n", "$\\sigma_t = \\sqrt{1-\\alpha_t^2}$ \n", "\n", - "The thing is, the maths in DDPM paper use the symbol $\\alpha$ for a different thing, as an intermediate to denote the value $\\alpha_t = 1-\\beta_t$, so just be careful with the notation. We use $\\alpha$ to denote the signal rate in this notebook." + "**Note: The thing is, the maths in DDPM paper use the symbol $\\alpha$ for a different thing, as an intermediate to denote the value $\\alpha_t = 1-\\beta_t$, so just be careful with the notation. We use $\\alpha$ to denote the signal rate in this notebook.**\n", + "\n", + "We shall thus define the Cosine Noise Scheduler twice: Once in terms of the $\\beta(t)$ parameter aka the way its formulated in the DDPM paper, and then in a more simplified way directly in terms of $\\alpha(t)$ and $\\sigma(t)$." ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "### Cosine Noise Scheduler in terms of $\\beta(t)$" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def cosine_beta_schedule(timesteps, start_angle=0.008, end_angle=0.999):\n", + " ts = np.linspace(0, 1, timesteps + 1, dtype=np.float64)\n", + " alphas_bar = np.cos((ts + start_angle) / (1 + start_angle) * np.pi /2) ** 2\n", + " alphas_bar = alphas_bar/alphas_bar[0]\n", + " betas = 1 - (alphas_bar[1:] / alphas_bar[:-1])\n", + " return np.clip(betas, 0, end_angle)\n", + "\n", + "class CosineDiscreteNoiseSchedule(NoiseScheduler):\n", + " \"\"\"\n", + " Variance Preserving Noise Scheduler\n", + " signal_rate**2 + noise_rate**2 = 1\n", + " \"\"\"\n", + " def __init__(self, timesteps,\n", + " beta_start=0.008, \n", + " beta_end=0.999,\n", + " *args, **kwargs):\n", + " super().__init__(timesteps, *args, **kwargs)\n", + " betas = cosine_beta_schedule(timesteps, beta_start, beta_end)\n", + " self.betas = jnp.array(betas)\n", + " alphas = jnp.cumprod(jnp.sqrt(1 - betas))\n", + " self.alphas = alphas # This is not the same alpha as mentioned in the original paper!\n", + " self.sigmas = jnp.sqrt(1 - alphas ** 2)\n", + " \n", + " def get_rates(self, steps, shape=()):\n", + " steps = jnp.astype(steps, jnp.int32)\n", + " alpha = self.alphas[steps]\n", + " sigma = self.sigmas[steps]\n", + " alpha = jnp.reshape(alpha, shape)\n", + " sigma = jnp.reshape(sigma, shape)\n", + " return alpha, sigma\n", + " \n", + " def get_weights(self, steps, shape=(-1, 1, 1, 1)):\n", + " return 1 # For simplicity, we are not using weights in this case" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cosine Noise Scheduler in terms of $\\alpha(t)$ and $\\sigma(t)$" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ - "\n", "class ContinuousNoiseScheduler(NoiseScheduler):\n", " \"\"\"\n", " General Continuous Noise Scheduler\n", " \"\"\"\n", " def __init__(self, *args, **kwargs):\n", - " super().__init__(timesteps=1, *args, **kwargs)\n", - "\n", + " super().__init__(*args, **kwargs)\n", + " \n", "class CosineContinuousNoiseScheduler(ContinuousNoiseScheduler):\n", " def get_rates(self, steps, shape=(-1, 1, 1, 1)) -> tuple[jnp.ndarray, jnp.ndarray]:\n", + " steps = jnp.float32(steps)\n", " signal_rates = jnp.cos((jnp.pi * steps) / (2 * self.max_timesteps))\n", " noise_rates = jnp.sin((jnp.pi * steps) / (2 * self.max_timesteps))\n", " return self.reshape_rates((signal_rates, noise_rates), shape=shape)\n", @@ -288,6 +409,3119 @@ " " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lets play with our Noise Schedulers\n", + "### Visualization of $\\alpha(t)$ and $\\sigma(t)$ with linear time steps $t$\n", + "to prove that both are equivalent." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Discrete Cosine Noise Schedule\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Continuous Cosine Noise Schedule\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "maxT = 1000\n", + "timesteps = jnp.linspace(0, maxT, 1000)\n", + "get_variance = lambda rates: rates[0] ** 2 + rates[1] ** 2\n", + "\"\"\"\n", + "Lets first plot the signal and noise rates for the discrete cosine noise schedule\n", + "\"\"\"\n", + "print(\"Discrete Cosine Noise Schedule\")\n", + "schedule = CosineDiscreteNoiseSchedule(maxT)\n", + "plt.plot([schedule.get_rates(i, shape=()) for i in timesteps], label=[\"signal\", \"noise\"])\n", + "plt.plot([get_variance(schedule.get_rates(i, shape=())) for i in timesteps], label=\"variance\")\n", + "plt.show()\n", + "\n", + "print(\"Continuous Cosine Noise Schedule\")\n", + "schedule = CosineContinuousNoiseScheduler(maxT)\n", + "plt.plot([schedule.get_rates(i, shape=()) for i in timesteps], label=[\"signal\", \"noise\"])\n", + "plt.plot([get_variance(schedule.get_rates(i, shape=())) for i in timesteps], label=\"variance\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now lets test the noise scheduler on some simple images\n", + "\n", + "We shall first sample some images from our dataset, then apply some noise to them using the noise scheduler, and then visualize the images at different time steps to see how the noise is added, and then how it is removed." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-07-07 00:51:42.862677: W tensorflow/core/kernels/data/cache_dataset_ops.cc:913] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rates: alpha=[[[[0.7071067]]]], sigma=[[[[0.7071068]]]]\n", + "Noisy Images\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_6640/3433040840.py:11: UserWarning: Explicitly requested dtype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " noise = jax.random.normal(jax.random.PRNGKey(4), shape=images.shape, dtype=jnp.float64)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reconstructed Images\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize adding some noise to some sample images and then removing it\n", + "data, _ = get_dataset(\"oxford_flowers102\", batch_size=32, image_scale=64)\n", + "images = next(iter(data))\n", + "plotImages(images)\n", + "noise_level = 500\n", + "noise_level_max = 1000\n", + "schedule = CosineContinuousNoiseScheduler(noise_level_max)\n", + "\n", + "alpha_t, sigma_t = schedule.get_rates(noise_level)\n", + "print(f\"Rates: alpha={alpha_t}, sigma={sigma_t}\") \n", + "noise = jax.random.normal(jax.random.PRNGKey(4), shape=images.shape, dtype=jnp.float64)\n", + "noisy_images = schedule.add_noise(images, noise, noise_level)\n", + "print(\"Noisy Images\")\n", + "plotImages(noisy_images)\n", + "print(\"Reconstructed Images\")\n", + "reconstructed_images = schedule.remove_all_noise(noisy_images, noise, noise_level)\n", + "plotImages(reconstructed_images)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modeling\n", + "\n", + "Neural network comes into play for learning to estimate the gradient $\\nabla_{x_t} \\log p_t(x_t)$ in the reverse diffusion process as described above:\n", + "\n", + "$dx_t = [f(t, x_t) - g(t, x_t)^2 \\nabla_{x_t} \\log p_t(x_t)] \\, dt + g(t, x_t) \\, d\\bar{W}_t $\n", + "\n", + "Score based models estimate the gradient $\\nabla_{x_t} \\log p_t(x_t)$ directly as\n", + "\n", + "$ s_{\\theta}(x_t) = \\nabla_{x_t} \\log p_t(x_t) $\n", + "\n", + "where $s_{\\theta}(x_t)$ is the score model, and $\\theta$ are the parameters of the score model. But we can also model it in terms of a neural network that predicts the actual noise at time $t$ as well\n", + "\n", + "$ \\frac{\\epsilon_{\\theta}(x_t, t)}{\\sigma_t} \\approx - s_{\\theta}(x_t) = \\nabla_{x_t} \\log p_t(x_t) $\n", + "\n", + "where $\\epsilon_{\\theta}(x_t, t)$ is the denoising model, and $\\theta$ are the parameters of the denoising model.\n", + "In this notebook, we will be using this denoising model for solving the reverse diffusion process.\n", + "\n", + "## Denoising Model\n", + "\n", + "We will be using a simple UNet architecture for our denoising model. The UNet architecture is a popular architecture for image segmentation tasks, but it proves to be quite useful for denoising tasks as well. The architecture is quite simple and consists of an encoder and a decoder connected by skip connections. The encoder downsamples the input image and extracts features, while the decoder upsamples the features and reconstructs the image. The skip connections help in preserving spatial information and gradients.\n", + "\n", + "We will also add some self attention blocks at each level of the UNet to help the model focus on finding clues in the image that are important for denoising.\n", + "\n", + "The encoder and decoder blocks will be made of several resolution levels, and on each level will be made of several residual blocks, an attention block and a downsampling or upsampling block (for encoder and decoder respectively). There would also be a middle block of a single level of the same design but without downsampling or upsampling.\n", + "\n", + "As our model $\\epsilon_{\\theta}(x_t, t)$ takes as input the time step $t$ as well, we will feed the model an additional input of the time step $t$ which would be added to each residual block after being embedded in a certain way and transformed and projected by few linear layers. The time step $t$ would be embedded in a way similar to how positional encodings are added in transformers. \n", + "\n", + "**We shall use the fourier embedding of the time step $t$ in our model.**\n", + "\n", + "**We shall also use separable convolutions in our model to reduce the number of parameters and thus the memory required. If these models do not compile on your machine, try switching all blocks to separable convs and than further reducing the resolution wise feature level sizes.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The basic building blocks" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Kernel initializer to use\n", + "def kernel_init(scale):\n", + " scale = max(scale, 1e-10)\n", + " return nn.initializers.variance_scaling(scale=scale, mode=\"fan_in\", distribution=\"truncated_normal\")\n", + "\n", + "class NormalAttention(nn.Module):\n", + " \"\"\"\n", + " Simple implementation of the normal attention.\n", + " \"\"\"\n", + " query_dim: int\n", + " heads: int = 4\n", + " dim_head: int = 64\n", + " dtype: Any = jnp.float32\n", + " precision: Any = jax.lax.Precision.HIGHEST\n", + " use_bias: bool = True\n", + " kernel_init: Callable = lambda : kernel_init(1.0)\n", + "\n", + " def setup(self):\n", + " inner_dim = self.dim_head * self.heads\n", + " dense = functools.partial(\n", + " nn.DenseGeneral,\n", + " features=[self.heads, self.dim_head], \n", + " axis=-1, \n", + " precision=self.precision, \n", + " use_bias=self.use_bias, \n", + " kernel_init=self.kernel_init(), \n", + " dtype=self.dtype\n", + " )\n", + " self.query = dense(name=\"to_q\")\n", + " self.key = dense(name=\"to_k\")\n", + " self.value = dense(name=\"to_v\")\n", + "\n", + " self.proj_attn = nn.DenseGeneral(\n", + " self.query_dim, \n", + " axis=(-2, -1), \n", + " precision=self.precision, \n", + " use_bias=self.use_bias, \n", + " dtype=self.dtype, \n", + " name=\"to_out_0\",\n", + " kernel_init=self.kernel_init()\n", + " # kernel_init=jax.nn.initializers.xavier_uniform()\n", + " )\n", + "\n", + " @nn.compact\n", + " def __call__(self, x, context=None):\n", + " # x has shape [B, H, W, C]\n", + " context = x if context is None else context\n", + " query = self.query(x)\n", + " key = self.key(context)\n", + " value = self.value(context)\n", + "\n", + " hidden_states = nn.dot_product_attention(\n", + " query, key, value, dtype=self.dtype, broadcast_dropout=False, dropout_rng=None, precision=self.precision\n", + " )\n", + " proj = self.proj_attn(hidden_states)\n", + " return proj\n", + "\n", + "class AttentionBlock(nn.Module):\n", + " heads: int = 4\n", + " dim_head: int = 32\n", + " use_linear_attention: bool = True\n", + " dtype: Any = jnp.float32\n", + " precision: Any = jax.lax.Precision.HIGH\n", + " use_projection: bool = False\n", + "\n", + " @nn.compact\n", + " def __call__(self, x):\n", + " inner_dim = self.heads * self.dim_head\n", + " B, H, W, C = x.shape\n", + " normed_x = nn.RMSNorm(epsilon=1e-5, dtype=self.dtype)(x)\n", + " projected_x = NormalAttention(\n", + " query_dim=C,\n", + " heads=self.heads,\n", + " dim_head=self.dim_head,\n", + " name=f'Attention',\n", + " precision=self.precision,\n", + " use_bias=False,\n", + " )(normed_x)\n", + " out = x + projected_x\n", + " return out\n", + " \n", + "class FourierEmbedding(nn.Module):\n", + " features:int\n", + " scale:int = 16\n", + "\n", + " def setup(self):\n", + " self.freqs = jax.random.normal(jax.random.PRNGKey(42), (self.features // 2, ), dtype=jnp.float32) * self.scale\n", + "\n", + " def __call__(self, x):\n", + " x = jax.lax.convert_element_type(x, jnp.float32)\n", + " emb = x[:, None] * (2 * jnp.pi * self.freqs)[None, :]\n", + " emb = jnp.concatenate([jnp.sin(emb), jnp.cos(emb)], axis=-1)\n", + " return emb\n", + "\n", + "class TimeProjection(nn.Module):\n", + " features:int\n", + " activation:Callable=jax.nn.gelu\n", + "\n", + " @nn.compact\n", + " def __call__(self, x):\n", + " x = nn.DenseGeneral(self.features, kernel_init=kernel_init(1.0))(x)\n", + " x = self.activation(x)\n", + " x = nn.DenseGeneral(self.features, kernel_init=kernel_init(1.0))(x)\n", + " x = self.activation(x)\n", + " return x\n", + "\n", + "class SeparableConv(nn.Module):\n", + " features:int\n", + " kernel_size:tuple=(3, 3)\n", + " strides:tuple=(1, 1)\n", + " use_bias:bool=False\n", + " kernel_init:Callable=kernel_init(1.0)\n", + " padding:str=\"SAME\"\n", + "\n", + " @nn.compact\n", + " def __call__(self, x):\n", + " in_features = x.shape[-1]\n", + " depthwise = nn.Conv(\n", + " features=in_features, kernel_size=self.kernel_size,\n", + " strides=self.strides, kernel_init=self.kernel_init,\n", + " feature_group_count=in_features, use_bias=self.use_bias,\n", + " padding=self.padding\n", + " )(x)\n", + " pointwise = nn.Conv(\n", + " features=self.features, kernel_size=(1, 1),\n", + " strides=(1, 1), kernel_init=self.kernel_init,\n", + " use_bias=self.use_bias\n", + " )(depthwise)\n", + " return pointwise\n", + "\n", + "class ConvLayer(nn.Module):\n", + " conv_type:str\n", + " features:int\n", + " kernel_size:tuple=(3, 3)\n", + " strides:tuple=(1, 1)\n", + " kernel_init:Callable=kernel_init(1.0)\n", + "\n", + " def setup(self):\n", + " if self.conv_type == \"conv\":\n", + " self.conv = nn.Conv(\n", + " features=self.features,\n", + " kernel_size=self.kernel_size,\n", + " strides=self.strides,\n", + " kernel_init=self.kernel_init,\n", + " )\n", + " elif self.conv_type == \"separable\":\n", + " self.conv = SeparableConv(\n", + " features=self.features,\n", + " kernel_size=self.kernel_size,\n", + " strides=self.strides,\n", + " kernel_init=self.kernel_init,\n", + " )\n", + "\n", + " def __call__(self, x):\n", + " return self.conv(x)\n", + "\n", + "class Upsample(nn.Module):\n", + " features:int\n", + " scale:int\n", + " activation:Callable=jax.nn.swish\n", + "\n", + " @nn.compact\n", + " def __call__(self, x, residual=None):\n", + " out = x\n", + " # out = PixelShuffle(scale=self.scale)(out)\n", + " B, H, W, C = x.shape\n", + " out = jax.image.resize(x, (B, H * self.scale, W * self.scale, C), method=\"nearest\")\n", + " out = ConvLayer(\n", + " \"conv\",\n", + " features=self.features,\n", + " kernel_size=(3, 3),\n", + " strides=(1, 1),\n", + " )(out)\n", + " if residual is not None:\n", + " out = jnp.concatenate([out, residual], axis=-1)\n", + " return out\n", + "\n", + "class Downsample(nn.Module):\n", + " features:int\n", + " scale:int\n", + " activation:Callable=jax.nn.swish\n", + "\n", + " @nn.compact\n", + " def __call__(self, x, residual=None):\n", + " out = ConvLayer(\n", + " \"conv\",\n", + " features=self.features,\n", + " kernel_size=(3, 3),\n", + " strides=(2, 2)\n", + " )(x)\n", + " if residual is not None:\n", + " if residual.shape[1] > out.shape[1]:\n", + " residual = nn.avg_pool(residual, window_shape=(2, 2), strides=(2, 2), padding=\"SAME\")\n", + " out = jnp.concatenate([out, residual], axis=-1)\n", + " return out\n", + "\n", + "class ResidualBlock(nn.Module):\n", + " conv_type:str\n", + " features:int\n", + " kernel_size:tuple=(3, 3)\n", + " strides:tuple=(1, 1)\n", + " padding:str=\"SAME\"\n", + " activation:Callable=jax.nn.swish\n", + " direction:str=None\n", + " res:int=2\n", + " norm_groups:int=8\n", + " kernel_init:Callable=kernel_init(1.0)\n", + "\n", + " @nn.compact\n", + " def __call__(self, x:jax.Array, temb:jax.Array, extra_features:jax.Array=None):\n", + " residual = x\n", + " out = nn.GroupNorm(self.norm_groups)(x)\n", + " out = self.activation(out)\n", + "\n", + " out = ConvLayer(\n", + " self.conv_type,\n", + " features=self.features,\n", + " kernel_size=self.kernel_size,\n", + " strides=self.strides,\n", + " kernel_init=self.kernel_init,\n", + " name=\"conv1\"\n", + " )(out)\n", + "\n", + " temb = nn.DenseGeneral(features=self.features, name=\"temb_projection\")(temb)\n", + " temb = jnp.expand_dims(jnp.expand_dims(temb, 1), 1)\n", + " out = out + temb\n", + "\n", + " out = nn.GroupNorm(self.norm_groups)(out)\n", + " out = self.activation(out)\n", + "\n", + " out = ConvLayer(\n", + " self.conv_type,\n", + " features=self.features,\n", + " kernel_size=self.kernel_size,\n", + " strides=self.strides,\n", + " kernel_init=self.kernel_init,\n", + " name=\"conv2\"\n", + " )(out)\n", + "\n", + " if residual.shape != out.shape:\n", + " residual = ConvLayer(\n", + " self.conv_type,\n", + " features=self.features,\n", + " kernel_size=(1, 1),\n", + " strides=1,\n", + " kernel_init=self.kernel_init,\n", + " name=\"residual_conv\"\n", + " )(residual)\n", + " out = out + residual\n", + "\n", + " out = jnp.concatenate([out, extra_features], axis=-1) if extra_features is not None else out\n", + "\n", + " return out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Main UNet Model" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "class Unet(nn.Module):\n", + " emb_features:int=64*4,\n", + " feature_depths:list=[64, 128, 256, 512],\n", + " attention_configs:list=[{\"heads\":8}, {\"heads\":8}, {\"heads\":8}, {\"heads\":8}],\n", + " num_res_blocks:int=2,\n", + " num_middle_res_blocks:int=1,\n", + " activation:Callable = jax.nn.mish\n", + " norm_groups:int=8\n", + "\n", + " @nn.compact\n", + " def __call__(self, x, temb):\n", + " temb = FourierEmbedding(features=self.emb_features)(temb)\n", + " temb = TimeProjection(features=self.emb_features)(temb)\n", + " feature_depths = self.feature_depths\n", + " attention_configs = self.attention_configs\n", + "\n", + " conv_type = \"conv\"\n", + " middle_conv_type = up_conv_type = down_conv_type = \"separable\"\n", + "\n", + " x = ConvLayer(\n", + " conv_type,\n", + " features=self.feature_depths[0],\n", + " kernel_size=(3, 3),\n", + " strides=(1, 1),\n", + " kernel_init=kernel_init(1.0)\n", + " )(x)\n", + " downs = [x]\n", + "\n", + " # Downscaling blocks\n", + " for i, (dim_out, attention_config) in enumerate(zip(feature_depths, attention_configs)):\n", + " dim_in = x.shape[-1]\n", + " # dim_in = dim_out\n", + " for j in range(self.num_res_blocks):\n", + " x = ResidualBlock(\n", + " down_conv_type,\n", + " name=f\"down_{i}_residual_{j}\",\n", + " features=dim_in,\n", + " kernel_init=kernel_init(1.0),\n", + " kernel_size=(3, 3),\n", + " strides=(1, 1),\n", + " activation=self.activation,\n", + " norm_groups=self.norm_groups\n", + " )(x, temb)\n", + " if attention_config is not None and j == self.num_res_blocks - 1: # Apply attention only on the last block\n", + " x = AttentionBlock(heads=attention_config['heads'], \n", + " dim_head=dim_in // attention_config['heads'],\n", + " name=f\"down_{i}_attention_{j}\")(x)\n", + " downs.append(x)\n", + " if i != len(feature_depths) - 1:\n", + " x = Downsample(\n", + " features=dim_out,\n", + " scale=2,\n", + " activation=self.activation,\n", + " name=f\"down_{i}_downsample\"\n", + " )(x)\n", + "\n", + " # Middle Blocks\n", + " middle_dim_out = self.feature_depths[-1]\n", + " middle_attention = self.attention_configs[-1]\n", + " for j in range(self.num_middle_res_blocks):\n", + " x = ResidualBlock(\n", + " middle_conv_type,\n", + " name=f\"middle_res1_{j}\",\n", + " features=middle_dim_out,\n", + " kernel_init=kernel_init(1.0),\n", + " kernel_size=(3, 3),\n", + " strides=(1, 1),\n", + " activation=self.activation,\n", + " norm_groups=self.norm_groups\n", + " )(x, temb)\n", + " if middle_attention is not None and j == self.num_middle_res_blocks - 1: # Apply attention only on the last block\n", + " x = AttentionBlock(heads=attention_config['heads'], \n", + " dim_head=middle_dim_out // attention_config['heads'],\n", + " use_linear_attention=False, name=f\"middle_attention_{j}\")(x)\n", + " x = ResidualBlock(\n", + " middle_conv_type,\n", + " name=f\"middle_res2_{j}\",\n", + " features=middle_dim_out,\n", + " kernel_init=kernel_init(1.0),\n", + " kernel_size=(3, 3),\n", + " strides=(1, 1),\n", + " activation=self.activation,\n", + " norm_groups=self.norm_groups\n", + " )(x, temb)\n", + "\n", + " # Upscaling Blocks\n", + " for i, (dim_out, attention_config) in enumerate(zip(reversed(feature_depths), reversed(attention_configs))):\n", + " for j in range(self.num_res_blocks):\n", + " x = jnp.concatenate([x, downs.pop()], axis=-1)\n", + " kernel_size = (3, 3)\n", + " x = ResidualBlock(\n", + " up_conv_type,\n", + " name=f\"up_{i}_residual_{j}\",\n", + " features=dim_out,\n", + " kernel_init=kernel_init(1.0),\n", + " kernel_size=kernel_size,\n", + " strides=(1, 1),\n", + " activation=self.activation,\n", + " norm_groups=self.norm_groups\n", + " )(x, temb)\n", + " if attention_config is not None and j == self.num_res_blocks - 1: # Apply attention only on the last block\n", + " x = AttentionBlock(heads=attention_config['heads'], \n", + " dim_head=dim_out // attention_config['heads'],\n", + " name=f\"up_{i}_attention_{j}\")(x)\n", + " if i != len(feature_depths) - 1:\n", + " x = Upsample(\n", + " features=feature_depths[-i],\n", + " scale=2,\n", + " activation=self.activation,\n", + " name=f\"up_{i}_upsample\"\n", + " )(x)\n", + " \n", + " x = jnp.concatenate([x, downs.pop()], axis=-1)\n", + "\n", + " x = ResidualBlock(\n", + " conv_type,\n", + " name=\"final_residual\",\n", + " features=self.feature_depths[0],\n", + " kernel_init=kernel_init(1.0),\n", + " kernel_size=(3,3),\n", + " strides=(1, 1),\n", + " activation=self.activation,\n", + " norm_groups=self.norm_groups\n", + " )(x, temb)\n", + "\n", + " x = nn.GroupNorm(self.norm_groups)(x)\n", + " x = self.activation(x)\n", + "\n", + " noise_out = ConvLayer(\n", + " conv_type,\n", + " features=3,\n", + " kernel_size=(3, 3),\n", + " strides=(1, 1),\n", + " # activation=jax.nn.mish\n", + " kernel_init=kernel_init(0.0)\n", + " )(x)\n", + " return noise_out#, attentions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Validate the model" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
                                                                  Unet Summary                                                                  \n",
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ path                                      ┃ module           ┃ inputs                 ┃ outputs               ┃ params                       ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│                                           │ Unet             │ - float32[1,64,64,3]   │ float32[1,64,64,3]    │                              │\n",
+       "│                                           │                  │ - float32[1]           │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ FourierEmbedding_0                        │ FourierEmbedding │ float32[1]             │ float32[1,256]        │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ TimeProjection_0                          │ TimeProjection   │ float32[1,256]         │ float32[1,256]        │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ TimeProjection_0/DenseGeneral_0           │ DenseGeneral     │ float32[1,256]         │ float32[1,256]        │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,256]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,792 (263.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ TimeProjection_0/DenseGeneral_1           │ DenseGeneral     │ float32[1,256]         │ float32[1,256]        │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,256]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,792 (263.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ ConvLayer_0                               │ ConvLayer        │ float32[1,64,64,3]     │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ ConvLayer_0/conv                          │ Conv             │ float32[1,64,64,3]     │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,3,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,792 (7.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0                         │ ResidualBlock    │ - float32[1,64,64,64]  │ float32[1,64,64,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/GroupNorm_0             │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv1                   │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv1/conv              │ SeparableConv    │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv1/conv/Conv_0       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv1/conv/Conv_1       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/GroupNorm_1             │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv2                   │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv2/conv              │ SeparableConv    │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv2/conv/Conv_0       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_0/conv2/conv/Conv_1       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1                         │ ResidualBlock    │ - float32[1,64,64,64]  │ float32[1,64,64,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/GroupNorm_0             │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv1                   │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv1/conv              │ SeparableConv    │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv1/conv/Conv_0       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv1/conv/Conv_1       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/GroupNorm_1             │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv2                   │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv2/conv              │ SeparableConv    │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv2/conv/Conv_0       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_residual_1/conv2/conv/Conv_1       │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1                        │ AttentionBlock   │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1/RMSNorm_0              │ RMSNorm          │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 64 (256 B)                   │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1/Attention              │ NormalAttention  │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1/Attention/to_q         │ DenseGeneral     │ float32[1,64,64,64]    │ float32[1,64,64,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1/Attention/to_k         │ DenseGeneral     │ float32[1,64,64,64]    │ float32[1,64,64,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1/Attention/to_v         │ DenseGeneral     │ float32[1,64,64,64]    │ float32[1,64,64,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_attention_1/Attention/to_out_0     │ DenseGeneral     │ float32[1,64,64,4,16]  │ float32[1,64,64,64]   │ kernel: float32[4,16,64]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_downsample                         │ Downsample       │ float32[1,64,64,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_downsample/ConvLayer_0             │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_0_downsample/ConvLayer_0/conv        │ Conv             │ float32[1,64,64,64]    │ float32[1,32,32,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 36,928 (147.7 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0                         │ ResidualBlock    │ - float32[1,32,32,64]  │ float32[1,32,32,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/GroupNorm_0             │ GroupNorm        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv1                   │ ConvLayer        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv1/conv              │ SeparableConv    │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv1/conv/Conv_0       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv1/conv/Conv_1       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/GroupNorm_1             │ GroupNorm        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv2                   │ ConvLayer        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv2/conv              │ SeparableConv    │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv2/conv/Conv_0       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_0/conv2/conv/Conv_1       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1                         │ ResidualBlock    │ - float32[1,32,32,64]  │ float32[1,32,32,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/GroupNorm_0             │ GroupNorm        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv1                   │ ConvLayer        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv1/conv              │ SeparableConv    │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv1/conv/Conv_0       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv1/conv/Conv_1       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/GroupNorm_1             │ GroupNorm        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv2                   │ ConvLayer        │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv2/conv              │ SeparableConv    │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv2/conv/Conv_0       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_residual_1/conv2/conv/Conv_1       │ Conv             │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1                        │ AttentionBlock   │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1/RMSNorm_0              │ RMSNorm          │ float32[1,32,32,64]    │ float32[1,32,32,64]   │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 64 (256 B)                   │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1/Attention              │ NormalAttention  │ float32[1,32,32,64]    │ float32[1,32,32,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1/Attention/to_q         │ DenseGeneral     │ float32[1,32,32,64]    │ float32[1,32,32,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1/Attention/to_k         │ DenseGeneral     │ float32[1,32,32,64]    │ float32[1,32,32,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1/Attention/to_v         │ DenseGeneral     │ float32[1,32,32,64]    │ float32[1,32,32,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_attention_1/Attention/to_out_0     │ DenseGeneral     │ float32[1,32,32,4,16]  │ float32[1,32,32,64]   │ kernel: float32[4,16,64]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_downsample                         │ Downsample       │ float32[1,32,32,64]    │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_downsample/ConvLayer_0             │ ConvLayer        │ float32[1,32,32,64]    │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_1_downsample/ConvLayer_0/conv        │ Conv             │ float32[1,32,32,64]    │ float32[1,16,16,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,64,128]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 73,856 (295.4 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0                         │ ResidualBlock    │ - float32[1,16,16,128] │ float32[1,16,16,128]  │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/GroupNorm_0             │ GroupNorm        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv1                   │ ConvLayer        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv1/conv              │ SeparableConv    │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv1/conv/Conv_0       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv1/conv/Conv_1       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[1,1,128,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,128]        │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,128]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 32,896 (131.6 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/GroupNorm_1             │ GroupNorm        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv2                   │ ConvLayer        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv2/conv              │ SeparableConv    │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv2/conv/Conv_0       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_0/conv2/conv/Conv_1       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[1,1,128,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1                         │ ResidualBlock    │ - float32[1,16,16,128] │ float32[1,16,16,128]  │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/GroupNorm_0             │ GroupNorm        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv1                   │ ConvLayer        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv1/conv              │ SeparableConv    │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv1/conv/Conv_0       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv1/conv/Conv_1       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[1,1,128,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,128]        │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,128]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 32,896 (131.6 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/GroupNorm_1             │ GroupNorm        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv2                   │ ConvLayer        │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv2/conv              │ SeparableConv    │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv2/conv/Conv_0       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_residual_1/conv2/conv/Conv_1       │ Conv             │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ kernel: float32[1,1,128,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1                        │ AttentionBlock   │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1/RMSNorm_0              │ RMSNorm          │ float32[1,16,16,128]   │ float32[1,16,16,128]  │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1/Attention              │ NormalAttention  │ float32[1,16,16,128]   │ float32[1,16,16,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1/Attention/to_q         │ DenseGeneral     │ float32[1,16,16,128]   │ float32[1,16,16,4,32] │ kernel: float32[128,4,32]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1/Attention/to_k         │ DenseGeneral     │ float32[1,16,16,128]   │ float32[1,16,16,4,32] │ kernel: float32[128,4,32]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1/Attention/to_v         │ DenseGeneral     │ float32[1,16,16,128]   │ float32[1,16,16,4,32] │ kernel: float32[128,4,32]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_attention_1/Attention/to_out_0     │ DenseGeneral     │ float32[1,16,16,4,32]  │ float32[1,16,16,128]  │ kernel: float32[4,32,128]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_downsample                         │ Downsample       │ float32[1,16,16,128]   │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_downsample/ConvLayer_0             │ ConvLayer        │ float32[1,16,16,128]   │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_2_downsample/ConvLayer_0/conv        │ Conv             │ float32[1,16,16,128]   │ float32[1,8,8,256]    │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,128,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 295,168 (1.2 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0                         │ ResidualBlock    │ - float32[1,8,8,256]   │ float32[1,8,8,256]    │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/GroupNorm_0             │ GroupNorm        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv1                   │ ConvLayer        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv1/conv              │ SeparableConv    │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv1/conv/Conv_0       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv1/conv/Conv_1       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[1,1,256,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,256]        │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,256]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,792 (263.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/GroupNorm_1             │ GroupNorm        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv2                   │ ConvLayer        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv2/conv              │ SeparableConv    │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv2/conv/Conv_0       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_0/conv2/conv/Conv_1       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[1,1,256,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1                         │ ResidualBlock    │ - float32[1,8,8,256]   │ float32[1,8,8,256]    │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/GroupNorm_0             │ GroupNorm        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv1                   │ ConvLayer        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv1/conv              │ SeparableConv    │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv1/conv/Conv_0       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv1/conv/Conv_1       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[1,1,256,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/temb_projection         │ DenseGeneral     │ float32[1,256]         │ float32[1,256]        │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,256]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,792 (263.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/GroupNorm_1             │ GroupNorm        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv2                   │ ConvLayer        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv2/conv              │ SeparableConv    │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv2/conv/Conv_0       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_residual_1/conv2/conv/Conv_1       │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[1,1,256,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1                        │ AttentionBlock   │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1/RMSNorm_0              │ RMSNorm          │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1/Attention              │ NormalAttention  │ float32[1,8,8,256]     │ float32[1,8,8,256]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1/Attention/to_q         │ DenseGeneral     │ float32[1,8,8,256]     │ float32[1,8,8,4,64]   │ kernel: float32[256,4,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1/Attention/to_k         │ DenseGeneral     │ float32[1,8,8,256]     │ float32[1,8,8,4,64]   │ kernel: float32[256,4,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1/Attention/to_v         │ DenseGeneral     │ float32[1,8,8,256]     │ float32[1,8,8,4,64]   │ kernel: float32[256,4,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ down_3_attention_1/Attention/to_out_0     │ DenseGeneral     │ float32[1,8,8,4,64]    │ float32[1,8,8,256]    │ kernel: float32[4,64,256]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0                             │ ResidualBlock    │ - float32[1,8,8,256]   │ float32[1,8,8,512]    │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/GroupNorm_0                 │ GroupNorm        │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv1                       │ ConvLayer        │ float32[1,8,8,256]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv1/conv                  │ SeparableConv    │ float32[1,8,8,256]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv1/conv/Conv_0           │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv1/conv/Conv_1           │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,512]    │ kernel: float32[1,1,256,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 131,072 (524.3 KB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/temb_projection             │ DenseGeneral     │ float32[1,256]         │ float32[1,512]        │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,512]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 131,584 (526.3 KB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/GroupNorm_1                 │ GroupNorm        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,024 (4.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv2                       │ ConvLayer        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv2/conv                  │ SeparableConv    │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv2/conv/Conv_0           │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[3,3,1,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,608 (18.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/conv2/conv/Conv_1           │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[1,1,512,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/residual_conv               │ ConvLayer        │ float32[1,8,8,256]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/residual_conv/conv          │ SeparableConv    │ float32[1,8,8,256]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/residual_conv/conv/Conv_0   │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,256]    │ kernel: float32[1,1,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res1_0/residual_conv/conv/Conv_1   │ Conv             │ float32[1,8,8,256]     │ float32[1,8,8,512]    │ kernel: float32[1,1,256,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 131,072 (524.3 KB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0                        │ AttentionBlock   │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0/RMSNorm_0              │ RMSNorm          │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0/Attention              │ NormalAttention  │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0/Attention/to_q         │ DenseGeneral     │ float32[1,8,8,512]     │ float32[1,8,8,4,128]  │ kernel: float32[512,4,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0/Attention/to_k         │ DenseGeneral     │ float32[1,8,8,512]     │ float32[1,8,8,4,128]  │ kernel: float32[512,4,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0/Attention/to_v         │ DenseGeneral     │ float32[1,8,8,512]     │ float32[1,8,8,4,128]  │ kernel: float32[512,4,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_attention_0/Attention/to_out_0     │ DenseGeneral     │ float32[1,8,8,4,128]   │ float32[1,8,8,512]    │ kernel: float32[4,128,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0                             │ ResidualBlock    │ - float32[1,8,8,512]   │ float32[1,8,8,512]    │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/GroupNorm_0                 │ GroupNorm        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,024 (4.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv1                       │ ConvLayer        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv1/conv                  │ SeparableConv    │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv1/conv/Conv_0           │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[3,3,1,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,608 (18.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv1/conv/Conv_1           │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[1,1,512,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/temb_projection             │ DenseGeneral     │ float32[1,256]         │ float32[1,512]        │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,512]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 131,584 (526.3 KB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/GroupNorm_1                 │ GroupNorm        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,024 (4.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv2                       │ ConvLayer        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv2/conv                  │ SeparableConv    │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv2/conv/Conv_0           │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[3,3,1,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,608 (18.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ middle_res2_0/conv2/conv/Conv_1           │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[1,1,512,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0                           │ ResidualBlock    │ - float32[1,8,8,768]   │ float32[1,8,8,512]    │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/GroupNorm_0               │ GroupNorm        │ float32[1,8,8,768]     │ float32[1,8,8,768]    │ bias: float32[768]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[768]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,536 (6.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv1                     │ ConvLayer        │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv1/conv                │ SeparableConv    │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv1/conv/Conv_0         │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,768]    │ kernel: float32[3,3,1,768]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 6,912 (27.6 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv1/conv/Conv_1         │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,512]    │ kernel: float32[1,1,768,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 393,216 (1.6 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,512]        │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,512]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 131,584 (526.3 KB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/GroupNorm_1               │ GroupNorm        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,024 (4.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv2                     │ ConvLayer        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv2/conv                │ SeparableConv    │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv2/conv/Conv_0         │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[3,3,1,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,608 (18.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/conv2/conv/Conv_1         │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[1,1,512,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/residual_conv             │ ConvLayer        │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/residual_conv/conv        │ SeparableConv    │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/residual_conv/conv/Conv_0 │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,768]    │ kernel: float32[1,1,1,768]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 768 (3.1 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_0/residual_conv/conv/Conv_1 │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,512]    │ kernel: float32[1,1,768,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 393,216 (1.6 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1                           │ ResidualBlock    │ - float32[1,8,8,768]   │ float32[1,8,8,512]    │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/GroupNorm_0               │ GroupNorm        │ float32[1,8,8,768]     │ float32[1,8,8,768]    │ bias: float32[768]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[768]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,536 (6.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv1                     │ ConvLayer        │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv1/conv                │ SeparableConv    │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv1/conv/Conv_0         │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,768]    │ kernel: float32[3,3,1,768]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 6,912 (27.6 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv1/conv/Conv_1         │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,512]    │ kernel: float32[1,1,768,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 393,216 (1.6 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,512]        │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,512]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 131,584 (526.3 KB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/GroupNorm_1               │ GroupNorm        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,024 (4.1 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv2                     │ ConvLayer        │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv2/conv                │ SeparableConv    │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv2/conv/Conv_0         │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[3,3,1,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,608 (18.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/conv2/conv/Conv_1         │ Conv             │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ kernel: float32[1,1,512,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/residual_conv             │ ConvLayer        │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/residual_conv/conv        │ SeparableConv    │ float32[1,8,8,768]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/residual_conv/conv/Conv_0 │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,768]    │ kernel: float32[1,1,1,768]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 768 (3.1 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_residual_1/residual_conv/conv/Conv_1 │ Conv             │ float32[1,8,8,768]     │ float32[1,8,8,512]    │ kernel: float32[1,1,768,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 393,216 (1.6 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1                          │ AttentionBlock   │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1/RMSNorm_0                │ RMSNorm          │ float32[1,8,8,512]     │ float32[1,8,8,512]    │ scale: float32[512]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1/Attention                │ NormalAttention  │ float32[1,8,8,512]     │ float32[1,8,8,512]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1/Attention/to_q           │ DenseGeneral     │ float32[1,8,8,512]     │ float32[1,8,8,4,128]  │ kernel: float32[512,4,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1/Attention/to_k           │ DenseGeneral     │ float32[1,8,8,512]     │ float32[1,8,8,4,128]  │ kernel: float32[512,4,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1/Attention/to_v           │ DenseGeneral     │ float32[1,8,8,512]     │ float32[1,8,8,4,128]  │ kernel: float32[512,4,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_attention_1/Attention/to_out_0       │ DenseGeneral     │ float32[1,8,8,4,128]   │ float32[1,8,8,512]    │ kernel: float32[4,128,512]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 262,144 (1.0 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_upsample                             │ Upsample         │ float32[1,8,8,512]     │ float32[1,16,16,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_upsample/ConvLayer_0                 │ ConvLayer        │ float32[1,16,16,512]   │ float32[1,16,16,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_0_upsample/ConvLayer_0/conv            │ Conv             │ float32[1,16,16,512]   │ float32[1,16,16,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,512,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 294,976 (1.2 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0                           │ ResidualBlock    │ - float32[1,16,16,192] │ float32[1,16,16,256]  │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/GroupNorm_0               │ GroupNorm        │ float32[1,16,16,192]   │ float32[1,16,16,192]  │ bias: float32[192]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[192]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 384 (1.5 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv1                     │ ConvLayer        │ float32[1,16,16,192]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv1/conv                │ SeparableConv    │ float32[1,16,16,192]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv1/conv/Conv_0         │ Conv             │ float32[1,16,16,192]   │ float32[1,16,16,192]  │ kernel: float32[3,3,1,192]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,728 (6.9 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv1/conv/Conv_1         │ Conv             │ float32[1,16,16,192]   │ float32[1,16,16,256]  │ kernel: float32[1,1,192,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 49,152 (196.6 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,256]        │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,256]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,792 (263.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/GroupNorm_1               │ GroupNorm        │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv2                     │ ConvLayer        │ float32[1,16,16,256]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv2/conv                │ SeparableConv    │ float32[1,16,16,256]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv2/conv/Conv_0         │ Conv             │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/conv2/conv/Conv_1         │ Conv             │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ kernel: float32[1,1,256,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/residual_conv             │ ConvLayer        │ float32[1,16,16,192]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/residual_conv/conv        │ SeparableConv    │ float32[1,16,16,192]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/residual_conv/conv/Conv_0 │ Conv             │ float32[1,16,16,192]   │ float32[1,16,16,192]  │ kernel: float32[1,1,1,192]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 192 (768 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_0/residual_conv/conv/Conv_1 │ Conv             │ float32[1,16,16,192]   │ float32[1,16,16,256]  │ kernel: float32[1,1,192,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 49,152 (196.6 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1                           │ ResidualBlock    │ - float32[1,16,16,384] │ float32[1,16,16,256]  │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/GroupNorm_0               │ GroupNorm        │ float32[1,16,16,384]   │ float32[1,16,16,384]  │ bias: float32[384]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[384]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 768 (3.1 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv1                     │ ConvLayer        │ float32[1,16,16,384]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv1/conv                │ SeparableConv    │ float32[1,16,16,384]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv1/conv/Conv_0         │ Conv             │ float32[1,16,16,384]   │ float32[1,16,16,384]  │ kernel: float32[3,3,1,384]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 3,456 (13.8 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv1/conv/Conv_1         │ Conv             │ float32[1,16,16,384]   │ float32[1,16,16,256]  │ kernel: float32[1,1,384,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 98,304 (393.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,256]        │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,256]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,792 (263.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/GroupNorm_1               │ GroupNorm        │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 512 (2.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv2                     │ ConvLayer        │ float32[1,16,16,256]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv2/conv                │ SeparableConv    │ float32[1,16,16,256]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv2/conv/Conv_0         │ Conv             │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ kernel: float32[3,3,1,256]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,304 (9.2 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/conv2/conv/Conv_1         │ Conv             │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ kernel: float32[1,1,256,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/residual_conv             │ ConvLayer        │ float32[1,16,16,384]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/residual_conv/conv        │ SeparableConv    │ float32[1,16,16,384]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/residual_conv/conv/Conv_0 │ Conv             │ float32[1,16,16,384]   │ float32[1,16,16,384]  │ kernel: float32[1,1,1,384]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 384 (1.5 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_residual_1/residual_conv/conv/Conv_1 │ Conv             │ float32[1,16,16,384]   │ float32[1,16,16,256]  │ kernel: float32[1,1,384,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 98,304 (393.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1                          │ AttentionBlock   │ float32[1,16,16,256]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1/RMSNorm_0                │ RMSNorm          │ float32[1,16,16,256]   │ float32[1,16,16,256]  │ scale: float32[256]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1/Attention                │ NormalAttention  │ float32[1,16,16,256]   │ float32[1,16,16,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1/Attention/to_q           │ DenseGeneral     │ float32[1,16,16,256]   │ float32[1,16,16,4,64] │ kernel: float32[256,4,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1/Attention/to_k           │ DenseGeneral     │ float32[1,16,16,256]   │ float32[1,16,16,4,64] │ kernel: float32[256,4,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1/Attention/to_v           │ DenseGeneral     │ float32[1,16,16,256]   │ float32[1,16,16,4,64] │ kernel: float32[256,4,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_attention_1/Attention/to_out_0       │ DenseGeneral     │ float32[1,16,16,4,64]  │ float32[1,16,16,256]  │ kernel: float32[4,64,256]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 65,536 (262.1 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_upsample                             │ Upsample         │ float32[1,16,16,256]   │ float32[1,32,32,512]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_upsample/ConvLayer_0                 │ ConvLayer        │ float32[1,32,32,256]   │ float32[1,32,32,512]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_1_upsample/ConvLayer_0/conv            │ Conv             │ float32[1,32,32,256]   │ float32[1,32,32,512]  │ bias: float32[512]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,256,512] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,180,160 (4.7 MB)           │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0                           │ ResidualBlock    │ - float32[1,32,32,576] │ float32[1,32,32,128]  │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/GroupNorm_0               │ GroupNorm        │ float32[1,32,32,576]   │ float32[1,32,32,576]  │ bias: float32[576]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[576]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv1                     │ ConvLayer        │ float32[1,32,32,576]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv1/conv                │ SeparableConv    │ float32[1,32,32,576]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv1/conv/Conv_0         │ Conv             │ float32[1,32,32,576]   │ float32[1,32,32,576]  │ kernel: float32[3,3,1,576]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 5,184 (20.7 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv1/conv/Conv_1         │ Conv             │ float32[1,32,32,576]   │ float32[1,32,32,128]  │ kernel: float32[1,1,576,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 73,728 (294.9 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,128]        │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,128]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 32,896 (131.6 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/GroupNorm_1               │ GroupNorm        │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv2                     │ ConvLayer        │ float32[1,32,32,128]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv2/conv                │ SeparableConv    │ float32[1,32,32,128]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv2/conv/Conv_0         │ Conv             │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/conv2/conv/Conv_1         │ Conv             │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ kernel: float32[1,1,128,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/residual_conv             │ ConvLayer        │ float32[1,32,32,576]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/residual_conv/conv        │ SeparableConv    │ float32[1,32,32,576]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/residual_conv/conv/Conv_0 │ Conv             │ float32[1,32,32,576]   │ float32[1,32,32,576]  │ kernel: float32[1,1,1,576]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_0/residual_conv/conv/Conv_1 │ Conv             │ float32[1,32,32,576]   │ float32[1,32,32,128]  │ kernel: float32[1,1,576,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 73,728 (294.9 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1                           │ ResidualBlock    │ - float32[1,32,32,192] │ float32[1,32,32,128]  │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/GroupNorm_0               │ GroupNorm        │ float32[1,32,32,192]   │ float32[1,32,32,192]  │ bias: float32[192]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[192]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 384 (1.5 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv1                     │ ConvLayer        │ float32[1,32,32,192]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv1/conv                │ SeparableConv    │ float32[1,32,32,192]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv1/conv/Conv_0         │ Conv             │ float32[1,32,32,192]   │ float32[1,32,32,192]  │ kernel: float32[3,3,1,192]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,728 (6.9 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv1/conv/Conv_1         │ Conv             │ float32[1,32,32,192]   │ float32[1,32,32,128]  │ kernel: float32[1,1,192,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 24,576 (98.3 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,128]        │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,128]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 32,896 (131.6 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/GroupNorm_1               │ GroupNorm        │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv2                     │ ConvLayer        │ float32[1,32,32,128]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv2/conv                │ SeparableConv    │ float32[1,32,32,128]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv2/conv/Conv_0         │ Conv             │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/conv2/conv/Conv_1         │ Conv             │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ kernel: float32[1,1,128,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/residual_conv             │ ConvLayer        │ float32[1,32,32,192]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/residual_conv/conv        │ SeparableConv    │ float32[1,32,32,192]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/residual_conv/conv/Conv_0 │ Conv             │ float32[1,32,32,192]   │ float32[1,32,32,192]  │ kernel: float32[1,1,1,192]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 192 (768 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_residual_1/residual_conv/conv/Conv_1 │ Conv             │ float32[1,32,32,192]   │ float32[1,32,32,128]  │ kernel: float32[1,1,192,128] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 24,576 (98.3 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1                          │ AttentionBlock   │ float32[1,32,32,128]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1/RMSNorm_0                │ RMSNorm          │ float32[1,32,32,128]   │ float32[1,32,32,128]  │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1/Attention                │ NormalAttention  │ float32[1,32,32,128]   │ float32[1,32,32,128]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1/Attention/to_q           │ DenseGeneral     │ float32[1,32,32,128]   │ float32[1,32,32,4,32] │ kernel: float32[128,4,32]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1/Attention/to_k           │ DenseGeneral     │ float32[1,32,32,128]   │ float32[1,32,32,4,32] │ kernel: float32[128,4,32]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1/Attention/to_v           │ DenseGeneral     │ float32[1,32,32,128]   │ float32[1,32,32,4,32] │ kernel: float32[128,4,32]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_attention_1/Attention/to_out_0       │ DenseGeneral     │ float32[1,32,32,4,32]  │ float32[1,32,32,128]  │ kernel: float32[4,32,128]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,384 (65.5 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_upsample                             │ Upsample         │ float32[1,32,32,128]   │ float32[1,64,64,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_upsample/ConvLayer_0                 │ ConvLayer        │ float32[1,64,64,128]   │ float32[1,64,64,256]  │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_2_upsample/ConvLayer_0/conv            │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,256]  │ bias: float32[256]           │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,128,256] │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 295,168 (1.2 MB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0                           │ ResidualBlock    │ - float32[1,64,64,320] │ float32[1,64,64,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/GroupNorm_0               │ GroupNorm        │ float32[1,64,64,320]   │ float32[1,64,64,320]  │ bias: float32[320]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[320]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 640 (2.6 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv1                     │ ConvLayer        │ float32[1,64,64,320]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv1/conv                │ SeparableConv    │ float32[1,64,64,320]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv1/conv/Conv_0         │ Conv             │ float32[1,64,64,320]   │ float32[1,64,64,320]  │ kernel: float32[3,3,1,320]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 2,880 (11.5 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv1/conv/Conv_1         │ Conv             │ float32[1,64,64,320]   │ float32[1,64,64,64]   │ kernel: float32[1,1,320,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 20,480 (81.9 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/GroupNorm_1               │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv2                     │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv2/conv                │ SeparableConv    │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv2/conv/Conv_0         │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/conv2/conv/Conv_1         │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/residual_conv             │ ConvLayer        │ float32[1,64,64,320]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/residual_conv/conv        │ SeparableConv    │ float32[1,64,64,320]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/residual_conv/conv/Conv_0 │ Conv             │ float32[1,64,64,320]   │ float32[1,64,64,320]  │ kernel: float32[1,1,1,320]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 320 (1.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_0/residual_conv/conv/Conv_1 │ Conv             │ float32[1,64,64,320]   │ float32[1,64,64,64]   │ kernel: float32[1,1,320,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 20,480 (81.9 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1                           │ ResidualBlock    │ - float32[1,64,64,128] │ float32[1,64,64,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/GroupNorm_0               │ GroupNorm        │ float32[1,64,64,128]   │ float32[1,64,64,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv1                     │ ConvLayer        │ float32[1,64,64,128]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv1/conv                │ SeparableConv    │ float32[1,64,64,128]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv1/conv/Conv_0         │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,128]  │ kernel: float32[3,3,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,152 (4.6 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv1/conv/Conv_1         │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,64]   │ kernel: float32[1,1,128,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 8,192 (32.8 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/temb_projection           │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/GroupNorm_1               │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv2                     │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv2/conv                │ SeparableConv    │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv2/conv/Conv_0         │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[3,3,1,64]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 576 (2.3 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/conv2/conv/Conv_1         │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ kernel: float32[1,1,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/residual_conv             │ ConvLayer        │ float32[1,64,64,128]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/residual_conv/conv        │ SeparableConv    │ float32[1,64,64,128]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/residual_conv/conv/Conv_0 │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,128]  │ kernel: float32[1,1,1,128]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_residual_1/residual_conv/conv/Conv_1 │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,64]   │ kernel: float32[1,1,128,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 8,192 (32.8 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1                          │ AttentionBlock   │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1/RMSNorm_0                │ RMSNorm          │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 64 (256 B)                   │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1/Attention                │ NormalAttention  │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1/Attention/to_q           │ DenseGeneral     │ float32[1,64,64,64]    │ float32[1,64,64,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1/Attention/to_k           │ DenseGeneral     │ float32[1,64,64,64]    │ float32[1,64,64,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1/Attention/to_v           │ DenseGeneral     │ float32[1,64,64,64]    │ float32[1,64,64,4,16] │ kernel: float32[64,4,16]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ up_3_attention_1/Attention/to_out_0       │ DenseGeneral     │ float32[1,64,64,4,16]  │ float32[1,64,64,64]   │ kernel: float32[4,16,64]     │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 4,096 (16.4 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual                            │ ResidualBlock    │ - float32[1,64,64,128] │ float32[1,64,64,64]   │                              │\n",
+       "│                                           │                  │ - float32[1,256]       │                       │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/GroupNorm_0                │ GroupNorm        │ float32[1,64,64,128]   │ float32[1,64,64,128]  │ bias: float32[128]           │\n",
+       "│                                           │                  │                        │                       │ scale: float32[128]          │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 256 (1.0 KB)                 │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/conv1                      │ ConvLayer        │ float32[1,64,64,128]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/conv1/conv                 │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,128,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 73,792 (295.2 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/temb_projection            │ DenseGeneral     │ float32[1,256]         │ float32[1,64]         │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[256,64]      │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 16,448 (65.8 KB)             │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/GroupNorm_1                │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/conv2                      │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/conv2/conv                 │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,64,64]   │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 36,928 (147.7 KB)            │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/residual_conv              │ ConvLayer        │ float32[1,64,64,128]   │ float32[1,64,64,64]   │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ final_residual/residual_conv/conv         │ Conv             │ float32[1,64,64,128]   │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[1,1,128,64]  │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 8,256 (33.0 KB)              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ GroupNorm_0                               │ GroupNorm        │ float32[1,64,64,64]    │ float32[1,64,64,64]   │ bias: float32[64]            │\n",
+       "│                                           │                  │                        │                       │ scale: float32[64]           │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 128 (512 B)                  │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ ConvLayer_1                               │ ConvLayer        │ float32[1,64,64,64]    │ float32[1,64,64,3]    │                              │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│ ConvLayer_1/conv                          │ Conv             │ float32[1,64,64,64]    │ float32[1,64,64,3]    │ bias: float32[3]             │\n",
+       "│                                           │                  │                        │                       │ kernel: float32[3,3,64,3]    │\n",
+       "│                                           │                  │                        │                       │                              │\n",
+       "│                                           │                  │                        │                       │ 1,731 (6.9 KB)               │\n",
+       "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n",
+       "│                                           │                  │                        │                 Total │ 10,601,347 (42.4 MB)         │\n",
+       "└───────────────────────────────────────────┴──────────────────┴────────────────────────┴───────────────────────┴──────────────────────────────┘\n",
+       "                                                                                                                                                \n",
+       "                                                     Total Parameters: 10,601,347 (42.4 MB)                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m Unet Summary \u001b[0m\n", + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mpath \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mmodule \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1minputs \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1moutputs \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mparams \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ │ Unet │ - \u001b[2mfloat32\u001b[0m[1,64,64,3] │ \u001b[2mfloat32\u001b[0m[1,64,64,3] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ FourierEmbedding_0 │ FourierEmbedding │ \u001b[2mfloat32\u001b[0m[1] │ \u001b[2mfloat32\u001b[0m[1,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ TimeProjection_0 │ TimeProjection │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ TimeProjection_0/DenseGeneral_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,792 \u001b[0m\u001b[1;2m(263.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ TimeProjection_0/DenseGeneral_1 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,792 \u001b[0m\u001b[1;2m(263.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,3] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,3] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,3,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,792 \u001b[0m\u001b[1;2m(7.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m64 \u001b[0m\u001b[1;2m(256 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[4,16,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_downsample │ Downsample │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_downsample/ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_0_downsample/ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m36,928 \u001b[0m\u001b[1;2m(147.7 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m64 \u001b[0m\u001b[1;2m(256 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,32,32,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,4,16] │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ kernel: \u001b[2mfloat32\u001b[0m[4,16,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_downsample │ Downsample │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_downsample/ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_1_downsample/ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,64] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,64,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m73,856 \u001b[0m\u001b[1;2m(295.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m32,896 \u001b[0m\u001b[1;2m(131.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m32,896 \u001b[0m\u001b[1;2m(131.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,4,32] │ kernel: \u001b[2mfloat32\u001b[0m[128,4,32] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,4,32] │ kernel: \u001b[2mfloat32\u001b[0m[128,4,32] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,16,16,4,32] │ kernel: \u001b[2mfloat32\u001b[0m[128,4,32] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,4,32] │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ kernel: \u001b[2mfloat32\u001b[0m[4,32,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_downsample │ Downsample │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_downsample/ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_2_downsample/ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,128] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,128,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m295,168 \u001b[0m\u001b[1;2m(1.2 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,792 \u001b[0m\u001b[1;2m(263.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,792 \u001b[0m\u001b[1;2m(263.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,64] │ kernel: \u001b[2mfloat32\u001b[0m[256,4,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,64] │ kernel: \u001b[2mfloat32\u001b[0m[256,4,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,64] │ kernel: \u001b[2mfloat32\u001b[0m[256,4,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ down_3_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,4,64] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[4,64,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m131,072 \u001b[0m\u001b[1;2m(524.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m131,584 \u001b[0m\u001b[1;2m(526.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,024 \u001b[0m\u001b[1;2m(4.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,608 \u001b[0m\u001b[1;2m(18.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,512,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res1_0/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,256] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m131,072 \u001b[0m\u001b[1;2m(524.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ kernel: \u001b[2mfloat32\u001b[0m[512,4,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ kernel: \u001b[2mfloat32\u001b[0m[512,4,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ kernel: \u001b[2mfloat32\u001b[0m[512,4,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_attention_0/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[4,128,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,024 \u001b[0m\u001b[1;2m(4.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,608 \u001b[0m\u001b[1;2m(18.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,512,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m131,584 \u001b[0m\u001b[1;2m(526.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,024 \u001b[0m\u001b[1;2m(4.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,608 \u001b[0m\u001b[1;2m(18.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ middle_res2_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,512,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ bias: \u001b[2mfloat32\u001b[0m[768] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[768] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,536 \u001b[0m\u001b[1;2m(6.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,768] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m6,912 \u001b[0m\u001b[1;2m(27.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,768,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m393,216 \u001b[0m\u001b[1;2m(1.6 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m131,584 \u001b[0m\u001b[1;2m(526.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,024 \u001b[0m\u001b[1;2m(4.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,608 \u001b[0m\u001b[1;2m(18.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,512,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,768] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m768 \u001b[0m\u001b[1;2m(3.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_0/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,768,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m393,216 \u001b[0m\u001b[1;2m(1.6 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ bias: \u001b[2mfloat32\u001b[0m[768] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[768] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,536 \u001b[0m\u001b[1;2m(6.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,768] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m6,912 \u001b[0m\u001b[1;2m(27.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,768,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m393,216 \u001b[0m\u001b[1;2m(1.6 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m131,584 \u001b[0m\u001b[1;2m(526.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,024 \u001b[0m\u001b[1;2m(4.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,608 \u001b[0m\u001b[1;2m(18.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,512,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,768] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m768 \u001b[0m\u001b[1;2m(3.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_residual_1/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,8,8,768] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,768,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m393,216 \u001b[0m\u001b[1;2m(1.6 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ scale: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ kernel: \u001b[2mfloat32\u001b[0m[512,4,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ kernel: \u001b[2mfloat32\u001b[0m[512,4,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ kernel: \u001b[2mfloat32\u001b[0m[512,4,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,8,8,4,128] │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ kernel: \u001b[2mfloat32\u001b[0m[4,128,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m262,144 \u001b[0m\u001b[1;2m(1.0 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_upsample │ Upsample │ \u001b[2mfloat32\u001b[0m[1,8,8,512] │ \u001b[2mfloat32\u001b[0m[1,16,16,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_upsample/ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,512] │ \u001b[2mfloat32\u001b[0m[1,16,16,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_0_upsample/ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,512] │ \u001b[2mfloat32\u001b[0m[1,16,16,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,512,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m294,976 \u001b[0m\u001b[1;2m(1.2 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ bias: \u001b[2mfloat32\u001b[0m[192] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[192] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m384 \u001b[0m\u001b[1;2m(1.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,192] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,728 \u001b[0m\u001b[1;2m(6.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,192,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m49,152 \u001b[0m\u001b[1;2m(196.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,792 \u001b[0m\u001b[1;2m(263.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,192] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m192 \u001b[0m\u001b[1;2m(768 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_0/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,192] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,192,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m49,152 \u001b[0m\u001b[1;2m(196.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ bias: \u001b[2mfloat32\u001b[0m[384] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[384] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m768 \u001b[0m\u001b[1;2m(3.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,384] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m3,456 \u001b[0m\u001b[1;2m(13.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,384,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m98,304 \u001b[0m\u001b[1;2m(393.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,792 \u001b[0m\u001b[1;2m(263.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m512 \u001b[0m\u001b[1;2m(2.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,304 \u001b[0m\u001b[1;2m(9.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,256,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,384] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m384 \u001b[0m\u001b[1;2m(1.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_residual_1/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,16,16,384] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,384,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m98,304 \u001b[0m\u001b[1;2m(393.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ scale: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,4,64] │ kernel: \u001b[2mfloat32\u001b[0m[256,4,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,4,64] │ kernel: \u001b[2mfloat32\u001b[0m[256,4,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,16,16,4,64] │ kernel: \u001b[2mfloat32\u001b[0m[256,4,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,16,16,4,64] │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ kernel: \u001b[2mfloat32\u001b[0m[4,64,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m65,536 \u001b[0m\u001b[1;2m(262.1 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_upsample │ Upsample │ \u001b[2mfloat32\u001b[0m[1,16,16,256] │ \u001b[2mfloat32\u001b[0m[1,32,32,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_upsample/ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,256] │ \u001b[2mfloat32\u001b[0m[1,32,32,512] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_1_upsample/ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,256] │ \u001b[2mfloat32\u001b[0m[1,32,32,512] │ bias: \u001b[2mfloat32\u001b[0m[512] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,256,512] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,180,160 \u001b[0m\u001b[1;2m(4.7 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ bias: \u001b[2mfloat32\u001b[0m[576] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[576] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,576] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m5,184 \u001b[0m\u001b[1;2m(20.7 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,576,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m73,728 \u001b[0m\u001b[1;2m(294.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m32,896 \u001b[0m\u001b[1;2m(131.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,576] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_0/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,576] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,576,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m73,728 \u001b[0m\u001b[1;2m(294.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ bias: \u001b[2mfloat32\u001b[0m[192] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[192] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m384 \u001b[0m\u001b[1;2m(1.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,192] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,728 \u001b[0m\u001b[1;2m(6.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,192,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m24,576 \u001b[0m\u001b[1;2m(98.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m32,896 \u001b[0m\u001b[1;2m(131.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,192] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m192 \u001b[0m\u001b[1;2m(768 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_residual_1/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,32,32,192] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,192,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m24,576 \u001b[0m\u001b[1;2m(98.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,4,32] │ kernel: \u001b[2mfloat32\u001b[0m[128,4,32] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,4,32] │ kernel: \u001b[2mfloat32\u001b[0m[128,4,32] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,32,32,4,32] │ kernel: \u001b[2mfloat32\u001b[0m[128,4,32] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,32,32,4,32] │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ kernel: \u001b[2mfloat32\u001b[0m[4,32,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,384 \u001b[0m\u001b[1;2m(65.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_upsample │ Upsample │ \u001b[2mfloat32\u001b[0m[1,32,32,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_upsample/ConvLayer_0 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,256] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_2_upsample/ConvLayer_0/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,256] │ bias: \u001b[2mfloat32\u001b[0m[256] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,128,256] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m295,168 \u001b[0m\u001b[1;2m(1.2 MB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ bias: \u001b[2mfloat32\u001b[0m[320] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[320] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m640 \u001b[0m\u001b[1;2m(2.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,320] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m2,880 \u001b[0m\u001b[1;2m(11.5 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,320,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m20,480 \u001b[0m\u001b[1;2m(81.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,320] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m320 \u001b[0m\u001b[1;2m(1.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_0/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,320] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,320,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m20,480 \u001b[0m\u001b[1;2m(81.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1 │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv1/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv1/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,152 \u001b[0m\u001b[1;2m(4.6 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv1/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m8,192 \u001b[0m\u001b[1;2m(32.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv2/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv2/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[3,3,1,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m576 \u001b[0m\u001b[1;2m(2.3 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/conv2/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/residual_conv/conv │ SeparableConv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/residual_conv/conv/Conv_0 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,1,128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_residual_1/residual_conv/conv/Conv_1 │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m8,192 \u001b[0m\u001b[1;2m(32.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1 │ AttentionBlock │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1/RMSNorm_0 │ RMSNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m64 \u001b[0m\u001b[1;2m(256 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1/Attention │ NormalAttention │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1/Attention/to_q │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1/Attention/to_k │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1/Attention/to_v │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ kernel: \u001b[2mfloat32\u001b[0m[64,4,16] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ up_3_attention_1/Attention/to_out_0 │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,64,64,4,16] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ kernel: \u001b[2mfloat32\u001b[0m[4,16,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m4,096 \u001b[0m\u001b[1;2m(16.4 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual │ ResidualBlock │ - \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "│ │ │ - \u001b[2mfloat32\u001b[0m[1,256] │ │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ bias: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[128] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m256 \u001b[0m\u001b[1;2m(1.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/conv1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/conv1/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,128,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m73,792 \u001b[0m\u001b[1;2m(295.2 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/temb_projection │ DenseGeneral │ \u001b[2mfloat32\u001b[0m[1,256] │ \u001b[2mfloat32\u001b[0m[1,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[256,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m16,448 \u001b[0m\u001b[1;2m(65.8 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/GroupNorm_1 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/conv2 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/conv2/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,64,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m36,928 \u001b[0m\u001b[1;2m(147.7 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/residual_conv │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ final_residual/residual_conv/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,128] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[1,1,128,64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m8,256 \u001b[0m\u001b[1;2m(33.0 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ GroupNorm_0 │ GroupNorm │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ bias: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ scale: \u001b[2mfloat32\u001b[0m[64] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m128 \u001b[0m\u001b[1;2m(512 B)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ ConvLayer_1 │ ConvLayer │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,3] │ │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│ ConvLayer_1/conv │ Conv │ \u001b[2mfloat32\u001b[0m[1,64,64,64] │ \u001b[2mfloat32\u001b[0m[1,64,64,3] │ bias: \u001b[2mfloat32\u001b[0m[3] │\n", + "│ │ │ │ │ kernel: \u001b[2mfloat32\u001b[0m[3,3,64,3] │\n", + "│ │ │ │ │ │\n", + "│ │ │ │ │ \u001b[1m1,731 \u001b[0m\u001b[1;2m(6.9 KB)\u001b[0m │\n", + "├───────────────────────────────────────────┼──────────────────┼────────────────────────┼───────────────────────┼──────────────────────────────┤\n", + "│\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m Total\u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m10,601,347 \u001b[0m\u001b[1;2m(42.4 MB)\u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m│\n", + "└───────────────────────────────────────────┴──────────────────┴────────────────────────┴───────────────────────┴──────────────────────────────┘\n", + "\u001b[1m \u001b[0m\n", + "\u001b[1m Total Parameters: 10,601,347 \u001b[0m\u001b[1;2m(42.4 MB)\u001b[0m\u001b[1m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "model = Unet(emb_features=256,\n", + " feature_depths=[64, 128, 256, 512],\n", + " attention_configs=[{\"heads\":4}, {\"heads\":4}, {\"heads\":4}, {\"heads\":4}],\n", + " num_res_blocks=2,\n", + " num_middle_res_blocks=1)\n", + "inp = jnp.ones((1, 64, 64, 3))\n", + "temb = jnp.ones((1,))\n", + "print(model.tabulate(jax.random.key(0), inp, temb, console_kwargs={\"width\": 200, \"force_jupyter\":True, }))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training utils" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/flaxdiff/models/simple_unet.py b/flaxdiff/models/simple_unet.py index db4fa08..34f4307 100644 --- a/flaxdiff/models/simple_unet.py +++ b/flaxdiff/models/simple_unet.py @@ -135,7 +135,6 @@ def __call__(self, x): )(depthwise) return pointwise - class ConvLayer(nn.Module): conv_type:str features:int diff --git a/flaxdiff/schedulers/common.py b/flaxdiff/schedulers/common.py index 770b6be..446d740 100644 --- a/flaxdiff/schedulers/common.py +++ b/flaxdiff/schedulers/common.py @@ -13,9 +13,16 @@ def __init__(self, timesteps, self.dtype = dtype self.clip_min = clip_min self.clip_max = clip_max + if type(timesteps) == int and timesteps > 1: + timestep_generator = lambda rng, batch_size, max_timesteps = timesteps: jax.random.randint(rng, (batch_size,), 0, max_timesteps) + else: + timestep_generator = lambda rng, batch_size, max_timesteps = timesteps: jax.random.uniform(rng, (batch_size,), minval=0, maxval=max_timesteps) + self.timestep_generator = timestep_generator def generate_timesteps(self, batch_size, state:RandomMarkovState) -> tuple[jnp.ndarray, RandomMarkovState]: - raise NotImplementedError + state, rng = state.get_random_key() + timesteps = self.timestep_generator(rng, batch_size, self.max_timesteps) + return timesteps, state def get_weights(self, steps): raise NotImplementedError @@ -65,16 +72,6 @@ def __init__(self, timesteps, sigma_min=0.002, sigma_max=80.0, sigma_data=1, *ar self.sigma_min = sigma_min self.sigma_max = sigma_max self.sigma_data = sigma_data - if type(timesteps) == int and timesteps > 1: - timestep_generator = lambda rng, batch_size, max_timesteps = timesteps: jax.random.randint(rng, (batch_size,), 0, max_timesteps) - else: - timestep_generator = lambda rng, batch_size, max_timesteps = timesteps: jax.random.uniform(rng, (batch_size,), minval=0, maxval=max_timesteps) - self.timestep_generator = timestep_generator - - def generate_timesteps(self, batch_size, state:RandomMarkovState) -> tuple[jnp.ndarray, RandomMarkovState]: - state, rng = state.get_random_key() - timesteps = self.timestep_generator(rng, batch_size, self.max_timesteps) - return timesteps, state def get_weights(self, steps, shape=(-1, 1, 1, 1)): sigma = self.get_sigmas(steps)