Use devices.autocast instead of torch.autocast

                if shared.state.interrupted:

                    break

                with torch.autocast("cuda"):

                with devices.autocast():

                    x = batch.latent_sample.to(devices.device, non_blocking=pin_memory)

                    if tag_drop_out != 0 or shuffle_tags:

                        shared.sd_model.cond_stage_model.to(devices.device)

            clip_image = self.clip_preprocess(pil_image).unsqueeze(0).type(self.dtype).to(devices.device_interrogate)

            precision_scope = torch.autocast if shared.cmd_opts.precision == "autocast" else contextlib.nullcontext

            with torch.no_grad(), precision_scope("cuda"):

            with torch.no_grad(), devices.autocast():

                image_features = self.clip_model.encode_image(clip_image).type(self.dtype)

                image_features /= image_features.norm(dim=-1, keepdim=True)

from modules.swinir_model_arch_v2 import Swin2SR as net2

from modules.upscaler import Upscaler, UpscalerData

precision_scope = (

    torch.autocast if cmd_opts.precision == "autocast" else contextlib.nullcontext

)

class UpscalerSwinIR(Upscaler):

    def __init__(self, dirname):

    img = np.moveaxis(img, 2, 0) / 255

    img = torch.from_numpy(img).float()

    img = img.unsqueeze(0).to(devices.device_swinir)

    with torch.no_grad(), precision_scope("cuda"):

    with torch.no_grad(), devices.autocast():

        _, _, h_old, w_old = img.size()

        h_pad = (h_old // window_size + 1) * window_size - h_old

        w_pad = (w_old // window_size + 1) * window_size - w_old

            torchdata = torch.from_numpy(npimage).permute(2, 0, 1).to(device=device, dtype=torch.float32)

            latent_sample = None

            with torch.autocast("cuda"):

            with devices.autocast():

                latent_dist = model.encode_first_stage(torchdata.unsqueeze(dim=0))

            if latent_sampling_method == "once" or (latent_sampling_method == "deterministic" and not isinstance(latent_dist, DiagonalGaussianDistribution)):

                entry.cond_text = self.create_text(filename_text)

            if include_cond and not (self.tag_drop_out != 0 or self.shuffle_tags):

                with torch.autocast("cuda"):

                with devices.autocast():

                    entry.cond = cond_model([entry.cond_text]).to(devices.cpu).squeeze(0)

            self.dataset.append(entry)

                if shared.state.interrupted:

                    break

                with torch.autocast("cuda"):

                with devices.autocast():

                    # c = stack_conds(batch.cond).to(devices.device)

                    # mask = torch.tensor(batch.emb_index).to(devices.device, non_blocking=pin_memory)

                    # print(mask)