randomize weighting? proceedural weighting?

[ImageDegen]

I posted something similar in the forge ui directory but I might as well put it here as well. I'd like to add a random number range to weight calculations in my prompts directly, even just a rand(-6,6) with decimal notation options if included in the prompt (-6.00,6.00) etc.

While I was thinking about this, why not add a feature/extension to do weights in a procedural fashion like, taking batch number +/- 1 etc = weight, so like ProW(starting weight, +/-number, min, max) and an option to reverse the +/- on hitting min/max, or return to starting weight/repeat/end.

This would add a hell of a lot of Lycoris functionality on top of everything else you could do with per batch generation without needing stuff like AnimateDiff or other batch methods that are kinda complicated if more granularly controlable like with wildcards etc.

[noisefloordev]

I'm guessing they won't want to complicate the core prompt syntax for this (it's already overly complicated to parse), but take a look at sd-dynamic-prompts (https://github.com/adieyal/sd-dynamic-prompts). This seems right up its alley. I think you could do something like "(duke nukem:{0.75|0.8|0.85|0.9|0.95|1|1.05|1.1|1.15|1.2|1.25})". By default that should choose a random weight from the list, and the "combinatoric prompt" feature would let you take that and generate every combination, if you want to batch generate a prompt with a series of weights to see how they vary.

(That extension also has more complex prompt generation that might be able to do this programmatically, but I haven't used that.)

[ImageDegen]

The issue for me there is when you have potentially a lot of iterative steps, say like with Lora's etc, and getting into .00 or .000 level decimal placing, static random preset numbers just don't quite cut it. I have similar issues with Lora Block Weighting extension an its the same limitations functionally speaking. I will look a bit deeper on the combinatoric prompt feature though.

[ImageDegen]

Some further consideration; if we don't want to mess with syntax, why not just have something like another drop down tab on the side, but using a keyword set like Sine_wave or RNGesus to get pulled on the back end and sorted through like an extension if not a base feature?

[w-e-w]

first you need to understand that prompt weighs and Extra Network weights (lora) are fundamentally different
they work on the completely different level

it overly simplified explanation is that changer prompt weight is like change input to model, the model is untouched,
changeing network weights on the other hand is changeing the model that recives the processing your inputs

in the web you are we already support changing of prompt weights in the middle of generation by default
see prompt-editing
they're also extensions such as sd-dynamic-prompts

network weights needs to handled by a completely different system
as of now webui have any sort of built-in support for changing the weight during generation
however there is an extension that supports this for LoRA composable-lora

this extension hasn't received any updates in a year (since 1.5) so I'm not sure if it's still working properly
from my quick test just now it seems to be at least partially functioning

[ImageDegen]

I'm not talking about changing weights during steps, but between successive completed generations in an automated, predetermined, and functional way.

I'm currently trying to brute force it with a txt file script replacing a weight syntax with a wave function or random number range calculation for my proposed weight range but it's having issues (i'm not a programmer by far). Not a seed alteration, not a iterative step in a single image.

I am aware of these extensions but they do not do or seem to not work with what I have been trying to do.

[ImageDegen]

I am currently successfully using

import sys
import re
import math
import random

def sine_wave(index, total, min_weight, max_weight, angle, precision):
    amplitude = (max_weight - min_weight) / 2
    midline = (max_weight + min_weight) / 2
    angle_rad = math.radians(angle)
    weight = midline + amplitude * math.sin(angle_rad * (index / total) * 2 * math.pi)
    return round(weight, precision)

def random_weight(min_weight, max_weight, precision):
    weight = random.uniform(min_weight, max_weight)
    return round(weight, precision)

def process_prompt(prompt, index, total_generations):
    sine_wave_pattern = re.compile(r"&sine_wav, (-?\d+\.?\d*), (-?\d+\.?\d*), (-?\d+\.?\d*), (\d+)&")
    random_pattern = re.compile(r"&Rand, (-?\d+\.?\d*), (-?\d+\.?\d*)&")
    directive_pattern = re.compile(r"(<[^<>]*\$(top|tart) \d+[^<>]*>)")

    # Remove directives based on the index before processing weights
    def check_visibility(match):
        content = match.group(0)
        directive, number = re.search(r"\$(top|tart) (\d+)", content).groups()
        threshold = int(number)
        if (directive == "top" and index >= threshold) or (directive == "tart" and index < threshold):
            return ""
        return content

    prompt = re.sub(directive_pattern, check_visibility, prompt)

    # Process sine wave and random weights
    prompt = re.sub(sine_wave_pattern, lambda m: str(sine_wave(index, total_generations, float(m.group(2)), float(m.group(1)), float(m.group(3)), int(m.group(4)))), prompt)
    prompt = re.sub(random_pattern, lambda m: str(random_weight(float(m.group(1)), float(m.group(2)), 2)), prompt)

    # Remove directive tags from final output
    prompt = re.sub(r"\$top \d+|\$tart \d+", "", prompt)

    return prompt

def main(input_file, output_file, total_generations):
    with open(input_file, 'r') as file:
        prompts = file.readlines()

    processed_prompts = []

    for index in range(total_generations):
        for prompt in prompts:
            processed_prompt = process_prompt(prompt.strip(), index, total_generations)
            processed_prompts.append(processed_prompt)

    with open(output_file, 'w') as file:
        file.write("\n".join(processed_prompts))

if __name__ == "__main__":
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    total_generations = int(sys.argv[3])
    main(input_file, output_file, total_generations)

to make batches of prompts in text files to do the thing. This will remove the syntaxing in the output, give me the randomization I want, and the clean Sine waves, start and stop scripts in specific orders in the output prompt.

oh and here's the batch file

@echo off
setlocal enabledelayedexpansion

:: Prompt for total number of generations
set /p total_generations="Enter the total number of generations: "

:: Prompt for output file name
set /p output_file="Enter the name of the output file (with .txt extension): "

:: Paths
set input_file=prompts.txt

:: Call the Python script with total generations and output file name
python process_prompts.py %input_file% %output_file% %total_generations%

echo Processing complete. Check %output_file% for results.
pause

[w-e-w]

the thing is what you want is very specific to your own needs
too specific I would say
the more specific that your needs are the less likely that someone would have the same needs and decielse make something that you also find to fit your use case

what you're asking it's highly unlikely to be integrated into the base web UI

so you're likely going to ask someone to make an extension for you
ask someone to integrate the features you want into existing extensions
make you own extension / script

you're basically halfway there on creating your own script

the built-in prompts_from_file script is a good starting point of makeing your own
https://github.com/AUTOMATIC1111/stable-diffusion-webui/blob/master/scripts/prompts_from_file.py
prompts_from_file is basicly
read command from lines of text and parse them as multiple jobs generating multiple images

very close to what you want
very similar to what you currently doing
read some sort of text parse as instructions for making modification to the origin of prompt generating for later use

alternatively
if you don't wish to make a built-in script you could always make API client that takes your input and send individual API request to generate the images you want
see https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/API
a good starting point is my Example script with + huchenlei API payload display

---

either script / extentions / API, it's just ways of automating the process

[ImageDegen]

I've been digging more into video stuff is part of why it gets finicky, but I am kinda making more work for myself from what I hear by not messing with the comfy tools in that area, or more so Animate Diff in general.