Merge branch 'master' of https://github.com/bamarillo/stable-diffusion-webui (e3f0e34c) · Commits · github_fork / Stable Diffusion Webui

localizations/ru_RU.json

0 → 100644

+475 −0

File added.

Preview size limit exceeded, changes collapsed.

modules/api/api.py

+62 −5

Original line number	Diff line number	Diff line
		from modules.api.processing import StableDiffusionProcessingAPI
		from modules.processing import StableDiffusionProcessingTxt2Img, process_images
		from modules.api.processing import StableDiffusionTxt2ImgProcessingAPI, StableDiffusionImg2ImgProcessingAPI
		from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img, process_images
		from modules.sd_samplers import all_samplers
		import modules.shared as shared
		import uvicorn
		@@ -37,6 +37,11 @@ def base64_to_images(base64Imgs: list[str]):
		imgs.append(img)
		return imgs

		class ImageToImageResponse(BaseModel):
		images: list[str] = Field(default=None, title="Image", description="The generated image in base64 format.")
		parameters: Json
		info: Json


		class Api:
		def __init__(self, app, queue_lock):
		@@ -44,10 +49,19 @@ class Api:
		self.app = app
		self.queue_lock = queue_lock
		self.app.add_api_route("/sdapi/v1/txt2img", self.text2imgapi, methods=["POST"], response_model=TextToImageResponse)
		self.app.add_api_route("/sdapi/v1/img2img", self.img2imgapi, methods=["POST"])
		self.app.add_api_route("/sdapi/v1/extra-single-image", self.extras_single_image_api, methods=["POST"], response_model=ExtrasSingleImageResponse)
		self.app.add_api_route("/sdapi/v1/extra-batch-image", self.extras_batch_images_api, methods=["POST"], response_model=ExtrasBatchImagesResponse)

		def text2imgapi(self, txt2imgreq: StableDiffusionProcessingAPI ):
		def __base64_to_image(self, base64_string):
		# if has a comma, deal with prefix
		if "," in base64_string:
		base64_string = base64_string.split(",")[1]
		imgdata = base64.b64decode(base64_string)
		# convert base64 to PIL image
		return Image.open(io.BytesIO(imgdata))

		def text2imgapi(self, txt2imgreq: StableDiffusionTxt2ImgProcessingAPI):
		sampler_index = sampler_to_index(txt2imgreq.sampler_index)

		if sampler_index is None:
		@@ -69,8 +83,51 @@ class Api:

		return TextToImageResponse(images=b64images, parameters=json.dumps(vars(txt2imgreq)), info=json.dumps(processed.info))

		def img2imgapi(self):
		raise NotImplementedError


		def img2imgapi(self, img2imgreq: StableDiffusionImg2ImgProcessingAPI):
		sampler_index = sampler_to_index(img2imgreq.sampler_index)

		if sampler_index is None:
		raise HTTPException(status_code=404, detail="Sampler not found")


		init_images = img2imgreq.init_images
		if init_images is None:
		raise HTTPException(status_code=404, detail="Init image not found")

		mask = img2imgreq.mask
		if mask:
		mask = self.__base64_to_image(mask)


		populate = img2imgreq.copy(update={ # Override __init__ params
		"sd_model": shared.sd_model,
		"sampler_index": sampler_index[0],
		"do_not_save_samples": True,
		"do_not_save_grid": True,
		"mask": mask
		}
		)
		p = StableDiffusionProcessingImg2Img(**vars(populate))

		imgs = []
		for img in init_images:
		img = self.__base64_to_image(img)
		imgs = [img] * p.batch_size

		p.init_images = imgs
		# Override object param
		with self.queue_lock:
		processed = process_images(p)

		b64images = []
		for i in processed.images:
		buffer = io.BytesIO()
		i.save(buffer, format="png")
		b64images.append(base64.b64encode(buffer.getvalue()))

		return ImageToImageResponse(images=b64images, parameters=json.dumps(vars(img2imgreq)), info=json.dumps(processed.info))

		def extras_single_image_api(self, req: ExtrasSingleImageRequest):
		upscaler1Index = upscaler_to_index(req.upscaler_1)

modules/api/processing.py

