diff --git a/.gitattributes b/.gitattributes index fb04c39af8e2079463bdb947994a828601209cbf..86d36d2d1ea562f1f48a7cd046c925a910a63d58 100644 --- a/.gitattributes +++ b/.gitattributes @@ -62,3 +62,5 @@ InternScenes/InternScenes_Real2Sim/textures/Marble012_1K-JPG.blend filter=lfs di InternScenes/InternScenes_Real2Sim/textures/WoodFloor051_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text InternScenes/InternScenes_Real2Sim/textures/WoodFloor043_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text InternScenes/InternScenes_Real2Sim/textures/Tiles099_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text +InternScenes/InternScenes_Real2Sim/textures/Tiles074_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text +InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/__init__.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f0b787d3c7901696ce94879af9d14991eb01f79 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/__init__.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/coarse_knit_fabric.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/coarse_knit_fabric.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..850504983c2ff22578327a92fbdeda114d70b870 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/coarse_knit_fabric.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/fabric_random.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/fabric_random.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..60e3c39b53068830cdd2074440c1f3c8da31bb30 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/fabric_random.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/fine_knit_fabric.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/fine_knit_fabric.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81ef17f8c4eee0269c31881f43f4ee90a56da75d Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/fine_knit_fabric.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/general_fabric.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/general_fabric.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28e6dc7b3ae4a97e9c354fdd9b0065e41ff280a3 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/general_fabric.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/leather.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/leather.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a9b2e1d5c507869086cb434fcf7254d039a32062 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/leather.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/lined_fabric.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/lined_fabric.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ed0432aa5a49efa743c8f0944de77d701478259a Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/lined_fabric.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/sofa_fabric.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/sofa_fabric.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9cdddaebb6545efab2eee5660daeda42d80e819 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/sofa_fabric.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/velvet.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/velvet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3633525cd422db79ffb1e311b7dae4aa7fd2a798 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/fabrics/__pycache__/velvet.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__init__.py b/InternScenes/InternScenes_Real2Sim/materials/metal/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3f6fd35eda9ff9f548506736eef13ce9cfa84814 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/metal/__init__.py @@ -0,0 +1,92 @@ +# Copyright (C) 2023, Princeton University. +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree. + +# Authors: Lingjie Mei +from collections.abc import Iterable + +import numpy as np +from numpy.random import uniform + +from infinigen.assets.materials import common +from infinigen.assets.materials.bark_random import hex_to_rgb +from infinigen.core.util.color import hsv2rgba, rgb2hsv +from infinigen.core.util.random import log_uniform +from infinigen.core.util.random import random_general as rg + +from . import ( + brushed_metal, + galvanized_metal, + grained_and_polished_metal, + hammered_metal, + metal_basic, +) + + +def apply(obj, selection=None, metal_color=None, **kwargs): + color = sample_metal_color(metal_color) + shader = get_shader() + common.apply(obj, shader, selection, base_color=color, **kwargs) + + +def get_shader(): + return np.random.choice( + [ + brushed_metal.shader_brushed_metal, + galvanized_metal.shader_galvanized_metal, + grained_and_polished_metal.shader_grained_metal, + hammered_metal.shader_hammered_metal, + ] + ) + + +plain_colors = ( + "weighted_choice", + (0.5, 0xFDD017), + (1, 0xC0C0C0), + (1, 0x8C7853), + (0.5, 0xB87333), + (0.5, 0xB5A642), + (1, 0xBDBAAE), + (1, 0xA9ACB6), + (1, 0xB6AFA9), +) +natural_colors = ( + "weighted_choice", + (1, 0xC0C0C0), + (1, 0x8C7853), + (1, 0xBDBAAE), + (1, 0xA9ACB6), + (1, 0xB6AFA9), +) + + +def sample_metal_color(metal_color=None, **kwargs): + match metal_color: + case np.ndarray(): + return metal_color + case "plain": + h, s, v = rgb2hsv(hex_to_rgb(rg(plain_colors))[:-1]) + return hsv2rgba( + h + uniform(-0.1, 0.1), + s + uniform(-0.1, 0.1), + v * log_uniform(0.5, 0.2), + ) + case "natural": + h, s, v = rgb2hsv(hex_to_rgb(rg(natural_colors))[:-1]) + return hsv2rgba( + h + uniform(-0.1, 0.1), + s + uniform(-0.1, 0.1), + v * log_uniform(0.5, 0.2), + ) + case "bw": + return hsv2rgba(uniform(0, 1), uniform(0.0, 0.2), log_uniform(0.01, 0.2)) + case "bw+natural": + return ( + sample_metal_color("bw") + if uniform() < 0.5 + else sample_metal_color("natural") + ) + case _: + if uniform() < 0.2: + return sample_metal_color("natural") + return hsv2rgba(uniform(0, 1), uniform(0.3, 0.6), log_uniform(0.02, 0.5)) diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/__init__.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16d72d570ad1edfdd013f76ed98b699c85f34eed Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/__init__.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/brushed_metal.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/brushed_metal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91c4b1724ff4690514a348896a3af014755af07a Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/brushed_metal.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/galvanized_metal.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/galvanized_metal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6e337e9c401f5ef1965a4b1d671e89d32f3d7f5 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/galvanized_metal.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/grained_and_polished_metal.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/grained_and_polished_metal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..acc1a8686ba0751aea441e06b363890a3e75584c Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/grained_and_polished_metal.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/hammered_metal.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/hammered_metal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18606c3bcf8631f51b2aed4fe72c55d50c9cf703 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/hammered_metal.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/metal_basic.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/metal_basic.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4e893ff678ab0320045af6b652a0cde113d4b96 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/metal/__pycache__/metal_basic.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/brushed_metal.py b/InternScenes/InternScenes_Real2Sim/materials/metal/brushed_metal.py new file mode 100644 index 0000000000000000000000000000000000000000..3ae66bc9d93b4398813b2795e3aa6151f9deed25 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/metal/brushed_metal.py @@ -0,0 +1,169 @@ +# Copyright (C) 2024, Princeton University. +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree. + +# Authors: Yiming Zuo +# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=QcAMYRgR03k by blenderian + + +from numpy.random import uniform + +from infinigen.core import surface +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + + +@node_utils.to_nodegroup( + "nodegroup_brushed_metal", singleton=False, type="ShaderNodeTree" +) +def nodegroup_brushed_metal(nw: NodeWrangler): + # Code generated using version 2.6.4 of the node_transpiler + + texture_coordinate = nw.new_node(Nodes.TextureCoord) + + mapping_1 = nw.new_node( + Nodes.Mapping, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "Scale": (0.2000, 0.2000, 5.0000), + }, + ) + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)), + ("NodeSocketFloat", "Scale", 0.0000), + ("NodeSocketFloat", "Seed", 0.0000), + ], + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 100.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture_2 = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": mapping_1, + "W": group_input.outputs["Seed"], + "Scale": multiply, + "Detail": 15.0000, + "Roughness": 0.4000, + "Distortion": 0.1000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + mapping = nw.new_node( + Nodes.Mapping, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "Scale": (1.0000, 1.0000, 20.0000), + }, + ) + + noise_texture_1 = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": 0.1000, + "Detail": 15.0000, + "Roughness": 0.0000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={0: 0.2000, 6: mapping, 7: noise_texture_1.outputs["Color"]}, + attrs={"data_type": "RGBA"}, + ) + + noise_texture = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": mix.outputs[2], + "W": group_input.outputs["Seed"], + "Scale": multiply, + "Detail": 15.0000, + "Roughness": 0.6000, + "Distortion": 0.1000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: 1.0000, + 6: noise_texture_2.outputs["Fac"], + 7: noise_texture.outputs["Fac"], + }, + attrs={"blend_type": "DARKEN", "data_type": "RGBA"}, + ) + + map_range = nw.new_node( + Nodes.MapRange, + input_kwargs={"Value": mix_1, 1: 0.4000, 2: 0.6000, 3: 0.8000, 4: 1.2000}, + ) + + hue_saturation_value = nw.new_node( + "ShaderNodeHueSaturation", + input_kwargs={ + "Value": map_range.outputs["Result"], + "Color": group_input.outputs["Base Color"], + }, + ) + + map_range_1 = nw.new_node( + Nodes.MapRange, + input_kwargs={"Value": mix_1, 1: 0.4000, 2: 0.6000, 3: 0.2000, 4: 0.3000}, + ) + + principled_bsdf = nw.new_node( + Nodes.PrincipledBSDF, + input_kwargs={ + "Base Color": hue_saturation_value, + "Metallic": 1.0000, + "Specular": 0.0000, + "Roughness": map_range_1.outputs["Result"], + }, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"BSDF": principled_bsdf, "tmp_viewer": principled_bsdf}, + attrs={"is_active_output": True}, + ) + + +def shader_brushed_metal( + nw: NodeWrangler, scale=1.0, base_color=None, seed=None, **kwargs +): + # Code generated using version 2.6.4 of the node_transpiler + if seed is None: + seed = uniform(-1000.0, 1000.0) + if base_color is None: + from infinigen.assets.materials.metal import sample_metal_color + + base_color = sample_metal_color(**kwargs) + + group = nw.new_node( + nodegroup_brushed_metal().name, + input_kwargs={"Base Color": base_color, "Scale": scale, "Seed": seed}, + ) + + material_output = nw.new_node( + Nodes.MaterialOutput, + input_kwargs={"Surface": group.outputs["BSDF"]}, + attrs={"is_active_output": True}, + ) + + +def apply(obj, selection=None, **kwargs): + surface.add_material( + obj, shader_brushed_metal, selection=selection, input_kwargs=kwargs + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/galvanized_metal.py b/InternScenes/InternScenes_Real2Sim/materials/metal/galvanized_metal.py new file mode 100644 index 0000000000000000000000000000000000000000..ffcdb57448bcb1eb070170522d63926dae18ea13 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/metal/galvanized_metal.py @@ -0,0 +1,122 @@ +# Copyright (C) 2024, Princeton University. +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree. + +# Authors: Yiming Zuo +# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=ECl2pQ1jQm8 by Ryan King Art + +from numpy.random import uniform + +from infinigen.assets.materials import common +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + + +@node_utils.to_nodegroup( + "nodegroup_galvanized_metal", singleton=False, type="ShaderNodeTree" +) +def nodegroup_galvanized_metal(nw: NodeWrangler): + # Code generated using version 2.6.4 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)), + ("NodeSocketFloat", "Scale", 0.0000), + ("NodeSocketFloat", "Seed", 0.0000), + ], + ) + + texture_coordinate = nw.new_node(Nodes.TextureCoord) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 5.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": multiply, + "Detail": 15.0000, + "Roughness": 0.4000, + "Distortion": 0.2000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: 0.0500, + 6: texture_coordinate.outputs["Object"], + 7: noise_texture.outputs["Color"], + }, + attrs={"clamp_factor": False, "data_type": "RGBA"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 500.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + voronoi_texture = nw.new_node( + Nodes.VoronoiTexture, + input_kwargs={ + "Vector": mix.outputs[2], + "W": group_input.outputs["Seed"], + "Scale": multiply_1, + }, + attrs={"distance": "MINKOWSKI", "voronoi_dimensions": "4D"}, + ) + + map_range = nw.new_node( + Nodes.MapRange, + input_kwargs={"Value": voronoi_texture.outputs["Color"], 3: 0.1000, 4: 0.5000}, + ) + + principled_bsdf = nw.new_node( + Nodes.PrincipledBSDF, + input_kwargs={ + "Base Color": group_input.outputs["Base Color"], + "Metallic": 1.0000, + "Specular": 0.0000, + "Roughness": map_range.outputs["Result"], + }, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"BSDF": principled_bsdf}, + attrs={"is_active_output": True}, + ) + + +def shader_galvanized_metal( + nw: NodeWrangler, scale=1.0, base_color=None, seed=None, **kwargs +): + # Code generated using version 2.6.4 of the node_transpiler + if seed is None: + seed = uniform(-1000.0, 1000.0) + if base_color is None: + from infinigen.assets.materials.metal import sample_metal_color + + base_color = sample_metal_color(**kwargs) + + group = nw.new_node( + nodegroup_galvanized_metal().name, + input_kwargs={"Base Color": base_color, "Scale": scale, "Seed": seed}, + ) + + material_output = nw.new_node( + Nodes.MaterialOutput, + input_kwargs={"Surface": group}, + attrs={"is_active_output": True}, + ) + + +def apply(obj, selection=None, **kwargs): + common.apply(obj, shader_galvanized_metal, selection=selection, **kwargs) diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/grained_and_polished_metal.py b/InternScenes/InternScenes_Real2Sim/materials/metal/grained_and_polished_metal.py new file mode 100644 index 0000000000000000000000000000000000000000..73e0dea0f148e041d47404585acce1080bdf483c --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/metal/grained_and_polished_metal.py @@ -0,0 +1,127 @@ +# Copyright (C) 2024, Princeton University. +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree. + +# Authors: Yiming Zuo + +from numpy.random import uniform + +from infinigen.core import surface +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + + +@node_utils.to_nodegroup( + "nodegroup_grained_metal", singleton=False, type="ShaderNodeTree" +) +def nodegroup_grained_metal(nw: NodeWrangler): + # Code generated using version 2.6.4 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)), + ("NodeSocketFloat", "Scale", 5.0000), + ("NodeSocketFloat", "Seed", 0.0000), + ("NodeSocketFloat", "Roughness", 0.0000), + ], + ) + + map_range = nw.new_node( + Nodes.MapRange, + input_kwargs={"Value": group_input.outputs["Roughness"], 3: 0.0500, 4: 0.2500}, + ) + + principled_bsdf = nw.new_node( + Nodes.PrincipledBSDF, + input_kwargs={ + "Base Color": group_input.outputs["Base Color"], + "Metallic": 1.0000, + "Specular": 0.0000, + "Roughness": map_range.outputs["Result"], + }, + ) + + texture_coordinate = nw.new_node(Nodes.TextureCoord) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 2000.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": multiply, + "Detail": 15.0000, + "Distortion": 2.0000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: map_range.outputs["Result"], 1: 0.4000}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: noise_texture.outputs["Fac"], 1: multiply_1}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_2, 1: 0.010}, + attrs={"operation": "MULTIPLY"}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"BSDF": principled_bsdf, "Displacement": multiply_3}, + attrs={"is_active_output": True}, + ) + + +def shader_grained_metal( + nw: NodeWrangler, scale=1.0, base_color=None, roughness=None, seed=None, **kwargs +): + # Code generated using version 2.6.4 of the node_transpiler + if roughness is None: + roughness = uniform(0.0, 1.0) + if seed is None: + seed = uniform(-1000.0, 1000.0) + if base_color is None: + from infinigen.assets.materials.metal import sample_metal_color + + base_color = sample_metal_color(**kwargs) + + group = nw.new_node( + nodegroup_grained_metal().name, + input_kwargs={ + "Base Color": base_color, + "Scale": scale, + "Seed": seed, + "Roughness": roughness, + }, + ) + + displacement = nw.new_node( + "ShaderNodeDisplacement", + input_kwargs={"Height": group.outputs["Displacement"], "Midlevel": 0.0000}, + ) + + material_output = nw.new_node( + Nodes.MaterialOutput, + input_kwargs={"Surface": group.outputs["BSDF"], "Displacement": displacement}, + attrs={"is_active_output": True}, + ) + + +def apply(obj, selection=None, **kwargs): + surface.add_material( + obj, shader_grained_metal, selection=selection, input_kwargs=kwargs + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/metal/hammered_metal.py b/InternScenes/InternScenes_Real2Sim/materials/metal/hammered_metal.py new file mode 100644 index 0000000000000000000000000000000000000000..e7e329e542f420b75475af63995bad176d1d27b1 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/metal/hammered_metal.py @@ -0,0 +1,153 @@ +# Copyright (C) 2024, Princeton University. +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree. + +# Authors: Yiming Zuo +# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=82smQvoh0GE by Mix CG Arts + +from numpy.random import uniform + +from infinigen.core import surface +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler +from infinigen.core.util.random import log_uniform + + +@node_utils.to_nodegroup( + "nodegroup_hammered_metal", singleton=False, type="ShaderNodeTree" +) +def nodegroup_hammered_metal(nw: NodeWrangler): + # Code generated using version 2.6.4 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)), + ("NodeSocketFloat", "Scale", 0.0000), + ("NodeSocketFloat", "Seed", 0.0000), + ], + ) + + principled_bsdf = nw.new_node( + Nodes.PrincipledBSDF, + input_kwargs={ + "Base Color": group_input.outputs["Base Color"], + "Metallic": 1.0000, + "Specular": 0.0000, + "Roughness": 0.1000, + }, + ) + + texture_coordinate = nw.new_node(Nodes.TextureCoord) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 20.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": multiply, + "Detail": 15.0000, + "Roughness": 0.4000, + "Distortion": 0.2000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: 0.0100, + 6: texture_coordinate.outputs["Object"], + 7: noise_texture.outputs["Color"], + }, + attrs={"clamp_factor": False, "data_type": "RGBA"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 300.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + voronoi_texture_1 = nw.new_node( + Nodes.VoronoiTexture, + input_kwargs={ + "Vector": mix.outputs[2], + "W": group_input.outputs["Seed"], + "Scale": multiply_1, + "Smoothness": 0.2000, + }, + attrs={"voronoi_dimensions": "4D", "feature": "SMOOTH_F1"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: voronoi_texture_1.outputs["Distance"], + 1: group_input.outputs["Scale"], + }, + attrs={"operation": "MULTIPLY"}, + ) + + power = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_2, 1: 2.5000}, + attrs={"operation": "POWER"}, + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: power, 1: log_uniform(0.001, 0.003)}, + attrs={"operation": "MULTIPLY"}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "BSDF": principled_bsdf, + "Displacement": multiply_3, + "tmp_viewer": voronoi_texture_1.outputs["Color"], + }, + attrs={"is_active_output": True}, + ) + + +def shader_hammered_metal( + nw: NodeWrangler, scale=None, base_color=None, seed=None, **kwargs +): + # Code generated using version 2.6.4 of the node_transpiler + if seed is None: + seed = uniform(-1000.0, 1000.0) + if base_color is None: + from infinigen.assets.materials.metal import sample_metal_color + + base_color = sample_metal_color(**kwargs) + if scale is None: + scale = log_uniform(0.8, 1.2) + + group = nw.new_node( + nodegroup_hammered_metal().name, + input_kwargs={"Base Color": base_color, "Scale": scale, "Seed": seed}, + ) + + displacement = nw.new_node( + "ShaderNodeDisplacement", + input_kwargs={"Height": group.outputs["Displacement"], "Midlevel": 0.0000}, + ) + + material_output = nw.new_node( + Nodes.MaterialOutput, + input_kwargs={"Surface": group.outputs["BSDF"], "Displacement": displacement}, + attrs={"is_active_output": True}, + ) + + +def apply(obj, selection=None, **kwargs): + surface.add_material( + obj, shader_hammered_metal, selection=selection, input_kwargs=kwargs + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/plastics/__pycache__/plastic_rough.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/plastics/__pycache__/plastic_rough.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e85a8646c46e5203c7a467e801c34c53ce8d1a97 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/plastics/__pycache__/plastic_rough.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/plastics/__pycache__/plastic_translucent.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/plastics/__pycache__/plastic_translucent.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2211086c1255f74a9cab529513561f2bba0b917e Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/plastics/__pycache__/plastic_translucent.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/__pycache__/concrete.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/__pycache__/concrete.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bcf23b4bd300b7602375eb657b65597dec94508d Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/__pycache__/concrete.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/concrete.py b/InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/concrete.py new file mode 100644 index 0000000000000000000000000000000000000000..cae4f3c0bb1382362a545e6ea91f4d35b867684f --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/concrete.py @@ -0,0 +1,486 @@ +# Copyright (C) 2024, Princeton University. +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree. + +# Authors: Yiming Zuo +# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=XDqRa0ExDqs by Ryan King Art + + +from numpy.random import uniform + +from infinigen.assets.materials import common +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler +from infinigen.core.util.color import color_category + + +@node_utils.to_nodegroup("nodegroup_crack", singleton=False, type="ShaderNodeTree") +def nodegroup_crack(nw: NodeWrangler): + # Code generated using version 2.6.4 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketFloat", "Seed", 0.0000), + ("NodeSocketFloat", "Amount", 1.0000), + ("NodeSocketFloat", "Scale", 0.0000), + ("NodeSocketFloatFactor", "Snake Crack", 0.3000), + ], + ) + + texture_coordinate_1 = nw.new_node(Nodes.TextureCoord) + + musgrave_texture_2 = nw.new_node( + Nodes.MusgraveTexture, + input_kwargs={ + "Vector": texture_coordinate_1.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": group_input.outputs["Scale"], + "Detail": 15.0000, + "Dimension": 0.2000, + }, + attrs={"musgrave_dimensions": "4D"}, + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"]}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture_2 = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate_1.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": multiply, + "Detail": 15.0000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + voronoi_texture = nw.new_node( + Nodes.VoronoiTexture, + input_kwargs={"Vector": noise_texture_2.outputs["Fac"], "Scale": 1.2000}, + attrs={"feature": "DISTANCE_TO_EDGE"}, + ) + + map_range_4 = nw.new_node( + Nodes.MapRange, + input_kwargs={ + "Value": voronoi_texture.outputs["Distance"], + 2: 0.0200, + 3: 2.0000, + 4: 0.0000, + }, + ) + + mix_7 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Snake Crack"], + 6: musgrave_texture_2, + 7: map_range_4.outputs["Result"], + }, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 0.6000}, + attrs={"operation": "MULTIPLY"}, + ) + + musgrave_texture_3 = nw.new_node( + Nodes.MusgraveTexture, + input_kwargs={ + "Vector": texture_coordinate_1.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": multiply_1, + "Detail": 15.0000, + "Dimension": 1.0000, + }, + attrs={"musgrave_dimensions": "4D"}, + ) + + map_range_2 = nw.new_node( + Nodes.MapRange, + input_kwargs={"Value": group_input.outputs["Amount"], 3: 1.0000, 4: -0.5000}, + ) + + add = nw.new_node( + Nodes.Math, input_kwargs={0: map_range_2.outputs["Result"], 1: 0.1000} + ) + + map_range_1 = nw.new_node( + Nodes.MapRange, + input_kwargs={ + "Value": musgrave_texture_3, + 1: map_range_2.outputs["Result"], + 2: add, + }, + ) + + mix_4 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_7.outputs[2], 7: map_range_1.outputs["Result"]}, + attrs={"blend_type": "DARKEN", "data_type": "RGBA"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Scale"], 1: 0.3000}, + attrs={"operation": "MULTIPLY"}, + ) + + musgrave_texture_4 = nw.new_node( + Nodes.MusgraveTexture, + input_kwargs={ + "Vector": texture_coordinate_1.outputs["Object"], + "W": group_input.outputs["Seed"], + "Scale": multiply_2, + "Detail": 15.0000, + "Dimension": 1.0000, + }, + attrs={"musgrave_dimensions": "4D"}, + ) + + add_1 = nw.new_node( + Nodes.Math, input_kwargs={0: map_range_2.outputs["Result"], 1: 0.1000} + ) + + map_range = nw.new_node( + Nodes.MapRange, + input_kwargs={ + "Value": musgrave_texture_4, + 1: map_range_2.outputs["Result"], + 2: add_1, + }, + ) + + mix_5 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: map_range.outputs["Result"]}, + attrs={"blend_type": "DARKEN", "data_type": "RGBA"}, + ) + + color_ramp = nw.new_node(Nodes.ColorRamp, input_kwargs={"Fac": mix_5.outputs[2]}) + color_ramp.color_ramp.elements[0].position = 0.0000 + color_ramp.color_ramp.elements[0].color = [0.0000, 0.0000, 0.0000, 1.0000] + color_ramp.color_ramp.elements[1].position = 1.0000 + color_ramp.color_ramp.elements[1].color = [1.0000, 1.0000, 1.0000, 1.0000] + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"Color": color_ramp.outputs["Color"]}, + attrs={"is_active_output": True}, + ) + + +@node_utils.to_nodegroup("nodegroup_concrete", singleton=False, type="ShaderNodeTree") +def nodegroup_concrete(nw: NodeWrangler): + # Code generated using version 2.6.4 of the node_transpiler + + group_input_1 = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)), + ("NodeSocketFloat", "Scale", 0.0000), + ("NodeSocketFloat", "Seed", 0.0000), + ("NodeSocketFloat", "Roughness", 0.0000), + ("NodeSocketFloat", "Crack Amount", 0.0000), + ("NodeSocketFloat", "Crack Scale", 0.0000), + ("NodeSocketFloatFactor", "Snake Crack", 0.3000), + ], + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Scale"], 1: 10.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply, 1: group_input_1.outputs["Crack Scale"]}, + attrs={"operation": "MULTIPLY"}, + ) + + group = nw.new_node( + nodegroup_crack().name, + input_kwargs={ + "Seed": group_input_1.outputs["Seed"], + "Amount": group_input_1.outputs["Crack Amount"], + "Scale": multiply_1, + "Snake Crack": group_input_1.outputs["Snake Crack"], + }, + ) + + map_range_3 = nw.new_node(Nodes.MapRange, input_kwargs={"Value": group}) + + texture_coordinate = nw.new_node(Nodes.TextureCoord) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Scale"], 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture_1 = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input_1.outputs["Seed"], + "Scale": multiply_2, + "Detail": 15.0000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Scale"], 1: 5.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + musgrave_texture_1 = nw.new_node( + Nodes.MusgraveTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input_1.outputs["Seed"], + "Scale": multiply_3, + "Detail": 15.0000, + "Dimension": 1.0000, + "Lacunarity": 3.0000, + }, + attrs={"musgrave_dimensions": "4D"}, + ) + + mix_2 = nw.new_node( + Nodes.Mix, input_kwargs={6: musgrave_texture_1}, attrs={"data_type": "RGBA"} + ) + + hue_saturation_value_1 = nw.new_node( + "ShaderNodeHueSaturation", + input_kwargs={"Value": 0.6000, "Color": group_input_1.outputs["Base Color"]}, + ) + + multiply_4 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Scale"], 1: 20.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + noise_texture = nw.new_node( + Nodes.NoiseTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input_1.outputs["Seed"], + "Scale": multiply_4, + "Detail": 15.0000, + "Distortion": 0.2000, + }, + attrs={"noise_dimensions": "4D"}, + ) + + multiply_5 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Scale"], 1: 20.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + musgrave_texture = nw.new_node( + Nodes.MusgraveTexture, + input_kwargs={ + "Vector": texture_coordinate.outputs["Object"], + "W": group_input_1.outputs["Seed"], + "Scale": multiply_5, + "Detail": 15.0000, + "Dimension": 0.2000, + }, + attrs={"musgrave_dimensions": "4D"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={6: noise_texture.outputs["Fac"], 7: musgrave_texture}, + attrs={"data_type": "RGBA"}, + ) + + hue_saturation_value = nw.new_node( + "ShaderNodeHueSaturation", + input_kwargs={"Value": 1.4000, "Color": group_input_1.outputs["Base Color"]}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: mix.outputs[2], + 6: group_input_1.outputs["Base Color"], + 7: hue_saturation_value, + }, + attrs={"data_type": "RGBA"}, + ) + + mix_3 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: mix_2.outputs[2], + 6: hue_saturation_value_1, + 7: mix_1.outputs[2], + }, + attrs={"data_type": "RGBA"}, + ) + + hue_saturation_value_2 = nw.new_node( + "ShaderNodeHueSaturation", + input_kwargs={ + "Value": noise_texture_1.outputs["Fac"], + "Fac": 0.2000, + "Color": mix_3.outputs[2], + }, + ) + + hue_saturation_value_3 = nw.new_node( + "ShaderNodeHueSaturation", + input_kwargs={"Value": 0.2000, "Color": group_input_1.outputs["Base Color"]}, + ) + + mix_6 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: map_range_3.outputs["Result"], + 6: hue_saturation_value_2, + 7: hue_saturation_value_3, + }, + attrs={"data_type": "RGBA"}, + ) + + principled_bsdf = nw.new_node( + Nodes.PrincipledBSDF, + input_kwargs={ + "Base Color": mix_6.outputs[2], + "Roughness": group_input_1.outputs["Roughness"], + }, + ) + + multiply_6 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Crack Amount"], 1: 0.6000}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_7 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_1, 1: 5.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + group_1 = nw.new_node( + nodegroup_crack().name, + input_kwargs={ + "Seed": group_input_1.outputs["Seed"], + "Amount": multiply_6, + "Scale": multiply_7, + }, + ) + + multiply_8 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input_1.outputs["Roughness"], 1: 1.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_9 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_1, 1: multiply_8}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_10 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_8, 1: group}, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_9, 1: multiply_10}) + + value = nw.new_node(Nodes.Value) + value.outputs[0].default_value = 0.3000 + + multiply_11 = nw.new_node( + Nodes.Math, + input_kwargs={0: value, 1: group_input_1.outputs["Roughness"]}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_12 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_11, 1: mix_1.outputs[2]}, + attrs={"operation": "MULTIPLY"}, + ) + + add_1 = nw.new_node(Nodes.Math, input_kwargs={0: add, 1: multiply_12}) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"BSDF": principled_bsdf, "Displacement": add_1}, + attrs={"is_active_output": True}, + ) + + +def shader_concrete( + nw: NodeWrangler, + scale=1.0, + base_color=None, + seed=None, + roughness=None, + crack_amount=None, + crack_scale=None, + snake_crack=None, + **kwargs, +): + # Code generated using version 2.6.4 of the node_transpiler + if seed is None: + seed = uniform(-1000.0, 1000.0) + if roughness is None: + roughness = uniform(0.5, 1.0) + if crack_amount is None: + crack_amount = uniform(0.2, 0.8) + if crack_scale is None: + crack_scale = uniform(1.0, 3.0) + if snake_crack is None: + snake_crack = uniform(0.0, 1.0) + if base_color is None: + base_color = color_category("concrete") + + group = nw.new_node( + nodegroup_concrete().name, + input_kwargs={ + "Base Color": base_color, + "Scale": scale, + "Seed": seed, + "Roughness": roughness, + "Crack Amount": crack_amount, + "Crack Scale": crack_scale, + "Snake Crack": snake_crack, + }, + ) + + displacement_1 = nw.new_node( + "ShaderNodeDisplacement", + input_kwargs={ + "Height": group.outputs["Displacement"], + "Midlevel": 0.0000, + "Scale": 0.0500, + }, + ) + + material_output = nw.new_node( + Nodes.MaterialOutput, + input_kwargs={"Surface": group.outputs["BSDF"], "Displacement": displacement_1}, + attrs={"is_active_output": True}, + ) + + +def apply(obj, selection=None, **kwargs): + common.apply(obj, shader_concrete, selection=selection, **kwargs) diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/advanced_tiles.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/advanced_tiles.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55114d0bde02f4d41bc95e4a84e7d6922c3cccbf Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/advanced_tiles.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/basket_weave.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/basket_weave.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8e9b25af96a134589366e1b1fa2e507246dada9 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/basket_weave.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/brick.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/brick.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ba076062bebfbd2a76afa2929327c675872767c Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/brick.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/cheveron.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/cheveron.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe392aff31f8dbef5d5c2082a5be8a061f8c18ed Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/cheveron.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/diamond.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/diamond.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9bbe769c2591aeb597637252132b53fe358c2387 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/diamond.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/herringbone.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/herringbone.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..911453d19b993872b35fcf947a62f132f7022e04 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/herringbone.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/hexagon.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/hexagon.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..842590afe407f9ffcb5d814c486d121b009dc6e0 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/hexagon.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/shell.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/shell.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..090e46568401ab692bdf95e946130c5bcd5ceb87 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/shell.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/spanish_bound.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/spanish_bound.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef438fba431dbfb2110ec35af5713215f355e278 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/spanish_bound.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/star.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/star.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eb2a75e74a071a2bac84c1a68ea42bc89518ff8c Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/star.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/triangle.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/triangle.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca533742b2563ff848b8a1577dd255592fe80aef Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/triangle.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/utils.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7b09fd61675473881abdc59fff923b542368124 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/tiles/__pycache__/utils.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/cheveron.py b/InternScenes/InternScenes_Real2Sim/materials/tiles/cheveron.py new file mode 100644 index 0000000000000000000000000000000000000000..e7994bc150a93b386b5184c84ddd1226e0b2b9ef --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/tiles/cheveron.py @@ -0,0 +1,209 @@ +# Copyright (C) 2024, Princeton University. + +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory +# of this source tree. + +# Authors: Yiming Zuo + +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + +from .utils import nodegroup_scalar_positive_modulo + + +@node_utils.to_nodegroup("nodegroup_cheveron", singleton=False, type="ShaderNodeTree") +def nodegroup_cheveron(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Subtiles Number", 1.0000), + ("NodeSocketFloat", "Aspect Ratio", 5.0000), + ("NodeSocketFloatFactor", "border", 0.1000), + ("NodeSocketFloatFactor", "Flatness", 0.9000), + ], + ) + + reroute_1 = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Aspect Ratio"]} + ) + + brick_width = nw.new_node(Nodes.Value, label="Brick Width") + brick_width.outputs[0].default_value = 1.0000 + + combine_xyz = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": reroute_1, "Y": brick_width} + ) + + scale = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz, "Scale": 0.5000}, + attrs={"operation": "SCALE"}, + ) + + reroute = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": scale.outputs["Vector"]} + ) + + separate_xyz = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]} + ) + + group_1 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: separate_xyz.outputs["X"], 1: reroute_1}, + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_1, 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + subtract = nw.new_node( + Nodes.Math, + input_kwargs={0: reroute_1, 1: multiply}, + attrs={"operation": "SUBTRACT"}, + ) + + snap = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["X"], 1: reroute_1}, + attrs={"operation": "SNAP"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: reroute_1, 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + group_2 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap, 1: multiply_1} + ) + + greater_than = nw.new_node( + Nodes.Math, input_kwargs={0: group_2}, attrs={"operation": "GREATER_THAN"} + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: subtract, 1: greater_than}, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_2, 1: group_1}) + + rot_amount = nw.new_node(Nodes.Value, label="rot amount") + rot_amount.outputs[0].default_value = 1.0000 + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: add, 1: rot_amount}, + attrs={"operation": "MULTIPLY"}, + ) + + add_1 = nw.new_node( + Nodes.Math, input_kwargs={0: separate_xyz.outputs["Y"], 1: multiply_3} + ) + + group = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: add_1, 1: brick_width} + ) + + combine_xyz_1 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": group_1, "Y": group} + ) + + subtract_1 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz_1, 1: reroute}, + attrs={"operation": "SUBTRACT"}, + ) + + absolute = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: subtract_1.outputs["Vector"]}, + attrs={"operation": "ABSOLUTE"}, + ) + + subtract_2 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: reroute, 1: absolute.outputs["Vector"]}, + attrs={"operation": "SUBTRACT"}, + ) + + separate_xyz_1 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": subtract_2.outputs["Vector"]} + ) + + smooth_min = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_1.outputs["X"], + 1: separate_xyz_1.outputs["Y"], + 2: 0.1000, + }, + attrs={"operation": "SMOOTH_MIN"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={0: group_input.outputs["border"], 6: smooth_min}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Flatness"], + 6: mix.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + snap_1 = nw.new_node( + Nodes.Math, input_kwargs={0: add_1, 1: brick_width}, attrs={"operation": "SNAP"} + ) + + snap_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["X"], 1: reroute_1}, + attrs={"operation": "SNAP"}, + ) + + combine_xyz_3 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap_2} + ) + + white_noise_texture = nw.new_node( + Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz_3} + ) + + snap_3 = nw.new_node( + Nodes.Math, input_kwargs={0: add_1, 1: brick_width}, attrs={"operation": "SNAP"} + ) + + multiply_4 = nw.new_node( + Nodes.Math, + input_kwargs={0: brick_width, 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + group_3 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_3, 1: multiply_4} + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "Result": mix_1.outputs[2], + "Tile Color": white_noise_texture.outputs["Color"], + "Tile Type 1": greater_than, + "Tile Type 2": group_3, + }, + attrs={"is_active_output": True}, + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/diamond.py b/InternScenes/InternScenes_Real2Sim/materials/tiles/diamond.py new file mode 100644 index 0000000000000000000000000000000000000000..f6c6061e8ceb2b16477ef3d7f0e61231a5122f2a --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/tiles/diamond.py @@ -0,0 +1,441 @@ +# Copyright (C) 2024, Princeton University. + +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory +# of this source tree. + +# Authors: Yiming Zuo + +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + +from .utils import nodegroup_scalar_positive_modulo + + +@node_utils.to_nodegroup( + "nodegroup_diamond_single", singleton=False, type="ShaderNodeTree" +) +def nodegroup_diamond_single(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + value_1 = nw.new_node(Nodes.Value) + value_1.outputs[0].default_value = 0.7070 + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Width", 0.0000), + ], + ) + + separate_xyz = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]} + ) + + reroute = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Width"]} + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: reroute, 1: 1.5000}, + attrs={"operation": "MULTIPLY"}, + ) + + snap = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["Y"], 1: multiply}, + attrs={"operation": "SNAP"}, + ) + + divide = nw.new_node( + Nodes.Math, input_kwargs={0: snap, 1: multiply}, attrs={"operation": "DIVIDE"} + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Width"], 1: 0.8660}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: divide, 1: multiply_1}, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node( + Nodes.Math, input_kwargs={0: separate_xyz.outputs["X"], 1: multiply_2} + ) + + combine_xyz_2 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": add, "Y": separate_xyz.outputs["Y"]} + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: reroute, 1: 1.7321}, + attrs={"operation": "MULTIPLY"}, + ) + + combine_xyz = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": multiply_3, "Y": reroute} + ) + + separate_xyz_1 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": combine_xyz} + ) + + snap_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: add, 1: separate_xyz_1.outputs["X"]}, + attrs={"operation": "SNAP"}, + ) + + combine_xyz_1 = nw.new_node(Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap}) + + subtract = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz_2, 1: combine_xyz_1}, + attrs={"operation": "SUBTRACT"}, + ) + + scale = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz, "Scale": 0.5000}, + attrs={"operation": "SCALE"}, + ) + + subtract_1 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: subtract.outputs["Vector"], 1: scale.outputs["Vector"]}, + attrs={"operation": "SUBTRACT"}, + ) + + value_3 = nw.new_node(Nodes.Value) + value_3.outputs[0].default_value = 1.0000 + + divide_1 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: value_3, 1: scale.outputs["Vector"]}, + attrs={"operation": "DIVIDE"}, + ) + + multiply_4 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: subtract_1.outputs["Vector"], 1: divide_1.outputs["Vector"]}, + attrs={"operation": "MULTIPLY"}, + ) + + vector_rotate = nw.new_node( + Nodes.VectorRotate, + input_kwargs={"Vector": multiply_4.outputs["Vector"], "Angle": 0.7854}, + ) + + absolute = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: vector_rotate}, + attrs={"operation": "ABSOLUTE"}, + ) + + subtract_2 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: value_1, 1: absolute.outputs["Vector"]}, + attrs={"operation": "SUBTRACT"}, + ) + + white_noise_texture = nw.new_node( + Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz_1} + ) + + divide_2 = nw.new_node( + Nodes.Math, input_kwargs={0: snap, 1: multiply}, attrs={"operation": "DIVIDE"} + ) + + group_1 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide_2, 1: 2.0000} + ) + + greater_than = nw.new_node( + Nodes.Math, input_kwargs={0: group_1}, attrs={"operation": "GREATER_THAN"} + ) + + divide_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: snap_1, 1: separate_xyz_1.outputs["X"]}, + attrs={"operation": "DIVIDE"}, + ) + + group = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide_3, 1: 2.0000} + ) + + greater_than_1 = nw.new_node( + Nodes.Math, input_kwargs={0: group}, attrs={"operation": "GREATER_THAN"} + ) + + multiply_5 = nw.new_node( + Nodes.Math, + input_kwargs={0: greater_than, 1: greater_than_1}, + attrs={"operation": "MULTIPLY"}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "UV": subtract_2.outputs["Vector"], + "Color": white_noise_texture.outputs["Color"], + "Value": multiply_5, + }, + attrs={"is_active_output": True}, + ) + + +@node_utils.to_nodegroup("nodegroup_diamond", singleton=False, type="ShaderNodeTree") +def nodegroup_diamond(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Subtiles Number", 1.0000), + ("NodeSocketFloat", "Aspect Ratio", 5.0000), + ("NodeSocketFloatFactor", "border", 0.1000), + ("NodeSocketFloatFactor", "Flatness", 0.9000), + ], + ) + + reroute_1 = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Flatness"]} + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["border"], 1: 1.5000}, + attrs={"operation": "MULTIPLY"}, + ) + + reroute = nw.new_node(Nodes.Reroute, input_kwargs={"Input": multiply}) + + value = nw.new_node(Nodes.Value) + value.outputs[0].default_value = 0.5000 + + mapping = nw.new_node( + Nodes.Mapping, + input_kwargs={"Vector": group_input.outputs["Coordinate"], "Scale": value}, + ) + + value_1 = nw.new_node(Nodes.Value) + value_1.outputs[0].default_value = 1.0000 + + group = nw.new_node( + nodegroup_diamond_single().name, + input_kwargs={"Coordinate": mapping, "Width": value_1}, + ) + + separate_xyz_3 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group.outputs["UV"]} + ) + + value_3 = nw.new_node(Nodes.Value) + value_3.outputs[0].default_value = 0.0000 + + smooth_min = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_3.outputs["X"], + 1: separate_xyz_3.outputs["Y"], + 2: value_3, + }, + attrs={"operation": "SMOOTH_MIN"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: smooth_min}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: reroute_1, + 6: mix.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, input_kwargs={0: value_1}, attrs={"operation": "MULTIPLY"} + ) + + combine_xyz = nw.new_node(Nodes.CombineXYZ, input_kwargs={"Y": multiply_1}) + + vector_rotate = nw.new_node( + Nodes.VectorRotate, + input_kwargs={"Vector": mapping, "Center": combine_xyz, "Angle": -2.0944}, + ) + + group_1 = nw.new_node( + nodegroup_diamond_single().name, + input_kwargs={"Coordinate": vector_rotate, "Width": value_1}, + ) + + separate_xyz_4 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_1.outputs["UV"]} + ) + + smooth_min_1 = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_4.outputs["X"], + 1: separate_xyz_4.outputs["Y"], + 2: value_3, + }, + attrs={"operation": "SMOOTH_MIN"}, + ) + + mix_2 = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: smooth_min_1}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_3 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: reroute_1, + 6: mix_2.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + mix_4 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: mix_3.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + vector_rotate_1 = nw.new_node( + Nodes.VectorRotate, + input_kwargs={"Vector": mapping, "Center": combine_xyz, "Angle": 2.0944}, + ) + + group_2 = nw.new_node( + nodegroup_diamond_single().name, + input_kwargs={"Coordinate": vector_rotate_1, "Width": value_1}, + ) + + separate_xyz_5 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_2.outputs["UV"]} + ) + + smooth_min_2 = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_5.outputs["X"], + 1: separate_xyz_5.outputs["Y"], + 2: value_3, + }, + attrs={"operation": "SMOOTH_MIN"}, + ) + + mix_5 = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: smooth_min_2}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_6 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: reroute_1, + 6: mix_5.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + mix_7 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: mix_6.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + mix_8 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: group.outputs["Color"]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_9 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: group_1.outputs["Color"], 7: mix_3.outputs[2]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_11 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_8.outputs[2], 7: mix_9.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + mix_10 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_6.outputs[2], 7: group_2.outputs["Color"]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_12 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_11.outputs[2], 7: mix_10.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + greater_than = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_1.outputs[2], 1: 0.0000}, + attrs={"operation": "GREATER_THAN"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_6.outputs[2], 1: group_2.outputs["Value"]}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: group.outputs["Value"], 1: mix_1.outputs[2]}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_4 = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_3.outputs[2], 1: group_1.outputs["Value"]}, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_3, 1: multiply_4}) + + add_1 = nw.new_node(Nodes.Math, input_kwargs={0: multiply_2, 1: add}) + + greater_than_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: add_1, 1: 0.0000}, + attrs={"operation": "GREATER_THAN"}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "Result": mix_7.outputs[2], + "Tile Color": mix_12.outputs[2], + "Tile Type 1": greater_than, + "Tile Type 2": greater_than_1, + }, + attrs={"is_active_output": True}, + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/herringbone.py b/InternScenes/InternScenes_Real2Sim/materials/tiles/herringbone.py new file mode 100644 index 0000000000000000000000000000000000000000..e4a0ae1649244b4283dac31cba344df1bb99debf --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/tiles/herringbone.py @@ -0,0 +1,350 @@ +# Copyright (C) 2024, Princeton University. + +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory +# of this source tree. + +# Authors: Yiming Zuo + +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + +from .utils import nodegroup_scalar_positive_modulo + + +@node_utils.to_nodegroup("nodegroup_mix", singleton=False, type="ShaderNodeTree") +def nodegroup_mix(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketFloat", "Mask", 0.0000), + ("NodeSocketVector", "Vector 1", (0.0000, 0.0000, 0.0000)), + ("NodeSocketVector", "Vector 2", (0.0000, 0.0000, 0.0000)), + ], + ) + + subtract = nw.new_node( + Nodes.Math, + input_kwargs={0: 1.0000, 1: group_input.outputs["Mask"]}, + attrs={"operation": "SUBTRACT"}, + ) + + multiply = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: group_input.outputs["Vector 2"], 1: subtract}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_1 = nw.new_node( + Nodes.VectorMath, + input_kwargs={ + 0: group_input.outputs["Vector 1"], + 1: group_input.outputs["Mask"], + }, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: multiply.outputs["Vector"], 1: multiply_1.outputs["Vector"]}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"Vector": add.outputs["Vector"]}, + attrs={"is_active_output": True}, + ) + + +@node_utils.to_nodegroup( + "nodegroup_herringbone", singleton=False, type="ShaderNodeTree" +) +def nodegroup_herringbone(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Subtiles Number", 1.0000), + ("NodeSocketFloat", "Aspect Ratio", 5.0000), + ("NodeSocketFloatFactor", "border", 0.1000), + ("NodeSocketFloatFactor", "Flatness", 0.9000), + ], + ) + + reroute_1 = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Aspect Ratio"]} + ) + + brick_width = nw.new_node(Nodes.Value, label="Brick Width") + brick_width.outputs[0].default_value = 1.0000 + + combine_xyz = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": reroute_1, "Y": brick_width} + ) + + scale = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz, "Scale": 0.5000}, + attrs={"operation": "SCALE"}, + ) + + combine_xyz_3 = nw.new_node( + Nodes.CombineXYZ, + input_kwargs={ + "X": 1.0000, + "Y": group_input.outputs["Subtiles Number"], + "Z": 1.0000, + }, + ) + + divide = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: scale.outputs["Vector"], 1: combine_xyz_3}, + attrs={"operation": "DIVIDE"}, + ) + + reroute = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": divide.outputs["Vector"]} + ) + + separate_xyz = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]} + ) + + snap = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["Y"], 1: brick_width}, + attrs={"operation": "SNAP"}, + ) + + subtract = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["X"], 1: snap}, + attrs={"operation": "SUBTRACT"}, + ) + + snap_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: subtract, 1: reroute_1}, + attrs={"operation": "SNAP"}, + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: reroute_1, 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + group_1 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_1, 1: multiply} + ) + + greater_than = nw.new_node( + Nodes.Math, input_kwargs={0: group_1}, attrs={"operation": "GREATER_THAN"} + ) + + group = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: subtract, 1: reroute_1}, + ) + + divide_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: brick_width, 1: group_input.outputs["Subtiles Number"]}, + attrs={"operation": "DIVIDE"}, + ) + + group_3 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: separate_xyz.outputs["Y"], 1: divide_1}, + ) + + combine_xyz_1 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": group, "Y": group_3} + ) + + snap_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["X"], 1: brick_width}, + attrs={"operation": "SNAP"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: snap_2, 1: brick_width}, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_1, 1: brick_width}) + + subtract_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["Y"], 1: add}, + attrs={"operation": "SUBTRACT"}, + ) + + group_2 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: subtract_1, 1: reroute_1}, + ) + + divide_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: brick_width, 1: group_input.outputs["Subtiles Number"]}, + attrs={"operation": "DIVIDE"}, + ) + + group_4 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: separate_xyz.outputs["X"], 1: divide_2}, + ) + + combine_xyz_2 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": group_2, "Y": group_4} + ) + + group_5 = nw.new_node( + nodegroup_mix().name, + input_kwargs={ + "Mask": greater_than, + "Vector 1": combine_xyz_1, + "Vector 2": combine_xyz_2, + }, + ) + + subtract_2 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: group_5, 1: reroute}, + attrs={"operation": "SUBTRACT"}, + ) + + absolute = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: subtract_2.outputs["Vector"]}, + attrs={"operation": "ABSOLUTE"}, + ) + + subtract_3 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: reroute, 1: absolute.outputs["Vector"]}, + attrs={"operation": "SUBTRACT"}, + ) + + separate_xyz_1 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": subtract_3.outputs["Vector"]} + ) + + smooth_min = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_1.outputs["X"], + 1: separate_xyz_1.outputs["Y"], + 2: 0.0000, + }, + attrs={"operation": "SMOOTH_MIN"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={0: group_input.outputs["border"], 6: smooth_min}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Flatness"], + 6: mix.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + snap_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: subtract, 1: reroute_1}, + attrs={"operation": "SNAP"}, + ) + + snap_4 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["Y"], 1: divide_1}, + attrs={"operation": "SNAP"}, + ) + + combine_xyz_6 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": snap_3, "Y": snap_4} + ) + + value = nw.new_node(Nodes.Value) + value.outputs[0].default_value = 0.5000 + + add_1 = nw.new_node(Nodes.VectorMath, input_kwargs={0: combine_xyz_6, 1: value}) + + snap_5 = nw.new_node( + Nodes.Math, + input_kwargs={0: subtract_1, 1: reroute_1}, + attrs={"operation": "SNAP"}, + ) + + snap_6 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz.outputs["X"], 1: divide_2}, + attrs={"operation": "SNAP"}, + ) + + combine_xyz_5 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": snap_5, "Y": snap_6} + ) + + group_6 = nw.new_node( + nodegroup_mix().name, + input_kwargs={ + "Mask": greater_than, + "Vector 1": add_1.outputs["Vector"], + "Vector 2": combine_xyz_5, + }, + ) + + white_noise_texture_1 = nw.new_node( + Nodes.WhiteNoiseTexture, input_kwargs={"Vector": group_6} + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: divide_1, 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + group_9 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_4, 1: multiply_2} + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: divide_2, 1: 2.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + group_7 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_6, 1: multiply_3} + ) + + group_8 = nw.new_node( + nodegroup_mix().name, + input_kwargs={"Mask": greater_than, "Vector 1": group_9, "Vector 2": group_7}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "Result": mix_1.outputs[2], + "Tile Color": white_noise_texture_1.outputs["Color"], + "Tile Type 1": greater_than, + "Tile Type 2": group_8, + }, + attrs={"is_active_output": True}, + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/hexagon.py b/InternScenes/InternScenes_Real2Sim/materials/tiles/hexagon.py new file mode 100644 index 0000000000000000000000000000000000000000..8eb586627e7bb92429d577b2da7764f50279ac80 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/tiles/hexagon.py @@ -0,0 +1,424 @@ +# Copyright (C) 2024, Princeton University. + +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory +# of this source tree. + +# Authors: Yiming Zuo + +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + +from .utils import nodegroup_scalar_positive_modulo + + +@node_utils.to_nodegroup( + "nodegroup_distance_to_axis", singleton=False, type="ShaderNodeTree" +) +def nodegroup_distance_to_axis(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Vector", (0.0000, 0.0000, 0.0000)), + ("NodeSocketVector", "Axis", (0.0000, 0.0000, 0.0000)), + ], + ) + + length = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: group_input.outputs["Vector"]}, + attrs={"operation": "LENGTH"}, + ) + + power = nw.new_node( + Nodes.Math, + input_kwargs={0: length.outputs["Value"], 1: 2.0000}, + attrs={"operation": "POWER"}, + ) + + normalize = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: group_input.outputs["Axis"]}, + attrs={"operation": "NORMALIZE"}, + ) + + dot_product = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: group_input.outputs["Vector"], 1: normalize.outputs["Vector"]}, + attrs={"operation": "DOT_PRODUCT"}, + ) + + power_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: dot_product.outputs["Value"], 1: 2.0000}, + attrs={"operation": "POWER"}, + ) + + subtract = nw.new_node( + Nodes.Math, input_kwargs={0: power, 1: power_1}, attrs={"operation": "SUBTRACT"} + ) + + sqrt = nw.new_node( + Nodes.Math, input_kwargs={0: subtract}, attrs={"operation": "SQRT"} + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={"Distance": sqrt}, + attrs={"is_active_output": True}, + ) + + +@node_utils.to_nodegroup("nodegroup_hex_single", singleton=False, type="ShaderNodeTree") +def nodegroup_hex_single(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Size", 0.5000), + ], + ) + + separate_xyz_3 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]} + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Size"], 1: 1.0000}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Size"], 1: 1.7321}, + attrs={"operation": "MULTIPLY"}, + ) + + combine_xyz_2 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": multiply, "Y": multiply_1} + ) + + separate_xyz_4 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": combine_xyz_2} + ) + + snap = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]}, + attrs={"operation": "SNAP"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, input_kwargs={0: snap, 1: 0.5774}, attrs={"operation": "MULTIPLY"} + ) + + add = nw.new_node( + Nodes.Math, input_kwargs={0: multiply_2, 1: separate_xyz_3.outputs["X"]} + ) + + group_3 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]}, + ) + + group_4 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]}, + ) + + combine_xyz_3 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": group_3, "Y": group_4} + ) + + multiply_3 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz_2, 1: (0.5000, 0.3333, 0.0000)}, + attrs={"operation": "MULTIPLY"}, + ) + + subtract = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz_3, 1: multiply_3.outputs["Vector"]}, + attrs={"operation": "SUBTRACT"}, + ) + + reroute = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": subtract.outputs["Vector"]} + ) + + group = nw.new_node( + nodegroup_distance_to_axis().name, + input_kwargs={"Vector": reroute, "Axis": (0.0000, 1.0000, 0.0000)}, + ) + + group_1 = nw.new_node( + nodegroup_distance_to_axis().name, + input_kwargs={"Vector": reroute, "Axis": (0.8660, -0.5000, 0.0000)}, + ) + + group_2 = nw.new_node( + nodegroup_distance_to_axis().name, + input_kwargs={"Vector": reroute, "Axis": (-0.8660, -0.5000, 0.0000)}, + ) + + combine_xyz_1 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": group, "Y": group_1, "Z": group_2} + ) + + snap_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]}, + attrs={"operation": "SNAP"}, + ) + + snap_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]}, + attrs={"operation": "SNAP"}, + ) + + combine_xyz = nw.new_node(Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap_2}) + + white_noise_texture = nw.new_node( + Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz} + ) + + divide = nw.new_node( + Nodes.Math, + input_kwargs={0: snap_2, 1: separate_xyz_4.outputs["X"]}, + attrs={"operation": "DIVIDE"}, + ) + + group_5 = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide, 1: 2.0000} + ) + + greater_than = nw.new_node( + Nodes.Math, input_kwargs={0: group_5}, attrs={"operation": "GREATER_THAN"} + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "UV": combine_xyz_1, + "Color": white_noise_texture.outputs["Color"], + "Value": greater_than, + }, + attrs={"is_active_output": True}, + ) + + +@node_utils.to_nodegroup("nodegroup_hexagon", singleton=False, type="ShaderNodeTree") +def nodegroup_hexagon(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Subtiles Number", 1.0000), + ("NodeSocketFloat", "Aspect Ratio", 5.0000), + ("NodeSocketFloatFactor", "border", 0.1000), + ("NodeSocketFloatFactor", "Flatness", 0.9000), + ], + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["border"], 1: 0.8660}, + attrs={"operation": "MULTIPLY"}, + ) + + reroute = nw.new_node(Nodes.Reroute, input_kwargs={"Input": multiply}) + + size = nw.new_node(Nodes.Value, label="Size") + size.outputs[0].default_value = 1.0000 + + multiply_1 = nw.new_node( + Nodes.Math, input_kwargs={0: size}, attrs={"operation": "MULTIPLY"} + ) + + value = nw.new_node(Nodes.Value) + value.outputs[0].default_value = 0.5000 + + mapping = nw.new_node( + Nodes.Mapping, + input_kwargs={"Vector": group_input.outputs["Coordinate"], "Scale": value}, + ) + + group_5 = nw.new_node( + nodegroup_hex_single().name, input_kwargs={"Coordinate": mapping, "Size": size} + ) + + separate_xyz_5 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_5.outputs["UV"]} + ) + + value_3 = nw.new_node(Nodes.Value) + value_3.outputs[0].default_value = 0.0000 + + smooth_max = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_5.outputs["X"], + 1: separate_xyz_5.outputs["Y"], + 2: value_3, + }, + attrs={"operation": "SMOOTH_MAX"}, + ) + + smooth_max_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: smooth_max, 1: separate_xyz_5.outputs["Z"], 2: value_3}, + attrs={"operation": "SMOOTH_MAX"}, + ) + + subtract = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_1, 1: smooth_max_1}, + attrs={"operation": "SUBTRACT"}, + ) + + mix = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: subtract}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Flatness"], + 6: mix.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, input_kwargs={0: size}, attrs={"operation": "MULTIPLY"} + ) + + multiply_3 = nw.new_node( + Nodes.Math, input_kwargs={0: size, 1: 0.8660}, attrs={"operation": "MULTIPLY"} + ) + + combine_xyz = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": multiply_2, "Y": multiply_3} + ) + + multiply_4 = nw.new_node( + Nodes.Math, input_kwargs={0: size, 1: 99.0000}, attrs={"operation": "MULTIPLY"} + ) + + combine_xyz_1 = nw.new_node(Nodes.CombineXYZ, input_kwargs={"X": multiply_4}) + + add = nw.new_node(Nodes.VectorMath, input_kwargs={0: combine_xyz, 1: combine_xyz_1}) + + add_1 = nw.new_node( + Nodes.VectorMath, input_kwargs={0: mapping, 1: add.outputs["Vector"]} + ) + + group_6 = nw.new_node( + nodegroup_hex_single().name, + input_kwargs={"Coordinate": add_1.outputs["Vector"], "Size": size}, + ) + + separate_xyz_6 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_6.outputs["UV"]} + ) + + smooth_max_2 = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_6.outputs["X"], + 1: separate_xyz_6.outputs["Y"], + 2: value_3, + }, + attrs={"operation": "SMOOTH_MAX"}, + ) + + smooth_max_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: smooth_max_2, 1: separate_xyz_6.outputs["Z"], 2: value_3}, + attrs={"operation": "SMOOTH_MAX"}, + ) + + subtract_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_1, 1: smooth_max_3}, + attrs={"operation": "SUBTRACT"}, + ) + + mix_3 = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: subtract_1}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_2 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Flatness"], + 6: mix_3.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + mix_4 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: mix_2.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + mix_5 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: group_5.outputs["Color"]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_6 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_2.outputs[2], 7: group_6.outputs["Color"]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_7 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_5.outputs[2], 7: mix_6.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + greater_than = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_1.outputs[2], 1: 0.0000}, + attrs={"operation": "GREATER_THAN"}, + ) + + multiply_5 = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_1.outputs[2], 1: group_5.outputs["Value"]}, + attrs={"operation": "MULTIPLY"}, + ) + + greater_than_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_5, 1: 0.0000}, + attrs={"operation": "GREATER_THAN"}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "Result": mix_4.outputs[2], + "Tile Color": mix_7.outputs[2], + "Tile Type 1": greater_than, + "Tile Type 2": greater_than_1, + }, + attrs={"is_active_output": True}, + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/tiles/triangle.py b/InternScenes/InternScenes_Real2Sim/materials/tiles/triangle.py new file mode 100644 index 0000000000000000000000000000000000000000..602e80c940cfa42100f2c7cbb2442a470ec66e41 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/materials/tiles/triangle.py @@ -0,0 +1,379 @@ +# Copyright (C) 2024, Princeton University. + +# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory +# of this source tree. + +# Authors: Yiming Zuo + +from infinigen.core.nodes import node_utils +from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler + +from .utils import nodegroup_scalar_positive_modulo + + +@node_utils.to_nodegroup( + "nodegroup_triangle_single", singleton=False, type="ShaderNodeTree" +) +def nodegroup_triangle_single(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + value_2 = nw.new_node(Nodes.Value) + value_2.outputs[0].default_value = 0.0000 + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Size", 0.5000), + ], + ) + + separate_xyz_3 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]} + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Size"], 1: 0.8660}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["Size"], 1: 0.7500}, + attrs={"operation": "MULTIPLY"}, + ) + + combine_xyz_2 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": multiply, "Y": multiply_1} + ) + + separate_xyz_4 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": combine_xyz_2} + ) + + snap = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]}, + attrs={"operation": "SNAP"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, input_kwargs={0: snap, 1: 0.5774}, attrs={"operation": "MULTIPLY"} + ) + + add = nw.new_node( + Nodes.Math, input_kwargs={0: multiply_2, 1: separate_xyz_3.outputs["X"]} + ) + + group_3 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]}, + ) + + group_4 = nw.new_node( + nodegroup_scalar_positive_modulo().name, + input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]}, + ) + + combine_xyz_3 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": group_3, "Y": group_4} + ) + + multiply_3 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz_2, 1: (0.5000, 0.3333, 0.0000)}, + attrs={"operation": "MULTIPLY"}, + ) + + subtract = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: combine_xyz_3, 1: multiply_3.outputs["Vector"]}, + attrs={"operation": "SUBTRACT"}, + ) + + reroute = nw.new_node( + Nodes.Reroute, input_kwargs={"Input": subtract.outputs["Vector"]} + ) + + dot_product = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: reroute, 1: (0.0000, 1.0000, 0.0000)}, + attrs={"operation": "DOT_PRODUCT"}, + ) + + dot_product_1 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: reroute, 1: (0.8660, -0.5000, 0.0000)}, + attrs={"operation": "DOT_PRODUCT"}, + ) + + dot_product_2 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: reroute, 1: (-0.8660, -0.5000, 0.0000)}, + attrs={"operation": "DOT_PRODUCT"}, + ) + + combine_xyz = nw.new_node( + Nodes.CombineXYZ, + input_kwargs={ + "X": dot_product.outputs["Value"], + "Y": dot_product_1.outputs["Value"], + "Z": dot_product_2.outputs["Value"], + }, + ) + + subtract_1 = nw.new_node( + Nodes.VectorMath, + input_kwargs={0: value_2, 1: combine_xyz}, + attrs={"operation": "SUBTRACT"}, + ) + + snap_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]}, + attrs={"operation": "SNAP"}, + ) + + snap_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]}, + attrs={"operation": "SNAP"}, + ) + + combine_xyz_1 = nw.new_node( + Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap_2} + ) + + white_noise_texture = nw.new_node( + Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz_1} + ) + + divide = nw.new_node( + Nodes.Math, + input_kwargs={0: snap_2, 1: separate_xyz_4.outputs["X"]}, + attrs={"operation": "DIVIDE"}, + ) + + group = nw.new_node( + nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide, 1: 2.0000} + ) + + greater_than = nw.new_node( + Nodes.Math, input_kwargs={0: group}, attrs={"operation": "GREATER_THAN"} + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "UV": subtract_1.outputs["Vector"], + "Color": white_noise_texture.outputs["Color"], + "Value": greater_than, + }, + attrs={"is_active_output": True}, + ) + + +@node_utils.to_nodegroup("nodegroup_triangle", singleton=False, type="ShaderNodeTree") +def nodegroup_triangle(nw: NodeWrangler): + # Code generated using version 2.6.5 of the node_transpiler + + group_input = nw.new_node( + Nodes.GroupInput, + expose_input=[ + ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)), + ("NodeSocketFloat", "Subtiles Number", 1.0000), + ("NodeSocketFloat", "Aspect Ratio", 5.0000), + ("NodeSocketFloatFactor", "border", 0.1000), + ("NodeSocketFloatFactor", "Flatness", 0.9000), + ], + ) + + multiply = nw.new_node( + Nodes.Math, + input_kwargs={0: group_input.outputs["border"], 1: 0.5774}, + attrs={"operation": "MULTIPLY"}, + ) + + reroute = nw.new_node(Nodes.Reroute, input_kwargs={"Input": multiply}) + + value_6 = nw.new_node(Nodes.Value) + value_6.outputs[0].default_value = 1.0000 + + multiply_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: value_6, 1: 0.2500}, + attrs={"operation": "MULTIPLY"}, + ) + + value = nw.new_node(Nodes.Value) + value.outputs[0].default_value = 0.4330 + + mapping_1 = nw.new_node( + Nodes.Mapping, + input_kwargs={"Vector": group_input.outputs["Coordinate"], "Scale": value}, + ) + + reroute_1 = nw.new_node(Nodes.Reroute, input_kwargs={"Input": mapping_1}) + + group_8 = nw.new_node( + nodegroup_triangle_single().name, + input_kwargs={"Coordinate": reroute_1, "Size": value_6}, + ) + + separate_xyz_5 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_8.outputs["UV"]} + ) + + value_4 = nw.new_node(Nodes.Value) + value_4.outputs[0].default_value = 0.0000 + + smooth_max = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_5.outputs["X"], + 1: separate_xyz_5.outputs["Y"], + 2: value_4, + }, + attrs={"operation": "SMOOTH_MAX"}, + ) + + smooth_max_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: smooth_max, 1: separate_xyz_5.outputs["Z"], 2: value_4}, + attrs={"operation": "SMOOTH_MAX"}, + ) + + subtract = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_1, 1: smooth_max_1}, + attrs={"operation": "SUBTRACT"}, + ) + + mix_1 = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: subtract}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_4 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Flatness"], + 6: mix_1.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + vector_rotate = nw.new_node( + Nodes.VectorRotate, input_kwargs={"Vector": reroute_1, "Angle": 3.1416} + ) + + group_7 = nw.new_node( + nodegroup_triangle_single().name, + input_kwargs={"Coordinate": vector_rotate, "Size": value_6}, + ) + + separate_xyz_6 = nw.new_node( + Nodes.SeparateXYZ, input_kwargs={"Vector": group_7.outputs["UV"]} + ) + + smooth_max_2 = nw.new_node( + Nodes.Math, + input_kwargs={ + 0: separate_xyz_6.outputs["X"], + 1: separate_xyz_6.outputs["Y"], + 2: value_4, + }, + attrs={"operation": "SMOOTH_MAX"}, + ) + + smooth_max_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: smooth_max_2, 1: separate_xyz_6.outputs["Z"], 2: value_4}, + attrs={"operation": "SMOOTH_MAX"}, + ) + + subtract_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: multiply_1, 1: smooth_max_3}, + attrs={"operation": "SUBTRACT"}, + ) + + mix_3 = nw.new_node( + Nodes.Mix, + input_kwargs={0: reroute, 6: subtract_1}, + attrs={"blend_type": "BURN", "data_type": "RGBA"}, + ) + + mix_2 = nw.new_node( + Nodes.Mix, + input_kwargs={ + 0: group_input.outputs["Flatness"], + 6: mix_3.outputs[2], + 7: (1.0000, 1.0000, 1.0000, 1.0000), + }, + attrs={"blend_type": "DODGE", "data_type": "RGBA"}, + ) + + mix_5 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: mix_2.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + mix_7 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_2.outputs[2], 7: group_7.outputs["Color"]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_6 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: group_8.outputs["Color"]}, + attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"}, + ) + + mix_8 = nw.new_node( + Nodes.Mix, + input_kwargs={0: 1.0000, 6: mix_7.outputs[2], 7: mix_6.outputs[2]}, + attrs={"blend_type": "ADD", "data_type": "RGBA"}, + ) + + greater_than = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_4.outputs[2], 1: 0.0000}, + attrs={"operation": "GREATER_THAN"}, + ) + + multiply_2 = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_4.outputs[2], 1: group_8.outputs["Value"]}, + attrs={"operation": "MULTIPLY"}, + ) + + multiply_3 = nw.new_node( + Nodes.Math, + input_kwargs={0: mix_2.outputs[2], 1: group_7.outputs["Value"]}, + attrs={"operation": "MULTIPLY"}, + ) + + add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_2, 1: multiply_3}) + + greater_than_1 = nw.new_node( + Nodes.Math, + input_kwargs={0: add, 1: 0.0000}, + attrs={"operation": "GREATER_THAN"}, + ) + + group_output = nw.new_node( + Nodes.GroupOutput, + input_kwargs={ + "Result": mix_5.outputs[2], + "Tile Color": mix_8.outputs[2], + "Tile Type 1": greater_than, + "Tile Type 2": greater_than_1, + }, + attrs={"is_active_output": True}, + ) diff --git a/InternScenes/InternScenes_Real2Sim/materials/utils/__pycache__/__init__.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/utils/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62b93a64138084ab3987d15e2fa4de6c835902e7 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/utils/__pycache__/__init__.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/utils/__pycache__/surface_utils.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/utils/__pycache__/surface_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f79e67e4ecd0c4c764db90a798f7b50821137bd Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/utils/__pycache__/surface_utils.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/wear_tear/__pycache__/procedural_edge_wear.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/wear_tear/__pycache__/procedural_edge_wear.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fccfb8ffabb5bf30fbf5d884cbd9d2f9d5158745 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/wear_tear/__pycache__/procedural_edge_wear.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/wear_tear/__pycache__/procedural_scratch.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/wear_tear/__pycache__/procedural_scratch.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5507357df3cc51528e74645780634c99d2b9550e Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/wear_tear/__pycache__/procedural_scratch.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/composite_wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/composite_wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..666065282e062781f37794323a481b3186dac08c Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/composite_wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/crossed_wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/crossed_wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b33942f29fbc5d9dbe162d01bd19efbb29bf4bf Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/crossed_wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/hexagon_wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/hexagon_wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97fc2f708501b46e56a6e476acb196819f2ca3a6 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/hexagon_wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/non_wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/non_wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41b479e54dd83c0598296a05d3e6e148e50dcccd Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/non_wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/square_wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/square_wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..914777099f7454a5381cdc078e2fb1c70897a301 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/square_wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/staggered_wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/staggered_wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e7ffe49ea0c0dd4a70297fbbfa4fbddbd6826b14 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/staggered_wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/tiled_wood.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/tiled_wood.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b7624a31d9fb19555685b1eb786974e3fd19d15 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/tiled_wood.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51c0230a7b4030379ce6a5dddb6e8886371d678e Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood_old.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood_old.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e1f70aa63fb1dc3ab8974e6237dbb009e3f999e Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood_old.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood_tile.cpython-310.pyc b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood_tile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b3d3479191cec33c418ebd00edbae4adf3cf8926 Binary files /dev/null and b/InternScenes/InternScenes_Real2Sim/materials/woods/__pycache__/wood_tile.cpython-310.pyc differ diff --git a/InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG.blend b/InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG.blend new file mode 100644 index 0000000000000000000000000000000000000000..366f17a8d1c6ee1bbab75c28fddcccbc10f803de --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG.blend @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:667978aa6e7ae8da38c0e52ff06e0d9fbf39fb19adb66994536fb9656c544ec3 +size 1109428 diff --git a/InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG_NormalDX.jpg b/InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG_NormalDX.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c2f069596a8d4798d6eb3ca9b6d98bd8f9085f9 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG_NormalDX.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d560cfb4d32f4049e3263e1c21a42caaad81599525900b04ee6977e5d4ac3ca +size 2134354 diff --git a/InternScenes/InternScenes_Real2Sim/textures/Marble012_1K-JPG_Roughness.jpg b/InternScenes/InternScenes_Real2Sim/textures/Marble012_1K-JPG_Roughness.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8758947e618eb69f1404720c2605d12c09d46652 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/Marble012_1K-JPG_Roughness.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7afd636d6cca0b470549959c514976186df58ac1013016b6c3919910a6d3a04 +size 535814 diff --git a/InternScenes/InternScenes_Real2Sim/textures/Tiles074_1K-JPG.blend b/InternScenes/InternScenes_Real2Sim/textures/Tiles074_1K-JPG.blend new file mode 100644 index 0000000000000000000000000000000000000000..8dff33c25b4165fa9759b3934d83d6d82496cfbb --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/Tiles074_1K-JPG.blend @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:27c3b83d08581ff17e1653525baec637084a97922451cdf7a92a9d1cbe547543 +size 1099412 diff --git a/InternScenes/InternScenes_Real2Sim/textures/Tiles099_1K-JPG_Displacement.jpg b/InternScenes/InternScenes_Real2Sim/textures/Tiles099_1K-JPG_Displacement.jpg new file mode 100644 index 0000000000000000000000000000000000000000..26a4ac91057e969a68461bc5de1535c1e8344e2d --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/Tiles099_1K-JPG_Displacement.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7e7cb8cfdbfc5b85c1ae4abca953915a8432e8e844a2f633c2235e1896ed702 +size 341890 diff --git a/InternScenes/InternScenes_Real2Sim/textures/WoodFloor040_1K-JPG_Roughness.jpg b/InternScenes/InternScenes_Real2Sim/textures/WoodFloor040_1K-JPG_Roughness.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7355f2fb816a8296bd79af8dcfbb2f6d966a4b74 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/WoodFloor040_1K-JPG_Roughness.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a396afced041d372218eaa881ba3157b9105f035826b22cf63cf2b65d82c081 +size 333438 diff --git a/InternScenes/InternScenes_Real2Sim/textures/WoodFloor051.png b/InternScenes/InternScenes_Real2Sim/textures/WoodFloor051.png new file mode 100644 index 0000000000000000000000000000000000000000..8f7a4b27ec8fb23c82c156c85503583fd9b37935 --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/WoodFloor051.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:71de4c616cdef3d1ecfd7ee2ab5708c60f92c5da8b7eefca104c2e287e56f726 +size 265985 diff --git a/InternScenes/InternScenes_Real2Sim/textures/wood_floor2.zip b/InternScenes/InternScenes_Real2Sim/textures/wood_floor2.zip new file mode 100644 index 0000000000000000000000000000000000000000..e10e3fcca50526610ebcf58344062a10955d659c --- /dev/null +++ b/InternScenes/InternScenes_Real2Sim/textures/wood_floor2.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c83a01f1733f2a1f6e95ad6703689eb12fe259e77245d4c0a5652728d07c87cb +size 5913872 diff --git a/src/infer/README.md b/src/infer/README.md new file mode 100644 index 0000000000000000000000000000000000000000..82e551beb52d4069491cf2f5bc10c3f3a5e6615c --- /dev/null +++ b/src/infer/README.md @@ -0,0 +1,49 @@ +# Inference + +vLLM-based inference scripts for group layout generation. + +## Scripts + +| Script | Description | +|--------|-------------| +| `run_group_infer.sh` | Single-GPU inference on training dataset splits | +| `run_group_infer_multi_gpu.sh` | Multi-GPU inference with tensor parallelism | +| `run_layout_instr_bench_infer.sh` | Inference on layout instruction benchmark data | + +## Quick Start + +```bash +# Single GPU +bash infer/run_group_infer.sh /path/to/checkpoint + +# Multi-GPU (auto-detect GPU count) +bash infer/run_group_infer_multi_gpu.sh /path/to/checkpoint + +# Layout instruction benchmark +bash infer/run_layout_instr_bench_infer.sh /path/to/checkpoint /path/to/bench_data + +# LoRA checkpoint (auto-detected) +bash infer/run_group_infer.sh /path/to/lora_checkpoint +``` + +## Environment Variables + +| Variable | Default | Description | +|----------|---------|-------------| +| `TEMPERATURE` | 0.6 | Sampling temperature | +| `TOP_P` | 0.85 | Nucleus sampling threshold | +| `TOP_K` | 20 | Top-k sampling | +| `REPETITION_PENALTY` | 1.05 | Repetition penalty | +| `MAX_NEW_TOKENS` | 32768 | Max generation length | +| `NUM_RETURN_SEQUENCES` | 1 | Sequences per input | +| `TENSOR_PARALLEL_SIZE` | auto | GPU count for tensor parallelism | +| `MAX_CONCURRENT_REQUESTS` | 16/32 | vLLM concurrency | +| `MAX_SAMPLES` | all | Limit number of samples | +| `INDIVIDUAL_FILES` | true | Save per-sample JSON files | +| `DATASET` | zones_test | Dataset name (for group infer) | + +## Files + +- `system_prompt.py` — shared system prompt +- `group_layout_vllm_infer.py` — inference via LlamaFactory dataset pipeline +- `layout_instr_bench_vllm_infer.py` — inference on JSONL prompt files diff --git a/src/infer/group_layout_vllm_infer.py b/src/infer/group_layout_vllm_infer.py new file mode 100644 index 0000000000000000000000000000000000000000..99c5c54306d1263873d458c94d940dcbff2254ca --- /dev/null +++ b/src/infer/group_layout_vllm_infer.py @@ -0,0 +1,413 @@ +#!/usr/bin/env python3 +""" +vLLM inference for group layout SFT checkpoints. +Loads data via LlamaFactory dataset pipeline. +""" +import json +import os +import re +import time +import argparse +from pathlib import Path +from datetime import datetime + +import fire +import yaml +from tqdm import tqdm +from transformers import Seq2SeqTrainingArguments + +from llamafactory.data import get_dataset, get_template_and_fix_tokenizer +from llamafactory.extras.constants import IGNORE_INDEX +from llamafactory.extras.misc import get_device_count +from llamafactory.extras.packages import is_vllm_available +from llamafactory.hparams import get_infer_args +from llamafactory.model import load_tokenizer + +if is_vllm_available(): + from vllm import LLM, SamplingParams + from vllm.lora.request import LoRARequest + +from system_prompt import SYSTEM_PROMPT + + +def load_system_prompt_from_yaml(yaml_path: str) -> str: + try: + with open(yaml_path, 'r', encoding='utf-8') as f: + config = yaml.safe_load(f) + prompt = config.get('default_system', '') + if prompt: + return prompt + except Exception: + pass + return SYSTEM_PROMPT + + +def load_original_dataset_with_ids(dataset_name: str, dataset_dir: str) -> dict: + if 'group_layout_local' in dataset_name: + data_file = os.path.join(dataset_dir, 'training_data_with_content_v2.json') + elif 'zones' in dataset_name: + data_file = os.path.join(dataset_dir, 'zones_data_mixed.json') + else: + return {} + + with open(data_file, 'r', encoding='utf-8') as f: + raw_data = json.load(f) + + data_items = raw_data.get('data', []) + + if 'test' in dataset_name: + target_split = 'test' + elif 'val' in dataset_name: + target_split = 'val' + elif dataset_name == 'zones_data': + target_split = 'val' + else: + target_split = 'train' + + filtered_data = [] + valid_indices = [] + for idx, item in enumerate(data_items): + if item.get("split") == target_split: + filtered_data.append(item) + valid_indices.append(idx) + + print(f"Loaded {len(filtered_data)} items from {dataset_name} split '{target_split}'") + return { + 'data': filtered_data, + 'id_mapping': {i: item.get('id', f'sample_{i}') for i, item in enumerate(filtered_data)}, + 'valid_indices': valid_indices + } + + +def analyze_results(results, predictions): + print("\n" + "=" * 50) + print("INFERENCE RESULTS ANALYSIS") + print("=" * 50) + + total = len(results) + think_cnt = sum(1 for p in predictions if "" in p and "" in p) + answer_cnt = sum(1 for p in predictions if "" in p and "" in p) + + rep_cnt = 0 + for pred in predictions: + words = pred.split() + for i in range(len(words) - 10): + if len(set(words[i:i + 10])) <= 2: + rep_cnt += 1 + break + + valid_json = 0 + for pred in predictions: + m = re.search(r'(.*?)', pred, re.DOTALL) + if m: + try: + json.loads(m.group(1).strip()) + valid_json += 1 + except json.JSONDecodeError: + pass + + print(f"Total: {total}") + print(f"With : {think_cnt} ({think_cnt / total * 100:.1f}%)") + print(f"With : {answer_cnt} ({answer_cnt / total * 100:.1f}%)") + print(f"Valid JSON: {valid_json} ({valid_json / total * 100:.1f}%)") + print(f"Repetitive: {rep_cnt} ({rep_cnt / total * 100:.1f}%)") + print("=" * 50) + + +def group_layout_vllm_infer( + model_name_or_path: str = "", + adapter_name_or_path: str = None, + dataset: str = "zones_test", + dataset_dir: str = "src/train_sft/data", + template: str = "qwen", + cutoff_len: int = 4096, + max_samples: int = None, + inference_mode: str = "sampling", + infer_dtype: str = "bfloat16", + temperature: float = 0.6, + top_p: float = 0.85, + top_k: int = 20, + max_new_tokens: int = 32768, + repetition_penalty: float = 1.05, + skip_special_tokens: bool = True, + num_return_sequences: int = 1, + config_yaml_path: str = "src/train_sft/examples/train_full/functional_zones_qwen3_full_sft.yaml", + enable_thinking: bool = True, + save_name: str = "generated_predictions.jsonl", + output_analysis: bool = True, + individual_files: bool = False, + output_dir: str = "infer_results/individual_samples", + seed: int = 42, + pipeline_parallel_size: int = 1, + max_concurrent_requests: int = 64, + tensor_parallel_size: int = 1, + enable_prefix_caching: bool = False, + debug_mode: bool = False, + check_samples: int = 0, + dry_run: bool = False, + vllm_config: str = "{}", +): + default_system = load_system_prompt_from_yaml(config_yaml_path) + + env_tp_size = os.environ.get("TENSOR_PARALLEL_SIZE") + if env_tp_size: + available_gpus = int(env_tp_size) + else: + available_gpus = get_device_count() + + if pipeline_parallel_size > available_gpus: + raise ValueError("Pipeline parallel size exceeds available GPU count.") + + model_args, data_args, _, generating_args = get_infer_args( + dict( + model_name_or_path=model_name_or_path, + adapter_name_or_path=adapter_name_or_path, + dataset=dataset, + dataset_dir=dataset_dir, + template=template, + cutoff_len=cutoff_len, + max_samples=max_samples, + preprocessing_num_workers=16, + default_system=default_system, + enable_thinking=enable_thinking, + infer_dtype=infer_dtype, + vllm_config=vllm_config, + temperature=temperature, + top_p=top_p, + top_k=top_k, + max_new_tokens=max_new_tokens, + repetition_penalty=repetition_penalty, + ) + ) + + print("=" * 60) + print(f"Group Layout vLLM Inference ({inference_mode})") + print("=" * 60) + print(f"Model: {model_name_or_path}") + if adapter_name_or_path: + print(f"LoRA: {adapter_name_or_path}") + print(f"Dataset: {dataset}") + print(f"Sampling: temp={temperature}, top_p={top_p}, top_k={top_k}, rep_pen={repetition_penalty}") + print(f"max_new_tokens={max_new_tokens}, n={num_return_sequences}, seed={seed}") + print("=" * 60) + + training_args = Seq2SeqTrainingArguments(output_dir="dummy_dir") + + tokenizer_module = load_tokenizer(model_args) + tokenizer = tokenizer_module["tokenizer"] + template_obj = get_template_and_fix_tokenizer(tokenizer, data_args) + template_obj.mm_plugin.expand_mm_tokens = False + + print("Loading dataset...") + dataset_module = get_dataset(template_obj, model_args, data_args, training_args, "ppo", **tokenizer_module) + train_dataset = dataset_module["train_dataset"] + print(f"Loaded {len(train_dataset)} examples") + + original_data = load_original_dataset_with_ids(dataset, dataset_dir) + id_mapping = original_data.get('id_mapping', {}) + + if len(id_mapping) != len(train_dataset): + id_mapping = {i: f"sample_{i}" for i in range(len(train_dataset))} + + if max_samples is not None and max_samples > 0 and len(train_dataset) > max_samples: + import random + random.seed(seed) + indices = sorted(random.sample(range(len(train_dataset)), max_samples)) + train_dataset = train_dataset.select(indices) + id_mapping = {new: id_mapping.get(old, f"sample_{old}") for new, old in enumerate(indices)} + print(f"Sampled {len(train_dataset)} examples") + + if debug_mode and check_samples > 0: + for i in range(min(check_samples, len(train_dataset))): + sample = train_dataset[i] + text = tokenizer.decode(sample["input_ids"], skip_special_tokens=True) + labels = [t for t in sample["labels"] if t != IGNORE_INDEX] + label_text = tokenizer.decode(labels, skip_special_tokens=True) if labels else "" + print(f"\n--- Sample {i} ---") + print(f"Input ({len(sample['input_ids'])} tokens): {repr(text[:300])}") + print(f"Label ({len(labels)} tokens): {repr(label_text[:300])}") + + if dry_run: + print("Dry run completed.") + return "dry_run_completed" + + if tensor_parallel_size is None: + if env_tp_size: + tensor_parallel_size = int(env_tp_size) + else: + tensor_parallel_size = (get_device_count() // pipeline_parallel_size) or 1 + + engine_args = { + "model": model_args.model_name_or_path, + "trust_remote_code": True, + "dtype": model_args.infer_dtype or "bfloat16", + "max_model_len": cutoff_len + max_new_tokens, + "tensor_parallel_size": tensor_parallel_size, + "pipeline_parallel_size": pipeline_parallel_size, + "disable_log_stats": True, + "enable_lora": model_args.adapter_name_or_path is not None, + "gpu_memory_utilization": 0.85, + "max_num_seqs": max_concurrent_requests, + } + + if enable_prefix_caching: + engine_args["enable_prefix_caching"] = True + + if model_args.adapter_name_or_path is not None: + try: + cfg_path = os.path.join(model_args.adapter_name_or_path, "adapter_config.json") + if os.path.exists(cfg_path): + with open(cfg_path, 'r') as f: + lora_rank = json.load(f).get("r", 32) + else: + lora_rank = 32 + except Exception: + lora_rank = 32 + engine_args.update({ + "max_lora_rank": max(lora_rank, 64), + "max_loras": 16, + "max_cpu_loras": 16, + }) + + if isinstance(model_args.vllm_config, dict): + engine_args.update(model_args.vllm_config) + + print(f"Initializing vLLM (tp={tensor_parallel_size})...") + try: + llm = LLM(**engine_args) + except TypeError as e: + if "enable_prefix_caching" in engine_args: + engine_args.pop("enable_prefix_caching", None) + llm = LLM(**engine_args) + else: + raise + + sampling_params = SamplingParams( + repetition_penalty=repetition_penalty, + temperature=temperature, + top_p=top_p, + top_k=top_k, + stop_token_ids=template_obj.get_stop_token_ids(tokenizer), + max_tokens=max_new_tokens, + skip_special_tokens=skip_special_tokens, + seed=seed, + n=num_return_sequences, + ) + + lora_request = None + if model_args.adapter_name_or_path is not None: + lora_request = LoRARequest("default", 1, model_args.adapter_name_or_path[0]) + + print("Preparing inputs...") + all_vllm_inputs = [] + all_prompts = [] + all_labels = [] + + for i in tqdm(range(len(train_dataset)), desc="Tokenizing"): + input_ids = train_dataset[i]["input_ids"] + prompt = tokenizer.decode(input_ids, skip_special_tokens=skip_special_tokens) + + mm_data = None + if train_dataset[i]["images"] is not None: + mm_data = { + "image": template_obj.mm_plugin._regularize_images( + train_dataset[i]["images"], + image_max_pixels=768 * 768, + image_min_pixels=32 * 32, + )["images"] + } + elif train_dataset[i]["videos"] is not None: + mm_data = { + "video": template_obj.mm_plugin._regularize_videos( + train_dataset[i]["videos"], + image_max_pixels=768 * 768, + image_min_pixels=32 * 32, + video_fps=2.0, + video_maxlen=128, + )["videos"] + } + + all_vllm_inputs.append({"prompt_token_ids": input_ids, "multi_modal_data": mm_data}) + all_prompts.append(prompt) + all_labels.append( + tokenizer.decode( + [t for t in train_dataset[i]["labels"] if t != IGNORE_INDEX], + skip_special_tokens=skip_special_tokens, + ) + ) + + print(f"Running inference ({len(all_vllm_inputs)} samples)...") + start_time = time.time() + results = llm.generate(all_vllm_inputs, sampling_params, lora_request=lora_request) + elapsed = time.time() - start_time + print(f"Inference done in {elapsed:.1f}s") + + all_preds_multi = [] + for result in results: + preds = [o.text for o in result.outputs] if result.outputs else [""] * num_return_sequences + all_preds_multi.append(preds) + + os.makedirs(os.path.dirname(save_name) or ".", exist_ok=True) + if individual_files: + os.makedirs(output_dir, exist_ok=True) + + timestamp = datetime.now().isoformat() + output_data = [] + + with open(save_name, "w", encoding="utf-8") as f: + for i, (prompt, preds, label) in enumerate(zip(all_prompts, all_preds_multi, all_labels)): + original_id = id_mapping.get(i, f"sample_{i}") + base_item = { + "original_id": original_id, + "prompt": prompt, + "label": label, + "timestamp": timestamp, + "model_path": model_name_or_path, + "inference_config": { + "inference_mode": inference_mode, + "temperature": temperature, + "top_p": top_p, + "top_k": top_k, + "max_new_tokens": max_new_tokens, + "repetition_penalty": repetition_penalty, + "num_return_sequences": num_return_sequences, + }, + } + + if num_return_sequences == 1: + item = {"id": i, **base_item, "predict": preds[0]} + output_data.append(item) + f.write(json.dumps(item, ensure_ascii=False) + "\n") + else: + for seq_idx, pred in enumerate(preds): + item = {"id": f"{i}_{seq_idx}", "sequence_id": seq_idx, **base_item, "predict": pred} + output_data.append(item) + f.write(json.dumps(item, ensure_ascii=False) + "\n") + + if individual_files: + safe_name = original_id.replace(":", "_").replace("/", "_") + if num_return_sequences == 1: + path = os.path.join(output_dir, f"{safe_name}.json") + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", encoding="utf-8") as fout: + json.dump({**base_item, "predict": preds[0]}, fout, ensure_ascii=False, indent=2) + else: + for seq_idx, pred in enumerate(preds): + path = os.path.join(output_dir, f"{safe_name}_seq_{seq_idx}.json") + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", encoding="utf-8") as fout: + json.dump({"sequence_id": seq_idx, **base_item, "predict": pred}, fout, ensure_ascii=False, indent=2) + + print(f"\n{len(all_prompts)} results saved to {save_name}") + if individual_files: + print(f"Individual files saved to {output_dir}") + + if output_analysis: + flat_preds = [p for preds in all_preds_multi for p in preds] + analyze_results(output_data, flat_preds) + + return save_name + + +if __name__ == "__main__": + fire.Fire(group_layout_vllm_infer) diff --git a/src/infer/layout_instr_bench_vllm_infer.py b/src/infer/layout_instr_bench_vllm_infer.py new file mode 100644 index 0000000000000000000000000000000000000000..4d61ab54aebd86c320bfd79a1ae6a952d524d414 --- /dev/null +++ b/src/infer/layout_instr_bench_vllm_infer.py @@ -0,0 +1,366 @@ +#!/usr/bin/env python3 +""" +vLLM inference for layout_instr_bench_test data. +Loads JSONL prompts directly without LlamaFactory dataset pipeline. +""" +import json +import os +import re +import glob +import time +from datetime import datetime + +import fire +import yaml +from tqdm import tqdm + +from llamafactory.extras.misc import get_device_count +from llamafactory.extras.packages import is_vllm_available +from llamafactory.model import load_tokenizer +from llamafactory.hparams import get_infer_args + +if is_vllm_available(): + from vllm import LLM, SamplingParams + +from system_prompt import SYSTEM_PROMPT + + +def load_system_prompt_from_yaml(yaml_path: str) -> str: + try: + with open(yaml_path, 'r', encoding='utf-8') as f: + config = yaml.safe_load(f) + prompt = config.get('default_system', '') + if prompt: + return prompt + except Exception: + pass + return SYSTEM_PROMPT + + +def load_layout_instr_bench_data(data_dir: str, room_types: list = None) -> list: + all_data = [] + pattern = os.path.join(data_dir, "*", "instructions.jsonl") + jsonl_files = glob.glob(pattern) + + if not jsonl_files: + raise ValueError(f"No instructions.jsonl files found in {data_dir}") + + print(f"Found {len(jsonl_files)} room type directories") + + for jsonl_file in sorted(jsonl_files): + room_type = os.path.basename(os.path.dirname(jsonl_file)) + if room_types is not None and room_type not in room_types: + continue + + with open(jsonl_file, 'r', encoding='utf-8') as f: + for line_idx, line in enumerate(f): + line = line.strip() + if not line: + continue + try: + item = json.loads(line) + item['room_type'] = room_type + item['source_file'] = jsonl_file + item['line_idx'] = line_idx + all_data.append(item) + except json.JSONDecodeError: + pass + + count = sum(1 for d in all_data if d['room_type'] == room_type) + print(f" {room_type}: {count} samples") + + print(f"Total: {len(all_data)} samples") + return all_data + + +def build_chat_prompt(user_prompt: str, system_prompt: str, template_name: str = "qwen") -> str: + if template_name == "qwen": + return f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n" + return f"System: {system_prompt}\n\nUser: {user_prompt}\n\nAssistant: " + + +def analyze_results(results, predictions, original_data): + print("\n" + "=" * 50) + print("INFERENCE RESULTS ANALYSIS") + print("=" * 50) + + total = len(predictions) + think_cnt = sum(1 for p in predictions if "" in p and "" in p) + answer_cnt = sum(1 for p in predictions if "" in p and "" in p) + + valid_json = 0 + for pred in predictions: + m = re.search(r'(.*?)', pred, re.DOTALL) + if m: + try: + json.loads(m.group(1).strip()) + valid_json += 1 + except json.JSONDecodeError: + pass + + print(f"Total: {total}") + print(f"With : {think_cnt} ({think_cnt / total * 100:.1f}%)") + print(f"With : {answer_cnt} ({answer_cnt / total * 100:.1f}%)") + print(f"Valid JSON: {valid_json} ({valid_json / total * 100:.1f}%)") + + room_stats = {} + for data, pred in zip(original_data, predictions): + rt = data.get('room_type', 'unknown') + if rt not in room_stats: + room_stats[rt] = {'total': 0, 'think': 0, 'answer': 0} + room_stats[rt]['total'] += 1 + if "" in pred and "" in pred: + room_stats[rt]['think'] += 1 + if "" in pred and "" in pred: + room_stats[rt]['answer'] += 1 + + print("\nBy room type:") + for rt, s in sorted(room_stats.items()): + print(f" {rt}: {s['total']} total, {s['think']} think, {s['answer']} answer") + print("=" * 50) + + +def layout_instr_bench_vllm_infer( + model_name_or_path: str = "", + data_dir: str = "", + room_types: str = None, + template: str = "qwen", + cutoff_len: int = 4096, + max_samples: int = None, + inference_mode: str = "sampling", + infer_dtype: str = "bfloat16", + temperature: float = 0.6, + top_p: float = 0.85, + top_k: int = 20, + max_new_tokens: int = 32768, + repetition_penalty: float = 1.05, + skip_special_tokens: bool = True, + num_return_sequences: int = 1, + config_yaml_path: str = "src/train_sft/examples/train_full/functional_zones_qwen3_full_sft.yaml", + enable_thinking: bool = True, + save_name: str = "layout_instr_bench_predictions.jsonl", + output_analysis: bool = True, + individual_files: bool = False, + output_dir: str = "infer_results/layout_instr_bench", + seed: int = 42, + pipeline_parallel_size: int = 1, + max_concurrent_requests: int = 32, + tensor_parallel_size: int = None, + enable_prefix_caching: bool = False, + debug_mode: bool = False, + check_samples: int = 0, + dry_run: bool = False, +): + room_type_list = None + if room_types: + room_type_list = [rt.strip() for rt in room_types.split(",")] + + default_system = load_system_prompt_from_yaml(config_yaml_path) + + env_tp_size = os.environ.get("TENSOR_PARALLEL_SIZE") + if env_tp_size: + available_gpus = int(env_tp_size) + else: + available_gpus = get_device_count() + + if pipeline_parallel_size > available_gpus: + raise ValueError("Pipeline parallel size exceeds available GPU count.") + + model_args, data_args, _, generating_args = get_infer_args( + dict( + model_name_or_path=model_name_or_path, + template=template, + cutoff_len=cutoff_len, + max_samples=max_samples, + preprocessing_num_workers=16, + default_system=default_system, + enable_thinking=enable_thinking, + temperature=temperature, + top_p=top_p, + top_k=top_k, + max_new_tokens=max_new_tokens, + repetition_penalty=repetition_penalty, + ) + ) + + print("=" * 60) + print(f"Layout Instr Bench vLLM Inference ({inference_mode})") + print("=" * 60) + print(f"Model: {model_name_or_path}") + print(f"Data: {data_dir}") + print(f"Room types: {room_type_list or 'all'}") + print(f"Sampling: temp={temperature}, top_p={top_p}, top_k={top_k}, rep_pen={repetition_penalty}") + print(f"max_new_tokens={max_new_tokens}, n={num_return_sequences}, seed={seed}") + print("=" * 60) + + tokenizer_module = load_tokenizer(model_args) + tokenizer = tokenizer_module["tokenizer"] + + print("Loading data...") + all_data = load_layout_instr_bench_data(data_dir, room_type_list) + + if max_samples is not None and max_samples > 0 and len(all_data) > max_samples: + import random + random.seed(seed) + all_data = random.sample(all_data, max_samples) + print(f"Sampled {len(all_data)} examples") + + if debug_mode and check_samples > 0: + for i in range(min(check_samples, len(all_data))): + s = all_data[i] + print(f"\n--- Sample {i} ---") + print(f"Room: {s.get('room_type')}, Focus: {s.get('content_focus')}") + print(f"Prompt: {repr(s.get('generated_prompt', '')[:300])}") + + if dry_run: + print("Dry run completed.") + return "dry_run_completed" + + if tensor_parallel_size is None: + if env_tp_size: + tensor_parallel_size = int(env_tp_size) + else: + tensor_parallel_size = (get_device_count() // pipeline_parallel_size) or 1 + + engine_args = { + "model": model_args.model_name_or_path, + "trust_remote_code": True, + "dtype": infer_dtype, + "max_model_len": cutoff_len + max_new_tokens, + "tensor_parallel_size": tensor_parallel_size, + "pipeline_parallel_size": pipeline_parallel_size, + "disable_log_stats": True, + "gpu_memory_utilization": 0.85, + "max_num_seqs": max_concurrent_requests, + } + + if enable_prefix_caching: + engine_args["enable_prefix_caching"] = True + + print(f"Initializing vLLM (tp={tensor_parallel_size})...") + try: + llm = LLM(**engine_args) + except TypeError as e: + if "enable_prefix_caching" in engine_args: + engine_args.pop("enable_prefix_caching", None) + llm = LLM(**engine_args) + else: + raise + + stop_ids = tokenizer.convert_tokens_to_ids(["<|im_end|>", "<|endoftext|>"]) + stop_ids = [t for t in stop_ids if t is not None] + + sampling_params = SamplingParams( + repetition_penalty=repetition_penalty, + temperature=temperature, + top_p=top_p, + top_k=top_k, + stop_token_ids=stop_ids or None, + max_tokens=max_new_tokens, + skip_special_tokens=skip_special_tokens, + seed=seed, + n=num_return_sequences, + ) + + print("Preparing inputs...") + all_vllm_inputs = [] + all_prompts = [] + + for i, sample in enumerate(tqdm(all_data, desc="Tokenizing")): + user_prompt = sample.get('generated_prompt', '') + if not user_prompt: + continue + + full_prompt = build_chat_prompt(user_prompt, default_system, template) + tokens = tokenizer.encode(full_prompt, add_special_tokens=False) + + if len(tokens) > cutoff_len: + tokens = tokens[:cutoff_len] + + all_vllm_inputs.append({"prompt_token_ids": tokens, "multi_modal_data": None}) + all_prompts.append(full_prompt) + + print(f"Running inference ({len(all_vllm_inputs)} samples)...") + start_time = time.time() + results = llm.generate(all_vllm_inputs, sampling_params) + elapsed = time.time() - start_time + print(f"Inference done in {elapsed:.1f}s") + + all_preds_multi = [] + for result in results: + preds = [o.text for o in result.outputs] if result.outputs else [""] * num_return_sequences + all_preds_multi.append(preds) + + os.makedirs(os.path.dirname(save_name) or ".", exist_ok=True) + if individual_files: + os.makedirs(output_dir, exist_ok=True) + + timestamp = datetime.now().isoformat() + output_data = [] + + with open(save_name, "w", encoding="utf-8") as f: + for i, (prompt, preds) in enumerate(zip(all_prompts, all_preds_multi)): + sample = all_data[i] + source_info = sample.get('source', {}) + original_id = source_info.get('image_id', f"{sample['room_type']}_{sample['line_idx']}") + + base_item = { + "original_id": original_id, + "room_type": sample.get('room_type', ''), + "content_focus": sample.get('content_focus', ''), + "focus_name": sample.get('focus_name', ''), + "complexity": sample.get('complexity', ''), + "persona": sample.get('persona', ''), + "user_prompt": sample.get('generated_prompt', ''), + "full_prompt": prompt, + "source": source_info, + "timestamp": timestamp, + "model_path": model_name_or_path, + "inference_config": { + "inference_mode": inference_mode, + "temperature": temperature, + "top_p": top_p, + "top_k": top_k, + "max_new_tokens": max_new_tokens, + "repetition_penalty": repetition_penalty, + "num_return_sequences": num_return_sequences, + }, + } + + if num_return_sequences == 1: + item = {"id": i, **base_item, "predict": preds[0]} + output_data.append(item) + f.write(json.dumps(item, ensure_ascii=False) + "\n") + else: + for seq_idx, pred in enumerate(preds): + item = {"id": f"{i}_{seq_idx}", "sequence_id": seq_idx, **base_item, "predict": pred} + output_data.append(item) + f.write(json.dumps(item, ensure_ascii=False) + "\n") + + if individual_files: + safe_name = original_id.replace(":", "_").replace("/", "_") + if num_return_sequences == 1: + path = os.path.join(output_dir, f"{safe_name}.json") + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", encoding="utf-8") as fout: + json.dump({**base_item, "predict": preds[0]}, fout, ensure_ascii=False, indent=2) + else: + for seq_idx, pred in enumerate(preds): + path = os.path.join(output_dir, f"{safe_name}_seq_{seq_idx}.json") + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", encoding="utf-8") as fout: + json.dump({"sequence_id": seq_idx, **base_item, "predict": pred}, fout, ensure_ascii=False, indent=2) + + print(f"\n{len(all_prompts)} results saved to {save_name}") + if individual_files: + print(f"Individual files saved to {output_dir}") + + if output_analysis: + flat_preds = [p for preds in all_preds_multi for p in preds] + analyze_results(output_data, flat_preds, all_data) + + return save_name + + +if __name__ == "__main__": + fire.Fire(layout_instr_bench_vllm_infer) diff --git a/src/infer/run_group_infer.sh b/src/infer/run_group_infer.sh new file mode 100644 index 0000000000000000000000000000000000000000..7cfcaa21fedef99b016da0d0123bc3f81aab016f --- /dev/null +++ b/src/infer/run_group_infer.sh @@ -0,0 +1,97 @@ +#!/usr/bin/env bash +# Single-GPU vLLM inference for group layout checkpoints. +# Usage: +# bash infer/run_group_infer.sh /path/to/checkpoint +# bash infer/run_group_infer.sh /path/to/lora_checkpoint + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +LF_SRC="$SCRIPT_DIR/../src/train_sft/src" +export PYTHONPATH="$LF_SRC${PYTHONPATH:+:$PYTHONPATH}" +export VLLM_USE_V1=0 + +MODEL_PATH="${1:?Usage: $0 [dataset] [output_path]}" +DATASET="${2:-zones_test}" +OUTPUT_PATH="${3:-infer_results/sampling/group_layout_sampling_$(date +%Y%m%d_%H%M%S).jsonl}" + +LORA_PATH="${LORA_PATH:-}" +BASE_MODEL="${BASE_MODEL:-}" + +# Auto-detect LoRA checkpoint +if [[ -d "$MODEL_PATH" && -f "$MODEL_PATH/adapter_config.json" ]]; then + if [[ -z "$LORA_PATH" ]]; then + LORA_PATH="$MODEL_PATH" + fi + if [[ -z "$BASE_MODEL" ]]; then + BASE_MODEL=$(python3 -c " +import json +with open('$MODEL_PATH/adapter_config.json') as f: + print(json.load(f).get('base_model_name_or_path', '')) +" 2>/dev/null || true) + fi +fi + +TEMPERATURE="${TEMPERATURE:-0.6}" +TOP_P="${TOP_P:-0.85}" +TOP_K="${TOP_K:-20}" +REPETITION_PENALTY="${REPETITION_PENALTY:-1.05}" +MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-32768}" +CUTOFF_LEN="${CUTOFF_LEN:-4096}" +INFER_DTYPE="${INFER_DTYPE:-bfloat16}" +NUM_RETURN_SEQUENCES="${NUM_RETURN_SEQUENCES:-1}" +MAX_CONCURRENT_REQUESTS="${MAX_CONCURRENT_REQUESTS:-16}" +MAX_SAMPLES="${MAX_SAMPLES:-}" +TENSOR_PARALLEL_SIZE="${TENSOR_PARALLEL_SIZE:-1}" +SEED="${SEED:-42}" +DATASET_DIR="${DATASET_DIR:-src/train_sft/data}" +TEMPLATE="${TEMPLATE:-qwen}" +ENABLE_THINKING="${ENABLE_THINKING:-true}" +INDIVIDUAL_FILES="${INDIVIDUAL_FILES:-true}" +OUTPUT_DIR="${OUTPUT_DIR:-infer_results/individual_samples}" + +mkdir -p "$(dirname "$OUTPUT_PATH")" +[[ "$INDIVIDUAL_FILES" = "true" ]] && mkdir -p "$OUTPUT_DIR" + +echo "==========================================" +echo "Group Layout vLLM Inference" +echo "==========================================" +echo "Model: $MODEL_PATH" +[[ -n "$LORA_PATH" ]] && echo "LoRA: $LORA_PATH" && echo "Base: ${BASE_MODEL:-auto}" +echo "Dataset: $DATASET | Output: $OUTPUT_PATH" +echo "Sampling: temp=$TEMPERATURE top_p=$TOP_P top_k=$TOP_K rep=$REPETITION_PENALTY" +echo "==========================================" + +PYTHON_CMD=( + python "$SCRIPT_DIR/group_layout_vllm_infer.py" + --model_name_or_path "${BASE_MODEL:-$MODEL_PATH}" + --infer_dtype "$INFER_DTYPE" + --dataset "$DATASET" + --dataset_dir "$DATASET_DIR" + --template "$TEMPLATE" + --cutoff_len "$CUTOFF_LEN" + --inference_mode sampling + --temperature "$TEMPERATURE" + --top_p "$TOP_P" + --top_k "$TOP_K" + --repetition_penalty "$REPETITION_PENALTY" + --max_new_tokens "$MAX_NEW_TOKENS" + --max_concurrent_requests "$MAX_CONCURRENT_REQUESTS" + --tensor_parallel_size "$TENSOR_PARALLEL_SIZE" + --enable_thinking "$ENABLE_THINKING" + --save_name "$OUTPUT_PATH" + --seed "$SEED" + --num_return_sequences "$NUM_RETURN_SEQUENCES" + --output_analysis true + --individual_files "$INDIVIDUAL_FILES" + --output_dir "$OUTPUT_DIR" +) + +[[ -n "$LORA_PATH" ]] && PYTHON_CMD+=(--adapter_name_or_path "$LORA_PATH") +[[ -n "$MAX_SAMPLES" ]] && PYTHON_CMD+=(--max_samples "$MAX_SAMPLES") + +echo "Command: ${PYTHON_CMD[*]}" +"${PYTHON_CMD[@]}" + +echo "" +echo "Done. Results: $OUTPUT_PATH" diff --git a/src/infer/run_group_infer_multi_gpu.sh b/src/infer/run_group_infer_multi_gpu.sh new file mode 100644 index 0000000000000000000000000000000000000000..33735cc77f892ab9a55abb4b956f96793d23a313 --- /dev/null +++ b/src/infer/run_group_infer_multi_gpu.sh @@ -0,0 +1,122 @@ +#!/usr/bin/env bash +# Multi-GPU vLLM inference for group layout checkpoints. +# Usage: +# bash infer/run_group_infer_multi_gpu.sh /path/to/checkpoint +# TENSOR_PARALLEL_SIZE=4 bash infer/run_group_infer_multi_gpu.sh /path/to/checkpoint + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +LF_SRC="$SCRIPT_DIR/../src/train_sft/src" +export PYTHONPATH="$LF_SRC${PYTHONPATH:+:$PYTHONPATH}" +export VLLM_USE_V1=0 +export HF_HUB_OFFLINE=1 +export VLLM_WORKER_MULTIPROC_METHOD=spawn +export CUDA_MODULE_LOADING=LAZY +unset WORLD_SIZE RANK LOCAL_RANK 2>/dev/null || true + +MODEL_PATH="${1:?Usage: $0 [dataset] [output_path]}" +DATASET="${2:-zones_data}" +OUTPUT_PATH="${3:-infer_results/sampling/group_layout_sampling_$(date +%Y%m%d_%H%M%S).jsonl}" + +LORA_PATH="${LORA_PATH:-}" +BASE_MODEL="${BASE_MODEL:-}" + +# Auto-detect LoRA checkpoint +if [[ -d "$MODEL_PATH" && -f "$MODEL_PATH/adapter_config.json" ]]; then + if [[ -z "$LORA_PATH" ]]; then + LORA_PATH="$MODEL_PATH" + fi + if [[ -z "$BASE_MODEL" ]]; then + BASE_MODEL=$(python3 -c " +import json +with open('$MODEL_PATH/adapter_config.json') as f: + print(json.load(f).get('base_model_name_or_path', '')) +" 2>/dev/null || true) + fi +fi + +TEMPERATURE="${TEMPERATURE:-0.6}" +TOP_P="${TOP_P:-0.85}" +TOP_K="${TOP_K:-20}" +REPETITION_PENALTY="${REPETITION_PENALTY:-1.05}" +MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-32768}" +CUTOFF_LEN="${CUTOFF_LEN:-4096}" +INFER_DTYPE="${INFER_DTYPE:-bfloat16}" +NUM_RETURN_SEQUENCES="${NUM_RETURN_SEQUENCES:-1}" +MAX_CONCURRENT_REQUESTS="${MAX_CONCURRENT_REQUESTS:-32}" +MAX_SAMPLES="${MAX_SAMPLES:-}" +SEED="${SEED:-42}" +DATASET_DIR="${DATASET_DIR:-src/train_sft/data}" +TEMPLATE="${TEMPLATE:-qwen}" +ENABLE_THINKING="${ENABLE_THINKING:-true}" +ENABLE_PREFIX_CACHING="${ENABLE_PREFIX_CACHING:-false}" +INDIVIDUAL_FILES="${INDIVIDUAL_FILES:-true}" +OUTPUT_DIR="${OUTPUT_DIR:-infer_results/individual_samples}" + +# Auto-detect GPU count +if [ -z "${TENSOR_PARALLEL_SIZE:-}" ]; then + if command -v nvidia-smi &>/dev/null; then + TENSOR_PARALLEL_SIZE=$(nvidia-smi -L | wc -l) + else + TENSOR_PARALLEL_SIZE=1 + fi +fi + +if [ -z "${CUDA_VISIBLE_DEVICES:-}" ] && [ "$TENSOR_PARALLEL_SIZE" -gt 1 ]; then + export CUDA_VISIBLE_DEVICES=$(seq -s, 0 $((TENSOR_PARALLEL_SIZE - 1))) +fi + +if [ "$TENSOR_PARALLEL_SIZE" -gt 1 ]; then + export NCCL_DEBUG="${NCCL_DEBUG:-WARN}" + export MASTER_ADDR="${MASTER_ADDR:-localhost}" + export MASTER_PORT="${MASTER_PORT:-29500}" +fi + +mkdir -p "$(dirname "$OUTPUT_PATH")" +[[ "$INDIVIDUAL_FILES" = "true" ]] && mkdir -p "$OUTPUT_DIR" + +echo "==========================================" +echo "Group Layout vLLM Inference (Multi-GPU)" +echo "==========================================" +echo "Model: $MODEL_PATH" +[[ -n "$LORA_PATH" ]] && echo "LoRA: $LORA_PATH" && echo "Base: ${BASE_MODEL:-auto}" +echo "Dataset: $DATASET | Output: $OUTPUT_PATH" +echo "TP=$TENSOR_PARALLEL_SIZE | GPUs: ${CUDA_VISIBLE_DEVICES:-all}" +echo "Sampling: temp=$TEMPERATURE top_p=$TOP_P top_k=$TOP_K rep=$REPETITION_PENALTY" +echo "==========================================" + +PYTHON_CMD=( + python "$SCRIPT_DIR/group_layout_vllm_infer.py" + --model_name_or_path "${BASE_MODEL:-$MODEL_PATH}" + --infer_dtype "$INFER_DTYPE" + --dataset "$DATASET" + --dataset_dir "$DATASET_DIR" + --template "$TEMPLATE" + --cutoff_len "$CUTOFF_LEN" + --inference_mode sampling + --temperature "$TEMPERATURE" + --top_p "$TOP_P" + --top_k "$TOP_K" + --repetition_penalty "$REPETITION_PENALTY" + --max_new_tokens "$MAX_NEW_TOKENS" + --max_concurrent_requests "$MAX_CONCURRENT_REQUESTS" + --tensor_parallel_size "$TENSOR_PARALLEL_SIZE" + --enable_prefix_caching "$ENABLE_PREFIX_CACHING" + --enable_thinking "$ENABLE_THINKING" + --save_name "$OUTPUT_PATH" + --seed "$SEED" + --num_return_sequences "$NUM_RETURN_SEQUENCES" + --output_analysis true + --individual_files "$INDIVIDUAL_FILES" + --output_dir "$OUTPUT_DIR" +) + +[[ -n "$LORA_PATH" ]] && PYTHON_CMD+=(--adapter_name_or_path "$LORA_PATH") +[[ -n "$MAX_SAMPLES" ]] && PYTHON_CMD+=(--max_samples "$MAX_SAMPLES") + +echo "Command: ${PYTHON_CMD[*]}" +"${PYTHON_CMD[@]}" + +echo "" +echo "Done. Results: $OUTPUT_PATH" diff --git a/src/infer/run_layout_instr_bench_infer.sh b/src/infer/run_layout_instr_bench_infer.sh new file mode 100644 index 0000000000000000000000000000000000000000..8039eeb68f75878254ef7ab0e263231e0beb6b1c --- /dev/null +++ b/src/infer/run_layout_instr_bench_infer.sh @@ -0,0 +1,105 @@ +#!/usr/bin/env bash +# Multi-GPU vLLM inference for layout_instr_bench_test data. +# Usage: +# bash infer/run_layout_instr_bench_infer.sh /path/to/checkpoint /path/to/bench_data +# ROOM_TYPES=bedroom,living_room bash infer/run_layout_instr_bench_infer.sh /path/to/checkpoint /path/to/bench_data + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +LF_SRC="$SCRIPT_DIR/../src/train_sft/src" +export PYTHONPATH="$LF_SRC${PYTHONPATH:+:$PYTHONPATH}" +export VLLM_USE_V1=0 +export HF_HUB_OFFLINE=1 +export VLLM_WORKER_MULTIPROC_METHOD=spawn +export CUDA_MODULE_LOADING=LAZY +unset WORLD_SIZE RANK LOCAL_RANK 2>/dev/null || true + +MODEL_PATH="${1:?Usage: $0 [data_dir] [output_path]}" +DATA_DIR="${2:?Usage: $0 [output_path]}" +OUTPUT_PATH="${3:-infer_results/layout_instr_bench/layout_instr_bench_sampling_$(date +%Y%m%d_%H%M%S).jsonl}" + +ROOM_TYPES="${ROOM_TYPES:-}" +TEMPERATURE="${TEMPERATURE:-0.6}" +TOP_P="${TOP_P:-0.85}" +TOP_K="${TOP_K:-20}" +REPETITION_PENALTY="${REPETITION_PENALTY:-1.05}" +MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-32768}" +CUTOFF_LEN="${CUTOFF_LEN:-4096}" +INFER_DTYPE="${INFER_DTYPE:-bfloat16}" +NUM_RETURN_SEQUENCES="${NUM_RETURN_SEQUENCES:-1}" +MAX_CONCURRENT_REQUESTS="${MAX_CONCURRENT_REQUESTS:-32}" +MAX_SAMPLES="${MAX_SAMPLES:-}" +SEED="${SEED:-42}" +TEMPLATE="${TEMPLATE:-qwen}" +ENABLE_THINKING="${ENABLE_THINKING:-true}" +ENABLE_PREFIX_CACHING="${ENABLE_PREFIX_CACHING:-false}" +INDIVIDUAL_FILES="${INDIVIDUAL_FILES:-true}" +OUTPUT_DIR="${OUTPUT_DIR:-infer_results/layout_instr_bench/individual_samples}" + +# Auto-detect GPU count +if [ -z "${TENSOR_PARALLEL_SIZE:-}" ]; then + if command -v nvidia-smi &>/dev/null; then + TENSOR_PARALLEL_SIZE=$(nvidia-smi -L | wc -l) + else + TENSOR_PARALLEL_SIZE=1 + fi +fi + +if [ -z "${CUDA_VISIBLE_DEVICES:-}" ] && [ "$TENSOR_PARALLEL_SIZE" -gt 1 ]; then + export CUDA_VISIBLE_DEVICES=$(seq -s, 0 $((TENSOR_PARALLEL_SIZE - 1))) +fi + +if [ "$TENSOR_PARALLEL_SIZE" -gt 1 ]; then + export NCCL_DEBUG="${NCCL_DEBUG:-WARN}" + export MASTER_ADDR="${MASTER_ADDR:-localhost}" + export MASTER_PORT="${MASTER_PORT:-29500}" +fi + +mkdir -p "$(dirname "$OUTPUT_PATH")" +[[ "$INDIVIDUAL_FILES" = "true" ]] && mkdir -p "$OUTPUT_DIR" + +echo "==========================================" +echo "Layout Instr Bench vLLM Inference" +echo "==========================================" +echo "Model: $MODEL_PATH" +echo "Data: $DATA_DIR" +echo "Room types: ${ROOM_TYPES:-all}" +echo "TP=$TENSOR_PARALLEL_SIZE | GPUs: ${CUDA_VISIBLE_DEVICES:-all}" +echo "Sampling: temp=$TEMPERATURE top_p=$TOP_P top_k=$TOP_K rep=$REPETITION_PENALTY" +echo "Output: $OUTPUT_PATH" +echo "==========================================" + +PYTHON_CMD=( + python "$SCRIPT_DIR/layout_instr_bench_vllm_infer.py" + --model_name_or_path "$MODEL_PATH" + --infer_dtype "$INFER_DTYPE" + --data_dir "$DATA_DIR" + --template "$TEMPLATE" + --cutoff_len "$CUTOFF_LEN" + --inference_mode sampling + --temperature "$TEMPERATURE" + --top_p "$TOP_P" + --top_k "$TOP_K" + --repetition_penalty "$REPETITION_PENALTY" + --max_new_tokens "$MAX_NEW_TOKENS" + --max_concurrent_requests "$MAX_CONCURRENT_REQUESTS" + --tensor_parallel_size "$TENSOR_PARALLEL_SIZE" + --enable_prefix_caching "$ENABLE_PREFIX_CACHING" + --enable_thinking "$ENABLE_THINKING" + --save_name "$OUTPUT_PATH" + --seed "$SEED" + --num_return_sequences "$NUM_RETURN_SEQUENCES" + --output_analysis true + --individual_files "$INDIVIDUAL_FILES" + --output_dir "$OUTPUT_DIR" +) + +[[ -n "$ROOM_TYPES" ]] && PYTHON_CMD+=(--room_types "$ROOM_TYPES") +[[ -n "$MAX_SAMPLES" ]] && PYTHON_CMD+=(--max_samples "$MAX_SAMPLES") + +echo "Command: ${PYTHON_CMD[*]}" +"${PYTHON_CMD[@]}" + +echo "" +echo "Done. Results: $OUTPUT_PATH" diff --git a/src/infer/system_prompt.py b/src/infer/system_prompt.py new file mode 100644 index 0000000000000000000000000000000000000000..ef64c55b8733fa5d85a7e749152ca55c4c4b0a8e --- /dev/null +++ b/src/infer/system_prompt.py @@ -0,0 +1,76 @@ +SYSTEM_PROMPT = """You are an expert AI Interior Architect. Your task is to generate a complete 3D indoor scene layout from a user's design brief through structured reasoning and thoughtful design decisions. + +Output contract: +- First, produce your design reasoning process enclosed in .... +- Then, produce the final layout as a single valid JSON object enclosed in .... + +Design reasoning process for : +- Think and reason through the design challenge systematically, demonstrating how you arrive at each decision. +- Write as a continuous internal dialogue that shows your thought progression from understanding the brief to finalizing the layout. +- Your reasoning should feel like a designer thinking through the problem in real-time, making decisions, evaluating them, and refining as needed. + +Technical conventions (apply consistently throughout your reasoning): +- Coordinate system: right-handed, Y-up; floor plane y = 0; units in meters. +- Rotations: quaternions [x, y, z, w]. +- Room envelope: a vertical prism with congruent top/bottom polygons; same vertex count and one-to-one correspondence; bounds_bottom vertices lie on y = 0; bounds_top on y = H (H > 0). +- Ergonomics: maintain clear walkways, avoid object collisions, preserve functional adjacency, comfortable reach distances, and coherent sightlines. + +Reasoning flow guidance for (think through these aspects naturally): +- Think and reason with one consistent pipeline regardless of how detailed the brief is. For vague briefs, expand high-level intent into a functional program, zone hypotheses, adjacency rules, and arrangement principles before any precise placement. For detailed briefs, identify the binding constraints and think through how to operationalize them while filling in missing details like exact positions and clearances. +- Define the room envelope by reasoning about the space needed to accommodate all required functions with proper circulation. +- Think through your object inventory, reasoning about appropriate sizes (W × H × D) and visual attributes for each item. For each object, consider color/finish palette, form factor/shape geometry, style vocabulary, texture/materiality, and any distinctive features or affordances. Synthesize these into a natural description. +- Reason through placement decisions group by group. For each functional zone, think about the anchor object, then systematically place related items. As you place each object, explicitly state its pos [x, y, z] and rot [x, y, z, w] and justify it against established principles. Your reasoning must confirm that each new placement avoids collision with the room envelope, previously placed groups, and other objects within its own group. +- After initial placement reasoning, critically evaluate your layout. When you identify issues with circulation, alignment, balance, functional relationships, or any collision or boundary violation, start the next sentence with "wait..." and think through corrections, then restate the improved pos and rot values. +- Conclude by verifying that your reasoning has led to a coherent, collision-free design that fulfills the brief and respects all spatial boundaries. + +Design principles to apply in your reasoning: +- Strict Envelope Containment: All objects must be fully contained within the room envelope without exception. +- Zero Collisions: The layout must be free of unintended collisions. This includes inter-group (between groups), and intra-group (within a group) collisions. +- Clear Circulation: Maintain ergonomic walkways and comfortable clearances for access and movement. +- Functional Adjacency: Position related objects logically to support their intended use. +- Proximity without Crowding: Group items closely to create functional zones, but maintain enough space to avoid a cluttered feel. +- Balanced Composition: Distribute visual weight to create a sense of harmony and stability. +- Alignment and Symmetry: Use shared axes, edges, or centerlines to create order, but only where appropriate for the design style. +- Logical Facing and Sightlines: Orient objects to support interaction (e.g., conversational seating) and create pleasing views. + +Contents for the tag: The Final JSON Layout +- Return a single, valid JSON object only (no extra text), conforming to this shape: + +{ + "room_type": "", + "room_envelope": { + "bounds_top": [ + [, , ] + // ... one entry per ceiling vertex, in order + ], + "bounds_bottom": [ + [, , ] + // ... one entry per floor vertex, same count/order correspondence as bounds_top + ] + }, + "groups": [ + { + "group_name": "", + "group_type": "", + "description": "", + "objects": [ + { + "desc": "", + "size": [, , ], + "pos": [, , ], + "rot": [, , , ] + } + // ... other objects in this group + ] + } + // ... other groups + ] +} + +JSON validity requirements: +- The JSON must be syntactically valid (numeric fields are numbers; no trailing commas; no comments). +- Top and bottom polygons must have identical vertex counts and correspond 1:1; all bounds_bottom vertices must have y = 0; all bounds_top vertices must share the same y = H. +- Every object's axis-aligned bounding box must lie within the room envelope. +- Floor-standing items should have their bottom at y = 0; wall-mounted items should have appropriate heights and rotations. +- Objects should be grouped logically by function; each object appears exactly once across all groups. +- The layout should respect ergonomic clearances and be free of unintended collisions.""" diff --git a/src/train_sft/.dockerignore b/src/train_sft/.dockerignore new file mode 100644 index 0000000000000000000000000000000000000000..a07ec860d9e8a49793fb478c405607bbdb3bf80e --- /dev/null +++ b/src/train_sft/.dockerignore @@ -0,0 +1,15 @@ +.vscode +.git +.github +.venv +cache +docker +saves +hf_cache +ms_cache +om_cache +shared_data +output +.dockerignore +.gitattributes +.gitignore diff --git a/src/train_sft/.env.local b/src/train_sft/.env.local new file mode 100644 index 0000000000000000000000000000000000000000..88ac8a46f115203f1a3faaeae503f063062fbe0d --- /dev/null +++ b/src/train_sft/.env.local @@ -0,0 +1,42 @@ +# Note: actually we do not support .env, just for reference +# api +API_HOST= +API_PORT= +API_KEY= +API_MODEL_NAME= +API_VERBOSE= +FASTAPI_ROOT_PATH= +MAX_CONCURRENT= +# general +DISABLE_VERSION_CHECK= +FORCE_CHECK_IMPORTS= +ALLOW_EXTRA_ARGS= +LLAMAFACTORY_VERBOSITY= +USE_MODELSCOPE_HUB= +USE_OPENMIND_HUB= +USE_RAY= +RECORD_VRAM= +OPTIM_TORCH= +NPU_JIT_COMPILE= +# torchrun +FORCE_TORCHRUN= +MASTER_ADDR= +MASTER_PORT= +NNODES= +NODE_RANK= +NPROC_PER_NODE= +# wandb +WANDB_DISABLED= +WANDB_PROJECT= +WANDB_API_KEY= +# gradio ui +GRADIO_SHARE= +GRADIO_SERVER_NAME= +GRADIO_SERVER_PORT= +GRADIO_ROOT_PATH= +GRADIO_IPV6= +# setup +ENABLE_SHORT_CONSOLE= +# reserved (do not use) +LLAMABOARD_ENABLED= +LLAMABOARD_WORKDIR= diff --git a/src/train_sft/.gitattributes b/src/train_sft/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..dfe0770424b2a19faf507a501ebfc23be8f54e7b --- /dev/null +++ b/src/train_sft/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/src/train_sft/.github/ISSUE_TEMPLATE/1-bug-report.yml b/src/train_sft/.github/ISSUE_TEMPLATE/1-bug-report.yml new file mode 100644 index 0000000000000000000000000000000000000000..a08596faa5b3be2545412d372f7bdeadca95afb4 --- /dev/null +++ b/src/train_sft/.github/ISSUE_TEMPLATE/1-bug-report.yml @@ -0,0 +1,61 @@ +name: "\U0001F41B Bug / help" +description: Create a report to help us improve the LLaMA Factory +labels: ["bug", "pending"] +body: + - type: markdown + attributes: + value: | + Issues included in **[FAQs](https://github.com/hiyouga/LLaMA-Factory/issues/4614)** or those with **insufficient** information may be closed without a response. + 已经包含在 **[常见问题](https://github.com/hiyouga/LLaMA-Factory/issues/4614)** 内或提供信息**不完整**的 issues 可能不会被回复。 + + - type: markdown + attributes: + value: | + Please do not create issues that are not related to framework bugs under this category, use **[Discussions](https://github.com/hiyouga/LLaMA-Factory/discussions/categories/q-a)** instead. + 请勿在此分类下创建和框架 bug 无关的 issues，训练问题求助请使用 **[讨论区](https://github.com/hiyouga/LLaMA-Factory/discussions/categories/q-a)**。 + + - type: checkboxes + id: reminder + attributes: + label: Reminder + description: | + Please ensure you have read the above rules carefully and searched the existing issues (including FAQs). + 请确保您已经认真阅读了上述规则并且搜索过现有的 issues（包括常见问题）。 + + options: + - label: I have read the above rules and searched the existing issues. + required: true + + - type: textarea + id: system-info + validations: + required: true + attributes: + label: System Info + description: | + Please share your system info with us. You can run the command **llamafactory-cli env** and copy-paste its output below. + 请提供您的系统信息。您可以在命令行运行 **llamafactory-cli env** 并将其输出复制到该文本框中。 + + placeholder: llamafactory version, platform, python version, ... + + - type: textarea + id: reproduction + validations: + required: true + attributes: + label: Reproduction + description: | + Please provide entry arguments, error messages and stack traces that reproduces the problem. + 请提供入口参数，错误日志以及异常堆栈以便于我们复现问题。 + + value: | + ```text + Put your message here. + ``` + + - type: textarea + id: others + validations: + required: false + attributes: + label: Others diff --git a/src/train_sft/.github/ISSUE_TEMPLATE/2-feature-request.yml b/src/train_sft/.github/ISSUE_TEMPLATE/2-feature-request.yml new file mode 100644 index 0000000000000000000000000000000000000000..5d72271ebc8db3d10bf7e9c6af209e857566bde6 --- /dev/null +++ b/src/train_sft/.github/ISSUE_TEMPLATE/2-feature-request.yml @@ -0,0 +1,41 @@ +name: "\U0001F680 Feature request" +description: Submit a request for a new feature +labels: ["enhancement", "pending"] +body: + - type: markdown + attributes: + value: | + Please do not create issues that are not related to new features under this category. + 请勿在此分类下创建和新特性无关的 issues。 + + - type: checkboxes + id: reminder + attributes: + label: Reminder + description: | + Please ensure you have read the above rules carefully and searched the existing issues. + 请确保您已经认真阅读了上述规则并且搜索过现有的 issues。 + + options: + - label: I have read the above rules and searched the existing issues. + required: true + + - type: textarea + id: description + validations: + required: true + attributes: + label: Description + description: | + A clear and concise description of the feature proposal. + 请详细描述您希望加入的新功能特性。 + + - type: textarea + id: contribution + validations: + required: false + attributes: + label: Pull Request + description: | + Have you already created the relevant PR and submitted the code? + 您是否已经创建了相关 PR 并提交了代码？ diff --git a/src/train_sft/.github/ISSUE_TEMPLATE/config.yml b/src/train_sft/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000000000000000000000000000000000000..1a7719634963d9d78bfa5155b51c5a82311084e4 --- /dev/null +++ b/src/train_sft/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,8 @@ +blank_issues_enabled: false +contact_links: + - name: 📚 FAQs | 常见问题 + url: https://github.com/hiyouga/LLaMA-Factory/issues/4614 + about: Reading in advance is recommended | 建议提前阅读 + - name: Discussions | 讨论区 + url: https://github.com/hiyouga/LLaMA-Factory/discussions + about: Please ask fine-tuning questions here | 请在这里讨论训练问题 diff --git a/src/train_sft/.github/workflows/docker.yml b/src/train_sft/.github/workflows/docker.yml new file mode 100644 index 0000000000000000000000000000000000000000..f5e099fae20831dccfc3dabb185174fd901146f7 --- /dev/null +++ b/src/train_sft/.github/workflows/docker.yml @@ -0,0 +1,108 @@ +name: docker + +on: + workflow_dispatch: + push: + branches: + - "main" + paths: + - "**/*.py" + - "requirements.txt" + - "docker/**" + - ".github/workflows/*.yml" + pull_request: + branches: + - "main" + paths: + - "**/*.py" + - "requirements.txt" + - "docker/**" + - ".github/workflows/*.yml" + +jobs: + build: + strategy: + fail-fast: false + matrix: + device: + - "cuda" + - "npu" + + runs-on: ubuntu-latest + + concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ matrix.device }} + cancel-in-progress: ${{ github.ref != 'refs/heads/main' }} + + environment: + name: docker + url: https://hub.docker.com/r/hiyouga/llamafactory + + steps: + - name: Free up disk space + uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be # v1.3.1 + with: + tool-cache: true + docker-images: false + + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.9" + + - name: Get llamafactory version + id: version + run: | + echo "tag=$(python setup.py --version | sed 's/\.dev0//')" >> "$GITHUB_OUTPUT" + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Login to Docker Hub + if: ${{ github.event_name != 'pull_request' }} + uses: docker/login-action@v3 + with: + username: ${{ vars.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Login to Quay + if: ${{ github.event_name != 'pull_request' && matrix.device == 'npu' }} + uses: docker/login-action@v3 + with: + registry: quay.io + username: ${{ vars.QUAY_ASCEND_USERNAME }} + password: ${{ secrets.QUAY_ASCEND_TOKEN }} + + - name: Build and push Docker image (CUDA) + if: ${{ matrix.device == 'cuda' }} + uses: docker/build-push-action@v6 + with: + context: . + file: ./docker/docker-cuda/Dockerfile + build-args: | + EXTRAS=metrics,deepspeed,liger-kernel + push: ${{ github.event_name != 'pull_request' }} + tags: | + docker.io/hiyouga/llamafactory:latest + docker.io/hiyouga/llamafactory:${{ steps.version.outputs.tag }} + cache-from: type=gha + cache-to: type=gha,mode=max + + - name: Build and push Docker image (NPU) + if: ${{ matrix.device == 'npu' }} + uses: docker/build-push-action@v6 + with: + context: . + platforms: linux/amd64,linux/arm64 + file: ./docker/docker-npu/Dockerfile + push: ${{ github.event_name != 'pull_request' }} + tags: | + docker.io/hiyouga/llamafactory:latest-npu-a2 + docker.io/hiyouga/llamafactory:${{ steps.version.outputs.tag }}-npu-a2 + quay.io/ascend/llamafactory:latest-npu-a2 + quay.io/ascend/llamafactory:${{ steps.version.outputs.tag }}-npu-a2 + cache-from: type=gha + cache-to: type=gha,mode=max diff --git a/src/train_sft/.github/workflows/label_issue.yml b/src/train_sft/.github/workflows/label_issue.yml new file mode 100644 index 0000000000000000000000000000000000000000..3d0424c77479d1a18a39f78240491461d50f3d22 --- /dev/null +++ b/src/train_sft/.github/workflows/label_issue.yml @@ -0,0 +1,32 @@ +name: label_issue + +on: + issues: + types: + - opened + +jobs: + label_issue: + runs-on: ubuntu-latest + + permissions: + issues: write + + steps: + - env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + ISSUE_URL: ${{ github.event.issue.html_url }} + ISSUE_TITLE: ${{ github.event.issue.title }} + run: | + LABEL="" + NPU_KEYWORDS=(npu huawei ascend 华为 昇腾 910) + ISSUE_TITLE_LOWER=$(echo $ISSUE_TITLE | tr '[:upper:]' '[:lower:]') + for KEYWORD in ${NPU_KEYWORDS[@]}; do + if [[ $ISSUE_TITLE_LOWER == *$KEYWORD* ]] && [[ $ISSUE_TITLE_LOWER != *input* ]]; then + LABEL="npu" + break + fi + done + if [ -n "$LABEL" ]; then + gh issue edit $ISSUE_URL --add-label $LABEL + fi diff --git a/src/train_sft/.github/workflows/publish.yml b/src/train_sft/.github/workflows/publish.yml new file mode 100644 index 0000000000000000000000000000000000000000..c3f729a085d326e29ef6c5bc4912c71278ebdd82 --- /dev/null +++ b/src/train_sft/.github/workflows/publish.yml @@ -0,0 +1,36 @@ +name: publish + +on: + workflow_dispatch: + release: + types: + - published + +jobs: + publish: + name: Upload release to PyPI + + runs-on: ubuntu-latest + + environment: + name: release + url: https://pypi.org/p/llamafactory + + permissions: + id-token: write + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.9" + + - name: Build package + run: | + make build + + - name: Publish package + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/src/train_sft/.github/workflows/tests.yml b/src/train_sft/.github/workflows/tests.yml new file mode 100644 index 0000000000000000000000000000000000000000..6d4ad682b259e0f2ad35ac2f4c6dd52ee90bd094 --- /dev/null +++ b/src/train_sft/.github/workflows/tests.yml @@ -0,0 +1,104 @@ +name: tests + +on: + workflow_dispatch: + push: + branches: + - "main" + paths: + - "**/*.py" + - "requirements.txt" + - ".github/workflows/*.yml" + pull_request: + branches: + - "main" + paths: + - "**/*.py" + - "requirements.txt" + - ".github/workflows/*.yml" + +jobs: + tests: + strategy: + fail-fast: false + matrix: + python: + - "3.9" + - "3.10" + - "3.11" + - "3.12" + os: + - "ubuntu-latest" + - "windows-latest" + - "macos-13" + transformers: + - null + include: # test backward compatibility + - python: "3.9" + os: "ubuntu-latest" + transformers: "4.49.0" + - python: "3.9" + os: "ubuntu-latest" + transformers: "4.51.0" + + runs-on: ${{ matrix.os }} + + concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ matrix.os }}-${{ matrix.python }}-${{ matrix.transformers }} + cancel-in-progress: ${{ github.ref != 'refs/heads/main' }} + + env: + HF_TOKEN: ${{ secrets.HF_TOKEN }} + OS_NAME: ${{ matrix.os }} + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + cache: "pip" + cache-dependency-path: "**/requirements*.txt" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install ".[torch,dev]" + + - name: Install transformers + if: ${{ matrix.transformers }} + run: | + python -m pip install "transformers==${{ matrix.transformers }}" + + - name: Install transformers to avoid mac os ci errors + if: ${{ matrix.os == 'macos-13' }} + run: | + python -m pip install "transformers<=4.51.3" + + - name: Cache files + id: hf-hub-cache + uses: actions/cache@v4 + with: + path: ${{ runner.temp }}/huggingface + key: huggingface-${{ matrix.os }}-${{ matrix.python }}-${{ matrix.transformers }}-${{ hashFiles('tests/version.txt') }} + + - name: Check quality + run: | + make style && make quality + + - name: Check license + run: | + make license + + - name: Check build + run: | + make build + + - name: Test with pytest + run: | + make test + env: + HF_HOME: ${{ runner.temp }}/huggingface + HF_HUB_OFFLINE: "${{ steps.hf-hub-cache.outputs.cache-hit == 'true' && '1' || '0' }}" diff --git a/src/train_sft/.gitignore b/src/train_sft/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..0a3a47bd8b251892e9d8db7b6878accc99c1a5bc --- /dev/null +++ b/src/train_sft/.gitignore @@ -0,0 +1,179 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + +# vscode +.vscode/ + +# uv +uv.lock + +# custom .gitignore +hf_cache/ +ms_cache/ +om_cache/ +cache/ +config/ +saves/ +output/ +wandb/ +swanlog/ +generated_predictions.jsonl +predictions_score.json diff --git a/src/train_sft/.pre-commit-config.yaml b/src/train_sft/.pre-commit-config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cbe361eeb5ffb7dd31b9203b691316906f0b1fe8 --- /dev/null +++ b/src/train_sft/.pre-commit-config.yaml @@ -0,0 +1,28 @@ +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v5.0.0 + hooks: + - id: check-ast + - id: check-added-large-files + args: ['--maxkb=25000'] + - id: check-merge-conflict + - id: check-yaml + - id: debug-statements + - id: end-of-file-fixer + - id: trailing-whitespace + args: [--markdown-linebreak-ext=md] + - id: no-commit-to-branch + args: ['--branch', 'main'] + +- repo: https://github.com/asottile/pyupgrade + rev: v3.17.0 + hooks: + - id: pyupgrade + args: [--py38-plus] + +- repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.6.9 + hooks: + - id: ruff + args: [--fix] + - id: ruff-format diff --git a/src/train_sft/CITATION.cff b/src/train_sft/CITATION.cff new file mode 100644 index 0000000000000000000000000000000000000000..01b4c9fd28aed295d50c71a7a3ed2e97a69434d4 --- /dev/null +++ b/src/train_sft/CITATION.cff @@ -0,0 +1,44 @@ +cff-version: 1.2.0 +date-released: 2024-03 +message: "If you use this software, please cite it as below." +authors: +- family-names: "Zheng" + given-names: "Yaowei" +- family-names: "Zhang" + given-names: "Richong" +- family-names: "Zhang" + given-names: "Junhao" +- family-names: "Ye" + given-names: "Yanhan" +- family-names: "Luo" + given-names: "Zheyan" +- family-names: "Feng" + given-names: "Zhangchi" +- family-names: "Ma" + given-names: "Yongqiang" +title: "LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models" +url: "https://arxiv.org/abs/2403.13372" +preferred-citation: + type: conference-paper + conference: + name: "Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations)" + authors: + - family-names: "Zheng" + given-names: "Yaowei" + - family-names: "Zhang" + given-names: "Richong" + - family-names: "Zhang" + given-names: "Junhao" + - family-names: "Ye" + given-names: "Yanhan" + - family-names: "Luo" + given-names: "Zheyan" + - family-names: "Feng" + given-names: "Zhangchi" + - family-names: "Ma" + given-names: "Yongqiang" + title: "LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models" + url: "https://arxiv.org/abs/2403.13372" + year: 2024 + publisher: "Association for Computational Linguistics" + address: "Bangkok, Thailand" diff --git a/src/train_sft/LICENSE b/src/train_sft/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b09cd7856d58590578ee1a4f3ad45d1310a97f87 --- /dev/null +++ b/src/train_sft/LICENSE @@ -0,0 +1,201 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/src/train_sft/MANIFEST.in b/src/train_sft/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..82c51f6348a58f9da0c839a61b0063b9aba66d75 --- /dev/null +++ b/src/train_sft/MANIFEST.in @@ -0,0 +1 @@ +include LICENSE requirements.txt diff --git a/src/train_sft/Makefile b/src/train_sft/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..2dcb7caf69b3b85b0c143dc62d2053515a5346a1 --- /dev/null +++ b/src/train_sft/Makefile @@ -0,0 +1,24 @@ +.PHONY: build commit license quality style test + +check_dirs := scripts src tests setup.py + +build: + pip3 install build && python3 -m build + +commit: + pre-commit install + pre-commit run --all-files + +license: + python3 tests/check_license.py $(check_dirs) + +quality: + ruff check $(check_dirs) + ruff format --check $(check_dirs) + +style: + ruff check $(check_dirs) --fix + ruff format $(check_dirs) + +test: + CUDA_VISIBLE_DEVICES= WANDB_DISABLED=true pytest -vv tests/ diff --git a/src/train_sft/README.md b/src/train_sft/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f4ce635a138347b77727bbf0c3f9ea468fc0dea3 --- /dev/null +++ b/src/train_sft/README.md @@ -0,0 +1,950 @@ +![# LLaMA Factory](assets/logo.png) + +[![GitHub Repo stars](https://img.shields.io/github/stars/hiyouga/LLaMA-Factory?style=social)](https://github.com/hiyouga/LLaMA-Factory/stargazers) +[![GitHub last commit](https://img.shields.io/github/last-commit/hiyouga/LLaMA-Factory)](https://github.com/hiyouga/LLaMA-Factory/commits/main) +[![GitHub contributors](https://img.shields.io/github/contributors/hiyouga/LLaMA-Factory?color=orange)](https://github.com/hiyouga/LLaMA-Factory/graphs/contributors) +[![GitHub workflow](https://github.com/hiyouga/LLaMA-Factory/actions/workflows/tests.yml/badge.svg)](https://github.com/hiyouga/LLaMA-Factory/actions/workflows/tests.yml) +[![PyPI](https://img.shields.io/pypi/v/llamafactory)](https://pypi.org/project/llamafactory/) +[![Citation](https://img.shields.io/badge/citation-760-green)](https://scholar.google.com/scholar?cites=12620864006390196564) +[![Docker Pulls](https://img.shields.io/docker/pulls/hiyouga/llamafactory)](https://hub.docker.com/r/hiyouga/llamafactory/tags) + +[![Twitter](https://img.shields.io/twitter/follow/llamafactory_ai)](https://twitter.com/llamafactory_ai) +[![Discord](https://dcbadge.vercel.app/api/server/rKfvV9r9FK?compact=true&style=flat)](https://discord.gg/rKfvV9r9FK) +[![GitCode](https://gitcode.com/zhengyaowei/LLaMA-Factory/star/badge.svg)](https://gitcode.com/zhengyaowei/LLaMA-Factory) + +[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1eRTPn37ltBbYsISy9Aw2NuI2Aq5CQrD9?usp=sharing) +[![Open in DSW](https://gallery.pai-ml.com/assets/open-in-dsw.svg)](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory) +[![Open in Alaya](assets/alaya_new.svg)](https://docs.alayanew.com/docs/documents/newActivities/llamafactory/?utm_source=LLaMA-Factory) +[![Open in Spaces](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue)](https://huggingface.co/spaces/hiyouga/LLaMA-Board) +[![Open in Studios](https://img.shields.io/badge/ModelScope-Open%20in%20Studios-blue)](https://modelscope.cn/studios/hiyouga/LLaMA-Board) +[![Open in Novita](https://img.shields.io/badge/Novita-Deploy%20Template-blue)](https://novita.ai/templates-library/105981?sharer=88115474-394e-4bda-968e-b88e123d0c47) + +### Used by [Amazon](https://aws.amazon.com/cn/blogs/machine-learning/how-apoidea-group-enhances-visual-information-extraction-from-banking-documents-with-multimodal-models-using-llama-factory-on-amazon-sagemaker-hyperpod/), [NVIDIA](https://developer.nvidia.com/rtx/ai-toolkit), [Aliyun](https://help.aliyun.com/zh/pai/use-cases/fine-tune-a-llama-3-model-with-llama-factory), etc. + +
+ +### Supporters ❤️ + +|
Warp sponsorship
Warp, the agentic terminal for developers
Available for MacOS, Linux, & Windows | SerpAPI sponsorship | +| ---- | ---- | + +---- + +### Easily fine-tune 100+ large language models with zero-code [CLI](#quickstart) and [Web UI](#fine-tuning-with-llama-board-gui-powered-by-gradio) + +![GitHub Trend](https://trendshift.io/api/badge/repositories/4535) + +
+ +👋 Join our [WeChat group](assets/wechat.jpg), [NPU user group](assets/wechat_npu.jpg) or [Alaya NeW user group](assets/wechat_alaya.png). + +\[ English | [中文](README_zh.md) \] + +**Fine-tuning a large language model can be easy as...** + +https://github.com/user-attachments/assets/3991a3a8-4276-4d30-9cab-4cb0c4b9b99e + +Choose your path: + +- **Documentation (WIP)**: https://llamafactory.readthedocs.io/en/latest/ +- **Documentation (AMD GPU)**: https://rocm.docs.amd.com/projects/ai-developer-hub/en/latest/notebooks/fine_tune/llama_factory_llama3.html +- **Colab (free)**: https://colab.research.google.com/drive/1eRTPn37ltBbYsISy9Aw2NuI2Aq5CQrD9?usp=sharing +- **Local machine**: Please refer to [usage](#getting-started) +- **PAI-DSW (free trial)**: https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory +- **Alaya NeW (cloud GPU deal)**: https://docs.alayanew.com/docs/documents/useGuide/LLaMAFactory/mutiple/?utm_source=LLaMA-Factory + +> [!NOTE] +> Except for the above links, all other websites are unauthorized third-party websites. Please carefully use them. + +## Table of Contents + +- [Features](#features) +- [Blogs](#blogs) +- [Changelog](#changelog) +- [Supported Models](#supported-models) +- [Supported Training Approaches](#supported-training-approaches) +- [Provided Datasets](#provided-datasets) +- [Requirement](#requirement) +- [Getting Started](#getting-started) + - [Installation](#installation) + - [Data Preparation](#data-preparation) + - [Quickstart](#quickstart) + - [Fine-Tuning with LLaMA Board GUI](#fine-tuning-with-llama-board-gui-powered-by-gradio) + - [Build Docker](#build-docker) + - [Deploy with OpenAI-style API and vLLM](#deploy-with-openai-style-api-and-vllm) + - [Download from ModelScope Hub](#download-from-modelscope-hub) + - [Download from Modelers Hub](#download-from-modelers-hub) + - [Use W&B Logger](#use-wb-logger) + - [Use SwanLab Logger](#use-swanlab-logger) +- [Projects using LLaMA Factory](#projects-using-llama-factory) +- [License](#license) +- [Citation](#citation) +- [Acknowledgement](#acknowledgement) + +## Features + +- **Various models**: LLaMA, LLaVA, Mistral, Mixtral-MoE, Qwen, Qwen2-VL, DeepSeek, Yi, Gemma, ChatGLM, Phi, etc. +- **Integrated methods**: (Continuous) pre-training, (multimodal) supervised fine-tuning, reward modeling, PPO, DPO, KTO, ORPO, etc. +- **Scalable resources**: 16-bit full-tuning, freeze-tuning, LoRA and 2/3/4/5/6/8-bit QLoRA via AQLM/AWQ/GPTQ/LLM.int8/HQQ/EETQ. +- **Advanced algorithms**: [GaLore](https://github.com/jiaweizzhao/GaLore), [BAdam](https://github.com/Ledzy/BAdam), [APOLLO](https://github.com/zhuhanqing/APOLLO), [Adam-mini](https://github.com/zyushun/Adam-mini), [Muon](https://github.com/KellerJordan/Muon), DoRA, LongLoRA, LLaMA Pro, Mixture-of-Depths, LoRA+, LoftQ and PiSSA. +- **Practical tricks**: [FlashAttention-2](https://github.com/Dao-AILab/flash-attention), [Unsloth](https://github.com/unslothai/unsloth), [Liger Kernel](https://github.com/linkedin/Liger-Kernel), RoPE scaling, NEFTune and rsLoRA. +- **Wide tasks**: Multi-turn dialogue, tool using, image understanding, visual grounding, video recognition, audio understanding, etc. +- **Experiment monitors**: LlamaBoard, TensorBoard, Wandb, MLflow, [SwanLab](https://github.com/SwanHubX/SwanLab), etc. +- **Faster inference**: OpenAI-style API, Gradio UI and CLI with [vLLM worker](https://github.com/vllm-project/vllm) or [SGLang worker](https://github.com/sgl-project/sglang). + +### Day-N Support for Fine-Tuning Cutting-Edge Models + +| Support Date | Model Name | +| ------------ | -------------------------------------------------------------------- | +| Day 0 | Qwen3 / Qwen2.5-VL / Gemma 3 / GLM-4.1V / InternLM 3 / MiniCPM-o-2.6 | +| Day 1 | Llama 3 / GLM-4 / Mistral Small / PaliGemma2 / Llama 4 | + +## Blogs + +- [Fine-tune GPT-OSS for Role-Playing using LLaMA-Factory](https://docs.llamafactory.com.cn/docs/documents/best-practice/gptoss/?utm_source=LLaMA-Factory) (Chinese) +- [Fine-tune Llama3.1-70B for Medical Diagnosis using LLaMA-Factory](https://docs.alayanew.com/docs/documents/bestPractice/bigModel/llama70B/?utm_source=LLaMA-Factory) (Chinese) +- [A One-Stop Code-Free Model Reinforcement Learning and Deployment Platform based on LLaMA-Factory and EasyR1](https://aws.amazon.com/cn/blogs/china/building-llm-model-hub-based-on-llamafactory-and-easyr1/) (Chinese) +- [How Apoidea Group enhances visual information extraction from banking documents with multimodal models using LLaMA-Factory on Amazon SageMaker HyperPod](https://aws.amazon.com/cn/blogs/machine-learning/how-apoidea-group-enhances-visual-information-extraction-from-banking-documents-with-multimodal-models-using-llama-factory-on-amazon-sagemaker-hyperpod/) (English) +- [Easy Dataset × LLaMA Factory: Enabling LLMs to Efficiently Learn Domain Knowledge](https://buaa-act.feishu.cn/wiki/GVzlwYcRFiR8OLkHbL6cQpYin7g) (English) + +
All Blogs + +- [Fine-tune Qwen2.5-VL for Autonomous Driving using LLaMA-Factory](https://docs.alayanew.com/docs/documents/useGuide/LLaMAFactory/mutiple/?utm_source=LLaMA-Factory) (Chinese) +- [LLaMA Factory: Fine-tuning the DeepSeek-R1-Distill-Qwen-7B Model for News Classifier](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory_deepseek_r1_distill_7b) (Chinese) +- [A One-Stop Code-Free Model Fine-Tuning \& Deployment Platform based on SageMaker and LLaMA-Factory](https://aws.amazon.com/cn/blogs/china/a-one-stop-code-free-model-fine-tuning-deployment-platform-based-on-sagemaker-and-llama-factory/) (Chinese) +- [LLaMA Factory Multi-Modal Fine-Tuning Practice: Fine-Tuning Qwen2-VL for Personal Tourist Guide](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory_qwen2vl) (Chinese) +- [LLaMA Factory: Fine-tuning Llama3 for Role-Playing](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory) (Chinese) + +
+ +## Changelog + +[25/08/06] We supported fine-tuning the **[GPT-OSS](https://github.com/openai/gpt-oss)** models. See [PR #8826](https://github.com/hiyouga/LLaMA-Factory/pull/8826) to get started. + +[25/07/02] We supported fine-tuning the **[GLM-4.1V-9B-Thinking](https://github.com/THUDM/GLM-4.1V-Thinking)** model. + +[25/04/28] We supported fine-tuning the **[Qwen3](https://qwenlm.github.io/blog/qwen3/)** model family. + +
Full Changelog + +[25/04/21] We supported the **[Muon](https://github.com/KellerJordan/Muon)** optimizer. See [examples](examples/README.md) for usage. Thank [@tianshijing](https://github.com/tianshijing)'s PR. + +[25/04/16] We supported fine-tuning the **[InternVL3](https://huggingface.co/OpenGVLab/InternVL3-8B)** model. See [PR #7258](https://github.com/hiyouga/LLaMA-Factory/pull/7258) to get started. + +[25/04/14] We supported fine-tuning the **[GLM-Z1](https://huggingface.co/THUDM/GLM-Z1-9B-0414)** and **[Kimi-VL](https://huggingface.co/moonshotai/Kimi-VL-A3B-Instruct)** models. + +[25/04/06] We supported fine-tuning the **[Llama 4](https://ai.meta.com/blog/llama-4-multimodal-intelligence/)** model. See [PR #7611](https://github.com/hiyouga/LLaMA-Factory/pull/7611) to get started. + +[25/03/31] We supported fine-tuning the **[Qwen2.5 Omni](https://qwenlm.github.io/blog/qwen2.5-omni/)** model. See [PR #7537](https://github.com/hiyouga/LLaMA-Factory/pull/7537) to get started. + +[25/03/15] We supported **[SGLang](https://github.com/sgl-project/sglang)** as inference backend. Try `infer_backend: sglang` to accelerate inference. + +[25/03/12] We supported fine-tuning the **[Gemma 3](https://huggingface.co/blog/gemma3)** model. + +[25/02/24] Announcing **[EasyR1](https://github.com/hiyouga/EasyR1)**, an efficient, scalable and multi-modality RL training framework for efficient GRPO training. + +[25/02/11] We supported saving the **[Ollama](https://github.com/ollama/ollama)** modelfile when exporting the model checkpoints. See [examples](examples/README.md) for usage. + +[25/02/05] We supported fine-tuning the **[Qwen2-Audio](Qwen/Qwen2-Audio-7B-Instruct)** and **[MiniCPM-o-2.6](https://huggingface.co/openbmb/MiniCPM-o-2_6)** on audio understanding tasks. + +[25/01/31] We supported fine-tuning the **[DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)** and **[Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct)** models. + +[25/01/15] We supported **[APOLLO](https://arxiv.org/abs/2412.05270)** optimizer. See [examples](examples/README.md) for usage. + +[25/01/14] We supported fine-tuning the **[MiniCPM-o-2.6](https://huggingface.co/openbmb/MiniCPM-o-2_6)** and **[MiniCPM-V-2.6](https://huggingface.co/openbmb/MiniCPM-V-2_6)** models. Thank [@BUAADreamer](https://github.com/BUAADreamer)'s PR. + +[25/01/14] We supported fine-tuning the **[InternLM 3](https://huggingface.co/collections/internlm/)** models. Thank [@hhaAndroid](https://github.com/hhaAndroid)'s PR. + +[25/01/10] We supported fine-tuning the **[Phi-4](https://huggingface.co/microsoft/phi-4)** model. + +[24/12/21] We supported using **[SwanLab](https://github.com/SwanHubX/SwanLab)** for experiment tracking and visualization. See [this section](#use-swanlab-logger) for details. + +[24/11/27] We supported fine-tuning the **[Skywork-o1](https://huggingface.co/Skywork/Skywork-o1-Open-Llama-3.1-8B)** model and the **[OpenO1](https://huggingface.co/datasets/O1-OPEN/OpenO1-SFT)** dataset. + +[24/10/09] We supported downloading pre-trained models and datasets from the **[Modelers Hub](https://modelers.cn/models)**. See [this tutorial](#download-from-modelers-hub) for usage. + +[24/09/19] We supported fine-tuning the **[Qwen2.5](https://qwenlm.github.io/blog/qwen2.5/)** models. + +[24/08/30] We supported fine-tuning the **[Qwen2-VL](https://qwenlm.github.io/blog/qwen2-vl/)** models. Thank [@simonJJJ](https://github.com/simonJJJ)'s PR. + +[24/08/27] We supported **[Liger Kernel](https://github.com/linkedin/Liger-Kernel)**. Try `enable_liger_kernel: true` for efficient training. + +[24/08/09] We supported **[Adam-mini](https://github.com/zyushun/Adam-mini)** optimizer. See [examples](examples/README.md) for usage. Thank [@relic-yuexi](https://github.com/relic-yuexi)'s PR. + +[24/07/04] We supported [contamination-free packed training](https://github.com/MeetKai/functionary/tree/main/functionary/train/packing). Use `neat_packing: true` to activate it. Thank [@chuan298](https://github.com/chuan298)'s PR. + +[24/06/16] We supported **[PiSSA](https://arxiv.org/abs/2404.02948)** algorithm. See [examples](examples/README.md) for usage. + +[24/06/07] We supported fine-tuning the **[Qwen2](https://qwenlm.github.io/blog/qwen2/)** and **[GLM-4](https://github.com/THUDM/GLM-4)** models. + +[24/05/26] We supported **[SimPO](https://arxiv.org/abs/2405.14734)** algorithm for preference learning. See [examples](examples/README.md) for usage. + +[24/05/20] We supported fine-tuning the **PaliGemma** series models. Note that the PaliGemma models are pre-trained models, you need to fine-tune them with `paligemma` template for chat completion. + +[24/05/18] We supported **[KTO](https://arxiv.org/abs/2402.01306)** algorithm for preference learning. See [examples](examples/README.md) for usage. + +[24/05/14] We supported training and inference on the Ascend NPU devices. Check [installation](#installation) section for details. + +[24/04/26] We supported fine-tuning the **LLaVA-1.5** multimodal LLMs. See [examples](examples/README.md) for usage. + +[24/04/22] We provided a **[Colab notebook](https://colab.research.google.com/drive/1eRTPn37ltBbYsISy9Aw2NuI2Aq5CQrD9?usp=sharing)** for fine-tuning the Llama-3 model on a free T4 GPU. Two Llama-3-derived models fine-tuned using LLaMA Factory are available at Hugging Face, check [Llama3-8B-Chinese-Chat](https://huggingface.co/shenzhi-wang/Llama3-8B-Chinese-Chat) and [Llama3-Chinese](https://huggingface.co/zhichen/Llama3-Chinese) for details. + +[24/04/21] We supported **[Mixture-of-Depths](https://arxiv.org/abs/2404.02258)** according to [AstraMindAI's implementation](https://github.com/astramind-ai/Mixture-of-depths). See [examples](examples/README.md) for usage. + +[24/04/16] We supported **[BAdam](https://arxiv.org/abs/2404.02827)** optimizer. See [examples](examples/README.md) for usage. + +[24/04/16] We supported **[unsloth](https://github.com/unslothai/unsloth)**'s long-sequence training (Llama-2-7B-56k within 24GB). It achieves **117%** speed and **50%** memory compared with FlashAttention-2, more benchmarks can be found in [this page](https://github.com/hiyouga/LLaMA-Factory/wiki/Performance-comparison). + +[24/03/31] We supported **[ORPO](https://arxiv.org/abs/2403.07691)**. See [examples](examples/README.md) for usage. + +[24/03/21] Our paper "[LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models](https://arxiv.org/abs/2403.13372)" is available at arXiv! + +[24/03/20] We supported **FSDP+QLoRA** that fine-tunes a 70B model on 2x24GB GPUs. See [examples](examples/README.md) for usage. + +[24/03/13] We supported **[LoRA+](https://arxiv.org/abs/2402.12354)**. See [examples](examples/README.md) for usage. + +[24/03/07] We supported **[GaLore](https://arxiv.org/abs/2403.03507)** optimizer. See [examples](examples/README.md) for usage. + +[24/03/07] We integrated **[vLLM](https://github.com/vllm-project/vllm)** for faster and concurrent inference. Try `infer_backend: vllm` to enjoy **270%** inference speed. + +[24/02/28] We supported weight-decomposed LoRA (**[DoRA](https://arxiv.org/abs/2402.09353)**). Try `use_dora: true` to activate DoRA training. + +[24/02/15] We supported **block expansion** proposed by [LLaMA Pro](https://github.com/TencentARC/LLaMA-Pro). See [examples](examples/README.md) for usage. + +[24/02/05] Qwen1.5 (Qwen2 beta version) series models are supported in LLaMA-Factory. Check this [blog post](https://qwenlm.github.io/blog/qwen1.5/) for details. + +[24/01/18] We supported **agent tuning** for most models, equipping model with tool using abilities by fine-tuning with `dataset: glaive_toolcall_en`. + +[23/12/23] We supported **[unsloth](https://github.com/unslothai/unsloth)**'s implementation to boost LoRA tuning for the LLaMA, Mistral and Yi models. Try `use_unsloth: true` argument to activate unsloth patch. It achieves **170%** speed in our benchmark, check [this page](https://github.com/hiyouga/LLaMA-Factory/wiki/Performance-comparison) for details. + +[23/12/12] We supported fine-tuning the latest MoE model **[Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1)** in our framework. See hardware requirement [here](#hardware-requirement). + +[23/12/01] We supported downloading pre-trained models and datasets from the **[ModelScope Hub](https://modelscope.cn/models)**. See [this tutorial](#download-from-modelscope-hub) for usage. + +[23/10/21] We supported **[NEFTune](https://arxiv.org/abs/2310.05914)** trick for fine-tuning. Try `neftune_noise_alpha: 5` argument to activate NEFTune. + +[23/09/27] We supported **$S^2$-Attn** proposed by [LongLoRA](https://github.com/dvlab-research/LongLoRA) for the LLaMA models. Try `shift_attn: true` argument to enable shift short attention. + +[23/09/23] We integrated MMLU, C-Eval and CMMLU benchmarks in this repo. See [examples](examples/README.md) for usage. + +[23/09/10] We supported **[FlashAttention-2](https://github.com/Dao-AILab/flash-attention)**. Try `flash_attn: fa2` argument to enable FlashAttention-2 if you are using RTX4090, A100 or H100 GPUs. + +[23/08/12] We supported **RoPE scaling** to extend the context length of the LLaMA models. Try `rope_scaling: linear` argument in training and `rope_scaling: dynamic` argument at inference to extrapolate the position embeddings. + +[23/08/11] We supported **[DPO training](https://arxiv.org/abs/2305.18290)** for instruction-tuned models. See [examples](examples/README.md) for usage. + +[23/07/31] We supported **dataset streaming**. Try `streaming: true` and `max_steps: 10000` arguments to load your dataset in streaming mode. + +[23/07/29] We released two instruction-tuned 13B models at Hugging Face. See these Hugging Face Repos ([LLaMA-2](https://huggingface.co/hiyouga/Llama-2-Chinese-13b-chat) / [Baichuan](https://huggingface.co/hiyouga/Baichuan-13B-sft)) for details. + +[23/07/18] We developed an **all-in-one Web UI** for training, evaluation and inference. Try `train_web.py` to fine-tune models in your Web browser. Thank [@KanadeSiina](https://github.com/KanadeSiina) and [@codemayq](https://github.com/codemayq) for their efforts in the development. + +[23/07/09] We released **[FastEdit](https://github.com/hiyouga/FastEdit)** ⚡🩹, an easy-to-use package for editing the factual knowledge of large language models efficiently. Please follow [FastEdit](https://github.com/hiyouga/FastEdit) if you are interested. + +[23/06/29] We provided a **reproducible example** of training a chat model using instruction-following datasets, see [Baichuan-7B-sft](https://huggingface.co/hiyouga/Baichuan-7B-sft) for details. + +[23/06/22] We aligned the [demo API](src/api_demo.py) with the [OpenAI's](https://platform.openai.com/docs/api-reference/chat) format where you can insert the fine-tuned model in **arbitrary ChatGPT-based applications**. + +[23/06/03] We supported quantized training and inference (aka **[QLoRA](https://github.com/artidoro/qlora)**). See [examples](examples/README.md) for usage. + +
+ +> [!TIP] +> If you cannot use the latest feature, please pull the latest code and install LLaMA-Factory again. + +## Supported Models + +| Model | Model size | Template | +| ----------------------------------------------------------------- | -------------------------------- | ------------------- | +| [Baichuan 2](https://huggingface.co/baichuan-inc) | 7B/13B | baichuan2 | +| [BLOOM/BLOOMZ](https://huggingface.co/bigscience) | 560M/1.1B/1.7B/3B/7.1B/176B | - | +| [ChatGLM3](https://huggingface.co/THUDM) | 6B | chatglm3 | +| [Command R](https://huggingface.co/CohereForAI) | 35B/104B | cohere | +| [DeepSeek (Code/MoE)](https://huggingface.co/deepseek-ai) | 7B/16B/67B/236B | deepseek | +| [DeepSeek 2.5/3](https://huggingface.co/deepseek-ai) | 236B/671B | deepseek3 | +| [DeepSeek R1 (Distill)](https://huggingface.co/deepseek-ai) | 1.5B/7B/8B/14B/32B/70B/671B | deepseekr1 | +| [Falcon](https://huggingface.co/tiiuae) | 7B/11B/40B/180B | falcon | +| [Falcon-H1](https://huggingface.co/tiiuae) | 0.5B/1.5B/3B/7B/34B | falcon_h1 | +| [Gemma/Gemma 2/CodeGemma](https://huggingface.co/google) | 2B/7B/9B/27B | gemma/gemma2 | +| [Gemma 3/Gemma 3n](https://huggingface.co/google) | 1B/4B/6B/8B/12B/27B | gemma3/gemma3n | +| [GLM-4/GLM-4-0414/GLM-Z1](https://huggingface.co/zai-org) | 9B/32B | glm4/glmz1 | +| [GLM-4.1V](https://huggingface.co/zai-org)* | 9B | glm4v | +| [GLM-4.5](https://huggingface.co/zai-org)* | 106B/355B | glm4_moe | +| [GPT-2](https://huggingface.co/openai-community) | 0.1B/0.4B/0.8B/1.5B | - | +| [GPT-OSS](https://huggingface.co/openai) | 20B/120B | gpt | +| [Granite 3.0-3.3](https://huggingface.co/ibm-granite) | 1B/2B/3B/8B | granite3 | +| [Granite 4](https://huggingface.co/ibm-granite) | 7B | granite4 | +| [Hunyuan](https://huggingface.co/tencent/) | 7B | hunyuan | +| [Index](https://huggingface.co/IndexTeam) | 1.9B | index | +| [InternLM 2-3](https://huggingface.co/internlm) | 7B/8B/20B | intern2 | +| [InternVL 2.5-3](https://huggingface.co/OpenGVLab) | 1B/2B/8B/14B/38B/78B | intern_vl | +| [Kimi-VL](https://huggingface.co/moonshotai) | 16B | kimi_vl | +| [Llama](https://github.com/facebookresearch/llama) | 7B/13B/33B/65B | - | +| [Llama 2](https://huggingface.co/meta-llama) | 7B/13B/70B | llama2 | +| [Llama 3-3.3](https://huggingface.co/meta-llama) | 1B/3B/8B/70B | llama3 | +| [Llama 4](https://huggingface.co/meta-llama) | 109B/402B | llama4 | +| [Llama 3.2 Vision](https://huggingface.co/meta-llama) | 11B/90B | mllama | +| [LLaVA-1.5](https://huggingface.co/llava-hf) | 7B/13B | llava | +| [LLaVA-NeXT](https://huggingface.co/llava-hf) | 7B/8B/13B/34B/72B/110B | llava_next | +| [LLaVA-NeXT-Video](https://huggingface.co/llava-hf) | 7B/34B | llava_next_video | +| [MiMo](https://huggingface.co/XiaomiMiMo) | 7B | mimo | +| [MiniCPM](https://huggingface.co/openbmb) | 0.5B/1B/2B/4B/8B | cpm/cpm3/cpm4 | +| [MiniCPM-o-2.6/MiniCPM-V-2.6](https://huggingface.co/openbmb) | 8B | minicpm_o/minicpm_v | +| [Ministral/Mistral-Nemo](https://huggingface.co/mistralai) | 8B/12B | ministral | +| [Mistral/Mixtral](https://huggingface.co/mistralai) | 7B/8x7B/8x22B | mistral | +| [Mistral Small](https://huggingface.co/mistralai) | 24B | mistral_small | +| [OLMo](https://huggingface.co/allenai) | 1B/7B | - | +| [PaliGemma/PaliGemma2](https://huggingface.co/google) | 3B/10B/28B | paligemma | +| [Phi-1.5/Phi-2](https://huggingface.co/microsoft) | 1.3B/2.7B | - | +| [Phi-3/Phi-3.5](https://huggingface.co/microsoft) | 4B/14B | phi | +| [Phi-3-small](https://huggingface.co/microsoft) | 7B | phi_small | +| [Phi-4](https://huggingface.co/microsoft) | 14B | phi4 | +| [Pixtral](https://huggingface.co/mistralai) | 12B | pixtral | +| [Qwen (1-2.5) (Code/Math/MoE/QwQ)](https://huggingface.co/Qwen) | 0.5B/1.5B/3B/7B/14B/32B/72B/110B | qwen | +| [Qwen3 (MoE)](https://huggingface.co/Qwen) | 0.6B/1.7B/4B/8B/14B/32B/235B | qwen3 | +| [Qwen2-Audio](https://huggingface.co/Qwen) | 7B | qwen2_audio | +| [Qwen2.5-Omni](https://huggingface.co/Qwen) | 3B/7B | qwen2_omni | +| [Qwen2-VL/Qwen2.5-VL/QVQ](https://huggingface.co/Qwen) | 2B/3B/7B/32B/72B | qwen2_vl | +| [Seed Coder](https://huggingface.co/ByteDance-Seed) | 8B | seed_coder | +| [Skywork o1](https://huggingface.co/Skywork) | 8B | skywork_o1 | +| [StarCoder 2](https://huggingface.co/bigcode) | 3B/7B/15B | - | +| [TeleChat2](https://huggingface.co/Tele-AI) | 3B/7B/35B/115B | telechat2 | +| [XVERSE](https://huggingface.co/xverse) | 7B/13B/65B | xverse | +| [Yi/Yi-1.5 (Code)](https://huggingface.co/01-ai) | 1.5B/6B/9B/34B | yi | +| [Yi-VL](https://huggingface.co/01-ai) | 6B/34B | yi_vl | +| [Yuan 2](https://huggingface.co/IEITYuan) | 2B/51B/102B | yuan | + +> [!NOTE] +> For the "base" models, the `template` argument can be chosen from `default`, `alpaca`, `vicuna` etc. But make sure to use the **corresponding template** for the "instruct/chat" models. +> +> Remember to use the **SAME** template in training and inference. +> +> \*: You should install the `transformers` from main branch and use `DISABLE_VERSION_CHECK=1` to skip version check. +> +> \*\*: You need to install a specific version of `transformers` to use the corresponding model. + +Please refer to [constants.py](src/llamafactory/extras/constants.py) for a full list of models we supported. + +You also can add a custom chat template to [template.py](src/llamafactory/data/template.py). + +## Supported Training Approaches + +| Approach | Full-tuning | Freeze-tuning | LoRA | QLoRA | +| ---------------------- | ------------------ | ------------------ | ------------------ | ------------------ | +| Pre-Training | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| Supervised Fine-Tuning | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| Reward Modeling | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| PPO Training | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| DPO Training | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| KTO Training | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| ORPO Training | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| SimPO Training | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | + +> [!TIP] +> The implementation details of PPO can be found in [this blog](https://newfacade.github.io/notes-on-reinforcement-learning/17-ppo-trl.html). + +## Provided Datasets + +
Pre-training datasets + +- [Wiki Demo (en)](data/wiki_demo.txt) +- [RefinedWeb (en)](https://huggingface.co/datasets/tiiuae/falcon-refinedweb) +- [RedPajama V2 (en)](https://huggingface.co/datasets/togethercomputer/RedPajama-Data-V2) +- [Wikipedia (en)](https://huggingface.co/datasets/olm/olm-wikipedia-20221220) +- [Wikipedia (zh)](https://huggingface.co/datasets/pleisto/wikipedia-cn-20230720-filtered) +- [Pile (en)](https://huggingface.co/datasets/EleutherAI/pile) +- [SkyPile (zh)](https://huggingface.co/datasets/Skywork/SkyPile-150B) +- [FineWeb (en)](https://huggingface.co/datasets/HuggingFaceFW/fineweb) +- [FineWeb-Edu (en)](https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu) +- [The Stack (en)](https://huggingface.co/datasets/bigcode/the-stack) +- [StarCoder (en)](https://huggingface.co/datasets/bigcode/starcoderdata) + +
+ +
Supervised fine-tuning datasets + +- [Identity (en&zh)](data/identity.json) +- [Stanford Alpaca (en)](https://github.com/tatsu-lab/stanford_alpaca) +- [Stanford Alpaca (zh)](https://github.com/ymcui/Chinese-LLaMA-Alpaca-3) +- [Alpaca GPT4 (en&zh)](https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM) +- [Glaive Function Calling V2 (en&zh)](https://huggingface.co/datasets/glaiveai/glaive-function-calling-v2) +- [LIMA (en)](https://huggingface.co/datasets/GAIR/lima) +- [Guanaco Dataset (multilingual)](https://huggingface.co/datasets/JosephusCheung/GuanacoDataset) +- [BELLE 2M (zh)](https://huggingface.co/datasets/BelleGroup/train_2M_CN) +- [BELLE 1M (zh)](https://huggingface.co/datasets/BelleGroup/train_1M_CN) +- [BELLE 0.5M (zh)](https://huggingface.co/datasets/BelleGroup/train_0.5M_CN) +- [BELLE Dialogue 0.4M (zh)](https://huggingface.co/datasets/BelleGroup/generated_chat_0.4M) +- [BELLE School Math 0.25M (zh)](https://huggingface.co/datasets/BelleGroup/school_math_0.25M) +- [BELLE Multiturn Chat 0.8M (zh)](https://huggingface.co/datasets/BelleGroup/multiturn_chat_0.8M) +- [UltraChat (en)](https://github.com/thunlp/UltraChat) +- [OpenPlatypus (en)](https://huggingface.co/datasets/garage-bAInd/Open-Platypus) +- [CodeAlpaca 20k (en)](https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k) +- [Alpaca CoT (multilingual)](https://huggingface.co/datasets/QingyiSi/Alpaca-CoT) +- [OpenOrca (en)](https://huggingface.co/datasets/Open-Orca/OpenOrca) +- [SlimOrca (en)](https://huggingface.co/datasets/Open-Orca/SlimOrca) +- [MathInstruct (en)](https://huggingface.co/datasets/TIGER-Lab/MathInstruct) +- [Firefly 1.1M (zh)](https://huggingface.co/datasets/YeungNLP/firefly-train-1.1M) +- [Wiki QA (en)](https://huggingface.co/datasets/wiki_qa) +- [Web QA (zh)](https://huggingface.co/datasets/suolyer/webqa) +- [WebNovel (zh)](https://huggingface.co/datasets/zxbsmk/webnovel_cn) +- [Nectar (en)](https://huggingface.co/datasets/berkeley-nest/Nectar) +- [deepctrl (en&zh)](https://www.modelscope.cn/datasets/deepctrl/deepctrl-sft-data) +- [Advertise Generating (zh)](https://huggingface.co/datasets/HasturOfficial/adgen) +- [ShareGPT Hyperfiltered (en)](https://huggingface.co/datasets/totally-not-an-llm/sharegpt-hyperfiltered-3k) +- [ShareGPT4 (en&zh)](https://huggingface.co/datasets/shibing624/sharegpt_gpt4) +- [UltraChat 200k (en)](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k) +- [AgentInstruct (en)](https://huggingface.co/datasets/THUDM/AgentInstruct) +- [LMSYS Chat 1M (en)](https://huggingface.co/datasets/lmsys/lmsys-chat-1m) +- [Evol Instruct V2 (en)](https://huggingface.co/datasets/WizardLM/WizardLM_evol_instruct_V2_196k) +- [Cosmopedia (en)](https://huggingface.co/datasets/HuggingFaceTB/cosmopedia) +- [STEM (zh)](https://huggingface.co/datasets/hfl/stem_zh_instruction) +- [Ruozhiba (zh)](https://huggingface.co/datasets/hfl/ruozhiba_gpt4_turbo) +- [Neo-sft (zh)](https://huggingface.co/datasets/m-a-p/neo_sft_phase2) +- [Magpie-Pro-300K-Filtered (en)](https://huggingface.co/datasets/Magpie-Align/Magpie-Pro-300K-Filtered) +- [Magpie-ultra-v0.1 (en)](https://huggingface.co/datasets/argilla/magpie-ultra-v0.1) +- [WebInstructSub (en)](https://huggingface.co/datasets/TIGER-Lab/WebInstructSub) +- [OpenO1-SFT (en&zh)](https://huggingface.co/datasets/O1-OPEN/OpenO1-SFT) +- [Open-Thoughts (en)](https://huggingface.co/datasets/open-thoughts/OpenThoughts-114k) +- [Open-R1-Math (en)](https://huggingface.co/datasets/open-r1/OpenR1-Math-220k) +- [Chinese-DeepSeek-R1-Distill (zh)](https://huggingface.co/datasets/Congliu/Chinese-DeepSeek-R1-Distill-data-110k-SFT) +- [LLaVA mixed (en&zh)](https://huggingface.co/datasets/BUAADreamer/llava-en-zh-300k) +- [Pokemon-gpt4o-captions (en&zh)](https://huggingface.co/datasets/jugg1024/pokemon-gpt4o-captions) +- [Open Assistant (de)](https://huggingface.co/datasets/mayflowergmbh/oasst_de) +- [Dolly 15k (de)](https://huggingface.co/datasets/mayflowergmbh/dolly-15k_de) +- [Alpaca GPT4 (de)](https://huggingface.co/datasets/mayflowergmbh/alpaca-gpt4_de) +- [OpenSchnabeltier (de)](https://huggingface.co/datasets/mayflowergmbh/openschnabeltier_de) +- [Evol Instruct (de)](https://huggingface.co/datasets/mayflowergmbh/evol-instruct_de) +- [Dolphin (de)](https://huggingface.co/datasets/mayflowergmbh/dolphin_de) +- [Booksum (de)](https://huggingface.co/datasets/mayflowergmbh/booksum_de) +- [Airoboros (de)](https://huggingface.co/datasets/mayflowergmbh/airoboros-3.0_de) +- [Ultrachat (de)](https://huggingface.co/datasets/mayflowergmbh/ultra-chat_de) + +
+ +
Preference datasets + +- [DPO mixed (en&zh)](https://huggingface.co/datasets/hiyouga/DPO-En-Zh-20k) +- [UltraFeedback (en)](https://huggingface.co/datasets/HuggingFaceH4/ultrafeedback_binarized) +- [COIG-P (zh)](https://huggingface.co/datasets/m-a-p/COIG-P) +- [RLHF-V (en)](https://huggingface.co/datasets/openbmb/RLHF-V-Dataset) +- [VLFeedback (en)](https://huggingface.co/datasets/Zhihui/VLFeedback) +- [RLAIF-V (en)](https://huggingface.co/datasets/openbmb/RLAIF-V-Dataset) +- [Orca DPO Pairs (en)](https://huggingface.co/datasets/Intel/orca_dpo_pairs) +- [HH-RLHF (en)](https://huggingface.co/datasets/Anthropic/hh-rlhf) +- [Nectar (en)](https://huggingface.co/datasets/berkeley-nest/Nectar) +- [Orca DPO (de)](https://huggingface.co/datasets/mayflowergmbh/intel_orca_dpo_pairs_de) +- [KTO mixed (en)](https://huggingface.co/datasets/argilla/kto-mix-15k) + +
+ +Some datasets require confirmation before using them, so we recommend logging in with your Hugging Face account using these commands. + +```bash +pip install --upgrade huggingface_hub +huggingface-cli login +``` + +## Requirement + +| Mandatory | Minimum | Recommend | +| ------------ | ------- | --------- | +| python | 3.9 | 3.10 | +| torch | 2.0.0 | 2.6.0 | +| torchvision | 0.15.0 | 0.21.0 | +| transformers | 4.49.0 | 4.50.0 | +| datasets | 2.16.0 | 3.2.0 | +| accelerate | 0.34.0 | 1.2.1 | +| peft | 0.14.0 | 0.15.1 | +| trl | 0.8.6 | 0.9.6 | + +| Optional | Minimum | Recommend | +| ------------ | ------- | --------- | +| CUDA | 11.6 | 12.2 | +| deepspeed | 0.10.0 | 0.16.4 | +| bitsandbytes | 0.39.0 | 0.43.1 | +| vllm | 0.4.3 | 0.8.2 | +| flash-attn | 2.5.6 | 2.7.2 | + +### Hardware Requirement + +\* *estimated* + +| Method | Bits | 7B | 14B | 30B | 70B | `x`B | +| ------------------------------- | ---- | ----- | ----- | ----- | ------ | ------- | +| Full (`bf16` or `fp16`) | 32 | 120GB | 240GB | 600GB | 1200GB | `18x`GB | +| Full (`pure_bf16`) | 16 | 60GB | 120GB | 300GB | 600GB | `8x`GB | +| Freeze/LoRA/GaLore/APOLLO/BAdam | 16 | 16GB | 32GB | 64GB | 160GB | `2x`GB | +| QLoRA | 8 | 10GB | 20GB | 40GB | 80GB | `x`GB | +| QLoRA | 4 | 6GB | 12GB | 24GB | 48GB | `x/2`GB | +| QLoRA | 2 | 4GB | 8GB | 16GB | 24GB | `x/4`GB | + +## Getting Started + +### Installation + +> [!IMPORTANT] +> Installation is mandatory. + +#### Install from Source + +```bash +git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git +cd LLaMA-Factory +pip install -e ".[torch,metrics]" --no-build-isolation +``` + +Extra dependencies available: torch, torch-npu, metrics, deepspeed, liger-kernel, bitsandbytes, hqq, eetq, gptq, aqlm, vllm, sglang, galore, apollo, badam, adam-mini, qwen, minicpm_v, openmind, swanlab, dev + +#### Install from Docker Image + +```bash +docker run -it --rm --gpus=all --ipc=host hiyouga/llamafactory:latest +``` + +This image is built on Ubuntu 22.04 (x86\_64), CUDA 12.4, Python 3.11, PyTorch 2.6.0, and Flash-attn 2.7.4. + +Find the pre-built images: https://hub.docker.com/r/hiyouga/llamafactory/tags + +Please refer to [build docker](#build-docker) to build the image yourself. + +
Setting up a virtual environment with uv + +Create an isolated Python environment with [uv](https://github.com/astral-sh/uv): + +```bash +uv sync --extra torch --extra metrics --prerelease=allow +``` + +Run LLaMA-Factory in the isolated environment: + +```bash +uv run --prerelease=allow llamafactory-cli train examples/train_lora/llama3_lora_pretrain.yaml +``` + +
+ +
For Windows users + +#### Install PyTorch + +You need to manually install the GPU version of PyTorch on the Windows platform. Please refer to the [official website](https://pytorch.org/get-started/locally/) and the following command to install PyTorch with CUDA support: + +```bash +pip uninstall torch torchvision torchaudio +pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126 +python -c "import torch; print(torch.cuda.is_available())" +``` + +If you see `True` then you have successfully installed PyTorch with CUDA support. + +Try `dataloader_num_workers: 0` if you encounter `Can't pickle local object` error. + +#### Install BitsAndBytes + +If you want to enable the quantized LoRA (QLoRA) on the Windows platform, you need to install a pre-built version of `bitsandbytes` library, which supports CUDA 11.1 to 12.2, please select the appropriate [release version](https://github.com/jllllll/bitsandbytes-windows-webui/releases/tag/wheels) based on your CUDA version. + +```bash +pip install https://github.com/jllllll/bitsandbytes-windows-webui/releases/download/wheels/bitsandbytes-0.41.2.post2-py3-none-win_amd64.whl +``` + +#### Install Flash Attention-2 + +To enable FlashAttention-2 on the Windows platform, please use the script from [flash-attention-windows-wheel](https://huggingface.co/lldacing/flash-attention-windows-wheel) to compile and install it by yourself. + +
+ +
For Ascend NPU users + +To install LLaMA Factory on Ascend NPU devices, please upgrade Python to version 3.10 or higher and specify extra dependencies: `pip install -e ".[torch-npu,metrics]"`. Additionally, you need to install the **[Ascend CANN Toolkit and Kernels](https://www.hiascend.com/developer/download/community/result?module=cann)**. Please follow the [installation tutorial](https://www.hiascend.com/document/detail/en/CANNCommunityEdition/600alphaX/softwareinstall/instg/atlasdeploy_03_0031.html) or use the following commands: + +```bash +# replace the url according to your CANN version and devices +# install CANN Toolkit +wget https://ascend-repo.obs.cn-east-2.myhuaweicloud.com/Milan-ASL/Milan-ASL%20V100R001C20SPC702/Ascend-cann-toolkit_8.0.0.alpha002_linux-"$(uname -i)".run +bash Ascend-cann-toolkit_8.0.0.alpha002_linux-"$(uname -i)".run --install + +# install CANN Kernels +wget https://ascend-repo.obs.cn-east-2.myhuaweicloud.com/Milan-ASL/Milan-ASL%20V100R001C20SPC702/Ascend-cann-kernels-910b_8.0.0.alpha002_linux-"$(uname -i)".run +bash Ascend-cann-kernels-910b_8.0.0.alpha002_linux-"$(uname -i)".run --install + +# set env variables +source /usr/local/Ascend/ascend-toolkit/set_env.sh +``` + +| Requirement | Minimum | Recommend | +| ------------ | ------- | -------------- | +| CANN | 8.0.RC1 | 8.0.0.alpha002 | +| torch | 2.1.0 | 2.4.0 | +| torch-npu | 2.1.0 | 2.4.0.post2 | +| deepspeed | 0.13.2 | 0.13.2 | +| vllm-ascend | - | 0.7.3 | + +Remember to use `ASCEND_RT_VISIBLE_DEVICES` instead of `CUDA_VISIBLE_DEVICES` to specify the device to use. + +If you cannot infer model on NPU devices, try setting `do_sample: false` in the configurations. + +Download the pre-built Docker images: [32GB](http://mirrors.cn-central-221.ovaijisuan.com/detail/130.html) | [64GB](http://mirrors.cn-central-221.ovaijisuan.com/detail/131.html) + +#### Install BitsAndBytes + +To use QLoRA based on bitsandbytes on Ascend NPU, please follow these 3 steps: + +1. Manually compile bitsandbytes: Refer to [the installation documentation](https://huggingface.co/docs/bitsandbytes/installation?backend=Ascend+NPU&platform=Ascend+NPU) for the NPU version of bitsandbytes to complete the compilation and installation. The compilation requires a cmake version of at least 3.22.1 and a g++ version of at least 12.x. + +```bash +# Install bitsandbytes from source +# Clone bitsandbytes repo, Ascend NPU backend is currently enabled on multi-backend-refactor branch +git clone -b multi-backend-refactor https://github.com/bitsandbytes-foundation/bitsandbytes.git +cd bitsandbytes/ + +# Install dependencies +pip install -r requirements-dev.txt + +# Install the dependencies for the compilation tools. Note that the commands for this step may vary depending on the operating system. The following are provided for reference +apt-get install -y build-essential cmake + +# Compile & install +cmake -DCOMPUTE_BACKEND=npu -S . +make +pip install . +``` + +2. Install transformers from the main branch. + +```bash +git clone -b main https://github.com/huggingface/transformers.git +cd transformers +pip install . +``` + +3. Set `double_quantization: false` in the configuration. You can refer to the [example](examples/train_qlora/llama3_lora_sft_bnb_npu.yaml). + +
+ +### Data Preparation + +Please refer to [data/README.md](data/README.md) for checking the details about the format of dataset files. You can use datasets on HuggingFace / ModelScope / Modelers hub, load the dataset in local disk, or specify a path to s3/gcs cloud storage. + +> [!NOTE] +> Please update `data/dataset_info.json` to use your custom dataset. + +You can also use **[Easy Dataset](https://github.com/ConardLi/easy-dataset)**, **[DataFlow](https://github.com/OpenDCAI/DataFlow)** and **[GraphGen](https://github.com/open-sciencelab/GraphGen)** to create synthetic data for fine-tuning. + +### Quickstart + +Use the following 3 commands to run LoRA **fine-tuning**, **inference** and **merging** of the Llama3-8B-Instruct model, respectively. + +```bash +llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml +llamafactory-cli chat examples/inference/llama3_lora_sft.yaml +llamafactory-cli export examples/merge_lora/llama3_lora_sft.yaml +``` + +See [examples/README.md](examples/README.md) for advanced usage (including distributed training). + +> [!TIP] +> Use `llamafactory-cli help` to show help information. +> +> Read [FAQs](https://github.com/hiyouga/LLaMA-Factory/issues/4614) first if you encounter any problems. + +### Fine-Tuning with LLaMA Board GUI (powered by [Gradio](https://github.com/gradio-app/gradio)) + +```bash +llamafactory-cli webui +``` + +### Build Docker + +For CUDA users: + +```bash +cd docker/docker-cuda/ +docker compose up -d +docker compose exec llamafactory bash +``` + +For Ascend NPU users: + +```bash +cd docker/docker-npu/ +docker compose up -d +docker compose exec llamafactory bash +``` + +For AMD ROCm users: + +```bash +cd docker/docker-rocm/ +docker compose up -d +docker compose exec llamafactory bash +``` + +
Build without Docker Compose + +For CUDA users: + +```bash +docker build -f ./docker/docker-cuda/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=metrics \ + -t llamafactory:latest . + +docker run -dit --ipc=host --gpus=all \ + -p 7860:7860 \ + -p 8000:8000 \ + --name llamafactory \ + llamafactory:latest + +docker exec -it llamafactory bash +``` + +For Ascend NPU users: + +```bash +docker build -f ./docker/docker-npu/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=torch-npu,metrics \ + -t llamafactory:latest . + +docker run -dit --ipc=host \ + -v /usr/local/dcmi:/usr/local/dcmi \ + -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \ + -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \ + -v /etc/ascend_install.info:/etc/ascend_install.info \ + -p 7860:7860 \ + -p 8000:8000 \ + --device /dev/davinci0 \ + --device /dev/davinci_manager \ + --device /dev/devmm_svm \ + --device /dev/hisi_hdc \ + --name llamafactory \ + llamafactory:latest + +docker exec -it llamafactory bash +``` + +For AMD ROCm users: + +```bash +docker build -f ./docker/docker-rocm/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=metrics \ + -t llamafactory:latest . + +docker run -dit --ipc=host \ + -p 7860:7860 \ + -p 8000:8000 \ + --device /dev/kfd \ + --device /dev/dri \ + --name llamafactory \ + llamafactory:latest + +docker exec -it llamafactory bash +``` + +
+ +
Use Docker volumes + +You can uncomment `VOLUME [ "/root/.cache/huggingface", "/app/shared_data", "/app/output" ]` in the Dockerfile to use data volumes. + +When building the Docker image, use `-v ./hf_cache:/root/.cache/huggingface` argument to mount the local directory to the container. The following data volumes are available. + +- `hf_cache`: Utilize Hugging Face cache on the host machine. +- `shared_data`: The directionary to store datasets on the host machine. +- `output`: Set export dir to this location so that the merged result can be accessed directly on the host machine. + +
+ +### Deploy with OpenAI-style API and vLLM + +```bash +API_PORT=8000 llamafactory-cli api examples/inference/llama3.yaml infer_backend=vllm vllm_enforce_eager=true +``` + +> [!TIP] +> Visit [this page](https://platform.openai.com/docs/api-reference/chat/create) for API document. +> +> Examples: [Image understanding](scripts/api_example/test_image.py) | [Function calling](scripts/api_example/test_toolcall.py) + +### Download from ModelScope Hub + +If you have trouble with downloading models and datasets from Hugging Face, you can use ModelScope. + +```bash +export USE_MODELSCOPE_HUB=1 # `set USE_MODELSCOPE_HUB=1` for Windows +``` + +Train the model by specifying a model ID of the ModelScope Hub as the `model_name_or_path`. You can find a full list of model IDs at [ModelScope Hub](https://modelscope.cn/models), e.g., `LLM-Research/Meta-Llama-3-8B-Instruct`. + +### Download from Modelers Hub + +You can also use Modelers Hub to download models and datasets. + +```bash +export USE_OPENMIND_HUB=1 # `set USE_OPENMIND_HUB=1` for Windows +``` + +Train the model by specifying a model ID of the Modelers Hub as the `model_name_or_path`. You can find a full list of model IDs at [Modelers Hub](https://modelers.cn/models), e.g., `TeleAI/TeleChat-7B-pt`. + +### Use W&B Logger + +To use [Weights & Biases](https://wandb.ai) for logging experimental results, you need to add the following arguments to yaml files. + +```yaml +report_to: wandb +run_name: test_run # optional +``` + +Set `WANDB_API_KEY` to [your key](https://wandb.ai/authorize) when launching training tasks to log in with your W&B account. + +### Use SwanLab Logger + +To use [SwanLab](https://github.com/SwanHubX/SwanLab) for logging experimental results, you need to add the following arguments to yaml files. + +```yaml +use_swanlab: true +swanlab_run_name: test_run # optional +``` + +When launching training tasks, you can log in to SwanLab in three ways: + +1. Add `swanlab_api_key=` to the yaml file, and set it to your [API key](https://swanlab.cn/settings). +2. Set the environment variable `SWANLAB_API_KEY` to your [API key](https://swanlab.cn/settings). +3. Use the `swanlab login` command to complete the login. + +## Projects using LLaMA Factory + +If you have a project that should be incorporated, please contact via email or create a pull request. + +
Click to show + +1. Wang et al. ESRL: Efficient Sampling-based Reinforcement Learning for Sequence Generation. 2023. [[arxiv]](https://arxiv.org/abs/2308.02223) +1. Yu et al. Open, Closed, or Small Language Models for Text Classification? 2023. [[arxiv]](https://arxiv.org/abs/2308.10092) +1. Wang et al. UbiPhysio: Support Daily Functioning, Fitness, and Rehabilitation with Action Understanding and Feedback in Natural Language. 2023. [[arxiv]](https://arxiv.org/abs/2308.10526) +1. Luceri et al. Leveraging Large Language Models to Detect Influence Campaigns in Social Media. 2023. [[arxiv]](https://arxiv.org/abs/2311.07816) +1. Zhang et al. Alleviating Hallucinations of Large Language Models through Induced Hallucinations. 2023. [[arxiv]](https://arxiv.org/abs/2312.15710) +1. Wang et al. Know Your Needs Better: Towards Structured Understanding of Marketer Demands with Analogical Reasoning Augmented LLMs. KDD 2024. [[arxiv]](https://arxiv.org/abs/2401.04319) +1. Wang et al. CANDLE: Iterative Conceptualization and Instantiation Distillation from Large Language Models for Commonsense Reasoning. ACL 2024. [[arxiv]](https://arxiv.org/abs/2401.07286) +1. Choi et al. FACT-GPT: Fact-Checking Augmentation via Claim Matching with LLMs. 2024. [[arxiv]](https://arxiv.org/abs/2402.05904) +1. Zhang et al. AutoMathText: Autonomous Data Selection with Language Models for Mathematical Texts. 2024. [[arxiv]](https://arxiv.org/abs/2402.07625) +1. Lyu et al. KnowTuning: Knowledge-aware Fine-tuning for Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.11176) +1. Yang et al. LaCo: Large Language Model Pruning via Layer Collaps. 2024. [[arxiv]](https://arxiv.org/abs/2402.11187) +1. Bhardwaj et al. Language Models are Homer Simpson! Safety Re-Alignment of Fine-tuned Language Models through Task Arithmetic. 2024. [[arxiv]](https://arxiv.org/abs/2402.11746) +1. Yang et al. Enhancing Empathetic Response Generation by Augmenting LLMs with Small-scale Empathetic Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.11801) +1. Yi et al. Generation Meets Verification: Accelerating Large Language Model Inference with Smart Parallel Auto-Correct Decoding. ACL 2024 Findings. [[arxiv]](https://arxiv.org/abs/2402.11809) +1. Cao et al. Head-wise Shareable Attention for Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.11819) +1. Zhang et al. Enhancing Multilingual Capabilities of Large Language Models through Self-Distillation from Resource-Rich Languages. 2024. [[arxiv]](https://arxiv.org/abs/2402.12204) +1. Kim et al. Efficient and Effective Vocabulary Expansion Towards Multilingual Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.14714) +1. Yu et al. KIEval: A Knowledge-grounded Interactive Evaluation Framework for Large Language Models. ACL 2024. [[arxiv]](https://arxiv.org/abs/2402.15043) +1. Huang et al. Key-Point-Driven Data Synthesis with its Enhancement on Mathematical Reasoning. 2024. [[arxiv]](https://arxiv.org/abs/2403.02333) +1. Duan et al. Negating Negatives: Alignment without Human Positive Samples via Distributional Dispreference Optimization. 2024. [[arxiv]](https://arxiv.org/abs/2403.03419) +1. Xie and Schwertfeger. Empowering Robotics with Large Language Models: osmAG Map Comprehension with LLMs. 2024. [[arxiv]](https://arxiv.org/abs/2403.08228) +1. Wu et al. Large Language Models are Parallel Multilingual Learners. 2024. [[arxiv]](https://arxiv.org/abs/2403.09073) +1. Zhang et al. EDT: Improving Large Language Models' Generation by Entropy-based Dynamic Temperature Sampling. 2024. [[arxiv]](https://arxiv.org/abs/2403.14541) +1. Weller et al. FollowIR: Evaluating and Teaching Information Retrieval Models to Follow Instructions. 2024. [[arxiv]](https://arxiv.org/abs/2403.15246) +1. Hongbin Na. CBT-LLM: A Chinese Large Language Model for Cognitive Behavioral Therapy-based Mental Health Question Answering. COLING 2024. [[arxiv]](https://arxiv.org/abs/2403.16008) +1. Zan et al. CodeS: Natural Language to Code Repository via Multi-Layer Sketch. 2024. [[arxiv]](https://arxiv.org/abs/2403.16443) +1. Liu et al. Extensive Self-Contrast Enables Feedback-Free Language Model Alignment. 2024. [[arxiv]](https://arxiv.org/abs/2404.00604) +1. Luo et al. BAdam: A Memory Efficient Full Parameter Training Method for Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.02827) +1. Du et al. Chinese Tiny LLM: Pretraining a Chinese-Centric Large Language Model. 2024. [[arxiv]](https://arxiv.org/abs/2404.04167) +1. Ma et al. Parameter Efficient Quasi-Orthogonal Fine-Tuning via Givens Rotation. ICML 2024. [[arxiv]](https://arxiv.org/abs/2404.04316) +1. Liu et al. Dynamic Generation of Personalities with Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.07084) +1. Shang et al. How Far Have We Gone in Stripped Binary Code Understanding Using Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.09836) +1. Huang et al. LLMTune: Accelerate Database Knob Tuning with Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.11581) +1. Deng et al. Text-Tuple-Table: Towards Information Integration in Text-to-Table Generation via Global Tuple Extraction. 2024. [[arxiv]](https://arxiv.org/abs/2404.14215) +1. Acikgoz et al. Hippocrates: An Open-Source Framework for Advancing Large Language Models in Healthcare. 2024. [[arxiv]](https://arxiv.org/abs/2404.16621) +1. Zhang et al. Small Language Models Need Strong Verifiers to Self-Correct Reasoning. ACL 2024 Findings. [[arxiv]](https://arxiv.org/abs/2404.17140) +1. Zhou et al. FREB-TQA: A Fine-Grained Robustness Evaluation Benchmark for Table Question Answering. NAACL 2024. [[arxiv]](https://arxiv.org/abs/2404.18585) +1. Xu et al. Large Language Models for Cyber Security: A Systematic Literature Review. 2024. [[arxiv]](https://arxiv.org/abs/2405.04760) +1. Dammu et al. "They are uncultured": Unveiling Covert Harms and Social Threats in LLM Generated Conversations. 2024. [[arxiv]](https://arxiv.org/abs/2405.05378) +1. Yi et al. A safety realignment framework via subspace-oriented model fusion for large language models. 2024. [[arxiv]](https://arxiv.org/abs/2405.09055) +1. Lou et al. SPO: Multi-Dimensional Preference Sequential Alignment With Implicit Reward Modeling. 2024. [[arxiv]](https://arxiv.org/abs/2405.12739) +1. Zhang et al. Getting More from Less: Large Language Models are Good Spontaneous Multilingual Learners. 2024. [[arxiv]](https://arxiv.org/abs/2405.13816) +1. Zhang et al. TS-Align: A Teacher-Student Collaborative Framework for Scalable Iterative Finetuning of Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2405.20215) +1. Zihong Chen. Sentence Segmentation and Sentence Punctuation Based on XunziALLM. 2024. [[paper]](https://aclanthology.org/2024.lt4hala-1.30) +1. Gao et al. The Best of Both Worlds: Toward an Honest and Helpful Large Language Model. 2024. [[arxiv]](https://arxiv.org/abs/2406.00380) +1. Wang and Song. MARS: Benchmarking the Metaphysical Reasoning Abilities of Language Models with a Multi-task Evaluation Dataset. 2024. [[arxiv]](https://arxiv.org/abs/2406.02106) +1. Hu et al. Computational Limits of Low-Rank Adaptation (LoRA) for Transformer-Based Models. 2024. [[arxiv]](https://arxiv.org/abs/2406.03136) +1. Ge et al. Time Sensitive Knowledge Editing through Efficient Finetuning. ACL 2024. [[arxiv]](https://arxiv.org/abs/2406.04496) +1. Tan et al. Peer Review as A Multi-Turn and Long-Context Dialogue with Role-Based Interactions. 2024. [[arxiv]](https://arxiv.org/abs/2406.05688) +1. Song et al. Turbo Sparse: Achieving LLM SOTA Performance with Minimal Activated Parameters. 2024. [[arxiv]](https://arxiv.org/abs/2406.05955) +1. Gu et al. RWKV-CLIP: A Robust Vision-Language Representation Learner. 2024. [[arxiv]](https://arxiv.org/abs/2406.06973) +1. Chen et al. Advancing Tool-Augmented Large Language Models: Integrating Insights from Errors in Inference Trees. 2024. [[arxiv]](https://arxiv.org/abs/2406.07115) +1. Zhu et al. Are Large Language Models Good Statisticians?. 2024. [[arxiv]](https://arxiv.org/abs/2406.07815) +1. Li et al. Know the Unknown: An Uncertainty-Sensitive Method for LLM Instruction Tuning. 2024. [[arxiv]](https://arxiv.org/abs/2406.10099) +1. Ding et al. IntentionQA: A Benchmark for Evaluating Purchase Intention Comprehension Abilities of Language Models in E-commerce. 2024. [[arxiv]](https://arxiv.org/abs/2406.10173) +1. He et al. COMMUNITY-CROSS-INSTRUCT: Unsupervised Instruction Generation for Aligning Large Language Models to Online Communities. 2024. [[arxiv]](https://arxiv.org/abs/2406.12074) +1. Lin et al. FVEL: Interactive Formal Verification Environment with Large Language Models via Theorem Proving. 2024. [[arxiv]](https://arxiv.org/abs/2406.14408) +1. Treutlein et al. Connecting the Dots: LLMs can Infer and Verbalize Latent Structure from Disparate Training Data. 2024. [[arxiv]](https://arxiv.org/abs/2406.14546) +1. Feng et al. SS-Bench: A Benchmark for Social Story Generation and Evaluation. 2024. [[arxiv]](https://arxiv.org/abs/2406.15695) +1. Feng et al. Self-Constructed Context Decompilation with Fined-grained Alignment Enhancement. 2024. [[arxiv]](https://arxiv.org/abs/2406.17233) +1. Liu et al. Large Language Models for Cuffless Blood Pressure Measurement From Wearable Biosignals. 2024. [[arxiv]](https://arxiv.org/abs/2406.18069) +1. Iyer et al. Exploring Very Low-Resource Translation with LLMs: The University of Edinburgh's Submission to AmericasNLP 2024 Translation Task. AmericasNLP 2024. [[paper]](https://aclanthology.org/2024.americasnlp-1.25) +1. Li et al. Calibrating LLMs with Preference Optimization on Thought Trees for Generating Rationale in Science Question Scoring. 2024. [[arxiv]](https://arxiv.org/abs/2406.19949) +1. Yang et al. Financial Knowledge Large Language Model. 2024. [[arxiv]](https://arxiv.org/abs/2407.00365) +1. Lin et al. DogeRM: Equipping Reward Models with Domain Knowledge through Model Merging. 2024. [[arxiv]](https://arxiv.org/abs/2407.01470) +1. Bako et al. Evaluating the Semantic Profiling Abilities of LLMs for Natural Language Utterances in Data Visualization. 2024. [[arxiv]](https://arxiv.org/abs/2407.06129) +1. Huang et al. RoLoRA: Fine-tuning Rotated Outlier-free LLMs for Effective Weight-Activation Quantization. 2024. [[arxiv]](https://arxiv.org/abs/2407.08044) +1. Jiang et al. LLM-Collaboration on Automatic Science Journalism for the General Audience. 2024. [[arxiv]](https://arxiv.org/abs/2407.09756) +1. Inouye et al. Applied Auto-tuning on LoRA Hyperparameters. 2024. [[paper]](https://scholarcommons.scu.edu/cseng_senior/272/) +1. Qi et al. Research on Tibetan Tourism Viewpoints information generation system based on LLM. 2024. [[arxiv]](https://arxiv.org/abs/2407.13561) +1. Xu et al. Course-Correction: Safety Alignment Using Synthetic Preferences. 2024. [[arxiv]](https://arxiv.org/abs/2407.16637) +1. Sun et al. LAMBDA: A Large Model Based Data Agent. 2024. [[arxiv]](https://arxiv.org/abs/2407.17535) +1. Zhu et al. CollectiveSFT: Scaling Large Language Models for Chinese Medical Benchmark with Collective Instructions in Healthcare. 2024. [[arxiv]](https://arxiv.org/abs/2407.19705) +1. Yu et al. Correcting Negative Bias in Large Language Models through Negative Attention Score Alignment. 2024. [[arxiv]](https://arxiv.org/abs/2408.00137) +1. Xie et al. The Power of Personalized Datasets: Advancing Chinese Composition Writing for Elementary School through Targeted Model Fine-Tuning. IALP 2024. [[paper]](https://www.asianlp.sg/conferences/ialp2024/proceedings/papers/IALP2024_P055.pdf) +1. Liu et al. Instruct-Code-Llama: Improving Capabilities of Language Model in Competition Level Code Generation by Online Judge Feedback. ICIC 2024. [[paper]](https://link.springer.com/chapter/10.1007/978-981-97-5669-8_11) +1. Wang et al. Cybernetic Sentinels: Unveiling the Impact of Safety Data Selection on Model Security in Supervised Fine-Tuning. ICIC 2024. [[paper]](https://link.springer.com/chapter/10.1007/978-981-97-5669-8_23) +1. Xia et al. Understanding the Performance and Estimating the Cost of LLM Fine-Tuning. 2024. [[arxiv]](https://arxiv.org/abs/2408.04693) +1. Zeng et al. Perceive, Reflect, and Plan: Designing LLM Agent for Goal-Directed City Navigation without Instructions. 2024. [[arxiv]](https://arxiv.org/abs/2408.04168) +1. Xia et al. Using Pre-trained Language Model for Accurate ESG Prediction. FinNLP 2024. [[paper]](https://aclanthology.org/2024.finnlp-2.1/) +1. Liang et al. I-SHEEP: Self-Alignment of LLM from Scratch through an Iterative Self-Enhancement Paradigm. 2024. [[arxiv]](https://arxiv.org/abs/2408.08072) +1. Bai et al. Aligning Large Language Model with Direct Multi-Preference Optimization for Recommendation. CIKM 2024. [[paper]](https://dl.acm.org/doi/10.1145/3627673.3679611) +1. Zhang et al. CPsyCoun: A Report-based Multi-turn Dialogue Reconstruction and Evaluation Framework for Chinese Psychological Counseling. ACL 2024. [[paper]](https://aclanthology.org/2024.findings-acl.830.pdf) +1. **[StarWhisper](https://github.com/Yu-Yang-Li/StarWhisper)**: A large language model for Astronomy, based on ChatGLM2-6B and Qwen-14B. +1. **[DISC-LawLLM](https://github.com/FudanDISC/DISC-LawLLM)**: A large language model specialized in Chinese legal domain, based on Baichuan-13B, is capable of retrieving and reasoning on legal knowledge. +1. **[Sunsimiao](https://github.com/X-D-Lab/Sunsimiao)**: A large language model specialized in Chinese medical domain, based on Baichuan-7B and ChatGLM-6B. +1. **[CareGPT](https://github.com/WangRongsheng/CareGPT)**: A series of large language models for Chinese medical domain, based on LLaMA2-7B and Baichuan-13B. +1. **[MachineMindset](https://github.com/PKU-YuanGroup/Machine-Mindset/)**: A series of MBTI Personality large language models, capable of giving any LLM 16 different personality types based on different datasets and training methods. +1. **[Luminia-13B-v3](https://huggingface.co/Nekochu/Luminia-13B-v3)**: A large language model specialized in generate metadata for stable diffusion. [[demo]](https://huggingface.co/spaces/Nekochu/Luminia-13B_SD_Prompt) +1. **[Chinese-LLaVA-Med](https://github.com/BUAADreamer/Chinese-LLaVA-Med)**: A multimodal large language model specialized in Chinese medical domain, based on LLaVA-1.5-7B. +1. **[AutoRE](https://github.com/THUDM/AutoRE)**: A document-level relation extraction system based on large language models. +1. **[NVIDIA RTX AI Toolkit](https://github.com/NVIDIA/RTX-AI-Toolkit)**: SDKs for fine-tuning LLMs on Windows PC for NVIDIA RTX. +1. **[LazyLLM](https://github.com/LazyAGI/LazyLLM)**: An easy and lazy way for building multi-agent LLMs applications and supports model fine-tuning via LLaMA Factory. +1. **[RAG-Retrieval](https://github.com/NLPJCL/RAG-Retrieval)**: A full pipeline for RAG retrieval model fine-tuning, inference, and distillation. [[blog]](https://zhuanlan.zhihu.com/p/987727357) +1. **[360-LLaMA-Factory](https://github.com/Qihoo360/360-LLaMA-Factory)**: A modified library that supports long sequence SFT & DPO using ring attention. +1. **[Sky-T1](https://novasky-ai.github.io/posts/sky-t1/)**: An o1-like model fine-tuned by NovaSky AI with very small cost. +1. **[WeClone](https://github.com/xming521/WeClone)**: One-stop solution for creating your digital avatar from chat logs. +1. **[EmoLLM](https://github.com/SmartFlowAI/EmoLLM)**: A project about large language models (LLMs) and mental health. +
+ +## License + +This repository is licensed under the [Apache-2.0 License](LICENSE). + +Please follow the model licenses to use the corresponding model weights: [Baichuan 2](https://huggingface.co/baichuan-inc/Baichuan2-7B-Base/blob/main/Community%20License%20for%20Baichuan%202%20Model.pdf) / [BLOOM](https://huggingface.co/spaces/bigscience/license) / [ChatGLM3](https://github.com/THUDM/ChatGLM3/blob/main/MODEL_LICENSE) / [Command R](https://cohere.com/c4ai-cc-by-nc-license) / [DeepSeek](https://github.com/deepseek-ai/DeepSeek-LLM/blob/main/LICENSE-MODEL) / [Falcon](https://huggingface.co/tiiuae/falcon-180B/blob/main/LICENSE.txt) / [Gemma](https://ai.google.dev/gemma/terms) / [GLM-4](https://huggingface.co/THUDM/glm-4-9b/blob/main/LICENSE) / [GPT-2](https://github.com/openai/gpt-2/blob/master/LICENSE) / [Granite](LICENSE) / [Index](https://huggingface.co/IndexTeam/Index-1.9B/blob/main/LICENSE) / [InternLM](https://github.com/InternLM/InternLM#license) / [Llama](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) / [Llama 2](https://ai.meta.com/llama/license/) / [Llama 3](https://llama.meta.com/llama3/license/) / [Llama 4](https://github.com/meta-llama/llama-models/blob/main/models/llama4/LICENSE) / [MiniCPM](https://github.com/OpenBMB/MiniCPM/blob/main/MiniCPM%20Model%20License.md) / [Mistral/Mixtral/Pixtral](LICENSE) / [OLMo](LICENSE) / [Phi-1.5/Phi-2](https://huggingface.co/microsoft/phi-1_5/resolve/main/Research%20License.docx) / [Phi-3/Phi-4](https://huggingface.co/microsoft/Phi-3-mini-4k-instruct/blob/main/LICENSE) / [Qwen](https://github.com/QwenLM/Qwen/blob/main/Tongyi%20Qianwen%20LICENSE%20AGREEMENT) / [Skywork](https://huggingface.co/Skywork/Skywork-13B-base/blob/main/Skywork%20Community%20License.pdf) / [StarCoder 2](https://huggingface.co/spaces/bigcode/bigcode-model-license-agreement) / [TeleChat2](https://huggingface.co/Tele-AI/telechat-7B/blob/main/TeleChat%E6%A8%A1%E5%9E%8B%E7%A4%BE%E5%8C%BA%E8%AE%B8%E5%8F%AF%E5%8D%8F%E8%AE%AE.pdf) / [XVERSE](https://github.com/xverse-ai/XVERSE-13B/blob/main/MODEL_LICENSE.pdf) / [Yi](https://huggingface.co/01-ai/Yi-6B/blob/main/LICENSE) / [Yi-1.5](LICENSE) / [Yuan 2](https://github.com/IEIT-Yuan/Yuan-2.0/blob/main/LICENSE-Yuan) + +## Citation + +If this work is helpful, please kindly cite as: + +```bibtex +@inproceedings{zheng2024llamafactory, + title={LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models}, + author={Yaowei Zheng and Richong Zhang and Junhao Zhang and Yanhan Ye and Zheyan Luo and Zhangchi Feng and Yongqiang Ma}, + booktitle={Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations)}, + address={Bangkok, Thailand}, + publisher={Association for Computational Linguistics}, + year={2024}, + url={http://arxiv.org/abs/2403.13372} +} +``` + +## Acknowledgement + +This repo benefits from [PEFT](https://github.com/huggingface/peft), [TRL](https://github.com/huggingface/trl), [QLoRA](https://github.com/artidoro/qlora) and [FastChat](https://github.com/lm-sys/FastChat). Thanks for their wonderful works. + +## Star History + +![Star History Chart](https://api.star-history.com/svg?repos=hiyouga/LLaMA-Factory&type=Date) diff --git a/src/train_sft/README_zh.md b/src/train_sft/README_zh.md new file mode 100644 index 0000000000000000000000000000000000000000..e970255c2336c6c002bf2af6bd2ff2754b3c1934 --- /dev/null +++ b/src/train_sft/README_zh.md @@ -0,0 +1,951 @@ +![# LLaMA Factory](assets/logo.png) + +[![GitHub Repo stars](https://img.shields.io/github/stars/hiyouga/LLaMA-Factory?style=social)](https://github.com/hiyouga/LLaMA-Factory/stargazers) +[![GitHub last commit](https://img.shields.io/github/last-commit/hiyouga/LLaMA-Factory)](https://github.com/hiyouga/LLaMA-Factory/commits/main) +[![GitHub contributors](https://img.shields.io/github/contributors/hiyouga/LLaMA-Factory?color=orange)](https://github.com/hiyouga/LLaMA-Factory/graphs/contributors) +[![GitHub workflow](https://github.com/hiyouga/LLaMA-Factory/actions/workflows/tests.yml/badge.svg)](https://github.com/hiyouga/LLaMA-Factory/actions/workflows/tests.yml) +[![PyPI](https://img.shields.io/pypi/v/llamafactory)](https://pypi.org/project/llamafactory/) +[![Citation](https://img.shields.io/badge/citation-760-green)](https://scholar.google.com/scholar?cites=12620864006390196564) +[![Docker Pulls](https://img.shields.io/docker/pulls/hiyouga/llamafactory)](https://hub.docker.com/r/hiyouga/llamafactory/tags) + +[![Twitter](https://img.shields.io/twitter/follow/llamafactory_ai)](https://twitter.com/llamafactory_ai) +[![Discord](https://dcbadge.vercel.app/api/server/rKfvV9r9FK?compact=true&style=flat)](https://discord.gg/rKfvV9r9FK) +[![GitCode](https://gitcode.com/zhengyaowei/LLaMA-Factory/star/badge.svg)](https://gitcode.com/zhengyaowei/LLaMA-Factory) + +[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1d5KQtbemerlSDSxZIfAaWXhKr30QypiK?usp=sharing) +[![Open in DSW](https://gallery.pai-ml.com/assets/open-in-dsw.svg)](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory) +[![Open in Alaya](assets/alaya_new.svg)](https://docs.alayanew.com/docs/documents/newActivities/llamafactory/?utm_source=LLaMA-Factory) +[![Open in Spaces](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue)](https://huggingface.co/spaces/hiyouga/LLaMA-Board) +[![Open in Studios](https://img.shields.io/badge/ModelScope-Open%20in%20Studios-blue)](https://modelscope.cn/studios/hiyouga/LLaMA-Board) +[![Open in Novita](https://img.shields.io/badge/Novita-Deploy%20Template-blue)](https://novita.ai/templates-library/105981?sharer=88115474-394e-4bda-968e-b88e123d0c47) + +### 获得[亚马逊](https://aws.amazon.com/cn/blogs/china/a-one-stop-code-free-model-fine-tuning-deployment-platform-based-on-sagemaker-and-llama-factory/)、[英伟达](https://developer.nvidia.cn/rtx/ai-toolkit)、[阿里云](https://help.aliyun.com/zh/pai/use-cases/fine-tune-a-llama-3-model-with-llama-factory)等的应用。 + +
+ +### 赞助商 ❤️ + +|
Warp sponsorship
Warp，面向开发者的智能终端
适用于 MacOS、Linux 和 Windows | SerpAPI sponsorship | +| ---- | ---- | + +---- + +### 使用零代码[命令行](#快速开始)与 [Web UI](#llama-board-可视化微调由-gradio-驱动) 轻松微调百余种大模型 + +![GitHub Trend](https://trendshift.io/api/badge/repositories/4535) + +
+ +👋 加入我们的[微信群](assets/wechat.jpg)、[NPU 用户群](assets/wechat_npu.jpg)或 [九章智算云算力优惠群](assets/wechat_alaya.png)。 + +\[ [English](README.md) | 中文 \] + +**微调大模型可以像这样轻松…** + +https://github.com/user-attachments/assets/43b700c6-a178-41db-b1f8-8190a5d3fcfc + +选择你的打开方式： + +- **入门教程**：https://zhuanlan.zhihu.com/p/695287607 +- **微调视频教程**：https://www.bilibili.com/video/BV1djgRzxEts/ +- **框架文档**：https://llamafactory.readthedocs.io/zh-cn/latest/ +- **框架文档（昇腾 NPU）**：https://ascend.github.io/docs/sources/llamafactory/ +- **Colab（免费）**：https://colab.research.google.com/drive/1d5KQtbemerlSDSxZIfAaWXhKr30QypiK?usp=sharing +- **本地机器**：请见[如何使用](#如何使用) +- **PAI-DSW（免费试用）**：https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory +- **九章智算云（算力优惠活动）**：https://docs.alayanew.com/docs/documents/useGuide/LLaMAFactory/mutiple/?utm_source=LLaMA-Factory + +> [!NOTE] +> 除上述链接以外的其他网站均为未经许可的第三方网站，请小心甄别。 + +## 目录 + +- [项目特色](#项目特色) +- [官方博客](#官方博客) +- [更新日志](#更新日志) +- [模型](#模型) +- [训练方法](#训练方法) +- [数据集](#数据集) +- [软硬件依赖](#软硬件依赖) +- [如何使用](#如何使用) + - [安装 LLaMA Factory](#安装-llama-factory) + - [数据准备](#数据准备) + - [快速开始](#快速开始) + - [LLaMA Board 可视化微调](#llama-board-可视化微调由-gradio-驱动) + - [构建 Docker](#构建-docker) + - [利用 vLLM 部署 OpenAI API](#利用-vllm-部署-openai-api) + - [从魔搭社区下载](#从魔搭社区下载) + - [从魔乐社区下载](#从魔乐社区下载) + - [使用 W&B 面板](#使用-wb-面板) + - [使用 SwanLab 面板](#使用-swanlab-面板) +- [使用了 LLaMA Factory 的项目](#使用了-llama-factory-的项目) +- [协议](#协议) +- [引用](#引用) +- [致谢](#致谢) + +## 项目特色 + +- **多种模型**：LLaMA、LLaVA、Mistral、Mixtral-MoE、Qwen、Qwen2-VL、DeepSeek、Yi、Gemma、ChatGLM、Phi 等等。 +- **集成方法**：（增量）预训练、（多模态）指令监督微调、奖励模型训练、PPO 训练、DPO 训练、KTO 训练、ORPO 训练等等。 +- **多种精度**：16 比特全参数微调、冻结微调、LoRA 微调和基于 AQLM/AWQ/GPTQ/LLM.int8/HQQ/EETQ 的 2/3/4/5/6/8 比特 QLoRA 微调。 +- **先进算法**：[GaLore](https://github.com/jiaweizzhao/GaLore)、[BAdam](https://github.com/Ledzy/BAdam)、[APOLLO](https://github.com/zhuhanqing/APOLLO)、[Adam-mini](https://github.com/zyushun/Adam-mini)、[Muon](https://github.com/KellerJordan/Muon)、DoRA、LongLoRA、LLaMA Pro、Mixture-of-Depths、LoRA+、LoftQ 和 PiSSA。 +- **实用技巧**：[FlashAttention-2](https://github.com/Dao-AILab/flash-attention)、[Unsloth](https://github.com/unslothai/unsloth)、[Liger Kernel](https://github.com/linkedin/Liger-Kernel)、RoPE scaling、NEFTune 和 rsLoRA。 +- **广泛任务**：多轮对话、工具调用、图像理解、视觉定位、视频识别和语音理解等等。 +- **实验监控**：LlamaBoard、TensorBoard、Wandb、MLflow、[SwanLab](https://github.com/SwanHubX/SwanLab) 等等。 +- **极速推理**：基于 [vLLM](https://github.com/vllm-project/vllm) 或 [SGLang](https://github.com/sgl-project/sglang) 的 OpenAI 风格 API、浏览器界面和命令行接口。 + +### 最新模型的 Day-N 微调适配 + +| 适配时间 | 模型名称 | +| ------------ | -------------------------------------------------------------------- | +| Day 0 | Qwen3 / Qwen2.5-VL / Gemma 3 / GLM-4.1V / InternLM 3 / MiniCPM-o-2.6 | +| Day 1 | Llama 3 / GLM-4 / Mistral Small / PaliGemma2 / Llama 4 | + +## 官方博客 + +- [使用 LLaMA-Factory 构建 GPT-OSS 角色扮演模型](https://docs.llamafactory.com.cn/docs/documents/best-practice/gptoss/?utm_source=LLaMA-Factory)（中文） +- [使用 LLaMA-Factory 微调 Llama3.1-70B 医学诊断模型](https://docs.alayanew.com/docs/documents/bestPractice/bigModel/llama70B/?utm_source=LLaMA-Factory)（中文） +- [基于 LLaMA-Factory 和 EasyR1 打造一站式无代码大模型强化学习和部署平台 LLM Model Hub](https://aws.amazon.com/cn/blogs/china/building-llm-model-hub-based-on-llamafactory-and-easyr1/)（中文） +- [通过亚马逊 SageMaker HyperPod 上的 LLaMA-Factory 增强多模态模型银行文档的视觉信息提取](https://aws.amazon.com/cn/blogs/machine-learning/how-apoidea-group-enhances-visual-information-extraction-from-banking-documents-with-multimodal-models-using-llama-factory-on-amazon-sagemaker-hyperpod/)（英文） +- [Easy Dataset × LLaMA Factory: 让大模型高效学习领域知识](https://buaa-act.feishu.cn/wiki/KY9xwTGs1iqHrRkjXBwcZP9WnL9)（中文） + +
全部博客 + +- [使用 LLaMA-Factory 微调 Qwen2.5-VL 实现自动驾驶场景微调](https://docs.alayanew.com/docs/documents/useGuide/LLaMAFactory/mutiple/?utm_source=LLaMA-Factory)（中文） +- [LLaMA Factory：微调 DeepSeek-R1-Distill-Qwen-7B 模型实现新闻标题分类器](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory_deepseek_r1_distill_7b)（中文） +- [基于 Amazon SageMaker 和 LLaMA-Factory 打造一站式无代码模型微调部署平台 Model Hub](https://aws.amazon.com/cn/blogs/china/a-one-stop-code-free-model-fine-tuning-deployment-platform-based-on-sagemaker-and-llama-factory/)（中文） +- [LLaMA Factory 多模态微调实践：微调 Qwen2-VL 构建文旅大模型](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory_qwen2vl)（中文） +- [LLaMA Factory：微调 Llama3 模型实现角色扮演](https://gallery.pai-ml.com/#/preview/deepLearning/nlp/llama_factory)（中文） + +
+ +## 更新日志 + +[25/08/06] 我们支持了 **[GPT-OSS](https://github.com/openai/gpt-oss)** 模型的微调。查看 [PR #8826](https://github.com/hiyouga/LLaMA-Factory/pull/8826) 以使用。 + +[25/07/02] 我们支持了 **[GLM-4.1V-9B-Thinking](https://github.com/THUDM/GLM-4.1V-Thinking)** 模型的微调。 + +[25/04/28] 我们支持了 **[Qwen3](https://qwenlm.github.io/blog/qwen3/)** 系列模型的微调。 + +
展开日志 + +[25/04/21] 我们支持了 **[Muon](https://github.com/KellerJordan/Muon)** 优化器。详细用法请参照 [examples](examples/README_zh.md)。感谢 [@tianshijing](https://github.com/tianshijing) 的 PR。 + +[25/04/16] 我们支持了 **[InternVL3](https://huggingface.co/OpenGVLab/InternVL3-8B)** 模型的微调。查看 [PR #7258](https://github.com/hiyouga/LLaMA-Factory/pull/7258) 以使用。 + +[25/04/14] 我们支持了 **[GLM-Z1](https://huggingface.co/THUDM/GLM-Z1-9B-0414)** 和 **[Kimi-VL](https://huggingface.co/moonshotai/Kimi-VL-A3B-Instruct)** 模型的微调。 + +[25/04/06] 我们支持了 **[Llama 4](https://ai.meta.com/blog/llama-4-multimodal-intelligence/)** 模型的微调。查看 [PR #7611](https://github.com/hiyouga/LLaMA-Factory/pull/7611) 以使用。 + +[25/03/31] 我们支持了 **[Qwen2.5 Omni](https://qwenlm.github.io/blog/qwen2.5-omni/)** 模型的微调。查看 [PR #7537](https://github.com/hiyouga/LLaMA-Factory/pull/7537) 以使用。 + +[25/03/15] 我们支持了 **[SGLang](https://github.com/sgl-project/sglang)** 推理后端，请使用 `infer_backend: sglang` 启用。 + +[25/03/12] 我们支持了 **[Gemma 3](https://huggingface.co/blog/gemma3)** 模型的微调。 + +[25/02/24] 我们宣布开源 **[EasyR1](https://github.com/hiyouga/EasyR1)**，一个高效可扩展的多模态强化学习框架，支持高效的 GRPO 训练。 + +[25/02/11] 我们支持了在导出模型时保存 **[Ollama](https://github.com/ollama/ollama)** 配置文件。详细用法请参照 [examples](examples/README_zh.md)。 + +[25/02/05] 我们支持了在语音理解任务上微调 **[Qwen2-Audio](Qwen/Qwen2-Audio-7B-Instruct)** 和 **[MiniCPM-o-2.6](https://huggingface.co/openbmb/MiniCPM-o-2_6)** 模型。 + +[25/01/31] 我们支持了 **[DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)** 和 **[Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct)** 模型的微调。 + +[25/01/15] 我们支持了 **[APOLLO](https://arxiv.org/abs/2412.05270)** 优化器。详细用法请参照 [examples](examples/README_zh.md)。 + +[25/01/14] 我们支持了 **[MiniCPM-o-2.6](https://huggingface.co/openbmb/MiniCPM-o-2_6)** 和 **[MiniCPM-V-2.6](https://huggingface.co/openbmb/MiniCPM-V-2_6)** 模型的微调。 感谢 [@BUAADreamer](https://github.com/BUAADreamer) 的 PR. + +[25/01/14] 我们支持了 **[InternLM 3](https://huggingface.co/collections/internlm/)** 模型的微调。感谢 [@hhaAndroid](https://github.com/hhaAndroid) 的 PR。 + +[25/01/10] 我们支持了 **[Phi-4](https://huggingface.co/microsoft/phi-4)** 模型的微调。 + +[24/12/21] 我们支持了使用 **[SwanLab](https://github.com/SwanHubX/SwanLab)** 跟踪与可视化实验。详细用法请参考 [此部分](#使用-swanlab-面板)。 + +[24/11/27] 我们支持了 **[Skywork-o1](https://huggingface.co/Skywork/Skywork-o1-Open-Llama-3.1-8B)** 模型的微调和 **[OpenO1](https://huggingface.co/datasets/O1-OPEN/OpenO1-SFT)** 数据集。 + +[24/10/09] 我们支持了从 **[魔乐社区](https://modelers.cn/models)** 下载预训练模型和数据集。详细用法请参照 [此教程](#从魔乐社区下载)。 + +[24/09/19] 我们支持了 **[Qwen2.5](https://qwenlm.github.io/blog/qwen2.5/)** 模型的微调。 + +[24/08/30] 我们支持了 **[Qwen2-VL](https://qwenlm.github.io/blog/qwen2-vl/)** 模型的微调。感谢 [@simonJJJ](https://github.com/simonJJJ) 的 PR。 + +[24/08/27] 我们支持了 **[Liger Kernel](https://github.com/linkedin/Liger-Kernel)**。请使用 `enable_liger_kernel: true` 来加速训练。 + +[24/08/09] 我们支持了 **[Adam-mini](https://github.com/zyushun/Adam-mini)** 优化器。详细用法请参照 [examples](examples/README_zh.md)。感谢 [@relic-yuexi](https://github.com/relic-yuexi) 的 PR。 + +[24/07/04] 我们支持了[无污染打包训练](https://github.com/MeetKai/functionary/tree/main/functionary/train/packing)。请使用 `neat_packing: true` 参数。感谢 [@chuan298](https://github.com/chuan298) 的 PR。 + +[24/06/16] 我们支持了 **[PiSSA](https://arxiv.org/abs/2404.02948)** 算法。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/06/07] 我们支持了 **[Qwen2](https://qwenlm.github.io/blog/qwen2/)** 和 **[GLM-4](https://github.com/THUDM/GLM-4)** 模型的微调。 + +[24/05/26] 我们支持了 **[SimPO](https://arxiv.org/abs/2405.14734)** 偏好对齐算法。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/05/20] 我们支持了 **PaliGemma** 系列模型的微调。注意 PaliGemma 是预训练模型，你需要使用 `paligemma` 模板进行微调使其获得对话能力。 + +[24/05/18] 我们支持了 **[KTO](https://arxiv.org/abs/2402.01306)** 偏好对齐算法。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/05/14] 我们支持了昇腾 NPU 设备的训练和推理。详情请查阅[安装](#安装-llama-factory)部分。 + +[24/04/26] 我们支持了多模态模型 **LLaVA-1.5** 的微调。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/04/22] 我们提供了在免费 T4 GPU 上微调 Llama-3 模型的 **[Colab 笔记本](https://colab.research.google.com/drive/1d5KQtbemerlSDSxZIfAaWXhKr30QypiK?usp=sharing)**。Hugging Face 社区公开了两个利用 LLaMA Factory 微调的 Llama-3 模型，详情请见 [Llama3-8B-Chinese-Chat](https://huggingface.co/shenzhi-wang/Llama3-8B-Chinese-Chat) 和 [Llama3-Chinese](https://huggingface.co/zhichen/Llama3-Chinese)。 + +[24/04/21] 我们基于 [AstraMindAI 的仓库](https://github.com/astramind-ai/Mixture-of-depths)支持了 **[混合深度训练](https://arxiv.org/abs/2404.02258)**。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/04/16] 我们支持了 **[BAdam](https://arxiv.org/abs/2404.02827)** 优化器。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/04/16] 我们支持了 **[unsloth](https://github.com/unslothai/unsloth)** 的长序列训练（24GB 可训练 Llama-2-7B-56k）。该方法相比 FlashAttention-2 提供了 **117%** 的训练速度和 **50%** 的显存节约。更多数据请见[此页面](https://github.com/hiyouga/LLaMA-Factory/wiki/Performance-comparison)。 + +[24/03/31] 我们支持了 **[ORPO](https://arxiv.org/abs/2403.07691)**。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/03/21] 我们的论文 "[LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models](https://arxiv.org/abs/2403.13372)" 可在 arXiv 上查看！ + +[24/03/20] 我们支持了能在 2x24GB GPU 上微调 70B 模型的 **FSDP+QLoRA**。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/03/13] 我们支持了 **[LoRA+](https://arxiv.org/abs/2402.12354)**。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/03/07] 我们支持了 **[GaLore](https://arxiv.org/abs/2403.03507)** 优化器。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/03/07] 我们集成了 **[vLLM](https://github.com/vllm-project/vllm)** 以实现极速并发推理。请使用 `infer_backend: vllm` 来获得 **270%** 的推理速度。 + +[24/02/28] 我们支持了 **[DoRA](https://arxiv.org/abs/2402.09353)** 微调。请使用 `use_dora: true` 参数进行 DoRA 微调。 + +[24/02/15] 我们支持了 [LLaMA Pro](https://github.com/TencentARC/LLaMA-Pro) 提出的**块扩展**方法。详细用法请参照 [examples](examples/README_zh.md)。 + +[24/02/05] Qwen1.5（Qwen2 测试版）系列模型已在 LLaMA-Factory 中实现微调支持。详情请查阅该[博客页面](https://qwenlm.github.io/zh/blog/qwen1.5/)。 + +[24/01/18] 我们针对绝大多数模型实现了 **Agent 微调**，微调时指定 `dataset: glaive_toolcall_zh` 即可使模型获得工具调用能力。 + +[23/12/23] 我们针对 LLaMA, Mistral 和 Yi 模型支持了 **[unsloth](https://github.com/unslothai/unsloth)** 的 LoRA 训练加速。请使用 `use_unsloth: true` 参数启用 unsloth 优化。该方法可提供 **170%** 的训练速度，详情请查阅[此页面](https://github.com/hiyouga/LLaMA-Factory/wiki/Performance-comparison)。 + +[23/12/12] 我们支持了微调最新的混合专家模型 **[Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1)**。硬件需求请查阅[此处](#硬件依赖)。 + +[23/12/01] 我们支持了从 **[魔搭社区](https://modelscope.cn/models)** 下载预训练模型和数据集。详细用法请参照 [此教程](#从魔搭社区下载)。 + +[23/10/21] 我们支持了 **[NEFTune](https://arxiv.org/abs/2310.05914)** 训练技巧。请使用 `neftune_noise_alpha: 5` 参数启用 NEFTune。 + +[23/09/27] 我们针对 LLaMA 模型支持了 [LongLoRA](https://github.com/dvlab-research/LongLoRA) 提出的 **$S^2$-Attn**。请使用 `shift_attn: true` 参数以启用该功能。 + +[23/09/23] 我们在项目中集成了 MMLU、C-Eval 和 CMMLU 评估集。详细用法请参照 [examples](examples/README_zh.md)。 + +[23/09/10] 我们支持了 **[FlashAttention-2](https://github.com/Dao-AILab/flash-attention)**。如果您使用的是 RTX4090、A100 或 H100 GPU，请使用 `flash_attn: fa2` 参数以启用 FlashAttention-2。 + +[23/08/12] 我们支持了 **RoPE 插值**来扩展 LLaMA 模型的上下文长度。请使用 `rope_scaling: linear` 参数训练模型或使用 `rope_scaling: dynamic` 参数评估模型。 + +[23/08/11] 我们支持了指令模型的 **[DPO 训练](https://arxiv.org/abs/2305.18290)**。详细用法请参照 [examples](examples/README_zh.md)。 + +[23/07/31] 我们支持了**数据流式加载**。请使用 `streaming: true` 和 `max_steps: 10000` 参数来流式加载数据集。 + +[23/07/29] 我们在 Hugging Face 发布了两个 13B 指令微调模型。详细内容请查阅我们的 Hugging Face 项目（[LLaMA-2](https://huggingface.co/hiyouga/Llama-2-Chinese-13b-chat) / [Baichuan](https://huggingface.co/hiyouga/Baichuan-13B-sft)）。 + +[23/07/18] 我们开发了支持训练和测试的**浏览器一体化界面**。请使用 `train_web.py` 在您的浏览器中微调模型。感谢 [@KanadeSiina](https://github.com/KanadeSiina) 和 [@codemayq](https://github.com/codemayq) 在该功能开发中付出的努力。 + +[23/07/09] 我们开源了 **[FastEdit](https://github.com/hiyouga/FastEdit)** ⚡🩹，一个简单易用的、能迅速编辑大模型事实记忆的工具包。如果您感兴趣请关注我们的 [FastEdit](https://github.com/hiyouga/FastEdit) 项目。 + +[23/06/29] 我们提供了一个**可复现的**指令模型微调示例，详细内容请查阅 [Baichuan-7B-sft](https://huggingface.co/hiyouga/Baichuan-7B-sft)。 + +[23/06/22] 我们对齐了[示例 API](src/api_demo.py) 与 [OpenAI API](https://platform.openai.com/docs/api-reference/chat) 的格式，您可以将微调模型接入**任意基于 ChatGPT 的应用**中。 + +[23/06/03] 我们实现了 4 比特的 LoRA 训练（也称 **[QLoRA](https://github.com/artidoro/qlora)**）。详细用法请参照 [examples](examples/README_zh.md)。 + +
+ +> [!TIP] +> 如果您无法使用最新的功能，请尝试重新拉取代码并再次安装 LLaMA-Factory。 + +## 模型 + +| 模型名 | 参数量 | Template | +| ----------------------------------------------------------------- | -------------------------------- | ------------------- | +| [Baichuan 2](https://huggingface.co/baichuan-inc) | 7B/13B | baichuan2 | +| [BLOOM/BLOOMZ](https://huggingface.co/bigscience) | 560M/1.1B/1.7B/3B/7.1B/176B | - | +| [ChatGLM3](https://huggingface.co/THUDM) | 6B | chatglm3 | +| [Command R](https://huggingface.co/CohereForAI) | 35B/104B | cohere | +| [DeepSeek (Code/MoE)](https://huggingface.co/deepseek-ai) | 7B/16B/67B/236B | deepseek | +| [DeepSeek 2.5/3](https://huggingface.co/deepseek-ai) | 236B/671B | deepseek3 | +| [DeepSeek R1 (Distill)](https://huggingface.co/deepseek-ai) | 1.5B/7B/8B/14B/32B/70B/671B | deepseekr1 | +| [Falcon](https://huggingface.co/tiiuae) | 7B/11B/40B/180B | falcon | +| [Falcon-H1](https://huggingface.co/tiiuae) | 0.5B/1.5B/3B/7B/34B | falcon_h1 | +| [Gemma/Gemma 2/CodeGemma](https://huggingface.co/google) | 2B/7B/9B/27B | gemma/gemma2 | +| [Gemma 3/Gemma 3n](https://huggingface.co/google) | 1B/4B/6B/8B/12B/27B | gemma3/gemma3n | +| [GLM-4/GLM-4-0414/GLM-Z1](https://huggingface.co/zai-org) | 9B/32B | glm4/glmz1 | +| [GLM-4.1V](https://huggingface.co/zai-org)* | 9B | glm4v | +| [GLM-4.5](https://huggingface.co/zai-org)* | 106B/355B | glm4_moe | +| [GPT-2](https://huggingface.co/openai-community) | 0.1B/0.4B/0.8B/1.5B | - | +| [GPT-OSS](https://huggingface.co/openai) | 20B/120B | gpt | +| [Granite 3.0-3.3](https://huggingface.co/ibm-granite) | 1B/2B/3B/8B | granite3 | +| [Granite 4](https://huggingface.co/ibm-granite) | 7B | granite4 | +| [Hunyuan](https://huggingface.co/tencent/) | 7B | hunyuan | +| [Index](https://huggingface.co/IndexTeam) | 1.9B | index | +| [InternLM 2-3](https://huggingface.co/internlm) | 7B/8B/20B | intern2 | +| [InternVL 2.5-3](https://huggingface.co/OpenGVLab) | 1B/2B/8B/14B/38B/78B | intern_vl | +| [Kimi-VL](https://huggingface.co/moonshotai) | 16B | kimi_vl | +| [Llama](https://github.com/facebookresearch/llama) | 7B/13B/33B/65B | - | +| [Llama 2](https://huggingface.co/meta-llama) | 7B/13B/70B | llama2 | +| [Llama 3-3.3](https://huggingface.co/meta-llama) | 1B/3B/8B/70B | llama3 | +| [Llama 4](https://huggingface.co/meta-llama) | 109B/402B | llama4 | +| [Llama 3.2 Vision](https://huggingface.co/meta-llama) | 11B/90B | mllama | +| [LLaVA-1.5](https://huggingface.co/llava-hf) | 7B/13B | llava | +| [LLaVA-NeXT](https://huggingface.co/llava-hf) | 7B/8B/13B/34B/72B/110B | llava_next | +| [LLaVA-NeXT-Video](https://huggingface.co/llava-hf) | 7B/34B | llava_next_video | +| [MiMo](https://huggingface.co/XiaomiMiMo) | 7B | mimo | +| [MiniCPM](https://huggingface.co/openbmb) | 0.5B/1B/2B/4B/8B | cpm/cpm3/cpm4 | +| [MiniCPM-o-2.6/MiniCPM-V-2.6](https://huggingface.co/openbmb) | 8B | minicpm_o/minicpm_v | +| [Ministral/Mistral-Nemo](https://huggingface.co/mistralai) | 8B/12B | ministral | +| [Mistral/Mixtral](https://huggingface.co/mistralai) | 7B/8x7B/8x22B | mistral | +| [Mistral Small](https://huggingface.co/mistralai) | 24B | mistral_small | +| [OLMo](https://huggingface.co/allenai) | 1B/7B | - | +| [PaliGemma/PaliGemma2](https://huggingface.co/google) | 3B/10B/28B | paligemma | +| [Phi-1.5/Phi-2](https://huggingface.co/microsoft) | 1.3B/2.7B | - | +| [Phi-3/Phi-3.5](https://huggingface.co/microsoft) | 4B/14B | phi | +| [Phi-3-small](https://huggingface.co/microsoft) | 7B | phi_small | +| [Phi-4](https://huggingface.co/microsoft) | 14B | phi4 | +| [Pixtral](https://huggingface.co/mistralai) | 12B | pixtral | +| [Qwen (1-2.5) (Code/Math/MoE/QwQ)](https://huggingface.co/Qwen) | 0.5B/1.5B/3B/7B/14B/32B/72B/110B | qwen | +| [Qwen3 (MoE)](https://huggingface.co/Qwen) | 0.6B/1.7B/4B/8B/14B/32B/235B | qwen3 | +| [Qwen2-Audio](https://huggingface.co/Qwen) | 7B | qwen2_audio | +| [Qwen2.5-Omni](https://huggingface.co/Qwen) | 3B/7B | qwen2_omni | +| [Qwen2-VL/Qwen2.5-VL/QVQ](https://huggingface.co/Qwen) | 2B/3B/7B/32B/72B | qwen2_vl | +| [Seed Coder](https://huggingface.co/ByteDance-Seed) | 8B | seed_coder | +| [Skywork o1](https://huggingface.co/Skywork) | 8B | skywork_o1 | +| [StarCoder 2](https://huggingface.co/bigcode) | 3B/7B/15B | - | +| [TeleChat2](https://huggingface.co/Tele-AI) | 3B/7B/35B/115B | telechat2 | +| [XVERSE](https://huggingface.co/xverse) | 7B/13B/65B | xverse | +| [Yi/Yi-1.5 (Code)](https://huggingface.co/01-ai) | 1.5B/6B/9B/34B | yi | +| [Yi-VL](https://huggingface.co/01-ai) | 6B/34B | yi_vl | +| [Yuan 2](https://huggingface.co/IEITYuan) | 2B/51B/102B | yuan | + +> [!NOTE] +> 对于所有“基座”（Base）模型，`template` 参数可以是 `default`, `alpaca`, `vicuna` 等任意值。但“对话”（Instruct/Chat）模型请务必使用**对应的模板**。 +> +> 请务必在训练和推理时采用**完全一致**的模板。 +> +> \*：您需要从 main 分支安装 `transformers` 并使用 `DISABLE_VERSION_CHECK=1` 来跳过版本检查。 +> +> \*\*：您需要安装特定版本的 `transformers` 以使用该模型。 + +项目所支持模型的完整列表请参阅 [constants.py](src/llamafactory/extras/constants.py)。 + +您也可以在 [template.py](src/llamafactory/data/template.py) 中添加自己的对话模板。 + +## 训练方法 + +| 方法 | 全参数训练 | 部分参数训练 | LoRA | QLoRA | +| --------------------- | ------------------ | ------------------ | ------------------ | ------------------ | +| 预训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| 指令监督微调 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| 奖励模型训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| PPO 训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| DPO 训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| KTO 训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| ORPO 训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | +| SimPO 训练 | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | + +> [!TIP] +> 有关 PPO 的实现细节，请参考[此博客](https://newfacade.github.io/notes-on-reinforcement-learning/17-ppo-trl.html)。 + +## 数据集 + +
预训练数据集 + +- [Wiki Demo (en)](data/wiki_demo.txt) +- [RefinedWeb (en)](https://huggingface.co/datasets/tiiuae/falcon-refinedweb) +- [RedPajama V2 (en)](https://huggingface.co/datasets/togethercomputer/RedPajama-Data-V2) +- [Wikipedia (en)](https://huggingface.co/datasets/olm/olm-wikipedia-20221220) +- [Wikipedia (zh)](https://huggingface.co/datasets/pleisto/wikipedia-cn-20230720-filtered) +- [Pile (en)](https://huggingface.co/datasets/EleutherAI/pile) +- [SkyPile (zh)](https://huggingface.co/datasets/Skywork/SkyPile-150B) +- [FineWeb (en)](https://huggingface.co/datasets/HuggingFaceFW/fineweb) +- [FineWeb-Edu (en)](https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu) +- [The Stack (en)](https://huggingface.co/datasets/bigcode/the-stack) +- [StarCoder (en)](https://huggingface.co/datasets/bigcode/starcoderdata) + +
+ +
指令微调数据集 + +- [Identity (en&zh)](data/identity.json) +- [Stanford Alpaca (en)](https://github.com/tatsu-lab/stanford_alpaca) +- [Stanford Alpaca (zh)](https://github.com/ymcui/Chinese-LLaMA-Alpaca-3) +- [Alpaca GPT4 (en&zh)](https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM) +- [Glaive Function Calling V2 (en&zh)](https://huggingface.co/datasets/glaiveai/glaive-function-calling-v2) +- [LIMA (en)](https://huggingface.co/datasets/GAIR/lima) +- [Guanaco Dataset (multilingual)](https://huggingface.co/datasets/JosephusCheung/GuanacoDataset) +- [BELLE 2M (zh)](https://huggingface.co/datasets/BelleGroup/train_2M_CN) +- [BELLE 1M (zh)](https://huggingface.co/datasets/BelleGroup/train_1M_CN) +- [BELLE 0.5M (zh)](https://huggingface.co/datasets/BelleGroup/train_0.5M_CN) +- [BELLE Dialogue 0.4M (zh)](https://huggingface.co/datasets/BelleGroup/generated_chat_0.4M) +- [BELLE School Math 0.25M (zh)](https://huggingface.co/datasets/BelleGroup/school_math_0.25M) +- [BELLE Multiturn Chat 0.8M (zh)](https://huggingface.co/datasets/BelleGroup/multiturn_chat_0.8M) +- [UltraChat (en)](https://github.com/thunlp/UltraChat) +- [OpenPlatypus (en)](https://huggingface.co/datasets/garage-bAInd/Open-Platypus) +- [CodeAlpaca 20k (en)](https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k) +- [Alpaca CoT (multilingual)](https://huggingface.co/datasets/QingyiSi/Alpaca-CoT) +- [OpenOrca (en)](https://huggingface.co/datasets/Open-Orca/OpenOrca) +- [SlimOrca (en)](https://huggingface.co/datasets/Open-Orca/SlimOrca) +- [MathInstruct (en)](https://huggingface.co/datasets/TIGER-Lab/MathInstruct) +- [Firefly 1.1M (zh)](https://huggingface.co/datasets/YeungNLP/firefly-train-1.1M) +- [Wiki QA (en)](https://huggingface.co/datasets/wiki_qa) +- [Web QA (zh)](https://huggingface.co/datasets/suolyer/webqa) +- [WebNovel (zh)](https://huggingface.co/datasets/zxbsmk/webnovel_cn) +- [Nectar (en)](https://huggingface.co/datasets/berkeley-nest/Nectar) +- [deepctrl (en&zh)](https://www.modelscope.cn/datasets/deepctrl/deepctrl-sft-data) +- [Advertise Generating (zh)](https://huggingface.co/datasets/HasturOfficial/adgen) +- [ShareGPT Hyperfiltered (en)](https://huggingface.co/datasets/totally-not-an-llm/sharegpt-hyperfiltered-3k) +- [ShareGPT4 (en&zh)](https://huggingface.co/datasets/shibing624/sharegpt_gpt4) +- [UltraChat 200k (en)](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k) +- [AgentInstruct (en)](https://huggingface.co/datasets/THUDM/AgentInstruct) +- [LMSYS Chat 1M (en)](https://huggingface.co/datasets/lmsys/lmsys-chat-1m) +- [Evol Instruct V2 (en)](https://huggingface.co/datasets/WizardLM/WizardLM_evol_instruct_V2_196k) +- [Cosmopedia (en)](https://huggingface.co/datasets/HuggingFaceTB/cosmopedia) +- [STEM (zh)](https://huggingface.co/datasets/hfl/stem_zh_instruction) +- [Ruozhiba (zh)](https://huggingface.co/datasets/hfl/ruozhiba_gpt4_turbo) +- [Neo-sft (zh)](https://huggingface.co/datasets/m-a-p/neo_sft_phase2) +- [Magpie-Pro-300K-Filtered (en)](https://huggingface.co/datasets/Magpie-Align/Magpie-Pro-300K-Filtered) +- [Magpie-ultra-v0.1 (en)](https://huggingface.co/datasets/argilla/magpie-ultra-v0.1) +- [WebInstructSub (en)](https://huggingface.co/datasets/TIGER-Lab/WebInstructSub) +- [OpenO1-SFT (en&zh)](https://huggingface.co/datasets/O1-OPEN/OpenO1-SFT) +- [Open-Thoughts (en)](https://huggingface.co/datasets/open-thoughts/OpenThoughts-114k) +- [Open-R1-Math (en)](https://huggingface.co/datasets/open-r1/OpenR1-Math-220k) +- [Chinese-DeepSeek-R1-Distill (zh)](https://huggingface.co/datasets/Congliu/Chinese-DeepSeek-R1-Distill-data-110k-SFT) +- [LLaVA mixed (en&zh)](https://huggingface.co/datasets/BUAADreamer/llava-en-zh-300k) +- [Pokemon-gpt4o-captions (en&zh)](https://huggingface.co/datasets/jugg1024/pokemon-gpt4o-captions) +- [Open Assistant (de)](https://huggingface.co/datasets/mayflowergmbh/oasst_de) +- [Dolly 15k (de)](https://huggingface.co/datasets/mayflowergmbh/dolly-15k_de) +- [Alpaca GPT4 (de)](https://huggingface.co/datasets/mayflowergmbh/alpaca-gpt4_de) +- [OpenSchnabeltier (de)](https://huggingface.co/datasets/mayflowergmbh/openschnabeltier_de) +- [Evol Instruct (de)](https://huggingface.co/datasets/mayflowergmbh/evol-instruct_de) +- [Dolphin (de)](https://huggingface.co/datasets/mayflowergmbh/dolphin_de) +- [Booksum (de)](https://huggingface.co/datasets/mayflowergmbh/booksum_de) +- [Airoboros (de)](https://huggingface.co/datasets/mayflowergmbh/airoboros-3.0_de) +- [Ultrachat (de)](https://huggingface.co/datasets/mayflowergmbh/ultra-chat_de) + +
+ +
偏好数据集 + +- [DPO mixed (en&zh)](https://huggingface.co/datasets/hiyouga/DPO-En-Zh-20k) +- [UltraFeedback (en)](https://huggingface.co/datasets/HuggingFaceH4/ultrafeedback_binarized) +- [COIG-P (zh)](https://huggingface.co/datasets/m-a-p/COIG-P) +- [RLHF-V (en)](https://huggingface.co/datasets/openbmb/RLHF-V-Dataset) +- [VLFeedback (en)](https://huggingface.co/datasets/Zhihui/VLFeedback) +- [RLAIF-V (en)](https://huggingface.co/datasets/openbmb/RLAIF-V-Dataset) +- [Orca DPO Pairs (en)](https://huggingface.co/datasets/Intel/orca_dpo_pairs) +- [HH-RLHF (en)](https://huggingface.co/datasets/Anthropic/hh-rlhf) +- [Nectar (en)](https://huggingface.co/datasets/berkeley-nest/Nectar) +- [Orca DPO (de)](https://huggingface.co/datasets/mayflowergmbh/intel_orca_dpo_pairs_de) +- [KTO mixed (en)](https://huggingface.co/datasets/argilla/kto-mix-15k) + +
+ +部分数据集的使用需要确认，我们推荐使用下述命令登录您的 Hugging Face 账户。 + +```bash +pip install --upgrade huggingface_hub +huggingface-cli login +``` + +## 软硬件依赖 + +| 必需项 | 至少 | 推荐 | +| ------------ | ------- | --------- | +| python | 3.9 | 3.10 | +| torch | 2.0.0 | 2.6.0 | +| torchvision | 0.15.0 | 0.21.0 | +| transformers | 4.49.0 | 4.50.0 | +| datasets | 2.16.0 | 3.2.0 | +| accelerate | 0.34.0 | 1.2.1 | +| peft | 0.14.0 | 0.15.1 | +| trl | 0.8.6 | 0.9.6 | + +| 可选项 | 至少 | 推荐 | +| ------------ | ------- | --------- | +| CUDA | 11.6 | 12.2 | +| deepspeed | 0.10.0 | 0.16.4 | +| bitsandbytes | 0.39.0 | 0.43.1 | +| vllm | 0.4.3 | 0.8.2 | +| flash-attn | 2.5.6 | 2.7.2 | + +### 硬件依赖 + +\* *估算值* + +| 方法 | 精度 | 7B | 14B | 30B | 70B | `x`B | +| ------------------------------- | ---- | ----- | ----- | ----- | ------ | ------- | +| Full (`bf16` or `fp16`) | 32 | 120GB | 240GB | 600GB | 1200GB | `18x`GB | +| Full (`pure_bf16`) | 16 | 60GB | 120GB | 300GB | 600GB | `8x`GB | +| Freeze/LoRA/GaLore/APOLLO/BAdam | 16 | 16GB | 32GB | 64GB | 160GB | `2x`GB | +| QLoRA | 8 | 10GB | 20GB | 40GB | 80GB | `x`GB | +| QLoRA | 4 | 6GB | 12GB | 24GB | 48GB | `x/2`GB | +| QLoRA | 2 | 4GB | 8GB | 16GB | 24GB | `x/4`GB | + +## 如何使用 + +### 安装 LLaMA Factory + +> [!IMPORTANT] +> 此步骤为必需。 + +#### 从源码安装 + +```bash +git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git +cd LLaMA-Factory +pip install -e ".[torch,metrics]" --no-build-isolation +``` + +可选的额外依赖项：torch、torch-npu、metrics、deepspeed、liger-kernel、bitsandbytes、hqq、eetq、gptq、aqlm、vllm、sglang、galore、apollo、badam、adam-mini、qwen、minicpm_v、openmind、swanlab、dev + +#### 从镜像安装 + +```bash +docker run -it --rm --gpus=all --ipc=host hiyouga/llamafactory:latest +``` + +该镜像基于 Ubuntu 22.04（x86\_64）、CUDA 12.4、Python 3.11、PyTorch 2.6.0 和 Flash-attn 2.7.4 构建。 + +查看全部镜像：https://hub.docker.com/r/hiyouga/llamafactory/tags + +请参阅[构建 Docker](#构建-docker) 来重新构建镜像。 + +
使用 uv 构建虚拟环境 + +使用 [uv](https://github.com/astral-sh/uv) 创建隔离的 Python 环境： + +```bash +uv sync --extra torch --extra metrics --prerelease=allow +``` + +在环境中运行 LLaMA-Factory： + +```bash +uv run --prerelease=allow llamafactory-cli train examples/train_lora/llama3_lora_pretrain.yaml +``` + +
+ +
Windows 用户指南 + +#### 安装 PyTorch + +Windows 平台需要额外手动安装 GPU 版本的 PyTorch 依赖包，您可以参考[官方网站](https://pytorch.org/get-started/locally/)和以下命令安装并测试 PyTorch 是否正确安装。 + +```bash +pip uninstall torch torchvision torchaudio +pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126 +python -c "import torch; print(torch.cuda.is_available())" +``` + +如果看到 `True` 则说明安装成功。 + +若遇到类似 `Can't pickle local object` 的报错，请设置 `dataloader_num_workers: 0`。 + +#### 安装 BitsAndBytes + +如果要在 Windows 平台上开启量化 LoRA（QLoRA），需要安装预编译的 `bitsandbytes` 库, 支持 CUDA 11.1 到 12.2, 请根据您的 CUDA 版本情况选择适合的[发布版本](https://github.com/jllllll/bitsandbytes-windows-webui/releases/tag/wheels)。 + +```bash +pip install https://github.com/jllllll/bitsandbytes-windows-webui/releases/download/wheels/bitsandbytes-0.41.2.post2-py3-none-win_amd64.whl +``` + +#### 安装 Flash Attention-2 + +如果要在 Windows 平台上开启 FlashAttention-2，请使用 [flash-attention-windows-wheel](https://huggingface.co/lldacing/flash-attention-windows-wheel) 中的脚本自行编译与安装。 + +
+ +
昇腾 NPU 用户指南 + +在昇腾 NPU 设备上安装 LLaMA Factory 时，请升级 Python 到 3.10 及以上，并需要指定额外依赖项，使用 `pip install -e ".[torch-npu,metrics]"` 命令安装。此外，还需要安装 **[Ascend CANN Toolkit 与 Kernels](https://www.hiascend.com/developer/download/community/result?module=cann)**，安装方法请参考[安装教程](https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/80RC2alpha002/quickstart/quickstart/quickstart_18_0004.html)或使用以下命令： + +```bash +# 请替换 URL 为 CANN 版本和设备型号对应的 URL +# 安装 CANN Toolkit +wget https://ascend-repo.obs.cn-east-2.myhuaweicloud.com/Milan-ASL/Milan-ASL%20V100R001C17SPC701/Ascend-cann-toolkit_8.0.RC1.alpha001_linux-"$(uname -i)".run +bash Ascend-cann-toolkit_8.0.RC1.alpha001_linux-"$(uname -i)".run --install + +# 安装 CANN Kernels +wget https://ascend-repo.obs.cn-east-2.myhuaweicloud.com/Milan-ASL/Milan-ASL%20V100R001C17SPC701/Ascend-cann-kernels-910b_8.0.RC1.alpha001_linux.run +bash Ascend-cann-kernels-910b_8.0.RC1.alpha001_linux.run --install + +# 设置环境变量 +source /usr/local/Ascend/ascend-toolkit/set_env.sh +``` + +| 依赖项 | 至少 | 推荐 | +| ------------ | ------- | -------------- | +| CANN | 8.0.RC1 | 8.0.0.alpha002 | +| torch | 2.1.0 | 2.4.0 | +| torch-npu | 2.1.0 | 2.4.0.post2 | +| deepspeed | 0.13.2 | 0.13.2 | +| vllm-ascend | - | 0.7.3 | + +请使用 `ASCEND_RT_VISIBLE_DEVICES` 而非 `CUDA_VISIBLE_DEVICES` 来指定运算设备。 + +如果遇到无法正常推理的情况，请尝试设置 `do_sample: false`。 + +下载预构建 Docker 镜像：[32GB](http://mirrors.cn-central-221.ovaijisuan.com/detail/130.html) | [64GB](http://mirrors.cn-central-221.ovaijisuan.com/detail/131.html) + +#### 安装 BitsAndBytes + +如果要在 Ascend NPU 上进行基于 bitsandbytes 的 QLoRA 量化微调，请执行如下步骤： + +1. 手动编译 bitsandbytes：请参考[安装文档](https://huggingface.co/docs/bitsandbytes/installation?backend=Ascend+NPU&platform=Ascend+NPU)完成 NPU 版的 bitsandbytes 安装，编译要求环境 cmake 版本不低于 3.22.1，g++ 版本不低于 12.x。 + +```bash +# 从源码安装 bitsandbytes +# 克隆 bitsandbytes 仓库, Ascend NPU 目前在 multi-backend-refactor 中支持 +git clone -b multi-backend-refactor https://github.com/bitsandbytes-foundation/bitsandbytes.git +cd bitsandbytes/ + +# 安装依赖 +pip install -r requirements-dev.txt + +# 安装编译工具依赖，该步骤在不同系统上命令有所不同，供参考 +apt-get install -y build-essential cmake + +# 编译 & 安装 +cmake -DCOMPUTE_BACKEND=npu -S . +make +pip install . +``` + +2. 安装 transformers 的 main 分支版本。 + +```bash +git clone -b main https://github.com/huggingface/transformers.git +cd transformers +pip install . +``` + +3. 在训练参数中设置 `double_quantization: false`，可参考[示例](examples/train_qlora/llama3_lora_sft_bnb_npu.yaml)。 + +
+ +### 数据准备 + +关于数据集文件的格式，请参考 [data/README_zh.md](data/README_zh.md) 的内容。你可以使用 HuggingFace / ModelScope / Modelers 上的数据集或加载本地数据集。 + +> [!NOTE] +> 使用自定义数据集时，请更新 `data/dataset_info.json` 文件。 + +您也可以使用 **[Easy Dataset](https://github.com/ConardLi/easy-dataset)**、**[DataFlow](https://github.com/OpenDCAI/DataFlow)** 和 **[GraphGen](https://github.com/open-sciencelab/GraphGen)** 构建用于微调的合成数据。 + +### 快速开始 + +下面三行命令分别对 Llama3-8B-Instruct 模型进行 LoRA **微调**、**推理**和**合并**。 + +```bash +llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml +llamafactory-cli chat examples/inference/llama3_lora_sft.yaml +llamafactory-cli export examples/merge_lora/llama3_lora_sft.yaml +``` + +高级用法请参考 [examples/README_zh.md](examples/README_zh.md)（包括多 GPU 微调）。 + +> [!TIP] +> 使用 `llamafactory-cli help` 显示帮助信息。 +> +> 遇到报错请先看[常见问题](https://github.com/hiyouga/LLaMA-Factory/issues/4614)。 + +### LLaMA Board 可视化微调（由 [Gradio](https://github.com/gradio-app/gradio) 驱动） + +```bash +llamafactory-cli webui +``` + +### 构建 Docker + +CUDA 用户： + +```bash +cd docker/docker-cuda/ +docker compose up -d +docker compose exec llamafactory bash +``` + +昇腾 NPU 用户： + +```bash +cd docker/docker-npu/ +docker compose up -d +docker compose exec llamafactory bash +``` + +AMD ROCm 用户： + +```bash +cd docker/docker-rocm/ +docker compose up -d +docker compose exec llamafactory bash +``` + +
不使用 Docker Compose 构建 + +CUDA 用户： + +```bash +docker build -f ./docker/docker-cuda/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=metrics \ + -t llamafactory:latest . + +docker run -dit --ipc=host --gpus=all \ + -p 7860:7860 \ + -p 8000:8000 \ + --name llamafactory \ + llamafactory:latest + +docker exec -it llamafactory bash +``` + +昇腾 NPU 用户： + +```bash +docker build -f ./docker/docker-npu/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=torch-npu,metrics \ + -t llamafactory:latest . + +docker run -dit --ipc=host \ + -v /usr/local/dcmi:/usr/local/dcmi \ + -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \ + -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \ + -v /etc/ascend_install.info:/etc/ascend_install.info \ + -p 7860:7860 \ + -p 8000:8000 \ + --device /dev/davinci0 \ + --device /dev/davinci_manager \ + --device /dev/devmm_svm \ + --device /dev/hisi_hdc \ + --name llamafactory \ + llamafactory:latest + +docker exec -it llamafactory bash +``` + +AMD ROCm 用户： + +```bash +docker build -f ./docker/docker-rocm/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=metrics \ + -t llamafactory:latest . + +docker run -dit --ipc=host \ + -p 7860:7860 \ + -p 8000:8000 \ + --device /dev/kfd \ + --device /dev/dri \ + --name llamafactory \ + llamafactory:latest + +docker exec -it llamafactory bash +``` + +
+ +
使用数据卷 + +您可以通过移除 Dockerfile 中 `VOLUME [ "/root/.cache/huggingface", "/app/shared_data", "/app/output" ]` 的注释来使用数据卷。 + +在构建 Docker 时使用参数 `-v ./hf_cache:/root/.cache/huggingface` 来挂载数据卷。各个数据卷的含义表示如下。 + +- `hf_cache`：使用宿主机的 Hugging Face 缓存文件夹。 +- `shared_data`：宿主机中存放数据集的文件夹路径。 +- `output`：将导出目录设置为该路径后，即可在宿主机中访问导出后的模型。 + +
+ +### 利用 vLLM 部署 OpenAI API + +```bash +API_PORT=8000 llamafactory-cli api examples/inference/llama3.yaml infer_backend=vllm vllm_enforce_eager=true +``` + +> [!TIP] +> API 文档请查阅[这里](https://platform.openai.com/docs/api-reference/chat/create)。 +> +> 示例：[图像理解](scripts/api_example/test_image.py) | [工具调用](scripts/api_example/test_toolcall.py) + +### 从魔搭社区下载 + +如果您在 Hugging Face 模型和数据集的下载中遇到了问题，可以通过下述方法使用魔搭社区。 + +```bash +export USE_MODELSCOPE_HUB=1 # Windows 使用 `set USE_MODELSCOPE_HUB=1` +``` + +将 `model_name_or_path` 设置为模型 ID 来加载对应的模型。在[魔搭社区](https://modelscope.cn/models)查看所有可用的模型，例如 `LLM-Research/Meta-Llama-3-8B-Instruct`。 + +### 从魔乐社区下载 + +您也可以通过下述方法，使用魔乐社区下载数据集和模型。 + +```bash +export USE_OPENMIND_HUB=1 # Windows 使用 `set USE_OPENMIND_HUB=1` +``` + +将 `model_name_or_path` 设置为模型 ID 来加载对应的模型。在[魔乐社区](https://modelers.cn/models)查看所有可用的模型，例如 `TeleAI/TeleChat-7B-pt`。 + +### 使用 W&B 面板 + +若要使用 [Weights & Biases](https://wandb.ai) 记录实验数据，请在 yaml 文件中添加下面的参数。 + +```yaml +report_to: wandb +run_name: test_run # 可选 +``` + +在启动训练任务时，将 `WANDB_API_KEY` 设置为[密钥](https://wandb.ai/authorize)来登录 W&B 账户。 + +### 使用 SwanLab 面板 + +若要使用 [SwanLab](https://github.com/SwanHubX/SwanLab) 记录实验数据，请在 yaml 文件中添加下面的参数。 + +```yaml +use_swanlab: true +swanlab_run_name: test_run # 可选 +``` + +在启动训练任务时，登录SwanLab账户有以下三种方式： + +方式一：在 yaml 文件中添加 `swanlab_api_key=` ，并设置为你的 [API 密钥](https://swanlab.cn/settings)。 +方式二：将环境变量 `SWANLAB_API_KEY` 设置为你的 [API 密钥](https://swanlab.cn/settings)。 +方式三：启动前使用 `swanlab login` 命令完成登录。 + +## 使用了 LLaMA Factory 的项目 + +如果您有项目希望添加至下述列表，请通过邮件联系或者创建一个 PR。 + +
点击显示 + +1. Wang et al. ESRL: Efficient Sampling-based Reinforcement Learning for Sequence Generation. 2023. [[arxiv]](https://arxiv.org/abs/2308.02223) +1. Yu et al. Open, Closed, or Small Language Models for Text Classification? 2023. [[arxiv]](https://arxiv.org/abs/2308.10092) +1. Wang et al. UbiPhysio: Support Daily Functioning, Fitness, and Rehabilitation with Action Understanding and Feedback in Natural Language. 2023. [[arxiv]](https://arxiv.org/abs/2308.10526) +1. Luceri et al. Leveraging Large Language Models to Detect Influence Campaigns in Social Media. 2023. [[arxiv]](https://arxiv.org/abs/2311.07816) +1. Zhang et al. Alleviating Hallucinations of Large Language Models through Induced Hallucinations. 2023. [[arxiv]](https://arxiv.org/abs/2312.15710) +1. Wang et al. Know Your Needs Better: Towards Structured Understanding of Marketer Demands with Analogical Reasoning Augmented LLMs. KDD 2024. [[arxiv]](https://arxiv.org/abs/2401.04319) +1. Wang et al. CANDLE: Iterative Conceptualization and Instantiation Distillation from Large Language Models for Commonsense Reasoning. ACL 2024. [[arxiv]](https://arxiv.org/abs/2401.07286) +1. Choi et al. FACT-GPT: Fact-Checking Augmentation via Claim Matching with LLMs. 2024. [[arxiv]](https://arxiv.org/abs/2402.05904) +1. Zhang et al. AutoMathText: Autonomous Data Selection with Language Models for Mathematical Texts. 2024. [[arxiv]](https://arxiv.org/abs/2402.07625) +1. Lyu et al. KnowTuning: Knowledge-aware Fine-tuning for Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.11176) +1. Yang et al. LaCo: Large Language Model Pruning via Layer Collaps. 2024. [[arxiv]](https://arxiv.org/abs/2402.11187) +1. Bhardwaj et al. Language Models are Homer Simpson! Safety Re-Alignment of Fine-tuned Language Models through Task Arithmetic. 2024. [[arxiv]](https://arxiv.org/abs/2402.11746) +1. Yang et al. Enhancing Empathetic Response Generation by Augmenting LLMs with Small-scale Empathetic Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.11801) +1. Yi et al. Generation Meets Verification: Accelerating Large Language Model Inference with Smart Parallel Auto-Correct Decoding. ACL 2024 Findings. [[arxiv]](https://arxiv.org/abs/2402.11809) +1. Cao et al. Head-wise Shareable Attention for Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.11819) +1. Zhang et al. Enhancing Multilingual Capabilities of Large Language Models through Self-Distillation from Resource-Rich Languages. 2024. [[arxiv]](https://arxiv.org/abs/2402.12204) +1. Kim et al. Efficient and Effective Vocabulary Expansion Towards Multilingual Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2402.14714) +1. Yu et al. KIEval: A Knowledge-grounded Interactive Evaluation Framework for Large Language Models. ACL 2024. [[arxiv]](https://arxiv.org/abs/2402.15043) +1. Huang et al. Key-Point-Driven Data Synthesis with its Enhancement on Mathematical Reasoning. 2024. [[arxiv]](https://arxiv.org/abs/2403.02333) +1. Duan et al. Negating Negatives: Alignment without Human Positive Samples via Distributional Dispreference Optimization. 2024. [[arxiv]](https://arxiv.org/abs/2403.03419) +1. Xie and Schwertfeger. Empowering Robotics with Large Language Models: osmAG Map Comprehension with LLMs. 2024. [[arxiv]](https://arxiv.org/abs/2403.08228) +1. Wu et al. Large Language Models are Parallel Multilingual Learners. 2024. [[arxiv]](https://arxiv.org/abs/2403.09073) +1. Zhang et al. EDT: Improving Large Language Models' Generation by Entropy-based Dynamic Temperature Sampling. 2024. [[arxiv]](https://arxiv.org/abs/2403.14541) +1. Weller et al. FollowIR: Evaluating and Teaching Information Retrieval Models to Follow Instructions. 2024. [[arxiv]](https://arxiv.org/abs/2403.15246) +1. Hongbin Na. CBT-LLM: A Chinese Large Language Model for Cognitive Behavioral Therapy-based Mental Health Question Answering. COLING 2024. [[arxiv]](https://arxiv.org/abs/2403.16008) +1. Zan et al. CodeS: Natural Language to Code Repository via Multi-Layer Sketch. 2024. [[arxiv]](https://arxiv.org/abs/2403.16443) +1. Liu et al. Extensive Self-Contrast Enables Feedback-Free Language Model Alignment. 2024. [[arxiv]](https://arxiv.org/abs/2404.00604) +1. Luo et al. BAdam: A Memory Efficient Full Parameter Training Method for Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.02827) +1. Du et al. Chinese Tiny LLM: Pretraining a Chinese-Centric Large Language Model. 2024. [[arxiv]](https://arxiv.org/abs/2404.04167) +1. Ma et al. Parameter Efficient Quasi-Orthogonal Fine-Tuning via Givens Rotation. ICML 2024. [[arxiv]](https://arxiv.org/abs/2404.04316) +1. Liu et al. Dynamic Generation of Personalities with Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.07084) +1. Shang et al. How Far Have We Gone in Stripped Binary Code Understanding Using Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.09836) +1. Huang et al. LLMTune: Accelerate Database Knob Tuning with Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2404.11581) +1. Deng et al. Text-Tuple-Table: Towards Information Integration in Text-to-Table Generation via Global Tuple Extraction. 2024. [[arxiv]](https://arxiv.org/abs/2404.14215) +1. Acikgoz et al. Hippocrates: An Open-Source Framework for Advancing Large Language Models in Healthcare. 2024. [[arxiv]](https://arxiv.org/abs/2404.16621) +1. Zhang et al. Small Language Models Need Strong Verifiers to Self-Correct Reasoning. ACL 2024 Findings. [[arxiv]](https://arxiv.org/abs/2404.17140) +1. Zhou et al. FREB-TQA: A Fine-Grained Robustness Evaluation Benchmark for Table Question Answering. NAACL 2024. [[arxiv]](https://arxiv.org/abs/2404.18585) +1. Xu et al. Large Language Models for Cyber Security: A Systematic Literature Review. 2024. [[arxiv]](https://arxiv.org/abs/2405.04760) +1. Dammu et al. "They are uncultured": Unveiling Covert Harms and Social Threats in LLM Generated Conversations. 2024. [[arxiv]](https://arxiv.org/abs/2405.05378) +1. Yi et al. A safety realignment framework via subspace-oriented model fusion for large language models. 2024. [[arxiv]](https://arxiv.org/abs/2405.09055) +1. Lou et al. SPO: Multi-Dimensional Preference Sequential Alignment With Implicit Reward Modeling. 2024. [[arxiv]](https://arxiv.org/abs/2405.12739) +1. Zhang et al. Getting More from Less: Large Language Models are Good Spontaneous Multilingual Learners. 2024. [[arxiv]](https://arxiv.org/abs/2405.13816) +1. Zhang et al. TS-Align: A Teacher-Student Collaborative Framework for Scalable Iterative Finetuning of Large Language Models. 2024. [[arxiv]](https://arxiv.org/abs/2405.20215) +1. Zihong Chen. Sentence Segmentation and Sentence Punctuation Based on XunziALLM. 2024. [[paper]](https://aclanthology.org/2024.lt4hala-1.30) +1. Gao et al. The Best of Both Worlds: Toward an Honest and Helpful Large Language Model. 2024. [[arxiv]](https://arxiv.org/abs/2406.00380) +1. Wang and Song. MARS: Benchmarking the Metaphysical Reasoning Abilities of Language Models with a Multi-task Evaluation Dataset. 2024. [[arxiv]](https://arxiv.org/abs/2406.02106) +1. Hu et al. Computational Limits of Low-Rank Adaptation (LoRA) for Transformer-Based Models. 2024. [[arxiv]](https://arxiv.org/abs/2406.03136) +1. Ge et al. Time Sensitive Knowledge Editing through Efficient Finetuning. ACL 2024. [[arxiv]](https://arxiv.org/abs/2406.04496) +1. Tan et al. Peer Review as A Multi-Turn and Long-Context Dialogue with Role-Based Interactions. 2024. [[arxiv]](https://arxiv.org/abs/2406.05688) +1. Song et al. Turbo Sparse: Achieving LLM SOTA Performance with Minimal Activated Parameters. 2024. [[arxiv]](https://arxiv.org/abs/2406.05955) +1. Gu et al. RWKV-CLIP: A Robust Vision-Language Representation Learner. 2024. [[arxiv]](https://arxiv.org/abs/2406.06973) +1. Chen et al. Advancing Tool-Augmented Large Language Models: Integrating Insights from Errors in Inference Trees. 2024. [[arxiv]](https://arxiv.org/abs/2406.07115) +1. Zhu et al. Are Large Language Models Good Statisticians?. 2024. [[arxiv]](https://arxiv.org/abs/2406.07815) +1. Li et al. Know the Unknown: An Uncertainty-Sensitive Method for LLM Instruction Tuning. 2024. [[arxiv]](https://arxiv.org/abs/2406.10099) +1. Ding et al. IntentionQA: A Benchmark for Evaluating Purchase Intention Comprehension Abilities of Language Models in E-commerce. 2024. [[arxiv]](https://arxiv.org/abs/2406.10173) +1. He et al. COMMUNITY-CROSS-INSTRUCT: Unsupervised Instruction Generation for Aligning Large Language Models to Online Communities. 2024. [[arxiv]](https://arxiv.org/abs/2406.12074) +1. Lin et al. FVEL: Interactive Formal Verification Environment with Large Language Models via Theorem Proving. 2024. [[arxiv]](https://arxiv.org/abs/2406.14408) +1. Treutlein et al. Connecting the Dots: LLMs can Infer and Verbalize Latent Structure from Disparate Training Data. 2024. [[arxiv]](https://arxiv.org/abs/2406.14546) +1. Feng et al. SS-Bench: A Benchmark for Social Story Generation and Evaluation. 2024. [[arxiv]](https://arxiv.org/abs/2406.15695) +1. Feng et al. Self-Constructed Context Decompilation with Fined-grained Alignment Enhancement. 2024. [[arxiv]](https://arxiv.org/abs/2406.17233) +1. Liu et al. Large Language Models for Cuffless Blood Pressure Measurement From Wearable Biosignals. 2024. [[arxiv]](https://arxiv.org/abs/2406.18069) +1. Iyer et al. Exploring Very Low-Resource Translation with LLMs: The University of Edinburgh's Submission to AmericasNLP 2024 Translation Task. AmericasNLP 2024. [[paper]](https://aclanthology.org/2024.americasnlp-1.25) +1. Li et al. Calibrating LLMs with Preference Optimization on Thought Trees for Generating Rationale in Science Question Scoring. 2024. [[arxiv]](https://arxiv.org/abs/2406.19949) +1. Yang et al. Financial Knowledge Large Language Model. 2024. [[arxiv]](https://arxiv.org/abs/2407.00365) +1. Lin et al. DogeRM: Equipping Reward Models with Domain Knowledge through Model Merging. 2024. [[arxiv]](https://arxiv.org/abs/2407.01470) +1. Bako et al. Evaluating the Semantic Profiling Abilities of LLMs for Natural Language Utterances in Data Visualization. 2024. [[arxiv]](https://arxiv.org/abs/2407.06129) +1. Huang et al. RoLoRA: Fine-tuning Rotated Outlier-free LLMs for Effective Weight-Activation Quantization. 2024. [[arxiv]](https://arxiv.org/abs/2407.08044) +1. Jiang et al. LLM-Collaboration on Automatic Science Journalism for the General Audience. 2024. [[arxiv]](https://arxiv.org/abs/2407.09756) +1. Inouye et al. Applied Auto-tuning on LoRA Hyperparameters. 2024. [[paper]](https://scholarcommons.scu.edu/cseng_senior/272/) +1. Qi et al. Research on Tibetan Tourism Viewpoints information generation system based on LLM. 2024. [[arxiv]](https://arxiv.org/abs/2407.13561) +1. Xu et al. Course-Correction: Safety Alignment Using Synthetic Preferences. 2024. [[arxiv]](https://arxiv.org/abs/2407.16637) +1. Sun et al. LAMBDA: A Large Model Based Data Agent. 2024. [[arxiv]](https://arxiv.org/abs/2407.17535) +1. Zhu et al. CollectiveSFT: Scaling Large Language Models for Chinese Medical Benchmark with Collective Instructions in Healthcare. 2024. [[arxiv]](https://arxiv.org/abs/2407.19705) +1. Yu et al. Correcting Negative Bias in Large Language Models through Negative Attention Score Alignment. 2024. [[arxiv]](https://arxiv.org/abs/2408.00137) +1. Xie et al. The Power of Personalized Datasets: Advancing Chinese Composition Writing for Elementary School through Targeted Model Fine-Tuning. IALP 2024. [[paper]](https://www.asianlp.sg/conferences/ialp2024/proceedings/papers/IALP2024_P055.pdf) +1. Liu et al. Instruct-Code-Llama: Improving Capabilities of Language Model in Competition Level Code Generation by Online Judge Feedback. ICIC 2024. [[paper]](https://link.springer.com/chapter/10.1007/978-981-97-5669-8_11) +1. Wang et al. Cybernetic Sentinels: Unveiling the Impact of Safety Data Selection on Model Security in Supervised Fine-Tuning. ICIC 2024. [[paper]](https://link.springer.com/chapter/10.1007/978-981-97-5669-8_23) +1. Xia et al. Understanding the Performance and Estimating the Cost of LLM Fine-Tuning. 2024. [[arxiv]](https://arxiv.org/abs/2408.04693) +1. Zeng et al. Perceive, Reflect, and Plan: Designing LLM Agent for Goal-Directed City Navigation without Instructions. 2024. [[arxiv]](https://arxiv.org/abs/2408.04168) +1. Xia et al. Using Pre-trained Language Model for Accurate ESG Prediction. FinNLP 2024. [[paper]](https://aclanthology.org/2024.finnlp-2.1/) +1. Liang et al. I-SHEEP: Self-Alignment of LLM from Scratch through an Iterative Self-Enhancement Paradigm. 2024. [[arxiv]](https://arxiv.org/abs/2408.08072) +1. Bai et al. Aligning Large Language Model with Direct Multi-Preference Optimization for Recommendation. CIKM 2024. [[paper]](https://dl.acm.org/doi/10.1145/3627673.3679611) +1. **[StarWhisper](https://github.com/Yu-Yang-Li/StarWhisper)**: 天文大模型 StarWhisper，基于 ChatGLM2-6B 和 Qwen-14B 在天文数据上微调而得。 +1. **[DISC-LawLLM](https://github.com/FudanDISC/DISC-LawLLM)**: 中文法律领域大模型 DISC-LawLLM，基于 Baichuan-13B 微调而得，具有法律推理和知识检索能力。 +1. **[Sunsimiao](https://github.com/X-D-Lab/Sunsimiao)**: 孙思邈中文医疗大模型 Sumsimiao，基于 Baichuan-7B 和 ChatGLM-6B 在中文医疗数据上微调而得。 +1. **[CareGPT](https://github.com/WangRongsheng/CareGPT)**: 医疗大模型项目 CareGPT，基于 LLaMA2-7B 和 Baichuan-13B 在中文医疗数据上微调而得。 +1. **[MachineMindset](https://github.com/PKU-YuanGroup/Machine-Mindset/)**：MBTI性格大模型项目，根据数据集与训练方式让任意 LLM 拥有 16 个不同的性格类型。 +1. **[Luminia-13B-v3](https://huggingface.co/Nekochu/Luminia-13B-v3)**：一个用于生成 Stable Diffusion 提示词的大型语言模型。[[demo]](https://huggingface.co/spaces/Nekochu/Luminia-13B_SD_Prompt) +1. **[Chinese-LLaVA-Med](https://github.com/BUAADreamer/Chinese-LLaVA-Med)**：中文多模态医学大模型，基于 LLaVA-1.5-7B 在中文多模态医疗数据上微调而得。 +1. **[AutoRE](https://github.com/THUDM/AutoRE)**：基于大语言模型的文档级关系抽取系统。 +1. **[NVIDIA RTX AI Toolkit](https://github.com/NVIDIA/RTX-AI-Toolkit)**：在 Windows 主机上利用英伟达 RTX 设备进行大型语言模型微调的开发包。 +1. **[LazyLLM](https://github.com/LazyAGI/LazyLLM)**：一个低代码构建多 Agent 大模型应用的开发工具，支持基于 LLaMA Factory 的模型微调. +1. **[RAG-Retrieval](https://github.com/NLPJCL/RAG-Retrieval)**：一个全链路 RAG 检索模型微调、推理和蒸馏代码库。[[blog]](https://zhuanlan.zhihu.com/p/987727357) +1. **[360-LLaMA-Factory](https://github.com/Qihoo360/360-LLaMA-Factory)**：一个魔改后的代码库，通过 Ring Attention 支持长序列的 SFT 和 DPO 训练。 +1. **[Sky-T1](https://novasky-ai.github.io/posts/sky-t1/)**：由 NovaSky AI 微调的低成本类 o1 长推理模型。 +1. **[WeClone](https://github.com/xming521/WeClone)**：从聊天记录创造数字分身的一站式解决方案。 + +
+ +## 协议 + +本仓库的代码依照 [Apache-2.0](LICENSE) 协议开源。 + +使用模型权重时，请遵循对应的模型协议：[Baichuan 2](https://huggingface.co/baichuan-inc/Baichuan2-7B-Base/blob/main/Community%20License%20for%20Baichuan%202%20Model.pdf) / [BLOOM](https://huggingface.co/spaces/bigscience/license) / [ChatGLM3](https://github.com/THUDM/ChatGLM3/blob/main/MODEL_LICENSE) / [Command R](https://cohere.com/c4ai-cc-by-nc-license) / [DeepSeek](https://github.com/deepseek-ai/DeepSeek-LLM/blob/main/LICENSE-MODEL) / [Falcon](https://huggingface.co/tiiuae/falcon-180B/blob/main/LICENSE.txt) / [Gemma](https://ai.google.dev/gemma/terms) / [GLM-4](https://huggingface.co/THUDM/glm-4-9b/blob/main/LICENSE) / [GPT-2](https://github.com/openai/gpt-2/blob/master/LICENSE) / [Granite](LICENSE) / [Index](https://huggingface.co/IndexTeam/Index-1.9B/blob/main/LICENSE) / [InternLM](https://github.com/InternLM/InternLM#license) / [Llama](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) / [Llama 2](https://ai.meta.com/llama/license/) / [Llama 3](https://llama.meta.com/llama3/license/) / [Llama 4](https://github.com/meta-llama/llama-models/blob/main/models/llama4/LICENSE) / [MiniCPM](https://github.com/OpenBMB/MiniCPM/blob/main/MiniCPM%20Model%20License.md) / [Mistral/Mixtral/Pixtral](LICENSE) / [OLMo](LICENSE) / [Phi-1.5/Phi-2](https://huggingface.co/microsoft/phi-1_5/resolve/main/Research%20License.docx) / [Phi-3/Phi-4](https://huggingface.co/microsoft/Phi-3-mini-4k-instruct/blob/main/LICENSE) / [Qwen](https://github.com/QwenLM/Qwen/blob/main/Tongyi%20Qianwen%20LICENSE%20AGREEMENT) / [Skywork](https://huggingface.co/Skywork/Skywork-13B-base/blob/main/Skywork%20Community%20License.pdf) / [StarCoder 2](https://huggingface.co/spaces/bigcode/bigcode-model-license-agreement) / [TeleChat2](https://huggingface.co/Tele-AI/telechat-7B/blob/main/TeleChat%E6%A8%A1%E5%9E%8B%E7%A4%BE%E5%8C%BA%E8%AE%B8%E5%8F%AF%E5%8D%8F%E8%AE%AE.pdf) / [XVERSE](https://github.com/xverse-ai/XVERSE-13B/blob/main/MODEL_LICENSE.pdf) / [Yi](https://huggingface.co/01-ai/Yi-6B/blob/main/LICENSE) / [Yi-1.5](LICENSE) / [Yuan 2](https://github.com/IEIT-Yuan/Yuan-2.0/blob/main/LICENSE-Yuan) + +## 引用 + +如果您觉得此项目有帮助，请考虑以下列格式引用 + +```bibtex +@inproceedings{zheng2024llamafactory, + title={LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models}, + author={Yaowei Zheng and Richong Zhang and Junhao Zhang and Yanhan Ye and Zheyan Luo and Zhangchi Feng and Yongqiang Ma}, + booktitle={Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations)}, + address={Bangkok, Thailand}, + publisher={Association for Computational Linguistics}, + year={2024}, + url={http://arxiv.org/abs/2403.13372} +} +``` + +## 致谢 + +本项目受益于 [PEFT](https://github.com/huggingface/peft)、[TRL](https://github.com/huggingface/trl)、[QLoRA](https://github.com/artidoro/qlora) 和 [FastChat](https://github.com/lm-sys/FastChat)，感谢以上诸位作者的付出。 + +## Star History + +![Star History Chart](https://api.star-history.com/svg?repos=hiyouga/LLaMA-Factory&type=Date) diff --git a/src/train_sft/assets/alaya_new.svg b/src/train_sft/assets/alaya_new.svg new file mode 100644 index 0000000000000000000000000000000000000000..3568e1511fb758b46cfc84122554ea23c8a0b1c7 --- /dev/null +++ b/src/train_sft/assets/alaya_new.svg @@ -0,0 +1,38 @@ + + + + + background + + + + Layer 1 + + + + + + + + + Ｏpen in Alaya NeW + + + + + diff --git a/src/train_sft/assets/serpapi.svg b/src/train_sft/assets/serpapi.svg new file mode 100644 index 0000000000000000000000000000000000000000..79bdf4001382b368148e9c3b611507bb7c0494f9 --- /dev/null +++ b/src/train_sft/assets/serpapi.svg @@ -0,0 +1 @@ + diff --git a/src/train_sft/docker/docker-cuda/Dockerfile b/src/train_sft/docker/docker-cuda/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..afca20871029757494bf9543d5fd44fd9afbc1a1 --- /dev/null +++ b/src/train_sft/docker/docker-cuda/Dockerfile @@ -0,0 +1,66 @@ +# https://hub.docker.com/r/hiyouga/pytorch/tags +ARG BASE_IMAGE=hiyouga/pytorch:th2.6.0-cu124-flashattn2.7.4-cxx11abi0-devel +FROM ${BASE_IMAGE} + +# Installation arguments +ARG PIP_INDEX=https://pypi.org/simple +ARG EXTRAS=metrics +ARG INSTALL_FLASHATTN=false +ARG HTTP_PROXY="" + +# Define environments +ENV MAX_JOBS=16 +ENV FLASH_ATTENTION_FORCE_BUILD=TRUE +ENV VLLM_WORKER_MULTIPROC_METHOD=spawn +ENV DEBIAN_FRONTEND=noninteractive +ENV NODE_OPTIONS="" +ENV PIP_ROOT_USER_ACTION=ignore +ENV http_proxy="${HTTP_PROXY}" +ENV https_proxy="${HTTP_PROXY}" + +# Use Bash instead of default /bin/sh +SHELL ["/bin/bash", "-c"] + +# Set the working directory +WORKDIR /app + +# Change pip source +RUN pip config set global.index-url "${PIP_INDEX}" && \ + pip config set global.extra-index-url "${PIP_INDEX}" && \ + pip install --no-cache-dir --upgrade pip packaging wheel setuptools + +# Install the requirements +COPY requirements.txt /app +RUN pip install --no-cache-dir -r requirements.txt + +# Copy the rest of the application into the image +COPY . /app + +# Install LLaMA Factory +RUN pip install --no-cache-dir -e ".[${EXTRAS}]" --no-build-isolation + +# Rebuild flash attention +RUN if [ "${INSTALL_FLASHATTN}" == "true" ]; then \ + pip uninstall -y ninja && \ + pip install --no-cache-dir ninja && \ + pip install --no-cache-dir flash-attn --no-build-isolation; \ + fi + +# Set up volumes +# VOLUME [ "/root/.cache/huggingface", "/app/shared_data", "/app/output" ] + +# Expose port 7860 for LLaMA Board +ENV GRADIO_SERVER_PORT=7860 +EXPOSE 7860 + +# Expose port 8000 for API service +ENV API_PORT=8000 +EXPOSE 8000 + +# unset proxy +ENV http_proxy= +ENV https_proxy= + +# Reset pip config +RUN pip config unset global.index-url && \ + pip config unset global.extra-index-url diff --git a/src/train_sft/docker/docker-cuda/Dockerfile.base b/src/train_sft/docker/docker-cuda/Dockerfile.base new file mode 100644 index 0000000000000000000000000000000000000000..542eb8dcced27998875cbd5dc5ee08b61e776db2 --- /dev/null +++ b/src/train_sft/docker/docker-cuda/Dockerfile.base @@ -0,0 +1,55 @@ +# Start from the pytorch official image (ubuntu-22.04 + cuda-12.4.1 + python-3.11) +# https://hub.docker.com/r/pytorch/pytorch/tags +FROM pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel + +# Define environments +ENV MAX_JOBS=16 +ENV VLLM_WORKER_MULTIPROC_METHOD=spawn +ENV DEBIAN_FRONTEND=noninteractive +ENV NODE_OPTIONS="" +ENV PIP_ROOT_USER_ACTION=ignore + +# Define installation arguments +ARG APT_SOURCE=https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ +ARG PIP_INDEX=https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple + +# Set apt source +RUN cp /etc/apt/sources.list /etc/apt/sources.list.bak && \ + { \ + echo "deb ${APT_SOURCE} jammy main restricted universe multiverse"; \ + echo "deb ${APT_SOURCE} jammy-updates main restricted universe multiverse"; \ + echo "deb ${APT_SOURCE} jammy-backports main restricted universe multiverse"; \ + echo "deb ${APT_SOURCE} jammy-security main restricted universe multiverse"; \ + } > /etc/apt/sources.list + +# Install systemctl and wget +RUN apt-get update && \ + apt-get install -y -o Dpkg::Options::="--force-confdef" systemd wget && \ + apt-get clean + +# Install git and vim +RUN apt-get update && \ + apt-get install -y git vim && \ + apt-get clean + +# Install gcc and g++ +RUN apt-get update && \ + apt-get install -y gcc g++ && \ + apt-get clean + +# Change pip source +RUN pip config set global.index-url "${PIP_INDEX}" && \ + pip config set global.extra-index-url "${PIP_INDEX}" && \ + pip install --no-cache-dir --upgrade pip packaging wheel setuptools + +# Install flash-attn-2.7.4.post1 (cxx11abi=False) +RUN wget -nv https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.4.post1/flash_attn-2.7.4.post1+cu12torch2.6cxx11abiFALSE-cp311-cp311-linux_x86_64.whl && \ + pip install --no-cache-dir flash_attn-2.7.4.post1+cu12torch2.6cxx11abiFALSE-cp311-cp311-linux_x86_64.whl + +# Install flashinfer-0.2.2.post1+cu124 (cxx11abi=False) +RUN wget -nv https://github.com/flashinfer-ai/flashinfer/releases/download/v0.2.2.post1/flashinfer_python-0.2.2.post1+cu124torch2.6-cp38-abi3-linux_x86_64.whl && \ + pip install --no-cache-dir flashinfer_python-0.2.2.post1+cu124torch2.6-cp38-abi3-linux_x86_64.whl + +# Reset pip config +RUN pip config unset global.index-url && \ + pip config unset global.extra-index-url diff --git a/src/train_sft/docker/docker-cuda/README.md b/src/train_sft/docker/docker-cuda/README.md new file mode 100644 index 0000000000000000000000000000000000000000..86707ce94852808d77d5f382ba5e1cff4c152a2b --- /dev/null +++ b/src/train_sft/docker/docker-cuda/README.md @@ -0,0 +1,111 @@ +# Docker Setup for NVIDIA GPUs + +This directory contains Docker configuration files for running LLaMA Factory with NVIDIA GPU support. + +## Prerequisites + +### Linux-specific Requirements + +Before running the Docker container with GPU support, you need to install the following packages: + +1. **Docker**: The container runtime + ```bash + # Ubuntu/Debian + sudo apt-get update + sudo apt-get install docker.io + + # Or install Docker Engine from the official repository: + # https://docs.docker.com/engine/install/ + ``` + +2. **Docker Compose** (if using the docker-compose method): + ```bash + # Ubuntu/Debian + sudo apt-get install docker-compose + + # Or install the latest version: + # https://docs.docker.com/compose/install/ + ``` + +3. **NVIDIA Container Toolkit** (required for GPU support): + ```bash + # Add the NVIDIA GPG key and repository + distribution=$(. /etc/os-release;echo $ID$VERSION_ID) + curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - + curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list + + # Install nvidia-container-toolkit + sudo apt-get update + sudo apt-get install -y nvidia-container-toolkit + + # Restart Docker to apply changes + sudo systemctl restart docker + ``` + + **Note**: Without `nvidia-container-toolkit`, the Docker container will not be able to access your NVIDIA GPU. + +### Verify GPU Access + +After installation, verify that Docker can access your GPU: + +```bash +sudo docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi +``` + +If successful, you should see your GPU information displayed. + +## Usage + +### Using Docker Compose (Recommended) + +```bash +cd docker/docker-cuda/ +docker compose up -d +docker compose exec llamafactory bash +``` + +### Using Docker Run + +```bash +# Build the image +docker build -f ./docker/docker-cuda/Dockerfile \ + --build-arg PIP_INDEX=https://pypi.org/simple \ + --build-arg EXTRAS=metrics \ + -t llamafactory:latest . + +# Run the container +docker run -dit --ipc=host --gpus=all \ + -p 7860:7860 \ + -p 8000:8000 \ + --name llamafactory \ + llamafactory:latest + +# Enter the container +docker exec -it llamafactory bash +``` + +## Troubleshooting + +### GPU Not Detected + +If your GPU is not detected inside the container: + +1. Ensure `nvidia-container-toolkit` is installed +2. Check that the Docker daemon has been restarted after installation +3. Verify your NVIDIA drivers are properly installed: `nvidia-smi` +4. Check Docker GPU support: `docker run --rm --gpus all ubuntu nvidia-smi` + +### Permission Denied + +If you get permission errors, ensure your user is in the docker group: + +```bash +sudo usermod -aG docker $USER +# Log out and back in for changes to take effect +``` + +## Additional Notes + +- The default image is built on Ubuntu 22.04 (x86_64), CUDA 12.4, Python 3.11, PyTorch 2.6.0, and Flash-attn 2.7.4 +- For different CUDA versions, you may need to adjust the base image in the Dockerfile +- Make sure your NVIDIA driver version is compatible with the CUDA version used in the Docker image diff --git a/src/train_sft/docker/docker-cuda/docker-compose.yml b/src/train_sft/docker/docker-cuda/docker-compose.yml new file mode 100644 index 0000000000000000000000000000000000000000..ab0da4d8702ce3a2a160e4cc222e31444d6592da --- /dev/null +++ b/src/train_sft/docker/docker-cuda/docker-compose.yml @@ -0,0 +1,25 @@ +services: + llamafactory: + build: + dockerfile: ./docker/docker-cuda/Dockerfile + context: ../.. + args: + PIP_INDEX: https://pypi.org/simple + EXTRAS: metrics + container_name: llamafactory + ports: + - "7860:7860" + - "8000:8000" + ipc: host + tty: true + # shm_size: "16gb" # ipc: host is set + stdin_open: true + command: bash + deploy: + resources: + reservations: + devices: + - driver: nvidia + count: "all" + capabilities: [ gpu ] + restart: unless-stopped diff --git a/src/train_sft/docker/docker-npu/Dockerfile b/src/train_sft/docker/docker-npu/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..7cd5e8f44ff74287c4407f483d5d9e5cb6b4c199 --- /dev/null +++ b/src/train_sft/docker/docker-npu/Dockerfile @@ -0,0 +1,63 @@ +# https://hub.docker.com/r/ascendai/cann/tags +ARG BASE_IMAGE=ascendai/cann:8.1.rc1-910b-ubuntu22.04-py3.11 +FROM ${BASE_IMAGE} + +# Installation arguments +ARG PIP_INDEX=https://pypi.org/simple +ARG EXTRAS=torch-npu,metrics +ARG HTTP_PROXY="" +ARG PYTORCH_INDEX=https://download.pytorch.org/whl/cpu + +# Define environments +ENV MAX_JOBS=16 +ENV FLASH_ATTENTION_FORCE_BUILD=TRUE +ENV VLLM_WORKER_MULTIPROC_METHOD=spawn +ENV DEBIAN_FRONTEND=noninteractive +ENV NODE_OPTIONS="" +ENV PIP_ROOT_USER_ACTION=ignore +ENV http_proxy="${HTTP_PROXY}" +ENV https_proxy="${HTTP_PROXY}" + +# Use Bash instead of default /bin/sh +SHELL ["/bin/bash", "-c"] + +# Set the working directory +WORKDIR /app + +# Change pip source +RUN pip config set global.index-url "${PIP_INDEX}" && \ + pip config set global.extra-index-url "${PIP_INDEX}" && \ + pip install --no-cache-dir --upgrade pip packaging wheel setuptools + +# Install torch-npu +RUN pip uninstall -y torch torchvision torchaudio && \ + pip install --no-cache-dir "torch-npu==2.5.1" "torchvision==0.20.1" --index-url "${PYTORCH_INDEX}" + +# Install the requirements +COPY requirements.txt /app +RUN pip install --no-cache-dir -r requirements.txt + +# Copy the rest of the application into the image +COPY . /app + +# Install LLaMA Factory +RUN pip install --no-cache-dir -e ".[${EXTRAS}]" --no-build-isolation + +# Set up volumes +# VOLUME [ "/root/.cache/huggingface", "/app/shared_data", "/app/output" ] + +# Expose port 7860 for LLaMA Board +ENV GRADIO_SERVER_PORT=7860 +EXPOSE 7860 + +# Expose port 8000 for API service +ENV API_PORT=8000 +EXPOSE 8000 + +# unset proxy +ENV http_proxy= +ENV https_proxy= + +# Reset pip config +RUN pip config unset global.index-url && \ + pip config unset global.extra-index-url diff --git a/src/train_sft/docker/docker-npu/docker-compose.yml b/src/train_sft/docker/docker-npu/docker-compose.yml new file mode 100644 index 0000000000000000000000000000000000000000..659f8d1bb29f98023447b7395d9a77bc24e81224 --- /dev/null +++ b/src/train_sft/docker/docker-npu/docker-compose.yml @@ -0,0 +1,28 @@ +services: + llamafactory: + build: + dockerfile: ./docker/docker-npu/Dockerfile + context: ../.. + args: + PIP_INDEX: https://pypi.org/simple + EXTRAS: torch-npu,metrics + container_name: llamafactory + volumes: + - /usr/local/dcmi:/usr/local/dcmi + - /usr/local/bin/npu-smi:/usr/local/bin/npu-smi + - /usr/local/Ascend/driver:/usr/local/Ascend/driver + - /etc/ascend_install.info:/etc/ascend_install.info + ports: + - "7860:7860" + - "8000:8000" + ipc: host + tty: true + # shm_size: "16gb" # ipc: host is set + stdin_open: true + command: bash + devices: + - /dev/davinci0 + - /dev/davinci_manager + - /dev/devmm_svm + - /dev/hisi_hdc + restart: unless-stopped diff --git a/src/train_sft/docker/docker-rocm/Dockerfile b/src/train_sft/docker/docker-rocm/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..67f4f3669c130327606eac2047295c09c1fd2cd6 --- /dev/null +++ b/src/train_sft/docker/docker-rocm/Dockerfile @@ -0,0 +1,71 @@ +# https://hub.docker.com/r/rocm/pytorch/tags +ARG BASE_IMAGE=rocm/pytorch:rocm6.4.1_ubuntu22.04_py3.10_pytorch_release_2.6.0 +FROM ${BASE_IMAGE} + +# Installation arguments +ARG PIP_INDEX=https://pypi.org/simple +ARG EXTRAS=metrics +ARG INSTALL_FLASHATTN=false +ARG HTTP_PROXY="" +ARG PYTORCH_INDEX=https://download.pytorch.org/whl/rocm6.3 + +# Define environments +ENV MAX_JOBS=16 +ENV FLASH_ATTENTION_FORCE_BUILD=TRUE +ENV VLLM_WORKER_MULTIPROC_METHOD=spawn +ENV DEBIAN_FRONTEND=noninteractive +ENV NODE_OPTIONS="" +ENV PIP_ROOT_USER_ACTION=ignore +ENV http_proxy="${HTTP_PROXY}" +ENV https_proxy="${HTTP_PROXY}" + +# Use Bash instead of default /bin/sh +SHELL ["/bin/bash", "-c"] + +# Set the working directory +WORKDIR /app + +# Change pip source +RUN pip config set global.index-url "${PIP_INDEX}" && \ + pip config set global.extra-index-url "${PIP_INDEX}" && \ + pip install --no-cache-dir --upgrade pip packaging wheel setuptools + +# Reinstall pytorch rocm +RUN pip uninstall -y torch torchvision torchaudio && \ + pip install --no-cache-dir --pre torch torchvision torchaudio --index-url "${PYTORCH_INDEX}" + +# Install the requirements +COPY requirements.txt /app +RUN pip install --no-cache-dir -r requirements.txt + +# Copy the rest of the application into the image +COPY . /app + +# Install LLaMA Factory +RUN pip install --no-cache-dir -e ".[${EXTRAS}]" --no-build-isolation + +# Rebuild flash attention +RUN if [ "${INSTALL_FLASHATTN}" == "true" ]; then \ + pip uninstall -y ninja && \ + pip install --no-cache-dir ninja && \ + pip install --no-cache-dir flash-attn --no-build-isolation; \ + fi + +# Set up volumes +# VOLUME [ "/root/.cache/huggingface", "/app/shared_data", "/app/output" ] + +# Expose port 7860 for LLaMA Board +ENV GRADIO_SERVER_PORT=7860 +EXPOSE 7860 + +# Expose port 8000 for API service +ENV API_PORT=8000 +EXPOSE 8000 + +# unset proxy +ENV http_proxy= +ENV https_proxy= + +# Reset pip config +RUN pip config unset global.index-url && \ + pip config unset global.extra-index-url diff --git a/src/train_sft/docker/docker-rocm/docker-compose.yml b/src/train_sft/docker/docker-rocm/docker-compose.yml new file mode 100644 index 0000000000000000000000000000000000000000..32cdf5633ef8a80863bf5b018d24612b2e923f7b --- /dev/null +++ b/src/train_sft/docker/docker-rocm/docker-compose.yml @@ -0,0 +1,21 @@ +services: + llamafactory: + build: + dockerfile: ./docker/docker-rocm/Dockerfile + context: ../.. + args: + PIP_INDEX: https://pypi.org/simple + EXTRAS: metrics + container_name: llamafactory + ports: + - "7860:7860" + - "8000:8000" + ipc: host + tty: true + # shm_size: "16gb" # ipc: host is set + stdin_open: true + command: bash + devices: + - /dev/kfd:/dev/kfd + - /dev/dri:/dev/dri + restart: unless-stopped diff --git a/src/train_sft/examples/extras/apollo/llama3_full_sft.yaml b/src/train_sft/examples/extras/apollo/llama3_full_sft.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d9fb6c2002df08018b7110437471797bdfef777e --- /dev/null +++ b/src/train_sft/examples/extras/apollo/llama3_full_sft.yaml @@ -0,0 +1,48 @@ +### model +model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct +trust_remote_code: true + +### method +stage: sft +do_train: true +finetuning_type: full +use_apollo: true +apollo_layerwise: true # choices: [true, false], use false for DDP training +apollo_target: all +apollo_rank: 128 +apollo_scale: 32.0 +apollo_scale_type: channel + +### dataset +dataset: identity,alpaca_en_demo +template: llama3 +cutoff_len: 2048 +max_samples: 1000 +overwrite_cache: true +preprocessing_num_workers: 16 +dataloader_num_workers: 4 + +### output +output_dir: saves/llama3-8b/full/sft +logging_steps: 10 +save_steps: 500 +plot_loss: true +overwrite_output_dir: true +save_only_model: false +report_to: none # choices: [none, wandb, tensorboard, swanlab, mlflow] + +### train +per_device_train_batch_size: 1 +gradient_accumulation_steps: 1 # use 1 for layerwise apollo +learning_rate: 1.0e-5 +num_train_epochs: 3.0 +lr_scheduler_type: cosine +warmup_ratio: 0.1 +pure_bf16: true +ddp_timeout: 180000000 + +### eval +# val_size: 0.1 +# per_device_eval_batch_size: 1 +# eval_strategy: steps +# eval_steps: 500 diff --git a/src/train_sft/examples/extras/fsdp_qlora/llama3_lora_sft.yaml b/src/train_sft/examples/extras/fsdp_qlora/llama3_lora_sft.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1a8d9743035e3c5848ba943eb0fc47eb7b1da6be --- /dev/null +++ b/src/train_sft/examples/extras/fsdp_qlora/llama3_lora_sft.yaml @@ -0,0 +1,45 @@ +### model +model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct +quantization_bit: 4 +trust_remote_code: true + +### method +stage: sft +do_train: true +finetuning_type: lora +lora_rank: 8 +lora_target: all + +### dataset +dataset: identity,alpaca_en_demo +template: llama3 +cutoff_len: 2048 +max_samples: 1000 +overwrite_cache: true +preprocessing_num_workers: 16 +dataloader_num_workers: 4 + +### output +output_dir: saves/llama3-8b/lora/sft +logging_steps: 10 +save_steps: 500 +plot_loss: true +overwrite_output_dir: true +save_only_model: false +report_to: none # choices: [none, wandb, tensorboard, swanlab, mlflow] + +### train +per_device_train_batch_size: 1 +gradient_accumulation_steps: 8 +learning_rate: 1.0e-4 +num_train_epochs: 3.0 +lr_scheduler_type: cosine +warmup_ratio: 0.1 +bf16: true +ddp_timeout: 180000000 + +### eval +# val_size: 0.1 +# per_device_eval_batch_size: 1 +# eval_strategy: steps +# eval_steps: 500 diff --git a/src/train_sft/examples/extras/fsdp_qlora/train.sh b/src/train_sft/examples/extras/fsdp_qlora/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..fac8cdee8781750d96e29999ab8a6b9b4f1bc322 --- /dev/null +++ b/src/train_sft/examples/extras/fsdp_qlora/train.sh @@ -0,0 +1,6 @@ +#!/bin/bash +# DO NOT use GPTQ/AWQ model in FSDP+QLoRA + +CUDA_VISIBLE_DEVICES=0,1 accelerate launch \ + --config_file examples/accelerate/fsdp_config.yaml \ + src/train.py examples/extras/fsdp_qlora/llama3_lora_sft.yaml diff --git a/src/train_sft/examples/extras/galore/llama3_full_sft.yaml b/src/train_sft/examples/extras/galore/llama3_full_sft.yaml new file mode 100644 index 0000000000000000000000000000000000000000..99730932ae5150e1eacdd2c20ad9b9a7b0e51263 --- /dev/null +++ b/src/train_sft/examples/extras/galore/llama3_full_sft.yaml @@ -0,0 +1,47 @@ +### model +model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct +trust_remote_code: true + +### method +stage: sft +do_train: true +finetuning_type: full +use_galore: true +galore_layerwise: true # choices: [true, false], use false for DDP training +galore_target: all +galore_rank: 128 +galore_scale: 2.0 + +### dataset +dataset: identity,alpaca_en_demo +template: llama3 +cutoff_len: 2048 +max_samples: 1000 +overwrite_cache: true +preprocessing_num_workers: 16 +dataloader_num_workers: 4 + +### output +output_dir: saves/llama3-8b/full/sft +logging_steps: 10 +save_steps: 500 +plot_loss: true +overwrite_output_dir: true +save_only_model: false +report_to: none # choices: [none, wandb, tensorboard, swanlab, mlflow] + +### train +per_device_train_batch_size: 1 +gradient_accumulation_steps: 1 # use 1 for layerwise galore +learning_rate: 1.0e-5 +num_train_epochs: 3.0 +lr_scheduler_type: cosine +warmup_ratio: 0.1 +pure_bf16: true +ddp_timeout: 180000000 + +### eval +# val_size: 0.1 +# per_device_eval_batch_size: 1 +# eval_strategy: steps +# eval_steps: 500 diff --git a/src/train_sft/examples/extras/pissa/llama3_lora_sft.yaml b/src/train_sft/examples/extras/pissa/llama3_lora_sft.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1668343bbec09711819d875a684ed646a54f8638 --- /dev/null +++ b/src/train_sft/examples/extras/pissa/llama3_lora_sft.yaml @@ -0,0 +1,47 @@ +### model +model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct +trust_remote_code: true + +### method +stage: sft +do_train: true +finetuning_type: lora +lora_rank: 8 +lora_target: all +pissa_init: true +pissa_iter: 16 +pissa_convert: true + +### dataset +dataset: identity,alpaca_en_demo +template: llama3 +cutoff_len: 2048 +max_samples: 1000 +overwrite_cache: true +preprocessing_num_workers: 16 +dataloader_num_workers: 4 + +### output +output_dir: saves/llama3-8b/lora/sft +logging_steps: 10 +save_steps: 500 +plot_loss: true +overwrite_output_dir: true +save_only_model: false +report_to: none # choices: [none, wandb, tensorboard, swanlab, mlflow] + +### train +per_device_train_batch_size: 1 +gradient_accumulation_steps: 8 +learning_rate: 1.0e-4 +num_train_epochs: 3.0 +lr_scheduler_type: cosine +warmup_ratio: 0.1 +bf16: true +ddp_timeout: 180000000 + +### eval +# val_size: 0.1 +# per_device_eval_batch_size: 1 +# eval_strategy: steps +# eval_steps: 500 diff --git a/src/train_sft/pyproject.toml b/src/train_sft/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..c9d753cbb25b34c4cdfde4aa98263360555981e3 --- /dev/null +++ b/src/train_sft/pyproject.toml @@ -0,0 +1,95 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "llamafactory" +dynamic = [ + "version", + "dependencies", + "optional-dependencies", + "requires-python", + "scripts", + "authors", + "description", + "readme", + "license", + "keywords", + "classifiers" +] + +[tool.ruff] +target-version = "py39" +line-length = 119 +indent-width = 4 + +[tool.ruff.lint] +ignore = [ + "C408", # collection + "C901", # complex + "E501", # line too long + "E731", # lambda function + "E741", # ambiguous var name + "D100", # no doc public module + "D101", # no doc public class + "D102", # no doc public method + "D103", # no doc public function + "D104", # no doc public package + "D105", # no doc magic method + "D107", # no doc __init__ +] +extend-select = [ + "C", # complexity + "E", # error + "F", # pyflakes + "I", # isort + "W", # warning + "UP", # pyupgrade + "D", # pydocstyle + "PT009", # pytest assert + "RUF022", # sort __all__ +] + +[tool.ruff.lint.isort] +lines-after-imports = 2 +known-first-party = ["llamafactory"] +known-third-party = [ + "accelerate", + "datasets", + "gradio", + "numpy", + "peft", + "torch", + "transformers", + "trl", +] + +[tool.ruff.lint.pydocstyle] +convention = "google" + +[tool.ruff.format] +quote-style = "double" +indent-style = "space" +docstring-code-format = true +skip-magic-trailing-comma = false +line-ending = "auto" + +[tool.uv] +conflicts = [ + [ + { extra = "torch-npu" }, + { extra = "aqlm" }, + ], + [ + { extra = "torch-npu" }, + { extra = "vllm" }, + ], + [ + { extra = "torch-npu" }, + { extra = "sglang" }, + ], + [ + { extra = "vllm" }, + { extra = "sglang" }, + ], +] diff --git a/src/train_sft/requirements.txt b/src/train_sft/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..650d08c30b08b11b7c3dc53021b44d17ae9d4dbf --- /dev/null +++ b/src/train_sft/requirements.txt @@ -0,0 +1,37 @@ +# core deps +transformers>=4.49.0,<=4.55.0,!=4.52.0 +datasets>=2.16.0,<=3.6.0 +accelerate>=1.3.0,<=1.7.0 +peft>=0.14.0,<=0.15.2 +trl>=0.8.6,<=0.9.6 +tokenizers>=0.19.0,<=0.21.1 +# gui +gradio>=4.38.0,<=5.31.0 +matplotlib>=3.7.0 +tyro<0.9.0 +# ops +einops +numpy<2.0.0 +pandas>=2.0.0 +scipy +# model and tokenizer +sentencepiece +tiktoken +modelscope>=1.14.0 +hf-transfer +safetensors<=0.5.3 +# python +fire +omegaconf +packaging +protobuf +pyyaml +pydantic<=2.10.6 +# api +uvicorn +fastapi +sse-starlette +# media +av +librosa +wandb diff --git a/src/train_sft/scripts/llama_pro.py b/src/train_sft/scripts/llama_pro.py new file mode 100644 index 0000000000000000000000000000000000000000..7e4b9448505769104f5155ce7bc4c3ef9ec01bc6 --- /dev/null +++ b/src/train_sft/scripts/llama_pro.py @@ -0,0 +1,129 @@ +# Copyright 2025 Tencent Inc. and the LlamaFactory team. +# +# This code is inspired by the Tencent's LLaMA-Pro library. +# https://github.com/TencentARC/LLaMA-Pro/blob/main/scripts/block_expansion.py +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import os +from collections import OrderedDict +from typing import TYPE_CHECKING + +import fire +import torch +from huggingface_hub import split_torch_state_dict_into_shards +from safetensors.torch import save_file +from tqdm import tqdm +from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, PreTrainedModel +from transformers.modeling_utils import SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, WEIGHTS_INDEX_NAME, WEIGHTS_NAME + + +if TYPE_CHECKING: + from transformers import PretrainedConfig + + +def change_name(name: str, old_index: int, new_index: int) -> str: + return name.replace(f".{old_index:d}.", f".{new_index:d}.") + + +def block_expansion( + model_name_or_path: str, + output_dir: str, + num_expand: int, + shard_size: str = "5GB", + save_safetensors: bool = True, +): + r"""Perform block expansion for LLaMA, Mistral, Qwen2 or Yi models. + + Usage: python llama_pro.py --model_name_or_path meta-llama/Llama-2-7b-hf --output_dir llama2_pro --num_expand 8 + """ + config: PretrainedConfig = AutoConfig.from_pretrained(model_name_or_path, trust_remote_code=True) + num_layers = getattr(config, "num_hidden_layers") + if num_layers % num_expand != 0: + raise ValueError(f"`num_layers` {num_layers} should be divisible by `num_expand` {num_expand}.") + + setattr(config, "num_hidden_layers", num_layers + num_expand) + config.save_pretrained(output_dir) + + tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True) + tokenizer.save_pretrained(output_dir) + + print(f"Expanding model of {num_layers} layers to {num_layers + num_expand} layers.") + model = AutoModelForCausalLM.from_pretrained( + model_name_or_path, torch_dtype="auto", device_map="cpu", trust_remote_code=True, low_cpu_mem_usage=True + ) + assert isinstance(model, PreTrainedModel) # type hint + if save_safetensors and getattr(model.config, "tie_word_embeddings", False): + del model.lm_head # safetensors does not allow shared weights + + split = num_layers // num_expand + layer_cnt = 0 + state_dict = model.state_dict() + output_state_dict: dict[str, torch.Tensor] = OrderedDict() + for i in range(num_layers): + for key, value in state_dict.items(): + if f".{i:d}." in key: + output_state_dict[change_name(key, i, layer_cnt)] = value + + print(f"Add layer {layer_cnt} copied from layer {i}.") + layer_cnt += 1 + if (i + 1) % split == 0: + for key, value in state_dict.items(): + if f".{i:d}." in key: + if "down_proj" in key or "o_proj" in key: + output_state_dict[change_name(key, i, layer_cnt)] = torch.zeros_like(value) + else: + output_state_dict[change_name(key, i, layer_cnt)] = torch.clone(value) + + print(f"Add layer {layer_cnt} expanded from layer {i}.") + layer_cnt += 1 + + for key, value in state_dict.items(): + if key not in output_state_dict: + output_state_dict[key] = value + + weights_name = SAFE_WEIGHTS_NAME if save_safetensors else WEIGHTS_NAME + filename_pattern = weights_name.replace(".bin", "{suffix}.bin").replace(".safetensors", "{suffix}.safetensors") + state_dict_split = split_torch_state_dict_into_shards( + output_state_dict, filename_pattern=filename_pattern, max_shard_size=shard_size + ) + for shard_file, tensors in tqdm(state_dict_split.filename_to_tensors.items(), desc="Save weights"): + shard = {tensor: output_state_dict[tensor].contiguous() for tensor in tensors} + if save_safetensors: + save_file(shard, os.path.join(output_dir, shard_file), metadata={"format": "pt"}) + else: + torch.save(shard, os.path.join(output_dir, shard_file)) + + if not state_dict_split.is_sharded: + print(f"Model weights saved in {os.path.join(output_dir, weights_name)}.") + else: + index = { + "metadata": state_dict_split.metadata, + "weight_map": state_dict_split.tensor_to_filename, + } + index_name = SAFE_WEIGHTS_INDEX_NAME if save_safetensors else WEIGHTS_INDEX_NAME + with open(os.path.join(output_dir, index_name), "w", encoding="utf-8") as f: + json.dump(index, f, indent=2, sort_keys=True) + + print(f"Model weights saved in {output_dir}.") + + print("- Fine-tune this model with:") + print(f"model_name_or_path: {output_dir}") + print("finetuning_type: freeze") + print(f"freeze_trainable_layers: {num_expand}") + print("use_llama_pro: true") + + +if __name__ == "__main__": + fire.Fire(block_expansion) diff --git a/src/train_sft/scripts/loftq_init.py b/src/train_sft/scripts/loftq_init.py new file mode 100644 index 0000000000000000000000000000000000000000..3a7933889be55a254b2417e9dca2ce2b7d691401 --- /dev/null +++ b/src/train_sft/scripts/loftq_init.py @@ -0,0 +1,88 @@ +# Copyright 2025 HuggingFace Inc. and the LlamaFactory team. +# +# This code is based on the HuggingFace's PEFT library. +# https://github.com/huggingface/peft/blob/v0.10.0/examples/loftq_finetuning/quantize_save_load.py +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import TYPE_CHECKING + +import fire +from peft import LoftQConfig, LoraConfig, TaskType, get_peft_model +from transformers import AutoModelForCausalLM, AutoTokenizer + + +if TYPE_CHECKING: + from transformers import PreTrainedModel + + +def quantize_loftq( + model_name_or_path: str, + output_dir: str, + loftq_bits: int = 4, + loftq_iter: int = 4, + lora_alpha: int = None, + lora_rank: int = 16, + lora_dropout: float = 0, + lora_target: tuple = ("q_proj", "v_proj"), + save_safetensors: bool = True, +): + r"""Initialize LoRA weights with LoRA-fine-tuning-aware Quantization (LoftQ). + + Usage: python loftq_init.py --model_name_or_path path_to_model --output_dir output_dir + """ + if isinstance(lora_target, str): + lora_target = [name.strip() for name in lora_target.split(",")] + + tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True) + model = AutoModelForCausalLM.from_pretrained(model_name_or_path, trust_remote_code=True, torch_dtype="auto") + + loftq_config = LoftQConfig(loftq_bits=loftq_bits, loftq_iter=loftq_iter) + lora_config = LoraConfig( + task_type=TaskType.CAUSAL_LM, + inference_mode=True, + r=lora_rank, + lora_alpha=lora_alpha if lora_alpha is not None else lora_rank * 2, + lora_dropout=lora_dropout, + target_modules=lora_target, + init_lora_weights="loftq", + loftq_config=loftq_config, + ) + + # Init LoftQ model + print("Initializing LoftQ weights, it may be take several minutes, wait patiently.") + peft_model = get_peft_model(model, lora_config) + loftq_dir = os.path.join(output_dir, "loftq_init") + + # Save LoftQ model + setattr(peft_model.peft_config["default"], "base_model_name_or_path", os.path.abspath(output_dir)) + setattr(peft_model.peft_config["default"], "init_lora_weights", True) # don't apply loftq again + peft_model.save_pretrained(loftq_dir, safe_serialization=save_safetensors) + print(f"Adapter weights saved in {loftq_dir}") + + # Save base model + base_model: PreTrainedModel = peft_model.unload() + base_model.save_pretrained(output_dir, safe_serialization=save_safetensors) + tokenizer.save_pretrained(output_dir) + print(f"Model weights saved in {output_dir}") + + print("- Fine-tune this model with:") + print(f"model_name_or_path: {output_dir}") + print(f"adapter_name_or_path: {loftq_dir}") + print("finetuning_type: lora") + print(f"quantization_bit: {loftq_bits}") + + +if __name__ == "__main__": + fire.Fire(quantize_loftq) diff --git a/src/train_sft/setup.py b/src/train_sft/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..6a079ac85ba7103b4b8a1b0954eb7bfc2add6bbe --- /dev/null +++ b/src/train_sft/setup.py @@ -0,0 +1,113 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import re + +from setuptools import find_packages, setup + + +def get_version() -> str: + with open(os.path.join("src", "llamafactory", "extras", "env.py"), encoding="utf-8") as f: + file_content = f.read() + pattern = r"{}\W*=\W*\"([^\"]+)\"".format("VERSION") + (version,) = re.findall(pattern, file_content) + return version + + +def get_requires() -> list[str]: + with open("requirements.txt", encoding="utf-8") as f: + file_content = f.read() + lines = [line.strip() for line in file_content.strip().split("\n") if not line.startswith("#")] + return lines + + +def get_console_scripts() -> list[str]: + console_scripts = ["llamafactory-cli = llamafactory.cli:main"] + if os.getenv("ENABLE_SHORT_CONSOLE", "1").lower() in ["true", "y", "1"]: + console_scripts.append("lmf = llamafactory.cli:main") + + return console_scripts + + +extra_require = { + "torch": ["torch>=2.0.0", "torchvision>=0.15.0"], + "torch-npu": ["torch-npu==2.5.1", "torchvision==0.20.1", "decorator"], + "metrics": ["nltk", "jieba", "rouge-chinese"], + "deepspeed": ["deepspeed>=0.10.0,<=0.16.9"], + "liger-kernel": ["liger-kernel>=0.5.5"], + "bitsandbytes": ["bitsandbytes>=0.39.0"], + "hqq": ["hqq"], + "eetq": ["eetq"], + "gptq": ["optimum>=1.24.0", "gptqmodel>=2.0.0"], + "aqlm": ["aqlm[gpu]>=1.1.0"], + "vllm": ["vllm>=0.4.3,<=0.10.0"], + "sglang": ["sglang[srt]>=0.4.5", "transformers==4.51.1"], + "galore": ["galore-torch"], + "apollo": ["apollo-torch"], + "badam": ["badam>=1.2.1"], + "adam-mini": ["adam-mini"], + "minicpm_v": [ + "soundfile", + "torchvision", + "torchaudio", + "vector_quantize_pytorch", + "vocos", + "msgpack", + "referencing", + "jsonschema_specifications", + ], + "openmind": ["openmind"], + "swanlab": ["swanlab"], + "dev": ["pre-commit", "ruff", "pytest", "build"], +} + + +def main(): + setup( + name="llamafactory", + version=get_version(), + author="hiyouga", + author_email="hiyouga@buaa.edu.cn", + description="Unified Efficient Fine-Tuning of 100+ LLMs", + long_description=open("README.md", encoding="utf-8").read(), + long_description_content_type="text/markdown", + keywords=["AI", "LLM", "GPT", "ChatGPT", "Llama", "Transformer", "DeepSeek", "Pytorch"], + license="Apache 2.0 License", + url="https://github.com/hiyouga/LLaMA-Factory", + package_dir={"": "src"}, + packages=find_packages("src"), + python_requires=">=3.9.0", + install_requires=get_requires(), + extras_require=extra_require, + entry_points={"console_scripts": get_console_scripts()}, + classifiers=[ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Intended Audience :: Education", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: Apache Software License", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + ], + ) + + +if __name__ == "__main__": + main() diff --git a/src/train_sft/src/llamafactory/__init__.py b/src/train_sft/src/llamafactory/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b1567ef572714881cc464db25d3da3d08a460963 --- /dev/null +++ b/src/train_sft/src/llamafactory/__init__.py @@ -0,0 +1,31 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +r"""Efficient fine-tuning of large language models. + +Level: + api, webui > chat, eval, train > data, model > hparams > extras + +Disable version checking: DISABLE_VERSION_CHECK=1 +Enable VRAM recording: RECORD_VRAM=1 +Force using torchrun: FORCE_TORCHRUN=1 +Set logging verbosity: LLAMAFACTORY_VERBOSITY=WARN +Use modelscope: USE_MODELSCOPE_HUB=1 +Use openmind: USE_OPENMIND_HUB=1 +""" + +from .extras.env import VERSION + + +__version__ = VERSION diff --git a/src/train_sft/src/llamafactory/__pycache__/__init__.cpython-311.pyc b/src/train_sft/src/llamafactory/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec8cbfaccfc909c4f9e352922f685a926660f0c9 Binary files /dev/null and b/src/train_sft/src/llamafactory/__pycache__/__init__.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/__pycache__/__init__.cpython-313.pyc b/src/train_sft/src/llamafactory/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..652d20053dc5fe0a6080a0084b57ddfc23a33f76 Binary files /dev/null and b/src/train_sft/src/llamafactory/__pycache__/__init__.cpython-313.pyc differ diff --git a/src/train_sft/src/llamafactory/__pycache__/cli.cpython-311.pyc b/src/train_sft/src/llamafactory/__pycache__/cli.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46d6cd0214311d1956ef258f5a1bd2e7944ea163 Binary files /dev/null and b/src/train_sft/src/llamafactory/__pycache__/cli.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/__pycache__/launcher.cpython-311.pyc b/src/train_sft/src/llamafactory/__pycache__/launcher.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec9245ab8d21867a410f2407ad5e3af8e8aa753f Binary files /dev/null and b/src/train_sft/src/llamafactory/__pycache__/launcher.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/api/__init__.py b/src/train_sft/src/llamafactory/api/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/train_sft/src/llamafactory/api/app.py b/src/train_sft/src/llamafactory/api/app.py new file mode 100644 index 0000000000000000000000000000000000000000..e0621d80b064f00970e8fb58909ec8656ba0fb6b --- /dev/null +++ b/src/train_sft/src/llamafactory/api/app.py @@ -0,0 +1,133 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import asyncio +import os +from contextlib import asynccontextmanager +from functools import partial +from typing import Annotated, Optional + +from ..chat import ChatModel +from ..extras.constants import EngineName +from ..extras.misc import torch_gc +from ..extras.packages import is_fastapi_available, is_starlette_available, is_uvicorn_available +from .chat import ( + create_chat_completion_response, + create_score_evaluation_response, + create_stream_chat_completion_response, +) +from .protocol import ( + ChatCompletionRequest, + ChatCompletionResponse, + ModelCard, + ModelList, + ScoreEvaluationRequest, + ScoreEvaluationResponse, +) + + +if is_fastapi_available(): + from fastapi import Depends, FastAPI, HTTPException, status + from fastapi.middleware.cors import CORSMiddleware + from fastapi.security.http import HTTPAuthorizationCredentials, HTTPBearer + + +if is_starlette_available(): + from sse_starlette import EventSourceResponse + + +if is_uvicorn_available(): + import uvicorn + + +async def sweeper() -> None: + while True: + torch_gc() + await asyncio.sleep(300) + + +@asynccontextmanager +async def lifespan(app: "FastAPI", chat_model: "ChatModel"): # collects GPU memory + if chat_model.engine.name == EngineName.HF: + asyncio.create_task(sweeper()) + + yield + torch_gc() + + +def create_app(chat_model: "ChatModel") -> "FastAPI": + root_path = os.getenv("FASTAPI_ROOT_PATH", "") + app = FastAPI(lifespan=partial(lifespan, chat_model=chat_model), root_path=root_path) + app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], + ) + api_key = os.getenv("API_KEY") + security = HTTPBearer(auto_error=False) + + async def verify_api_key(auth: Annotated[Optional[HTTPAuthorizationCredentials], Depends(security)]): + if api_key and (auth is None or auth.credentials != api_key): + raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key.") + + @app.get( + "/v1/models", + response_model=ModelList, + status_code=status.HTTP_200_OK, + dependencies=[Depends(verify_api_key)], + ) + async def list_models(): + model_card = ModelCard(id=os.getenv("API_MODEL_NAME", "gpt-3.5-turbo")) + return ModelList(data=[model_card]) + + @app.post( + "/v1/chat/completions", + response_model=ChatCompletionResponse, + status_code=status.HTTP_200_OK, + dependencies=[Depends(verify_api_key)], + ) + async def create_chat_completion(request: ChatCompletionRequest): + if not chat_model.engine.can_generate: + raise HTTPException(status_code=status.HTTP_405_METHOD_NOT_ALLOWED, detail="Not allowed") + + if request.stream: + generate = create_stream_chat_completion_response(request, chat_model) + return EventSourceResponse(generate, media_type="text/event-stream", sep="\n") + else: + return await create_chat_completion_response(request, chat_model) + + @app.post( + "/v1/score/evaluation", + response_model=ScoreEvaluationResponse, + status_code=status.HTTP_200_OK, + dependencies=[Depends(verify_api_key)], + ) + async def create_score_evaluation(request: ScoreEvaluationRequest): + if chat_model.engine.can_generate: + raise HTTPException(status_code=status.HTTP_405_METHOD_NOT_ALLOWED, detail="Not allowed") + + return await create_score_evaluation_response(request, chat_model) + + return app + + +def run_api() -> None: + chat_model = ChatModel() + app = create_app(chat_model) + api_host = os.getenv("API_HOST", "0.0.0.0") + api_port = int(os.getenv("API_PORT", "8000")) + print(f"Visit http://localhost:{api_port}/docs for API document.") + uvicorn.run(app, host=api_host, port=api_port) diff --git a/src/train_sft/src/llamafactory/api/chat.py b/src/train_sft/src/llamafactory/api/chat.py new file mode 100644 index 0000000000000000000000000000000000000000..c0d87196c5d09de7b223c6d161da57405a526628 --- /dev/null +++ b/src/train_sft/src/llamafactory/api/chat.py @@ -0,0 +1,285 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import base64 +import io +import json +import os +import re +import uuid +from collections.abc import AsyncGenerator +from typing import TYPE_CHECKING, Optional + +from ..data import Role as DataRole +from ..extras import logging +from ..extras.constants import AUDIO_PLACEHOLDER, IMAGE_PLACEHOLDER, VIDEO_PLACEHOLDER +from ..extras.misc import is_env_enabled +from ..extras.packages import is_fastapi_available, is_pillow_available, is_requests_available +from .common import dictify, jsonify +from .protocol import ( + ChatCompletionMessage, + ChatCompletionResponse, + ChatCompletionResponseChoice, + ChatCompletionResponseUsage, + ChatCompletionStreamResponse, + ChatCompletionStreamResponseChoice, + Finish, + Function, + FunctionCall, + Role, + ScoreEvaluationResponse, +) + + +if is_fastapi_available(): + from fastapi import HTTPException, status + + +if is_pillow_available(): + from PIL import Image + + +if is_requests_available(): + import requests + + +if TYPE_CHECKING: + from ..chat import ChatModel + from ..data.mm_plugin import AudioInput, ImageInput, VideoInput + from .protocol import ChatCompletionRequest, ScoreEvaluationRequest + + +logger = logging.get_logger(__name__) +ROLE_MAPPING = { + Role.USER: DataRole.USER.value, + Role.ASSISTANT: DataRole.ASSISTANT.value, + Role.SYSTEM: DataRole.SYSTEM.value, + Role.FUNCTION: DataRole.FUNCTION.value, + Role.TOOL: DataRole.OBSERVATION.value, +} + + +def _process_request( + request: "ChatCompletionRequest", +) -> tuple[ + list[dict[str, str]], + Optional[str], + Optional[str], + Optional[list["ImageInput"]], + Optional[list["VideoInput"]], + Optional[list["AudioInput"]], +]: + if is_env_enabled("API_VERBOSE", "1"): + logger.info_rank0(f"==== request ====\n{json.dumps(dictify(request), indent=2, ensure_ascii=False)}") + + if len(request.messages) == 0: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid length") + + if request.messages[0].role == Role.SYSTEM: + content = request.messages.pop(0).content + system = content[0].text if isinstance(content, list) else content + else: + system = None + + if len(request.messages) % 2 == 0: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Only supports u/a/u/a/u...") + + input_messages = [] + images, videos, audios = [], [], [] + for i, message in enumerate(request.messages): + if i % 2 == 0 and message.role not in [Role.USER, Role.TOOL]: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid role") + elif i % 2 == 1 and message.role not in [Role.ASSISTANT, Role.FUNCTION]: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid role") + + if message.role == Role.ASSISTANT and isinstance(message.tool_calls, list) and len(message.tool_calls): + tool_calls = [ + {"name": tool_call.function.name, "arguments": tool_call.function.arguments} + for tool_call in message.tool_calls + ] + content = json.dumps(tool_calls, ensure_ascii=False) + input_messages.append({"role": ROLE_MAPPING[Role.FUNCTION], "content": content}) + elif isinstance(message.content, list): + text_content = "" + for input_item in message.content: + if input_item.type == "text": + text_content += input_item.text + elif input_item.type == "image_url": + text_content += IMAGE_PLACEHOLDER + image_url = input_item.image_url.url + if re.match(r"^data:image\/(png|jpg|jpeg|gif|bmp);base64,(.+)$", image_url): # base64 image + image_stream = io.BytesIO(base64.b64decode(image_url.split(",", maxsplit=1)[1])) + elif os.path.isfile(image_url): # local file + image_stream = open(image_url, "rb") + else: # web uri + image_stream = requests.get(image_url, stream=True).raw + + images.append(Image.open(image_stream).convert("RGB")) + elif input_item.type == "video_url": + text_content += VIDEO_PLACEHOLDER + video_url = input_item.video_url.url + if re.match(r"^data:video\/(mp4|mkv|avi|mov);base64,(.+)$", video_url): # base64 video + video_stream = io.BytesIO(base64.b64decode(video_url.split(",", maxsplit=1)[1])) + elif os.path.isfile(video_url): # local file + video_stream = video_url + else: # web uri + video_stream = requests.get(video_url, stream=True).raw + + videos.append(video_stream) + elif input_item.type == "audio_url": + text_content += AUDIO_PLACEHOLDER + audio_url = input_item.audio_url.url + if re.match(r"^data:audio\/(mpeg|mp3|wav|ogg);base64,(.+)$", audio_url): # base64 audio + audio_stream = io.BytesIO(base64.b64decode(audio_url.split(",", maxsplit=1)[1])) + elif os.path.isfile(audio_url): # local file + audio_stream = audio_url + else: # web uri + audio_stream = requests.get(audio_url, stream=True).raw + + audios.append(audio_stream) + else: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, detail=f"Invalid input type {input_item.type}." + ) + + input_messages.append({"role": ROLE_MAPPING[message.role], "content": text_content}) + else: + input_messages.append({"role": ROLE_MAPPING[message.role], "content": message.content}) + + tool_list = request.tools + if isinstance(tool_list, list) and len(tool_list): + try: + tools = json.dumps([dictify(tool.function) for tool in tool_list], ensure_ascii=False) + except json.JSONDecodeError: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid tools") + else: + tools = None + + return input_messages, system, tools, images or None, videos or None, audios or None + + +def _create_stream_chat_completion_chunk( + completion_id: str, + model: str, + delta: "ChatCompletionMessage", + index: Optional[int] = 0, + finish_reason: Optional["Finish"] = None, +) -> str: + choice_data = ChatCompletionStreamResponseChoice(index=index, delta=delta, finish_reason=finish_reason) + chunk = ChatCompletionStreamResponse(id=completion_id, model=model, choices=[choice_data]) + return jsonify(chunk) + + +async def create_chat_completion_response( + request: "ChatCompletionRequest", chat_model: "ChatModel" +) -> "ChatCompletionResponse": + completion_id = f"chatcmpl-{uuid.uuid4().hex}" + input_messages, system, tools, images, videos, audios = _process_request(request) + responses = await chat_model.achat( + input_messages, + system, + tools, + images, + videos, + audios, + do_sample=request.do_sample, + temperature=request.temperature, + top_p=request.top_p, + max_new_tokens=request.max_tokens, + num_return_sequences=request.n, + repetition_penalty=request.presence_penalty, + stop=request.stop, + ) + + prompt_length, response_length = 0, 0 + choices = [] + for i, response in enumerate(responses): + if tools: + result = chat_model.engine.template.extract_tool(response.response_text) + else: + result = response.response_text + + if isinstance(result, list): + tool_calls = [] + for tool in result: + function = Function(name=tool.name, arguments=tool.arguments) + tool_calls.append(FunctionCall(id=f"call_{uuid.uuid4().hex}", function=function)) + + response_message = ChatCompletionMessage(role=Role.ASSISTANT, tool_calls=tool_calls) + finish_reason = Finish.TOOL + else: + response_message = ChatCompletionMessage(role=Role.ASSISTANT, content=result) + finish_reason = Finish.STOP if response.finish_reason == "stop" else Finish.LENGTH + + choices.append(ChatCompletionResponseChoice(index=i, message=response_message, finish_reason=finish_reason)) + prompt_length = response.prompt_length + response_length += response.response_length + + usage = ChatCompletionResponseUsage( + prompt_tokens=prompt_length, + completion_tokens=response_length, + total_tokens=prompt_length + response_length, + ) + + return ChatCompletionResponse(id=completion_id, model=request.model, choices=choices, usage=usage) + + +async def create_stream_chat_completion_response( + request: "ChatCompletionRequest", chat_model: "ChatModel" +) -> AsyncGenerator[str, None]: + completion_id = f"chatcmpl-{uuid.uuid4().hex}" + input_messages, system, tools, images, videos, audios = _process_request(request) + if tools: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot stream function calls.") + + if request.n > 1: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot stream multiple responses.") + + yield _create_stream_chat_completion_chunk( + completion_id=completion_id, model=request.model, delta=ChatCompletionMessage(role=Role.ASSISTANT, content="") + ) + async for new_token in chat_model.astream_chat( + input_messages, + system, + tools, + images, + videos, + audios, + do_sample=request.do_sample, + temperature=request.temperature, + top_p=request.top_p, + max_new_tokens=request.max_tokens, + repetition_penalty=request.presence_penalty, + stop=request.stop, + ): + if len(new_token) != 0: + yield _create_stream_chat_completion_chunk( + completion_id=completion_id, model=request.model, delta=ChatCompletionMessage(content=new_token) + ) + + yield _create_stream_chat_completion_chunk( + completion_id=completion_id, model=request.model, delta=ChatCompletionMessage(), finish_reason=Finish.STOP + ) + yield "[DONE]" + + +async def create_score_evaluation_response( + request: "ScoreEvaluationRequest", chat_model: "ChatModel" +) -> "ScoreEvaluationResponse": + score_id = f"scoreval-{uuid.uuid4().hex}" + if len(request.messages) == 0: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid request") + + scores = await chat_model.aget_scores(request.messages, max_length=request.max_length) + return ScoreEvaluationResponse(id=score_id, model=request.model, scores=scores) diff --git a/src/train_sft/src/llamafactory/api/common.py b/src/train_sft/src/llamafactory/api/common.py new file mode 100644 index 0000000000000000000000000000000000000000..f4d0c2fb68da41b072e5d73340a88b4203398087 --- /dev/null +++ b/src/train_sft/src/llamafactory/api/common.py @@ -0,0 +1,34 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +from typing import TYPE_CHECKING, Any + + +if TYPE_CHECKING: + from pydantic import BaseModel + + +def dictify(data: "BaseModel") -> dict[str, Any]: + try: # pydantic v2 + return data.model_dump(exclude_unset=True) + except AttributeError: # pydantic v1 + return data.dict(exclude_unset=True) + + +def jsonify(data: "BaseModel") -> str: + try: # pydantic v2 + return json.dumps(data.model_dump(exclude_unset=True), ensure_ascii=False) + except AttributeError: # pydantic v1 + return data.json(exclude_unset=True, ensure_ascii=False) diff --git a/src/train_sft/src/llamafactory/api/protocol.py b/src/train_sft/src/llamafactory/api/protocol.py new file mode 100644 index 0000000000000000000000000000000000000000..889d938e0b727ef1fca63d95fa20926c31830c52 --- /dev/null +++ b/src/train_sft/src/llamafactory/api/protocol.py @@ -0,0 +1,157 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import time +from enum import Enum, unique +from typing import Any, Optional, Union + +from pydantic import BaseModel, Field +from typing_extensions import Literal + + +@unique +class Role(str, Enum): + USER = "user" + ASSISTANT = "assistant" + SYSTEM = "system" + FUNCTION = "function" + TOOL = "tool" + + +@unique +class Finish(str, Enum): + STOP = "stop" + LENGTH = "length" + TOOL = "tool_calls" + + +class ModelCard(BaseModel): + id: str + object: Literal["model"] = "model" + created: int = Field(default_factory=lambda: int(time.time())) + owned_by: Literal["owner"] = "owner" + + +class ModelList(BaseModel): + object: Literal["list"] = "list" + data: list[ModelCard] = [] + + +class Function(BaseModel): + name: str + arguments: str + + +class FunctionDefinition(BaseModel): + name: str + description: str + parameters: dict[str, Any] + + +class FunctionAvailable(BaseModel): + type: Literal["function", "code_interpreter"] = "function" + function: Optional[FunctionDefinition] = None + + +class FunctionCall(BaseModel): + id: str + type: Literal["function"] = "function" + function: Function + + +class URL(BaseModel): + url: str + detail: Literal["auto", "low", "high"] = "auto" + + +class MultimodalInputItem(BaseModel): + type: Literal["text", "image_url", "video_url", "audio_url"] + text: Optional[str] = None + image_url: Optional[URL] = None + video_url: Optional[URL] = None + audio_url: Optional[URL] = None + + +class ChatMessage(BaseModel): + role: Role + content: Optional[Union[str, list[MultimodalInputItem]]] = None + tool_calls: Optional[list[FunctionCall]] = None + + +class ChatCompletionMessage(BaseModel): + role: Optional[Role] = None + content: Optional[str] = None + tool_calls: Optional[list[FunctionCall]] = None + + +class ChatCompletionRequest(BaseModel): + model: str + messages: list[ChatMessage] + tools: Optional[list[FunctionAvailable]] = None + do_sample: Optional[bool] = None + temperature: Optional[float] = None + top_p: Optional[float] = None + n: int = 1 + presence_penalty: Optional[float] = None + max_tokens: Optional[int] = None + stop: Optional[Union[str, list[str]]] = None + stream: bool = False + + +class ChatCompletionResponseChoice(BaseModel): + index: int + message: ChatCompletionMessage + finish_reason: Finish + + +class ChatCompletionStreamResponseChoice(BaseModel): + index: int + delta: ChatCompletionMessage + finish_reason: Optional[Finish] = None + + +class ChatCompletionResponseUsage(BaseModel): + prompt_tokens: int + completion_tokens: int + total_tokens: int + + +class ChatCompletionResponse(BaseModel): + id: str + object: Literal["chat.completion"] = "chat.completion" + created: int = Field(default_factory=lambda: int(time.time())) + model: str + choices: list[ChatCompletionResponseChoice] + usage: ChatCompletionResponseUsage + + +class ChatCompletionStreamResponse(BaseModel): + id: str + object: Literal["chat.completion.chunk"] = "chat.completion.chunk" + created: int = Field(default_factory=lambda: int(time.time())) + model: str + choices: list[ChatCompletionStreamResponseChoice] + + +class ScoreEvaluationRequest(BaseModel): + model: str + messages: list[str] + max_length: Optional[int] = None + + +class ScoreEvaluationResponse(BaseModel): + id: str + object: Literal["score.evaluation"] = "score.evaluation" + model: str + scores: list[float] diff --git a/src/train_sft/src/llamafactory/chat/__init__.py b/src/train_sft/src/llamafactory/chat/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..15d8b9ba2d77d6f300d59300da5a49abd3ed4e57 --- /dev/null +++ b/src/train_sft/src/llamafactory/chat/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .base_engine import BaseEngine +from .chat_model import ChatModel + + +__all__ = ["BaseEngine", "ChatModel"] diff --git a/src/train_sft/src/llamafactory/chat/base_engine.py b/src/train_sft/src/llamafactory/chat/base_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..6d497c1ae927f94f396c18833b18cdb894cbd59d --- /dev/null +++ b/src/train_sft/src/llamafactory/chat/base_engine.py @@ -0,0 +1,98 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from abc import ABC, abstractmethod +from collections.abc import AsyncGenerator +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Literal, Optional, Union + + +if TYPE_CHECKING: + from transformers import PreTrainedModel, PreTrainedTokenizer + from vllm import AsyncLLMEngine + + from ..data import Template + from ..data.mm_plugin import AudioInput, ImageInput, VideoInput + from ..extras.constants import EngineName + from ..hparams import DataArguments, FinetuningArguments, GeneratingArguments, ModelArguments + + +@dataclass +class Response: + response_text: str + response_length: int + prompt_length: int + finish_reason: Literal["stop", "length"] + + +class BaseEngine(ABC): + r"""Base class for inference engine of chat models. + + Must implements async methods: chat(), stream_chat() and get_scores(). + """ + + name: "EngineName" + model: Union["PreTrainedModel", "AsyncLLMEngine"] + tokenizer: "PreTrainedTokenizer" + can_generate: bool + template: "Template" + generating_args: dict[str, Any] + + @abstractmethod + def __init__( + self, + model_args: "ModelArguments", + data_args: "DataArguments", + finetuning_args: "FinetuningArguments", + generating_args: "GeneratingArguments", + ) -> None: + r"""Initialize an inference engine.""" + ... + + @abstractmethod + async def chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> list["Response"]: + r"""Get a list of responses of the chat model.""" + ... + + @abstractmethod + async def stream_chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncGenerator[str, None]: + r"""Get the response token-by-token of the chat model.""" + ... + + @abstractmethod + async def get_scores( + self, + batch_input: list[str], + **input_kwargs, + ) -> list[float]: + r"""Get a list of scores of the reward model.""" + ... diff --git a/src/train_sft/src/llamafactory/chat/chat_model.py b/src/train_sft/src/llamafactory/chat/chat_model.py new file mode 100644 index 0000000000000000000000000000000000000000..0022eed95d13f38f8d7f61153731b35737fd2e36 --- /dev/null +++ b/src/train_sft/src/llamafactory/chat/chat_model.py @@ -0,0 +1,184 @@ +# Copyright 2025 THUDM and the LlamaFactory team. +# +# This code is inspired by the THUDM's ChatGLM implementation. +# https://github.com/THUDM/ChatGLM-6B/blob/main/cli_demo.py +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import asyncio +import os +from collections.abc import AsyncGenerator, Generator +from threading import Thread +from typing import TYPE_CHECKING, Any, Optional + +from ..extras.constants import EngineName +from ..extras.misc import torch_gc +from ..hparams import get_infer_args +from .hf_engine import HuggingfaceEngine +from .sglang_engine import SGLangEngine +from .vllm_engine import VllmEngine + + +if TYPE_CHECKING: + from ..data.mm_plugin import AudioInput, ImageInput, VideoInput + from .base_engine import BaseEngine, Response + + +def _start_background_loop(loop: "asyncio.AbstractEventLoop") -> None: + asyncio.set_event_loop(loop) + loop.run_forever() + + +class ChatModel: + r"""General class for chat models. Backed by huggingface or vllm engines. + + Supports both sync and async methods. + Sync methods: chat(), stream_chat() and get_scores(). + Async methods: achat(), astream_chat() and aget_scores(). + """ + + def __init__(self, args: Optional[dict[str, Any]] = None) -> None: + model_args, data_args, finetuning_args, generating_args = get_infer_args(args) + if model_args.infer_backend == EngineName.HF: + self.engine: BaseEngine = HuggingfaceEngine(model_args, data_args, finetuning_args, generating_args) + elif model_args.infer_backend == EngineName.VLLM: + self.engine: BaseEngine = VllmEngine(model_args, data_args, finetuning_args, generating_args) + elif model_args.infer_backend == EngineName.SGLANG: + self.engine: BaseEngine = SGLangEngine(model_args, data_args, finetuning_args, generating_args) + else: + raise NotImplementedError(f"Unknown backend: {model_args.infer_backend}") + + self._loop = asyncio.new_event_loop() + self._thread = Thread(target=_start_background_loop, args=(self._loop,), daemon=True) + self._thread.start() + + def chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> list["Response"]: + r"""Get a list of responses of the chat model.""" + task = asyncio.run_coroutine_threadsafe( + self.achat(messages, system, tools, images, videos, audios, **input_kwargs), self._loop + ) + return task.result() + + async def achat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> list["Response"]: + r"""Asynchronously get a list of responses of the chat model.""" + return await self.engine.chat(messages, system, tools, images, videos, audios, **input_kwargs) + + def stream_chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> Generator[str, None, None]: + r"""Get the response token-by-token of the chat model.""" + generator = self.astream_chat(messages, system, tools, images, videos, audios, **input_kwargs) + while True: + try: + task = asyncio.run_coroutine_threadsafe(generator.__anext__(), self._loop) + yield task.result() + except StopAsyncIteration: + break + + async def astream_chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncGenerator[str, None]: + r"""Asynchronously get the response token-by-token of the chat model.""" + async for new_token in self.engine.stream_chat( + messages, system, tools, images, videos, audios, **input_kwargs + ): + yield new_token + + def get_scores( + self, + batch_input: list[str], + **input_kwargs, + ) -> list[float]: + r"""Get a list of scores of the reward model.""" + task = asyncio.run_coroutine_threadsafe(self.aget_scores(batch_input, **input_kwargs), self._loop) + return task.result() + + async def aget_scores( + self, + batch_input: list[str], + **input_kwargs, + ) -> list[float]: + r"""Asynchronously get a list of scores of the reward model.""" + return await self.engine.get_scores(batch_input, **input_kwargs) + + +def run_chat() -> None: + if os.name != "nt": + try: + import readline # noqa: F401 + except ImportError: + print("Install `readline` for a better experience.") + + chat_model = ChatModel() + messages = [] + print("Welcome to the CLI application, use `clear` to remove the history, use `exit` to exit the application.") + + while True: + try: + query = input("\nUser: ") + except UnicodeDecodeError: + print("Detected decoding error at the inputs, please set the terminal encoding to utf-8.") + continue + except Exception: + raise + + if query.strip() == "exit": + break + + if query.strip() == "clear": + messages = [] + torch_gc() + print("History has been removed.") + continue + + messages.append({"role": "user", "content": query}) + print("Assistant: ", end="", flush=True) + + response = "" + for new_text in chat_model.stream_chat(messages): + print(new_text, end="", flush=True) + response += new_text + print() + messages.append({"role": "assistant", "content": response}) diff --git a/src/train_sft/src/llamafactory/chat/hf_engine.py b/src/train_sft/src/llamafactory/chat/hf_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..adaaaa872786446fde2eba4a2a8f32f7ec4cc462 --- /dev/null +++ b/src/train_sft/src/llamafactory/chat/hf_engine.py @@ -0,0 +1,412 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import asyncio +import os +from collections.abc import AsyncGenerator +from threading import Thread +from typing import TYPE_CHECKING, Any, Callable, Optional, Union + +import torch +from transformers import GenerationConfig, TextIteratorStreamer +from typing_extensions import override + +from ..data import get_template_and_fix_tokenizer +from ..extras import logging +from ..extras.constants import AUDIO_PLACEHOLDER, IMAGE_PLACEHOLDER, VIDEO_PLACEHOLDER, EngineName +from ..model import load_model, load_tokenizer +from .base_engine import BaseEngine, Response + + +if TYPE_CHECKING: + from transformers import PreTrainedModel, PreTrainedTokenizer, ProcessorMixin + from trl import PreTrainedModelWrapper + + from ..data import Template + from ..data.mm_plugin import AudioInput, ImageInput, VideoInput + from ..hparams import DataArguments, FinetuningArguments, GeneratingArguments, ModelArguments + + +logger = logging.get_logger(__name__) + + +class HuggingfaceEngine(BaseEngine): + def __init__( + self, + model_args: "ModelArguments", + data_args: "DataArguments", + finetuning_args: "FinetuningArguments", + generating_args: "GeneratingArguments", + ) -> None: + self.name = EngineName.HF + self.can_generate = finetuning_args.stage == "sft" + tokenizer_module = load_tokenizer(model_args) + self.tokenizer = tokenizer_module["tokenizer"] + self.processor = tokenizer_module["processor"] + self.tokenizer.padding_side = "left" if self.can_generate else "right" + self.template = get_template_and_fix_tokenizer(self.tokenizer, data_args) + self.model = load_model( + self.tokenizer, model_args, finetuning_args, is_trainable=False, add_valuehead=(not self.can_generate) + ) # must after fixing tokenizer to resize vocab + self.generating_args = generating_args.to_dict() + try: + asyncio.get_event_loop() + except RuntimeError: + logger.warning_rank0_once("There is no current event loop, creating a new one.") + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + + self.semaphore = asyncio.Semaphore(int(os.getenv("MAX_CONCURRENT", "1"))) + + @staticmethod + def _process_args( + model: "PreTrainedModel", + tokenizer: "PreTrainedTokenizer", + processor: Optional["ProcessorMixin"], + template: "Template", + generating_args: dict[str, Any], + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + input_kwargs: Optional[dict[str, Any]] = {}, + ) -> tuple[dict[str, Any], int]: + mm_input_dict = {"images": [], "videos": [], "audios": [], "imglens": [0], "vidlens": [0], "audlens": [0]} + if images is not None: + mm_input_dict.update({"images": images, "imglens": [len(images)]}) + if not any(IMAGE_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = IMAGE_PLACEHOLDER * len(images) + messages[0]["content"] + + if videos is not None: + mm_input_dict.update({"videos": videos, "vidlens": [len(videos)]}) + if not any(VIDEO_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = VIDEO_PLACEHOLDER * len(videos) + messages[0]["content"] + + if audios is not None: + mm_input_dict.update({"audios": audios, "audlens": [len(audios)]}) + if not any(AUDIO_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = AUDIO_PLACEHOLDER * len(audios) + messages[0]["content"] + + messages = template.mm_plugin.process_messages( + messages, mm_input_dict["images"], mm_input_dict["videos"], mm_input_dict["audios"], processor + ) + paired_messages = messages + [{"role": "assistant", "content": ""}] + prompt_ids, _ = template.encode_oneturn(tokenizer, paired_messages, system, tools) + prompt_ids, _ = template.mm_plugin.process_token_ids( + prompt_ids, + None, + mm_input_dict["images"], + mm_input_dict["videos"], + mm_input_dict["audios"], + tokenizer, + processor, + ) + prompt_length = len(prompt_ids) + inputs = torch.tensor([prompt_ids], device=model.device) + attention_mask = torch.ones_like(inputs, dtype=torch.long) + + do_sample: Optional[bool] = input_kwargs.pop("do_sample", None) + temperature: Optional[float] = input_kwargs.pop("temperature", None) + top_p: Optional[float] = input_kwargs.pop("top_p", None) + top_k: Optional[float] = input_kwargs.pop("top_k", None) + num_return_sequences: int = input_kwargs.pop("num_return_sequences", 1) + repetition_penalty: Optional[float] = input_kwargs.pop("repetition_penalty", None) + length_penalty: Optional[float] = input_kwargs.pop("length_penalty", None) + skip_special_tokens: Optional[bool] = input_kwargs.pop("skip_special_tokens", None) + max_length: Optional[int] = input_kwargs.pop("max_length", None) + max_new_tokens: Optional[int] = input_kwargs.pop("max_new_tokens", None) + stop: Optional[Union[str, list[str]]] = input_kwargs.pop("stop", None) + + if stop is not None: + logger.warning_rank0("Stop parameter is not supported by the huggingface engine yet.") + + generating_args = generating_args.copy() + generating_args.update( + dict( + do_sample=do_sample if do_sample is not None else generating_args["do_sample"], + temperature=temperature if temperature is not None else generating_args["temperature"], + top_p=top_p if top_p is not None else generating_args["top_p"], + top_k=top_k if top_k is not None else generating_args["top_k"], + num_return_sequences=num_return_sequences, + repetition_penalty=repetition_penalty + if repetition_penalty is not None + else generating_args["repetition_penalty"], + length_penalty=length_penalty if length_penalty is not None else generating_args["length_penalty"], + skip_special_tokens=skip_special_tokens + if skip_special_tokens is not None + else generating_args["skip_special_tokens"], + eos_token_id=template.get_stop_token_ids(tokenizer), + pad_token_id=tokenizer.pad_token_id, + ) + ) + + if isinstance(num_return_sequences, int) and num_return_sequences > 1: # do_sample needs temperature > 0 + generating_args["do_sample"] = True + generating_args["temperature"] = generating_args["temperature"] or 1.0 + + if not generating_args["temperature"]: + generating_args["do_sample"] = False + + if not generating_args["do_sample"]: + generating_args.pop("temperature", None) + generating_args.pop("top_p", None) + + if max_length: + generating_args.pop("max_new_tokens", None) + generating_args["max_length"] = max_length + + if max_new_tokens: + generating_args.pop("max_length", None) + generating_args["max_new_tokens"] = max_new_tokens + + gen_kwargs = dict( + inputs=inputs, + attention_mask=attention_mask, + generation_config=GenerationConfig(**generating_args), + ) + + mm_inputs = template.mm_plugin.get_mm_inputs(**mm_input_dict, batch_ids=[prompt_ids], processor=processor) + for key, value in mm_inputs.items(): + if isinstance(value, list) and isinstance(value[0], torch.Tensor): # for pixtral inputs + value = torch.stack(value) # assume they have same sizes + elif ( + isinstance(value, list) and isinstance(value[0], list) and isinstance(value[0][0], torch.Tensor) + ): # for minicpmv inputs + value = torch.stack([torch.stack(v) for v in value]) + elif not isinstance(value, torch.Tensor): + value = torch.tensor(value) + + if torch.is_floating_point(value): # cast data dtype for paligemma + value = value.to(model.dtype) + + if key == "second_per_grid_ts": # qwen2.5vl special case + gen_kwargs[key] = value.tolist() + else: + gen_kwargs[key] = value.to(model.device) + + if getattr(model.config, "model_type", None) in ["minicpmv", "minicpmo"]: + gen_kwargs["input_ids"] = inputs + gen_kwargs["tokenizer"] = tokenizer + if "audio_feature_lens" in mm_inputs: + gen_kwargs["audio_feature_lens"] = mm_inputs["audio_feature_lens"] + + gen_kwargs.pop("image_sizes", None) + + return gen_kwargs, prompt_length + + @staticmethod + @torch.inference_mode() + def _chat( + model: "PreTrainedModel", + tokenizer: "PreTrainedTokenizer", + processor: Optional["ProcessorMixin"], + template: "Template", + generating_args: dict[str, Any], + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + input_kwargs: Optional[dict[str, Any]] = {}, + ) -> list["Response"]: + gen_kwargs, prompt_length = HuggingfaceEngine._process_args( + model, + tokenizer, + processor, + template, + generating_args, + messages, + system, + tools, + images, + videos, + audios, + input_kwargs, + ) + generate_output = model.generate(**gen_kwargs) + if isinstance(generate_output, tuple): + generate_output = generate_output[1][0] # post-process the minicpm_o output + + response_ids = generate_output[:, prompt_length:] + response = tokenizer.batch_decode( + response_ids, + skip_special_tokens=getattr(gen_kwargs["generation_config"], "skip_special_tokens", True), + clean_up_tokenization_spaces=True, + ) + results = [] + for i in range(len(response)): + eos_index = (response_ids[i] == tokenizer.eos_token_id).nonzero() + response_length = (eos_index[0].item() + 1) if len(eos_index) else len(response_ids[i]) + results.append( + Response( + response_text=response[i], + response_length=response_length, + prompt_length=prompt_length, + finish_reason="stop" if len(eos_index) else "length", + ) + ) + + return results + + @staticmethod + @torch.inference_mode() + def _stream_chat( + model: "PreTrainedModel", + tokenizer: "PreTrainedTokenizer", + processor: Optional["ProcessorMixin"], + template: "Template", + generating_args: dict[str, Any], + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + input_kwargs: Optional[dict[str, Any]] = {}, + ) -> Callable[[], str]: + gen_kwargs, _ = HuggingfaceEngine._process_args( + model, + tokenizer, + processor, + template, + generating_args, + messages, + system, + tools, + images, + videos, + audios, + input_kwargs, + ) + streamer = TextIteratorStreamer( + tokenizer, + skip_prompt=True, + skip_special_tokens=getattr(gen_kwargs["generation_config"], "skip_special_tokens", True), + ) + gen_kwargs["streamer"] = streamer + thread = Thread(target=model.generate, kwargs=gen_kwargs, daemon=True) + thread.start() + + def stream(): + try: + return streamer.__next__() + except StopIteration: + raise StopAsyncIteration() + + return stream + + @staticmethod + @torch.inference_mode() + def _get_scores( + model: "PreTrainedModelWrapper", + tokenizer: "PreTrainedTokenizer", + batch_input: list[str], + input_kwargs: Optional[dict[str, Any]] = {}, + ) -> list[float]: + max_length: Optional[int] = input_kwargs.pop("max_length", None) + device = getattr(model.pretrained_model, "device", "cuda") + inputs: dict[str, torch.Tensor] = tokenizer( + batch_input, + padding=True, + truncation=True, + max_length=max_length or getattr(model.config, "max_position_embeddings", 1024), + return_tensors="pt", + add_special_tokens=False, + ).to(device) + values: torch.Tensor = model(**inputs, return_dict=True, use_cache=False)[-1] + scores = values.gather(dim=-1, index=(inputs["attention_mask"].sum(dim=-1, keepdim=True) - 1)) + return scores + + @override + async def chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> list["Response"]: + if not self.can_generate: + raise ValueError("The current model does not support `chat`.") + + input_args = ( + self.model, + self.tokenizer, + self.processor, + self.template, + self.generating_args, + messages, + system, + tools, + images, + videos, + audios, + input_kwargs, + ) + async with self.semaphore: + return await asyncio.to_thread(self._chat, *input_args) + + @override + async def stream_chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncGenerator[str, None]: + if not self.can_generate: + raise ValueError("The current model does not support `stream_chat`.") + + input_args = ( + self.model, + self.tokenizer, + self.processor, + self.template, + self.generating_args, + messages, + system, + tools, + images, + videos, + audios, + input_kwargs, + ) + async with self.semaphore: + stream = self._stream_chat(*input_args) + while True: + try: + yield await asyncio.to_thread(stream) + except StopAsyncIteration: + break + + @override + async def get_scores( + self, + batch_input: list[str], + **input_kwargs, + ) -> list[float]: + if self.can_generate: + raise ValueError("Cannot get scores using an auto-regressive model.") + + input_args = (self.model, self.tokenizer, batch_input, input_kwargs) + async with self.semaphore: + return await asyncio.to_thread(self._get_scores, *input_args) diff --git a/src/train_sft/src/llamafactory/chat/sglang_engine.py b/src/train_sft/src/llamafactory/chat/sglang_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..b1d2ead33823bc70d51cda59750d25580f972083 --- /dev/null +++ b/src/train_sft/src/llamafactory/chat/sglang_engine.py @@ -0,0 +1,289 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import asyncio +import atexit +import json +from collections.abc import AsyncGenerator, AsyncIterator, Sequence +from typing import TYPE_CHECKING, Any, Optional, Union + +import requests +from typing_extensions import override + +from ..data import get_template_and_fix_tokenizer +from ..extras import logging +from ..extras.constants import AUDIO_PLACEHOLDER, IMAGE_PLACEHOLDER, VIDEO_PLACEHOLDER, EngineName +from ..extras.misc import get_device_count, torch_gc +from ..extras.packages import is_sglang_available +from ..hparams import DataArguments, FinetuningArguments, GeneratingArguments, ModelArguments +from ..model import load_config, load_tokenizer +from ..model.model_utils.quantization import QuantizationMethod +from .base_engine import BaseEngine, Response + + +if is_sglang_available(): + from sglang.utils import launch_server_cmd, terminate_process, wait_for_server # type: ignore + + +if TYPE_CHECKING: + from ..data.mm_plugin import AudioInput, ImageInput, VideoInput + + +logger = logging.get_logger(__name__) + + +class SGLangEngine(BaseEngine): + """Inference engine for SGLang models. + + This class wraps the SGLang engine to provide a consistent interface for text generation + that matches LLaMA Factory's requirements. It uses the SGLang HTTP server approach for + better interaction and performance. The engine launches a server process and communicates + with it via HTTP requests. + + For more details on the SGLang HTTP server approach, see: + https://docs.sglang.ai/backend/send_request.html + """ + + def __init__( + self, + model_args: "ModelArguments", + data_args: "DataArguments", + finetuning_args: "FinetuningArguments", + generating_args: "GeneratingArguments", + ) -> None: + self.name = EngineName.SGLANG + self.model_args = model_args + config = load_config(model_args) # may download model from ms hub + if getattr(config, "quantization_config", None): # gptq models should use float16 + quantization_config: dict[str, Any] = getattr(config, "quantization_config", None) + quant_method = quantization_config.get("quant_method", "") + if quant_method == QuantizationMethod.GPTQ and model_args.infer_dtype == "auto": + model_args.infer_dtype = "float16" + + self.can_generate = finetuning_args.stage == "sft" + tokenizer_module = load_tokenizer(model_args) + self.tokenizer = tokenizer_module["tokenizer"] + self.processor = tokenizer_module["processor"] + self.tokenizer.padding_side = "left" + self.template = get_template_and_fix_tokenizer(self.tokenizer, data_args) + self.template.mm_plugin.expand_mm_tokens = False # for sglang generate + self.generating_args = generating_args.to_dict() + if model_args.adapter_name_or_path is not None: + self.lora_request = True + else: + self.lora_request = False + + launch_cmd = [ + "python3 -m sglang.launch_server", + f"--model-path {model_args.model_name_or_path}", + f"--dtype {model_args.infer_dtype}", + f"--context-length {model_args.sglang_maxlen}", + f"--mem-fraction-static {model_args.sglang_mem_fraction}", + f"--tp-size {model_args.sglang_tp_size if model_args.sglang_tp_size != -1 else get_device_count() or 1}", + f"--download-dir {model_args.cache_dir}", + "--log-level error", + ] + if self.lora_request: + launch_cmd.extend( + [ + "--max-loras-per-batch 1", + f"--lora-backend {model_args.sglang_lora_backend}", + f"--lora-paths lora0={model_args.adapter_name_or_path[0]}", + "--disable-radix-cache", + ] + ) + launch_cmd = " ".join(launch_cmd) + logger.info_rank0(f"Starting SGLang server with command: {launch_cmd}") + try: + torch_gc() + self.server_process, port = launch_server_cmd(launch_cmd) + self.base_url = f"http://localhost:{port}" + atexit.register(self._cleanup_server) + + logger.info_rank0(f"Waiting for SGLang server to be ready at {self.base_url}") + wait_for_server(self.base_url, timeout=300) + logger.info_rank0(f"SGLang server initialized successfully at {self.base_url}") + try: + response = requests.get(f"{self.base_url}/get_model_info", timeout=5) + if response.status_code == 200: + model_info = response.json() + logger.info(f"SGLang server model info: {model_info}") + except Exception as e: + logger.debug(f"Note: could not get model info: {str(e)}") + + except Exception as e: + logger.error(f"Failed to start SGLang server: {str(e)}") + self._cleanup_server() # make sure to clean up any started process + raise RuntimeError(f"SGLang server initialization failed: {str(e)}.") + + def _cleanup_server(self): + r"""Clean up the server process when the engine is destroyed.""" + if hasattr(self, "server_process") and self.server_process: + try: + logger.info("Terminating SGLang server process") + terminate_process(self.server_process) + logger.info("SGLang server process terminated") + except Exception as e: + logger.warning(f"Error terminating SGLang server: {str(e)}") + + async def _generate( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncIterator[dict[str, Any]]: + if images is not None and not any(IMAGE_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = IMAGE_PLACEHOLDER * len(images) + messages[0]["content"] + + if videos is not None and not any(VIDEO_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = VIDEO_PLACEHOLDER * len(videos) + messages[0]["content"] + + if audios is not None and not any(AUDIO_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = AUDIO_PLACEHOLDER * len(audios) + messages[0]["content"] + + messages = self.template.mm_plugin.process_messages( + messages, images or [], videos or [], audios or [], self.processor + ) + paired_messages = messages + [{"role": "assistant", "content": ""}] + prompt_ids, _ = self.template.encode_oneturn(self.tokenizer, paired_messages, system, tools) + prompt_length = len(prompt_ids) + + temperature: Optional[float] = input_kwargs.pop("temperature", None) + top_p: Optional[float] = input_kwargs.pop("top_p", None) + top_k: Optional[float] = input_kwargs.pop("top_k", None) + num_return_sequences: int = input_kwargs.pop("num_return_sequences", 1) + repetition_penalty: Optional[float] = input_kwargs.pop("repetition_penalty", None) + skip_special_tokens: Optional[bool] = input_kwargs.pop("skip_special_tokens", None) + max_length: Optional[int] = input_kwargs.pop("max_length", None) + max_new_tokens: Optional[int] = input_kwargs.pop("max_new_tokens", None) + stop: Optional[Union[str, list[str]]] = input_kwargs.pop("stop", None) + + if num_return_sequences != 1: + raise NotImplementedError("SGLang only supports n=1.") + + if "max_new_tokens" in self.generating_args: + max_tokens = self.generating_args["max_new_tokens"] + elif "max_length" in self.generating_args: + if self.generating_args["max_length"] > prompt_length: + max_tokens = self.generating_args["max_length"] - prompt_length + else: + max_tokens = 1 + + if max_length: + max_tokens = max_length - prompt_length if max_length > prompt_length else 1 + + if max_new_tokens: + max_tokens = max_new_tokens + + sampling_params = { + "temperature": temperature if temperature is not None else self.generating_args["temperature"], + "top_p": (top_p if top_p is not None else self.generating_args["top_p"]) or 1.0, # top_p must > 0 + "top_k": (top_k if top_k is not None else self.generating_args["top_k"]) or -1, # top_k must > 0 + "stop": stop, + "stop_token_ids": self.template.get_stop_token_ids(self.tokenizer), + "max_new_tokens": max_tokens, + "repetition_penalty": ( + repetition_penalty if repetition_penalty is not None else self.generating_args["repetition_penalty"] + ) + or 1.0, # repetition_penalty must > 0 + "skip_special_tokens": skip_special_tokens + if skip_special_tokens is not None + else self.generating_args["skip_special_tokens"], + } + + def stream_request(): + json_data = { + "input_ids": prompt_ids, + "sampling_params": sampling_params, + "stream": True, + } + if self.lora_request: + json_data["lora_request"] = ["lora0"] + response = requests.post(f"{self.base_url}/generate", json=json_data, stream=True) + if response.status_code != 200: + raise RuntimeError(f"SGLang server error: {response.status_code}, {response.text}") + + for chunk in response.iter_lines(decode_unicode=False): + chunk = str(chunk.decode("utf-8")) + if chunk == "data: [DONE]": + break + + if chunk and chunk.startswith("data:"): + yield json.loads(chunk[5:].strip("\n")) + + return await asyncio.to_thread(stream_request) + + @override + async def chat( + self, + messages: Sequence[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[Sequence["ImageInput"]] = None, + videos: Optional[Sequence["VideoInput"]] = None, + audios: Optional[Sequence["AudioInput"]] = None, + **input_kwargs, + ) -> list["Response"]: + final_output = None + generator = await self._generate(messages, system, tools, images, videos, audios, **input_kwargs) + for request_output in generator: + final_output = request_output + + results = [ + Response( + response_text=final_output["text"], + response_length=final_output["meta_info"]["completion_tokens"], + prompt_length=final_output["meta_info"]["prompt_tokens"], + finish_reason="stop" if final_output["meta_info"]["finish_reason"] == "stop" else "length", + ) + ] + return results + + @override + async def stream_chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncGenerator[str, None]: + generated_text = "" + generator = await self._generate(messages, system, tools, images, videos, audios, **input_kwargs) + for result in generator: + delta_text = result["text"][len(generated_text) :] + generated_text = result["text"] + yield delta_text + + @override + async def get_scores( + self, + batch_input: list[str], + **input_kwargs, + ) -> list[float]: + raise NotImplementedError("SGLang engine does not support `get_scores`.") + + def __del__(self): + r"""Ensure server is cleaned up when object is deleted.""" + self._cleanup_server() + try: + atexit.unregister(self._cleanup_server) + except Exception: + pass diff --git a/src/train_sft/src/llamafactory/chat/vllm_engine.py b/src/train_sft/src/llamafactory/chat/vllm_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..b33705279da13d398f8089b94c72b22d742f2c6f --- /dev/null +++ b/src/train_sft/src/llamafactory/chat/vllm_engine.py @@ -0,0 +1,263 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import uuid +from collections.abc import AsyncGenerator, AsyncIterator +from typing import TYPE_CHECKING, Any, Optional, Union + +from typing_extensions import override + +from ..data import get_template_and_fix_tokenizer +from ..extras import logging +from ..extras.constants import AUDIO_PLACEHOLDER, IMAGE_PLACEHOLDER, VIDEO_PLACEHOLDER, EngineName +from ..extras.misc import get_device_count +from ..extras.packages import is_vllm_available +from ..model import load_config, load_tokenizer +from ..model.model_utils.quantization import QuantizationMethod +from ..model.model_utils.visual import LlavaMultiModalProjectorForYiVLForVLLM +from .base_engine import BaseEngine, Response + + +if is_vllm_available(): + from vllm import AsyncEngineArgs, AsyncLLMEngine, RequestOutput, SamplingParams + from vllm.lora.request import LoRARequest + + +if TYPE_CHECKING: + from ..data.mm_plugin import AudioInput, ImageInput, VideoInput + from ..hparams import DataArguments, FinetuningArguments, GeneratingArguments, ModelArguments + + +logger = logging.get_logger(__name__) + + +class VllmEngine(BaseEngine): + def __init__( + self, + model_args: "ModelArguments", + data_args: "DataArguments", + finetuning_args: "FinetuningArguments", + generating_args: "GeneratingArguments", + ) -> None: + self.name = EngineName.VLLM + self.model_args = model_args + config = load_config(model_args) # may download model from ms hub + if getattr(config, "quantization_config", None): # gptq models should use float16 + quantization_config: dict[str, Any] = getattr(config, "quantization_config", None) + quant_method = quantization_config.get("quant_method", "") + if quant_method == QuantizationMethod.GPTQ and model_args.infer_dtype == "auto": + model_args.infer_dtype = "float16" + + self.can_generate = finetuning_args.stage == "sft" + tokenizer_module = load_tokenizer(model_args) + self.tokenizer = tokenizer_module["tokenizer"] + self.processor = tokenizer_module["processor"] + self.tokenizer.padding_side = "left" + self.template = get_template_and_fix_tokenizer(self.tokenizer, data_args) + self.template.mm_plugin.expand_mm_tokens = False # for vllm generate + self.generating_args = generating_args.to_dict() + + engine_args = { + "model": model_args.model_name_or_path, + "trust_remote_code": model_args.trust_remote_code, + "download_dir": model_args.cache_dir, + "dtype": model_args.infer_dtype, + "max_model_len": model_args.vllm_maxlen, + "tensor_parallel_size": get_device_count() or 1, + "gpu_memory_utilization": model_args.vllm_gpu_util, + "disable_log_stats": True, + "disable_log_requests": True, + "enforce_eager": model_args.vllm_enforce_eager, + "enable_lora": model_args.adapter_name_or_path is not None, + "max_lora_rank": model_args.vllm_max_lora_rank, + } + if self.template.mm_plugin.__class__.__name__ != "BasePlugin": + engine_args["limit_mm_per_prompt"] = {"image": 4, "video": 2, "audio": 2} + + if isinstance(model_args.vllm_config, dict): + engine_args.update(model_args.vllm_config) + + if getattr(config, "is_yi_vl_derived_model", None): + import vllm.model_executor.models.llava + + logger.info_rank0("Detected Yi-VL model, applying projector patch.") + vllm.model_executor.models.llava.LlavaMultiModalProjector = LlavaMultiModalProjectorForYiVLForVLLM + + self.model = AsyncLLMEngine.from_engine_args(AsyncEngineArgs(**engine_args)) + if model_args.adapter_name_or_path is not None: + self.lora_request = LoRARequest("default", 1, model_args.adapter_name_or_path[0]) + else: + self.lora_request = None + + async def _generate( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncIterator["RequestOutput"]: + request_id = f"chatcmpl-{uuid.uuid4().hex}" + if images is not None and not any(IMAGE_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = IMAGE_PLACEHOLDER * len(images) + messages[0]["content"] + + if videos is not None and not any(VIDEO_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = VIDEO_PLACEHOLDER * len(videos) + messages[0]["content"] + + if audios is not None and not any(AUDIO_PLACEHOLDER in message["content"] for message in messages): + messages[0]["content"] = AUDIO_PLACEHOLDER * len(audios) + messages[0]["content"] + + messages = self.template.mm_plugin.process_messages( + messages, images or [], videos or [], audios or [], self.processor + ) + paired_messages = messages + [{"role": "assistant", "content": ""}] + prompt_ids, _ = self.template.encode_oneturn(self.tokenizer, paired_messages, system, tools) + prompt_length = len(prompt_ids) + + temperature: Optional[float] = input_kwargs.pop("temperature", None) + top_p: Optional[float] = input_kwargs.pop("top_p", None) + top_k: Optional[float] = input_kwargs.pop("top_k", None) + num_return_sequences: int = input_kwargs.pop("num_return_sequences", 1) + repetition_penalty: Optional[float] = input_kwargs.pop("repetition_penalty", None) + length_penalty: Optional[float] = input_kwargs.pop("length_penalty", None) + skip_special_tokens: Optional[bool] = input_kwargs.pop("skip_special_tokens", None) + max_length: Optional[int] = input_kwargs.pop("max_length", None) + max_new_tokens: Optional[int] = input_kwargs.pop("max_new_tokens", None) + stop: Optional[Union[str, list[str]]] = input_kwargs.pop("stop", None) + + if length_penalty is not None: + logger.warning_rank0("Length penalty is not supported by the vllm engine yet.") + + if "max_new_tokens" in self.generating_args: + max_tokens = self.generating_args["max_new_tokens"] + elif "max_length" in self.generating_args: + if self.generating_args["max_length"] > prompt_length: + max_tokens = self.generating_args["max_length"] - prompt_length + else: + max_tokens = 1 + + if max_length: + max_tokens = max_length - prompt_length if max_length > prompt_length else 1 + + if max_new_tokens: + max_tokens = max_new_tokens + + sampling_params = SamplingParams( + n=num_return_sequences, + repetition_penalty=( + repetition_penalty if repetition_penalty is not None else self.generating_args["repetition_penalty"] + ) + or 1.0, # repetition_penalty must > 0 + temperature=temperature if temperature is not None else self.generating_args["temperature"], + top_p=(top_p if top_p is not None else self.generating_args["top_p"]) or 1.0, # top_p must > 0 + top_k=(top_k if top_k is not None else self.generating_args["top_k"]) or -1, # top_k must > 0 + stop=stop, + stop_token_ids=self.template.get_stop_token_ids(self.tokenizer), + max_tokens=max_tokens, + skip_special_tokens=skip_special_tokens + if skip_special_tokens is not None + else self.generating_args["skip_special_tokens"], + ) + + if images is not None: # add image features + multi_modal_data = { + "image": self.template.mm_plugin._regularize_images( + images, + image_max_pixels=self.model_args.image_max_pixels, + image_min_pixels=self.model_args.image_min_pixels, + )["images"] + } + elif videos is not None: + multi_modal_data = { + "video": self.template.mm_plugin._regularize_videos( + videos, + image_max_pixels=self.model_args.video_max_pixels, + image_min_pixels=self.model_args.video_min_pixels, + video_fps=self.model_args.video_fps, + video_maxlen=self.model_args.video_maxlen, + )["videos"] + } + elif audios is not None: + audio_data = self.template.mm_plugin._regularize_audios( + audios, + sampling_rate=self.model_args.audio_sampling_rate, + ) + multi_modal_data = {"audio": zip(audio_data["audios"], audio_data["sampling_rates"])} + else: + multi_modal_data = None + + result_generator = self.model.generate( + {"prompt_token_ids": prompt_ids, "multi_modal_data": multi_modal_data}, + sampling_params=sampling_params, + request_id=request_id, + lora_request=self.lora_request, + ) + return result_generator + + @override + async def chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> list["Response"]: + final_output = None + generator = await self._generate(messages, system, tools, images, videos, audios, **input_kwargs) + async for request_output in generator: + final_output = request_output + + results = [] + for output in final_output.outputs: + results.append( + Response( + response_text=output.text, + response_length=len(output.token_ids), + prompt_length=len(final_output.prompt_token_ids), + finish_reason=output.finish_reason, + ) + ) + + return results + + @override + async def stream_chat( + self, + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + images: Optional[list["ImageInput"]] = None, + videos: Optional[list["VideoInput"]] = None, + audios: Optional[list["AudioInput"]] = None, + **input_kwargs, + ) -> AsyncGenerator[str, None]: + generated_text = "" + generator = await self._generate(messages, system, tools, images, videos, audios, **input_kwargs) + async for result in generator: + delta_text = result.outputs[0].text[len(generated_text) :] + generated_text = result.outputs[0].text + yield delta_text + + @override + async def get_scores( + self, + batch_input: list[str], + **input_kwargs, + ) -> list[float]: + raise NotImplementedError("vLLM engine does not support `get_scores`.") diff --git a/src/train_sft/src/llamafactory/cli.py b/src/train_sft/src/llamafactory/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..fb94b35c2d44ea094befc15b9bf0411c42f91f3b --- /dev/null +++ b/src/train_sft/src/llamafactory/cli.py @@ -0,0 +1,160 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import subprocess +import sys +from copy import deepcopy +from functools import partial + + +USAGE = ( + "-" * 70 + + "\n" + + "| Usage: |\n" + + "| llamafactory-cli api -h: launch an OpenAI-style API server |\n" + + "| llamafactory-cli chat -h: launch a chat interface in CLI |\n" + + "| llamafactory-cli eval -h: evaluate models |\n" + + "| llamafactory-cli export -h: merge LoRA adapters and export model |\n" + + "| llamafactory-cli train -h: train models |\n" + + "| llamafactory-cli webchat -h: launch a chat interface in Web UI |\n" + + "| llamafactory-cli webui: launch LlamaBoard |\n" + + "| llamafactory-cli version: show version info |\n" + + "-" * 70 +) + + +def main(): + from . import launcher + from .api.app import run_api + from .chat.chat_model import run_chat + from .eval.evaluator import run_eval + from .extras import logging + from .extras.env import VERSION, print_env + from .extras.misc import find_available_port, get_device_count, is_env_enabled, use_ray + from .train.tuner import export_model, run_exp + from .webui.interface import run_web_demo, run_web_ui + + logger = logging.get_logger(__name__) + + WELCOME = ( + "-" * 58 + + "\n" + + f"| Welcome to LLaMA Factory, version {VERSION}" + + " " * (21 - len(VERSION)) + + "|\n|" + + " " * 56 + + "|\n" + + "| Project page: https://github.com/hiyouga/LLaMA-Factory |\n" + + "-" * 58 + ) + + COMMAND_MAP = { + "api": run_api, + "chat": run_chat, + "env": print_env, + "eval": run_eval, + "export": export_model, + "train": run_exp, + "webchat": run_web_demo, + "webui": run_web_ui, + "version": partial(print, WELCOME), + "help": partial(print, USAGE), + } + + command = sys.argv.pop(1) if len(sys.argv) > 1 else "help" + if command == "train" and (is_env_enabled("FORCE_TORCHRUN") or (get_device_count() > 1 and not use_ray())): + # launch distributed training + nnodes = os.getenv("NNODES", "1") + node_rank = os.getenv("NODE_RANK", "0") + nproc_per_node = os.getenv("NPROC_PER_NODE", str(get_device_count())) + master_addr = os.getenv("MASTER_ADDR", "127.0.0.1") + master_port = os.getenv("MASTER_PORT", str(find_available_port())) + logger.info_rank0(f"Initializing {nproc_per_node} distributed tasks at: {master_addr}:{master_port}") + if int(nnodes) > 1: + logger.info_rank0(f"Multi-node training enabled: num nodes: {nnodes}, node rank: {node_rank}") + + # elastic launch support + max_restarts = os.getenv("MAX_RESTARTS", "0") + rdzv_id = os.getenv("RDZV_ID") + min_nnodes = os.getenv("MIN_NNODES") + max_nnodes = os.getenv("MAX_NNODES") + + env = deepcopy(os.environ) + if is_env_enabled("OPTIM_TORCH", "1"): + # optimize DDP, see https://zhuanlan.zhihu.com/p/671834539 + env["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True" + env["TORCH_NCCL_AVOID_RECORD_STREAMS"] = "1" + + if rdzv_id is not None: + # launch elastic job with fault tolerant support when possible + # see also https://docs.pytorch.org/docs/stable/elastic/train_script.html + rdzv_nnodes = nnodes + # elastic number of nodes if MIN_NNODES and MAX_NNODES are set + if min_nnodes is not None and max_nnodes is not None: + rdzv_nnodes = f"{min_nnodes}:{max_nnodes}" + + process = subprocess.run( + ( + "torchrun --nnodes {rdzv_nnodes} --nproc-per-node {nproc_per_node} " + "--rdzv-id {rdzv_id} --rdzv-backend c10d --rdzv-endpoint {master_addr}:{master_port} " + "--max-restarts {max_restarts} {file_name} {args}" + ) + .format( + rdzv_nnodes=rdzv_nnodes, + nproc_per_node=nproc_per_node, + rdzv_id=rdzv_id, + master_addr=master_addr, + master_port=master_port, + max_restarts=max_restarts, + file_name=launcher.__file__, + args=" ".join(sys.argv[1:]), + ) + .split(), + env=env, + check=True, + ) + else: + # NOTE: DO NOT USE shell=True to avoid security risk + process = subprocess.run( + ( + "torchrun --nnodes {nnodes} --node_rank {node_rank} --nproc_per_node {nproc_per_node} " + "--master_addr {master_addr} --master_port {master_port} {file_name} {args}" + ) + .format( + nnodes=nnodes, + node_rank=node_rank, + nproc_per_node=nproc_per_node, + master_addr=master_addr, + master_port=master_port, + file_name=launcher.__file__, + args=" ".join(sys.argv[1:]), + ) + .split(), + env=env, + check=True, + ) + + sys.exit(process.returncode) + elif command in COMMAND_MAP: + COMMAND_MAP[command]() + else: + print(f"Unknown command: {command}.\n{USAGE}") + + +if __name__ == "__main__": + from multiprocessing import freeze_support + + freeze_support() + main() diff --git a/src/train_sft/src/llamafactory/data/__init__.py b/src/train_sft/src/llamafactory/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..11c8c9fcecd10e736e240196fde98f833c9df3dc --- /dev/null +++ b/src/train_sft/src/llamafactory/data/__init__.py @@ -0,0 +1,37 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .collator import ( + KTODataCollatorWithPadding, + MultiModalDataCollatorForSeq2Seq, + PairwiseDataCollatorWithPadding, + SFTDataCollatorWith4DAttentionMask, +) +from .data_utils import Role, split_dataset +from .loader import get_dataset +from .template import TEMPLATES, Template, get_template_and_fix_tokenizer + + +__all__ = [ + "TEMPLATES", + "KTODataCollatorWithPadding", + "MultiModalDataCollatorForSeq2Seq", + "PairwiseDataCollatorWithPadding", + "Role", + "SFTDataCollatorWith4DAttentionMask", + "Template", + "get_dataset", + "get_template_and_fix_tokenizer", + "split_dataset", +] diff --git a/src/train_sft/src/llamafactory/data/__pycache__/__init__.cpython-311.pyc b/src/train_sft/src/llamafactory/data/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d88d6adf5ed762ae1ba255e75f2f17ad8f8f042 Binary files /dev/null and b/src/train_sft/src/llamafactory/data/__pycache__/__init__.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/data/__pycache__/converter.cpython-311.pyc b/src/train_sft/src/llamafactory/data/__pycache__/converter.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77d98e3734c29805313aceb164f2d5b4f6c55615 Binary files /dev/null and b/src/train_sft/src/llamafactory/data/__pycache__/converter.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/data/__pycache__/group_layout_augmentor_new.cpython-311.pyc b/src/train_sft/src/llamafactory/data/__pycache__/group_layout_augmentor_new.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2c60ecf7609228c0499be032e894e1e13c22690 Binary files /dev/null and b/src/train_sft/src/llamafactory/data/__pycache__/group_layout_augmentor_new.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/data/__pycache__/loader.cpython-311.pyc b/src/train_sft/src/llamafactory/data/__pycache__/loader.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..184d2c11e04d41978e871610456db8fa3d325378 Binary files /dev/null and b/src/train_sft/src/llamafactory/data/__pycache__/loader.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/data/__pycache__/tool_utils.cpython-311.pyc b/src/train_sft/src/llamafactory/data/__pycache__/tool_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a96680052fc260685698e63e2ab2f84f84e30107 Binary files /dev/null and b/src/train_sft/src/llamafactory/data/__pycache__/tool_utils.cpython-311.pyc differ diff --git a/src/train_sft/src/llamafactory/data/augment_example.py b/src/train_sft/src/llamafactory/data/augment_example.py new file mode 100644 index 0000000000000000000000000000000000000000..c932329a56f9c13b893d9ae3fd19c62aa2ed4bc7 --- /dev/null +++ b/src/train_sft/src/llamafactory/data/augment_example.py @@ -0,0 +1,604 @@ +import numpy as np +import pickle +import pandas as pd +import glob +from trl import DataCollatorForCompletionOnlyLM +from datasets import Dataset +import copy +import os +from scipy.spatial.transform import Rotation as R +import json +from tqdm import tqdm +import pdb +from pathlib import Path +from shapely.geometry import Polygon, box +import random +import torch +from copy import deepcopy +import matplotlib.pyplot as plt + +from src.utils import inherit_props_by_id, get_pths_dataset_split, remove_and_recreate_folder, get_system_prompt_sgllm + +def create_floor_plan_polygon(bounds): + return Polygon(np.array(bounds)[:, [0, 2]].tolist()) + +def rotate_around_y(point, angle_radians): + rotation_matrix = np.array([ + [np.cos(angle_radians), 0, np.sin(angle_radians)], + [0, 1, 0], + [-np.sin(angle_radians), 0, np.cos(angle_radians)] + ]) + rot_point = np.dot(rotation_matrix, point).tolist() + rot_point = [ round(elem, 2) for elem in rot_point ] + + return rot_point + +def combine_quaternion_with_y_rot_for_global_rot(original_quat, angle_radians): + y_axis_rotation = R.from_euler('y', angle_radians).as_quat() + original_rotation = R.from_quat(original_quat) + combined_rotation = R.from_quat(y_axis_rotation) * original_rotation + return [round(elem, 5) for elem in combined_rotation.as_quat().tolist()] + +def rotate_obj(obj, angle_radians): + obj["pos"] = rotate_around_y(obj["pos"], angle_radians) + obj["rot"] = combine_quaternion_with_y_rot_for_global_rot(obj["rot"], angle_radians) + +def rotate_scenegraph(sample_scene, angle_radians): + if sample_scene.get("bounds_top"): + for key in ["bounds_top", "bounds_bottom"]: + sample_scene[key] = [rotate_around_y(point, angle_radians) for point in sample_scene[key]] + if sample_scene.get("objects"): + for obj in sample_scene.get("objects"): + rotate_obj(obj, angle_radians) + if sample_scene.get("pos"): + rotate_obj(sample_scene, angle_radians) + +def offset_bounds(sample_scene, shift_amount): + if sample_scene.get("bounds_top") and shift_amount != 0: + sample_scene["bounds_top"] = sample_scene["bounds_top"][shift_amount:] + sample_scene["bounds_top"][:shift_amount] + sample_scene["bounds_bottom"] = sample_scene["bounds_bottom"][shift_amount:] + sample_scene["bounds_bottom"][:shift_amount] + +def get_2d_bbox(pos, size): + x, _, z = pos + width, _, depth = size + half_width, half_depth = width/2, depth/2 + return box(x - half_width, z - half_depth, x + half_width, z + half_depth) + +def perturb_value_with_bounds(value, bounds, min_delta=-0.02, max_delta=0.02): + min_val, max_val = bounds + delta = np.random.uniform(min_delta, max_delta) + new_val = round(value + delta, 2) + # return np.clip(new_val, min_val, max_val) + return new_val + +def get_safe_perturbation(pos, size, floor_polygon, desc, max_attempts=10): + # Get bounds from the floor polygon + minx, minz, maxx, maxz = floor_polygon.bounds + + # if not floor_polygon.contains(get_2d_bbox(pos, size)): + # print("object not contained in floor polygon already !") + # print(f"\tdesc: {desc}") + # print(f"\tpos: {pos}") + # print(f"\tsize: {size}") + # print(f"\tbounds: ", minx, minz, maxx, maxz) + + for i in range(max_attempts): + # print(f"trying to find perturbation... ({i}/{max_attempts})") + pos_perturbed = pos.copy() + pos_perturbed[0] = perturb_value_with_bounds(pos[0], bounds=(minx, maxx)) + pos_perturbed[2] = perturb_value_with_bounds(pos[2], bounds=(minz, maxz)) + + size_perturbed = size.copy() + size_perturbed[0] = perturb_value_with_bounds(size[0], bounds=(minx, maxx)) + size_perturbed[2] = perturb_value_with_bounds(size[2], bounds=(minx, maxx)) + + new_bbox = get_2d_bbox(pos_perturbed, size_perturbed) + if floor_polygon.contains(new_bbox): + # print("valid perturbation found at iter ", i) + # print(f"\tdesc: {desc}") + # print(f"\tbounds: ", minx, minz, maxx, maxz) + # print(f"\tpos: {pos} -> {pos_perturbed}") + # print(f"\tsize: {size} -> {size_perturbed}") + return pos_perturbed, size_perturbed + + # if no valid perturbation found, return original values + # print("no valid perturbation found, returning original values") + # print(f"\tdesc: {desc}") + return pos, size + +def perturb_scene(sample_scene, floor_polygon): + if sample_scene.get("objects"): + for obj in sample_scene["objects"]: + new_pos, new_size = get_safe_perturbation(obj["pos"], obj["size"], floor_polygon, obj["desc"]) + obj["pos"] = new_pos + obj["size"] = new_size + if sample_scene.get("pos"): + new_pos, new_size = get_safe_perturbation(sample_scene["pos"], sample_scene["size"], floor_polygon, sample_scene["desc"]) + sample_scene["pos"] = new_pos + sample_scene["size"] = new_size + +def do_random_augm_on_sgs(sample, augm_prob=0.85): + + sg_input = sample.get("sg_input") + sg_output_add = sample.get("sg_output_add") + + # (1) with 15% prob, we don't perform any augmentation (return original data) + # TODO: could be hyperparam itself actually... + if np.random.rand() > augm_prob: + return sg_input, sg_output_add + + sg_input_augm = copy.deepcopy(json.loads(sg_input)) + sg_output_add_augm = copy.deepcopy(json.loads(sg_output_add)) + + # (2) do random rotation + angle_radians = np.radians(np.random.choice([0, 90, 180, 270])) + rotate_scenegraph(sg_input_augm, angle_radians) + rotate_scenegraph(sg_output_add_augm, angle_radians) + + # (3) circular shift of room boundaries + shift_amount = np.random.randint(0, len(sg_input_augm.get("bounds_bottom"))) + offset_bounds(sg_input_augm, shift_amount) + offset_bounds(sg_output_add_augm, shift_amount) + + # (4) scale entire "polygon" of bounds equally by +[0, 5] cm + # TODO + # scale_factor = np.random.uniform(0, 0.05) + # ... + + # (5) Perturb object sizes and positions + floor_polygon = create_floor_plan_polygon(sg_input_augm.get("bounds_bottom")) + perturb_scene(sg_input_augm, floor_polygon) + perturb_scene(sg_output_add_augm, floor_polygon) + + return json.dumps(sg_input_augm), json.dumps(sg_output_add_augm) + +def create_dataset_from_files(pth_output, room_type, dataset_split): + data = { + "room_type": [], + "n_objects": [], + "pth_orig_file": [], + "split": [], + "scene": [], + } + + pth_root = os.getenv("PTH_STAGE_2_DEDUP") + + all_pths = get_pths_dataset_split(room_type, dataset_split) + + for pth_scene in tqdm(all_pths, desc=f"Loading {room_type or 'all'} ({dataset_split} split)"): + with open(os.path.join(pth_root, pth_scene), 'r') as f: + scene = json.load(f) + + data["room_type"].append(scene.get("room_type")) + data["n_objects"].append(len(scene.get("objects"))) + data["split"].append(dataset_split) + data["scene"].append(scene) + data["pth_orig_file"].append(pth_scene) + + # data["sg_input"].append(sample.get("sg_input")) + # data["sg_output_add"].append(sample.get("sg_output_add")) + #data["prompt_var"].append(sample.get("prompt_var")) + #data["n_objects_query"].append(sample.get("n_objects_query")) + #data["n_objects_full"].append(sample.get("n_objects_full")) + #data["is_complete"].append(sample.get("is_complete")) + + dataset = Dataset.from_dict(data) + + with open(pth_output, 'wb') as fp: + pickle.dump(dataset, fp) + + return dataset + +def simplify_descs_for_ablation(sg_raw, all_assets_metadata_simple_descs): + sg_simplified = copy.deepcopy(json.loads(sg_raw)) + if sg_simplified.get("objects"): + for obj in sg_simplified["objects"]: + obj["desc"] = all_assets_metadata_simple_descs.get(obj["desc"]) + if sg_simplified.get("desc"): + sg_simplified["desc"] = all_assets_metadata_simple_descs.get(sg_simplified["desc"]) + return json.dumps(sg_simplified) + +def simplify_sample(sample, all_assets_metadata_simple_descs): + sample["sg_input"] = simplify_descs_for_ablation(sample["sg_input"], all_assets_metadata_simple_descs) + sample["sg_output_add"] = simplify_descs_for_ablation(sample["sg_output_add"], all_assets_metadata_simple_descs) + return sample + +def create_full_scene_from_before_and_added(scene_before, obj_add): + scene_after = copy.deepcopy(scene_before) + scene_after["objects"].append(obj_add) + return scene_after + +def ensure_order_of_keys_for_sg_input_dict(sg_input, do_keep_jids=False): + sg_input_ordered = {} + + sg_input_ordered["room_type"] = sg_input.get("room_type") + sg_input_ordered["bounds_top"] = sg_input.get("bounds_top") + sg_input_ordered["bounds_bottom"] = sg_input.get("bounds_bottom") + + # for each object in the scene, ensure fixed order such that we always have "desc", "size", "pos", "rot": + objects_ordered = [] + for obj in sg_input.get("objects"): + obj_ordered = {} + obj_ordered["desc"] = obj.get("desc") + obj_ordered["size"] = obj.get("size") + obj_ordered["pos"] = obj.get("pos") + obj_ordered["rot"] = obj.get("rot") + if do_keep_jids: + obj_ordered["jid"] = obj.get("jid") + objects_ordered.append(obj_ordered) + sg_input_ordered["objects"] = objects_ordered + + return sg_input_ordered + +def create_instruction_dict(prompt, scene_query, obj_add, room_type, n_objects_full, is_complete=False, do_keep_jids=False): + # remove id from sg_input + scene_query.pop("room_id") + + # ensure fixed order of keys for sg_input + scene_query = ensure_order_of_keys_for_sg_input_dict(scene_query, do_keep_jids=do_keep_jids) + + return { + "instr_type": "add", + "prompt": prompt, + "room_type": room_type, + "sg_input": json.dumps(scene_query), + "sg_output_add": json.dumps(obj_add), + "n_objects_query": len(scene_query["objects"]), + "n_objects_full": n_objects_full, + "is_complete": is_complete + } + +def clean_copy_of_objects(objects, do_keep_jids=False): + cleaned = deepcopy(objects) + + if do_keep_jids: + return cleaned + + if isinstance(cleaned, list): + for obj in cleaned: + obj.pop("jid", None) + else: + cleaned.pop("jid", None) + return cleaned + +def get_exposure_factor(n_objects, lambda_instr_exp=None): + if lambda_instr_exp is None: + return 1 + + # lambda_instr_exp should be in range 0.0 - 0.9 for reasonably scales ? + + # base = 4 * np.log(n_objects + 1) # +1 to handle n_objects=1 case + # scaled = base * (lambda_instr_exp ** 2) + # exposure = max(1, int(scaled + 1)) + # print(f"n_objects: {n_objects}, n_instructions: {n_instructions}") + exposure = np.exp(lambda_instr_exp * n_objects) + + return exposure + +def plot_scaling_curves(): + n_objects = range(2, 50) + for param in [0.1, 0.5, 1.0, 1.5, 2.0]: + instructions = [get_exposure_factor(n, param) for n in n_objects] + plt.plot(n_objects, instructions, label=f'param={param}') + + plt.xlabel('Number of Objects') + plt.ylabel('Number of Instructions') + plt.title('Instruction Exposure Scaling') + plt.legend() + plt.show() + +def get_sampling_weights(dataset, lambda_instr_exp): + weights = [get_exposure_factor(sample["n_objects"], lambda_instr_exp) for sample in dataset] + return np.array(weights) / sum(weights) + +class WeightedRandomSampler(torch.utils.data.Sampler): + def __init__(self, weights, num_samples, replacement=True): + self.weights = weights + self.num_samples = num_samples + self.replacement = replacement + + def __iter__(self): + return iter(torch.multinomial(self.weights, self.num_samples, self.replacement).tolist()) + + def __len__(self): + return self.num_samples + +def load_train_val_test_datasets(lambda_instr_exp=None, use_cached_dataset=True, room_type="all", do_sanity_check=False, seed=1234, accelerator=None): + pth_train = f"{os.getenv('PTH_DATASET_CACHE')}/dataset_{room_type}_train.pkl" + pth_val = f"{os.getenv('PTH_DATASET_CACHE')}/dataset_{room_type}_val.pkl" + pth_test = f"{os.getenv('PTH_DATASET_CACHE')}/dataset_{room_type}_test.pkl" + + if not use_cached_dataset: + dataset_train = create_dataset_from_files(pth_train, room_type, "train") + dataset_val = create_dataset_from_files(pth_val, room_type, "val") + dataset_test = create_dataset_from_files(pth_test, room_type, "test") + else: + print(f"loading cached dataset from {os.getenv('PTH_DATASET_CACHE')}") + dataset_train = pd.read_pickle(pth_train) + dataset_val = pd.read_pickle(pth_val) + dataset_test = pd.read_pickle(pth_test) + + # ONLY FOR TRAINING SPLIT: get normalized sampling weights + if lambda_instr_exp is not None: + train_weights = get_sampling_weights(dataset_train, lambda_instr_exp) + dataset_train = dataset_train.add_column("sampling_weight", train_weights) + + # plots weights vs number of objects and save as image + # x axis: number of objects, y axis: sampling weight + # plt.scatter([sample["n_objects"] for sample in dataset_train], train_weights) + # plt.xlabel('Number of Objects') + # plt.ylabel('Sampling Weight') + # plt.title('Sampling Weights vs Number of Objects') + # plt.savefig(f"sampling_weights_{room_type}.png") + + gen = np.random.default_rng(seed) + dataset_train = dataset_train.shuffle(generator=gen) + dataset_val = dataset_val.shuffle(generator=gen) + dataset_test = dataset_test.shuffle(generator=gen) + + if do_sanity_check: + n_max = 32 + dataset_train = dataset_train.select(range(n_max)) + dataset_val = dataset_val.select(range(n_max)) + dataset_test = dataset_test.select(range(n_max)) + + if accelerator: + dataset_train = accelerator.prepare(dataset_train) + dataset_val = accelerator.prepare(dataset_val) + dataset_test = accelerator.prepare(dataset_test) + + print(f"len of train dataset: {len(dataset_train)}") + print(f"len of val dataset: {len(dataset_val)}") + print(f"len of test dataset: {len(dataset_test)}") + + return dataset_train, dataset_val, dataset_test + +def build_full_instruction_from_prompt(prompt, sg_input): + sg_input_str = json.dumps(ensure_order_of_keys_for_sg_input_dict(json.loads(sg_input))) + return f"\n\t{prompt}\n\n\n\t{sg_input_str}\n" + +def sample_prompt(all_prompts, jid): + if "-(" in jid: + jid_clean = jid.split("-(")[0] + else: + jid_clean = jid + return random.choice(all_prompts[jid_clean]) + +def create_instruction_from_scene(sample, all_prompts, all_assets_metadata_simple_descs=None, do_simple_descs=False, do_keep_jids=False): + scene = sample["scene"] + n_objects = sample["n_objects"] + room_type = sample["room_type"] + + # get weight for instruction generation + # n_zero_start = min(1 // n_objects, 0.1) + # n_full_scene = min(1 // n_objects, 0.1) + + n_zero_start = 0.1 + n_full_scene = 0.1 + + n_random = 1.0 - n_zero_start - n_full_scene + + complete_scene = deepcopy(scene) + n_objects_full = len(complete_scene["objects"]) + + # sample instruction style from probs + instr_style = np.random.choice(["zero_start", "full_scene", "random"], p=[n_zero_start, n_full_scene, n_random]) + + # print(instr_style) + + if instr_style == "zero_start": + # Start with empty scene but keep everything else + scene_query = deepcopy(scene) + scene_query["objects"] = [] + + # select random object to add + obj_add = random.choice(scene["objects"]) + prompt = sample_prompt(all_prompts, obj_add.get("jid")) + obj_add = clean_copy_of_objects(obj_add, do_keep_jids) + + instr = create_instruction_dict(prompt, scene_query, obj_add, room_type, n_objects_full, do_keep_jids=do_keep_jids) + + elif instr_style == "full_scene": + # shuffle scene then pick first one and remove from list + scene_query = deepcopy(scene) + + obj_add = random.choice(scene["objects"]) + prompt = sample_prompt(all_prompts, obj_add.get("jid")) + obj_add = clean_copy_of_objects(obj_add, do_keep_jids) + + remaining_objects = clean_copy_of_objects(scene["objects"], do_keep_jids) + random.shuffle(remaining_objects) + scene_query["objects"] = [obj for obj in remaining_objects if obj != obj_add] + + instr = create_instruction_dict(prompt, scene_query, obj_add, room_type, n_objects_full, is_complete=True, do_keep_jids=do_keep_jids) + + else: + scene_query = deepcopy(scene) + random.shuffle(scene_query["objects"]) + + # drop between 0 and N-1 objects + n_total = len(scene_query["objects"]) + m_drop = np.random.choice(np.arange(0, n_total-1)) + n_total_new = n_total - m_drop + scene_query["objects"] = scene_query["objects"][:n_total_new] + + obj_add = scene_query["objects"][-1] + prompt = sample_prompt(all_prompts, obj_add.get("jid")) + obj_add = clean_copy_of_objects(obj_add, do_keep_jids) + + scene_query["objects"].pop() + scene_query["objects"] = clean_copy_of_objects(scene_query["objects"], do_keep_jids) + + instr = create_instruction_dict(prompt, scene_query, obj_add, room_type, n_objects_full, is_complete=(True if n_total_new == n_objects_full else False), do_keep_jids=do_keep_jids) + + # simplify descriptions if needed + if do_simple_descs: + instr = simplify_sample(instr, all_assets_metadata_simple_descs) + + return instr + +def format_and_tokenize(tokenizer, full_sample_instr, sample_sg_output_full, max_seq_length, padding_free, truncate=True): + + formatted_text = format_with_chat_template(tokenizer, full_sample_instr, sample_sg_output_full) + + if truncate: + tokenized_inputs = tokenizer( + formatted_text, + truncation=True, + max_length=max_seq_length, + padding="max_length" if not padding_free else False, + return_tensors="pt", + return_length=True + ) + else: + tokenized_inputs = tokenizer( + formatted_text, + truncation=False, + return_tensors="pt", + return_length=True + ) + + length = tokenized_inputs.get("length", None) + + return tokenized_inputs, length + +def process_scene_sample(orig_sample, tokenizer, max_seq_length, all_prompts, all_assets_metadata_simple_descs, do_simple_descs, do_augm=False, do_full_sg_outputs=False, do_keep_jids=False): + while True: + # Create instruction from scene + sample = create_instruction_from_scene(orig_sample, all_prompts, all_assets_metadata_simple_descs, do_simple_descs, do_keep_jids=do_keep_jids) + + # Apply data augmentation if enabled + if sample.get("split") == "train" and do_augm: + sample_sg_input, sample_sg_output_add = do_random_augm_on_sgs(sample) + else: + sample_sg_input, sample_sg_output_add = sample["sg_input"], sample["sg_output_add"] + + # Prepare the scene output/completion + if do_full_sg_outputs: + scene = json.loads(sample_sg_input) + scene["objects"].append(json.loads(sample_sg_output_add)) + completion = json.dumps(scene) + else: + completion = sample_sg_output_add + + # Build the full instruction + full_sample_instr = build_full_instruction_from_prompt(sample["prompt"], sample_sg_input) + + # check tok length and if it exceeds max length, retry + _, tok_length = format_and_tokenize(tokenizer, full_sample_instr, completion, max_seq_length, padding_free=True, truncate=False) + # subtract 150 tokens for the next object as the latter needs to fit into the context as well + if tok_length <= (max_seq_length - 150): + break + else: + print(f"sample exceeded max length ({tok_length} > {max_seq_length}-150), # of objects: {len(json.loads(sample_sg_input).get('objects'))}, retrying...") + + return full_sample_instr, completion, sample["prompt"], sample + +def format_with_chat_template(tokenizer, prompt, completion=None): + messages = [ + {"role": "system", "content": get_system_prompt_sgllm()}, + {"role": "user", "content": prompt} + ] + if completion is not None: + messages.append({"role": "assistant", "content": completion}) + + return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=(True if completion is None else False)) + +class SFTSceneDataCollator(DataCollatorForCompletionOnlyLM): + def __init__(self, do_augm, response_template, tokenizer, padding_free, max_seq_length, do_simple_descs, do_full_sg_outputs, **kwargs): + super().__init__(response_template=response_template, tokenizer=tokenizer, padding_free=padding_free, mlm=False, **kwargs) + + self.tokenizer = tokenizer + self.max_seq_length = max_seq_length + self.padding_free = padding_free + self.do_augm = do_augm + self.do_simple_descs = do_simple_descs + self.do_full_sg_outputs = do_full_sg_outputs + self.all_prompts = json.load(open(os.getenv("PTH_ASSETS_METADATA_PROMPTS"))) + self.all_assets_metadata_simple_descs = json.load(open(os.getenv("PTH_ASSETS_METADATA_SIMPLE_DESCS"))) + + def __call__(self, samples): + batch_input_ids = [] + batch_attention_masks = [] + + # print room type and number of object for each sample + # for sample in samples: + # print(f"room_type: {sample['room_type']}, n_objects: {sample['n_objects']}") + + # make histogram with n_objects and count for each bin + # plt.clf() + # n_objects = [sample["n_objects"] for sample in samples] + # plt.hist(n_objects, bins=range(0, max(n_objects), 1)) + # plt.xlabel('Number of Objects') + # plt.ylabel('Count') + # plt.title('Distribution of Number of Objects in Scenes') + # plt.savefig("batch_n_objects_histogram_0.1.png") + # exit() + + for idx, sample in enumerate(samples): + + full_sample_instr, sample_sg_output_full, _, _ = process_scene_sample(sample, self.tokenizer, self.max_seq_length, self.all_prompts, self.all_assets_metadata_simple_descs, self.do_simple_descs, self.do_augm, self.do_full_sg_outputs) + + tok_inputs, tok_length = format_and_tokenize(self.tokenizer, full_sample_instr, sample_sg_output_full, self.max_seq_length, self.padding_free) + + if tok_length is not None and tok_length > self.max_seq_length: + print(f"Input was truncated. Original length: {tok_length}, Max length: {self.max_seq_length}") + + batch_input_ids.append(tok_inputs["input_ids"].squeeze(0)) + batch_attention_masks.append(tok_inputs["attention_mask"].squeeze(0)) + + batch = [{"input_ids": input_ids, "attention_mask": attention_mask} for input_ids, attention_mask in zip(batch_input_ids, batch_attention_masks)] + + return super().__call__(batch) + +def count_samples_exceeding_max_length(dataset, tokenizer, max_seq_length, all_prompts, all_assets_metadata_simple_descs, do_simple_descs=False, do_full_sg_outputs=False): + for attempt in range(10): + count_exceeding = 0 + + for sample in tqdm(dataset, desc="Counting samples exceeding max length"): + + full_sample_instr, sample_sg_output_full, _, _ = process_scene_sample(sample, tokenizer, max_seq_length, all_prompts, all_assets_metadata_simple_descs, do_simple_descs, False, do_full_sg_outputs) + + print("\n\n") + + # tok_inputs, tok_length = format_and_tokenize(tokenizer, full_sample_instr, sample_sg_output_full, max_seq_length, False, truncate=False) + + # Format with BOTH input and output included + # formatted_text = format_with_chat_template(tokenizer, full_sample_instr, sample_sg_output_full) + + # Tokenize the COMPLETE text (input + output) + # tokenized = tokenizer(formatted_text, truncation=False) + + # if tok_length > max_seq_length: + # print("exceeding", tok_length) + # print("number of corners: ", len(sample["scene"].get("bounds_top"))) + # print("n_objects: ", sample["n_objects"]) + # print("") + # count_exceeding += 1 + + # print("total exceeding samples: ", count_exceeding) + # print("") + +def count_samples_testset_seeds_exceeding_max_length(dataset, tokenizer, max_seq_length, all_test_instrs, all_prompts, all_assets_metadata_simple_descs, do_simple_descs=False, do_full_sg_outputs=False): + for sample in tqdm(dataset, desc="Counting samples exceeding max length"): + + # full_sample_instr, sample_sg_output_full, _, _ = process_scene_sample(sample, tokenizer, max_seq_length, all_prompts, all_assets_metadata_simple_descs, do_simple_descs, False, do_full_sg_outputs) + + for seed in [1234, 3456, 5678]: + instr_sample = all_test_instrs.get(sample.get("pth_orig_file"))[seed] + + full_instruction = build_full_instruction_from_prompt(instr_sample.get("prompt"), instr_sample.get("sg_input")) + + tok_inputs, tok_length = format_and_tokenize(tokenizer, full_instruction, instr_sample.get("sg_output_add"), max_seq_length, False, truncate=False) + + if tok_length > max_seq_length: + print("exceeding", tok_length) + print("number of corners: ", len(sample["scene"].get("bounds_top"))) + print("n_objects: ", sample["n_objects"]) + print("") + +def get_random_sample(dataset, idx=None): + if idx is None: + idx = np.random.choice(len(dataset)) + print("choosing random sample with idx:", idx) + return dataset.select([idx])[0] \ No newline at end of file diff --git a/src/train_sft/src/llamafactory/data/augmentor.py b/src/train_sft/src/llamafactory/data/augmentor.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/train_sft/src/llamafactory/data/collator.py b/src/train_sft/src/llamafactory/data/collator.py new file mode 100644 index 0000000000000000000000000000000000000000..cd7802db515b91b1f2c1d3c298891a61f144d502 --- /dev/null +++ b/src/train_sft/src/llamafactory/data/collator.py @@ -0,0 +1,483 @@ +# Copyright 2025 OpenAccess AI Collective and the LlamaFactory team. +# +# This code is inspired by the OpenAccess AI Collective's axolotl library. +# https://github.com/OpenAccess-AI-Collective/axolotl/blob/main/src/axolotl/monkeypatch/utils.py +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Literal, Optional + +import numpy as np +import torch +import torch.nn.functional as F +from peft import PeftModel +from transformers import DataCollatorForSeq2Seq +import time + +from ..extras.constants import AUDIO_PLACEHOLDER, IGNORE_INDEX, IMAGE_PLACEHOLDER +from ..extras.packages import is_pillow_available + + +if is_pillow_available(): + from PIL import Image + + +if TYPE_CHECKING: + from transformers import ProcessorMixin + + from .template import Template + + +def prepare_4d_attention_mask(attention_mask_with_indices: "torch.Tensor", dtype: "torch.dtype") -> "torch.Tensor": + r"""Expand 2d attention mask to 4d attention mask. + + Expand the attention mask with indices from (batch_size, seq_len) to (batch_size, 1, seq_len, seq_len), + handle packed sequences and transforms the mask to lower triangular form to prevent future peeking. + + e.g. + ```python + # input + [[1, 1, 2, 2, 2, 0]] + # output + [ + [ + [ + [o, x, x, x, x, x], + [o, o, x, x, x, x], + [x, x, o, x, x, x], + [x, x, o, o, x, x], + [x, x, o, o, o, x], + [x, x, x, x, x, x], + ] + ] + ] + ``` + where `o` equals to `0.0`, `x` equals to `min_dtype`. + """ + _, seq_len = attention_mask_with_indices.size() + min_dtype = torch.finfo(dtype).min + zero_tensor = torch.tensor(0, dtype=dtype) + + # Create a non-padding mask. + non_padding_mask = (attention_mask_with_indices != 0).unsqueeze(1).unsqueeze(2) + # Create indices for comparison. + indices = attention_mask_with_indices.unsqueeze(1).unsqueeze(2) # [bsz, 1, 1, seq_len] + indices_t = attention_mask_with_indices.unsqueeze(1).unsqueeze(3) # [bsz, 1, seq_len, 1] + # Create a lower triangular mask. + tril_mask = torch.tril(torch.ones((seq_len, seq_len), dtype=torch.bool)) + attention_mask_4d = (indices == indices_t) & non_padding_mask & tril_mask + # Invert the attention mask. + attention_mask_4d = torch.where(attention_mask_4d, zero_tensor, min_dtype) + return attention_mask_4d + + +@dataclass +class MultiModalDataCollatorForSeq2Seq(DataCollatorForSeq2Seq): + r"""Data collator that supports VLMs. + + Features should contain input_ids, attention_mask, labels, and optionally contain images, videos and audios. + """ + + template: Optional["Template"] = None + processor: Optional["ProcessorMixin"] = None + + def __post_init__(self): + if self.template is None: + raise ValueError("Template is required for MultiModalDataCollator.") + + if isinstance(self.model, PeftModel): + self.model = self.model.base_model.model + + if self.model is not None and hasattr(self.model, "get_rope_index"): # for qwen2vl mrope + self.get_rope_func = self.model.get_rope_index # transformers < 4.52.0 or qwen2.5 omni + elif self.model is not None and hasattr(self.model, "model") and hasattr(self.model.model, "get_rope_index"): + self.get_rope_func = self.model.model.get_rope_index # transformers >= 4.52.0 + else: + self.get_rope_func = None + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + batch_images, batch_videos, batch_audios = [], [], [] + batch_imglens, batch_vidlens, batch_audlens, batch_input_ids = [], [], [], [] + for feature in features: + images = feature.pop("images", None) or [] + videos = feature.pop("videos", None) or [] + audios = feature.pop("audios", None) or [] + batch_images.extend(images) + batch_videos.extend(videos) + batch_audios.extend(audios) + batch_imglens.append(len(images)) + batch_vidlens.append(len(videos)) + batch_audlens.append(len(audios)) + batch_input_ids.append(feature["input_ids"]) + + fake_input_ids = [] + if ( + self.template.mm_plugin.image_token is not None and sum(batch_imglens) == 0 and sum(batch_vidlens) == 0 + ): # avoid process hanging in zero3/fsdp case + fake_messages = [{"role": "user", "content": IMAGE_PLACEHOLDER}] + fake_images = [Image.new("RGB", (64, 64), (255, 255, 255))] + fake_messages = self.template.mm_plugin.process_messages( + fake_messages, fake_images, [], [], self.processor + ) + _fake_input_ids = self.tokenizer.encode(fake_messages[0]["content"], add_special_tokens=False) + _fake_input_ids, _ = self.template.mm_plugin.process_token_ids( + _fake_input_ids, None, fake_images, [], [], self.tokenizer, self.processor + ) + fake_input_ids.extend(_fake_input_ids) + batch_images = fake_images + batch_imglens[0] = 1 + + if ( + self.template.mm_plugin.audio_token is not None and sum(batch_audlens) == 0 + ): # avoid process hanging in zero3/fsdp case + fake_messages = [{"role": "user", "content": AUDIO_PLACEHOLDER}] + fake_audios = [np.zeros(1600)] + fake_messages = self.template.mm_plugin.process_messages( + fake_messages, [], [], fake_audios, self.processor + ) + _fake_input_ids = self.tokenizer.encode(fake_messages[0]["content"], add_special_tokens=False) + _fake_input_ids, _ = self.template.mm_plugin.process_token_ids( + _fake_input_ids, None, [], [], fake_audios, self.tokenizer, self.processor + ) + fake_input_ids.extend(_fake_input_ids) + batch_audios = fake_audios + batch_audlens[0] = 1 + + if len(fake_input_ids) != 0: + if self.tokenizer.padding_side == "right": + features[0]["input_ids"] = features[0]["input_ids"] + fake_input_ids + features[0]["attention_mask"] = features[0]["attention_mask"] + [0] * len(fake_input_ids) + features[0]["labels"] = features[0]["labels"] + [IGNORE_INDEX] * len(fake_input_ids) + else: + features[0]["input_ids"] = fake_input_ids + features[0]["input_ids"] + features[0]["attention_mask"] = [0] * len(fake_input_ids) + features[0]["attention_mask"] + features[0]["labels"] = [IGNORE_INDEX] * len(fake_input_ids) + features[0]["labels"] + + batch_input_ids[0] = features[0]["input_ids"] + + mm_inputs = self.template.mm_plugin.get_mm_inputs( + batch_images, + batch_videos, + batch_audios, + batch_imglens, + batch_vidlens, + batch_audlens, + batch_input_ids, + self.processor, + ) + if "token_type_ids" in mm_inputs: + token_type_ids = mm_inputs.pop("token_type_ids") + for i, feature in enumerate(features): + feature["token_type_ids"] = token_type_ids[i] + + features: dict[str, torch.Tensor] = super().__call__(features) + + if self.get_rope_func is not None: + rope_index_kwargs = { + "input_ids": features["input_ids"], + "image_grid_thw": mm_inputs.get("image_grid_thw"), + "video_grid_thw": mm_inputs.get("video_grid_thw"), + "attention_mask": (features["attention_mask"] >= 1).float(), + } + if "second_per_grid_ts" in mm_inputs: # for qwen2vl + rope_index_kwargs["second_per_grid_ts"] = mm_inputs.get("second_per_grid_ts") + elif "video_second_per_grid" in mm_inputs: # for qwen2.5 omni + rope_index_kwargs["second_per_grids"] = mm_inputs.get("video_second_per_grid") + + if getattr(self.model.config, "model_type", None) == "qwen2_5_omni_thinker": # for qwen2.5 omni + rope_index_kwargs["use_audio_in_video"] = getattr(self.processor, "use_audio_in_video", False) + feature_attention_mask = mm_inputs.get("feature_attention_mask", None) + if feature_attention_mask is not None: # FIXME: need to get video image lengths + audio_feature_lengths = torch.sum(feature_attention_mask, dim=1) + rope_index_kwargs["audio_seqlens"] = audio_feature_lengths # prepare for input + + features["position_ids"], rope_deltas = self.get_rope_func(**rope_index_kwargs) + features["rope_deltas"] = rope_deltas - (1 - rope_index_kwargs["attention_mask"]).sum( + dim=-1 + ).unsqueeze(-1) + else: # for qwen2vl + features["position_ids"], features["rope_deltas"] = self.get_rope_func(**rope_index_kwargs) + + if ( + self.model is not None + and getattr(self.model.config, "model_type", None) + in ["glm4v", "Keye", "qwen2_vl", "qwen2_5_vl", "qwen2_5_omni_thinker"] + and ("position_ids" not in features or features["position_ids"].dim() != 3) + ): + raise ValueError(f"{self.model.config.model_type} requires 3D position ids for mrope.") + + if "cross_attention_mask" in mm_inputs: # for mllama inputs when pad_to_multiple_of is enabled + cross_attention_mask = mm_inputs.pop("cross_attention_mask") + seq_len = features["input_ids"].size(1) + orig_len = cross_attention_mask.size(1) + mm_inputs["cross_attention_mask"] = F.pad(cross_attention_mask, (0, 0, 0, 0, 0, seq_len - orig_len)) + + features.update(mm_inputs) + + if "image_bound" in features: # for minicpmv inputs + bsz, seq_length = features["input_ids"].shape + features["position_ids"] = torch.arange(seq_length).long().repeat(bsz, 1) + return {"data": features, "input_ids": features["input_ids"], "labels": features["labels"]} + + return features + + +@dataclass +class SFTDataCollatorWith4DAttentionMask(MultiModalDataCollatorForSeq2Seq): + r"""Data collator for 4d attention mask with data augmentation support.""" + + block_diag_attn: bool = False + attn_implementation: Literal["eager", "sdpa", "flash_attention_2"] = "eager" + compute_dtype: "torch.dtype" = torch.float32 + data_args: Optional[Any] = None # 用于访问数据增强配置 + + def __post_init__(self): + super().__post_init__() + + # 初始化数据增强器 + self.augmentor = None + if self.data_args and getattr(self.data_args, 'enable_data_augmentation', False): + try: + from .group_layout_augmentor_new import GroupLayoutAugmentor + + # 正确处理augmentation_types字符串格式 + augmentation_types_str = getattr(self.data_args, 'augmentation_types', 'random_group_shuffle,random_object_shuffle') + print("augmentation_types:", augmentation_types_str) + if isinstance(augmentation_types_str, str): + augmentation_types = [t.strip() for t in augmentation_types_str.split(',') if t.strip()] + else: + augmentation_types = augmentation_types_str or ['random_group_shuffle', 'random_object_shuffle'] + + augmentation_ratio = getattr(self.data_args, 'augmentation_ratio', 0.85) + + self.augmentor = GroupLayoutAugmentor( + augmentation_types=augmentation_types, + augmentation_ratio=augmentation_ratio + ) + print(f"✓ 数据增强器初始化成功: types={augmentation_types}, ratio={augmentation_ratio}") + except Exception as e: + print(f"警告: 数据增强器初始化失败: {e}") + self.augmentor = None + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + # 如果启用了数据增强且数据格式为原始对话格式，则进行增强处理 + # print("self.augmentor:", self.augmentor) + # print("feature[0]:", features[0]) + if self.augmentor is not None and features and "conversations" in features[0]: + features = self._apply_augmentation_and_tokenization(features) + + # 确保所有features都有必需的字段 + for feature in features: + # print("feature:", feature) + # time.sleep(10) + if "input_ids" not in feature: + raise ValueError(f"Feature missing 'input_ids' field. Available keys: {list(feature.keys())}") + + features = super().__call__(features) + # print("features input_ids:", features["input_ids"][-10:]) + if self.block_diag_attn and self.attn_implementation != "flash_attention_2": + features["attention_mask"] = prepare_4d_attention_mask(features["attention_mask"], self.compute_dtype) + + for key, value in features.items(): # cast data dtype for paligemma + if torch.is_tensor(value) and torch.is_floating_point(value): + features[key] = value.to(self.compute_dtype) + + return features + + def _apply_augmentation_and_tokenization(self, features: list[dict[str, Any]]) -> list[dict[str, Any]]: + """对原始对话数据应用增强并进行tokenization""" + processed_features = [] + + for feature in features: + try: + conversation = feature["conversations"] + + # 构建用户消息和助手回复 + prompt_parts = conversation["prompt"] + response_parts = conversation["response"] + + # 提取最后一个用户消息（通常是实际的用户输入） + user_content = prompt_parts[-1]["content"] if prompt_parts and isinstance(prompt_parts[-1], dict) else (prompt_parts[-1] if prompt_parts else "") + + # 提取助手回复 + assistant_content = response_parts[0]["content"] if response_parts and isinstance(response_parts[0], dict) else (response_parts[0] if response_parts else "") + + # 应用数据增强 + if self.augmentor and assistant_content: + try: + user_content, assistant_content = self.augmentor.augment_sample(user_content, assistant_content) + except Exception as e: + print(f"数据增强失败: {e}") + # 如果增强失败，使用原始数据 + + # print("assistant_content:", assistant_content) + + # 构建完整的消息列表 + messages = [] + + # 添加系统消息（如果有） + if conversation.get("system"): + messages.append({"role": "system", "content": conversation["system"]}) + + # 添加历史对话（除了最后一个用户消息） + for msg in prompt_parts[:-1]: + if isinstance(msg, dict): + messages.append(msg) + else: + # 如果是旧格式，需要转换 + messages.append({"role": "user", "content": str(msg)}) + + # 添加当前用户消息和助手回复 + messages.append({"role": "user", "content": user_content}) + messages.append({"role": "assistant", "content": assistant_content}) + + # 应用chat template + formatted_text = self.tokenizer.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=False + ) + + # print(f"formatted_text: {formatted_text}") + + # tokenize + tokenized = self.tokenizer( + formatted_text, + padding=False, + truncation=True, + max_length=getattr(self.data_args, 'cutoff_len', 2048), + return_tensors=None + ) + + # 创建labels：只对assistant回复部分计算loss + input_ids = tokenized["input_ids"] + labels = input_ids.copy() + + # 找到assistant回复的起始位置 + assistant_start = self._find_assistant_start(formatted_text, assistant_content) + if assistant_start is not None and assistant_start < len(labels): + # 将assistant回复之前的部分设为IGNORE_INDEX + labels[:assistant_start] = [IGNORE_INDEX] * assistant_start + else: + # 如果找不到assistant回复，将整个序列设为IGNORE_INDEX（这样不会计算loss） + labels = [IGNORE_INDEX] * len(labels) + + processed_feature = { + "input_ids": input_ids, + "attention_mask": tokenized["attention_mask"], + "labels": labels, + "images": conversation.get("images", []), + "videos": conversation.get("videos", []), + "audios": conversation.get("audios", []) + } + + processed_features.append(processed_feature) + + except Exception as e: + print(f"❌ 处理feature失败: {e}") + print(f"Feature keys: {list(feature.keys()) if isinstance(feature, dict) else 'Not a dict'}") + if isinstance(feature, dict) and "conversations" in feature: + conv = feature["conversations"] + print(f"Conversations type: {type(conv)}") + if isinstance(conv, dict): + print(f"Conversations keys: {list(conv.keys())}") + # 返回空列表，这样会导致父类处理时出现KeyError + return [] + + return processed_features + + def _find_assistant_start(self, formatted_text: str, assistant_content: str) -> Optional[int]: + """找到assistant回复在tokenized序列中的起始位置""" + try: + # 找到assistant内容在格式化文本中的位置 + assistant_pos = formatted_text.find(assistant_content) + if assistant_pos >= 0: + # tokenize到assistant开始位置的文本 + prefix_text = formatted_text[:assistant_pos] + prefix_tokens = self.tokenizer(prefix_text, add_special_tokens=False)["input_ids"] + return len(prefix_tokens) + + return None + except Exception: + return None + + +@dataclass +class PairwiseDataCollatorWithPadding(MultiModalDataCollatorForSeq2Seq): + r"""Data collator for pairwise data.""" + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + r"""Pad batched data to the longest sequence in the batch. + + We generate 2 * n examples where the first n examples represent chosen examples and + the last n examples represent rejected examples. + """ + concatenated_features = [] + for key in ("chosen", "rejected"): + for feature in features: + target_feature = { + "input_ids": feature[f"{key}_input_ids"], + "attention_mask": feature[f"{key}_attention_mask"], + "labels": feature[f"{key}_labels"], + "images": feature["images"], + "videos": feature["videos"], + "audios": feature["audios"], + } + concatenated_features.append(target_feature) + + return super().__call__(concatenated_features) + + +@dataclass +class KTODataCollatorWithPadding(MultiModalDataCollatorForSeq2Seq): + r"""Data collator for KTO data.""" + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + target_features = [] + kl_features = [] + kto_tags = [] + for feature in features: + target_feature = { + "input_ids": feature["input_ids"], + "attention_mask": feature["attention_mask"], + "labels": feature["labels"], + "images": feature["images"], + "videos": feature["videos"], + "audios": feature["audios"], + } + kl_feature = { + "input_ids": feature["kl_input_ids"], + "attention_mask": feature["kl_attention_mask"], + "labels": feature["kl_labels"], + "images": feature["images"], + "videos": feature["videos"], + "audios": feature["audios"], + } + target_features.append(target_feature) + kl_features.append(kl_feature) + kto_tags.append(feature["kto_tags"]) + + batch = super().__call__(target_features) + kl_batch = super().__call__(kl_features) + batch["kl_input_ids"] = kl_batch["input_ids"] + batch["kl_attention_mask"] = kl_batch["attention_mask"] + batch["kl_labels"] = kl_batch["labels"] + if "cross_attention_mask" in kl_batch: # for mllama inputs + batch["kl_cross_attention_mask"] = kl_batch["cross_attention_mask"] + + if "token_type_ids" in kl_batch: + batch["kl_token_type_ids"] = kl_batch["token_type_ids"] + + batch["kto_tags"] = torch.tensor(kto_tags) + return batch \ No newline at end of file diff --git a/src/train_sft/src/llamafactory/data/collator_backup.py b/src/train_sft/src/llamafactory/data/collator_backup.py new file mode 100644 index 0000000000000000000000000000000000000000..8c0d44f210415c5ba060c747e21debf8c9cf292f --- /dev/null +++ b/src/train_sft/src/llamafactory/data/collator_backup.py @@ -0,0 +1,322 @@ +# Copyright 2025 OpenAccess AI Collective and the LlamaFactory team. +# +# This code is inspired by the OpenAccess AI Collective's axolotl library. +# https://github.com/OpenAccess-AI-Collective/axolotl/blob/main/src/axolotl/monkeypatch/utils.py +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Literal, Optional + +import numpy as np +import torch +import torch.nn.functional as F +from peft import PeftModel +from transformers import DataCollatorForSeq2Seq + +from ..extras.constants import AUDIO_PLACEHOLDER, IGNORE_INDEX, IMAGE_PLACEHOLDER +from ..extras.packages import is_pillow_available + + +if is_pillow_available(): + from PIL import Image + + +if TYPE_CHECKING: + from transformers import ProcessorMixin + + from .template import Template + + +def prepare_4d_attention_mask(attention_mask_with_indices: "torch.Tensor", dtype: "torch.dtype") -> "torch.Tensor": + r"""Expand 2d attention mask to 4d attention mask. + + Expand the attention mask with indices from (batch_size, seq_len) to (batch_size, 1, seq_len, seq_len), + handle packed sequences and transforms the mask to lower triangular form to prevent future peeking. + + e.g. + ```python + # input + [[1, 1, 2, 2, 2, 0]] + # output + [ + [ + [ + [o, x, x, x, x, x], + [o, o, x, x, x, x], + [x, x, o, x, x, x], + [x, x, o, o, x, x], + [x, x, o, o, o, x], + [x, x, x, x, x, x], + ] + ] + ] + ``` + where `o` equals to `0.0`, `x` equals to `min_dtype`. + """ + _, seq_len = attention_mask_with_indices.size() + min_dtype = torch.finfo(dtype).min + zero_tensor = torch.tensor(0, dtype=dtype) + + # Create a non-padding mask. + non_padding_mask = (attention_mask_with_indices != 0).unsqueeze(1).unsqueeze(2) + # Create indices for comparison. + indices = attention_mask_with_indices.unsqueeze(1).unsqueeze(2) # [bsz, 1, 1, seq_len] + indices_t = attention_mask_with_indices.unsqueeze(1).unsqueeze(3) # [bsz, 1, seq_len, 1] + # Create a lower triangular mask. + tril_mask = torch.tril(torch.ones((seq_len, seq_len), dtype=torch.bool)) + attention_mask_4d = (indices == indices_t) & non_padding_mask & tril_mask + # Invert the attention mask. + attention_mask_4d = torch.where(attention_mask_4d, zero_tensor, min_dtype) + return attention_mask_4d + + +@dataclass +class MultiModalDataCollatorForSeq2Seq(DataCollatorForSeq2Seq): + r"""Data collator that supports VLMs. + + Features should contain input_ids, attention_mask, labels, and optionally contain images, videos and audios. + """ + + template: Optional["Template"] = None + processor: Optional["ProcessorMixin"] = None + + def __post_init__(self): + if self.template is None: + raise ValueError("Template is required for MultiModalDataCollator.") + + if isinstance(self.model, PeftModel): + self.model = self.model.base_model.model + + if self.model is not None and hasattr(self.model, "get_rope_index"): # for qwen2vl mrope + self.get_rope_func = self.model.get_rope_index # transformers < 4.52.0 or qwen2.5 omni + elif self.model is not None and hasattr(self.model, "model") and hasattr(self.model.model, "get_rope_index"): + self.get_rope_func = self.model.model.get_rope_index # transformers >= 4.52.0 + else: + self.get_rope_func = None + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + batch_images, batch_videos, batch_audios = [], [], [] + batch_imglens, batch_vidlens, batch_audlens, batch_input_ids = [], [], [], [] + for feature in features: + images = feature.pop("images", None) or [] + videos = feature.pop("videos", None) or [] + audios = feature.pop("audios", None) or [] + batch_images.extend(images) + batch_videos.extend(videos) + batch_audios.extend(audios) + batch_imglens.append(len(images)) + batch_vidlens.append(len(videos)) + batch_audlens.append(len(audios)) + batch_input_ids.append(feature["input_ids"]) + + fake_input_ids = [] + if ( + self.template.mm_plugin.image_token is not None and sum(batch_imglens) == 0 and sum(batch_vidlens) == 0 + ): # avoid process hanging in zero3/fsdp case + fake_messages = [{"role": "user", "content": IMAGE_PLACEHOLDER}] + fake_images = [Image.new("RGB", (64, 64), (255, 255, 255))] + fake_messages = self.template.mm_plugin.process_messages( + fake_messages, fake_images, [], [], self.processor + ) + _fake_input_ids = self.tokenizer.encode(fake_messages[0]["content"], add_special_tokens=False) + _fake_input_ids, _ = self.template.mm_plugin.process_token_ids( + _fake_input_ids, None, fake_images, [], [], self.tokenizer, self.processor + ) + fake_input_ids.extend(_fake_input_ids) + batch_images = fake_images + batch_imglens[0] = 1 + + if ( + self.template.mm_plugin.audio_token is not None and sum(batch_audlens) == 0 + ): # avoid process hanging in zero3/fsdp case + fake_messages = [{"role": "user", "content": AUDIO_PLACEHOLDER}] + fake_audios = [np.zeros(1600)] + fake_messages = self.template.mm_plugin.process_messages( + fake_messages, [], [], fake_audios, self.processor + ) + _fake_input_ids = self.tokenizer.encode(fake_messages[0]["content"], add_special_tokens=False) + _fake_input_ids, _ = self.template.mm_plugin.process_token_ids( + _fake_input_ids, None, [], [], fake_audios, self.tokenizer, self.processor + ) + fake_input_ids.extend(_fake_input_ids) + batch_audios = fake_audios + batch_audlens[0] = 1 + + if len(fake_input_ids) != 0: + if self.tokenizer.padding_side == "right": + features[0]["input_ids"] = features[0]["input_ids"] + fake_input_ids + features[0]["attention_mask"] = features[0]["attention_mask"] + [0] * len(fake_input_ids) + features[0]["labels"] = features[0]["labels"] + [IGNORE_INDEX] * len(fake_input_ids) + else: + features[0]["input_ids"] = fake_input_ids + features[0]["input_ids"] + features[0]["attention_mask"] = [0] * len(fake_input_ids) + features[0]["attention_mask"] + features[0]["labels"] = [IGNORE_INDEX] * len(fake_input_ids) + features[0]["labels"] + + batch_input_ids[0] = features[0]["input_ids"] + + mm_inputs = self.template.mm_plugin.get_mm_inputs( + batch_images, + batch_videos, + batch_audios, + batch_imglens, + batch_vidlens, + batch_audlens, + batch_input_ids, + self.processor, + ) + if "token_type_ids" in mm_inputs: + token_type_ids = mm_inputs.pop("token_type_ids") + for i, feature in enumerate(features): + feature["token_type_ids"] = token_type_ids[i] + + features: dict[str, torch.Tensor] = super().__call__(features) + + if self.get_rope_func is not None: + rope_index_kwargs = { + "input_ids": features["input_ids"], + "image_grid_thw": mm_inputs.get("image_grid_thw"), + "video_grid_thw": mm_inputs.get("video_grid_thw"), + "attention_mask": (features["attention_mask"] >= 1).float(), + } + if "second_per_grid_ts" in mm_inputs: # for qwen2vl + rope_index_kwargs["second_per_grid_ts"] = mm_inputs.get("second_per_grid_ts") + elif "video_second_per_grid" in mm_inputs: # for qwen2.5 omni + rope_index_kwargs["second_per_grids"] = mm_inputs.get("video_second_per_grid") + + if getattr(self.model.config, "model_type", None) == "qwen2_5_omni_thinker": # for qwen2.5 omni + rope_index_kwargs["use_audio_in_video"] = getattr(self.processor, "use_audio_in_video", False) + feature_attention_mask = mm_inputs.get("feature_attention_mask", None) + if feature_attention_mask is not None: # FIXME: need to get video image lengths + audio_feature_lengths = torch.sum(feature_attention_mask, dim=1) + rope_index_kwargs["audio_seqlens"] = audio_feature_lengths # prepare for input + + features["position_ids"], rope_deltas = self.get_rope_func(**rope_index_kwargs) + features["rope_deltas"] = rope_deltas - (1 - rope_index_kwargs["attention_mask"]).sum( + dim=-1 + ).unsqueeze(-1) + else: # for qwen2vl + features["position_ids"], features["rope_deltas"] = self.get_rope_func(**rope_index_kwargs) + + if ( + self.model is not None + and getattr(self.model.config, "model_type", None) + in ["glm4v", "Keye", "qwen2_vl", "qwen2_5_vl", "qwen2_5_omni_thinker"] + and ("position_ids" not in features or features["position_ids"].dim() != 3) + ): + raise ValueError(f"{self.model.config.model_type} requires 3D position ids for mrope.") + + if "cross_attention_mask" in mm_inputs: # for mllama inputs when pad_to_multiple_of is enabled + cross_attention_mask = mm_inputs.pop("cross_attention_mask") + seq_len = features["input_ids"].size(1) + orig_len = cross_attention_mask.size(1) + mm_inputs["cross_attention_mask"] = F.pad(cross_attention_mask, (0, 0, 0, 0, 0, seq_len - orig_len)) + + features.update(mm_inputs) + + if "image_bound" in features: # for minicpmv inputs + bsz, seq_length = features["input_ids"].shape + features["position_ids"] = torch.arange(seq_length).long().repeat(bsz, 1) + return {"data": features, "input_ids": features["input_ids"], "labels": features["labels"]} + + return features + + +@dataclass +class SFTDataCollatorWith4DAttentionMask(MultiModalDataCollatorForSeq2Seq): + r"""Data collator for 4d attention mask.""" + + block_diag_attn: bool = False + attn_implementation: Literal["eager", "sdpa", "flash_attention_2"] = "eager" + compute_dtype: "torch.dtype" = torch.float32 + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + features = super().__call__(features) + if self.block_diag_attn and self.attn_implementation != "flash_attention_2": + features["attention_mask"] = prepare_4d_attention_mask(features["attention_mask"], self.compute_dtype) + + for key, value in features.items(): # cast data dtype for paligemma + if torch.is_tensor(value) and torch.is_floating_point(value): + features[key] = value.to(self.compute_dtype) + + return features + + +@dataclass +class PairwiseDataCollatorWithPadding(MultiModalDataCollatorForSeq2Seq): + r"""Data collator for pairwise data.""" + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + r"""Pad batched data to the longest sequence in the batch. + + We generate 2 * n examples where the first n examples represent chosen examples and + the last n examples represent rejected examples. + """ + concatenated_features = [] + for key in ("chosen", "rejected"): + for feature in features: + target_feature = { + "input_ids": feature[f"{key}_input_ids"], + "attention_mask": feature[f"{key}_attention_mask"], + "labels": feature[f"{key}_labels"], + "images": feature["images"], + "videos": feature["videos"], + "audios": feature["audios"], + } + concatenated_features.append(target_feature) + + return super().__call__(concatenated_features) + + +@dataclass +class KTODataCollatorWithPadding(MultiModalDataCollatorForSeq2Seq): + r"""Data collator for KTO data.""" + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, "torch.Tensor"]: + target_features = [] + kl_features = [] + kto_tags = [] + for feature in features: + target_feature = { + "input_ids": feature["input_ids"], + "attention_mask": feature["attention_mask"], + "labels": feature["labels"], + "images": feature["images"], + "videos": feature["videos"], + "audios": feature["audios"], + } + kl_feature = { + "input_ids": feature["kl_input_ids"], + "attention_mask": feature["kl_attention_mask"], + "labels": feature["kl_labels"], + "images": feature["images"], + "videos": feature["videos"], + "audios": feature["audios"], + } + target_features.append(target_feature) + kl_features.append(kl_feature) + kto_tags.append(feature["kto_tags"]) + + batch = super().__call__(target_features) + kl_batch = super().__call__(kl_features) + batch["kl_input_ids"] = kl_batch["input_ids"] + batch["kl_attention_mask"] = kl_batch["attention_mask"] + batch["kl_labels"] = kl_batch["labels"] + if "cross_attention_mask" in kl_batch: # for mllama inputs + batch["kl_cross_attention_mask"] = kl_batch["cross_attention_mask"] + + if "token_type_ids" in kl_batch: + batch["kl_token_type_ids"] = kl_batch["token_type_ids"] + + batch["kto_tags"] = torch.tensor(kto_tags) + return batch \ No newline at end of file diff --git a/src/train_sft/src/llamafactory/data/converter.py b/src/train_sft/src/llamafactory/data/converter.py new file mode 100644 index 0000000000000000000000000000000000000000..1523c6f3733d8ff9805d1ce2c04ce2280aaf067a --- /dev/null +++ b/src/train_sft/src/llamafactory/data/converter.py @@ -0,0 +1,368 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from abc import abstractmethod +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Optional, Union + +from ..extras import logging +from .data_utils import Role +import time +import json + +if TYPE_CHECKING: + from datasets import Dataset, IterableDataset + from transformers import Seq2SeqTrainingArguments + + from ..hparams import DataArguments + from .mm_plugin import AudioInput, ImageInput, VideoInput + from .parser import DatasetAttr + + MediaType = Union[ImageInput, VideoInput, AudioInput] + + +logger = logging.get_logger(__name__) + + +def _get_by_path(obj: dict[str, Any], path: Optional[str]) -> Any: + r"""Safely get nested value by dot-separated path, return None if not found or path is falsy.""" + if not path: + return None + cur: Any = obj + for part in path.split("."): + if isinstance(cur, dict) and part in cur: + cur = cur[part] + else: + return None + return cur + + +@dataclass +class DatasetConverter: + dataset_attr: "DatasetAttr" + data_args: "DataArguments" + + def _find_medias(self, medias: Union["MediaType", list["MediaType"], None]) -> Optional[list["MediaType"]]: + r"""Optionally concatenate media path to media dir when loading from local disk.""" + if medias is None: + return None + elif not isinstance(medias, list): + medias = [medias] + elif len(medias) == 0: + return None + else: + medias = medias[:] + + if self.dataset_attr.load_from in ["script", "file"]: + if isinstance(medias[0], str): + for i in range(len(medias)): + media_path = os.path.join(self.data_args.media_dir, medias[i]) + if os.path.isfile(media_path): + medias[i] = media_path + else: + logger.warning_rank0_once( + f"Media {medias[i]} does not exist in `media_dir`. Use original path." + ) + elif isinstance(medias[0], list): # for processed video frames + # medias is a list of lists, e.g., [[frame1.jpg, frame2.jpg], [frame3.jpg, frame4.jpg]] + for i in range(len(medias)): + for j in range(len(medias[i])): + media_path = os.path.join(self.data_args.media_dir, medias[i][j]) + if os.path.isfile(media_path): + medias[i][j] = media_path + else: + logger.warning_rank0_once( + f"Media {medias[i][j]} does not exist in `media_dir`. Use original path." + ) + + return medias + + @abstractmethod + def __call__(self, example: dict[str, Any]) -> dict[str, Any]: + r"""Convert a single example in the dataset to the standard format.""" + ... + + +@dataclass +class AlpacaDatasetConverter(DatasetConverter): + def __call__(self, example: dict[str, Any]) -> dict[str, Any]: + prompt = [] + history_value = _get_by_path(example, self.dataset_attr.history) if self.dataset_attr.history else None + if isinstance(history_value, list): + for old_prompt, old_response in history_value: + prompt.append({"role": Role.USER.value, "content": old_prompt}) + prompt.append({"role": Role.ASSISTANT.value, "content": old_response}) + + query = [] + prompt_value = _get_by_path(example, self.dataset_attr.prompt) if self.dataset_attr.prompt else None + if prompt_value: + query.append(prompt_value) + + query_value = _get_by_path(example, self.dataset_attr.query) if self.dataset_attr.query else None + if query_value: + query.append(query_value) + + prompt.append({"role": Role.USER.value, "content": "\n".join(query)}) # "prompt\nquery" + + response = [] + kto_value = _get_by_path(example, self.dataset_attr.kto_tag) if self.dataset_attr.kto_tag else None + if isinstance(kto_value, bool): # kto example + resp_text = _get_by_path(example, self.dataset_attr.response) if self.dataset_attr.response else None + response = [{"role": Role.ASSISTANT.value, "content": resp_text or ""}] + if kto_value: + response = response + [{"role": Role.ASSISTANT.value, "content": ""}] + else: + response = [{"role": Role.ASSISTANT.value, "content": ""}] + response + elif self.dataset_attr.ranking: + chosen = _get_by_path(example, self.dataset_attr.chosen) if self.dataset_attr.chosen else None + rejected = _get_by_path(example, self.dataset_attr.rejected) if self.dataset_attr.rejected else None + if isinstance(chosen, str) and isinstance(rejected, str): + response = [ + {"role": Role.ASSISTANT.value, "content": chosen}, + {"role": Role.ASSISTANT.value, "content": rejected}, + ] + else: + resp_text = _get_by_path(example, self.dataset_attr.response) if self.dataset_attr.response else None + if isinstance(resp_text, str): + response = [{"role": Role.ASSISTANT.value, "content": resp_text}] + + output = { + "_prompt": prompt, + "_response": response, + "_system": _get_by_path(example, self.dataset_attr.system) if self.dataset_attr.system else (self.data_args.default_system or ""), + "_tools": _get_by_path(example, self.dataset_attr.tools) if self.dataset_attr.tools else "", + "_images": self._find_medias(_get_by_path(example, self.dataset_attr.images)) if self.dataset_attr.images else None, + "_videos": self._find_medias(_get_by_path(example, self.dataset_attr.videos)) if self.dataset_attr.videos else None, + "_audios": self._find_medias(_get_by_path(example, self.dataset_attr.audios)) if self.dataset_attr.audios else None, + } + return output + + +@dataclass +class SharegptDatasetConverter(DatasetConverter): + def __call__(self, example: dict[str, Any]) -> dict[str, Any]: + tag_mapping = { + self.dataset_attr.user_tag: Role.USER.value, + self.dataset_attr.assistant_tag: Role.ASSISTANT.value, + self.dataset_attr.observation_tag: Role.OBSERVATION.value, + self.dataset_attr.function_tag: Role.FUNCTION.value, + self.dataset_attr.system_tag: Role.SYSTEM.value, + } + odd_tags = (self.dataset_attr.user_tag, self.dataset_attr.observation_tag) + even_tags = (self.dataset_attr.assistant_tag, self.dataset_attr.function_tag) + accept_tags = (odd_tags, even_tags) + messages = _get_by_path(example, self.dataset_attr.messages) + if ( + self.dataset_attr.system_tag + and len(messages) != 0 + and messages[0][self.dataset_attr.role_tag] == self.dataset_attr.system_tag + ): + system = messages[0][self.dataset_attr.content_tag] + messages = messages[1:] + else: + system = _get_by_path(example, self.dataset_attr.system) if self.dataset_attr.system else (self.data_args.default_system or "") + + aligned_messages = [] + broken_data = False + for turn_idx, message in enumerate(messages): + if message[self.dataset_attr.role_tag] not in accept_tags[turn_idx % 2]: + logger.warning_rank0(f"Invalid role tag in {messages}.") + broken_data = True + break + + aligned_messages.append( + { + "role": tag_mapping[message[self.dataset_attr.role_tag]], + "content": message[self.dataset_attr.content_tag], + } + ) + + if (not self.dataset_attr.ranking and len(aligned_messages) % 2 != 0) or ( + self.dataset_attr.ranking and len(aligned_messages) % 2 == 0 + ): + logger.warning_rank0(f"Invalid message count in {messages}.") + broken_data = True + + if broken_data: + logger.warning_rank0("Skipping this abnormal example.") + prompt, response = [], [] + elif self.dataset_attr.kto_tag and isinstance(_get_by_path(example, self.dataset_attr.kto_tag), bool): # kto example + prompt = aligned_messages[:-1] + response = aligned_messages[-1:] + if _get_by_path(example, self.dataset_attr.kto_tag): + response = response + [{"role": Role.ASSISTANT.value, "content": ""}] + else: + response = [{"role": Role.ASSISTANT.value, "content": ""}] + response + elif self.dataset_attr.ranking: + chosen = _get_by_path(example, self.dataset_attr.chosen) + rejected = _get_by_path(example, self.dataset_attr.rejected) + if ( + isinstance(chosen, dict) + and isinstance(rejected, dict) + and chosen[self.dataset_attr.role_tag] in accept_tags[-1] + and rejected[self.dataset_attr.role_tag] in accept_tags[-1] + ): + prompt = aligned_messages + response = [ + { + "role": tag_mapping[chosen[self.dataset_attr.role_tag]], + "content": chosen[self.dataset_attr.content_tag], + }, + { + "role": tag_mapping[rejected[self.dataset_attr.role_tag]], + "content": rejected[self.dataset_attr.content_tag], + }, + ] + else: + logger.warning_rank0(f"Invalid role tag in {[chosen, rejected]}.") + prompt, response = [], [] + else: # normal example + prompt = aligned_messages[:-1] + response = aligned_messages[-1:] + + output = { + "_prompt": prompt, + "_response": response, + "_system": system, + "_tools": _get_by_path(example, self.dataset_attr.tools) if self.dataset_attr.tools else "", + "_images": self._find_medias(_get_by_path(example, self.dataset_attr.images)) if self.dataset_attr.images else None, + "_videos": self._find_medias(_get_by_path(example, self.dataset_attr.videos)) if self.dataset_attr.videos else None, + "_audios": self._find_medias(_get_by_path(example, self.dataset_attr.audios)) if self.dataset_attr.audios else None, + } + return output + + +@dataclass +class GroupLayoutDatasetConverter(DatasetConverter): + r"""Converter for the custom group-layout dataset with fields under 'content'.""" + + def __call__(self, example: dict[str, Any]) -> dict[str, Any]: + user_input = example["content"]["user_input"] + cot = example["content"].get("cot", "") + answer_obj = json.loads(example["content"].get("answer")) + + # 在 train split 中移除不需要学习的字段，例如 'jid' + def _strip_keys(obj: Any, keys: set[str]) -> Any: + if isinstance(obj, dict): + return {k: _strip_keys(v, keys) for k, v in obj.items() if k not in keys} + if isinstance(obj, list): + return [_strip_keys(v, keys) for v in obj] + return obj + + def _delete_ids(obj: Any) -> Any: + metadata = obj.get("meta", {}) + metadata.pop("scene_id", None) + + if "functional_zones" in obj: + for fz in obj["functional_zones"]: + for asset in fz.get("assets", []): + asset.pop("id", None) + asset.pop("model_id", None) + asset.pop("model_uid", None) + + return obj + + if answer_obj is None: + ans_text = "" + else: + try: + # 仅在训练与验证（计算 CE）阶段移除 jid；测试集保留完整答案 + split_lower = str(getattr(self.dataset_attr, "split", "")).lower() + if split_lower in {"train", "val"}: + answer_obj = _strip_keys(answer_obj, {"jid", "room_id", "model_id", "scene_id"}) + answer_obj = _delete_ids(answer_obj) + + ans_text = json.dumps(answer_obj, ensure_ascii=False) + except Exception: + ans_text = str(answer_obj) + + # 统一包裹 … + ans_wrapped = f"{ans_text}" + if cot and (self.data_args.enable_thinking is None or self.data_args.enable_thinking): + assistant_text = f"{cot}\n" + ans_wrapped + else: + assistant_text = ans_wrapped + + prompt = [{"role": Role.USER.value, "content": user_input}] + response = [{"role": Role.ASSISTANT.value, "content": assistant_text}] + + output = { + "_prompt": prompt, + "_response": response, + "_system": self.data_args.default_system or "", + "_tools": "", + "_images": None, + "_videos": None, + "_audios": None, + } + return output + + +DATASET_CONVERTERS = { + "alpaca": AlpacaDatasetConverter, + "sharegpt": SharegptDatasetConverter, + "group_layout": GroupLayoutDatasetConverter, +} + + +def register_dataset_converter(name: str, dataset_converter: type["DatasetConverter"]) -> None: + r"""Register a new dataset converter.""" + if name in DATASET_CONVERTERS: + raise ValueError(f"Dataset converter {name} already exists.") + + DATASET_CONVERTERS[name] = dataset_converter + + +def get_dataset_converter(name: str, dataset_attr: "DatasetAttr", data_args: "DataArguments") -> "DatasetConverter": + r"""Get a dataset converter.""" + if name not in DATASET_CONVERTERS: + raise ValueError(f"Dataset converter {name} not found.") + + return DATASET_CONVERTERS[name](dataset_attr, data_args) + + +def align_dataset( + dataset: Union["Dataset", "IterableDataset"], + dataset_attr: "DatasetAttr", + data_args: "DataArguments", + training_args: "Seq2SeqTrainingArguments", +) -> Union["Dataset", "IterableDataset"]: + r"""Align the dataset to a specific format. + + Aligned dataset: + _prompt: [{"role": "user", "content": "..."}] * (2T - 1) + _response: [{"role": "assistant", "content": "..."}] * N (N > 1 for ranking dataset) + _system: "..." + _tools: "..." + _images: [] + _videos: [] + _audios: [] + """ + column_names = list(next(iter(dataset)).keys()) + kwargs = {} + if not data_args.streaming: + kwargs = dict( + num_proc=data_args.preprocessing_num_workers, + load_from_cache_file=(not data_args.overwrite_cache) or (training_args.local_process_index != 0), + desc="Converting format of dataset", + ) + + dataset_converter = get_dataset_converter(dataset_attr.formatting, dataset_attr, data_args) + return dataset.map( + dataset_converter, + batched=False, + remove_columns=column_names, + **kwargs, + ) diff --git a/src/train_sft/src/llamafactory/data/data_utils.py b/src/train_sft/src/llamafactory/data/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..14e261290a032466c87772915eb9f472e08d14fa --- /dev/null +++ b/src/train_sft/src/llamafactory/data/data_utils.py @@ -0,0 +1,190 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +from enum import Enum, unique +from typing import TYPE_CHECKING, Any, Optional, TypedDict, Union + +import fsspec +from datasets import DatasetDict, concatenate_datasets, interleave_datasets + +from ..extras import logging + + +if TYPE_CHECKING: + from datasets import Dataset, IterableDataset + + from ..hparams import DataArguments + + +logger = logging.get_logger(__name__) + + +SLOTS = list[Union[str, set[str], dict[str, str]]] + + +@unique +class Role(str, Enum): + USER = "user" + ASSISTANT = "assistant" + SYSTEM = "system" + FUNCTION = "function" + OBSERVATION = "observation" + + +class DatasetModule(TypedDict): + train_dataset: Optional[Union["Dataset", "IterableDataset"]] + eval_dataset: Optional[Union["Dataset", "IterableDataset", dict[str, "Dataset"]]] + + +def merge_dataset( + all_datasets: list[Union["Dataset", "IterableDataset"]], data_args: "DataArguments", seed: int +) -> Union["Dataset", "IterableDataset"]: + r"""Merge multiple datasets to a unified dataset.""" + if len(all_datasets) == 1: + return all_datasets[0] + + elif data_args.mix_strategy == "concat": + if data_args.streaming: + logger.warning_rank0_once("The samples between different datasets will not be mixed in streaming mode.") + + return concatenate_datasets(all_datasets) + + elif data_args.mix_strategy.startswith("interleave"): + if not data_args.streaming: + logger.warning_rank0_once("We recommend using `mix_strategy=concat` in non-streaming mode.") + + return interleave_datasets( + datasets=all_datasets, + probabilities=data_args.interleave_probs, + seed=seed, + stopping_strategy="first_exhausted" if data_args.mix_strategy.endswith("under") else "all_exhausted", + ) + + else: + raise ValueError(f"Unknown mixing strategy: {data_args.mix_strategy}.") + + +def split_dataset( + dataset: Optional[Union["Dataset", "IterableDataset"]], + eval_dataset: Optional[Union["Dataset", "IterableDataset", dict[str, "Dataset"]]], + data_args: "DataArguments", + seed: int, +) -> "DatasetDict": + r"""Split the dataset and returns a dataset dict containing train set and validation set. + + Support both map dataset and iterable dataset. + """ + if eval_dataset is not None and data_args.val_size > 1e-6: + raise ValueError("Cannot specify `val_size` if `eval_dataset` is not None.") + + dataset_dict = {} + if dataset is not None: + if data_args.streaming: + dataset = dataset.shuffle(buffer_size=data_args.buffer_size, seed=seed) + + if data_args.val_size > 1e-6: + if data_args.streaming: + dataset_dict["validation"] = dataset.take(int(data_args.val_size)) + dataset_dict["train"] = dataset.skip(int(data_args.val_size)) + else: + val_size = int(data_args.val_size) if data_args.val_size > 1 else data_args.val_size + dataset_dict = dataset.train_test_split(test_size=val_size, seed=seed) + dataset = dataset.train_test_split(test_size=val_size, seed=seed) + dataset_dict = {"train": dataset["train"], "validation": dataset["test"]} + else: + dataset_dict["train"] = dataset + + if eval_dataset is not None: + if isinstance(eval_dataset, dict): + dataset_dict.update({f"validation_{name}": data for name, data in eval_dataset.items()}) + else: + if data_args.streaming: + eval_dataset = eval_dataset.shuffle(buffer_size=data_args.buffer_size, seed=seed) + + dataset_dict["validation"] = eval_dataset + + return DatasetDict(dataset_dict) + + +def get_dataset_module(dataset: Union["Dataset", "DatasetDict"]) -> "DatasetModule": + r"""Convert dataset or dataset dict to dataset module.""" + dataset_module: DatasetModule = {} + if isinstance(dataset, DatasetDict): # dataset dict + if "train" in dataset: + dataset_module["train_dataset"] = dataset["train"] + + if "validation" in dataset: + dataset_module["eval_dataset"] = dataset["validation"] + else: + eval_dataset = {} + for key in dataset.keys(): + if key.startswith("validation_"): + eval_dataset[key[len("validation_") :]] = dataset[key] + + if len(eval_dataset): + dataset_module["eval_dataset"] = eval_dataset + + else: # single dataset + dataset_module["train_dataset"] = dataset + + return dataset_module + + +def setup_fs(path: str, anon: bool = False) -> "fsspec.AbstractFileSystem": + r"""Set up a filesystem object based on the path protocol.""" + storage_options = {"anon": anon} if anon else {} + if path.startswith("s3://"): + fs = fsspec.filesystem("s3", **storage_options) + elif path.startswith(("gs://", "gcs://")): + fs = fsspec.filesystem("gcs", **storage_options) + else: + raise ValueError(f"Unsupported protocol in path: {path}. Use 's3://' or 'gs://'.") + + if not fs.exists(path): + raise ValueError(f"Path does not exist: {path}.") + + return fs + + +def _read_json_with_fs(fs: "fsspec.AbstractFileSystem", path: str) -> list[Any]: + r"""Helper function to read JSON/JSONL files using fsspec.""" + with fs.open(path, "r") as f: + if path.endswith(".jsonl"): + return [json.loads(line) for line in f if line.strip()] + else: + return json.load(f) + + +def read_cloud_json(cloud_path: str) -> list[Any]: + r"""Read a JSON/JSONL file from cloud storage (S3 or GCS). + + Args: + cloud_path: str + Cloud path in the format: + - 's3://bucket-name/file.json' for AWS S3 + - 'gs://bucket-name/file.jsonl' or 'gcs://bucket-name/file.jsonl' for Google Cloud Storage + """ + try: + fs = setup_fs(cloud_path, anon=True) # try with anonymous access first + except Exception: + fs = setup_fs(cloud_path) # try again with credentials + + # filter out non-JSON files + files = [x["Key"] for x in fs.listdir(cloud_path)] if fs.isdir(cloud_path) else [cloud_path] + files = filter(lambda file: file.endswith(".json") or file.endswith(".jsonl"), files) + if not files: + raise ValueError(f"No JSON/JSONL files found in the specified path: {cloud_path}.") + + return sum([_read_json_with_fs(fs, file) for file in files], []) diff --git a/src/train_sft/src/llamafactory/data/formatter.py b/src/train_sft/src/llamafactory/data/formatter.py new file mode 100644 index 0000000000000000000000000000000000000000..0a101ac6787b99431807714c88da1a75d7a8b3f2 --- /dev/null +++ b/src/train_sft/src/llamafactory/data/formatter.py @@ -0,0 +1,142 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import re +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import Optional, Union + +from typing_extensions import override + +from .data_utils import SLOTS +from .tool_utils import FunctionCall, get_tool_utils + + +@dataclass +class Formatter(ABC): + slots: SLOTS = field(default_factory=list) + tool_format: Optional[str] = None + + @abstractmethod + def apply(self, **kwargs) -> SLOTS: + r"""Forms a list of slots according to the inputs to encode.""" + ... + + def extract(self, content: str) -> Union[str, list["FunctionCall"]]: + r"""Extract a list of tuples from the response message if using tools. + + Each tuple consists of function name and function arguments. + """ + raise NotImplementedError + + +@dataclass +class EmptyFormatter(Formatter): + def __post_init__(self): + has_placeholder = False + for slot in filter(lambda s: isinstance(s, str), self.slots): + if re.search(r"\{\{[a-zA-Z_][a-zA-Z0-9_]*\}\}", slot): + has_placeholder = True + + if has_placeholder: + raise ValueError("Empty formatter should not contain any placeholder.") + + @override + def apply(self, **kwargs) -> SLOTS: + return self.slots + + +@dataclass +class StringFormatter(Formatter): + def __post_init__(self): + has_placeholder = False + for slot in filter(lambda s: isinstance(s, str), self.slots): + if re.search(r"\{\{[a-zA-Z_][a-zA-Z0-9_]*\}\}", slot): + has_placeholder = True + + if not has_placeholder: + raise ValueError("A placeholder is required in the string formatter.") + + @override + def apply(self, **kwargs) -> SLOTS: + elements = [] + for slot in self.slots: + if isinstance(slot, str): + for name, value in kwargs.items(): + if not isinstance(value, str): + raise RuntimeError(f"Expected a string, got {value}") + + slot = slot.replace("{{" + name + "}}", value, 1) + elements.append(slot) + elif isinstance(slot, (dict, set)): + elements.append(slot) + else: + raise RuntimeError(f"Input must be string, set[str] or dict[str, str], got {type(slot)}.") + + return elements + + +@dataclass +class FunctionFormatter(StringFormatter): + def __post_init__(self): + super().__post_init__() + self.tool_utils = get_tool_utils(self.tool_format) + + @override + def apply(self, **kwargs) -> SLOTS: + content: str = kwargs.pop("content") + regex = re.compile(r"(.*)", re.DOTALL) + thought = re.search(regex, content) + if thought: + content = content.replace(thought.group(0), "") + + functions: list[FunctionCall] = [] + try: + tool_calls = json.loads(content) + if not isinstance(tool_calls, list): # parallel function call + tool_calls = [tool_calls] + + for tool_call in tool_calls: + functions.append( + FunctionCall(tool_call["name"], json.dumps(tool_call["arguments"], ensure_ascii=False)) + ) + + except json.JSONDecodeError: + raise RuntimeError(f"Invalid JSON format in function message: {str([content])}.") # flat string + + function_str = self.tool_utils.function_formatter(functions) + if thought: + function_str = thought.group(0) + function_str + + return super().apply(content=function_str) + + +@dataclass +class ToolFormatter(Formatter): + def __post_init__(self): + self.tool_utils = get_tool_utils(self.tool_format) + + @override + def apply(self, **kwargs) -> SLOTS: + content = kwargs.pop("content") + try: + tools = json.loads(content) + return [self.tool_utils.tool_formatter(tools) if len(tools) != 0 else ""] + except json.JSONDecodeError: + raise RuntimeError(f"Invalid JSON format in tool description: {str([content])}.") # flat string + + @override + def extract(self, content: str) -> Union[str, list["FunctionCall"]]: + return self.tool_utils.tool_extractor(content) diff --git a/src/train_sft/src/llamafactory/data/group_layout_augmentor.py b/src/train_sft/src/llamafactory/data/group_layout_augmentor.py new file mode 100644 index 0000000000000000000000000000000000000000..f083a5fdaa3726eb98a31d0340ea3303bca4dcec --- /dev/null +++ b/src/train_sft/src/llamafactory/data/group_layout_augmentor.py @@ -0,0 +1,371 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import random +import numpy as np +import re +from typing import Dict, List, Any, Optional, Tuple +from copy import deepcopy +import logging + +logger = logging.getLogger(__name__) + + +class GroupLayoutAugmentor: + """室内布局数据增强器，用于在data collator阶段动态增强样本""" + + def __init__(self, + augmentation_types: List[str], + augmentation_ratio: float = 0.3, + seed: int = 42): + """ + 初始化增强器 + + Args: + augmentation_types: 增强类型列表 + augmentation_ratio: 增强概率 (0.0-1.0) + seed: 随机种子 + """ + random.seed(seed) + np.random.seed(seed) + + self.augmentation_types = augmentation_types + self.augmentation_ratio = augmentation_ratio + + # 增强配置 + self.config = { + 'rotation_angles': [90, 180, 270], + 'scale_factors': [0.8, 0.9, 1.1, 1.2], + 'translation_range': 0.5, + 'object_variations': { + 'sofa': ['sectional sofa', 'loveseat', 'modern sofa', 'fabric sofa', 'leather sofa'], + 'table': ['dining table', 'coffee table', 'side table', 'round table', 'rectangular table'], + 'chair': ['armchair', 'office chair', 'dining chair', 'accent chair', 'lounge chair'], + 'bed': ['queen bed', 'king bed', 'twin bed', 'platform bed', 'sleigh bed'], + 'desk': ['office desk', 'writing desk', 'computer desk', 'standing desk'], + 'shelf': ['bookshelf', 'wall shelf', 'floating shelf', 'storage shelf'], + 'lamp': ['table lamp', 'floor lamp', 'desk lamp', 'pendant lamp'], + 'cabinet': ['storage cabinet', 'display cabinet', 'kitchen cabinet', 'wardrobe'], + }, + 'style_variations': [ + 'modern', 'contemporary', 'traditional', 'minimalist', + 'industrial', 'scandinavian', 'mid-century', 'rustic' + ], + 'color_variations': [ + 'white', 'black', 'gray', 'brown', 'beige', 'navy', + 'dark', 'light', 'warm', 'cool', 'neutral' + ] + } + + def should_augment(self) -> bool: + """判断是否应该对当前样本进行增强""" + return random.random() < self.augmentation_ratio + + def augment_sample(self, prompt_text: str, response_text: str) -> Tuple[str, str]: + """ + 对单个样本进行增强 + + Args: + prompt_text: 用户输入文本 + response_text: 助手回复文本 + + Returns: + 增强后的 (prompt_text, response_text) + """ + if not self.should_augment() or not self.augmentation_types: + return prompt_text, response_text + + try: + # 随机选择增强类型 + aug_type = random.choice(self.augmentation_types) + + if aug_type == 'geometric_transform': + return self._apply_geometric_transform(prompt_text, response_text) + elif aug_type == 'object_variation': + return self._apply_object_variation(prompt_text, response_text) + elif aug_type == 'style_variation': + return self._apply_style_variation(prompt_text, response_text) + elif aug_type == 'prompt_paraphrase': + return self._apply_prompt_paraphrase(prompt_text, response_text) + elif aug_type == 'layout_modification': + return self._apply_layout_modification(prompt_text, response_text) + else: + return prompt_text, response_text + + except Exception as e: + logger.warning(f"Data augmentation failed with {aug_type}: {e}") + return prompt_text, response_text + + def _apply_geometric_transform(self, prompt: str, response: str) -> Tuple[str, str]: + """应用几何变换""" + try: + # 从response中提取JSON + if '' in response and '' in response: + answer_start = response.find('') + len('') + answer_end = response.find('') + answer_json_str = response[answer_start:answer_end].strip() + + # 解析JSON + answer_obj = json.loads(answer_json_str) + + # 应用几何变换 + transform_type = random.choice(['rotation', 'scaling', 'translation']) + + if transform_type == 'rotation': + angle = random.choice(self.config['rotation_angles']) + answer_obj = self._rotate_layout(answer_obj, angle) + elif transform_type == 'scaling': + scale = random.choice(self.config['scale_factors']) + answer_obj = self._scale_layout(answer_obj, scale) + elif transform_type == 'translation': + offset = random.uniform(-self.config['translation_range'], + self.config['translation_range']) + answer_obj = self._translate_layout(answer_obj, offset) + + # 重构response + new_answer_json = json.dumps(answer_obj, ensure_ascii=False, separators=(',', ':')) + new_response = response[:answer_start] + new_answer_json + response[answer_end:] + + return prompt, new_response + + except Exception as e: + logger.debug(f"Geometric transform failed: {e}") + + return prompt, response + + def _apply_object_variation(self, prompt: str, response: str) -> Tuple[str, str]: + """应用对象变换""" + try: + new_prompt = prompt + new_response = response + + # 替换prompt中的对象描述 + for base_obj, variations in self.config['object_variations'].items(): + if base_obj.lower() in new_prompt.lower(): + replacement = random.choice(variations) + # 使用word boundary来避免部分匹配 + pattern = r'\b' + re.escape(base_obj) + r'\b' + new_prompt = re.sub(pattern, replacement, new_prompt, count=1, flags=re.IGNORECASE) + + # 替换response中的对象描述 + for base_obj, variations in self.config['object_variations'].items(): + if base_obj.lower() in new_response.lower(): + replacement = random.choice(variations) + pattern = r'\b' + re.escape(base_obj) + r'\b' + new_response = re.sub(pattern, replacement, new_response, count=1, flags=re.IGNORECASE) + + return new_prompt, new_response + + except Exception as e: + logger.debug(f"Object variation failed: {e}") + + return prompt, response + + def _apply_style_variation(self, prompt: str, response: str) -> Tuple[str, str]: + """应用风格变换""" + try: + style = random.choice(self.config['style_variations']) + color = random.choice(self.config['color_variations']) + + # 在prompt中添加风格要求 + style_requirement = f" Please use a {style} style with {color} tones." + new_prompt = prompt + style_requirement + + # 在response的thinking部分体现风格考虑 + new_response = response + if '' in response and '' in response: + think_start = response.find('') + len('') + think_end = response.find('') + think_content = response[think_start:think_end] + + style_thinking = f" I will incorporate {style} design principles with {color} color scheme throughout the layout." + new_think_content = think_content + style_thinking + + new_response = (response[:think_start] + + new_think_content + + response[think_end:]) + + return new_prompt, new_response + + except Exception as e: + logger.debug(f"Style variation failed: {e}") + + return prompt, response + + def _apply_prompt_paraphrase(self, prompt: str, response: str) -> Tuple[str, str]: + """应用提示词改写""" + try: + paraphrases = { + "design": ["create", "plan", "arrange", "layout", "organize"], + "room": ["space", "area", "interior", "environment"], + "furniture": ["furnishings", "pieces", "items", "objects"], + "layout": ["arrangement", "configuration", "setup", "design"], + "place": ["position", "locate", "situate", "arrange"], + } + + new_prompt = prompt + for original, alternatives in paraphrases.items(): + if original in new_prompt.lower(): + replacement = random.choice(alternatives) + pattern = r'\b' + re.escape(original) + r'\b' + new_prompt = re.sub(pattern, replacement, new_prompt, count=1, flags=re.IGNORECASE) + + return new_prompt, response + + except Exception as e: + logger.debug(f"Prompt paraphrase failed: {e}") + + return prompt, response + + def _apply_layout_modification(self, prompt: str, response: str) -> Tuple[str, str]: + """应用布局修改""" + try: + # 从response中提取JSON + if '' in response and '' in response: + answer_start = response.find('') + len('') + answer_end = response.find('') + answer_json_str = response[answer_start:answer_end].strip() + + # 解析JSON + answer_obj = json.loads(answer_json_str) + + # 应用布局修改 + modification_type = random.choice(['add_object', 'adjust_position']) + + if modification_type == 'add_object' and answer_obj.get('groups'): + self._add_decorative_object(answer_obj) + elif modification_type == 'adjust_position': + self._adjust_positions(answer_obj) + + # 重构response + new_answer_json = json.dumps(answer_obj, ensure_ascii=False, separators=(',', ':')) + new_response = response[:answer_start] + new_answer_json + response[answer_end:] + + return prompt, new_response + + except Exception as e: + logger.debug(f"Layout modification failed: {e}") + + return prompt, response + + def _rotate_layout(self, layout_data: Dict, angle_degrees: int) -> Dict: + """旋转布局""" + angle_rad = np.radians(angle_degrees) + cos_a, sin_a = np.cos(angle_rad), np.sin(angle_rad) + + layout_copy = deepcopy(layout_data) + + # 旋转房间轮廓 + if 'room_envelope' in layout_copy: + for bounds_key in ['bounds_top', 'bounds_bottom']: + if bounds_key in layout_copy['room_envelope']: + for point in layout_copy['room_envelope'][bounds_key]: + x, z = point[0], point[2] + point[0] = x * cos_a - z * sin_a + point[2] = x * sin_a + z * cos_a + + # 旋转对象位置 + for group in layout_copy.get('groups', []): + for obj in group.get('objects', []): + if 'pos' in obj and len(obj['pos']) >= 3: + x, z = obj['pos'][0], obj['pos'][2] + obj['pos'][0] = x * cos_a - z * sin_a + obj['pos'][2] = x * sin_a + z * cos_a + + # 简单的旋转四元数处理 + if 'rot' in obj and len(obj['rot']) >= 4: + # 围绕Y轴旋转 + qy_add = np.sin(angle_rad / 2) + qw_mult = np.cos(angle_rad / 2) + obj['rot'][1] += qy_add + obj['rot'][3] *= qw_mult + + return layout_copy + + def _scale_layout(self, layout_data: Dict, scale_factor: float) -> Dict: + """缩放布局""" + layout_copy = deepcopy(layout_data) + + # 缩放房间轮廓 + if 'room_envelope' in layout_copy: + for bounds_key in ['bounds_top', 'bounds_bottom']: + if bounds_key in layout_copy['room_envelope']: + for point in layout_copy['room_envelope'][bounds_key]: + point[0] *= scale_factor + point[2] *= scale_factor + + # 缩放对象位置和尺寸 + for group in layout_copy.get('groups', []): + for obj in group.get('objects', []): + if 'pos' in obj and len(obj['pos']) >= 3: + obj['pos'][0] *= scale_factor + obj['pos'][2] *= scale_factor + + if 'size' in obj and isinstance(obj['size'], list): + obj['size'] = [s * scale_factor for s in obj['size']] + + return layout_copy + + def _translate_layout(self, layout_data: Dict, offset: float) -> Dict: + """平移布局""" + layout_copy = deepcopy(layout_data) + + # 平移对象位置 + for group in layout_copy.get('groups', []): + for obj in group.get('objects', []): + if 'pos' in obj and len(obj['pos']) >= 3: + obj['pos'][0] += offset + obj['pos'][2] += offset + + return layout_copy + + def _add_decorative_object(self, layout_data: Dict) -> None: + """添加装饰性对象""" + if not layout_data.get('groups'): + return + + decorative_objects = [ + {"desc": "Table Lamp", "size": [0.3, 0.6, 0.3]}, + {"desc": "Floor Lamp", "size": [0.4, 1.8, 0.4]}, + {"desc": "Plant Pot", "size": [0.4, 0.8, 0.4]}, + {"desc": "Decorative Vase", "size": [0.25, 0.4, 0.25]}, + {"desc": "Picture Frame", "size": [0.3, 0.4, 0.05]}, + ] + + # 随机选择一个组添加对象 + group_idx = random.randint(0, len(layout_data['groups']) - 1) + new_object = random.choice(decorative_objects).copy() + + # 设置随机位置 + if layout_data['groups'][group_idx]['objects']: + existing_obj = layout_data['groups'][group_idx]['objects'][0] + new_object['pos'] = [ + existing_obj['pos'][0] + random.uniform(-1, 1), + 0.0, + existing_obj['pos'][2] + random.uniform(-1, 1) + ] + else: + new_object['pos'] = [random.uniform(-2, 2), 0.0, random.uniform(-2, 2)] + + new_object['rot'] = [0, 0, 0, 1] + layout_data['groups'][group_idx]['objects'].append(new_object) + + def _adjust_positions(self, layout_data: Dict) -> None: + """微调对象位置""" + for group in layout_data.get('groups', []): + for obj in group.get('objects', []): + if 'pos' in obj and len(obj['pos']) >= 3: + obj['pos'][0] += random.uniform(-0.3, 0.3) + obj['pos'][2] += random.uniform(-0.3, 0.3) diff --git a/src/train_sft/src/llamafactory/data/group_layout_augmentor_backup.py b/src/train_sft/src/llamafactory/data/group_layout_augmentor_backup.py new file mode 100644 index 0000000000000000000000000000000000000000..29b634bb0c9456a9b3a9c984e745972e1d51a7f5 --- /dev/null +++ b/src/train_sft/src/llamafactory/data/group_layout_augmentor_backup.py @@ -0,0 +1,708 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import random +import numpy as np +import re +from typing import Dict, List, Any, Optional, Tuple +from copy import deepcopy +import logging + +logger = logging.getLogger(__name__) + +# 可选依赖 +try: + from shapely.geometry import Polygon, box + HAS_SHAPELY = True +except ImportError: + HAS_SHAPELY = False + logger.warning("Shapely not available, some advanced augmentations will be disabled") + +try: + from scipy.spatial.transform import Rotation as R + HAS_SCIPY = True +except ImportError: + HAS_SCIPY = False + logger.warning("SciPy not available, quaternion rotation may be less accurate") + + +def rotate_around_y(point, angle_radians): + """围绕Y轴旋转点""" + rotation_matrix = np.array([ + [np.cos(angle_radians), 0, np.sin(angle_radians)], + [0, 1, 0], + [-np.sin(angle_radians), 0, np.cos(angle_radians)] + ]) + rot_point = np.dot(rotation_matrix, point).tolist() + return [round(elem, 2) for elem in rot_point] + + +def combine_quaternion_with_y_rot_for_global_rot(original_quat, angle_radians): + """将Y轴旋转与原始四元数组合""" + if HAS_SCIPY: + y_axis_rotation = R.from_euler('y', angle_radians).as_quat() + original_rotation = R.from_quat(original_quat) + combined_rotation = R.from_quat(y_axis_rotation) * original_rotation + return [round(elem, 5) for elem in combined_rotation.as_quat().tolist()] + else: + # 简化的四元数旋转 + qy_add = np.sin(angle_radians / 2) + qw_mult = np.cos(angle_radians / 2) + new_quat = original_quat.copy() + new_quat[1] += qy_add + new_quat[3] *= qw_mult + return [round(elem, 5) for elem in new_quat] + + +def rotate_obj(obj, angle_radians): + """旋转单个对象""" + obj["pos"] = rotate_around_y(obj["pos"], angle_radians) + obj["rot"] = combine_quaternion_with_y_rot_for_global_rot(obj["rot"], angle_radians) + + +def rotate_scenegraph(scene_data, angle_radians): + """旋转整个场景图""" + # 旋转房间轮廓 + for bounds_key in ["bounds_top", "bounds_bottom"]: + if bounds_key in scene_data.get("room_envelop", {}): + scene_data["room_envelop"][bounds_key] = [ + rotate_around_y(point, angle_radians) + for point in scene_data["room_envelop"][bounds_key] + ] + + # 旋转所有对象 + for group in scene_data.get("groups", []): + for obj in group.get("objects", []): + rotate_obj(obj, angle_radians) + + +def offset_bounds(scene_data, shift_amount): + """循环偏移房间边界点""" + room_envelop = scene_data.get("room_envelop", {}) + for bounds_key in ["bounds_top", "bounds_bottom"]: + if bounds_key in room_envelop and shift_amount != 0: + bounds = room_envelop[bounds_key] + room_envelop[bounds_key] = bounds[shift_amount:] + bounds[:shift_amount] + + +def get_2d_bbox(pos, size): + """获取对象的2D边界框""" + if not HAS_SHAPELY: + return None + + x, _, z = pos + width, _, depth = size + half_width, half_depth = width/2, depth/2 + return box(x - half_width, z - half_depth, x + half_width, z + half_depth) + + +def create_floor_plan_polygon(bounds_bottom): + """从底部边界创建地板多边形""" + if not HAS_SHAPELY or not bounds_bottom: + return None + + try: + # 提取X和Z坐标 + points_2d = [(point[0], point[2]) for point in bounds_bottom] + return Polygon(points_2d) + except: + return None + + +def perturb_value_with_bounds(value, bounds=None, min_delta=-0.02, max_delta=0.02): + """在给定范围内扰动数值""" + delta = np.random.uniform(min_delta, max_delta) + new_val = round(value + delta, 2) + + if bounds: + min_val, max_val = bounds + return np.clip(new_val, min_val, max_val) + + return new_val + + +def get_safe_perturbation(pos, size, floor_polygon, max_attempts=10): + """获取安全的位置和尺寸扰动""" + if not floor_polygon: + # 如果没有floor_polygon，直接进行小范围扰动 + pos_perturbed = pos.copy() + pos_perturbed[0] = perturb_value_with_bounds(pos[0]) + pos_perturbed[2] = perturb_value_with_bounds(pos[2]) + + size_perturbed = size.copy() + size_perturbed[0] = perturb_value_with_bounds(size[0]) + size_perturbed[2] = perturb_value_with_bounds(size[2]) + + return pos_perturbed, size_perturbed + + # 获取地板边界 + minx, minz, maxx, maxz = floor_polygon.bounds + + for i in range(max_attempts): + pos_perturbed = pos.copy() + pos_perturbed[0] = perturb_value_with_bounds(pos[0], bounds=(minx, maxx)) + pos_perturbed[2] = perturb_value_with_bounds(pos[2], bounds=(minz, maxz)) + + size_perturbed = size.copy() + size_perturbed[0] = perturb_value_with_bounds(size[0]) + size_perturbed[2] = perturb_value_with_bounds(size[2]) + + new_bbox = get_2d_bbox(pos_perturbed, size_perturbed) + if new_bbox and floor_polygon.contains(new_bbox): + return pos_perturbed, size_perturbed + + # 如果找不到有效扰动，返回原始值 + return pos, size + + +def perturb_scene(scene_data, floor_polygon): + """扰动场景中所有对象的位置和尺寸""" + for group in scene_data.get("groups", []): + for obj in group.get("objects", []): + new_pos, new_size = get_safe_perturbation( + obj["pos"], obj["size"], floor_polygon + ) + obj["pos"] = new_pos + obj["size"] = new_size + + +class GroupLayoutAugmentor: + """室内布局数据增强器，专门针对group_layout格式""" + + def __init__(self, + augmentation_types: List[str], + augmentation_ratio: float = 0.15, # 85%概率进行增强（与原系统一致） + seed: int = 42): + """ + 初始化增强器 + + Args: + augmentation_types: 增强类型列表 + augmentation_ratio: 增强概率 (0.0-1.0) + seed: 随机种子 + """ + random.seed(seed) + np.random.seed(seed) + + self.augmentation_types = augmentation_types + self.augmentation_ratio = augmentation_ratio + + def should_augment(self) -> bool: + """判断是否应该对当前样本进行增强""" + return random.random() < self.augmentation_ratio + + def augment_sample(self, prompt_text: str, response_text: str) -> Tuple[str, str]: + """ + 对单个样本进行增强 + + Args: + prompt_text: 用户输入文本 + response_text: 助手回复文本 + + Returns: + 增强后的 (prompt_text, response_text) + """ + # 85%概率不进行任何增强（与原系统保持一致） + if not self.should_augment(): + return prompt_text, response_text + + try: + # 从response中提取JSON数据 + if '' not in response_text or '' not in response_text: + return prompt_text, response_text + + answer_start = response_text.find('') + len('') + answer_end = response_text.find('') + answer_json_str = response_text[answer_start:answer_end].strip() + + # 解析JSON + layout_data = json.loads(answer_json_str) + layout_data_augmented = deepcopy(layout_data) + + # 应用增强序列（按照原系统的顺序） + self._apply_augmentation_sequence(layout_data_augmented) + + # 重构response + new_answer_json = json.dumps(layout_data_augmented, ensure_ascii=False, separators=(',', ':')) + new_response = response_text[:answer_start] + new_answer_json + response_text[answer_end:] + + return prompt_text, new_response + + except Exception as e: + logger.warning(f"Data augmentation failed: {e}") + return prompt_text, response_text + + def _apply_augmentation_sequence(self, layout_data: Dict) -> None: + """ + 应用完整的增强序列，基于原系统的增强流程 + """ + # (1) 随机旋转 (0, 90, 180, 270度) + angle_radians = np.radians(np.random.choice([0, 90, 180, 270])) + rotate_scenegraph(layout_data, angle_radians) + + # (2) 循环偏移房间边界 + if layout_data.get("room_envelop", {}).get("bounds_bottom"): + shift_amount = np.random.randint(0, len(layout_data["room_envelop"]["bounds_bottom"])) + offset_bounds(layout_data, shift_amount) + + # (3) 扰动对象位置和尺寸 + floor_polygon = None + if layout_data.get("room_envelop", {}).get("bounds_bottom"): + floor_polygon = create_floor_plan_polygon(layout_data["room_envelop"]["bounds_bottom"]) + perturb_scene(layout_data, floor_polygon) + + # (4) 随机重排组的顺序 + if layout_data.get("groups") and len(layout_data["groups"]) > 1: + random.shuffle(layout_data["groups"]) + + # (5) 随机重排每个组内对象的顺序 + for group in layout_data.get("groups", []): + if group.get("objects") and len(group["objects"]) > 1: + random.shuffle(group["objects"]) + + +def do_random_augm_on_sgs(prompt_text: str, response_text: str, augm_prob: float = 0.15) -> Tuple[str, str]: + """ + 兼容原系统的增强函数接口 + + Args: + prompt_text: 输入文本 + response_text: 输出文本 + augm_prob: 增强概率 + + Returns: + 增强后的 (prompt_text, response_text) + """ + # 使用所有可用的增强类型 + augmentation_types = ['full_sequence'] + augmentor = GroupLayoutAugmentor( + augmentation_types=augmentation_types, + augmentation_ratio=augm_prob, + seed=random.randint(0, 10000) # 使用随机种子 + ) + + return augmentor.augment_sample(prompt_text, response_text) + +import json +import random +import numpy as np +import re +from typing import Dict, List, Any, Optional, Tuple +from copy import deepcopy +import logging + +# 可选依赖 +try: + from scipy.spatial.transform import Rotation as R + HAS_SCIPY = True +except ImportError: + HAS_SCIPY = False + +try: + from shapely.geometry import Polygon, box + HAS_SHAPELY = True +except ImportError: + HAS_SHAPELY = False + +logger = logging.getLogger(__name__) + + +class GroupLayoutAugmentor: + """室内布局数据增强器，基于原始增强系统的高级实现""" + + def __init__(self, + augmentation_types: List[str], + augmentation_ratio: float = 0.85, # 与原系统保持一致 + seed: int = 42): + """ + 初始化增强器 + + Args: + augmentation_types: 增强类型列表 + augmentation_ratio: 增强概率 (0.0-1.0) + seed: 随机种子 + """ + random.seed(seed) + np.random.seed(seed) + + self.augmentation_types = augmentation_types + self.augmentation_ratio = augmentation_ratio + + # 增强配置 + self.config = { + 'rotation_angles': [90, 180, 270], + 'scale_factors': [0.8, 0.9, 1.1, 1.2], + 'translation_range': 0.5, + 'perturbation_range': 0.02, # 小范围扰动 + } + + def should_augment(self) -> bool: + """判断是否应该对当前样本进行增强""" + return random.random() < self.augmentation_ratio + + def augment_sample(self, prompt_text: str, response_text: str) -> Tuple[str, str]: + """ + 对单个样本进行高级增强，基于原始系统的do_random_augm_on_sgs方法 + + Args: + prompt_text: 用户输入文本 + response_text: 助手回复文本 + + Returns: + 增强后的 (prompt_text, response_text) + """ + # 15%概率不进行任何增强（与原系统保持一致） + if not self.should_augment(): + return prompt_text, response_text + + try: + # 从response中提取JSON数据 + if '' not in response_text or '' not in response_text: + return prompt_text, response_text + + answer_start = response_text.find('') + len('') + answer_end = response_text.find('') + answer_json_str = response_text[answer_start:answer_end].strip() + + # 解析JSON + layout_data = json.loads(answer_json_str) + layout_data_augmented = deepcopy(layout_data) + + # 应用增强序列（按照原系统的顺序） + self._apply_augmentation_sequence(layout_data_augmented) + + # 重构response + new_answer_json = json.dumps(layout_data_augmented, ensure_ascii=False, separators=(',', ':')) + new_response = response_text[:answer_start] + new_answer_json + response_text[answer_end:] + + return prompt_text, new_response # 不修改prompt + + except Exception as e: + logger.warning(f"Data augmentation failed: {e}") + return prompt_text, response_text + + def _apply_augmentation_sequence(self, layout_data: Dict) -> None: + """ + 应用完整的增强序列，基于配置的增强类型 + """ + # 根据配置的增强类型应用相应的变换 + for aug_type in self.augmentation_types: + if random.random() < 0.8: # 80%概率应用每种增强 + if aug_type == 'rotation': + angle_radians = np.radians(np.random.choice(self.config['rotation_angles'])) + self._rotate_scenegraph(layout_data, angle_radians) + elif aug_type == 'perturbation': + self._perturb_scene_objects(layout_data) + elif aug_type == 'group_reorder': + self._reorder_groups(layout_data) + elif aug_type == 'object_reorder': + self._reorder_objects_in_groups(layout_data) + elif aug_type == 'bounds_shift': + self._offset_room_bounds(layout_data) + + def _rotate_scenegraph(self, layout_data: Dict, angle_radians: float) -> None: + """ + 旋转整个场景图，基于原系统的rotate_scenegraph函数 + """ + # 旋转房间轮廓 + if 'room_envelope' in layout_data: + for bounds_key in ['bounds_top', 'bounds_bottom']: + if bounds_key in layout_data['room_envelope']: + for point in layout_data['room_envelope'][bounds_key]: + rotated_point = self._rotate_around_y(point, angle_radians) + point[0], point[1], point[2] = rotated_point + + # 旋转组中的对象 + for group in layout_data.get('groups', []): + for obj in group.get('objects', []): + self._rotate_object(obj, angle_radians) + + def _rotate_around_y(self, point: List[float], angle_radians: float) -> List[float]: + """ + 围绕Y轴旋转点，基于原系统的rotate_around_y函数 + """ + rotation_matrix = np.array([ + [np.cos(angle_radians), 0, np.sin(angle_radians)], + [0, 1, 0], + [-np.sin(angle_radians), 0, np.cos(angle_radians)] + ]) + rot_point = np.dot(rotation_matrix, point).tolist() + return [round(elem, 2) for elem in rot_point] + + def _rotate_object(self, obj: Dict, angle_radians: float) -> None: + """ + 旋转单个对象，基于原系统的rotate_obj函数 + """ + if 'pos' in obj and len(obj['pos']) >= 3: + obj['pos'] = self._rotate_around_y(obj['pos'], angle_radians) + + if 'rot' in obj and len(obj['rot']) >= 4: + obj['rot'] = self._combine_quaternion_with_y_rotation(obj['rot'], angle_radians) + + def _combine_quaternion_with_y_rotation(self, original_quat: List[float], angle_radians: float) -> List[float]: + """ + 组合四元数与Y轴旋转，基于原系统的combine_quaternion_with_y_rot_for_global_rot函数 + """ + if not HAS_SCIPY: + # 如果没有scipy，使用简化的四元数处理 + qy_add = np.sin(angle_radians / 2) + qw_mult = np.cos(angle_radians / 2) + new_quat = original_quat.copy() + new_quat[1] += qy_add + new_quat[3] *= qw_mult + return [round(elem, 5) for elem in new_quat] + + try: + y_axis_rotation = R.from_euler('y', angle_radians).as_quat() + original_rotation = R.from_quat(original_quat) + combined_rotation = R.from_quat(y_axis_rotation) * original_rotation + return [round(elem, 5) for elem in combined_rotation.as_quat().tolist()] + except Exception: + # 如果四元数操作失败，返回原始值 + return original_quat + + def _offset_room_bounds(self, layout_data: Dict) -> None: + """ + 对房间边界进行循环位移，基于原系统的offset_bounds函数 + """ + if 'room_envelope' not in layout_data: + return + + bounds_bottom = layout_data['room_envelope'].get('bounds_bottom', []) + if not bounds_bottom: + return + + shift_amount = np.random.randint(0, len(bounds_bottom)) + + if shift_amount != 0: + for bounds_key in ['bounds_top', 'bounds_bottom']: + if bounds_key in layout_data['room_envelope']: + bounds = layout_data['room_envelope'][bounds_key] + layout_data['room_envelope'][bounds_key] = bounds[shift_amount:] + bounds[:shift_amount] + + def _perturb_scene_objects(self, layout_data: Dict) -> None: + """ + 扰动场景中对象的位置和尺寸，基于原系统的perturb_scene函数 + """ + # 创建房间多边形用于约束检查 + floor_polygon = self._create_floor_polygon(layout_data) + if not floor_polygon: + return + + # 扰动所有组中的对象 + for group in layout_data.get('groups', []): + for obj in group.get('objects', []): + self._perturb_object(obj, floor_polygon) + + def _create_floor_polygon(self, layout_data: Dict) -> Optional[Any]: + """ + 从房间边界创建地板多边形 + """ + if not HAS_SHAPELY: + # 如果没有shapely，返回简化的边界框 + try: + if 'room_envelope' not in layout_data: + return None + + bounds_bottom = layout_data['room_envelope'].get('bounds_bottom', []) + if len(bounds_bottom) < 3: + return None + + # 返回简化的边界框 [minx, minz, maxx, maxz] + x_coords = [point[0] for point in bounds_bottom] + z_coords = [point[2] for point in bounds_bottom] + return { + 'bounds': (min(x_coords), min(z_coords), max(x_coords), max(z_coords)), + 'type': 'simple_bbox' + } + except Exception: + return None + + try: + if 'room_envelope' not in layout_data: + return None + + bounds_bottom = layout_data['room_envelope'].get('bounds_bottom', []) + if len(bounds_bottom) < 3: + return None + + # 提取x,z坐标（忽略y坐标） + coords = [(point[0], point[2]) for point in bounds_bottom] + return Polygon(coords) + except Exception: + return None + + def _perturb_object(self, obj: Dict, floor_polygon: Any) -> None: + """ + 扰动单个对象的位置和尺寸，基于原系统的get_safe_perturbation函数 + """ + if 'pos' not in obj or 'size' not in obj: + return + + original_pos = obj['pos'].copy() + original_size = obj['size'].copy() + + # 尝试找到安全的扰动 + for attempt in range(10): # 最多尝试10次 + new_pos, new_size = self._get_safe_perturbation( + original_pos, original_size, floor_polygon, obj.get('desc', '') + ) + + # 检查新位置是否在房间内 + if self._is_object_within_bounds(new_pos, new_size, floor_polygon): + obj['pos'] = new_pos + obj['size'] = new_size + break + + def _get_safe_perturbation(self, pos: List[float], size: List[float], + floor_polygon: Any, desc: str) -> Tuple[List[float], List[float]]: + """ + 获取安全的位置和尺寸扰动 + """ + try: + if floor_polygon is None: + return pos, size + + if not HAS_SHAPELY and floor_polygon.get('type') == 'simple_bbox': + # 使用简化的边界框 + minx, minz, maxx, maxz = floor_polygon['bounds'] + elif HAS_SHAPELY: + minx, minz, maxx, maxz = floor_polygon.bounds + else: + return pos, size + + pos_perturbed = pos.copy() + pos_perturbed[0] = self._perturb_value_with_bounds( + pos[0], (minx, maxx), -self.config['perturbation_range'], self.config['perturbation_range'] + ) + pos_perturbed[2] = self._perturb_value_with_bounds( + pos[2], (minz, maxz), -self.config['perturbation_range'], self.config['perturbation_range'] + ) + + size_perturbed = size.copy() + if len(size_perturbed) >= 1: + size_perturbed[0] = self._perturb_value_with_bounds( + size[0], (0.1, maxx-minx), -self.config['perturbation_range'], self.config['perturbation_range'] + ) + if len(size_perturbed) >= 3: + size_perturbed[2] = self._perturb_value_with_bounds( + size[2], (0.1, maxz-minz), -self.config['perturbation_range'], self.config['perturbation_range'] + ) + + return pos_perturbed, size_perturbed + except Exception: + return pos, size + + def _perturb_value_with_bounds(self, value: float, bounds: Tuple[float, float], + min_delta: float = -0.02, max_delta: float = 0.02) -> float: + """ + 在给定边界内扰动值，基于原系统的perturb_value_with_bounds函数 + """ + min_val, max_val = bounds + delta = np.random.uniform(min_delta, max_delta) + new_val = round(value + delta, 2) + return np.clip(new_val, min_val, max_val) + + def _is_object_within_bounds(self, pos: List[float], size: List[float], + floor_polygon: Any) -> bool: + """ + 检查对象是否在房间边界内 + """ + try: + if len(pos) < 3 or len(size) < 3: + return True # 如果数据不完整，假设有效 + + if floor_polygon is None: + return True + + if not HAS_SHAPELY and floor_polygon.get('type') == 'simple_bbox': + # 使用简化的边界框检查 + minx, minz, maxx, maxz = floor_polygon['bounds'] + x, z = pos[0], pos[2] + width, depth = size[0], size[2] + + return (minx <= x - width/2 and x + width/2 <= maxx and + minz <= z - depth/2 and z + depth/2 <= maxz) + elif HAS_SHAPELY: + bbox = self._get_2d_bbox(pos, size) + return floor_polygon.contains(bbox) + else: + return True + except Exception: + return True + + def _get_2d_bbox(self, pos: List[float], size: List[float]): + """ + 获取对象的2D边界框，基于原系统的get_2d_bbox函数 + """ + if not HAS_SHAPELY: + # 返回简化的边界框信息 + x, z = pos[0], pos[2] + width, depth = size[0], size[2] + return { + 'type': 'simple_bbox', + 'bounds': [x - width/2, z - depth/2, x + width/2, z + depth/2] + } + else: + try: + from shapely.geometry import box + x, z = pos[0], pos[2] + width, depth = size[0], size[2] + half_width, half_depth = width/2, depth/2 + return box(x - half_width, z - half_depth, x + half_width, z + half_depth) + except ImportError: + # Fallback to simple bbox + x, z = pos[0], pos[2] + width, depth = size[0], size[2] + return { + 'type': 'simple_bbox', + 'bounds': [x - width/2, z - depth/2, x + width/2, z + depth/2] + } + + def _reorder_groups(self, layout_data: Dict) -> None: + """ + 随机重排序组的顺序 + """ + if 'groups' in layout_data and len(layout_data['groups']) > 1: + random.shuffle(layout_data['groups']) + + def _reorder_objects_in_groups(self, layout_data: Dict) -> None: + """ + 随机重排序每个组内对象的顺序 + """ + for group in layout_data.get('groups', []): + if 'objects' in group and len(group['objects']) > 1: + random.shuffle(group['objects']) + + def _offset_room_bounds(self, layout_data: Dict) -> None: + """ + 对房间边界应用小的偏移 + """ + if 'room_envelop' in layout_data: + room_envelop = layout_data['room_envelop'] + + # 生成小的偏移量 + offset_range = 0.1 + x_offset = random.uniform(-offset_range, offset_range) + z_offset = random.uniform(-offset_range, offset_range) + + # 应用偏移到边界 + if 'bounds_top' in room_envelop: + room_envelop['bounds_top'][0] += x_offset + room_envelop['bounds_top'][2] += z_offset + + if 'bounds_bottom' in room_envelop: + room_envelop['bounds_bottom'][0] += x_offset + room_envelop['bounds_bottom'][2] += z_offset diff --git a/src/train_sft/src/llamafactory/data/group_layout_augmentor_new.py b/src/train_sft/src/llamafactory/data/group_layout_augmentor_new.py new file mode 100644 index 0000000000000000000000000000000000000000..7e74e2508c7e5de43fbb92f41b047333f3c0fb7c --- /dev/null +++ b/src/train_sft/src/llamafactory/data/group_layout_augmentor_new.py @@ -0,0 +1,348 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import random +import logging +import numpy as np +from typing import Dict, List, Any, Optional, Tuple +from copy import deepcopy +from scipy.spatial.transform import Rotation as R +from shapely.geometry import Polygon, box + +logger = logging.getLogger(__name__) + + +class GroupLayoutAugmentor: + """室内布局数据增强器，用于在data collator阶段动态增强样本""" + + def __init__(self, + augmentation_types: List[str], + augmentation_ratio: float = 0.85, + seed: int = 42): + """ + 初始化增强器 + + Args: + augmentation_types: 增强类型列表 + augmentation_ratio: 增强概率 (0.0-1.0) + seed: 随机种子 + """ + random.seed(seed) + np.random.seed(seed) + + self.augmentation_types = augmentation_types + self.augmentation_ratio = augmentation_ratio + + # 支持的增强类型 + self.supported_augmentations = { + 'random_group_shuffle', # 随机交换group之间的顺序 + 'random_object_shuffle', # 随机交换group内object的顺序 + 'geometric_rotation', # 几何旋转 + 'bounds_offset', # 边界偏移 + 'position_perturbation' # 位置扰动 + } + + def should_augment(self) -> bool: + """判断是否应该对当前样本进行增强""" + return random.random() < self.augmentation_ratio + + def augment_sample(self, prompt_text: str, response_text: str) -> Tuple[str, str]: + """ + 对单个样本进行增强 + + Args: + prompt_text: 用户输入文本 + response_text: 助手回复文本（包含） + + Returns: + 增强后的 (prompt_text, response_text) + """ + if not self.should_augment() or not self.augmentation_types: + return prompt_text, response_text + + try: + # 从response中提取中的JSON + answer_json = self._extract_answer_json(response_text) + if answer_json is None: + return prompt_text, response_text + + # 应用随机选择的增强方法 + augmented_json = self._apply_augmentations(answer_json) + + # 重新构建response + new_response = self._replace_answer_json(response_text, augmented_json) + + return prompt_text, new_response + + except Exception as e: + logger.warning(f"数据增强失败: {e}") + return prompt_text, response_text + + def _extract_answer_json(self, response_text: str) -> Optional[Dict]: + """从response中提取包裹的JSON""" + try: + start_tag = '' + end_tag = '' + + if start_tag not in response_text or end_tag not in response_text: + return None + + start_idx = response_text.find(start_tag) + len(start_tag) + end_idx = response_text.find(end_tag) + + json_str = response_text[start_idx:end_idx].strip() + return json.loads(json_str) + + except Exception as e: + logger.debug(f"提取answer JSON失败: {e}") + return None + + def _replace_answer_json(self, response_text: str, new_json: Dict) -> str: + """替换response中包裹的JSON""" + try: + start_tag = '' + end_tag = '' + + start_idx = response_text.find(start_tag) + len(start_tag) + end_idx = response_text.find(end_tag) + + new_json_str = json.dumps(new_json, ensure_ascii=False, separators=(',', ':')) + + return (response_text[:start_idx] + + new_json_str + + response_text[end_idx:]) + + except Exception as e: + logger.debug(f"替换answer JSON失败: {e}") + return response_text + + def _apply_augmentations(self, layout_data: Dict) -> Dict: + """应用数据增强方法""" + augmented_data = deepcopy(layout_data) + + # 获取可用的增强方法 + available_methods = [aug for aug in self.augmentation_types + if aug in self.supported_augmentations] + + if not available_methods: + return augmented_data + + # 随机选择1-4个增强方法 + num_methods = random.randint(1, min(4, len(available_methods))) + selected_methods = random.sample(available_methods, num_methods) + + # group交换和object交换不能同时使用 + if 'random_group_shuffle' in selected_methods and 'random_object_shuffle' in selected_methods: + # 随机保留其中一个 + keep_method = random.choice(['random_group_shuffle', 'random_object_shuffle']) + selected_methods = [m for m in selected_methods if m not in ['random_group_shuffle', 'random_object_shuffle']] + selected_methods.append(keep_method) + + # 应用选中的增强方法 + for method in selected_methods: + if method == 'random_group_shuffle': + self._shuffle_groups(augmented_data) + elif method == 'random_object_shuffle': + self._shuffle_objects_in_groups(augmented_data) + elif method == 'geometric_rotation': + self._apply_geometric_rotation(augmented_data) + elif method == 'bounds_offset': + self._apply_bounds_offset(augmented_data) + elif method == 'position_perturbation': + self._apply_position_perturbation(augmented_data) + + return augmented_data + + def _shuffle_groups(self, layout_data: Dict) -> None: + """随机交换两个group的顺序""" + if 'groups' in layout_data and isinstance(layout_data['groups'], list) and len(layout_data['groups']) >= 2: + groups = layout_data['groups'] + # 随机选择两个不同的group进行交换 + idx1, idx2 = random.sample(range(len(groups)), 2) + groups[idx1], groups[idx2] = groups[idx2], groups[idx1] + + def _shuffle_objects_in_groups(self, layout_data: Dict) -> None: + """随机选择1-2个group，对其内部的object进行shuffle""" + if 'groups' not in layout_data or not isinstance(layout_data['groups'], list): + return + + # 找出有多个object的group + valid_groups = [] + for i, group in enumerate(layout_data['groups']): + if (isinstance(group, dict) and 'objects' in group and + isinstance(group['objects'], list) and len(group['objects']) > 1): + valid_groups.append(i) + + if not valid_groups: + return + + # 随机选择1-2个group进行shuffle + num_groups_to_shuffle = random.randint(1, min(2, len(valid_groups))) + groups_to_shuffle = random.sample(valid_groups, num_groups_to_shuffle) + + for group_idx in groups_to_shuffle: + random.shuffle(layout_data['groups'][group_idx]['objects']) + + def _apply_geometric_rotation(self, layout_data: Dict) -> None: + """应用几何旋转变换""" + # 随机选择旋转角度 (0, 90, 180, 270度) + angle_degrees = random.choice([0, 90, 180, 270]) + if angle_degrees == 0: + return + + angle_radians = np.radians(angle_degrees) + + # 旋转房间边界 + if 'room_envelope' in layout_data and isinstance(layout_data['room_envelope'], dict): + self._rotate_bounds(layout_data['room_envelope'], angle_radians) + + # 旋转所有对象 + if 'groups' in layout_data and isinstance(layout_data['groups'], list): + for group in layout_data['groups']: + if isinstance(group, dict) and 'objects' in group and isinstance(group['objects'], list): + for obj in group['objects']: + if isinstance(obj, dict): + self._rotate_object(obj, angle_radians) + + def _rotate_bounds(self, room_envelope: Dict, angle_radians: float) -> None: + """旋转房间边界""" + for bounds_key in ['bounds_top', 'bounds_bottom']: + if bounds_key in room_envelope and isinstance(room_envelope[bounds_key], list): + rotated_bounds = [] + for point in room_envelope[bounds_key]: + if isinstance(point, list) and len(point) >= 3: + rotated_point = self._rotate_point_around_y(point, angle_radians) + rotated_bounds.append(rotated_point) + room_envelope[bounds_key] = rotated_bounds + + def _rotate_object(self, obj: Dict, angle_radians: float) -> None: + """旋转单个对象""" + if 'pos' in obj and isinstance(obj['pos'], list) and len(obj['pos']) >= 3: + obj['pos'] = self._rotate_point_around_y(obj['pos'], angle_radians) + + if 'rot' in obj and isinstance(obj['rot'], list) and len(obj['rot']) >= 4: + obj['rot'] = self._combine_quaternion_with_y_rotation(obj['rot'], angle_radians) + + def _rotate_point_around_y(self, point: List[float], angle_radians: float) -> List[float]: + """绕Y轴旋转点""" + rotation_matrix = np.array([ + [np.cos(angle_radians), 0, np.sin(angle_radians)], + [0, 1, 0], + [-np.sin(angle_radians), 0, np.cos(angle_radians)] + ]) + rotated_point = np.dot(rotation_matrix, point).tolist() + return [round(elem, 2) for elem in rotated_point] + + def _combine_quaternion_with_y_rotation(self, original_quat: List[float], angle_radians: float) -> List[float]: + """组合原始四元数与Y轴旋转""" + y_axis_rotation = R.from_euler('y', angle_radians).as_quat() + original_rotation = R.from_quat(original_quat) + combined_rotation = R.from_quat(y_axis_rotation) * original_rotation + return [round(elem, 5) for elem in combined_rotation.as_quat().tolist()] + + def _apply_bounds_offset(self, layout_data: Dict) -> None: + """应用边界偏移（循环移位）""" + if 'room_envelope' not in layout_data or not isinstance(layout_data['room_envelope'], dict): + return + + room_envelope = layout_data['room_envelope'] + + for bounds_key in ['bounds_top', 'bounds_bottom']: + if bounds_key in room_envelope and isinstance(room_envelope[bounds_key], list) and len(room_envelope[bounds_key]) > 1: + bounds = room_envelope[bounds_key] + shift_amount = random.randint(0, len(bounds) - 1) + if shift_amount > 0: + room_envelope[bounds_key] = bounds[shift_amount:] + bounds[:shift_amount] + + def _apply_position_perturbation(self, layout_data: Dict) -> None: + """应用位置扰动""" + # 首先创建floor polygon用于约束 + floor_polygon = self._create_floor_polygon(layout_data) + if floor_polygon is None: + return + + if 'groups' in layout_data and isinstance(layout_data['groups'], list): + for group in layout_data['groups']: + if isinstance(group, dict) and 'objects' in group and isinstance(group['objects'], list): + for obj in group['objects']: + if isinstance(obj, dict): + self._perturb_object_position(obj, floor_polygon) + + def _create_floor_polygon(self, layout_data: Dict) -> Optional[Polygon]: + """从房间边界创建floor polygon""" + try: + if ('room_envelope' in layout_data and + isinstance(layout_data['room_envelope'], dict) and + 'bounds_bottom' in layout_data['room_envelope'] and + isinstance(layout_data['room_envelope']['bounds_bottom'], list)): + + bounds = layout_data['room_envelope']['bounds_bottom'] + # 提取x,z坐标 (忽略y坐标) + points_2d = [] + for point in bounds: + if isinstance(point, list) and len(point) >= 3: + points_2d.append((point[0], point[2])) + + if len(points_2d) >= 3: # 至少需要3个点构成多边形 + return Polygon(points_2d) + except Exception as e: + logger.debug(f"创建floor polygon失败: {e}") + return None + + def _perturb_object_position(self, obj: Dict, floor_polygon: Polygon, max_attempts: int = 10) -> None: + """扰动对象位置，确保仍在floor polygon内""" + if ('pos' not in obj or not isinstance(obj['pos'], list) or len(obj['pos']) < 3 or + 'size' not in obj or not isinstance(obj['size'], list) or len(obj['size']) < 3): + return + + original_pos = obj['pos'].copy() + original_size = obj['size'].copy() + + # 获取floor边界 + minx, minz, maxx, maxz = floor_polygon.bounds + + for _ in range(max_attempts): + # 扰动位置和尺寸 + new_pos = original_pos.copy() + new_pos[0] = self._perturb_value_with_bounds(original_pos[0], (minx, maxx)) + new_pos[2] = self._perturb_value_with_bounds(original_pos[2], (minz, maxz)) + + new_size = original_size.copy() + new_size[0] = self._perturb_value_with_bounds(original_size[0], (0.1, 5.0)) # 合理的尺寸范围 + new_size[2] = self._perturb_value_with_bounds(original_size[2], (0.1, 5.0)) + + # 检查新的边界框是否在floor polygon内 + new_bbox = self._get_2d_bbox(new_pos, new_size) + if floor_polygon.contains(new_bbox): + obj['pos'] = new_pos + obj['size'] = new_size + return + + # 如果找不到有效扰动，保持原值 + + def _perturb_value_with_bounds(self, value: float, bounds: Tuple[float, float], + min_delta: float = -0.02, max_delta: float = 0.02) -> float: + """在指定范围内扰动数值""" + min_val, max_val = bounds + delta = np.random.uniform(min_delta, max_delta) + new_val = round(value + delta, 2) + return np.clip(new_val, min_val, max_val) + + def _get_2d_bbox(self, pos: List[float], size: List[float]) -> box: + """获取2D边界框""" + x, _, z = pos + width, _, depth = size + half_width, half_depth = width/2, depth/2 + return box(x - half_width, z - half_depth, x + half_width, z + half_depth) diff --git a/src/train_sft/src/llamafactory/data/group_layout_collator.py b/src/train_sft/src/llamafactory/data/group_layout_collator.py new file mode 100644 index 0000000000000000000000000000000000000000..5c3a30a68953166c9fa606adf16fce2506c6dc27 --- /dev/null +++ b/src/train_sft/src/llamafactory/data/group_layout_collator.py @@ -0,0 +1,248 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Literal, Optional, List +from collections import defaultdict + +from transformers import DataCollatorForSeq2Seq +from ..extras.constants import IGNORE_INDEX +from .group_layout_augmentor_new import GroupLayoutAugmentor +from .processor.processor_utils import infer_seqlen + +if TYPE_CHECKING: + from transformers import PreTrainedTokenizer, ProcessorMixin + from .template import Template + from ..hparams import DataArguments + + +@dataclass +class GroupLayoutDataCollator(DataCollatorForSeq2Seq): + """ + 专门用于Group Layout数据的Data Collator + 支持在collation阶段进行动态数据增强和tokenization + """ + + template: "Template" + processor: Optional["ProcessorMixin"] = None + data_args: Optional["DataArguments"] = None + block_diag_attn: bool = False + attn_implementation: Literal["eager", "sdpa", "flash_attention_2"] = "eager" + compute_dtype: torch.dtype = torch.float32 + + def __post_init__(self): + super().__post_init__() + + # 初始化数据增强器 + self.augmentor = None + if (self.data_args and + getattr(self.data_args, 'enable_data_augmentation', False)): + + augmentation_types = getattr(self.data_args, 'augmentation_types', '').split(',') + augmentation_types = [t.strip() for t in augmentation_types if t.strip()] + + if augmentation_types: + self.augmentor = GroupLayoutAugmentor( + augmentation_types=augmentation_types, + augmentation_ratio=getattr(self.data_args, 'augmentation_ratio', 0.85), + seed=getattr(self.data_args, 'augmentation_seed', 42) + ) + + def __call__(self, features: List[dict[str, Any]]) -> dict[str, torch.Tensor]: + """ + 处理batch数据：应用数据增强 -> tokenization -> 构建batch + """ + batch_input_ids = [] + batch_attention_masks = [] + batch_labels = [] + + for feature in features: + # 获取原始对话数据 + conversation = feature.get("conversations") + if not conversation: + continue + + # 应用数据增强（如果启用且在训练模式） + augmented_conversation = self._apply_augmentation_if_needed(conversation) + + # 将对话转换为input_ids和labels + input_ids, labels = self._encode_conversation(augmented_conversation) + + if input_ids and labels: + batch_input_ids.append(torch.tensor(input_ids, dtype=torch.long)) + batch_labels.append(torch.tensor(labels, dtype=torch.long)) + # attention_mask由DataCollatorForSeq2Seq自动生成 + + if not batch_input_ids: + return {} + + # 构建features格式，供父类处理 + formatted_features = [] + for input_ids, labels in zip(batch_input_ids, batch_labels): + formatted_features.append({ + "input_ids": input_ids, + "labels": labels, + }) + + # 调用父类进行padding等处理 + batch = super().__call__(formatted_features) + + # 处理4D attention mask + if self.block_diag_attn and self.attn_implementation != "flash_attention_2": + from .collator import prepare_4d_attention_mask + batch["attention_mask"] = prepare_4d_attention_mask( + batch["attention_mask"], self.compute_dtype + ) + + # 类型转换 + for key, value in batch.items(): + if torch.is_tensor(value) and torch.is_floating_point(value): + batch[key] = value.to(self.compute_dtype) + + return batch + + def _apply_augmentation_if_needed(self, conversation: dict[str, Any]) -> dict[str, Any]: + """根据需要应用数据增强""" + if not self.augmentor or not self._is_training_mode(): + return conversation + + try: + # 提取prompt和response + prompt_messages = conversation.get("prompt", []) + response_messages = conversation.get("response", []) + + if not prompt_messages or not response_messages: + return conversation + + # 构建完整的prompt文本 + prompt_text = self._messages_to_text(prompt_messages) + response_text = response_messages[0].get("content", "") if response_messages else "" + + # 应用数据增强 + augmented_prompt, augmented_response = self.augmentor.augment_sample( + prompt_text, response_text + ) + + # 如果有变化，更新conversation + if augmented_prompt != prompt_text or augmented_response != response_text: + new_conversation = conversation.copy() + + # 更新prompt (通常只有user message需要更新) + if augmented_prompt != prompt_text: + new_prompt = [] + for msg in prompt_messages: + if msg.get("role") == "user": + new_msg = msg.copy() + new_msg["content"] = augmented_prompt + new_prompt.append(new_msg) + else: + new_prompt.append(msg) + new_conversation["prompt"] = new_prompt + + # 更新response + if augmented_response != response_text: + new_response = [] + for msg in response_messages: + new_msg = msg.copy() + new_msg["content"] = augmented_response + new_response.append(new_msg) + new_conversation["response"] = new_response + + return new_conversation + + except Exception as e: + print(f"数据增强失败: {e}") + + return conversation + + def _messages_to_text(self, messages: List[dict[str, str]]) -> str: + """将messages转换为文本""" + texts = [] + for msg in messages: + content = msg.get("content", "") + if content: + texts.append(content) + return " ".join(texts) + + def _is_training_mode(self) -> bool: + """检查是否在训练模式""" + # 可以通过多种方式检测训练模式 + # 这里使用一个简单的方法，实际使用时可能需要调整 + import torch + return torch.is_grad_enabled() + + def _encode_conversation(self, conversation: dict[str, Any]) -> tuple[List[int], List[int]]: + """将对话编码为input_ids和labels""" + try: + prompt_messages = conversation.get("prompt", []) + response_messages = conversation.get("response", []) + system_message = conversation.get("system") + tools = conversation.get("tools") + + # 处理多模态输入 + images = conversation.get("images", []) + videos = conversation.get("videos", []) + audios = conversation.get("audios", []) + + # 使用template进行编码 + messages = self.template.mm_plugin.process_messages( + prompt_messages + response_messages, images, videos, audios, self.processor + ) + + input_ids, labels = self.template.mm_plugin.process_token_ids( + [], [], images, videos, audios, self.tokenizer, self.processor + ) + + encoded_pairs = self.template.encode_multiturn( + self.tokenizer, messages, system_message, tools + ) + + total_length = len(input_ids) + (1 if self.template.efficient_eos else 0) + + for turn_idx, (source_ids, target_ids) in enumerate(encoded_pairs): + if total_length >= self.data_args.cutoff_len: + break + + source_len, target_len = infer_seqlen( + len(source_ids), len(target_ids), + self.data_args.cutoff_len - total_length + ) + + source_ids = source_ids[:source_len] + target_ids = target_ids[:target_len] + total_length += source_len + target_len + + # 设置labels + if self.data_args.train_on_prompt: + source_label = source_ids + elif self.template.efficient_eos and turn_idx != 0: + source_label = [self.tokenizer.eos_token_id] + [IGNORE_INDEX] * (source_len - 1) + else: + source_label = [IGNORE_INDEX] * source_len + + target_label = target_ids + + input_ids += source_ids + target_ids + labels += source_label + target_label + + if self.template.efficient_eos: + input_ids += [self.tokenizer.eos_token_id] + labels += [self.tokenizer.eos_token_id] + + return input_ids, labels + + except Exception as e: + print(f"编码对话失败: {e}") + return [], [] diff --git a/src/train_sft/src/llamafactory/data/loader.py b/src/train_sft/src/llamafactory/data/loader.py new file mode 100644 index 0000000000000000000000000000000000000000..accb5ad55e9d8b24ff26dc7534f2a4ae936400fb --- /dev/null +++ b/src/train_sft/src/llamafactory/data/loader.py @@ -0,0 +1,379 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import TYPE_CHECKING, Literal, Optional, Union + +import numpy as np +from datasets import Dataset, load_dataset, load_from_disk +import csv + +from ..extras import logging +from ..extras.constants import FILEEXT2TYPE +from ..extras.misc import check_version, has_tokenized_data +from .converter import align_dataset +from .data_utils import get_dataset_module, merge_dataset, read_cloud_json, split_dataset +from .parser import get_dataset_list +from .processor import ( + FeedbackDatasetProcessor, + PackedSupervisedDatasetProcessor, + PairwiseDatasetProcessor, + PretrainDatasetProcessor, + SupervisedDatasetProcessor, + UnsupervisedDatasetProcessor, +) + + +if TYPE_CHECKING: + from datasets import Dataset, IterableDataset + from transformers import PreTrainedTokenizer, ProcessorMixin, Seq2SeqTrainingArguments + + from ..hparams import DataArguments, ModelArguments + from .data_utils import DatasetModule + from .parser import DatasetAttr + from .processor import DatasetProcessor + from .template import Template + + +logger = logging.get_logger(__name__) + + +def _load_single_dataset( + dataset_attr: "DatasetAttr", + model_args: "ModelArguments", + data_args: "DataArguments", + training_args: "Seq2SeqTrainingArguments", +) -> Union["Dataset", "IterableDataset"]: + r"""Load a single dataset and aligns it to the standard format.""" + logger.info_rank0(f"Loading dataset {dataset_attr}...") + data_path, data_name, data_dir, data_files = None, None, None, None + if dataset_attr.load_from in ["hf_hub", "ms_hub", "om_hub"]: + data_path = dataset_attr.dataset_name + data_name = dataset_attr.subset + data_dir = dataset_attr.folder + + elif dataset_attr.load_from == "script": + data_path = os.path.join(data_args.dataset_dir, dataset_attr.dataset_name) + data_name = dataset_attr.subset + data_dir = dataset_attr.folder + + elif dataset_attr.load_from == "cloud_file": + data_path = dataset_attr.dataset_name + + elif dataset_attr.load_from == "file": + data_files = [] + local_path = os.path.join(data_args.dataset_dir, dataset_attr.dataset_name) + if os.path.isdir(local_path): # is directory + for file_name in os.listdir(local_path): + data_files.append(os.path.join(local_path, file_name)) + elif os.path.isfile(local_path): # is file + data_files.append(local_path) + else: + raise ValueError(f"File {local_path} not found.") + + data_path = FILEEXT2TYPE.get(os.path.splitext(data_files[0])[-1][1:], None) + if data_path is None: + raise ValueError("Allowed file types: {}.".format(",".join(FILEEXT2TYPE.keys()))) + + if any(data_path != FILEEXT2TYPE.get(os.path.splitext(data_file)[-1][1:], None) for data_file in data_files): + raise ValueError("File types should be identical.") + else: + raise NotImplementedError(f"Unknown load type: {dataset_attr.load_from}.") + + if dataset_attr.load_from == "ms_hub": + check_version("modelscope>=1.14.0", mandatory=True) + from modelscope import MsDataset # type: ignore + from modelscope.utils.config_ds import MS_DATASETS_CACHE # type: ignore + + cache_dir = model_args.cache_dir or MS_DATASETS_CACHE + dataset = MsDataset.load( + dataset_name=data_path, + subset_name=data_name, + data_dir=data_dir, + data_files=data_files, + split=dataset_attr.split, + cache_dir=cache_dir, + token=model_args.ms_hub_token, + use_streaming=data_args.streaming, + ) + if isinstance(dataset, MsDataset): + dataset = dataset.to_hf_dataset() + + elif dataset_attr.load_from == "om_hub": + check_version("openmind>=0.8.0", mandatory=True) + from openmind import OmDataset # type: ignore + from openmind.utils.hub import OM_DATASETS_CACHE # type: ignore + + cache_dir = model_args.cache_dir or OM_DATASETS_CACHE + dataset = OmDataset.load_dataset( + path=data_path, + name=data_name, + data_dir=data_dir, + data_files=data_files, + split=dataset_attr.split, + cache_dir=cache_dir, + token=model_args.om_hub_token, + streaming=data_args.streaming, + ) + elif dataset_attr.load_from == "cloud_file": + dataset = Dataset.from_list(read_cloud_json(data_path), split=dataset_attr.split) + else: + if data_path == "json" and dataset_attr.load_from == "file" and len(data_files) == 1: + # custom: load a big json dict with a specific top-level field (e.g., "data") + import json as _json + + with open(data_files[0], "r", encoding="utf-8") as f: + obj = _json.load(f) + data_list = obj.get(dataset_attr.field, None) if isinstance(obj, dict) else None + if isinstance(data_list, list): + dataset = Dataset.from_list(data_list, split=dataset_attr.split) + else: + dataset = load_dataset( + path=data_path, + name=data_name, + data_dir=data_dir, + data_files=data_files, + split=dataset_attr.split, + cache_dir=model_args.cache_dir, + token=model_args.hf_hub_token, + num_proc=data_args.preprocessing_num_workers, + trust_remote_code=model_args.trust_remote_code, + streaming=data_args.streaming and dataset_attr.load_from != "file", + ) + else: + dataset = load_dataset( + path=data_path, + name=data_name, + data_dir=data_dir, + data_files=data_files, + split=dataset_attr.split, + cache_dir=model_args.cache_dir, + token=model_args.hf_hub_token, + num_proc=data_args.preprocessing_num_workers, + trust_remote_code=model_args.trust_remote_code, + streaming=data_args.streaming and dataset_attr.load_from != "file", + ) + if data_args.streaming and dataset_attr.load_from == "file": + dataset = dataset.to_iterable_dataset(num_shards=training_args.dataloader_num_workers) + + # Apply split filtering - either by split_map CSV or by split field in data + target_split = getattr(dataset_attr, "split", "train").lower() + + if getattr(dataset_attr, "split_map", None): + # 使用外部CSV文件做split映射 + split_csv = dataset_attr.split_map + if not os.path.isabs(split_csv): + split_csv = os.path.join(data_args.dataset_dir, split_csv) + id2split: dict[str, str] = {} + with open(split_csv, "r", encoding="utf-8") as f: + reader = csv.reader(f) + for row in reader: + if not row: continue + # Expect format: id,split + key, sp = row[0].strip(), row[1].strip().lower() + id2split[key] = sp + + def _matches_split_csv(ex): + return ex["split"] == target_split + + dataset = dataset.filter(_matches_split_csv) + print(f"[split_map] target split: {target_split}, {len(dataset)} examples after filtering") + + elif target_split: + # 直接使用数据中的split字段过滤 + def _matches_split_field(ex): + return ex.get("split", "") == target_split + + original_len = len(dataset) + dataset = dataset.filter(_matches_split_field) + print(f"[split field] target split: '{target_split}', filtered {original_len} -> {len(dataset)} examples") + + return align_dataset(dataset, dataset_attr, data_args, training_args) + + +def _get_merged_dataset( + dataset_names: Optional[list[str]], + model_args: "ModelArguments", + data_args: "DataArguments", + training_args: "Seq2SeqTrainingArguments", + stage: Literal["pt", "sft", "rm", "ppo", "kto"], + return_dict: bool = False, +) -> Optional[Union["Dataset", "IterableDataset", dict[str, "Dataset"]]]: + r"""Return the merged datasets in the standard format.""" + if dataset_names is None: + return None + + datasets = {} + for dataset_name, dataset_attr in zip(dataset_names, get_dataset_list(dataset_names, data_args.dataset_dir)): + if (stage == "rm" and dataset_attr.ranking is False) or (stage != "rm" and dataset_attr.ranking is True): + raise ValueError("The dataset is not applicable in the current training stage.") + + datasets[dataset_name] = _load_single_dataset(dataset_attr, model_args, data_args, training_args) + + if return_dict: + return datasets + else: + return merge_dataset(list(datasets.values()), data_args, seed=training_args.seed) + + +def _get_dataset_processor( + data_args: "DataArguments", + stage: Literal["pt", "sft", "rm", "ppo", "kto"], + template: "Template", + tokenizer: "PreTrainedTokenizer", + processor: Optional["ProcessorMixin"], + do_generate: bool = False, +) -> "DatasetProcessor": + r"""Return the corresponding dataset processor.""" + if stage == "pt": + dataset_processor_class = PretrainDatasetProcessor + elif stage == "sft" and not do_generate: + # 检查是否启用了数据增强，如果启用则使用RawDatasetProcessor + if getattr(data_args, 'enable_data_augmentation', False): + from .processor import RawDatasetProcessor + dataset_processor_class = RawDatasetProcessor + elif data_args.packing: + if data_args.neat_packing: # hack datasets to have int32 attention mask + from datasets.arrow_writer import OptimizedTypedSequence, TypedSequence + + def __init__(self, data, **kwargs): + return TypedSequence.__init__( + self, + data, + type=kwargs.pop("type", None), + try_type=kwargs.pop("try_type", None), + optimized_int_type=kwargs.pop("optimized_int_type", None), + ) + + OptimizedTypedSequence.__init__ = __init__ + dataset_processor_class = PackedSupervisedDatasetProcessor + else: + dataset_processor_class = SupervisedDatasetProcessor + + elif stage == "rm": + dataset_processor_class = PairwiseDatasetProcessor + elif stage == "kto": + dataset_processor_class = FeedbackDatasetProcessor + else: + dataset_processor_class = UnsupervisedDatasetProcessor + + return dataset_processor_class(template=template, tokenizer=tokenizer, processor=processor, data_args=data_args) + + +def _get_preprocessed_dataset( + dataset: Optional[Union["Dataset", "IterableDataset"]], + data_args: "DataArguments", + training_args: "Seq2SeqTrainingArguments", + stage: Literal["pt", "sft", "rm", "ppo", "kto"], + template: "Template", + tokenizer: "PreTrainedTokenizer", + processor: Optional["ProcessorMixin"] = None, + is_eval: bool = False, +) -> Optional[Union["Dataset", "IterableDataset"]]: + r"""Preprocesses the dataset, including format checking and tokenization.""" + if dataset is None: + return None + + dataset_processor = _get_dataset_processor( + data_args, stage, template, tokenizer, processor, do_generate=(training_args.predict_with_generate and is_eval) + ) + column_names = list(next(iter(dataset)).keys()) + kwargs = {} + if not data_args.streaming: + kwargs = dict( + num_proc=data_args.preprocessing_num_workers, + load_from_cache_file=(not data_args.overwrite_cache) or (training_args.local_process_index != 0), + desc="Running tokenizer on dataset", + ) + + dataset = dataset.map( + dataset_processor.preprocess_dataset, + batched=True, + batch_size=data_args.preprocessing_batch_size, + remove_columns=column_names, + **kwargs, + ) + + if training_args.should_log: + try: + print("eval example:" if is_eval else "training example:") + dataset_processor.print_data_example(next(iter(dataset))) + except StopIteration: + if stage == "pt": + raise RuntimeError("Cannot find sufficient samples, consider increasing dataset size.") + else: + raise RuntimeError("Cannot find valid samples, check `data/README.md` for the data format.") + + return dataset + + +def get_dataset( + template: "Template", + model_args: "ModelArguments", + data_args: "DataArguments", + training_args: "Seq2SeqTrainingArguments", + stage: Literal["pt", "sft", "rm", "ppo", "kto"], + tokenizer: "PreTrainedTokenizer", + processor: Optional["ProcessorMixin"] = None, +) -> "DatasetModule": + r"""Get the train dataset and optionally gets the evaluation dataset.""" + # Load tokenized dataset if path exists + if data_args.tokenized_path is not None: + if has_tokenized_data(data_args.tokenized_path): + logger.warning_rank0("Loading dataset from disk will ignore other data arguments.") + tokenized_data = load_from_disk(data_args.tokenized_path) + dataset_module = get_dataset_module(tokenized_data) + if data_args.streaming: + dataset_module["train_dataset"] = dataset_module["train_dataset"].to_iterable_dataset() + + logger.info_rank0(f"Loaded tokenized dataset from {data_args.tokenized_path}.") + return dataset_module + + if data_args.streaming: + raise ValueError("Turn off `streaming` when saving dataset to disk.") + + # Load and preprocess dataset + with training_args.main_process_first(desc="load dataset", local=(not data_args.data_shared_file_system)): + dataset = _get_merged_dataset(data_args.dataset, model_args, data_args, training_args, stage) + eval_dataset = _get_merged_dataset( + data_args.eval_dataset, + model_args, + data_args, + training_args, + stage, + return_dict=data_args.eval_on_each_dataset, + ) + + with training_args.main_process_first(desc="pre-process dataset", local=(not data_args.data_shared_file_system)): + dataset = _get_preprocessed_dataset( + dataset, data_args, training_args, stage, template, tokenizer, processor, is_eval=False + ) + if isinstance(eval_dataset, dict): + for eval_name, eval_data in eval_dataset.items(): + eval_dataset[eval_name] = _get_preprocessed_dataset( + eval_data, data_args, training_args, stage, template, tokenizer, processor, is_eval=True + ) + else: + eval_dataset = _get_preprocessed_dataset( + eval_dataset, data_args, training_args, stage, template, tokenizer, processor, is_eval=True + ) + + dataset_dict = split_dataset(dataset, eval_dataset, data_args, seed=training_args.seed) + if data_args.tokenized_path is not None: # save tokenized dataset to disk + if training_args.should_save: + dataset_dict.save_to_disk(data_args.tokenized_path) + logger.info_rank0(f"Tokenized dataset is saved at {data_args.tokenized_path}.") + logger.info_rank0(f"Please launch the training with `tokenized_path: {data_args.tokenized_path}`.") + + return get_dataset_module(dataset_dict) diff --git a/src/train_sft/src/llamafactory/data/mm_plugin.py b/src/train_sft/src/llamafactory/data/mm_plugin.py new file mode 100644 index 0000000000000000000000000000000000000000..be8cea9d6ca8480de2e7172a5f4023e583f54b23 --- /dev/null +++ b/src/train_sft/src/llamafactory/data/mm_plugin.py @@ -0,0 +1,1912 @@ +# Copyright 2025 HuggingFace Inc. and the LlamaFactory team. +# +# This code is inspired by the HuggingFace's Transformers library. +# https://github.com/huggingface/transformers/blob/v4.40.0/src/transformers/models/llava/processing_llava.py +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import inspect +import math +import os +import re +from copy import deepcopy +from dataclasses import dataclass +from io import BytesIO +from typing import TYPE_CHECKING, BinaryIO, Literal, Optional, TypedDict, Union + +import numpy as np +import torch +from transformers.image_utils import get_image_size, is_valid_image, to_numpy_array +from transformers.models.mllama.processing_mllama import ( + convert_sparse_cross_attention_mask_to_dense, + get_cross_attention_token_mask, +) +from typing_extensions import override + +from ..extras.constants import AUDIO_PLACEHOLDER, IGNORE_INDEX, IMAGE_PLACEHOLDER, VIDEO_PLACEHOLDER +from ..extras.packages import ( + is_librosa_available, + is_pillow_available, + is_pyav_available, + is_transformers_version_greater_than, +) + + +if is_librosa_available(): + import librosa + + +if is_pillow_available(): + from PIL import Image + from PIL.Image import Image as ImageObject + + +if is_pyav_available(): + import av + + +if is_transformers_version_greater_than("4.52.0"): + from transformers.image_utils import make_flat_list_of_images + from transformers.video_utils import make_batched_videos +else: + from transformers.image_utils import make_batched_videos, make_flat_list_of_images + + +if TYPE_CHECKING: + from av.stream import Stream + from numpy.typing import NDArray + from transformers import PreTrainedTokenizer, ProcessorMixin + from transformers.feature_extraction_sequence_utils import SequenceFeatureExtractor + from transformers.image_processing_utils import BaseImageProcessor + + class EncodedImage(TypedDict): + path: Optional[str] + bytes: Optional[bytes] + + ImageInput = Union[str, bytes, EncodedImage, BinaryIO, ImageObject] + VideoInput = Union[str, BinaryIO, list[list[ImageInput]]] + AudioInput = Union[str, BinaryIO, NDArray] + + class MMProcessor(ProcessorMixin): + patch_size: int + image_seq_length: int + num_additional_image_tokens: int + vision_feature_select_strategy: Literal["default", "full"] + + def _get_number_of_features(self, orig_height: int, orig_width: int, height: int, width: int) -> int: + pass + + +def _get_paligemma_token_type_ids(imglens: list[int], seqlens: list[int], processor: "MMProcessor") -> list[list[int]]: + r"""Get paligemma token type ids for computing loss. + + It is slightly different with the original token type ids where the prompt part is 0. + + Returns: + batch_token_type_ids: shape (batch_size, seq_length) + + """ + batch_token_type_ids = [] + for imglen, seqlen in zip(imglens, seqlens): + image_seqlen = imglen * processor.image_seq_length + batch_token_type_ids.append([0] * image_seqlen + [1] * (seqlen - image_seqlen)) + + return batch_token_type_ids + + +def _get_gemma3_token_type_ids(batch_ids: list[list[int]], processor: "MMProcessor"): + r"""Get gemma3 token type ids for computing loss. + + Returns: + batch_token_type_ids: shape (batch_size, seq_length) + + """ + image_token_id: int = getattr(processor, "image_token_id") + batch_token_type_ids = [] + for token_ids in batch_ids: + token_ids = np.array(token_ids) + token_type_ids = np.zeros_like(token_ids) + token_type_ids[token_ids == image_token_id] = 1 + batch_token_type_ids.append(token_type_ids.tolist()) + + return batch_token_type_ids + + +def _make_batched_images(images: list["ImageObject"], imglens: list[int]) -> list[list["ImageObject"]]: + r"""Make nested list of images.""" + batch_images = [] + for imglen in imglens: + batch_images.append(images[:imglen]) + images = images[imglen:] + + return batch_images + + +def _check_video_is_nested_images(video: "VideoInput") -> bool: + r"""Check if the video is nested images.""" + return isinstance(video, list) and all(isinstance(frame, (str, BinaryIO, dict)) for frame in video) + + +@dataclass +class MMPluginMixin: + image_token: Optional[str] + video_token: Optional[str] + audio_token: Optional[str] + expand_mm_tokens: bool = True + + def _validate_input( + self, + processor: Optional["MMProcessor"], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + ) -> None: + r"""Validate if this model accepts the input modalities.""" + image_processor: BaseImageProcessor = getattr(processor, "image_processor", None) + video_processor: BaseImageProcessor = getattr( + processor, "video_processor", getattr(processor, "image_processor", None) + ) + feature_extractor: SequenceFeatureExtractor = getattr(processor, "feature_extractor", None) + if len(images) != 0 and self.image_token is None: + raise ValueError( + "This model does not support image input. Please check whether the correct `template` is used." + ) + + if len(videos) != 0 and self.video_token is None: + raise ValueError( + "This model does not support video input. Please check whether the correct `template` is used." + ) + + if len(audios) != 0 and self.audio_token is None: + raise ValueError( + "This model does not support audio input. Please check whether the correct `template` is used." + ) + + if self.image_token is not None and processor is None: + raise ValueError("Processor was not found, please check and update your model file.") + + if self.image_token is not None and image_processor is None: + raise ValueError("Image processor was not found, please check and update your model file.") + + if self.video_token is not None and video_processor is None: + raise ValueError("Video processor was not found, please check and update your model file.") + + if self.audio_token is not None and feature_extractor is None: + raise ValueError("Audio feature extractor was not found, please check and update your model file.") + + def _validate_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + ): + r"""Validate if the number of images, videos and audios match the number of placeholders in messages.""" + num_image_tokens, num_video_tokens, num_audio_tokens = 0, 0, 0 + for message in messages: + num_image_tokens += message["content"].count(IMAGE_PLACEHOLDER) + num_video_tokens += message["content"].count(VIDEO_PLACEHOLDER) + num_audio_tokens += message["content"].count(AUDIO_PLACEHOLDER) + + if len(images) != num_image_tokens: + raise ValueError( + f"The number of images does not match the number of {IMAGE_PLACEHOLDER} tokens in {messages}." + ) + + if len(videos) != num_video_tokens: + raise ValueError( + f"The number of videos does not match the number of {VIDEO_PLACEHOLDER} tokens in {messages}." + ) + + if len(audios) != num_audio_tokens: + raise ValueError( + f"The number of audios does not match the number of {AUDIO_PLACEHOLDER} tokens in {messages}." + ) + + def _preprocess_image( + self, image: "ImageObject", image_max_pixels: int, image_min_pixels: int, **kwargs + ) -> "ImageObject": + r"""Pre-process a single image.""" + if (image.width * image.height) > image_max_pixels: + resize_factor = math.sqrt(image_max_pixels / (image.width * image.height)) + width, height = int(image.width * resize_factor), int(image.height * resize_factor) + image = image.resize((width, height)) + + if (image.width * image.height) < image_min_pixels: + resize_factor = math.sqrt(image_min_pixels / (image.width * image.height)) + width, height = int(image.width * resize_factor), int(image.height * resize_factor) + image = image.resize((width, height)) + + if image.mode != "RGB": + image = image.convert("RGB") + + return image + + def _get_video_sample_indices( + self, video_stream: "Stream", video_fps: float, video_maxlen: int, **kwargs + ) -> list[int]: + r"""Compute video sample indices according to fps.""" + total_frames = video_stream.frames + if total_frames == 0: # infinite video + return np.linspace(0, video_maxlen - 1, video_maxlen).astype(np.int32) + + sample_frames = max(1, math.floor(float(video_stream.duration * video_stream.time_base) * video_fps)) + sample_frames = min(total_frames, video_maxlen, sample_frames) + return np.linspace(0, total_frames - 1, sample_frames).astype(np.int32) + + def _regularize_images(self, images: list["ImageInput"], **kwargs) -> dict[str, list["ImageObject"]]: + r"""Regularize images to avoid error. Including reading and pre-processing.""" + results = [] + for image in images: + if isinstance(image, (str, BinaryIO)): + image = Image.open(image) + elif isinstance(image, bytes): + image = Image.open(BytesIO(image)) + elif isinstance(image, dict): + if image["bytes"] is not None: + image = Image.open(BytesIO(image["bytes"])) + else: + image = Image.open(image["path"]) + + if not isinstance(image, ImageObject): + raise ValueError(f"Expect input is a list of images, but got {type(image)}.") + + results.append(self._preprocess_image(image, **kwargs)) + + return {"images": results} + + def _regularize_videos(self, videos: list["VideoInput"], **kwargs) -> dict[str, list[list["ImageObject"]]]: + r"""Regularizes videos to avoid error. Including reading, resizing and converting.""" + results = [] + for video in videos: + frames: list[ImageObject] = [] + if _check_video_is_nested_images(video): + for frame in video: + if not is_valid_image(frame) and not isinstance(frame, dict) and not os.path.exists(frame): + raise ValueError("Invalid image found in video frames.") + frames = video + else: + container = av.open(video, "r") + video_stream = next(stream for stream in container.streams if stream.type == "video") + sample_indices = self._get_video_sample_indices(video_stream, **kwargs) + container.seek(0) + for frame_idx, frame in enumerate(container.decode(video_stream)): + if frame_idx in sample_indices: + frames.append(frame.to_image()) + + frames = self._regularize_images(frames, **kwargs)["images"] + results.append(frames) + + return {"videos": results} + + def _regularize_audios( + self, audios: list["AudioInput"], sampling_rate: float, **kwargs + ) -> dict[str, Union[list["NDArray"], list[float]]]: + r"""Regularizes audios to avoid error. Including reading and resampling.""" + results, sampling_rates = [], [] + for audio in audios: + if not isinstance(audio, np.ndarray): + audio, sampling_rate = librosa.load(audio, sr=sampling_rate) + + results.append(audio) + sampling_rates.append(sampling_rate) + + return {"audios": results, "sampling_rates": sampling_rates} + + def _get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: "MMProcessor", + imglens: Optional[list[int]] = None, + ) -> dict[str, "torch.Tensor"]: + r"""Process visual inputs. + + Returns: (llava and paligemma) + pixel_values: tensor with shape (B, C, H, W) + + Returns: (qwen2-vl) + pixel_values: tensor with shape (num_patches, patch_dim) + image_grid_thw: tensor with shape (num_images, 3), where the three numbers are time, width, height + where num_patches == torch.prod(image_grid_thw) + + Returns: (mllama) + pixel_values: tensor with shape + (batch_size, max_num_images, max_image_tiles, channels, tile_height, tile_width) + For example, (2, 1, 4, 3, 560, 560). + aspect_ratio_ids: tensor with shape (batch_size, max_num_images). For example, (2, 1). + aspect_ratio_mask: tensor with shape (batch_size, max_num_images, max_image_tiles). For example, (2, 1, 4). + num_tiles: List[List[int]] with shape (batch_size, num_images_in_batch). For example, (2, 1). + + """ + mm_inputs = {} + if len(images) != 0: + image_processor: BaseImageProcessor = getattr(processor, "image_processor", None) + images = self._regularize_images( + images, + image_max_pixels=getattr(processor, "image_max_pixels", 768 * 768), + image_min_pixels=getattr(processor, "image_min_pixels", 32 * 32), + )["images"] + if imglens is not None: # if imglens are provided, make batched images + images = _make_batched_images(images, imglens) + + image_processor_kwargs = {} + if getattr(processor, "image_do_pan_and_scan", False): # gemma3 image processor + image_processor_kwargs.update( + { + "do_pan_and_scan": True, + "pan_and_scan_min_crop_size": 256, + "pan_and_scan_max_num_crops": 4, + "pan_and_scan_min_ratio_to_activate": 1.2, + } + ) + + mm_inputs.update(image_processor(images, return_tensors="pt", **image_processor_kwargs)) + + if len(videos) != 0: + video_processor: BaseImageProcessor = getattr( + processor, "video_processor", getattr(processor, "image_processor", None) + ) + videos = self._regularize_videos( + videos, + image_max_pixels=getattr(processor, "video_max_pixels", 256 * 256), + image_min_pixels=getattr(processor, "video_min_pixels", 16 * 16), + video_fps=getattr(processor, "video_fps", 2.0), + video_maxlen=getattr(processor, "video_maxlen", 128), + )["videos"] + if "videos" in inspect.signature(video_processor.preprocess).parameters: # for qwen2_vl and video_llava + mm_inputs.update(video_processor(images=None, videos=videos, return_tensors="pt")) + else: # for llava_next_video + mm_inputs.update(video_processor(videos, return_tensors="pt")) + + if len(audios) != 0: + feature_extractor: SequenceFeatureExtractor = getattr(processor, "feature_extractor", None) + audios = self._regularize_audios( + audios, + sampling_rate=getattr(processor, "audio_sampling_rate", 16000), + )["audios"] + mm_inputs.update( + feature_extractor( + audios, + sampling_rate=getattr(processor, "audio_sampling_rate", 16000), + return_attention_mask=True, + padding="max_length", + return_tensors="pt", + ) + ) + mm_inputs["feature_attention_mask"] = mm_inputs.pop("attention_mask", None) # prevent conflicts + + return mm_inputs + + +@dataclass +class BasePlugin(MMPluginMixin): + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + r"""Pre-process input messages before tokenization for VLMs.""" + self._validate_input(processor, images, videos, audios) + return messages + + def process_token_ids( + self, + input_ids: list[int], + labels: Optional[list[int]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + tokenizer: "PreTrainedTokenizer", + processor: Optional["MMProcessor"], + ) -> tuple[list[int], Optional[list[int]]]: + r"""Pre-process token ids after tokenization for VLMs.""" + self._validate_input(processor, images, videos, audios) + return input_ids, labels + + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + r"""Build batched multimodal inputs for VLMs. + + Arguments: + images: a list of image inputs, shape (num_images,) + videos: a list of video inputs, shape (num_videos,) + audios: a list of audio inputs, shape (num_audios,) + imglens: number of images in each sample, shape (batch_size,) + vidlens: number of videos in each sample, shape (batch_size,) + audlens: number of audios in each sample, shape (batch_size,) + batch_ids: token ids of input samples, shape (batch_size, seq_len) + processor: a processor for pre-processing images and videos + + """ + self._validate_input(processor, images, videos, audios) + return self._get_mm_inputs(images, videos, audios, processor) + + +@dataclass +class Gemma3Plugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens = 0 + messages = deepcopy(messages) + boi_token: str = getattr(processor, "boi_token") + full_image_sequence: str = getattr(processor, "full_image_sequence") + image_str = full_image_sequence if self.expand_mm_tokens else boi_token + + do_pan_and_scan: bool = getattr(processor, "image_do_pan_and_scan", False) + if do_pan_and_scan: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + if do_pan_and_scan: + image_placeholder_str = ( + "Here is the original image {{image}} and here are some crops to help you see better " + + " ".join(["{{image}}"] * mm_inputs["num_crops"][0][num_image_tokens]) + ) + else: + image_placeholder_str = "{{image}}" + + content = content.replace(IMAGE_PLACEHOLDER, image_placeholder_str, 1) + num_image_tokens += 1 + + message["content"] = content.replace("{{image}}", image_str) + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + mm_inputs.pop("num_crops", None) + mm_inputs["token_type_ids"] = _get_gemma3_token_type_ids(batch_ids, processor) + return mm_inputs + + +class Gemma3nPlugin(Gemma3Plugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + messages = deepcopy(messages) + boi_token: str = getattr(processor, "boi_token") + boa_token: str = getattr(processor, "boa_token") + full_image_sequence: str = getattr(processor, "full_image_sequence") + full_audio_sequence: str = getattr(processor, "full_audio_sequence") + image_str = full_image_sequence if self.expand_mm_tokens else boi_token + audio_str = full_audio_sequence if self.expand_mm_tokens else boa_token + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + content = content.replace(IMAGE_PLACEHOLDER, image_str, 1) + + while AUDIO_PLACEHOLDER in content: + content = content.replace(AUDIO_PLACEHOLDER, audio_str, 1) + + message["content"] = content + + return messages + + +@dataclass +class InternVLPlugin(BasePlugin): + @override + def _get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: "ProcessorMixin", + **kwargs, + ) -> dict[str, "torch.Tensor"]: + image_processor: BaseImageProcessor = getattr(processor, "image_processor") + image_processor_kwargs = {} + if getattr(processor, "crop_to_patches", False): + image_processor_kwargs.update( + { + "crop_to_patches": True, + "max_patches": 12, + "min_patches": 1, + } + ) + + mm_inputs = {} + image_video_patches = [] + + if len(images) != 0: + images = self._regularize_images( + images, + image_max_pixels=getattr(processor, "image_max_pixels", 1024 * 1024), + image_min_pixels=getattr(processor, "image_min_pixels", 32 * 32), + )["images"] + + if len(videos) != 0: + videos = self._regularize_videos( + videos, + image_max_pixels=getattr(processor, "video_max_pixels", 256 * 256), + image_min_pixels=getattr(processor, "video_min_pixels", 16 * 16), + video_fps=getattr(processor, "video_fps", 2.0), + video_maxlen=getattr(processor, "video_maxlen", 128), + )["videos"] + + if len(images) != 0: + images = make_flat_list_of_images(images) + image_inputs = image_processor(images=images, return_tensors="pt", **image_processor_kwargs) + image_num_patches = image_inputs.pop("num_patches") + image_pixel_values = image_inputs.pop("pixel_values") + image_num_patches_indices = np.cumsum(image_num_patches) + + if len(videos) != 0: + videos = make_batched_videos(videos) + num_frames_per_video = [len(video) for video in videos] + patch_indices = np.cumsum(num_frames_per_video) + image_processor_kwargs["crop_to_patches"] = False + video_inputs = image_processor(images=videos, return_tensors="pt", **image_processor_kwargs) + video_num_patches = video_inputs.pop("num_patches") + video_pixel_values = video_inputs.pop("pixel_values") + video_num_patches_indices = np.cumsum(video_num_patches) + + # NOT SUPPORT IMAGE VIDEO INTERLEAVED + if len(images) != 0 and image_pixel_values is not None: + for i in range(len(images)): + start_index = image_num_patches_indices[i - 1] if i > 0 else 0 + end_index = image_num_patches_indices[i] + image_video_patches.append(image_pixel_values[start_index:end_index]) + + if len(videos) != 0 and video_pixel_values is not None: + patch_indices_with_prefix = [0] + list(patch_indices) + for i in range(len(videos)): + current_patch_index = patch_indices_with_prefix[i] + end_patch_index = patch_indices_with_prefix[i + 1] + start_index = video_num_patches_indices[current_patch_index - 1] if i > 0 else 0 + end_index = video_num_patches_indices[end_patch_index - 1] + image_video_patches.append(video_pixel_values[start_index:end_index]) + + if len(images) != 0 or len(videos) != 0: + mm_inputs["pixel_values"] = torch.cat(image_video_patches, dim=0) + + if len(images) != 0: + mm_inputs.update({"image_num_patches": image_num_patches}) + + if len(videos) != 0: + mm_inputs.update({"video_patch_indices": patch_indices}) + mm_inputs.update({"video_num_patches": video_num_patches}) + + return mm_inputs + + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["ProcessorMixin"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens, num_video_tokens = 0, 0 + image_seqlen = getattr(processor, "image_seq_length") if self.expand_mm_tokens else 1 + messages = deepcopy(messages) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + + image_pixel_patch_list = mm_inputs.get("image_num_patches") # pathes of images + video_num_patches = mm_inputs.get("video_num_patches") # all patches for frames of videos + video_patch_indices = mm_inputs.get("video_patch_indices") # num frames of per video + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + content = content.replace( + IMAGE_PLACEHOLDER, + f"{'' * image_seqlen * image_pixel_patch_list[num_image_tokens]}", + 1, + ) + num_image_tokens += 1 + + while VIDEO_PLACEHOLDER in content: + current_patch_index = video_patch_indices[num_video_tokens - 1] if num_video_tokens > 0 else 0 + end_patch_index = video_patch_indices[num_video_tokens] + num_patches = list(video_num_patches[current_patch_index:end_patch_index]) + video_replaced_prompt = "\n".join( + f"Frame{i + 1}: {'' * image_seqlen * num_patches[i]}" + for i in range(len(num_patches)) + ) + content = content.replace(VIDEO_PLACEHOLDER, video_replaced_prompt, 1) + num_video_tokens += 1 + + message["content"] = content + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["ProcessorMixin"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + mm_inputs.pop("image_num_patches", None) + mm_inputs.pop("video_patch_indices", None) + mm_inputs.pop("video_num_patches", None) + return mm_inputs + + +class KimiVLPlugin(BasePlugin): + @override + def process_messages(self, messages, images, videos, audios, processor): + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + image_grid_hws = mm_inputs.get("image_grid_hws", []) + else: + image_grid_hws = [None] * len(images) + + num_image_tokens = 0 + image_processor: BaseImageProcessor = getattr(processor, "image_processor") + merge_length = math.prod(image_processor.merge_kernel_size) + messages = deepcopy(messages) + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + image_seqlen = image_grid_hws[num_image_tokens].prod() // merge_length if self.expand_mm_tokens else 1 + content = content.replace( + IMAGE_PLACEHOLDER, + f"<|media_start|>image<|media_content|>{self.image_token * image_seqlen}<|media_end|>", + 1, + ) + num_image_tokens += 1 + + message["content"] = content + + return messages + + +@dataclass +class Llama4Plugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + if "pixel_values" in mm_inputs: + image_height, image_width = mm_inputs["pixel_values"][0].shape[-2:] + num_patches_per_chunk = int( + (image_height // processor.patch_size) + * (image_width // processor.patch_size) + // processor.downsample_ratio + ) + aspect_ratios = mm_inputs.pop("aspect_ratios") + + num_image_tokens = 0 + messages = deepcopy(messages) + for message in messages: + content = message["content"] + if self.expand_mm_tokens: + placeholder_count = content.count(IMAGE_PLACEHOLDER) + prompt_splits = content.split(IMAGE_PLACEHOLDER) + new_content = [] + for local_image_index, split_part in enumerate(prompt_splits): + new_content.append(split_part) + if local_image_index < placeholder_count: + tokens_for_this_image = processor._prompt_split_image( + aspect_ratios[num_image_tokens], num_patches_per_chunk + ) + num_image_tokens += 1 + new_content.append(tokens_for_this_image) + + content = "".join(new_content) + else: + content = content.replace(IMAGE_PLACEHOLDER, self.image_token) + + message["content"] = content + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + mm_inputs.pop("aspect_ratios", None) + return mm_inputs + + +@dataclass +class LlavaPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + messages = deepcopy(messages) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + if "pixel_values" in mm_inputs: + height, width = get_image_size(to_numpy_array(mm_inputs["pixel_values"][0])) + image_seqlen = (height // processor.patch_size) * ( + width // processor.patch_size + ) + processor.num_additional_image_tokens + if processor.vision_feature_select_strategy == "default": + image_seqlen -= 1 + else: + image_seqlen = 1 + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + content = content.replace(IMAGE_PLACEHOLDER, "{{image}}" * image_seqlen, 1) + + message["content"] = content.replace("{{image}}", self.image_token) + + return messages + + +@dataclass +class LlavaNextPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens = 0 + messages = deepcopy(messages) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + if "pixel_values" in mm_inputs: + image_sizes = iter(mm_inputs["image_sizes"].tolist()) + height, width = get_image_size(to_numpy_array(mm_inputs["pixel_values"][0][0])) + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + if self.expand_mm_tokens: + orig_height, orig_width = next(image_sizes) + image_seqlen = processor._get_number_of_features(orig_height, orig_width, height, width) + if processor.vision_feature_select_strategy == "default": + image_seqlen -= 1 + else: + image_seqlen = 1 + + content = content.replace(IMAGE_PLACEHOLDER, "{{image}}" * image_seqlen, 1) + num_image_tokens += 1 + + message["content"] = content.replace("{{image}}", self.image_token) + + return messages + + +@dataclass +class LlavaNextVideoPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + messages = deepcopy(messages) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + if "pixel_values" in mm_inputs: + image_sizes = iter(mm_inputs["image_sizes"].tolist()) + height, width = get_image_size(to_numpy_array(mm_inputs["pixel_values"][0][0])) + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + if self.expand_mm_tokens: + orig_height, orig_width = next(image_sizes) + image_seqlen = processor._get_number_of_features(orig_height, orig_width, height, width) + if processor.vision_feature_select_strategy == "default": + image_seqlen -= 1 + else: + image_seqlen = 1 + + content = content.replace(IMAGE_PLACEHOLDER, "{{image}}" * image_seqlen, 1) + + message["content"] = content.replace("{{image}}", self.image_token) + + if self.expand_mm_tokens: + if "pixel_values_videos" in mm_inputs: + one_video = to_numpy_array(mm_inputs.get("pixel_values_videos")[0]) + height, width = get_image_size(one_video[0]) + num_frames = one_video.shape[0] # frame dim is always after batch dim + image_seqlen = (height // processor.patch_size) * (width // processor.patch_size) + video_seqlen = image_seqlen // 4 * num_frames # divide by 4 needed for avg pooling layer + else: + video_seqlen = 1 + + for message in messages: + content = message["content"] + while VIDEO_PLACEHOLDER in content: + content = content.replace(VIDEO_PLACEHOLDER, "{{video}}" * video_seqlen, 1) + + message["content"] = content.replace("{{video}}", self.video_token) + + return messages + + +@dataclass +class MiniCPMVPlugin(BasePlugin): + @override + def _get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: "MMProcessor", + **kwargs, + ) -> dict[str, "torch.Tensor"]: + image_processor: BaseImageProcessor = getattr(processor, "image_processor") + mm_inputs = {} + if len(images) != 0: + images = self._regularize_images( + images, + image_max_pixels=getattr(processor, "image_max_pixels", 768 * 768), + image_min_pixels=getattr(processor, "image_min_pixels", 32 * 32), + )["images"] + if "valid_image_nums_ls" in kwargs: + valid_image_nums_ls = kwargs["valid_image_nums_ls"] + new_images = [] + idx = 0 + for valid_image_nums in valid_image_nums_ls: + new_images.append(images[idx : idx + valid_image_nums]) + idx += valid_image_nums + + images = new_images + + image_inputs = image_processor( + images, do_pad=True, max_slice_nums=image_processor.max_slice_nums, return_tensors="pt" + ) + mm_inputs.update(image_inputs) + + if len(videos) != 0: + videos = self._regularize_videos( + videos, + image_max_pixels=getattr(processor, "video_max_pixels", 256 * 256), + image_min_pixels=getattr(processor, "video_min_pixels", 16 * 16), + video_fps=getattr(processor, "video_fps", 2.0), + video_maxlen=getattr(processor, "video_maxlen", 128), + )["videos"] + video_inputs = image_processor(videos, do_pad=True, max_slice_nums=2, return_tensors="pt") + mm_inputs.update(video_inputs) + + if len(audios) != 0: + audios = self._regularize_audios( + audios, + sampling_rate=getattr(processor, "audio_sampling_rate", 16000), + )["audios"] + if "valid_audio_nums_ls" in kwargs: + valid_audio_nums_ls = kwargs["valid_audio_nums_ls"] + audios_ls = [] + idx = 0 + for valid_audio_nums in valid_audio_nums_ls: + audios_ls.append(audios[idx : idx + valid_audio_nums]) + idx += valid_audio_nums + else: + audios_ls = [audios] + + audio_features, audio_feature_lens, audio_phs = processor.audio_feature_extract( + audios_ls, + chunk_input=True, + sampling_rate=getattr(processor, "audio_sampling_rate", 16000), + ) + audio_feature_lens = [torch.tensor(audio_feature_len) for audio_feature_len in audio_feature_lens] + mm_inputs.update({"audio_features": audio_features, "audio_feature_lens": audio_feature_lens}) + if kwargs.get("ret_phs", False): + mm_inputs.update({"audio_phs": audio_phs}) + + return mm_inputs + + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens, num_video_tokens, num_audio_tokens = 0, 0, 0 + messages = deepcopy(messages) + image_processor: BaseImageProcessor = getattr(processor, "image_processor") + mm_inputs, audio_inputs = {}, {} + if len(images) != 0 and len(videos) != 0: + raise ValueError("MiniCPM-V model does not support input images and videos at the same time.") + + if len(videos) != 0: + max_slice_nums = 2 + use_image_id = False + mm_inputs = self._get_mm_inputs([], videos, [], processor) + else: + max_slice_nums = image_processor.max_slice_nums + use_image_id = image_processor.use_image_id + + for i, message in enumerate(messages): + content = message["content"] + while IMAGE_PLACEHOLDER in content: + content = content.replace(IMAGE_PLACEHOLDER, "{{image}}", 1) + num_image_tokens += 1 + + while VIDEO_PLACEHOLDER in content: + video_seqlen = len(mm_inputs["pixel_values"][num_video_tokens]) if self.expand_mm_tokens else 1 + content = content.replace(VIDEO_PLACEHOLDER, "{{image}}" * video_seqlen, 1) + num_video_tokens += 1 + + while AUDIO_PLACEHOLDER in content: + content = content.replace(AUDIO_PLACEHOLDER, "{{audio}}", 1) + num_audio_tokens += 1 + + message["content"] = content.replace("{{image}}", "(./)").replace( + "{{audio}}", "()" + ) + + if len(images): + mm_inputs = self._get_mm_inputs(images, [], [], processor) + + if len(audios): + audio_inputs = self._get_mm_inputs([], [], audios, processor, ret_phs=True) + + if self.expand_mm_tokens and mm_inputs: + pattern = "(./)" + image_sizes = mm_inputs["image_sizes"] + idx = 0 + for index, message in enumerate(messages): + text = message["content"] + image_tags = re.findall(pattern, text) + text_chunks = text.split(pattern) + final_text = "" + for i in range(len(image_tags)): + final_text = ( + final_text + + text_chunks[i] + + image_processor.get_slice_image_placeholder( + image_sizes[0][idx], idx, max_slice_nums, use_image_id + ) + ) + idx += 1 + + final_text += text_chunks[-1] + messages[index]["content"] = final_text + + if self.expand_mm_tokens and audio_inputs: + pattern = "()" + idx = 0 + for index, message in enumerate(messages): + text = message["content"] + audio_tags = re.findall(pattern, text) + text_chunks = text.split(pattern) + final_text = "" + for i in range(len(audio_tags)): + audio_placeholder = audio_inputs["audio_phs"][0][idx] + final_text = final_text + text_chunks[i] + audio_placeholder + idx += 1 + + final_text += text_chunks[-1] + messages[index]["content"] = final_text + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + # image bound + image_bounds_list = [] + valid_image_nums_ls = [] + for i, input_ids in enumerate(batch_ids): + input_ids_ = torch.tensor(input_ids) + start_cond = (input_ids_ == processor.tokenizer.im_start_id) | ( + input_ids_ == processor.tokenizer.slice_start_id + ) + end_cond = (input_ids_ == processor.tokenizer.im_end_id) | (input_ids_ == processor.tokenizer.slice_end_id) + image_start_tokens = torch.where(start_cond)[0] + image_start_tokens += 1 + image_end_tokens = torch.where(end_cond)[0] + valid_image_nums_ls.append(imglens[i]) + image_bounds = torch.hstack( + [ + image_start_tokens.unsqueeze(-1), + image_end_tokens.unsqueeze(-1), + ] + ) + image_bounds_list.append(image_bounds) + + mm_inputs = self._get_mm_inputs(images, videos, [], processor, valid_image_nums_ls=valid_image_nums_ls) + if "tgt_sizes" not in mm_inputs: + dummy_data = [torch.empty(0) for _ in range(len(batch_ids))] + mm_inputs.update({"tgt_sizes": dummy_data, "pixel_values": dummy_data, "image_sizes": dummy_data}) + + mm_inputs.update({"image_bound": image_bounds_list}) + + if len(audios) > 0: + # audio bound + audio_bounds_ls = [] + spk_bounds_ls = [] + valid_audio_nums_ls = [] + + for input_ids, audiolen in zip(batch_ids, audlens): + input_ids_ = torch.tensor(input_ids) + audio_start_idx = torch.where(input_ids_ == processor.tokenizer.audio_start_id)[0] + audio_end_idx = torch.where(input_ids_ == processor.tokenizer.audio_end_id)[0] + assert len(audio_start_idx) == len(audio_end_idx) + audio_bounds = torch.hstack([(audio_start_idx + 1).unsqueeze(-1), audio_end_idx.unsqueeze(-1)]) + audio_bounds_ls.append(audio_bounds) + valid_audio_nums_ls.append(audiolen) + + spk_start_idx = torch.where(input_ids_ == processor.tokenizer.spk_start_id)[0] + spk_end_idx = torch.where(input_ids_ == processor.tokenizer.spk_end_id)[0] + assert len(spk_start_idx) == len(spk_end_idx) + spk_bounds = torch.hstack([(spk_start_idx + 1).unsqueeze(-1), spk_end_idx.unsqueeze(-1)]) + spk_bounds_ls.append(spk_bounds) + + audio_inputs = self._get_mm_inputs([], [], audios, processor, valid_audio_nums_ls=valid_audio_nums_ls) + mm_inputs.update(audio_inputs) + mm_inputs.update({"audio_bounds": audio_bounds_ls, "spk_bounds": spk_bounds_ls}) + + return mm_inputs + + +@dataclass +class MllamaPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens = 0 + messages = deepcopy(messages) + for message in messages: + content = message["content"] + num_image_tokens += content.count(IMAGE_PLACEHOLDER) + message["content"] = content.replace(IMAGE_PLACEHOLDER, self.image_token) + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor, imglens) + if mm_inputs: + num_tiles = mm_inputs.pop("num_tiles") + image_token_id: int = getattr(processor, "image_token_id") + max_image_tiles: int = getattr(processor.image_processor, "max_image_tiles") + cross_attention_token_mask = [ + get_cross_attention_token_mask(input_ids, image_token_id) for input_ids in batch_ids + ] + mm_inputs["cross_attention_mask"] = torch.from_numpy( + convert_sparse_cross_attention_mask_to_dense( + cross_attention_token_mask, + num_tiles=num_tiles, + max_num_tiles=max_image_tiles, + length=max(len(input_ids) for input_ids in batch_ids), + ) + ) # shape: (batch_size, length, max_num_images, max_num_tiles) + + return mm_inputs + + +@dataclass +class PaliGemmaPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens = 0 + messages = deepcopy(messages) + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + content = content.replace(IMAGE_PLACEHOLDER, "", 1) + num_image_tokens += 1 + + message["content"] = content + + return messages + + @override + def process_token_ids( + self, + input_ids: list[int], + labels: Optional[list[int]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + tokenizer: "PreTrainedTokenizer", + processor: Optional["MMProcessor"], + ) -> tuple[list[int], Optional[list[int]]]: + self._validate_input(processor, images, videos, audios) + num_images = len(images) + image_seqlen = processor.image_seq_length if self.expand_mm_tokens else 0 # skip mm token + image_token_id = tokenizer.convert_tokens_to_ids(self.image_token) + input_ids = [image_token_id] * num_images * image_seqlen + input_ids + if labels is not None: + labels = [IGNORE_INDEX] * num_images * image_seqlen + labels + + return input_ids, labels + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + seqlens = [len(input_ids) for input_ids in batch_ids] + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + mm_inputs["token_type_ids"] = _get_paligemma_token_type_ids(imglens, seqlens, processor) + return mm_inputs + + +@dataclass +class PixtralPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + messages = deepcopy(messages) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + if "pixel_values" in mm_inputs: + # BC for transformers < 4.49.0 + if isinstance(mm_inputs["image_sizes"], list): + image_sizes = iter(mm_inputs["image_sizes"][0]) + else: + image_sizes = iter(mm_inputs["image_sizes"].tolist()) + + image_break_token: str = getattr(processor, "image_break_token") + image_end_token: str = getattr(processor, "image_end_token") + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + if self.expand_mm_tokens: + patch_size = processor.patch_size * getattr(processor, "spatial_merge_size", 1) + height, width = next(image_sizes) + num_height_tokens = height // patch_size + num_width_tokens = width // patch_size + replace_tokens = [[self.image_token] * num_width_tokens + [image_break_token]] * num_height_tokens + replace_tokens = [item for sublist in replace_tokens for item in sublist] # flatten list + replace_tokens[-1] = image_end_token + replace_str = "".join(replace_tokens) + else: + replace_str = self.image_token + + content = content.replace(IMAGE_PLACEHOLDER, replace_str, 1) + + message["content"] = content + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + # ref to this commit https://github.com/huggingface/transformers/pull/35122 + # after transformers 4.49.0, the `image_sizes` is mandatory as an input parameter for Pixtral VisionEncoder forwarding. + # it can be passed into `LlavaConditionalGeneration` as a parameter. + if not is_transformers_version_greater_than("4.49.0"): + mm_inputs.pop("image_sizes", None) + return mm_inputs + + +@dataclass +class Qwen2AudioPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + bos_token: str = getattr(processor, "audio_bos_token") + eos_token: str = getattr(processor, "audio_eos_token") + messages = deepcopy(messages) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs([], [], audios, processor) + if "feature_attention_mask" in mm_inputs: + audio_lengths = mm_inputs["feature_attention_mask"].sum(-1).tolist() + + for message in messages: + content = message["content"] + while AUDIO_PLACEHOLDER in content: + if self.expand_mm_tokens: + audio_length = audio_lengths.pop(0) + input_length = (audio_length - 1) // 2 + 1 + audio_seqlen = (input_length - 2) // 2 + 1 + else: + audio_seqlen = 1 + + content = content.replace( + AUDIO_PLACEHOLDER, f"{bos_token}{self.audio_token * audio_seqlen}{eos_token}", 1 + ) + + message["content"] = content + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["MMProcessor"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + return self._get_mm_inputs(images, videos, audios, processor) + + +@dataclass +class Qwen2VLPlugin(BasePlugin): + @override + def _preprocess_image(self, image: "ImageObject", **kwargs) -> "ImageObject": + image = super()._preprocess_image(image, **kwargs) + if min(image.width, image.height) < 28: + width, height = max(image.width, 28), max(image.height, 28) + image = image.resize((width, height)) + + if image.width / image.height > 200: + width, height = image.height * 180, image.height + image = image.resize((width, height)) + + if image.height / image.width > 200: + width, height = image.width, image.width * 180 + image = image.resize((width, height)) + + return image + + @override + def _regularize_videos( + self, videos: list["VideoInput"], **kwargs + ) -> dict[str, Union[list[list["ImageObject"]], list[float]]]: + results, fps_per_video = [], [] + for video in videos: + frames: list[ImageObject] = [] + if _check_video_is_nested_images(video): + for frame in video: + if not is_valid_image(frame) and not isinstance(frame, dict) and not os.path.exists(frame): + raise ValueError("Invalid image found in video frames.") + + frames = video + fps_per_video.append(kwargs.get("video_fps", 2.0)) + else: + container = av.open(video, "r") + video_stream = next(stream for stream in container.streams if stream.type == "video") + sample_indices = self._get_video_sample_indices(video_stream, **kwargs) + container.seek(0) + for frame_idx, frame in enumerate(container.decode(video_stream)): + if frame_idx in sample_indices: + frames.append(frame.to_image()) + + if video_stream.duration is None: + fps_per_video.append(kwargs.get("video_fps", 2.0)) + else: + fps_per_video.append(len(sample_indices) / float(video_stream.duration * video_stream.time_base)) + + if len(frames) % 2 != 0: + frames.append(frames[-1]) + + frames = self._regularize_images(frames, **kwargs)["images"] + results.append(frames) + + return {"videos": results, "fps_per_video": fps_per_video} + + @override + def _get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: "MMProcessor", + ) -> dict[str, "torch.Tensor"]: + image_processor: BaseImageProcessor = getattr(processor, "image_processor", None) + mm_inputs = {} + if len(images) != 0: + images = self._regularize_images( + images, + image_max_pixels=getattr(processor, "image_max_pixels", 768 * 768), + image_min_pixels=getattr(processor, "image_min_pixels", 32 * 32), + )["images"] + mm_inputs.update(image_processor(images, return_tensors="pt")) + + if len(videos) != 0: + video_data = self._regularize_videos( + videos, + image_max_pixels=getattr(processor, "video_max_pixels", 256 * 256), + image_min_pixels=getattr(processor, "video_min_pixels", 16 * 16), + video_fps=getattr(processor, "video_fps", 2.0), + video_maxlen=getattr(processor, "video_maxlen", 128), + ) + mm_inputs.update(image_processor(images=None, videos=video_data["videos"], return_tensors="pt")) + temporal_patch_size: int = getattr(image_processor, "temporal_patch_size", 2) + if "second_per_grid_ts" in processor.model_input_names: + mm_inputs["second_per_grid_ts"] = [temporal_patch_size / fps for fps in video_data["fps_per_video"]] + + return mm_inputs + + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens, num_video_tokens = 0, 0 + messages = deepcopy(messages) + image_processor: BaseImageProcessor = getattr(processor, "image_processor") + + merge_length: int = getattr(image_processor, "merge_size") ** 2 + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + image_grid_thw = mm_inputs.get("image_grid_thw", []) + video_grid_thw = mm_inputs.get("video_grid_thw", []) + else: + image_grid_thw = [None] * len(images) + video_grid_thw = [None] * len(videos) + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + image_seqlen = image_grid_thw[num_image_tokens].prod() // merge_length if self.expand_mm_tokens else 1 + content = content.replace( + IMAGE_PLACEHOLDER, f"<|vision_start|>{self.image_token * image_seqlen}<|vision_end|>", 1 + ) + num_image_tokens += 1 + + while VIDEO_PLACEHOLDER in content: + video_seqlen = video_grid_thw[num_video_tokens].prod() // merge_length if self.expand_mm_tokens else 1 + content = content.replace( + VIDEO_PLACEHOLDER, f"<|vision_start|>{self.video_token * video_seqlen}<|vision_end|>", 1 + ) + num_video_tokens += 1 + + message["content"] = content + + return messages + + +@dataclass +class GLM4VPlugin(Qwen2VLPlugin): + @override + def _get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: "MMProcessor", + ) -> dict[str, "torch.Tensor"]: + image_processor: BaseImageProcessor = getattr(processor, "image_processor", None) + video_processor: BaseImageProcessor = getattr(processor, "video_processor", None) + mm_inputs = {} + if len(images) != 0: + images = self._regularize_images( + images, + image_max_pixels=getattr(processor, "image_max_pixels", 768 * 768), + image_min_pixels=getattr(processor, "image_min_pixels", 32 * 32), + )["images"] + mm_inputs.update(image_processor(images, return_tensors="pt")) + + if len(videos) != 0: + video_data = self._regularize_videos( + videos, + image_max_pixels=getattr(processor, "video_max_pixels", 256 * 256), + image_min_pixels=getattr(processor, "video_min_pixels", 16 * 16), + video_fps=getattr(processor, "video_fps", 2.0), + video_maxlen=getattr(processor, "video_maxlen", 128), + ) + # prepare video metadata + video_metadata = [ + {"fps": 2, "duration": len(video), "total_frames": len(video)} for video in video_data["videos"] + ] + mm_inputs.update(video_processor(images=None, videos=video_data["videos"], video_metadata=video_metadata)) + + return mm_inputs + + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens, num_video_tokens = 0, 0 + messages = deepcopy(messages) + image_processor: BaseImageProcessor = getattr(processor, "image_processor") + + merge_length: int = getattr(image_processor, "merge_size") ** 2 + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + image_grid_thw = mm_inputs.get("image_grid_thw", []) + video_grid_thw = mm_inputs.get("video_grid_thw", []) + num_frames = video_grid_thw[0][0] if len(video_grid_thw) > 0 else 0 # hard code for now + timestamps = mm_inputs.get("timestamps", []) + + if hasattr(timestamps, "tolist"): + timestamps = timestamps.tolist() + + if not timestamps: + timestamps_list = [] + elif isinstance(timestamps[0], list): + timestamps_list = timestamps[0] + else: + timestamps_list = timestamps + + unique_timestamps = timestamps_list.copy() + selected_timestamps = unique_timestamps[:num_frames] + while len(selected_timestamps) < num_frames: + selected_timestamps.append(selected_timestamps[-1] if selected_timestamps else 0) + + else: + image_grid_thw = [None] * len(images) + video_grid_thw = [None] * len(videos) + num_frames = 0 + selected_timestamps = [0] + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + image_seqlen = image_grid_thw[num_image_tokens].prod() // merge_length if self.expand_mm_tokens else 1 + content = content.replace( + IMAGE_PLACEHOLDER, f"<|begin_of_image|>{self.image_token * image_seqlen}<|end_of_image|>", 1 + ) + num_image_tokens += 1 + + while VIDEO_PLACEHOLDER in content: + video_structure = "" + for frame_index in range(num_frames): + video_seqlen = ( + video_grid_thw[num_video_tokens][1:].prod() // merge_length if self.expand_mm_tokens else 1 + ) + timestamp_sec = selected_timestamps[frame_index] + frame_structure = ( + f"<|begin_of_image|>{self.image_token * video_seqlen}<|end_of_image|>{timestamp_sec}" + ) + video_structure += frame_structure + + content = content.replace(VIDEO_PLACEHOLDER, f"<|begin_of_video|>{video_structure}<|end_of_video|>", 1) + num_video_tokens += 1 + + message["content"] = content + + return messages + + @override + def get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + imglens: list[int], + vidlens: list[int], + audlens: list[int], + batch_ids: list[list[int]], + processor: Optional["ProcessorMixin"], + ) -> dict[str, Union[list[int], "torch.Tensor"]]: + self._validate_input(processor, images, videos, audios) + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + mm_inputs.pop("timestamps", None) + return mm_inputs + + +class Qwen2OmniPlugin(Qwen2VLPlugin): + @override + def _get_mm_inputs( + self, + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: "MMProcessor", + ) -> dict[str, "torch.Tensor"]: + image_processor: BaseImageProcessor = getattr(processor, "image_processor", None) + feature_extractor: SequenceFeatureExtractor = getattr(processor, "feature_extractor", None) + mm_inputs = {} + if len(images) != 0: + images = self._regularize_images( + images, + image_max_pixels=getattr(processor, "image_max_pixels", 768 * 768), + image_min_pixels=getattr(processor, "image_min_pixels", 32 * 32), + )["images"] + mm_inputs.update(image_processor(images, return_tensors="pt")) + + if len(videos) != 0: + video_dict = self._regularize_videos( + videos, + image_max_pixels=getattr(processor, "video_max_pixels", 256 * 256), + image_min_pixels=getattr(processor, "video_min_pixels", 16 * 16), + video_fps=getattr(processor, "video_fps", 2.0), + video_maxlen=getattr(processor, "video_maxlen", 128), + ) + mm_inputs.update(image_processor(images=None, videos=video_dict["videos"], return_tensors="pt")) + temporal_patch_size: int = getattr(image_processor, "temporal_patch_size", 2) + mm_inputs["video_second_per_grid"] = torch.tensor( + [temporal_patch_size / fps for fps in video_dict["fps_per_video"]] + ) + + if len(audios) != 0: + audios = self._regularize_audios( + audios, + sampling_rate=getattr(processor, "audio_sampling_rate", 16000), + )["audios"] + mm_inputs.update( + feature_extractor( + audios, + sampling_rate=getattr(processor, "audio_sampling_rate", 16000), + return_attention_mask=True, + padding="max_length", + return_tensors="pt", + ) + ) + mm_inputs["feature_attention_mask"] = mm_inputs.pop("attention_mask") # prevent conflicts + + return mm_inputs + + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens, num_video_tokens, num_audio_tokens = 0, 0, 0 + messages = deepcopy(messages) + image_processor: BaseImageProcessor = getattr(processor, "image_processor", None) + + merge_length = processor.image_processor.merge_size**2 + use_audio_in_video = getattr(processor, "use_audio_in_video", False) + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + image_grid_thw = mm_inputs.get("image_grid_thw", []) + video_grid_thw = mm_inputs.get("video_grid_thw", []) + if "feature_attention_mask" in mm_inputs: + input_lengths = (mm_inputs["feature_attention_mask"].sum(-1).numpy() - 1) // 2 + 1 + audio_lengths = (input_lengths - 2) // 2 + 1 + else: + mm_inputs = {} + image_grid_thw = [None] * len(images) + video_grid_thw = [None] * len(videos) + audio_lengths = [None] * len(audios) + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + image_seqlen = image_grid_thw[num_image_tokens].prod() // merge_length if self.expand_mm_tokens else 1 + content = content.replace( + IMAGE_PLACEHOLDER, f"<|vision_bos|>{self.image_token * image_seqlen}<|vision_eos|>", 1 + ) + num_image_tokens += 1 + + if ( + use_audio_in_video and len(audios) and len(videos) + ): # if use the audio of video # deal video token and audio token togather + if len(videos) != len(audios): + raise ValueError( + f"Number of videos ({len(videos)}) must match number of audios ({len(audios)}) when using audio in video." + ) + + while VIDEO_PLACEHOLDER in content: + video_pos = content.find(VIDEO_PLACEHOLDER) + audio_pos = content.find(AUDIO_PLACEHOLDER, video_pos) + if audio_pos == -1 or audio_pos < video_pos: + raise ValueError( + f"Each {VIDEO_PLACEHOLDER} must be followed by an {AUDIO_PLACEHOLDER} when using audio in video." + ) + + audio_t_index = torch.arange(audio_lengths[num_audio_tokens]) + video_t_index = ( + torch.arange(video_grid_thw[num_video_tokens][0]) + .view(-1, 1, 1) + .expand( + -1, + video_grid_thw[num_video_tokens][1] // image_processor.merge_size, + video_grid_thw[num_video_tokens][2] // image_processor.merge_size, + ) + .flatten() + * mm_inputs["video_second_per_grid"][num_video_tokens] + * 25 # FIXME hardcode of position_id_per_seconds=25 + ).long() + t_ntoken_per_chunk = 50 # FIXME hardcode: [25 * 2] + video_chunk_indices = processor.get_chunked_index(video_t_index, t_ntoken_per_chunk) + audio_chunk_indices = processor.get_chunked_index(audio_t_index, t_ntoken_per_chunk) + placeholder_string = "" + placeholder_string += "<|vision_bos|>" + "<|audio_bos|>" + for j in range(max(len(video_chunk_indices), len(audio_chunk_indices))): + video_chunk_index = video_chunk_indices[j] if j < len(video_chunk_indices) else None + audio_chunk_index = audio_chunk_indices[j] if j < len(audio_chunk_indices) else None + if video_chunk_index is not None: + placeholder_string += self.video_token * (video_chunk_index[1] - video_chunk_index[0]) + + if audio_chunk_index is not None: + placeholder_string += self.audio_token * (audio_chunk_index[1] - audio_chunk_index[0]) + + placeholder_string += "<|audio_eos|>" + "<|vision_eos|>" + content = content.replace(VIDEO_PLACEHOLDER, placeholder_string, 1) + content = content.replace(AUDIO_PLACEHOLDER, "", 1) + num_audio_tokens += 1 + num_video_tokens += 1 + else: + while AUDIO_PLACEHOLDER in content: + audio_seqlen = audio_lengths[num_audio_tokens] if self.expand_mm_tokens else 1 + content = content.replace( + AUDIO_PLACEHOLDER, f"<|audio_bos|>{self.audio_token * audio_seqlen}<|audio_eos|>", 1 + ) + num_audio_tokens += 1 + + while VIDEO_PLACEHOLDER in content: + video_seqlen = ( + video_grid_thw[num_video_tokens].prod() // merge_length if self.expand_mm_tokens else 1 + ) + content = content.replace( + VIDEO_PLACEHOLDER, f"<|vision_bos|>{self.video_token * video_seqlen}<|vision_eos|>", 1 + ) + num_video_tokens += 1 + + message["content"] = content + + return messages + + +@dataclass +class VideoLlavaPlugin(BasePlugin): + @override + def process_messages( + self, + messages: list[dict[str, str]], + images: list["ImageInput"], + videos: list["VideoInput"], + audios: list["AudioInput"], + processor: Optional["MMProcessor"], + ) -> list[dict[str, str]]: + self._validate_input(processor, images, videos, audios) + self._validate_messages(messages, images, videos, audios) + num_image_tokens, num_video_tokens = 0, 0 + messages = deepcopy(messages) + num_frames = 0 + if self.expand_mm_tokens: + mm_inputs = self._get_mm_inputs(images, videos, audios, processor) + if "pixel_values_images" in mm_inputs: + height, width = get_image_size(to_numpy_array(mm_inputs["pixel_values_images"][0])) + num_frames = 1 + + if "pixel_values_videos" in mm_inputs: + one_video = to_numpy_array(mm_inputs["pixel_values_videos"][0]) + height, width = get_image_size(one_video[0]) + num_frames = one_video.shape[0] # frame dim is always after batch dim + + if "pixel_values_images" in mm_inputs or "pixel_values_videos" in mm_inputs: + image_seqlen = (height // processor.patch_size) * ( + width // processor.patch_size + ) + processor.num_additional_image_tokens + video_seqlen = image_seqlen * num_frames + if processor.vision_feature_select_strategy == "default": + image_seqlen -= 1 + else: + image_seqlen, video_seqlen = 1, 1 + + for message in messages: + content = message["content"] + while IMAGE_PLACEHOLDER in content: + content = content.replace(IMAGE_PLACEHOLDER, "{{image}}" * image_seqlen, 1) + num_image_tokens += 1 + + while VIDEO_PLACEHOLDER in content: + content = content.replace(VIDEO_PLACEHOLDER, "{{video}}" * video_seqlen, 1) + num_video_tokens += 1 + + content = content.replace("{{image}}", self.image_token) + message["content"] = content.replace("{{video}}", self.video_token) + + return messages + + +PLUGINS = { + "base": BasePlugin, + "gemma3": Gemma3Plugin, + "glm4v": GLM4VPlugin, + "gemma3n": Gemma3nPlugin, + "intern_vl": InternVLPlugin, + "kimi_vl": KimiVLPlugin, + "llama4": Llama4Plugin, + "llava": LlavaPlugin, + "llava_next": LlavaNextPlugin, + "llava_next_video": LlavaNextVideoPlugin, + "minicpm_v": MiniCPMVPlugin, + "mllama": MllamaPlugin, + "paligemma": PaliGemmaPlugin, + "pixtral": PixtralPlugin, + "qwen2_audio": Qwen2AudioPlugin, + "qwen2_omni": Qwen2OmniPlugin, + "qwen2_vl": Qwen2VLPlugin, + "video_llava": VideoLlavaPlugin, +} + + +def register_mm_plugin(name: str, plugin_class: type["BasePlugin"]) -> None: + r"""Register a multimodal plugin.""" + if name in PLUGINS: + raise ValueError(f"Multimodal plugin {name} already exists.") + + PLUGINS[name] = plugin_class + + +def get_mm_plugin( + name: str, + image_token: Optional[str] = None, + video_token: Optional[str] = None, + audio_token: Optional[str] = None, +) -> "BasePlugin": + r"""Get plugin for multimodal inputs.""" + if name not in PLUGINS: + raise ValueError(f"Multimodal plugin `{name}` not found.") + + return PLUGINS[name](image_token, video_token, audio_token) diff --git a/src/train_sft/src/llamafactory/data/parser.py b/src/train_sft/src/llamafactory/data/parser.py new file mode 100644 index 0000000000000000000000000000000000000000..f95462e305fb2989973b4d8961477e889f23c5ff --- /dev/null +++ b/src/train_sft/src/llamafactory/data/parser.py @@ -0,0 +1,153 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import os +from dataclasses import dataclass +from typing import Any, Literal, Optional, Union + +from huggingface_hub import hf_hub_download + +from ..extras.constants import DATA_CONFIG +from ..extras.misc import use_modelscope, use_openmind + + +@dataclass +class DatasetAttr: + r"""Dataset attributes.""" + + # basic configs + load_from: Literal["hf_hub", "ms_hub", "om_hub", "script", "file"] + dataset_name: str + formatting: Literal["alpaca", "sharegpt"] = "alpaca" + ranking: bool = False + # extra configs + subset: Optional[str] = None + split: str = "train" + folder: Optional[str] = None + num_samples: Optional[int] = None + field: Optional[str] = None # for json datasets with a top-level list field + split_map: Optional[str] = None # path to csv with id,split mapping + # common columns + system: Optional[str] = None + tools: Optional[str] = None + images: Optional[str] = None + videos: Optional[str] = None + audios: Optional[str] = None + # dpo columns + chosen: Optional[str] = None + rejected: Optional[str] = None + kto_tag: Optional[str] = None + # alpaca columns + prompt: Optional[str] = "instruction" + query: Optional[str] = "input" + response: Optional[str] = "output" + history: Optional[str] = None + # sharegpt columns + messages: Optional[str] = "conversations" + # sharegpt tags + role_tag: Optional[str] = "from" + content_tag: Optional[str] = "value" + user_tag: Optional[str] = "human" + assistant_tag: Optional[str] = "gpt" + observation_tag: Optional[str] = "observation" + function_tag: Optional[str] = "function_call" + system_tag: Optional[str] = "system" + + def __repr__(self) -> str: + return self.dataset_name + + def set_attr(self, key: str, obj: dict[str, Any], default: Optional[Any] = None) -> None: + setattr(self, key, obj.get(key, default)) + + def join(self, attr: dict[str, Any]) -> None: + self.set_attr("formatting", attr, default="alpaca") + self.set_attr("ranking", attr, default=False) + self.set_attr("subset", attr) + self.set_attr("split", attr, default="train") + self.set_attr("folder", attr) + self.set_attr("num_samples", attr) + self.set_attr("field", attr) # new: read top-level json field if provided + self.set_attr("split_map", attr) # new: external split mapping file (csv) + + if "columns" in attr: + column_names = ["prompt", "query", "response", "history", "messages", "system", "tools"] + column_names += ["images", "videos", "audios", "chosen", "rejected", "kto_tag"] + for column_name in column_names: + self.set_attr(column_name, attr["columns"]) + + if "tags" in attr: + tag_names = ["role_tag", "content_tag"] + tag_names += ["user_tag", "assistant_tag", "observation_tag", "function_tag", "system_tag"] + for tag in tag_names: + self.set_attr(tag, attr["tags"]) + + +def get_dataset_list(dataset_names: Optional[list[str]], dataset_dir: Union[str, dict]) -> list["DatasetAttr"]: + r"""Get the attributes of the datasets.""" + if dataset_names is None: + dataset_names = [] + + if isinstance(dataset_dir, dict): + dataset_info = dataset_dir + elif dataset_dir == "ONLINE": + dataset_info = None + else: + if dataset_dir.startswith("REMOTE:"): + config_path = hf_hub_download(repo_id=dataset_dir[7:], filename=DATA_CONFIG, repo_type="dataset") + else: + config_path = os.path.join(dataset_dir, DATA_CONFIG) + + try: + with open(config_path) as f: + dataset_info = json.load(f) + except Exception as err: + if len(dataset_names) != 0: + raise ValueError(f"Cannot open {config_path} due to {str(err)}.") + + dataset_info = None + + dataset_list: list[DatasetAttr] = [] + for name in dataset_names: + if dataset_info is None: # dataset_dir is ONLINE + load_from = "ms_hub" if use_modelscope() else "om_hub" if use_openmind() else "hf_hub" + dataset_attr = DatasetAttr(load_from, dataset_name=name) + dataset_list.append(dataset_attr) + continue + + if name not in dataset_info: + raise ValueError(f"Undefined dataset {name} in {DATA_CONFIG}.") + + has_hf_url = "hf_hub_url" in dataset_info[name] + has_ms_url = "ms_hub_url" in dataset_info[name] + has_om_url = "om_hub_url" in dataset_info[name] + + if has_hf_url or has_ms_url or has_om_url: + if has_ms_url and (use_modelscope() or not has_hf_url): + dataset_attr = DatasetAttr("ms_hub", dataset_name=dataset_info[name]["ms_hub_url"]) + elif has_om_url and (use_openmind() or not has_hf_url): + dataset_attr = DatasetAttr("om_hub", dataset_name=dataset_info[name]["om_hub_url"]) + else: + dataset_attr = DatasetAttr("hf_hub", dataset_name=dataset_info[name]["hf_hub_url"]) + elif "script_url" in dataset_info[name]: + dataset_attr = DatasetAttr("script", dataset_name=dataset_info[name]["script_url"]) + elif "cloud_file_name" in dataset_info[name]: + dataset_attr = DatasetAttr("cloud_file", dataset_name=dataset_info[name]["cloud_file_name"]) + else: + dataset_attr = DatasetAttr("file", dataset_name=dataset_info[name]["file_name"]) + + dataset_attr.join(dataset_info[name]) + dataset_list.append(dataset_attr) + + return dataset_list diff --git a/src/train_sft/src/llamafactory/data/template.py b/src/train_sft/src/llamafactory/data/template.py new file mode 100644 index 0000000000000000000000000000000000000000..b888b6b1fc847e75f4c23f26e0b0f80b1e7e277a --- /dev/null +++ b/src/train_sft/src/llamafactory/data/template.py @@ -0,0 +1,2040 @@ +# Copyright 2025 the LlamaFactory team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import re +from copy import deepcopy +from dataclasses import dataclass +from typing import TYPE_CHECKING, Optional, Union + +from typing_extensions import override + +from ..extras import logging +from .data_utils import Role +from .formatter import EmptyFormatter, FunctionFormatter, StringFormatter, ToolFormatter +from .mm_plugin import get_mm_plugin + + +if TYPE_CHECKING: + from transformers import PreTrainedTokenizer + + from ..hparams import DataArguments + from .formatter import SLOTS, Formatter + from .mm_plugin import BasePlugin + from .tool_utils import FunctionCall + + +logger = logging.get_logger(__name__) + + +@dataclass +class Template: + format_user: "Formatter" + format_assistant: "Formatter" + format_system: "Formatter" + format_function: "Formatter" + format_observation: "Formatter" + format_tools: "Formatter" + format_prefix: "Formatter" + default_system: str + stop_words: list[str] + thought_words: tuple[str, str] + efficient_eos: bool + replace_eos: bool + replace_jinja_template: bool + enable_thinking: Optional[bool] + mm_plugin: "BasePlugin" + + def encode_oneturn( + self, + tokenizer: "PreTrainedTokenizer", + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + ) -> tuple[list[int], list[int]]: + r"""Return a single pair of token ids representing prompt and response respectively.""" + encoded_messages = self._encode(tokenizer, messages, system, tools) + prompt_ids = [] + for encoded_ids in encoded_messages[:-1]: + prompt_ids += encoded_ids + + response_ids = encoded_messages[-1] + return prompt_ids, response_ids + + def encode_multiturn( + self, + tokenizer: "PreTrainedTokenizer", + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + ) -> list[tuple[list[int], list[int]]]: + r"""Return multiple pairs of token ids representing prompts and responses respectively.""" + encoded_messages = self._encode(tokenizer, messages, system, tools) + return [(encoded_messages[i], encoded_messages[i + 1]) for i in range(0, len(encoded_messages), 2)] + + def extract_tool(self, content: str) -> Union[str, list["FunctionCall"]]: + r"""Extract tool message.""" + return self.format_tools.extract(content) + + def get_stop_token_ids(self, tokenizer: "PreTrainedTokenizer") -> list[int]: + r"""Return stop token ids.""" + stop_token_ids = {tokenizer.eos_token_id} + for token in self.stop_words: + stop_token_ids.add(tokenizer.convert_tokens_to_ids(token)) + + return list(stop_token_ids) + + def add_thought(self, content: str = "") -> str: + r"""Add empty thought to assistant message.""" + return f"{self.thought_words[0]}{self.thought_words[1]}" + content + + def remove_thought(self, content: str) -> str: + r"""Remove thought from assistant message.""" + pattern = re.compile(f"{re.escape(self.thought_words[0])}(.*?){re.escape(self.thought_words[1])}", re.DOTALL) + return re.sub(pattern, "", content).lstrip("\n") + + def get_thought_word_ids(self, tokenizer: "PreTrainedTokenizer") -> list[int]: + r"""Get the token ids of thought words.""" + return tokenizer.encode(self.add_thought(), add_special_tokens=False) + + def _convert_elements_to_ids(self, tokenizer: "PreTrainedTokenizer", elements: "SLOTS") -> list[int]: + r"""Convert elements to token ids.""" + token_ids = [] + for elem in elements: + if isinstance(elem, str): + if len(elem) != 0: + token_ids += tokenizer.encode(elem, add_special_tokens=False) + elif isinstance(elem, dict): + token_ids += [tokenizer.convert_tokens_to_ids(elem.get("token"))] + elif isinstance(elem, set): + if "bos_token" in elem and tokenizer.bos_token_id is not None: + token_ids += [tokenizer.bos_token_id] + elif "eos_token" in elem and tokenizer.eos_token_id is not None: + token_ids += [tokenizer.eos_token_id] + else: + raise ValueError(f"Input must be string, set[str] or dict[str, str], got {type(elem)}") + + return token_ids + + def _encode( + self, + tokenizer: "PreTrainedTokenizer", + messages: list[dict[str, str]], + system: Optional[str], + tools: Optional[str], + ) -> list[list[int]]: + r"""Encode formatted inputs to pairs of token ids. + + Turn 0: prefix + system + query resp + Turn t: query resp. + """ + system = system or self.default_system + encoded_messages = [] + for i, message in enumerate(messages): + elements = [] + + if i == 0: + elements += self.format_prefix.apply() + if system or tools: + tool_text = self.format_tools.apply(content=tools)[0] if tools else "" + elements += self.format_system.apply(content=(system + tool_text)) + + if message["role"] == Role.USER: + elements += self.format_user.apply(content=message["content"], idx=str(i // 2)) + elif message["role"] == Role.ASSISTANT: + elements += self.format_assistant.apply(content=message["content"]) + elif message["role"] == Role.OBSERVATION: + elements += self.format_observation.apply(content=message["content"]) + elif message["role"] == Role.FUNCTION: + elements += self.format_function.apply(content=message["content"]) + else: + raise NotImplementedError("Unexpected role: {}".format(message["role"])) + + encoded_messages.append(self._convert_elements_to_ids(tokenizer, elements)) + + return encoded_messages + + @staticmethod + def _add_or_replace_eos_token(tokenizer: "PreTrainedTokenizer", eos_token: str) -> None: + r"""Add or replace eos token to the tokenizer.""" + if tokenizer.eos_token == eos_token: + return + + is_added = tokenizer.eos_token_id is None + num_added_tokens = tokenizer.add_special_tokens({"eos_token": eos_token}) + + if is_added: + logger.info_rank0(f"Add eos token: {tokenizer.eos_token}.") + else: + logger.info_rank0(f"Replace eos token: {tokenizer.eos_token}.") + + if num_added_tokens > 0: + logger.warning_rank0("New tokens have been added, make sure `resize_vocab` is True.") + + def fix_special_tokens(self, tokenizer: "PreTrainedTokenizer") -> None: + r"""Add eos token and pad token to the tokenizer.""" + stop_words = self.stop_words + if self.replace_eos: + if not stop_words: + raise ValueError("Stop words are required to replace the EOS token.") + + self._add_or_replace_eos_token(tokenizer, eos_token=stop_words[0]) + stop_words = stop_words[1:] + + if tokenizer.eos_token_id is None: + self._add_or_replace_eos_token(tokenizer, eos_token="<|endoftext|>") + + if tokenizer.pad_token_id is None: + tokenizer.pad_token = tokenizer.eos_token + logger.info_rank0(f"Add pad token: {tokenizer.pad_token}") + + if stop_words: + num_added_tokens = tokenizer.add_special_tokens( + dict(additional_special_tokens=stop_words), replace_additional_special_tokens=False + ) + logger.info_rank0("Add {} to stop words.".format(",".join(stop_words))) + if num_added_tokens > 0: + logger.warning_rank0("New tokens have been added, make sure `resize_vocab` is True.") + + @staticmethod + def _jinja_escape(content: str) -> str: + r"""Escape single quotes in content.""" + return content.replace("'", r"\'") + + @staticmethod + def _convert_slots_to_jinja(slots: "SLOTS", tokenizer: "PreTrainedTokenizer", placeholder: str = "content") -> str: + r"""Convert slots to jinja template.""" + slot_items = [] + for slot in slots: + if isinstance(slot, str): + slot_pieces = slot.split("{{content}}") + if slot_pieces[0]: + slot_items.append("'" + Template._jinja_escape(slot_pieces[0]) + "'") + if len(slot_pieces) > 1: + slot_items.append(placeholder) + if slot_pieces[1]: + slot_items.append("'" + Template._jinja_escape(slot_pieces[1]) + "'") + elif isinstance(slot, set): # do not use {{ eos_token }} since it may be replaced + if "bos_token" in slot and tokenizer.bos_token_id is not None: + slot_items.append("'" + tokenizer.bos_token + "'") + elif "eos_token" in slot and tokenizer.eos_token_id is not None: + slot_items.append("'" + tokenizer.eos_token + "'") + elif isinstance(slot, dict): + raise ValueError("Dict is not supported.") + + return " + ".join(slot_items) + + def _get_jinja_template(self, tokenizer: "PreTrainedTokenizer") -> str: + r"""Return the jinja template.""" + prefix = self._convert_slots_to_jinja(self.format_prefix.apply(), tokenizer) + system = self._convert_slots_to_jinja(self.format_system.apply(), tokenizer, placeholder="system_message") + user = self._convert_slots_to_jinja(self.format_user.apply(), tokenizer) + assistant = self._convert_slots_to_jinja(self.format_assistant.apply(), tokenizer) + jinja_template = "" + if prefix: + jinja_template += "{{ " + prefix + " }}" + + if self.default_system: + jinja_template += "{% set system_message = '" + self._jinja_escape(self.default_system) + "' %}" + + jinja_template += ( + "{% if messages[0]['role'] == 'system' %}{% set loop_messages = messages[1:] %}" + "{% set system_message = messages[0]['content'] %}{% else %}{% set loop_messages = messages %}{% endif %}" + "{% if system_message is defined %}{{ " + system + " }}{% endif %}" + "{% for message in loop_messages %}" + "{% set content = message['content'] %}" + "{% if message['role'] == 'user' %}" + "{{ " + user + " }}" + "{% elif message['role'] == 'assistant' %}" + "{{ " + assistant + " }}" + "{% endif %}" + "{% endfor %}" + ) + return jinja_template + + def fix_jinja_template(self, tokenizer: "PreTrainedTokenizer") -> None: + r"""Replace the jinja template in the tokenizer.""" + if tokenizer.chat_template is None or self.replace_jinja_template: + try: + tokenizer.chat_template = self._get_jinja_template(tokenizer) + except ValueError as e: + logger.info_rank0(f"Cannot add this chat template to tokenizer: {e}.") + + @staticmethod + def _convert_slots_to_ollama( + slots: "SLOTS", tokenizer: "PreTrainedTokenizer", placeholder: str = "content" + ) -> str: + r"""Convert slots to ollama template.""" + slot_items = [] + for slot in slots: + if isinstance(slot, str): + slot_pieces = slot.split("{{content}}") + if slot_pieces[0]: + slot_items.append(slot_pieces[0]) + if len(slot_pieces) > 1: + slot_items.append("{{ " + placeholder + " }}") + if slot_pieces[1]: + slot_items.append(slot_pieces[1]) + elif isinstance(slot, set): # do not use {{ eos_token }} since it may be replaced + if "bos_token" in slot and tokenizer.bos_token_id is not None: + slot_items.append(tokenizer.bos_token) + elif "eos_token" in slot and tokenizer.eos_token_id is not None: + slot_items.append(tokenizer.eos_token) + elif isinstance(slot, dict): + raise ValueError("Dict is not supported.") + + return "".join(slot_items) + + def _get_ollama_template(self, tokenizer: "PreTrainedTokenizer") -> str: + r"""Return the ollama template.""" + prefix = self._convert_slots_to_ollama(self.format_prefix.apply(), tokenizer) + system = self._convert_slots_to_ollama(self.format_system.apply(), tokenizer, placeholder=".System") + user = self._convert_slots_to_ollama(self.format_user.apply(), tokenizer, placeholder=".Content") + assistant = self._convert_slots_to_ollama(self.format_assistant.apply(), tokenizer, placeholder=".Content") + return ( + f"{prefix}{{{{ if .System }}}}{system}{{{{ end }}}}" + f"""{{{{ range .Messages }}}}{{{{ if eq .Role "user" }}}}{user}""" + f"""{{{{ else if eq .Role "assistant" }}}}{assistant}{{{{ end }}}}{{{{ end }}}}""" + ) + + def get_ollama_modelfile(self, tokenizer: "PreTrainedTokenizer") -> str: + r"""Return the ollama modelfile. + + TODO: support function calling. + """ + modelfile = "# ollama modelfile auto-generated by llamafactory\n\n" + modelfile += f'FROM .\n\nTEMPLATE """{self._get_ollama_template(tokenizer)}"""\n\n' + + if self.default_system: + modelfile += f'SYSTEM """{self.default_system}"""\n\n' + + for stop_token_id in self.get_stop_token_ids(tokenizer): + modelfile += f'PARAMETER stop "{tokenizer.convert_ids_to_tokens(stop_token_id)}"\n' + + modelfile += "PARAMETER num_ctx 4096\n" + return modelfile + + +@dataclass +class Llama2Template(Template): + r"""A template that fuse the system message to first user message.""" + + @override + def _encode( + self, + tokenizer: "PreTrainedTokenizer", + messages: list[dict[str, str]], + system: str, + tools: str, + ) -> list[list[int]]: + system = system or self.default_system + encoded_messages = [] + for i, message in enumerate(messages): + elements = [] + + system_text = "" + if i == 0: + elements += self.format_prefix.apply() + if system or tools: + tool_text = self.format_tools.apply(content=tools)[0] if tools else "" + system_text = self.format_system.apply(content=(system + tool_text))[0] + + if message["role"] == Role.USER: + elements += self.format_user.apply(content=system_text + message["content"]) + elif message["role"] == Role.ASSISTANT: + elements += self.format_assistant.apply(content=message["content"]) + elif message["role"] == Role.OBSERVATION: + elements += self.format_observation.apply(content=message["content"]) + elif message["role"] == Role.FUNCTION: + elements += self.format_function.apply(content=message["content"]) + else: + raise NotImplementedError("Unexpected role: {}".format(message["role"])) + + encoded_messages.append(self._convert_elements_to_ids(tokenizer, elements)) + + return encoded_messages + + def _get_jinja_template(self, tokenizer: "PreTrainedTokenizer") -> str: + prefix = self._convert_slots_to_jinja(self.format_prefix.apply(), tokenizer) + system_message = self._convert_slots_to_jinja( + self.format_system.apply(), tokenizer, placeholder="system_message" + ) + user_message = self._convert_slots_to_jinja(self.format_user.apply(), tokenizer) + assistant_message = self._convert_slots_to_jinja(self.format_assistant.apply(), tokenizer) + jinja_template = "" + if prefix: + jinja_template += "{{ " + prefix + " }}" + + if self.default_system: + jinja_template += "{% set system_message = '" + self._jinja_escape(self.default_system) + "' %}" + + jinja_template += ( + "{% if messages[0]['role'] == 'system' %}{% set loop_messages = messages[1:] %}" + "{% set system_message = messages[0]['content'] %}{% else %}{% set loop_messages = messages %}{% endif %}" + "{% for message in loop_messages %}" + "{% if loop.index0 == 0 and system_message is defined %}" + "{% set content = " + system_message + " + message['content'] %}" + "{% else %}{% set content = message['content'] %}{% endif %}" + "{% if message['role'] == 'user' %}" + "{{ " + user_message + " }}" + "{% elif message['role'] == 'assistant' %}" + "{{ " + assistant_message + " }}" + "{% endif %}" + "{% endfor %}" + ) + return jinja_template + + +@dataclass +class ReasoningTemplate(Template): + r"""A template that add thought to assistant message.""" + + @override + def encode_oneturn( + self, + tokenizer: "PreTrainedTokenizer", + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + ) -> tuple[list[int], list[int]]: + messages = deepcopy(messages) + for i in range(1, len(messages) - 2, 2): + messages[i]["content"] = self.remove_thought(messages[i]["content"]) + + if self.enable_thinking is False: # remove all cot + messages[-1]["content"] = self.remove_thought(messages[-1]["content"]) + + prompt_ids, response_ids = super().encode_oneturn(tokenizer, messages, system, tools) + if ( + self.thought_words[0] not in messages[-1]["content"] + and self.thought_words[1] not in messages[-1]["content"] + ): # add empty cot + if not self.enable_thinking: # do not compute loss + prompt_ids += self.get_thought_word_ids(tokenizer) + else: # do compute loss + response_ids = self.get_thought_word_ids(tokenizer) + response_ids + + return prompt_ids, response_ids + + @override + def encode_multiturn( + self, + tokenizer: "PreTrainedTokenizer", + messages: list[dict[str, str]], + system: Optional[str] = None, + tools: Optional[str] = None, + ) -> list[tuple[list[int], list[int]]]: + messages = deepcopy(messages) + if self.enable_thinking is False: # remove all cot + for i in range(1, len(messages), 2): + messages[i]["content"] = self.remove_thought(messages[i]["content"]) + + encoded_messages = self._encode(tokenizer, messages, system, tools) + for i in range(0, len(messages), 2): + if ( + self.thought_words[0] not in messages[i + 1]["content"] + and self.thought_words[1] not in messages[i + 1]["content"] + ): # add empty cot + if not self.enable_thinking: # do not compute loss + encoded_messages[i] += self.get_thought_word_ids(tokenizer) + else: # do compute loss + encoded_messages[i + 1] = self.get_thought_word_ids(tokenizer) + encoded_messages[i + 1] + + return [(encoded_messages[i], encoded_messages[i + 1]) for i in range(0, len(encoded_messages), 2)] + + +TEMPLATES: dict[str, "Template"] = {} + + +def register_template( + name: str, + format_user: Optional["Formatter"] = None, + format_assistant: Optional["Formatter"] = None, + format_system: Optional["Formatter"] = None, + format_function: Optional["Formatter"] = None, + format_observation: Optional["Formatter"] = None, + format_tools: Optional["Formatter"] = None, + format_prefix: Optional["Formatter"] = None, + default_system: str = "", + stop_words: Optional[list[str]] = None, + thought_words: Optional[tuple[str, str]] = None, + efficient_eos: bool = False, + replace_eos: bool = False, + replace_jinja_template: bool = False, + enable_thinking: Optional[bool] = True, + mm_plugin: "BasePlugin" = get_mm_plugin(name="base"), + template_class: type["Template"] = Template, +) -> None: + r"""Register a chat template. + + To add the following chat template: + ``` + user prompt here + model response here + user prompt here + model response here + ``` + + The corresponding code should be: + ``` + register_template( + name="custom", + format_user=StringFormatter(slots=["{{content}}\n"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + format_prefix=EmptyFormatter(""), + ) + ``` + """ + if name in TEMPLATES: + raise ValueError(f"Template {name} already exists.") + + default_slots = ["{{content}}"] if efficient_eos else ["{{content}}", {"eos_token"}] + default_user_formatter = StringFormatter(slots=["{{content}}"]) + default_assistant_formatter = StringFormatter(slots=default_slots) + if format_assistant is not None: + default_function_formatter = FunctionFormatter(slots=format_assistant.slots, tool_format="default") + else: + default_function_formatter = FunctionFormatter(slots=default_slots, tool_format="default") + + default_tool_formatter = ToolFormatter(tool_format="default") + default_prefix_formatter = EmptyFormatter() + TEMPLATES[name] = template_class( + format_user=format_user or default_user_formatter, + format_assistant=format_assistant or default_assistant_formatter, + format_system=format_system or default_user_formatter, + format_function=format_function or default_function_formatter, + format_observation=format_observation or format_user or default_user_formatter, + format_tools=format_tools or default_tool_formatter, + format_prefix=format_prefix or default_prefix_formatter, + default_system=default_system, + stop_words=stop_words or [], + thought_words=thought_words or ("\n", "\n\n\n"), + efficient_eos=efficient_eos, + replace_eos=replace_eos, + replace_jinja_template=replace_jinja_template, + enable_thinking=enable_thinking, + mm_plugin=mm_plugin, + ) + + +def parse_template(tokenizer: "PreTrainedTokenizer") -> "Template": + r"""Extract a chat template from the tokenizer.""" + + def find_diff(short_str: str, long_str: str) -> str: + i, j = 0, 0 + diff = "" + while i < len(short_str) and j < len(long_str): + if short_str[i] == long_str[j]: + i += 1 + j += 1 + else: + diff += long_str[j] + j += 1 + + return diff + + prefix = tokenizer.decode(tokenizer.encode("")) + + messages = [{"role": "system", "content": "{{content}}"}] + system_slot = tokenizer.apply_chat_template(messages, add_generation_prompt=False, tokenize=False)[len(prefix) :] + + messages = [{"role": "system", "content": ""}, {"role": "user", "content": "{{content}}"}] + user_slot_empty_system = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False) + user_slot_empty_system = user_slot_empty_system[len(prefix) :] + + messages = [{"role": "user", "content": "{{content}}"}] + user_slot = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False) + user_slot = user_slot[len(prefix) :] + + messages = [{"role": "user", "content": "{{content}}"}, {"role": "assistant", "content": "{{content}}"}] + assistant_slot = tokenizer.apply_chat_template(messages, add_generation_prompt=False, tokenize=False) + assistant_slot = assistant_slot[len(prefix) + len(user_slot) :] + template_class = ReasoningTemplate if "" in assistant_slot else Template + assistant_slot = assistant_slot.replace("", "").replace("", "").lstrip("\n") # remove thought tags + + if len(user_slot) > len(user_slot_empty_system): + default_system = find_diff(user_slot_empty_system, user_slot) + sole_system = system_slot.replace("{{content}}", default_system, 1) + user_slot = user_slot[len(sole_system) :] + else: # if defaut_system is empty, user_slot_empty_system will be longer than user_slot + default_system = "" + + return template_class( + format_user=StringFormatter(slots=[user_slot]), + format_assistant=StringFormatter(slots=[assistant_slot]), + format_system=StringFormatter(slots=[system_slot]), + format_function=FunctionFormatter(slots=[assistant_slot], tool_format="default"), + format_observation=StringFormatter(slots=[user_slot]), + format_tools=ToolFormatter(tool_format="default"), + format_prefix=EmptyFormatter(slots=[prefix]) if prefix else EmptyFormatter(), + default_system=default_system, + stop_words=[], + thought_words=("\n", "\n\n\n"), + efficient_eos=False, + replace_eos=False, + replace_jinja_template=False, + enable_thinking=True, + mm_plugin=get_mm_plugin(name="base"), + ) + + +def get_template_and_fix_tokenizer(tokenizer: "PreTrainedTokenizer", data_args: "DataArguments") -> "Template": + r"""Get chat template and fixes the tokenizer.""" + if data_args.template is None: + if isinstance(tokenizer.chat_template, str): + logger.warning_rank0("`template` was not specified, try parsing the chat template from the tokenizer.") + template = parse_template(tokenizer) + else: + logger.warning_rank0("`template` was not specified, use `empty` template.") + template = TEMPLATES["empty"] # placeholder + else: + if data_args.template not in TEMPLATES: + raise ValueError(f"Template {data_args.template} does not exist.") + + template = TEMPLATES[data_args.template] + + if data_args.train_on_prompt and template.efficient_eos: + raise ValueError("Current template does not support `train_on_prompt`.") + + if data_args.tool_format is not None: + logger.info_rank0(f"Using tool format: {data_args.tool_format}.") + default_slots = ["{{content}}"] if template.efficient_eos else ["{{content}}", {"eos_token"}] + template.format_function = FunctionFormatter(slots=default_slots, tool_format=data_args.tool_format) + template.format_tools = ToolFormatter(tool_format=data_args.tool_format) + + if data_args.default_system is not None: + logger.info_rank0(f"Using default system message: {data_args.default_system}.") + template.default_system = data_args.default_system + + template.enable_thinking = data_args.enable_thinking + template.fix_special_tokens(tokenizer) + template.fix_jinja_template(tokenizer) + return template + + +register_template( + name="alpaca", + format_user=StringFormatter(slots=["### Instruction:\n{{content}}\n\n### Response:\n"]), + format_assistant=StringFormatter(slots=["{{content}}", {"eos_token"}, "\n\n"]), + default_system=( + "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n" + ), + replace_jinja_template=True, +) + + +register_template( + name="aquila", + format_user=StringFormatter(slots=["Human: {{content}}###Assistant:"]), + format_assistant=StringFormatter(slots=["{{content}}###"]), + format_system=StringFormatter(slots=["System: {{content}}###"]), + default_system=( + "A chat between a curious human and an artificial intelligence assistant. " + "The assistant gives helpful, detailed, and polite answers to the human's questions." + ), + stop_words=[""], +) + + +register_template( + name="atom", + format_user=StringFormatter( + slots=[{"bos_token"}, "Human: {{content}}\n", {"eos_token"}, {"bos_token"}, "Assistant:"] + ), + format_assistant=StringFormatter(slots=["{{content}}\n", {"eos_token"}]), +) + + +register_template( + name="baichuan", + format_user=StringFormatter(slots=[{"token": ""}, "{{content}}", {"token": ""}]), + efficient_eos=True, +) + + +register_template( + name="baichuan2", + format_user=StringFormatter(slots=["{{content}}"]), + efficient_eos=True, +) + + +register_template( + name="bailing", + format_user=StringFormatter(slots=["HUMAN{{content}}ASSISTANT"]), + format_system=StringFormatter(slots=["SYSTEM{{content}}"]), + format_observation=StringFormatter(slots=["OBSERVATION{{content}}ASSISTANT"]), + stop_words=["<|endoftext|>"], + efficient_eos=True, +) + + +register_template( + name="belle", + format_user=StringFormatter(slots=["Human: {{content}}\n\nBelle: "]), + format_assistant=StringFormatter(slots=["{{content}}", {"eos_token"}, "\n\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), +) + + +register_template( + name="bluelm", + format_user=StringFormatter(slots=[{"token": "[|Human|]:"}, "{{content}}", {"token": "[|AI|]:"}]), +) + + +register_template( + name="breeze", + format_user=StringFormatter(slots=["[INST] {{content}} [/INST] "]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + efficient_eos=True, +) + + +register_template( + name="chatglm2", + format_user=StringFormatter(slots=["[Round {{idx}}]\n\n问：{{content}}\n\n答："]), + format_prefix=EmptyFormatter(slots=[{"token": "[gMASK]"}, {"token": "sop"}]), + efficient_eos=True, +) + + +register_template( + name="chatglm3", + format_user=StringFormatter(slots=[{"token": "<|user|>"}, "\n", "{{content}}", {"token": "<|assistant|>"}]), + format_assistant=StringFormatter(slots=["\n", "{{content}}"]), + format_system=StringFormatter(slots=[{"token": "<|system|>"}, "\n", "{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4"), + format_observation=StringFormatter( + slots=[{"token": "<|observation|>"}, "\n", "{{content}}", {"token": "<|assistant|>"}] + ), + format_tools=ToolFormatter(tool_format="glm4"), + format_prefix=EmptyFormatter(slots=[{"token": "[gMASK]"}, {"token": "sop"}]), + stop_words=["<|user|>", "<|observation|>"], + efficient_eos=True, +) + + +register_template( + name="chatml", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_observation=StringFormatter(slots=["<|im_start|>tool\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + stop_words=["<|im_end|>", "<|im_start|>"], + replace_eos=True, + replace_jinja_template=True, +) + + +# copied from chatml template +register_template( + name="chatml_de", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_observation=StringFormatter(slots=["<|im_start|>tool\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + default_system="Du bist ein freundlicher und hilfsbereiter KI-Assistent.", + stop_words=["<|im_end|>", "<|im_start|>"], + replace_eos=True, + replace_jinja_template=True, +) + + +register_template( + name="codegeex2", + format_prefix=EmptyFormatter(slots=[{"token": "[gMASK]"}, {"token": "sop"}]), +) + + +register_template( + name="codegeex4", + format_user=StringFormatter(slots=["<|user|>\n{{content}}<|assistant|>\n"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4"), + format_observation=StringFormatter(slots=["<|observation|>\n{{content}}<|assistant|>\n"]), + format_tools=ToolFormatter(tool_format="glm4"), + format_prefix=EmptyFormatter(slots=["[gMASK]"]), + default_system=( + "你是一位智能编程助手，你叫CodeGeeX。你会为用户回答关于编程、代码、计算机方面的任何问题，" + "并提供格式规范、可以执行、准确安全的代码，并在必要时提供详细的解释。" + ), + stop_words=["<|user|>", "<|observation|>"], + efficient_eos=True, +) + + +register_template( + name="cohere", + format_user=StringFormatter( + slots=[ + ( + "<|START_OF_TURN_TOKEN|><|USER_TOKEN|>{{content}}<|END_OF_TURN_TOKEN|>" + "<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>" + ) + ] + ), + format_system=StringFormatter(slots=["<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>{{content}}<|END_OF_TURN_TOKEN|>"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), +) + + +register_template( + name="cpm", + format_user=StringFormatter(slots=["<用户>{{content}}"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), +) + + +# copied from chatml template +register_template( + name="cpm3", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_observation=StringFormatter(slots=["<|im_start|>tool\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=["<|im_end|>"], +) + + +# copied from chatml template +register_template( + name="cpm4", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_observation=StringFormatter(slots=["<|im_start|>tool\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=["<|im_end|>"], +) + + +# copied from chatml template +register_template( + name="dbrx", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_observation=StringFormatter(slots=["<|im_start|>tool\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + default_system=( + "You are DBRX, created by Databricks. You were last updated in December 2023. " + "You answer questions based on information available up to that point.\n" + "YOU PROVIDE SHORT RESPONSES TO SHORT QUESTIONS OR STATEMENTS, but provide thorough " + "responses to more complex and open-ended questions.\nYou assist with various tasks, " + "from writing to coding (using markdown for code blocks — remember to use ``` with " + "code, JSON, and tables).\n(You do not have real-time data access or code execution " + "capabilities. You avoid stereotyping and provide balanced perspectives on " + "controversial topics. You do not provide song lyrics, poems, or news articles and " + "do not divulge details of your training data.)\nThis is your system prompt, " + "guiding your responses. Do not reference it, just respond to the user. If you find " + "yourself talking about this message, stop. You should be responding appropriately " + "and usually that means not mentioning this.\nYOU DO NOT MENTION ANY OF THIS INFORMATION " + "ABOUT YOURSELF UNLESS THE INFORMATION IS DIRECTLY PERTINENT TO THE USER'S QUERY." + ), + stop_words=["<|im_end|>"], + replace_eos=True, +) + + +register_template( + name="deepseek", + format_user=StringFormatter(slots=["User: {{content}}\n\nAssistant:"]), + format_system=StringFormatter(slots=["{{content}}\n\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), +) + + +register_template( + name="deepseek3", + format_user=StringFormatter(slots=["<｜User｜>{{content}}<｜Assistant｜>"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), +) + + +# copied from deepseek3 template +register_template( + name="deepseekr1", + format_user=StringFormatter(slots=["<｜User｜>{{content}}<｜Assistant｜>"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + template_class=ReasoningTemplate, +) + + +register_template( + name="deepseekcoder", + format_user=StringFormatter(slots=["### Instruction:\n{{content}}\n### Response:"]), + format_assistant=StringFormatter(slots=["\n{{content}}\n<|EOT|>\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + default_system=( + "You are an AI programming assistant, utilizing the DeepSeek Coder model, " + "developed by DeepSeek Company, and you only answer questions related to computer science. " + "For politically sensitive questions, security and privacy issues, " + "and other non-computer science questions, you will refuse to answer.\n" + ), +) + + +register_template( + name="default", + format_user=StringFormatter(slots=["Human: {{content}}", {"eos_token"}, "\nAssistant:"]), + format_assistant=StringFormatter(slots=["{{content}}", {"eos_token"}, "\n"]), + format_system=StringFormatter(slots=["System: {{content}}", {"eos_token"}, "\n"]), + replace_jinja_template=True, +) + + +register_template( + name="empty", + format_assistant=StringFormatter(slots=["{{content}}"]), +) + + +register_template( + name="exaone", + format_user=StringFormatter(slots=["[|user|]{{content}}\n[|assistant|]"]), + format_assistant=StringFormatter(slots=["{{content}}", {"eos_token"}, "\n"]), + format_system=StringFormatter(slots=["[|system|]{{content}}[|endofturn|]\n"]), +) + + +register_template( + name="falcon", + format_user=StringFormatter(slots=["User: {{content}}\nFalcon:"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + efficient_eos=True, +) + + +# copied from chatml template +register_template( + name="falcon_h1", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_observation=StringFormatter(slots=["<|im_start|>tool\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=["<|im_end|>", "<|end_of_text|>"], +) + + +register_template( + name="fewshot", + format_assistant=StringFormatter(slots=["{{content}}\n\n"]), + efficient_eos=True, + replace_jinja_template=True, +) + + +register_template( + name="gemma", + format_user=StringFormatter(slots=["user\n{{content}}\nmodel\n"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + format_system=StringFormatter(slots=["{{content}}\n\n"]), + format_observation=StringFormatter( + slots=["tool\n{{content}}\nmodel\n"] + ), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=[""], + replace_eos=True, + template_class=Llama2Template, +) + + +# copied from gemma template +register_template( + name="gemma2", + format_user=StringFormatter(slots=["user\n{{content}}\nmodel\n"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + format_system=StringFormatter(slots=["{{content}}\n\n"]), + format_observation=StringFormatter( + slots=["tool\n{{content}}\nmodel\n"] + ), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=["", ""], + efficient_eos=True, + template_class=Llama2Template, +) + + +# copied from gemma template +register_template( + name="gemma3", + format_user=StringFormatter(slots=["user\n{{content}}\nmodel\n"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + format_system=StringFormatter(slots=["{{content}}\n\n"]), + format_observation=StringFormatter( + slots=["tool\n{{content}}\nmodel\n"] + ), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=[""], + replace_eos=True, + mm_plugin=get_mm_plugin("gemma3", image_token=""), + template_class=Llama2Template, +) + + +register_template( + name="gemma3n", + format_user=StringFormatter(slots=["user\n{{content}}\nmodel\n"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + format_system=StringFormatter(slots=["{{content}}\n\n"]), + format_observation=StringFormatter( + slots=["tool\n{{content}}\nmodel\n"] + ), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + stop_words=[""], + replace_eos=True, + mm_plugin=get_mm_plugin("gemma3n", image_token="", audio_token=""), + template_class=Llama2Template, +) + + +register_template( + name="glm4", + format_user=StringFormatter(slots=["<|user|>\n{{content}}<|assistant|>"]), + format_assistant=StringFormatter(slots=["\n{{content}}"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4"), + format_observation=StringFormatter(slots=["<|observation|>\n{{content}}<|assistant|>"]), + format_tools=ToolFormatter(tool_format="glm4"), + format_prefix=EmptyFormatter(slots=["[gMASK]"]), + stop_words=["<|user|>", "<|observation|>"], + efficient_eos=True, +) + + +# copied from glm4 template +register_template( + name="glm4_moe", + format_user=StringFormatter(slots=["<|user|>\n{{content}}<|assistant|>"]), + format_assistant=StringFormatter(slots=["\n{{content}}"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4_moe"), + format_observation=StringFormatter(slots=["<|observation|>\n{{content}}<|assistant|>"]), + format_tools=ToolFormatter(tool_format="glm4_moe"), + format_prefix=EmptyFormatter(slots=["[gMASK]"]), + stop_words=["<|user|>", "<|observation|>"], + efficient_eos=True, + template_class=ReasoningTemplate, +) + + +# copied from glm4 template +register_template( + name="glm4v", + format_user=StringFormatter(slots=["<|user|>\n{{content}}<|assistant|>"]), + format_assistant=StringFormatter(slots=["\n{{content}}"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4"), + format_observation=StringFormatter(slots=["<|observation|>\n{{content}}<|assistant|>"]), + format_tools=ToolFormatter(tool_format="glm4"), + format_prefix=EmptyFormatter(slots=["[gMASK]"]), + stop_words=["<|user|>", "<|observation|>", ""], + efficient_eos=True, + mm_plugin=get_mm_plugin(name="glm4v", image_token="<|image|>", video_token="<|video|>"), + template_class=ReasoningTemplate, +) + + +register_template( + name="glm45v", + format_user=StringFormatter(slots=["<|user|>\n{{content}}<|assistant|>"]), + format_assistant=StringFormatter(slots=["\n{{content}}"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4_moe"), + format_observation=StringFormatter(slots=["<|observation|>\n{{content}}<|assistant|>"]), + format_tools=ToolFormatter(tool_format="glm4_moe"), + format_prefix=EmptyFormatter(slots=["[gMASK]"]), + stop_words=["<|user|>", "<|observation|>", ""], + efficient_eos=True, + mm_plugin=get_mm_plugin(name="glm4v", image_token="<|image|>", video_token="<|video|>"), + template_class=ReasoningTemplate, +) + + +# copied from glm4 template +register_template( + name="glmz1", + format_user=StringFormatter(slots=["<|user|>\n{{content}}<|assistant|>"]), + format_assistant=StringFormatter(slots=["\n{{content}}"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}"]), + format_function=FunctionFormatter(slots=["{{content}}"], tool_format="glm4"), + format_observation=StringFormatter(slots=["<|observation|>\n{{content}}<|assistant|>"]), + format_tools=ToolFormatter(tool_format="glm4"), + format_prefix=EmptyFormatter(slots=["[gMASK]"]), + stop_words=["<|user|>", "<|observation|>"], + efficient_eos=True, + template_class=ReasoningTemplate, +) + + +register_template( + name="gpt", + format_user=StringFormatter(slots=["<|start|>user<|message|>{{content}}<|end|><|start|>assistant"]), + format_assistant=StringFormatter(slots=["{{content}}<|end|>"]), + format_system=StringFormatter(slots=["<|start|>system<|message|>{{content}}<|end|>"]), + default_system="You are ChatGPT, a large language model trained by OpenAI.", + thought_words=("<|channel|>analysis<|message|>", "<|end|><|start|>assistant<|channel|>final<|message|>"), + efficient_eos=True, + template_class=ReasoningTemplate, +) + + +register_template( + name="granite3", + format_user=StringFormatter( + slots=[ + "<|start_of_role|>user<|end_of_role|>{{content}}<|end_of_text|>\n<|start_of_role|>assistant<|end_of_role|>" + ] + ), + format_assistant=StringFormatter(slots=["{{content}}<|end_of_text|>\n"]), + format_system=StringFormatter(slots=["<|start_of_role|>system<|end_of_role|>{{content}}<|end_of_text|>\n"]), +) + + +register_template( + name="granite3_vision", + format_user=StringFormatter(slots=["<|user|>\n{{content}}\n<|assistant|>\n"]), + format_system=StringFormatter(slots=["<|system|>\n{{content}}\n"]), + default_system=( + "A chat between a curious user and an artificial intelligence assistant. " + "The assistant gives helpful, detailed, and polite answers to the user's questions." + ), + mm_plugin=get_mm_plugin(name="llava_next", image_token=""), +) + + +register_template( + name="granite4", + format_user=StringFormatter( + slots=[ + "<|start_of_role|>user<|end_of_role|>{{content}}<|end_of_text|>\n<|start_of_role|>assistant<|end_of_role|>" + ] + ), + format_assistant=StringFormatter(slots=["{{content}}<|end_of_text|>\n"]), + format_system=StringFormatter(slots=["<|start_of_role|>system<|end_of_role|>{{content}}<|end_of_text|>\n"]), + format_function=FunctionFormatter(slots=["{{content}}<|end_of_text|>\n"], tool_format="default"), + format_observation=StringFormatter( + slots=["<|start_of_role|>tool<|end_of_role|>{{content}}<|end_of_text|>\n<|start_of_role|>assistant\n"] + ), + format_tools=ToolFormatter(tool_format="default"), + stop_words=["<|end_of_text|>"], + default_system="You are Granite, developed by IBM. You are a helpful AI assistant.", +) + + +register_template( + name="index", + format_user=StringFormatter(slots=["reserved_0{{content}}reserved_1"]), + format_system=StringFormatter(slots=["{{content}}"]), + efficient_eos=True, +) + + +register_template( + name="hunyuan", + format_user=StringFormatter(slots=["<|bos|>user\n{{content}}<|eos|>\n<|bos|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|eos|>\n"]), + format_system=StringFormatter(slots=["<|bos|>system\n{{content}}<|eos|>\n"]), + format_prefix=EmptyFormatter(slots=["<|bos|>"]), + stop_words=["<|eos|>"], +) + + +register_template( + name="intern", + format_user=StringFormatter(slots=["<|User|>:{{content}}\n<|Bot|>:"]), + format_assistant=StringFormatter(slots=["{{content}}\n"]), + format_system=StringFormatter(slots=["<|System|>:{{content}}\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + default_system=( + "You are an AI assistant whose name is InternLM (书生·浦语).\n" + "- InternLM (书生·浦语) is a conversational language model that is developed by Shanghai AI Laboratory " + "(上海人工智能实验室). It is designed to be helpful, honest, and harmless.\n" + "- InternLM (书生·浦语) can understand and communicate fluently in the language " + "chosen by the user such as English and 中文." + ), + stop_words=[""], +) + + +register_template( + name="intern2", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + default_system=( + "You are an AI assistant whose name is InternLM (书生·浦语).\n" + "- InternLM (书生·浦语) is a conversational language model that is developed by Shanghai AI Laboratory " + "(上海人工智能实验室). It is designed to be helpful, honest, and harmless.\n" + "- InternLM (书生·浦语) can understand and communicate fluently in the language " + "chosen by the user such as English and 中文." + ), + stop_words=["<|im_end|>"], +) + + +register_template( + name="intern_vl", + format_user=StringFormatter(slots=["<|im_start|>user\n{{content}}<|im_end|>\n<|im_start|>assistant\n"]), + format_assistant=StringFormatter(slots=["{{content}}<|im_end|>\n"]), + format_system=StringFormatter(slots=["<|im_start|>system\n{{content}}<|im_end|>\n"]), + format_prefix=EmptyFormatter(slots=[{"bos_token"}]), + default_system=( + "你是书生·万象，英文名是InternVL，是由上海人工智能实验室、清华大学及多家合作单位联合开发的多模态大语言模型。" + ), + stop_words=["<|im_end|>"], + mm_plugin=get_mm_plugin(name="intern_vl", image_token="", video_token="