samplers.py 27.9 KB
Newer Older
1
from .k_diffusion import sampling as k_diffusion_sampling
2
from .extra_samplers import uni_pc
comfyanonymous's avatar
comfyanonymous committed
3
import torch
4
import enum
5
from comfy import model_management
comfyanonymous's avatar
comfyanonymous committed
6
import math
7
from comfy import model_base
8
import comfy.utils
9
import comfy.conds
10
11


comfyanonymous's avatar
comfyanonymous committed
12
#The main sampling function shared by all the samplers
comfyanonymous's avatar
comfyanonymous committed
13
#Returns denoised
14
def sampling_function(model, x, timestep, uncond, cond, cond_scale, model_options={}, seed=None):
15
        def get_area_and_mult(conds, x_in, timestep_in):
16
17
            area = (x_in.shape[2], x_in.shape[3], 0, 0)
            strength = 1.0
18
19
20

            if 'timestep_start' in conds:
                timestep_start = conds['timestep_start']
21
                if timestep_in[0] > timestep_start:
22
                    return None
23
24
            if 'timestep_end' in conds:
                timestep_end = conds['timestep_end']
25
                if timestep_in[0] < timestep_end:
26
                    return None
27
28
29
30
            if 'area' in conds:
                area = conds['area']
            if 'strength' in conds:
                strength = conds['strength']
31

32
            input_x = x_in[:,:,area[2]:area[0] + area[2],area[3]:area[1] + area[3]]
33
            if 'mask' in conds:
Jacob Segal's avatar
Jacob Segal committed
34
35
                # Scale the mask to the size of the input
                # The mask should have been resized as we began the sampling process
36
                mask_strength = 1.0
37
38
39
                if "mask_strength" in conds:
                    mask_strength = conds["mask_strength"]
                mask = conds['mask']
Jacob Segal's avatar
Jacob Segal committed
40
41
                assert(mask.shape[1] == x_in.shape[2])
                assert(mask.shape[2] == x_in.shape[3])
42
                mask = mask[:,area[2]:area[0] + area[2],area[3]:area[1] + area[3]] * mask_strength
