VACE preview was just released :

https://github.com/ali-vilab/VACE https://ali-vilab.github.io/VACE-Page/ https://huggingface.co/collections/ali-vilab/vace-67eca186ff3e3564726aff38

VACE-Wan2.1-1.3B-Preview and VACE-LTX-Video-0.9 have been released.
The VACE-Wan2.1-14B version will be released at a later time

https://github.com/ali-vilab/VACE

i want to put my face on some photos. how do i make it to look most realistic? is there any guide/recommendation?

I'm a 3d motion designer and looking to embrace what GenAi has to offer and how I can include it in my workflow.

Places I've integrared ai already:- Chatgpt for ideation Various text to image models for visualization/storyboarding Meshy ai for generating 3d models from sketches and images Rokoko's motion capture ai for animating humans Sometimes I use ai upscale for upscaling resolution of my videos

I feel like I can speed up my workflow a lot by involving GenAi in my rendering workflow. I'm looking for models which I can use to add elements/effects to final renders. Or if I render a video at low samples and resolution, a model to upscale it's resolution and add details. I saw an Instagram post where the person hasrscreen recorded their 3d viewport and use Krea ai to get final render like output.

I am new to this so if you include a tutorial or stepst on how to get started, that would help me a lot.

How to input a person photo, and then convert the person to materials such as chrome, jelly or melting candle or holograms while keeping the likeness and good image quality?

I wonder what is the better option in 2025, here is the old method I know: Forge SDXL inpaint, person mask extension, CN canny for the contour, CN ipadaptor to input the material.

The problems are: 1. The eyes are usually still human eyes

1. The image quality become blurry or simply bad, way worse than using the same model and ask it to draw a statue of that material, it is like CN or inpaint will force degrade it

2. The face looks like some roman statue instead of the person

3. The material look like close up texture shot from e.g 10cm, but the person is full or upper half body shot, so probably 100cm away, and so the outcome doesn't look good.

4. The input texture will not match the 3d depth/normal of the person so forcing the material with ipadaptor often make some parts look flattened, but using CN depth to workaround will just turn the output into human again

5. The masked person border seldom look good

Thanks in advance

In the context of quantizing Stable Diffusion v1.x for research — specifically applying weight-only quantization where Linear and Conv2d weights are saved as UINT8, and FP32 inference is performed via dequantization — what is the conventional practice for storing and managing the quantization parameters (scale and zero point)?

Is it more common to:

1. Save the quantized weights and their scale/zero_point values in a separate .pth file? For example, save a separate quantized_info.pth file (no weight itself) to save the zero point and scale value and load zero_point and scale value from there.
2. Redesign the model architecture and save a modified ckpt model with embedded quantization logic.
3. Create custom wrapper classes for quantized layers and integrate scale/zero_point there?

I know that my question might look weird, but please understand that I am new to the field.

Please recommend any GitHub code or papers to look for to find conventional methods in the research field.

Thank you.

After looking at what 4o was capable of doing, it occurred to me that why not let AI control, generate, and refine image generation with a simple user request. In this age of vibe coding and agents, it was only natural to consider it I thought.

So, I decided to build a workflow using Gemini Pro 2.5 through API to handle from selecting the model, loras, controlnet, and everything else, let it analyze the input image and the user request to begin the process, and rework/ refine the output through a defined pass/fail criteria and a series of predefined routines to address different aspects of the image until it produces the image that matches the request made by the user.

I knew that it would require building a bunch of custom nodes but it involved more than just building custom nodes as it require necessary database for Gemini to rely on its decisions and actions in addition to building a decision/action/output tracking data necessary for each API call to Gemini could understand the context.

At the moment, I am still defining the database schema with Gemini 2.5 Pro as can be seen below:

summary_title: Resource Database Schema Design & Refinements

details:

- point: 1

title: General Database Strategy

items:

- Agreed to define YAML schemas for necessary resource types (Checkpoints, LoRAs, IPAdapters) and a global settings file.