+9 −2

Original line number	Diff line number	Diff line
		from array import array
		from inflection import underscore
		from typing import Any, Dict, Optional
		from pydantic import BaseModel, Field, create_model
		from modules.processing import StableDiffusionProcessingTxt2Img
		from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img
		import inspect


		@@ -92,8 +93,14 @@ class PydanticModelGenerator:
		DynamicModel.__config__.allow_mutation = True
		return DynamicModel

		StableDiffusionProcessingAPI = PydanticModelGenerator(
		StableDiffusionTxt2ImgProcessingAPI = PydanticModelGenerator(
		"StableDiffusionProcessingTxt2Img",
		StableDiffusionProcessingTxt2Img,
		[{"key": "sampler_index", "type": str, "default": "Euler"}]
		).generate_model()

		StableDiffusionImg2ImgProcessingAPI = PydanticModelGenerator(
		"StableDiffusionProcessingImg2Img",
		StableDiffusionProcessingImg2Img,
		[{"key": "sampler_index", "type": str, "default": "Euler"}, {"key": "init_images", "type": list, "default": None}, {"key": "denoising_strength", "type": float, "default": 0.75}, {"key": "mask", "type": str, "default": None}]
		).generate_model()
		No newline at end of file

modules/bsrgan_model.py

deleted100644 → 0

+0 −76

Original line number	Diff line number	Diff line
		import os.path
		import sys
		import traceback

		import PIL.Image
		import numpy as np
		import torch
		from basicsr.utils.download_util import load_file_from_url

		import modules.upscaler
		from modules import devices, modelloader
		from modules.bsrgan_model_arch import RRDBNet


		class UpscalerBSRGAN(modules.upscaler.Upscaler):
		def __init__(self, dirname):
		self.name = "BSRGAN"
		self.model_name = "BSRGAN 4x"
		self.model_url = "https://github.com/cszn/KAIR/releases/download/v1.0/BSRGAN.pth"
		self.user_path = dirname
		super().__init__()
		model_paths = self.find_models(ext_filter=[".pt", ".pth"])
		scalers = []
		if len(model_paths) == 0:
		scaler_data = modules.upscaler.UpscalerData(self.model_name, self.model_url, self, 4)
		scalers.append(scaler_data)
		for file in model_paths:
		if "http" in file:
		name = self.model_name
		else:
		name = modelloader.friendly_name(file)
		try:
		scaler_data = modules.upscaler.UpscalerData(name, file, self, 4)
		scalers.append(scaler_data)
		except Exception:
		print(f"Error loading BSRGAN model: {file}", file=sys.stderr)
		print(traceback.format_exc(), file=sys.stderr)
		self.scalers = scalers

		def do_upscale(self, img: PIL.Image, selected_file):
		torch.cuda.empty_cache()
		model = self.load_model(selected_file)
		if model is None:
		return img
		model.to(devices.device_bsrgan)
		torch.cuda.empty_cache()
		img = np.array(img)
		img = img[:, :, ::-1]
		img = np.moveaxis(img, 2, 0) / 255
		img = torch.from_numpy(img).float()
		img = img.unsqueeze(0).to(devices.device_bsrgan)
		with torch.no_grad():
		output = model(img)
		output = output.squeeze().float().cpu().clamp_(0, 1).numpy()
		output = 255. * np.moveaxis(output, 0, 2)
		output = output.astype(np.uint8)
		output = output[:, :, ::-1]
		torch.cuda.empty_cache()
		return PIL.Image.fromarray(output, 'RGB')

		def load_model(self, path: str):
		if "http" in path:
		filename = load_file_from_url(url=self.model_url, model_dir=self.model_path, file_name="%s.pth" % self.name,
		progress=True)
		else:
		filename = path
		if not os.path.exists(filename) or filename is None:
		print(f"BSRGAN: Unable to load model from {filename}", file=sys.stderr)
		return None
		model = RRDBNet(in_nc=3, out_nc=3, nf=64, nb=23, gc=32, sf=4) # define network
		model.load_state_dict(torch.load(filename), strict=True)
		model.eval()
		for k, v in model.named_parameters():
		v.requires_grad = False
		return model

modules/bsrgan_model_arch.py

deleted100644 → 0

+0 −102

Original line number	Diff line number	Diff line
		import functools
		import torch
		import torch.nn as nn
		import torch.nn.functional as F
		import torch.nn.init as init


		def initialize_weights(net_l, scale=1):
		if not isinstance(net_l, list):
		net_l = [net_l]
		for net in net_l:
		for m in net.modules():
		if isinstance(m, nn.Conv2d):
		init.kaiming_normal_(m.weight, a=0, mode='fan_in')
		m.weight.data *= scale # for residual block
		if m.bias is not None:
		m.bias.data.zero_()
		elif isinstance(m, nn.Linear):
		init.kaiming_normal_(m.weight, a=0, mode='fan_in')
		m.weight.data *= scale
		if m.bias is not None:
		m.bias.data.zero_()
		elif isinstance(m, nn.BatchNorm2d):
		init.constant_(m.weight, 1)
		init.constant_(m.bias.data, 0.0)


		def make_layer(block, n_layers):
		layers = []
		for _ in range(n_layers):
		layers.append(block())
		return nn.Sequential(*layers)


		class ResidualDenseBlock_5C(nn.Module):
		def __init__(self, nf=64, gc=32, bias=True):
		super(ResidualDenseBlock_5C, self).__init__()
		# gc: growth channel, i.e. intermediate channels
		self.conv1 = nn.Conv2d(nf, gc, 3, 1, 1, bias=bias)
		self.conv2 = nn.Conv2d(nf + gc, gc, 3, 1, 1, bias=bias)
		self.conv3 = nn.Conv2d(nf + 2 * gc, gc, 3, 1, 1, bias=bias)
		self.conv4 = nn.Conv2d(nf + 3 * gc, gc, 3, 1, 1, bias=bias)
		self.conv5 = nn.Conv2d(nf + 4 * gc, nf, 3, 1, 1, bias=bias)
		self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)

		# initialization
		initialize_weights([self.conv1, self.conv2, self.conv3, self.conv4, self.conv5], 0.1)

		def forward(self, x):
		x1 = self.lrelu(self.conv1(x))
		x2 = self.lrelu(self.conv2(torch.cat((x, x1), 1)))
		x3 = self.lrelu(self.conv3(torch.cat((x, x1, x2), 1)))
		x4 = self.lrelu(self.conv4(torch.cat((x, x1, x2, x3), 1)))
		x5 = self.conv5(torch.cat((x, x1, x2, x3, x4), 1))
		return x5 * 0.2 + x


		class RRDB(nn.Module):
		'''Residual in Residual Dense Block'''

		def __init__(self, nf, gc=32):
		super(RRDB, self).__init__()
		self.RDB1 = ResidualDenseBlock_5C(nf, gc)
		self.RDB2 = ResidualDenseBlock_5C(nf, gc)
		self.RDB3 = ResidualDenseBlock_5C(nf, gc)

		def forward(self, x):
		out = self.RDB1(x)
		out = self.RDB2(out)
		out = self.RDB3(out)
		return out * 0.2 + x


		class RRDBNet(nn.Module):
		def __init__(self, in_nc=3, out_nc=3, nf=64, nb=23, gc=32, sf=4):
		super(RRDBNet, self).__init__()
		RRDB_block_f = functools.partial(RRDB, nf=nf, gc=gc)
		self.sf = sf

		self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
		self.RRDB_trunk = make_layer(RRDB_block_f, nb)
		self.trunk_conv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
		#### upsampling
		self.upconv1 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
		if self.sf==4:
		self.upconv2 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
		self.HRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
		self.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)

		self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)

		def forward(self, x):
		fea = self.conv_first(x)
		trunk = self.trunk_conv(self.RRDB_trunk(fea))
		fea = fea + trunk

		fea = self.lrelu(self.upconv1(F.interpolate(fea, scale_factor=2, mode='nearest')))
		if self.sf==4:
		fea = self.lrelu(self.upconv2(F.interpolate(fea, scale_factor=2, mode='nearest')))
		out = self.conv_last(self.lrelu(self.HRconv(fea)))

		return out
		No newline at end of file

Admin message