Jacob Segal's avatar
Jacob Segal committed
43
                mask = mask.unsqueeze(1).repeat(input_x.shape[0] // mask.shape[0], input_x.shape[1], 1, 1)
Jacob Segal's avatar
Jacob Segal committed
44
45
46
47
            else:
                mask = torch.ones_like(input_x)
            mult = mask * strength

48
            if 'mask' not in conds:
Jacob Segal's avatar
Jacob Segal committed
49
50
51
52
53
54
55
56
57
58
59
60
61
62
                rr = 8
                if area[2] != 0:
                    for t in range(rr):
                        mult[:,:,t:1+t,:] *= ((1.0/rr) * (t + 1))
                if (area[0] + area[2]) < x_in.shape[2]:
                    for t in range(rr):
                        mult[:,:,area[0] - 1 - t:area[0] - t,:] *= ((1.0/rr) * (t + 1))
                if area[3] != 0:
                    for t in range(rr):
                        mult[:,:,:,t:1+t] *= ((1.0/rr) * (t + 1))
                if (area[1] + area[3]) < x_in.shape[3]:
                    for t in range(rr):
                        mult[:,:,:,area[1] - 1 - t:area[1] - t] *= ((1.0/rr) * (t + 1))

comfyanonymous's avatar
comfyanonymous committed
63
            conditionning = {}
64
65
66
            model_conds = conds["model_conds"]
            for c in model_conds:
                conditionning[c] = model_conds[c].process_cond(batch_size=x_in.shape[0], device=x_in.device, area=area)
67

comfyanonymous's avatar
comfyanonymous committed
68
            control = None
69
70
            if 'control' in conds:
                control = conds['control']
71
72

            patches = None
73
74
            if 'gligen' in conds:
                gligen = conds['gligen']
75
76
77
78
                patches = {}
                gligen_type = gligen[0]
                gligen_model = gligen[1]
                if gligen_type == "position":
comfyanonymous's avatar
comfyanonymous committed
79
                    gligen_patch = gligen_model.model.set_position(input_x.shape, gligen[2], input_x.device)
80
                else:
comfyanonymous's avatar
comfyanonymous committed
81
                    gligen_patch = gligen_model.model.set_empty(input_x.shape, input_x.device)
82
83
84
85

                patches['middle_patch'] = [gligen_patch]

            return (input_x, mult, conditionning, area, control, patches)
comfyanonymous's avatar
comfyanonymous committed
86
87

        def cond_equal_size(c1, c2):
comfyanonymous's avatar
comfyanonymous committed
88
89
            if c1 is c2:
                return True
comfyanonymous's avatar
comfyanonymous committed
90
91
            if c1.keys() != c2.keys():
                return False
92
93
            for k in c1:
                if not c1[k].can_concat(c2[k]):
94
                    return False
comfyanonymous's avatar
comfyanonymous committed
95
96
            return True

comfyanonymous's avatar
comfyanonymous committed
97
98
99
        def can_concat_cond(c1, c2):
            if c1[0].shape != c2[0].shape:
                return False
100
101

            #control
comfyanonymous's avatar
comfyanonymous committed
102
103
104
105
106
107
            if (c1[4] is None) != (c2[4] is None):
                return False
            if c1[4] is not None:
                if c1[4] is not c2[4]:
                    return False

108
109
110
111
112
113
114
            #patches
            if (c1[5] is None) != (c2[5] is None):
                return False
            if (c1[5] is not None):
                if c1[5] is not c2[5]:
                    return False

comfyanonymous's avatar
comfyanonymous committed
115
116
            return cond_equal_size(c1[2], c2[2])

comfyanonymous's avatar
comfyanonymous committed
117
118
119
        def cond_cat(c_list):
            c_crossattn = []
            c_concat = []
120
            c_adm = []
comfyanonymous's avatar
comfyanonymous committed
121
            crossattn_max_len = 0
122
123

            temp = {}
comfyanonymous's avatar
comfyanonymous committed
124
            for x in c_list:
125
126
127
128
129
                for k in x:
                    cur = temp.get(k, [])
                    cur.append(x[k])
                    temp[k] = cur

comfyanonymous's avatar
comfyanonymous committed
130
            out = {}
131
132
133
134
            for k in temp:
                conds = temp[k]
                out[k] = conds[0].concat(conds[1:])

comfyanonymous's avatar
comfyanonymous committed
135
136
            return out

137
        def calc_cond_uncond_batch(model, cond, uncond, x_in, timestep, model_options):
comfyanonymous's avatar
comfyanonymous committed
138
            out_cond = torch.zeros_like(x_in)
comfyanonymous's avatar
comfyanonymous committed
139
            out_count = torch.ones_like(x_in) * 1e-37
140
141

            out_uncond = torch.zeros_like(x_in)
comfyanonymous's avatar
comfyanonymous committed
142
            out_uncond_count = torch.ones_like(x_in) * 1e-37
143
144
145

            COND = 0
            UNCOND = 1
comfyanonymous's avatar
comfyanonymous committed
146

147
            to_run = []
comfyanonymous's avatar
comfyanonymous committed
148
            for x in cond:
149
                p = get_area_and_mult(x, x_in, timestep)
150
                if p is None:
comfyanonymous's avatar
comfyanonymous committed
151
                    continue
152
153

                to_run += [(p, COND)]
154
155
            if uncond is not None:
                for x in uncond:
156
                    p = get_area_and_mult(x, x_in, timestep)
157
158
                    if p is None:
                        continue
159

160
                    to_run += [(p, UNCOND)]
161
162
163
164

            while len(to_run) > 0:
                first = to_run[0]
                first_shape = first[0][0].shape
165
                to_batch_temp = []
166
                for x in range(len(to_run)):
comfyanonymous's avatar
comfyanonymous committed
167
168
                    if can_concat_cond(to_run[x][0], first[0]):
                        to_batch_temp += [x]
169
170
171
172

                to_batch_temp.reverse()
                to_batch = to_batch_temp[:1]

173
                free_memory = model_management.get_free_memory(x_in.device)
174
175
                for i in range(1, len(to_batch_temp) + 1):
                    batch_amount = to_batch_temp[:len(to_batch_temp)//i]
176
177
                    input_shape = [len(batch_amount) * first_shape[0]] + list(first_shape)[1:]
                    if model.memory_required(input_shape) < free_memory:
178
179
                        to_batch = batch_amount
                        break
180
181
182
183
184
185

                input_x = []
                mult = []
                c = []
                cond_or_uncond = []
                area = []
comfyanonymous's avatar
comfyanonymous committed
186
                control = None
187
                patches = None
188
189
190
191
192
193
194
195
                for x in to_batch:
                    o = to_run.pop(x)
                    p = o[0]
                    input_x += [p[0]]
                    mult += [p[1]]
                    c += [p[2]]
                    area += [p[3]]
                    cond_or_uncond += [o[1]]
comfyanonymous's avatar
comfyanonymous committed
196
                    control = p[4]
197
                    patches = p[5]
198
199
200

                batch_chunks = len(cond_or_uncond)
                input_x = torch.cat(input_x)
comfyanonymous's avatar
comfyanonymous committed
201
                c = cond_cat(c)
comfyanonymous's avatar
comfyanonymous committed
202
                timestep_ = torch.cat([timestep] * batch_chunks)
203

comfyanonymous's avatar
comfyanonymous committed
204
                if control is not None:
205
                    c['control'] = control.get_control(input_x, timestep_, c, len(cond_or_uncond))
comfyanonymous's avatar
comfyanonymous committed
206

207
                transformer_options = {}
208
                if 'transformer_options' in model_options:
209
210
211
                    transformer_options = model_options['transformer_options'].copy()

                if patches is not None:
212
213
214
215
216
217
218
219
220
                    if "patches" in transformer_options:
                        cur_patches = transformer_options["patches"].copy()
                        for p in patches:
                            if p in cur_patches:
                                cur_patches[p] = cur_patches[p] + patches[p]
                            else:
                                cur_patches[p] = patches[p]
                    else:
                        transformer_options["patches"] = patches
221

222
                transformer_options["cond_or_uncond"] = cond_or_uncond[:]
223
224
                transformer_options["sigmas"] = timestep

225
                c['transformer_options'] = transformer_options
226

227
                if 'model_function_wrapper' in model_options:
228
                    output = model_options['model_function_wrapper'](model.apply_model, {"input": input_x, "timestep": timestep_, "c": c, "cond_or_uncond": cond_or_uncond}).chunk(batch_chunks)
229
                else:
230
                    output = model.apply_model(input_x, timestep_, **c).chunk(batch_chunks)
comfyanonymous's avatar
comfyanonymous committed
231
                del input_x
232
233
234
235
236
237
238
239

                for o in range(batch_chunks):
                    if cond_or_uncond[o] == COND:
                        out_cond[:,:,area[o][2]:area[o][0] + area[o][2],area[o][3]:area[o][1] + area[o][3]] += output[o] * mult[o]
                        out_count[:,:,area[o][2]:area[o][0] + area[o][2],area[o][3]:area[o][1] + area[o][3]] += mult[o]
                    else:
                        out_uncond[:,:,area[o][2]:area[o][0] + area[o][2],area[o][3]:area[o][1] + area[o][3]] += output[o] * mult[o]
                        out_uncond_count[:,:,area[o][2]:area[o][0] + area[o][2],area[o][3]:area[o][1] + area[o][3]] += mult[o]
comfyanonymous's avatar
comfyanonymous committed
240
241
242
243
                del mult

            out_cond /= out_count
            del out_count
244
245
246
            out_uncond /= out_uncond_count
            del out_uncond_count
            return out_cond, out_uncond
comfyanonymous's avatar
comfyanonymous committed
247
248


249
250
251
        if math.isclose(cond_scale, 1.0):
            uncond = None

252
        cond, uncond = calc_cond_uncond_batch(model, cond, uncond, x, timestep, model_options)
253
        if "sampler_cfg_function" in model_options:
comfyanonymous's avatar
comfyanonymous committed
254
            args = {"cond": x - cond, "uncond": x - uncond, "cond_scale": cond_scale, "timestep": timestep, "input": x, "sigma": timestep}
255
            return x - model_options["sampler_cfg_function"](args)
256
257
        else:
            return uncond + (cond - uncond) * cond_scale
comfyanonymous's avatar
comfyanonymous committed
258

comfyanonymous's avatar
comfyanonymous committed
259
260
261
262
class CFGNoisePredictor(torch.nn.Module):
    def __init__(self, model):
        super().__init__()
        self.inner_model = model
263
    def apply_model(self, x, timestep, cond, uncond, cond_scale, model_options={}, seed=None):
264
        out = sampling_function(self.inner_model, x, timestep, uncond, cond, cond_scale, model_options=model_options, seed=seed)
comfyanonymous's avatar
comfyanonymous committed
265
        return out
comfyanonymous's avatar
comfyanonymous committed
266
267
    def forward(self, *args, **kwargs):
        return self.apply_model(*args, **kwargs)
comfyanonymous's avatar
comfyanonymous committed
268
269

class KSamplerX0Inpaint(torch.nn.Module):
270
271
272
    def __init__(self, model):
        super().__init__()
        self.inner_model = model
273
    def forward(self, x, sigma, uncond, cond, cond_scale, denoise_mask, model_options={}, seed=None):
274
275
        if denoise_mask is not None:
            latent_mask = 1. - denoise_mask
276
            x = x * denoise_mask + (self.latent_image + self.noise * sigma.reshape([sigma.shape[0]] + [1] * (len(self.noise.shape) - 1))) * latent_mask
277
        out = self.inner_model(x, sigma, cond=cond, uncond=uncond, cond_scale=cond_scale, model_options=model_options, seed=seed)
278
        if denoise_mask is not None:
comfyanonymous's avatar
comfyanonymous committed
279
            out = out * denoise_mask + self.latent_image * latent_mask
280
        return out
281

comfyanonymous's avatar
comfyanonymous committed
282
def simple_scheduler(model, steps):
comfyanonymous's avatar
comfyanonymous committed
283
    s = model.model_sampling
comfyanonymous's avatar
comfyanonymous committed
284
    sigs = []
comfyanonymous's avatar
comfyanonymous committed
285
    ss = len(s.sigmas) / steps
comfyanonymous's avatar
comfyanonymous committed
286
    for x in range(steps):
comfyanonymous's avatar
comfyanonymous committed
287
        sigs += [float(s.sigmas[-(1 + int(x * ss))])]
comfyanonymous's avatar
comfyanonymous committed
288
289
290
    sigs += [0.0]
    return torch.FloatTensor(sigs)

comfyanonymous's avatar
comfyanonymous committed
291
def ddim_scheduler(model, steps):
comfyanonymous's avatar
comfyanonymous committed
292
    s = model.model_sampling
comfyanonymous's avatar
comfyanonymous committed
293
    sigs = []
comfyanonymous's avatar
comfyanonymous committed
294
295
296
297
298
299
    ss = len(s.sigmas) // steps
    x = 1
    while x < len(s.sigmas):
        sigs += [float(s.sigmas[x])]
        x += ss
    sigs = sigs[::-1]
comfyanonymous's avatar
comfyanonymous committed
300
301
302
    sigs += [0.0]
    return torch.FloatTensor(sigs)

comfyanonymous's avatar
comfyanonymous committed
303
304
305
306
307
308
309
310
311
312
def normal_scheduler(model, steps, sgm=False, floor=False):
    s = model.model_sampling
    start = s.timestep(s.sigma_max)
    end = s.timestep(s.sigma_min)

    if sgm:
        timesteps = torch.linspace(start, end, steps + 1)[:-1]
    else:
        timesteps = torch.linspace(start, end, steps)

313
314
315
    sigs = []
    for x in range(len(timesteps)):
        ts = timesteps[x]
comfyanonymous's avatar
comfyanonymous committed
316
        sigs.append(s.sigma(ts))
317
318
319
    sigs += [0.0]
    return torch.FloatTensor(sigs)

Jacob Segal's avatar
Jacob Segal committed
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
def get_mask_aabb(masks):
    if masks.numel() == 0:
        return torch.zeros((0, 4), device=masks.device, dtype=torch.int)

    b = masks.shape[0]

    bounding_boxes = torch.zeros((b, 4), device=masks.device, dtype=torch.int)
    is_empty = torch.zeros((b), device=masks.device, dtype=torch.bool)
    for i in range(b):
        mask = masks[i]
        if mask.numel() == 0:
            continue
        if torch.max(mask != 0) == False:
            is_empty[i] = True
            continue
        y, x = torch.where(mask)
        bounding_boxes[i, 0] = torch.min(x)
        bounding_boxes[i, 1] = torch.min(y)
        bounding_boxes[i, 2] = torch.max(x)
        bounding_boxes[i, 3] = torch.max(y)

    return bounding_boxes, is_empty

343
def resolve_areas_and_cond_masks(conditions, h, w, device):
Jacob Segal's avatar
Jacob Segal committed
344
345
346
347
    # We need to decide on an area outside the sampling loop in order to properly generate opposite areas of equal sizes.
    # While we're doing this, we can also resolve the mask device and scaling for performance reasons
    for i in range(len(conditions)):
        c = conditions[i]
348
349
        if 'area' in c:
            area = c['area']
350
            if area[0] == "percentage":
351
                modified = c.copy()
352
353
                area = (max(1, round(area[1] * h)), max(1, round(area[2] * w)), round(area[3] * h), round(area[4] * w))
                modified['area'] = area
354
                c = modified
355
356
                conditions[i] = c

357
358
        if 'mask' in c:
            mask = c['mask']
Jacob Segal's avatar
Jacob Segal committed
359
            mask = mask.to(device=device)
360
            modified = c.copy()
Jacob Segal's avatar
Jacob Segal committed
361
362
            if len(mask.shape) == 2:
                mask = mask.unsqueeze(0)
mara's avatar
mara committed
363
            if mask.shape[1] != h or mask.shape[2] != w:
Jacob Segal's avatar
Jacob Segal committed
364
365
                mask = torch.nn.functional.interpolate(mask.unsqueeze(1), size=(h, w), mode='bilinear', align_corners=False).squeeze(1)

Jacob Segal's avatar
Jacob Segal committed
366
            if modified.get("set_area_to_bounds", False):
Jacob Segal's avatar
Jacob Segal committed
367
                bounds = torch.max(torch.abs(mask),dim=0).values.unsqueeze(0)
Jacob Segal's avatar
Jacob Segal committed
368
369
370
371
                boxes, is_empty = get_mask_aabb(bounds)
                if is_empty[0]:
                    # Use the minimum possible size for efficiency reasons. (Since the mask is all-0, this becomes a noop anyway)
                    modified['area'] = (8, 8, 0, 0)
Jacob Segal's avatar
Jacob Segal committed
372
                else:
Jacob Segal's avatar
Jacob Segal committed
373
                    box = boxes[0]
Jacob Segal's avatar
Jacob Segal committed
374
                    H, W, Y, X = (box[3] - box[1] + 1, box[2] - box[0] + 1, box[1], box[0])
375
376
                    H = max(8, H)
                    W = max(8, W)
Jacob Segal's avatar
Jacob Segal committed
377
378
                    area = (int(H), int(W), int(Y), int(X))
                    modified['area'] = area
Jacob Segal's avatar
Jacob Segal committed
379
380

            modified['mask'] = mask
381
            conditions[i] = modified
Jacob Segal's avatar
Jacob Segal committed
382

comfyanonymous's avatar
comfyanonymous committed
383
def create_cond_with_same_area_if_none(conds, c):
384
    if 'area' not in c:
comfyanonymous's avatar
comfyanonymous committed
385
386
        return

387
    c_area = c['area']
comfyanonymous's avatar
comfyanonymous committed
388
389
    smallest = None
    for x in conds:
390
391
        if 'area' in x:
            a = x['area']
comfyanonymous's avatar
comfyanonymous committed
392
393
394
395
396
            if c_area[2] >= a[2] and c_area[3] >= a[3]:
                if a[0] + a[2] >= c_area[0] + c_area[2]:
                    if a[1] + a[3] >= c_area[1] + c_area[3]:
                        if smallest is None:
                            smallest = x
397
                        elif 'area' not in smallest:
comfyanonymous's avatar
comfyanonymous committed
398
399
                            smallest = x
                        else:
400
                            if smallest['area'][0] * smallest['area'][1] > a[0] * a[1]:
comfyanonymous's avatar
comfyanonymous committed
401
402
403
404
405
406
                                smallest = x
        else:
            if smallest is None:
                smallest = x
    if smallest is None:
        return
407
408
    if 'area' in smallest:
        if smallest['area'] == c_area:
comfyanonymous's avatar
comfyanonymous committed
409
            return
410
411
412
413

    out = c.copy()
    out['model_conds'] = smallest['model_conds'].copy() #TODO: which fields should be copied?
    conds += [out]
comfyanonymous's avatar
comfyanonymous committed
414

415
def calculate_start_end_timesteps(model, conds):
416
    s = model.model_sampling
417
418
419
420
421
    for t in range(len(conds)):
        x = conds[t]

        timestep_start = None
        timestep_end = None
422
        if 'start_percent' in x:
423
            timestep_start = s.percent_to_sigma(x['start_percent'])
424
        if 'end_percent' in x:
425
            timestep_end = s.percent_to_sigma(x['end_percent'])
426
427

        if (timestep_start is not None) or (timestep_end is not None):
428
            n = x.copy()
429
430
431
432
            if (timestep_start is not None):
                n['timestep_start'] = timestep_start
            if (timestep_end is not None):
                n['timestep_end'] = timestep_end
433
            conds[t] = n
434

435
def pre_run_control(model, conds):
436
    s = model.model_sampling
437
438
439
440
441
    for t in range(len(conds)):
        x = conds[t]

        timestep_start = None
        timestep_end = None
442
        percent_to_timestep_function = lambda a: s.percent_to_sigma(a)
443
        if 'control' in x:
444
            x['control'].pre_run(model, percent_to_timestep_function)
445

446
def apply_empty_x_to_equal_area(conds, uncond, name, uncond_fill_func):
comfyanonymous's avatar
comfyanonymous committed
447
448
449
450
451
452
    cond_cnets = []
    cond_other = []
    uncond_cnets = []
    uncond_other = []
    for t in range(len(conds)):
        x = conds[t]
453
454
455
        if 'area' not in x:
            if name in x and x[name] is not None:
                cond_cnets.append(x[name])
comfyanonymous's avatar
comfyanonymous committed
456
457
458
459
            else:
                cond_other.append((x, t))
    for t in range(len(uncond)):
        x = uncond[t]
460
461
462
        if 'area' not in x:
            if name in x and x[name] is not None:
                uncond_cnets.append(x[name])
comfyanonymous's avatar
comfyanonymous committed
463
464
465
466
467
468
469
470
471
            else:
                uncond_other.append((x, t))

    if len(uncond_cnets) > 0:
        return

    for x in range(len(cond_cnets)):
        temp = uncond_other[x % len(uncond_other)]
        o = temp[0]
472
473
        if name in o and o[name] is not None:
            n = o.copy()
474
            n[name] = uncond_fill_func(cond_cnets, x)
475
            uncond += [n]
comfyanonymous's avatar
comfyanonymous committed
476
        else:
477
            n = o.copy()
478
            n[name] = uncond_fill_func(cond_cnets, x)
479
            uncond[temp[1]] = n
480

481
def encode_model_conds(model_function, conds, noise, device, prompt_type, **kwargs):
482
483
    for t in range(len(conds)):
        x = conds[t]
484
        params = x.copy()
485
        params["device"] = device
486
487
488
489
        params["noise"] = noise
        params["width"] = params.get("width", noise.shape[3] * 8)
        params["height"] = params.get("height", noise.shape[2] * 8)
        params["prompt_type"] = params.get("prompt_type", prompt_type)
490
491
492
493
494
        for k in kwargs:
            if k not in params:
                params[k] = kwargs[k]

        out = model_function(**params)
495
496
497
498
499
500
        x = x.copy()
        model_conds = x['model_conds'].copy()
        for k in out:
            model_conds[k] = out[k]
        x['model_conds'] = model_conds
        conds[t] = x
501
    return conds
502

comfyanonymous's avatar
comfyanonymous committed
503
504
505
506
507
class Sampler:
    def sample(self):
        pass

    def max_denoise(self, model_wrap, sigmas):
comfyanonymous's avatar
comfyanonymous committed
508
509
510
        max_sigma = float(model_wrap.inner_model.model_sampling.sigma_max)
        sigma = float(sigmas[0])
        return math.isclose(max_sigma, sigma, rel_tol=1e-05) or sigma > max_sigma
comfyanonymous's avatar
comfyanonymous committed
511
512
513

class UNIPC(Sampler):
    def sample(self, model_wrap, sigmas, extra_args, callback, noise, latent_image=None, denoise_mask=None, disable_pbar=False):
514
        return uni_pc.sample_unipc(model_wrap, noise, latent_image, sigmas, max_denoise=self.max_denoise(model_wrap, sigmas), extra_args=extra_args, noise_mask=denoise_mask, callback=callback, disable=disable_pbar)
comfyanonymous's avatar
comfyanonymous committed
515
516
517

class UNIPCBH2(Sampler):
    def sample(self, model_wrap, sigmas, extra_args, callback, noise, latent_image=None, denoise_mask=None, disable_pbar=False):
518
        return uni_pc.sample_unipc(model_wrap, noise, latent_image, sigmas, max_denoise=self.max_denoise(model_wrap, sigmas), extra_args=extra_args, noise_mask=denoise_mask, callback=callback, variant='bh2', disable=disable_pbar)
comfyanonymous's avatar
comfyanonymous committed
519

comfyanonymous's avatar
comfyanonymous committed
520
KSAMPLER_NAMES = ["euler", "euler_ancestral", "heun", "heunpp2","dpm_2", "dpm_2_ancestral",
comfyanonymous's avatar
comfyanonymous committed
521
                  "lms", "dpm_fast", "dpm_adaptive", "dpmpp_2s_ancestral", "dpmpp_sde", "dpmpp_sde_gpu",
comfyanonymous's avatar
comfyanonymous committed
522
                  "dpmpp_2m", "dpmpp_2m_sde", "dpmpp_2m_sde_gpu", "dpmpp_3m_sde", "dpmpp_3m_sde_gpu", "ddpm", "lcm"]
comfyanonymous's avatar
comfyanonymous committed
523

524
525
526
527
528
class KSAMPLER(Sampler):
    def __init__(self, sampler_function, extra_options={}, inpaint_options={}):
        self.sampler_function = sampler_function
        self.extra_options = extra_options
        self.inpaint_options = inpaint_options
comfyanonymous's avatar
comfyanonymous committed
529

530
531
532
533
534
535
536
537
538
    def sample(self, model_wrap, sigmas, extra_args, callback, noise, latent_image=None, denoise_mask=None, disable_pbar=False):
        extra_args["denoise_mask"] = denoise_mask
        model_k = KSamplerX0Inpaint(model_wrap)
        model_k.latent_image = latent_image
        if self.inpaint_options.get("random", False): #TODO: Should this be the default?
            generator = torch.manual_seed(extra_args.get("seed", 41) + 1)
            model_k.noise = torch.randn(noise.shape, generator=generator, device="cpu").to(noise.dtype).to(noise.device)
        else:
            model_k.noise = noise
comfyanonymous's avatar
comfyanonymous committed
539

540
541
542
543
544
545
546
547
548
549
550
551
        if self.max_denoise(model_wrap, sigmas):
            noise = noise * torch.sqrt(1.0 + sigmas[0] ** 2.0)
        else:
            noise = noise * sigmas[0]

        k_callback = None
        total_steps = len(sigmas) - 1
        if callback is not None:
            k_callback = lambda x: callback(x["i"], x["denoised"], x["x"], total_steps)

        if latent_image is not None:
            noise += latent_image
comfyanonymous's avatar
comfyanonymous committed
552

553
554
555
556
557
558
559
        samples = self.sampler_function(model_k, noise, sigmas, extra_args=extra_args, callback=k_callback, disable=disable_pbar, **self.extra_options)
        return samples


def ksampler(sampler_name, extra_options={}, inpaint_options={}):
    if sampler_name == "dpm_fast":
        def dpm_fast_function(model, noise, sigmas, extra_args, callback, disable):
comfyanonymous's avatar
comfyanonymous committed
560
561
562
            sigma_min = sigmas[-1]
            if sigma_min == 0:
                sigma_min = sigmas[-2]
563
564
565
566
567
568
569
570
571
572
573
574
            total_steps = len(sigmas) - 1
            return k_diffusion_sampling.sample_dpm_fast(model, noise, sigma_min, sigmas[0], total_steps, extra_args=extra_args, callback=callback, disable=disable)
        sampler_function = dpm_fast_function
    elif sampler_name == "dpm_adaptive":
        def dpm_adaptive_function(model, noise, sigmas, extra_args, callback, disable):
            sigma_min = sigmas[-1]
            if sigma_min == 0:
                sigma_min = sigmas[-2]
            return k_diffusion_sampling.sample_dpm_adaptive(model, noise, sigma_min, sigmas[0], extra_args=extra_args, callback=callback, disable=disable)
        sampler_function = dpm_adaptive_function
    else:
        sampler_function = getattr(k_diffusion_sampling, "sample_{}".format(sampler_name))
comfyanonymous's avatar
comfyanonymous committed
575

576
    return KSAMPLER(sampler_function, extra_options, inpaint_options)
comfyanonymous's avatar
comfyanonymous committed
577

comfyanonymous's avatar
comfyanonymous committed
578
579
def wrap_model(model):
    model_denoise = CFGNoisePredictor(model)
comfyanonymous's avatar
comfyanonymous committed
580
    return model_denoise
comfyanonymous's avatar
comfyanonymous committed
581
582
583
584
585
586
587
588

def sample(model, noise, positive, negative, cfg, device, sampler, sigmas, model_options={}, latent_image=None, denoise_mask=None, callback=None, disable_pbar=False, seed=None):
    positive = positive[:]
    negative = negative[:]

    resolve_areas_and_cond_masks(positive, noise.shape[2], noise.shape[3], device)
    resolve_areas_and_cond_masks(negative, noise.shape[2], noise.shape[3], device)

comfyanonymous's avatar
comfyanonymous committed
589
    model_wrap = wrap_model(model)
comfyanonymous's avatar
comfyanonymous committed
590

591
592
    calculate_start_end_timesteps(model, negative)
    calculate_start_end_timesteps(model, positive)
comfyanonymous's avatar
comfyanonymous committed
593
594
595
596
597
598
599

    #make sure each cond area has an opposite one with the same area
    for c in positive:
        create_cond_with_same_area_if_none(negative, c)
    for c in negative:
        create_cond_with_same_area_if_none(positive, c)

600
    pre_run_control(model, negative + positive)
comfyanonymous's avatar
comfyanonymous committed
601

602
    apply_empty_x_to_equal_area(list(filter(lambda c: c.get('control_apply_to_uncond', False) == True, positive)), negative, 'control', lambda cond_cnets, x: cond_cnets[x])
comfyanonymous's avatar
comfyanonymous committed
603
604
    apply_empty_x_to_equal_area(positive, negative, 'gligen', lambda cond_cnets, x: cond_cnets[x])

605
606
607
    if latent_image is not None:
        latent_image = model.process_latent_in(latent_image)

608
609
610
    if hasattr(model, 'extra_conds'):
        positive = encode_model_conds(model.extra_conds, positive, noise, device, "positive", latent_image=latent_image, denoise_mask=denoise_mask)
        negative = encode_model_conds(model.extra_conds, negative, noise, device, "negative", latent_image=latent_image, denoise_mask=denoise_mask)
comfyanonymous's avatar
comfyanonymous committed
611
612
613
614
615
616

    extra_args = {"cond":positive, "uncond":negative, "cond_scale": cfg, "model_options": model_options, "seed":seed}

    samples = sampler.sample(model_wrap, sigmas, extra_args, callback, noise, latent_image, denoise_mask, disable_pbar)
    return model.process_latent_out(samples.to(torch.float32))

comfyanonymous's avatar
comfyanonymous committed
617
618
619
620
621
SCHEDULER_NAMES = ["normal", "karras", "exponential", "sgm_uniform", "simple", "ddim_uniform"]
SAMPLER_NAMES = KSAMPLER_NAMES + ["ddim", "uni_pc", "uni_pc_bh2"]

def calculate_sigmas_scheduler(model, scheduler_name, steps):
    if scheduler_name == "karras":
comfyanonymous's avatar
comfyanonymous committed
622
        sigmas = k_diffusion_sampling.get_sigmas_karras(n=steps, sigma_min=float(model.model_sampling.sigma_min), sigma_max=float(model.model_sampling.sigma_max))
comfyanonymous's avatar
comfyanonymous committed
623
    elif scheduler_name == "exponential":
comfyanonymous's avatar
comfyanonymous committed
624
        sigmas = k_diffusion_sampling.get_sigmas_exponential(n=steps, sigma_min=float(model.model_sampling.sigma_min), sigma_max=float(model.model_sampling.sigma_max))
comfyanonymous's avatar
comfyanonymous committed
625
    elif scheduler_name == "normal":
comfyanonymous's avatar
comfyanonymous committed
626
        sigmas = normal_scheduler(model, steps)
comfyanonymous's avatar
comfyanonymous committed
627
    elif scheduler_name == "simple":
comfyanonymous's avatar
comfyanonymous committed
628
        sigmas = simple_scheduler(model, steps)
comfyanonymous's avatar
comfyanonymous committed
629
    elif scheduler_name == "ddim_uniform":
comfyanonymous's avatar
comfyanonymous committed
630
        sigmas = ddim_scheduler(model, steps)
comfyanonymous's avatar
comfyanonymous committed
631
    elif scheduler_name == "sgm_uniform":
comfyanonymous's avatar
comfyanonymous committed
632
        sigmas = normal_scheduler(model, steps, sgm=True)
comfyanonymous's avatar
comfyanonymous committed
633
634
635
636
    else:
        print("error invalid scheduler", self.scheduler)
    return sigmas

637
def sampler_object(name):
638
    if name == "uni_pc":
639
        sampler = UNIPC()
640
    elif name == "uni_pc_bh2":
641
        sampler = UNIPCBH2()
642
    elif name == "ddim":
643
        sampler = ksampler("euler", inpaint_options={"random": True})
644
645
646
647
    else:
        sampler = ksampler(name)
    return sampler

comfyanonymous's avatar
comfyanonymous committed
648
class KSampler:
comfyanonymous's avatar
comfyanonymous committed
649
650
    SCHEDULERS = SCHEDULER_NAMES
    SAMPLERS = SAMPLER_NAMES
comfyanonymous's avatar
comfyanonymous committed
651

652
    def __init__(self, model, steps, device, sampler=None, scheduler=None, denoise=None, model_options={}):
comfyanonymous's avatar
comfyanonymous committed
653
654
655
656
657
658
659
660
661
        self.model = model
        self.device = device
        if scheduler not in self.SCHEDULERS:
            scheduler = self.SCHEDULERS[0]
        if sampler not in self.SAMPLERS:
            sampler = self.SAMPLERS[0]
        self.scheduler = scheduler
        self.sampler = sampler
        self.set_steps(steps, denoise)
662
        self.denoise = denoise
663
        self.model_options = model_options
comfyanonymous's avatar
comfyanonymous committed
664

comfyanonymous's avatar
comfyanonymous committed
665
666
667
668
    def calculate_sigmas(self, steps):
        sigmas = None

        discard_penultimate_sigma = False
669
        if self.sampler in ['dpm_2', 'dpm_2_ancestral', 'uni_pc', 'uni_pc_bh2']:
comfyanonymous's avatar
comfyanonymous committed
670
671
672
            steps += 1
            discard_penultimate_sigma = True

comfyanonymous's avatar
comfyanonymous committed
673
        sigmas = calculate_sigmas_scheduler(self.model, self.scheduler, steps)
comfyanonymous's avatar
comfyanonymous committed
674
675
676
677
678

        if discard_penultimate_sigma:
            sigmas = torch.cat([sigmas[:-2], sigmas[-1:]])
        return sigmas

comfyanonymous's avatar
comfyanonymous committed
679
680
    def set_steps(self, steps, denoise=None):
        self.steps = steps
681
        if denoise is None or denoise > 0.9999:
comfyanonymous's avatar
comfyanonymous committed
682
            self.sigmas = self.calculate_sigmas(steps).to(self.device)
comfyanonymous's avatar
comfyanonymous committed
683
684
        else:
            new_steps = int(steps/denoise)
comfyanonymous's avatar
comfyanonymous committed
685
            sigmas = self.calculate_sigmas(new_steps).to(self.device)
comfyanonymous's avatar
comfyanonymous committed
686
687
            self.sigmas = sigmas[-(steps + 1):]

688
    def sample(self, noise, positive, negative, cfg, latent_image=None, start_step=None, last_step=None, force_full_denoise=False, denoise_mask=None, sigmas=None, callback=None, disable_pbar=False, seed=None):
689
690
        if sigmas is None:
            sigmas = self.sigmas
comfyanonymous's avatar
comfyanonymous committed
691

comfyanonymous's avatar
comfyanonymous committed
692
        if last_step is not None and last_step < (len(sigmas) - 1):
comfyanonymous's avatar
comfyanonymous committed
693
            sigmas = sigmas[:last_step + 1]
comfyanonymous's avatar
comfyanonymous committed
694
695
696
            if force_full_denoise:
                sigmas[-1] = 0

comfyanonymous's avatar
comfyanonymous committed
697
        if start_step is not None:
comfyanonymous's avatar
comfyanonymous committed
698
699
700
701
702
703
704
            if start_step < (len(sigmas) - 1):
                sigmas = sigmas[start_step:]
            else:
                if latent_image is not None:
                    return latent_image
                else:
                    return torch.zeros_like(noise)
comfyanonymous's avatar
comfyanonymous committed
705

706
        sampler = sampler_object(self.sampler)
707

708
        return sample(self.model, noise, positive, negative, cfg, self.device, sampler, sigmas, self.model_options, latent_image=latent_image, denoise_mask=denoise_mask, callback=callback, disable_pbar=disable_pbar, seed=seed)