- Key Decision: Databases will store model **filenames** (matching ComfyUI discovery via standard folders and `extra_model_paths.yaml`) rather than full paths. Custom nodes will output filenames to standard ComfyUI loader nodes.

- point: 2

title: Checkpoints Schema (`checkpoints.yaml`)

items:

- Finalized schema structure including: `filename`, `model_type` (Enum: SDXL, Pony, Illustrious), `style_tags` (List: for selection), `trigger_words` (List: optional, for prompt), `prediction_type` (Enum: epsilon, v_prediction), `recommended_samplers` (List), `recommended_scheduler` (String, optional), `recommended_cfg_scale` (Float/String, optional), `prompt_guidance` (Object: prefixes/style notes), `notes` (String).

- point: 3

title: Global Settings Schema (`global_settings.yaml`)

items:

- Established this new file for shared configurations.

- `supported_resolutions`: Contains a specific list of allowed `[Width, Height]` pairs. Workflow logic will find the closest aspect ratio match from this list and require pre-resizing/cropping of inputs.

- `default_prompt_guidance_by_type`: Defines default prompt structures (prefixes, style notes) for each `model_type` (SDXL, Pony, Illustrious), allowing overrides in `checkpoints.yaml`.

- `sampler_compatibility`: Optional reference map for `epsilon` vs. `v_prediction` compatible samplers (v-pred list to be fully populated later by user).

- point: 4

title: ControlNet Strategy

items:

- Primary Model: Plan to use a unified model ("xinsir controlnet union").

- Configuration: Agreed a separate `controlnets.yaml` is not needed. Configuration will rely on:

- `global_settings.yaml`: Adding `available_controlnet_types` (a limited list like Depth, Canny, Tile - *final list confirmation pending*) and `controlnet_preprocessors` (mapping types to default/optional preprocessor node names recognized by ComfyUI).

- Custom Selector Node: Acknowledged the likely need for a custom node to take Gemini's chosen type string (e.g., "Depth") and activate that mode in the "xinsir" model.

- Preprocessing Execution: Agreed to use **existing, individual preprocessor nodes** (from e.g., `ComfyUI_controlnet_aux`) combined with **dynamic routing** (switches/gates) based on the selected preprocessor name, rather than building a complex unified preprocessor node.

- Scope Limitation: Agreed to **limit** the `available_controlnet_types` to a small set known to be reliable with SDXL (e.g., Depth, Canny, Tile) to manage complexity.

- point: 5

title: IPAdapters Schema (`ipadapters.yaml`)

items:

- Identified the need to select specific IPAdapter models (e.g., general vs. face).

- Agreed a separate `ipadapters.yaml` file is necessary.

- Proposed schema including: `filename`, `model_type` (e.g., SDXL), `adapter_purpose` (List: tags like 'general', 'face_transfer'), `required_clip_vision_model` (String: e.g., 'ViT-H'), `notes` (String).

- point: 6

title: Immediate Next Step

items:

- Define the schema for **`loras.yaml`**.

While working on this, something occurred to me. It came about when I was explaining about the need to build certain custom nodes (e.g. each controlnet preprocessor has its own node and the user typically just add that corresponding node into the workflow but that simply didn't work in the AI automated workflow.) As I had to explain why this and that node needed to be built, I realized the whole issue with the ComfyUI; it was designed to be used by human manual construction which didn't fit with the direction I was trying to build.

The whole point of 4o is that, as the AI advances with more integrated capabilities, the need for a complicated workflow becomes unnecessary and obsolete. And this advancement will only accelerate in the coming days. So, all I am doing may just be a complete waste of time on my part. Still being a human, I am going to be irrational about it: since I started it, I would finish it regardless.

And all the buzz about agents and MCP looks to me like desperate attempts at relevance by the people about to become irrelevant.

https://reddit.com/link/1jpblfe/video/afaortqfhbse1/player