diff --git "a/huggingface_accelerate.txt" "b/huggingface_accelerate.txt" new file mode 100644--- /dev/null +++ "b/huggingface_accelerate.txt" @@ -0,0 +1,7101 @@ +# File: accelerate-main/manim_animations/big_model_inference/stage_1.py +from manim import * + +class Stage1(Scene): + + def construct(self): + mem = Rectangle(height=0.5, width=0.5) + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + cpu_left_col_base = [mem.copy() for i in range(6)] + cpu_right_col_base = [mem.copy() for i in range(6)] + cpu_left_col = VGroup(*cpu_left_col_base).arrange(UP, buff=0) + cpu_right_col = VGroup(*cpu_right_col_base).arrange(UP, buff=0) + cpu_rects = VGroup(cpu_left_col, cpu_right_col).arrange(RIGHT, buff=0) + cpu_text = Text('CPU', font_size=24) + cpu = Group(cpu_rects, cpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + cpu.move_to([-2.5, -0.5, 0]) + self.add(cpu) + gpu_base = [mem.copy() for i in range(1)] + gpu_rect = VGroup(*gpu_base).arrange(UP, buff=0) + gpu_text = Text('GPU', font_size=24) + gpu = Group(gpu_rect, gpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + gpu.align_to(cpu, DOWN) + gpu.set_x(gpu.get_x() - 1) + self.add(gpu) + model_base = [mem.copy() for i in range(6)] + model_rect = VGroup(*model_base).arrange(RIGHT, buff=0) + model_text = Text('Model', font_size=24) + model = Group(model_rect, model_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + model.move_to([3, -1.0, 0]) + self.play(Create(cpu_left_col, run_time=1), Create(cpu_right_col, run_time=1), Create(gpu_rect, run_time=1)) + step_1 = MarkupText(f"First, an empty model skeleton is loaded\ninto memory without using much RAM.", font_size=24) + key = Square(side_length=2.2) + key.move_to([-5, 2, 0]) + key_text = MarkupText(f"Key:\n\n● Empty Model", font_size=18) + key_text.move_to([-5, 2.4, 0]) + step_1.move_to([2, 2, 0]) + self.play(Write(step_1, run_time=2.5), Write(key_text), Write(key)) + self.add(model) + cpu_targs = [] + first_animations = [] + second_animations = [] + for (i, rect) in enumerate(model_base): + cpu_target = Rectangle(height=0.46, width=0.46).set_stroke(width=0.0).set_fill(YELLOW, opacity=0.7) + cpu_target.move_to(rect) + cpu_target.generate_target() + cpu_target.target.height = 0.46 / 4 + cpu_target.target.width = 0.46 / 3 + if i == 0: + cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT), buff=0.02, direction=UP) + cpu_target.target.set_x(cpu_target.target.get_x() + 0.1) + elif i == 3: + cpu_target.target.next_to(cpu_targs[0].target, direction=UP, buff=0.0) + else: + cpu_target.target.next_to(cpu_targs[i - 1].target, direction=RIGHT, buff=0.0) + cpu_targs.append(cpu_target) + first_animations.append(rect.animate(run_time=0.5).set_stroke(YELLOW)) + second_animations.append(MoveToTarget(cpu_target, run_time=1.5)) + self.play(*first_animations) + self.play(*second_animations) + self.wait() + +# File: accelerate-main/manim_animations/big_model_inference/stage_2.py +from manim import * + +class Stage2(Scene): + + def construct(self): + mem = Rectangle(height=0.5, width=0.5) + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + cpu_left_col_base = [mem.copy() for i in range(6)] + cpu_right_col_base = [mem.copy() for i in range(6)] + cpu_left_col = VGroup(*cpu_left_col_base).arrange(UP, buff=0) + cpu_right_col = VGroup(*cpu_right_col_base).arrange(UP, buff=0) + cpu_rects = VGroup(cpu_left_col, cpu_right_col).arrange(RIGHT, buff=0) + cpu_text = Text('CPU', font_size=24) + cpu = Group(cpu_rects, cpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + cpu.move_to([-2.5, -0.5, 0]) + self.add(cpu) + gpu_base = [mem.copy() for i in range(4)] + gpu_rect = VGroup(*gpu_base).arrange(UP, buff=0) + gpu_text = Text('GPU', font_size=24) + gpu = Group(gpu_rect, gpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + gpu.move_to([-1, -1, 0]) + self.add(gpu) + model_base = [mem.copy() for i in range(6)] + model_rect = VGroup(*model_base).arrange(RIGHT, buff=0) + model_text = Text('Model', font_size=24) + model = Group(model_rect, model_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + model.move_to([3, -1.0, 0]) + self.add(model) + cpu_targs = [] + for (i, rect) in enumerate(model_base): + rect.set_stroke(YELLOW) + cpu_target = Rectangle(height=0.46 / 4, width=0.46 / 3).set_stroke(width=0.0).set_fill(YELLOW, opacity=0.7) + if i == 0: + cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT), buff=0.02, direction=UP) + cpu_target.set_x(cpu_target.get_x() + 0.1) + elif i == 3: + cpu_target.next_to(cpu_targs[0], direction=UP, buff=0.0) + else: + cpu_target.next_to(cpu_targs[i - 1], direction=RIGHT, buff=0.0) + self.add(cpu_target) + cpu_targs.append(cpu_target) + checkpoint_base = [mem.copy() for i in range(6)] + checkpoint_rect = VGroup(*checkpoint_base).arrange(RIGHT, buff=0) + checkpoint_text = Text('Loaded Checkpoint', font_size=24) + checkpoint = Group(checkpoint_rect, checkpoint_text).arrange(DOWN, aligned_edge=DOWN, buff=0.4) + checkpoint.move_to([3, 0.5, 0]) + key = Square(side_length=2.2) + key.move_to([-5, 2, 0]) + key_text = MarkupText(f"Key:\n\n● Empty Model", font_size=18) + key_text.move_to([-5, 2.4, 0]) + self.add(key_text, key) + blue_text = MarkupText(f"● Checkpoint", font_size=18) + blue_text.next_to(key_text, DOWN * 2.4, aligned_edge=key_text.get_left()) + step_2 = MarkupText(f'Next, a second model is loaded into memory,\nwith the weights of a single shard.', font_size=24) + step_2.move_to([2, 2, 0]) + self.play(Write(step_2), Write(blue_text)) + self.play(Write(checkpoint_text, run_time=1), Create(checkpoint_rect, run_time=1)) + first_animations = [] + second_animations = [] + for (i, rect) in enumerate(checkpoint_base): + target = fill.copy().set_fill(BLUE, opacity=0.7) + target.move_to(rect) + first_animations.append(GrowFromCenter(target, run_time=1)) + cpu_target = target.copy() + cpu_target.generate_target() + if i < 5: + cpu_target.target.move_to(cpu_left_col_base[i + 1]) + else: + cpu_target.target.move_to(cpu_right_col_base[i - 5]) + second_animations.append(MoveToTarget(cpu_target, run_time=1.5)) + self.play(*first_animations) + self.play(*second_animations) + self.wait() + +# File: accelerate-main/manim_animations/big_model_inference/stage_3.py +from manim import * + +class Stage3(Scene): + + def construct(self): + mem = Rectangle(height=0.5, width=0.5) + meta_mem = Rectangle(height=0.25, width=0.25) + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + cpu_left_col_base = [mem.copy() for i in range(6)] + cpu_right_col_base = [mem.copy() for i in range(6)] + cpu_left_col = VGroup(*cpu_left_col_base).arrange(UP, buff=0) + cpu_right_col = VGroup(*cpu_right_col_base).arrange(UP, buff=0) + cpu_rects = VGroup(cpu_left_col, cpu_right_col).arrange(RIGHT, buff=0) + cpu_text = Text('CPU', font_size=24) + cpu = Group(cpu_rects, cpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + cpu.move_to([-2.5, -0.5, 0]) + self.add(cpu) + gpu_base = [mem.copy() for i in range(4)] + gpu_rect = VGroup(*gpu_base).arrange(UP, buff=0) + gpu_text = Text('GPU', font_size=24) + gpu = Group(gpu_rect, gpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + gpu.move_to([-1, -1, 0]) + self.add(gpu) + model_base = [mem.copy() for i in range(6)] + model_rect = VGroup(*model_base).arrange(RIGHT, buff=0) + model_text = Text('Model', font_size=24) + model = Group(model_rect, model_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + model.move_to([3, -1.0, 0]) + self.add(model) + model_arr = [] + model_cpu_arr = [] + model_meta_arr = [] + for (i, rect) in enumerate(model_base): + rect.set_stroke(YELLOW) + cpu_target = Rectangle(height=0.46 / 4, width=0.46 / 3).set_stroke(width=0.0).set_fill(YELLOW, opacity=0.7) + if i == 0: + cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT), buff=0.02, direction=UP) + cpu_target.set_x(cpu_target.get_x() + 0.1) + elif i == 3: + cpu_target.next_to(model_cpu_arr[0], direction=UP, buff=0.0) + else: + cpu_target.next_to(model_cpu_arr[i - 1], direction=RIGHT, buff=0.0) + self.add(cpu_target) + model_cpu_arr.append(cpu_target) + self.add(*model_arr, *model_cpu_arr, *model_meta_arr) + checkpoint_base = [mem.copy() for i in range(6)] + checkpoint_rect = VGroup(*checkpoint_base).arrange(RIGHT, buff=0) + checkpoint_text = Text('Loaded Checkpoint', font_size=24) + checkpoint = Group(checkpoint_rect, checkpoint_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + checkpoint.move_to([3, 0.5, 0]) + self.add(checkpoint) + ckpt_arr = [] + ckpt_cpu_arr = [] + for (i, rect) in enumerate(checkpoint_base): + target = fill.copy().set_fill(BLUE, opacity=0.7) + target.move_to(rect) + ckpt_arr.append(target) + cpu_target = target.copy() + if i < 5: + cpu_target.move_to(cpu_left_col_base[i + 1]) + else: + cpu_target.move_to(cpu_right_col_base[i - 5]) + ckpt_cpu_arr.append(cpu_target) + self.add(*ckpt_arr, *ckpt_cpu_arr) + key = Square(side_length=2.2) + key.move_to([-5, 2, 0]) + key_text = MarkupText(f"Key:\n\n● Empty Model", font_size=18) + key_text.move_to([-5, 2.4, 0]) + self.add(key_text, key) + blue_text = MarkupText(f"● Checkpoint", font_size=18) + blue_text.next_to(key_text, DOWN * 2.4, aligned_edge=key_text.get_left()) + self.add(blue_text) + step_3 = MarkupText(f'Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.', font_size=24) + step_3.move_to([2, 2, 0]) + disk_left_col_base = [meta_mem.copy() for i in range(6)] + disk_right_col_base = [meta_mem.copy() for i in range(6)] + disk_left_col = VGroup(*disk_left_col_base).arrange(UP, buff=0) + disk_right_col = VGroup(*disk_right_col_base).arrange(UP, buff=0) + disk_rects = VGroup(disk_left_col, disk_right_col).arrange(RIGHT, buff=0) + disk_text = Text('Disk', font_size=24) + disk = Group(disk_rects, disk_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + disk.move_to([-4.0, -1.25, 0]) + self.play(Write(step_3, run_time=3), Write(disk_text, run_time=1), Create(disk_rects, run_time=1)) + animations = [] + for (i, rect) in enumerate(ckpt_cpu_arr): + target = rect.copy() + target.generate_target() + target.target.move_to(disk_left_col_base[i]).scale(0.5) + animations.append(MoveToTarget(target, run_time=1.5)) + self.play(*animations) + self.play(FadeOut(step_3)) + step_4 = MarkupText(f'Then, the checkpoint is removed from memory\nthrough garbage collection.', font_size=24) + step_4.move_to([2, 2, 0]) + self.play(Write(step_4, run_time=3)) + self.play(FadeOut(checkpoint_rect, checkpoint_text, *ckpt_arr, *ckpt_cpu_arr)) + self.wait() + +# File: accelerate-main/manim_animations/big_model_inference/stage_4.py +from manim import * + +class Stage4(Scene): + + def construct(self): + mem = Rectangle(height=0.5, width=0.5) + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + meta_mem = Rectangle(height=0.25, width=0.25) + cpu_left_col_base = [mem.copy() for i in range(6)] + cpu_right_col_base = [mem.copy() for i in range(6)] + cpu_left_col = VGroup(*cpu_left_col_base).arrange(UP, buff=0) + cpu_right_col = VGroup(*cpu_right_col_base).arrange(UP, buff=0) + cpu_rects = VGroup(cpu_left_col, cpu_right_col).arrange(RIGHT, buff=0) + cpu_text = Text('CPU', font_size=24) + cpu = Group(cpu_rects, cpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + cpu.move_to([-2.5, -0.5, 0]) + self.add(cpu) + gpu_base = [mem.copy() for i in range(4)] + gpu_rect = VGroup(*gpu_base).arrange(UP, buff=0) + gpu_text = Text('GPU', font_size=24) + gpu = Group(gpu_rect, gpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + gpu.move_to([-1, -1, 0]) + self.add(gpu) + model_base = [mem.copy() for i in range(6)] + model_rect = VGroup(*model_base).arrange(RIGHT, buff=0) + model_text = Text('Model', font_size=24) + model = Group(model_rect, model_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + model.move_to([3, -1.0, 0]) + self.add(model) + model_cpu_arr = [] + model_meta_arr = [] + for (i, rect) in enumerate(model_base): + rect.set_stroke(YELLOW) + cpu_target = Rectangle(height=0.46 / 4, width=0.46 / 3).set_stroke(width=0.0).set_fill(YELLOW, opacity=0.7) + if i == 0: + cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT), buff=0.02, direction=UP) + cpu_target.set_x(cpu_target.get_x() + 0.1) + elif i == 3: + cpu_target.next_to(model_cpu_arr[0], direction=UP, buff=0.0) + else: + cpu_target.next_to(model_cpu_arr[i - 1], direction=RIGHT, buff=0.0) + self.add(cpu_target) + model_cpu_arr.append(cpu_target) + self.add(*model_cpu_arr, *model_meta_arr) + disk_left_col_base = [meta_mem.copy() for i in range(6)] + disk_right_col_base = [meta_mem.copy() for i in range(6)] + disk_left_col = VGroup(*disk_left_col_base).arrange(UP, buff=0) + disk_right_col = VGroup(*disk_right_col_base).arrange(UP, buff=0) + disk_rects = VGroup(disk_left_col, disk_right_col).arrange(RIGHT, buff=0) + disk_text = Text('Disk', font_size=24) + disk = Group(disk_rects, disk_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + disk.move_to([-4.0, -1.25, 0]) + self.add(disk_text, disk_rects) + cpu_disk_arr = [] + for i in range(6): + target = fill.copy().set_fill(BLUE, opacity=0.8) + target.move_to(disk_left_col_base[i]).scale(0.5) + cpu_disk_arr.append(target) + self.add(*cpu_disk_arr) + key = Square(side_length=2.2) + key.move_to([-5, 2, 0]) + key_text = MarkupText(f"Key:\n\n● Empty Model", font_size=18) + key_text.move_to([-5, 2.4, 0]) + self.add(key_text, key) + blue_text = MarkupText(f"● Checkpoint", font_size=18) + blue_text.next_to(key_text, DOWN * 2.4, aligned_edge=key_text.get_left()) + self.add(blue_text) + step_5 = MarkupText(f'The offloaded weights are all sent to the CPU.', font_size=24) + step_5.move_to([2, 2, 0]) + self.play(Write(step_5, run_time=3)) + for i in range(6): + rect = cpu_disk_arr[i] + cp2 = rect.copy().set_fill(BLUE, opacity=0.8).scale(2.0) + cp2.generate_target() + cp2.target.move_to(model_base[i]) + if i == 0: + rect.set_fill(BLUE, opacity=0.8) + rect.generate_target() + rect.target.move_to(cpu_left_col_base[0]).scale(2.0) + self.remove(*model_meta_arr, *model_cpu_arr) + else: + rect.generate_target() + rect.target.move_to(cpu_left_col_base[i]).scale(2.0) + self.play(MoveToTarget(rect), MoveToTarget(cp2), model_base[i].animate.set_stroke(WHITE)) + self.play(FadeOut(step_5)) + step_5 = MarkupText(f'Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.', font_size=24) + step_5.move_to([2, 2, 0]) + self.play(Write(step_5, run_time=3)) + arrows = [] + animations = [] + for i in range(6): + a = Arrow(start=UP, end=DOWN, color=RED, buff=0.5) + a.next_to(model_base[i].get_left(), UP, buff=0.2) + arrows.append(a) + animations.append(Write(a)) + self.play(*animations) + self.wait() + +# File: accelerate-main/manim_animations/big_model_inference/stage_5.py +from manim import * + +class Stage5(Scene): + + def construct(self): + mem = Rectangle(height=0.5, width=0.5) + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + meta_mem = Rectangle(height=0.25, width=0.25) + cpu_left_col_base = [mem.copy() for i in range(6)] + cpu_right_col_base = [mem.copy() for i in range(6)] + cpu_left_col = VGroup(*cpu_left_col_base).arrange(UP, buff=0) + cpu_right_col = VGroup(*cpu_right_col_base).arrange(UP, buff=0) + cpu_rects = VGroup(cpu_left_col, cpu_right_col).arrange(RIGHT, buff=0) + cpu_text = Text('CPU', font_size=24) + cpu = Group(cpu_rects, cpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + cpu.move_to([-2.5, -0.5, 0]) + self.add(cpu) + gpu_base = [mem.copy() for i in range(4)] + gpu_rect = VGroup(*gpu_base).arrange(UP, buff=0) + gpu_text = Text('GPU', font_size=24) + gpu = Group(gpu_rect, gpu_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + gpu.move_to([-1, -1, 0]) + self.add(gpu) + model_base = [mem.copy() for i in range(6)] + model_rect = VGroup(*model_base).arrange(RIGHT, buff=0) + model_text = Text('Model', font_size=24) + model = Group(model_rect, model_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + model.move_to([3, -1.0, 0]) + self.add(model) + model_arr = [] + model_cpu_arr = [] + for (i, rect) in enumerate(model_base): + target = fill.copy().set_fill(BLUE, opacity=0.8) + target.move_to(rect) + model_arr.append(target) + cpu_target = Rectangle(height=0.46, width=0.46).set_stroke(width=0.0).set_fill(BLUE, opacity=0.8) + cpu_target.move_to(cpu_left_col_base[i]) + model_cpu_arr.append(cpu_target) + self.add(*model_arr, *model_cpu_arr) + disk_left_col_base = [meta_mem.copy() for i in range(6)] + disk_right_col_base = [meta_mem.copy() for i in range(6)] + disk_left_col = VGroup(*disk_left_col_base).arrange(UP, buff=0) + disk_right_col = VGroup(*disk_right_col_base).arrange(UP, buff=0) + disk_rects = VGroup(disk_left_col, disk_right_col).arrange(RIGHT, buff=0) + disk_text = Text('Disk', font_size=24) + disk = Group(disk_rects, disk_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + disk.move_to([-4, -1.25, 0]) + self.add(disk_text, disk_rects) + key = Square(side_length=2.2) + key.move_to([-5, 2, 0]) + key_text = MarkupText(f"Key:\n\n● Empty Model", font_size=18) + key_text.move_to([-5, 2.4, 0]) + self.add(key_text, key) + blue_text = MarkupText(f"● Checkpoint", font_size=18) + blue_text.next_to(key_text, DOWN * 2.4, aligned_edge=key_text.get_left()) + self.add(blue_text) + step_6 = MarkupText(f'Now watch as an input is passed through the model\nand how the memory is utilized and handled.', font_size=24) + step_6.move_to([2, 2, 0]) + self.play(Write(step_6)) + input = Square(0.3) + input.set_fill(RED, opacity=1.0) + input.set_stroke(width=0.0) + input.next_to(model_base[0], LEFT, buff=0.5) + self.play(Write(input)) + input.generate_target() + input.target.next_to(model_arr[0], direction=LEFT, buff=0.02) + self.play(MoveToTarget(input)) + self.play(FadeOut(step_6)) + a = Arrow(start=UP, end=DOWN, color=RED, buff=0.5) + a.next_to(model_arr[0].get_left(), UP, buff=0.2) + model_cpu_arr[0].generate_target() + model_cpu_arr[0].target.move_to(gpu_rect[0]) + step_7 = MarkupText(f'As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.', font_size=24) + step_7.move_to([2, 2, 0]) + self.play(Write(step_7, run_time=3)) + circ_kwargs = {'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02} + self.play(Write(a), Circumscribe(model_arr[0], color=ORANGE, **circ_kwargs), Circumscribe(model_cpu_arr[0], color=ORANGE, **circ_kwargs), Circumscribe(gpu_rect[0], color=ORANGE, **circ_kwargs)) + self.play(MoveToTarget(model_cpu_arr[0])) + a_c = a.copy() + for i in range(6): + a_c.next_to(model_arr[i].get_right() + 0.02, UP, buff=0.2) + input.generate_target() + input.target.move_to(model_arr[i].get_right() + 0.02) + grp = AnimationGroup(FadeOut(a, run_time=0.5), MoveToTarget(input, run_time=0.5), FadeIn(a_c, run_time=0.5), lag_ratio=0.2) + self.play(grp) + model_cpu_arr[i].generate_target() + model_cpu_arr[i].target.move_to(cpu_left_col_base[i]) + if i < 5: + model_cpu_arr[i + 1].generate_target() + model_cpu_arr[i + 1].target.move_to(gpu_rect[0]) + if i >= 1: + circ_kwargs['run_time'] = 0.7 + self.play(Circumscribe(model_arr[i], **circ_kwargs), Circumscribe(cpu_left_col_base[i], **circ_kwargs), Circumscribe(cpu_left_col_base[i + 1], color=ORANGE, **circ_kwargs), Circumscribe(gpu_rect[0], color=ORANGE, **circ_kwargs), Circumscribe(model_arr[i + 1], color=ORANGE, **circ_kwargs)) + if i < 1: + self.play(MoveToTarget(model_cpu_arr[i]), MoveToTarget(model_cpu_arr[i + 1])) + else: + self.play(MoveToTarget(model_cpu_arr[i], run_time=0.7), MoveToTarget(model_cpu_arr[i + 1], run_time=0.7)) + else: + model_cpu_arr[i].generate_target() + model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]) + input.generate_target() + input.target.next_to(model_arr[-1].get_right(), RIGHT + 0.02, buff=0.2) + self.play(Circumscribe(model_arr[-1], color=ORANGE, **circ_kwargs), Circumscribe(cpu_left_col_base[-1], color=ORANGE, **circ_kwargs), Circumscribe(gpu_rect[0], color=ORANGE, **circ_kwargs)) + self.play(MoveToTarget(model_cpu_arr[i])) + a = a_c + a_c = a_c.copy() + input.generate_target() + input.target.next_to(model_base[-1], RIGHT + 0.02, buff=0.5) + self.play(FadeOut(step_7), FadeOut(a, run_time=0.5)) + step_8 = MarkupText(f'Inference on a model too large for GPU memory\nis successfully completed.', font_size=24) + step_8.move_to([2, 2, 0]) + self.play(Write(step_8, run_time=3), MoveToTarget(input)) + self.wait() + +# File: accelerate-main/manim_animations/dataloaders/stage_0.py +from manim import * + +class Stage0(Scene): + + def construct(self): + mascot = ImageMobject('mascot_bookie.png') + mascot.scale(0.35) + mascot.move_to([-3.75, -1, 0]) + text = Paragraph('Distributed Training,\nHugging Face Accelerate,\nand PyTorch DataLoaders\n\nHow do they all interact?', font_size=36, line_spacing=1, alignment='center', weight=BOLD) + text.move_to([1.75, 0.5, 0]) + self.add(mascot) + self.add(text) + +# File: accelerate-main/manim_animations/dataloaders/stage_1.py +from manim import * + +class Stage01(Scene): + + def construct(self): + mascot = ImageMobject('mascot_bookie.png') + mascot.scale(0.35) + mascot.move_to([-3.75, -1, 0]) + text = Paragraph('Distributed Training,\nHugging Face Accelerate,\nand PyTorch DataLoaders\n\nHow do they all interact?', font_size=36, line_spacing=1, alignment='center', weight=BOLD) + text.move_to([1.75, 0.5, 0]) + self.add(mascot) + self.add(text) + +# File: accelerate-main/manim_animations/dataloaders/stage_2.py +from manim import * + +class Stage2(Scene): + + def construct(self): + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + columns = [VGroup(*[Rectangle(height=0.25, width=0.25, color='green') for i in range(8)]).arrange(RIGHT, buff=0) for j in range(4)] + dataset_recs = VGroup(*columns).arrange(UP, buff=0) + dataset_text = Text('Dataset', font_size=24) + dataset = Group(dataset_recs, dataset_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + dataset.move_to([-2, 0, 0]) + self.add(dataset) + code = Code(code='dataloader = DataLoader(...)\nfor batch in dataloader():\n\t...', tab_width=4, background='window', language='Python', font='Monospace', font_size=14, corner_radius=0.2, insert_line_no=False, line_spacing=0.75, style=Code.styles_list[1]) + code.move_to([-3.5, 2.5, 0]) + self.add(code) + dataloader = Group(Rectangle(color='red', height=2, width=2), Text('DataLoader', font_size=24)).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + sampler = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + dataloader.move_to([1, 0, 0]) + sampler.move_to([0.75, 0.25, 0]) + self.add(dataloader) + self.add(sampler) + gpu_1 = Group(Rectangle(color='white', height=1, width=1), Text('GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4, 2, 0]) + gpu_2 = Group(Rectangle(color='white', height=1, width=1), Text('GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4, 0.5, 0]) + gpu_3 = Group(Rectangle(color='white', height=1, width=1), Text('GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4, -1, 0]) + gpu_4 = Group(Rectangle(color='white', height=1, width=1), Text('GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4, -2.5, 0]) + gpus = [gpu_1[0], gpu_2[0], gpu_3[0], gpu_4[0]] + self.add(gpu_1, gpu_2, gpu_3, gpu_4) + self.play(Create(gpu_1[0], run_time=0.5), Create(gpu_2[0], run_time=0.5), Create(gpu_3[0], run_time=0.5), Create(gpu_4[0], run_time=0.5), Create(dataset_recs, run_time=1), Create(sampler[0], run_time=1), Create(dataloader[0], run_time=1)) + step_1 = MarkupText(f'Without any special care, \nthe same data is sent though each sampler, \nand the same samples are spit out on each GPU', font_size=18) + step_1.move_to([0, -2.5, 0]) + self.play(Write(step_1, run_time=4)) + first_animations = [] + second_animations = [] + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + current_color = colors[0] + buff = 0 + lr_buff = 0.25 + old_target = None + new_datasets = [] + for (i, data) in enumerate(dataset_recs[-1]): + if i % 2 == 0: + current_color = 'BLUE_E' + dataset_target = Rectangle(height=0.46 / 2, width=0.46 / 2).set_stroke(width=0.0).set_fill(current_color, opacity=0.7) + dataset_target.move_to(data) + dataset_target.generate_target() + aligned_edge = ORIGIN + if i % 2 == 0: + old_target = dataset_target.target + buff -= 0.25 + aligned_edge = LEFT + dataset_target.target.next_to(sampler, buff=buff, direction=UP, aligned_edge=LEFT) + else: + dataset_target.target.next_to(old_target, direction=RIGHT, buff=0.01) + new_datasets.append(dataset_target) + first_animations.append(data.animate(run_time=0.5).set_stroke(current_color)) + second_animations.append(MoveToTarget(dataset_target, run_time=1.5)) + self.play(*first_animations) + self.play(*second_animations) + self.wait() + move_animation = [] + for (j, gpu) in enumerate(gpus): + buff = 0 + for (i, data) in enumerate(new_datasets): + if i % 2 == 0: + current_color = colors[i // 2] + if j != 3: + data = data.copy() + data.generate_target() + aligned_edge = ORIGIN + if i % 2 == 0: + old_target = data.target + buff -= 0.25 + aligned_edge = LEFT + data.target.next_to(gpu, buff=buff, direction=UP, aligned_edge=LEFT) + else: + data.target.next_to(old_target, direction=RIGHT, buff=0.01) + move_animation.append(MoveToTarget(data, run_time=1.5)) + self.play(*move_animation) + self.remove(step_1) + step_2 = MarkupText(f'This behavior is undesireable, because we want\neach GPU to see different data for efficient training.', font_size=18) + step_2.move_to([0, -2.5, 0]) + self.play(Write(step_2, run_time=2.5)) + self.wait() + +# File: accelerate-main/manim_animations/dataloaders/stage_3.py +from manim import * + +class Stage3(Scene): + + def construct(self): + step_1 = MarkupText(f'To combat this, Accelerate employs one of two different\nSampler wrapper methods depending on the scenario:', font_size=24) + step_1.move_to([0, 1.5, 0]) + self.add(step_1) + step_2 = MarkupText(f"1. Sharding the dataset before drawing:\n\t● IterableDatasetShard\n\t● BatchSamplerShard", font_size=24).next_to(step_1, direction=DOWN, aligned_edge=LEFT) + self.add(step_2) + step_3 = MarkupText(f"\n\n2. Splitting the batch after drawing:\n\t● DataLoaderDispatcher", font_size=24).next_to(step_2, direction=DOWN, aligned_edge=LEFT) + self.add(step_3) + +# File: accelerate-main/manim_animations/dataloaders/stage_4.py +from manim import * + +class Stage4(Scene): + + def construct(self): + step_1 = MarkupText(f"To understand the next part fully, let's define two terms,\n`batch_size` and `global_batch_size`:", font_size=18) + step_1.move_to([0, 1.5, 0]) + step_2 = MarkupText(f"\n\n● `batch_size`: \n\tThis will be defined as the batch size seen on a given\n\t*individual* GPU", font_size=18).next_to(step_1, direction=DOWN, aligned_edge=LEFT) + step_3 = MarkupText(f"\n\n● `global_batch_size`:\n\tThis will be defined as the *total* number of\n\tdifferent items seen in the dataset, across all GPUs", font_size=18).next_to(step_2, direction=DOWN, aligned_edge=LEFT) + step_4 = MarkupText(f'\n\nSo if we have a dataset of 64 items, 8 GPUs, \nand a `batch_size` of 8, each *step* will go through\nthe entire dataset one time as 8*8=64', font_size=18).next_to(step_3, direction=DOWN, aligned_edge=LEFT) + self.play(Write(step_1, run_time=4)) + self.play(Write(step_2, run_time=4)) + self.play(Write(step_3, run_time=4)) + self.play(Write(step_4, run_time=6)) + self.wait() + +# File: accelerate-main/manim_animations/dataloaders/stage_5.py +from manim import * + +class Stage5(Scene): + + def construct(self): + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + columns = [VGroup(*[Rectangle(height=0.25, width=0.25, color=colors[j]) for i in range(8)]).arrange(RIGHT, buff=0) for j in range(4)] + dataset_recs = VGroup(*columns).arrange(UP, buff=0) + dataset_text = Text('Dataset', font_size=24) + dataset = Group(dataset_recs, dataset_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + dataset.move_to([-2, 0, 0]) + self.add(dataset) + code = Code(code='# We enable this by default\naccelerator = Accelerator()\ndataloader = DataLoader(...)\ndataloader = accelerator.prepare(dataloader)\nfor batch in dataloader:\n\t...', tab_width=4, background='window', language='Python', font='Monospace', font_size=14, corner_radius=0.2, insert_line_no=False, line_spacing=0.75, style=Code.styles_list[1]) + code.move_to([-3.5, 2.5, 0]) + self.add(code) + sampler_1 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_2 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_3 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_4 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_1.move_to([2, 2, 0]) + sampler_2.move_to([2, 0.5, 0]) + sampler_3.move_to([2, -1.0, 0]) + sampler_4.move_to([2, -2.5, 0]) + self.add(sampler_1, sampler_2, sampler_3, sampler_4) + samplers = [sampler_1[0], sampler_2[0], sampler_3[0], sampler_4[0]] + gpu_1 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, 2, 0]) + gpu_2 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, 0.5, 0]) + gpu_3 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, -1, 0]) + gpu_4 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, -2.5, 0]) + gpus = [gpu_1[0], gpu_2[0], gpu_3[0], gpu_4[0]] + self.add(gpu_1, gpu_2, gpu_3, gpu_4) + self.play(Create(gpu_1[0], run_time=1), Create(gpu_2[0], run_time=1), Create(gpu_3[0], run_time=1), Create(gpu_4[0], run_time=1), Create(dataset_recs, run_time=1), Create(sampler_1[0], run_time=1), Create(sampler_2[0], run_time=1), Create(sampler_3[0], run_time=1), Create(sampler_4[0], run_time=1)) + first_animations = [] + second_animations = [] + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + current_color = colors[0] + buff = 0 + lr_buff = 0.25 + old_target = None + new_datasets = [] + for (i, row_data) in enumerate(dataset_recs): + new_row = [] + current_color = colors[i] + if i == 0: + idx = -3 + elif i == 1: + idx = -2 + elif i == 2: + idx = -1 + elif i == 3: + idx = 0 + for (j, indiv_data) in enumerate(row_data): + dataset_target = Rectangle(height=0.46 / 2, width=0.46 / 2).set_stroke(width=0.0).set_fill(current_color, opacity=0.7) + dataset_target.move_to(indiv_data) + dataset_target.generate_target() + aligned_edge = ORIGIN + if j % 8 == 0: + aligned_edge = LEFT + dataset_target.target.next_to(samplers[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + dataset_target.target.set_x(dataset_target.target.get_x()) + elif j % 4 == 0: + old_target = dataset_target.target + dataset_target.target.next_to(samplers[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + dataset_target.target.set_x(dataset_target.target.get_x()) + dataset_target.target.set_y(dataset_target.target.get_y() - 0.25) + else: + dataset_target.target.next_to(old_target, direction=RIGHT, buff=0.02) + old_target = dataset_target.target + new_row.append(dataset_target) + first_animations.append(indiv_data.animate(run_time=0.5).set_stroke(current_color)) + second_animations.append(MoveToTarget(dataset_target, run_time=1.5)) + new_datasets.append(new_row) + step_1 = MarkupText(f'Since we splice the dataset between each GPU,\nthe models weights can be averaged during `backward()`\nActing as though we did one giant epoch\nvery quickly.', font_size=18) + step_1.move_to([-2.5, -2, 0]) + self.play(Write(step_1, run_time=3)) + self.play(*first_animations) + self.play(*second_animations) + self.wait(duration=0.5) + move_animation = [] + import random + for (i, row) in enumerate(new_datasets): + current_color = colors[i] + if i == 0: + idx = -3 + elif i == 1: + idx = -2 + elif i == 2: + idx = -1 + elif i == 3: + idx = 0 + for (j, indiv_data) in enumerate(row): + indiv_data.generate_target() + aligned_edge = ORIGIN + if j % 8 == 0: + aligned_edge = LEFT + indiv_data.target.next_to(gpus[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + indiv_data.target.set_x(indiv_data.target.get_x()) + elif j % 4 == 0: + indiv_data.target.next_to(gpus[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + indiv_data.target.set_x(indiv_data.target.get_x()) + indiv_data.target.set_y(indiv_data.target.get_y() - 0.25) + else: + indiv_data.target.next_to(old_target, direction=RIGHT, buff=0.02) + old_target = indiv_data.target + move_animation.append(MoveToTarget(indiv_data, run_time=1.5)) + self.play(*move_animation) + self.wait() + +# File: accelerate-main/manim_animations/dataloaders/stage_6.py +from manim import * + +class Stage6(Scene): + + def construct(self): + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + columns = [VGroup(*[Rectangle(height=0.25, width=0.25, color=colors[j]) for i in range(8)]).arrange(RIGHT, buff=0) for j in range(4)] + dataset_recs = VGroup(*columns).arrange(UP, buff=0) + dataset_text = Text('Dataset', font_size=24) + dataset = Group(dataset_recs, dataset_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + dataset.move_to([-2, 0, 0]) + self.add(dataset) + code = Code(code='# We enable this by default\naccelerator = Accelerator()\ndataloader = DataLoader(..., shuffle=True)\ndataloader = accelerator.prepare(dataloader)\nfor batch in dataloader:\n\t...', tab_width=4, background='window', language='Python', font='Monospace', font_size=14, corner_radius=0.2, insert_line_no=False, line_spacing=0.75, style=Code.styles_list[1]) + code.move_to([-3.5, 2.5, 0]) + self.add(code) + sampler_1 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_2 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_3 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_4 = Group(Rectangle(color='blue', height=1, width=1), Text('Sampler GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_1.move_to([2, 2, 0]) + sampler_2.move_to([2, 0.5, 0]) + sampler_3.move_to([2, -1.0, 0]) + sampler_4.move_to([2, -2.5, 0]) + self.add(sampler_1, sampler_2, sampler_3, sampler_4) + samplers = [sampler_1[0], sampler_2[0], sampler_3[0], sampler_4[0]] + gpu_1 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, 2, 0]) + gpu_2 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, 0.5, 0]) + gpu_3 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, -1, 0]) + gpu_4 = Group(Rectangle(color='white', height=1, width=1), Text('Output GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, -2.5, 0]) + gpus = [gpu_1[0], gpu_2[0], gpu_3[0], gpu_4[0]] + self.add(gpu_1, gpu_2, gpu_3, gpu_4) + first_animations = [] + second_animations = [] + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + current_color = colors[0] + buff = 0 + lr_buff = 0.25 + old_target = None + new_datasets = [] + for (i, row_data) in enumerate(dataset_recs): + new_row = [] + current_color = colors[i] + if i == 0: + idx = -3 + elif i == 1: + idx = -2 + elif i == 2: + idx = -1 + elif i == 3: + idx = 0 + for (j, indiv_data) in enumerate(row_data): + dataset_target = Rectangle(height=0.46 / 2, width=0.46 / 2).set_stroke(width=0.0).set_fill(current_color, opacity=0.7) + dataset_target.move_to(indiv_data) + dataset_target.generate_target() + aligned_edge = ORIGIN + if j % 8 == 0: + aligned_edge = LEFT + old_target = dataset_target.target + dataset_target.target.next_to(samplers[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + dataset_target.target.set_x(dataset_target.target.get_x()) + elif j % 4 == 0: + old_target = dataset_target.target + dataset_target.target.next_to(samplers[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + dataset_target.target.set_x(dataset_target.target.get_x()) + dataset_target.target.set_y(dataset_target.target.get_y() - 0.25) + else: + dataset_target.target.next_to(old_target, direction=RIGHT, buff=0.02) + old_target = dataset_target.target + new_row.append(dataset_target) + first_animations.append(indiv_data.animate(run_time=0.5).set_stroke(current_color)) + second_animations.append(MoveToTarget(dataset_target, run_time=1.5)) + new_datasets.append(new_row) + step_1 = MarkupText(f"During shuffling, each mini-batch's\noutput order will be modified", font_size=18) + step_1.move_to([-1.5, -2, 0]) + self.play(Write(step_1, run_time=3)) + self.play(*first_animations) + self.play(*second_animations) + self.wait(duration=0.5) + move_animation = [] + import random + for (i, row) in enumerate(new_datasets): + row = [row[k] for k in random.sample(range(8), 8)] + current_color = colors[i] + if i == 0: + idx = -3 + elif i == 1: + idx = -2 + elif i == 2: + idx = -1 + elif i == 3: + idx = 0 + for (j, indiv_data) in enumerate(row): + indiv_data.generate_target() + aligned_edge = ORIGIN + if j % 8 == 0: + aligned_edge = LEFT + indiv_data.target.next_to(gpus[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + indiv_data.target.set_x(indiv_data.target.get_x()) + elif j % 4 == 0: + indiv_data.target.next_to(gpus[abs(idx)].get_corner(UP + LEFT), buff=0.02, direction=RIGHT + DOWN) + indiv_data.target.set_x(indiv_data.target.get_x()) + indiv_data.target.set_y(indiv_data.target.get_y() - 0.25) + else: + indiv_data.target.next_to(old_target, direction=RIGHT, buff=0.02) + old_target = indiv_data.target + move_animation.append(MoveToTarget(indiv_data, run_time=1.5)) + self.play(*move_animation) + self.wait() + +# File: accelerate-main/manim_animations/dataloaders/stage_7.py +from manim import * + +class Stage7(Scene): + + def construct(self): + code = Code(code='accelerator = Accelerator(dispatch_batches=True)\ndataloader = DataLoader(...)\ndataloader = accelerator.prepare(dataloader)\nfor batch in dataloader:\n\t...', tab_width=4, background='window', language='Python', font='Monospace', font_size=14, corner_radius=0.2, insert_line_no=False, line_spacing=0.75, style=Code.styles_list[1]) + code.move_to([-3.5, 2.5, 0]) + self.add(code) + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + fill = Rectangle(height=0.46, width=0.46).set_stroke(width=0) + columns = [VGroup(*[Rectangle(height=0.25, width=0.25, color=colors[j]) for i in range(8)]).arrange(RIGHT, buff=0) for j in range(4)] + dataset_recs = VGroup(*columns).arrange(UP, buff=0) + dataset_text = Text('Dataset', font_size=24) + dataset = Group(dataset_recs, dataset_text).arrange(DOWN, buff=0.5, aligned_edge=DOWN) + dataset.move_to([-2, 0, 0]) + self.add(dataset) + sampler_1 = Group(Rectangle(color='blue', height=1.02, width=1.02), Text('Sampler GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_2 = Group(Rectangle(color='blue', height=1.02, width=1.02), Text('Sampler GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_3 = Group(Rectangle(color='blue', height=1.02, width=1.02), Text('Sampler GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_4 = Group(Rectangle(color='blue', height=1.02, width=1.02), Text('Sampler GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN) + sampler_1.move_to([2, 2, 0]) + sampler_2.move_to([2, 0.5, 0]) + sampler_3.move_to([2, -1.0, 0]) + sampler_4.move_to([2, -2.5, 0]) + self.add(sampler_1, sampler_2, sampler_3, sampler_4) + samplers = [sampler_1[0], sampler_2[0], sampler_3[0], sampler_4[0]] + gpu_1 = Group(Rectangle(color='white', height=1.02, width=0.98), Text('Output GPU 1', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, 2, 0]) + gpu_2 = Group(Rectangle(color='white', height=1.02, width=0.98), Text('Output GPU 2', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, 0.5, 0]) + gpu_3 = Group(Rectangle(color='white', height=1.02, width=0.98), Text('Output GPU 3', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, -1, 0]) + gpu_4 = Group(Rectangle(color='white', height=1.02, width=0.98), Text('Output GPU 4', font_size=12)).arrange(DOWN, buff=0.25, aligned_edge=DOWN).move_to([4.5, -2.5, 0]) + gpus = [gpu_1[0], gpu_2[0], gpu_3[0], gpu_4[0]] + self.add(gpu_1, gpu_2, gpu_3, gpu_4) + step_1 = MarkupText(f"When using a `DataLoaderDispatcher`, all\nof the samples are collected from GPU 0's dataset,\nthen divided and sent to each GPU.\nAs a result, this will be slower.", font_size=18) + step_1.move_to([-2.5, -2, 0]) + self.play(Write(step_1, run_time=3.5)) + first_animations = [] + second_animations = [] + colors = ['BLUE_E', 'DARK_BROWN', 'GOLD_E', 'GRAY_A'] + current_color = colors[0] + ud_buff = 0.01 + lr_buff = 0.01 + old_target = None + new_datasets = [] + for (i, row_data) in enumerate(dataset_recs): + new_row = [] + current_color = colors[i] + for (j, indiv_data) in enumerate(row_data): + dataset_target = Rectangle(height=0.46 / 4, width=0.46 / 2).set_stroke(width=0.0).set_fill(current_color, opacity=0.7) + dataset_target.move_to(indiv_data) + dataset_target.generate_target() + aligned_edge = ORIGIN + if j % 8 == 0: + aligned_edge = LEFT + dataset_target.target.next_to(samplers[0].get_corner(DOWN + LEFT), buff=0.0125, direction=RIGHT + UP) + dataset_target.target.set_x(dataset_target.target.get_x()) + dataset_target.target.set_y(dataset_target.target.get_y() + 0.25 * i) + elif j % 4 == 0: + old_target = dataset_target.target + dataset_target.target.next_to(samplers[0].get_corner(DOWN + LEFT), buff=0.0125, direction=RIGHT + UP) + dataset_target.target.set_x(dataset_target.target.get_x()) + dataset_target.target.set_y(dataset_target.target.get_y() + 0.125 + 0.25 * i) + else: + dataset_target.target.next_to(old_target, direction=RIGHT, buff=0.0125) + old_target = dataset_target.target + new_row.append(dataset_target) + first_animations.append(indiv_data.animate(run_time=0.5).set_stroke(current_color)) + second_animations.append(MoveToTarget(dataset_target, run_time=1.5)) + new_datasets.append(new_row) + self.play(*first_animations) + self.play(*second_animations) + move_animation = [] + for (i, row) in enumerate(new_datasets): + current_color = colors[i] + if i == 0: + idx = -3 + elif i == 1: + idx = -2 + elif i == 2: + idx = -1 + elif i == 3: + idx = 0 + for (j, indiv_data) in enumerate(row): + indiv_data.generate_target() + indiv_data.animate.stretch_to_fit_height(0.46 / 2) + aligned_edge = ORIGIN + if j % 8 == 0: + aligned_edge = LEFT + indiv_data.target.next_to(gpus[abs(idx)].get_corner(UP + LEFT), buff=0.01, direction=RIGHT + DOWN) + indiv_data.target.set_x(indiv_data.target.get_x()) + indiv_data.target.set_y(indiv_data.target.get_y() - 0.25) + elif j % 4 == 0: + indiv_data.target.next_to(gpus[abs(idx)].get_corner(UP + LEFT), buff=0.01, direction=RIGHT + DOWN) + indiv_data.target.set_x(indiv_data.target.get_x()) + else: + indiv_data.target.next_to(old_target, direction=RIGHT, buff=0.01) + old_target = indiv_data.target + move_animation.append(MoveToTarget(indiv_data, run_time=1.5)) + self.play(*move_animation) + self.wait() + +# File: accelerate-main/src/accelerate/__init__.py +__version__ = '0.35.0.dev0' +from .accelerator import Accelerator +from .big_modeling import cpu_offload, cpu_offload_with_hook, disk_offload, dispatch_model, init_empty_weights, init_on_device, load_checkpoint_and_dispatch +from .data_loader import skip_first_batches +from .inference import prepare_pippy +from .launchers import debug_launcher, notebook_launcher +from .state import PartialState +from .utils import AutocastKwargs, DataLoaderConfiguration, DDPCommunicationHookType, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, FullyShardedDataParallelPlugin, GradScalerKwargs, InitProcessGroupKwargs, ProfileKwargs, find_executable_batch_size, infer_auto_device_map, is_rich_available, load_checkpoint_in_model, synchronize_rng_states +if is_rich_available(): + from .utils import rich + +# File: accelerate-main/src/accelerate/accelerator.py +from __future__ import annotations +import contextlib +import functools +import json +import math +import os +import re +import shutil +import sys +import warnings +from collections import OrderedDict +from contextlib import contextmanager +from functools import partial +from types import MethodType +from typing import Any, Callable, Union +import torch +import torch.utils.hooks as hooks +from huggingface_hub import split_torch_state_dict_into_shards +from .checkpointing import load_accelerator_state, load_custom_state, save_accelerator_state, save_custom_state +from .data_loader import DataLoaderDispatcher, prepare_data_loader, skip_first_batches +from .hooks import AlignDevicesHook +from .logging import get_logger +from .optimizer import AcceleratedOptimizer +from .scheduler import AcceleratedScheduler +from .state import AcceleratorState, GradientState, PartialState +from .tracking import LOGGER_TYPE_TO_CLASS, GeneralTracker, filter_trackers +from .utils import MODEL_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SAFE_WEIGHTS_PATTERN_NAME, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, WEIGHTS_PATTERN_NAME, AutocastKwargs, DataLoaderConfiguration, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FP8RecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProfileKwargs, ProjectConfiguration, RNGType, TorchDynamoPlugin, apply_fp8_autowrap, check_os_kernel, clean_state_dict_for_safetensors, compare_versions, convert_model, convert_outputs_to_fp32, extract_model_from_parallel, gather, gather_object, get_mixed_precision_context_manager, get_pretty_name, is_bf16_available, is_deepspeed_available, is_ipex_available, is_lomo_available, is_megatron_lm_available, is_mlu_available, is_msamp_available, is_musa_available, is_npu_available, is_torch_version, is_torch_xla_available, is_transformer_engine_available, is_xpu_available, load_fsdp_model, load_fsdp_optimizer, pad_across_processes, parse_choice_from_env, recursively_apply, reduce, release_memory, save, save_fsdp_model, save_fsdp_optimizer, wait_for_everyone +from .utils.constants import FSDP_PYTORCH_VERSION, PROFILE_PATTERN_NAME +from .utils.modeling import get_state_dict_offloaded_model +from .utils.other import is_compiled_module +if is_deepspeed_available(): + from .utils import DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler +if is_megatron_lm_available(): + from .utils import MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, megatron_lm_initialize, megatron_lm_prepare_data_loader, megatron_lm_prepare_model_optimizer_scheduler +from torch.distributed.algorithms.join import Join +if is_torch_xla_available(): + import torch_xla.amp as xamp + import torch_xla.core.xla_model as xm + import torch_xla.distributed.xla_multiprocessing as xmp +if is_npu_available(check_device=False): + import torch_npu +try: + from torch.optim.lr_scheduler import LRScheduler +except ImportError: + from torch.optim.lr_scheduler import _LRScheduler as LRScheduler +logger = get_logger(__name__) +_split_batches = object() +_dispatch_batches = object() +_even_batches = object() +_use_seedable_sampler = object() + +class Accelerator: + + def __init__(self, device_placement: bool=True, split_batches: bool=_split_batches, mixed_precision: PrecisionType | str | None=None, gradient_accumulation_steps: int=1, cpu: bool=False, dataloader_config: DataLoaderConfiguration | None=None, deepspeed_plugin: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None=None, fsdp_plugin: FullyShardedDataParallelPlugin | None=None, megatron_lm_plugin: MegatronLMPlugin | None=None, rng_types: list[str | RNGType] | None=None, log_with: str | LoggerType | GeneralTracker | list[str | LoggerType | GeneralTracker] | None=None, project_dir: str | os.PathLike | None=None, project_config: ProjectConfiguration | None=None, gradient_accumulation_plugin: GradientAccumulationPlugin | None=None, step_scheduler_with_optimizer: bool=True, kwargs_handlers: list[KwargsHandler] | None=None, dynamo_backend: DynamoBackend | str | None=None, deepspeed_plugins: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None=None): + self.trackers = [] + if project_config is not None: + self.project_configuration = project_config + else: + self.project_configuration = ProjectConfiguration(project_dir=project_dir) + if project_dir is not None and self.project_dir is None: + self.project_configuration.set_directories(project_dir) + if mixed_precision is not None: + mixed_precision = str(mixed_precision) + if mixed_precision not in PrecisionType: + raise ValueError(f'Unknown mixed_precision mode: {mixed_precision}. Choose between {PrecisionType.list()}') + dynamo_plugin = TorchDynamoPlugin() if dynamo_backend is None else TorchDynamoPlugin(backend=dynamo_backend) + if deepspeed_plugins is not None and deepspeed_plugin is not None: + raise ValueError('You cannot pass in both `deepspeed_plugins` and `deepspeed_plugin`.') + elif deepspeed_plugin is not None: + deepspeed_plugins = deepspeed_plugin + if deepspeed_plugins is None: + if PartialState._shared_state != {} and PartialState().distributed_type == DistributedType.DEEPSPEED: + deepspeed_plugins = AcceleratorState().deepspeed_plugins + else: + deepspeed_plugins = DeepSpeedPlugin() if os.environ.get('ACCELERATE_USE_DEEPSPEED', 'false') == 'true' else None + else: + if PartialState().distributed_type == DistributedType.DEEPSPEED and AcceleratorState._shared_state != {} and (AcceleratorState().deepspeed_plugins is not None): + raise NotImplementedError('You cannot pass in a `deepspeed_plugin` when creating a second `Accelerator`. Please make sure the first `Accelerator` is initialized with all the plugins you want to use.') + if isinstance(deepspeed_plugins, dict): + for plugin in deepspeed_plugins.values(): + if not isinstance(plugin, DeepSpeedPlugin): + raise TypeError('`deepspeed_plugin` must be a DeepSpeedPlugin object.') + if deepspeed_plugins is not None: + os.environ['ACCELERATE_USE_DEEPSPEED'] = 'true' + if not is_deepspeed_available(): + raise ImportError('DeepSpeed is not installed => run `pip install deepspeed` or build it from source.') + if is_mlu_available(): + if compare_versions('deepspeed-mlu', '<', '0.10.1'): + raise ImportError('DeepSpeed MLU version must be >= 0.10.1. Please update DeepSpeed MLU.') + elif is_musa_available(): + if compare_versions('deepspeed', '>', '0.14.3'): + raise ImportError('DeepSpeed MUSA version must be <= 0.14.3. Please downgrade DeepSpeed.') + elif compare_versions('deepspeed', '<', '0.9.3'): + raise ImportError('DeepSpeed version must be >= 0.9.3. Please update DeepSpeed.') + mixed_precision = os.environ.get('ACCELERATE_MIXED_PRECISION', 'no') if mixed_precision is None else mixed_precision + if not isinstance(deepspeed_plugins, dict): + deepspeed_plugins.set_mixed_precision(mixed_precision) + deepspeed_plugins.select(_from_accelerator_state=True) + else: + for plugin in deepspeed_plugins.values(): + plugin.set_mixed_precision(mixed_precision) + first_plugin = next(iter(deepspeed_plugins.values())) + first_plugin.select(_from_accelerator_state=True) + self.deepspeed_engine_wrapped = None + if os.environ.get('ACCELERATE_USE_FSDP', 'false') == 'true' or isinstance(fsdp_plugin, FullyShardedDataParallelPlugin): + if not is_torch_version('>=', FSDP_PYTORCH_VERSION): + raise ValueError(f'FSDP requires PyTorch >= {FSDP_PYTORCH_VERSION}') + if fsdp_plugin is None: + fsdp_plugin = FullyShardedDataParallelPlugin() if os.environ.get('ACCELERATE_USE_FSDP', 'false') == 'true' else None + else: + if not isinstance(fsdp_plugin, FullyShardedDataParallelPlugin): + raise TypeError('`fsdp_plugin` must be a FullyShardedDataParallelPlugin object.') + os.environ['ACCELERATE_USE_FSDP'] = 'true' + if megatron_lm_plugin is None: + megatron_lm_plugin = MegatronLMPlugin() if os.environ.get('ACCELERATE_USE_MEGATRON_LM', 'false') == 'true' else None + else: + if not isinstance(megatron_lm_plugin, MegatronLMPlugin): + raise TypeError('`megatron_lm_plugin` must be a MegatronLMPlugin object.') + os.environ['ACCELERATE_USE_MEGATRON_LM'] = 'true' + if megatron_lm_plugin: + if not is_megatron_lm_available(): + raise ImportError('Megatron is not installed. please build it from source.') + self.ddp_handler = None + self.scaler_handler = None + self.init_handler = None + self.fp8_recipe_handler = None + self.autocast_handler = None + self.profile_handler = None + self.has_lomo_optimizer = False + if kwargs_handlers is not None: + for handler in kwargs_handlers: + assert isinstance(handler, KwargsHandler), f'Unsupported kwargs handler passed: {handler}, must be one that inherits `accelerate.utils.KwargsHandler`.' + if isinstance(handler, DistributedDataParallelKwargs): + if self.ddp_handler is not None: + raise ValueError('You can only pass one `DistributedDataParallelKwargs` in `kwargs_handler`.') + else: + self.ddp_handler = handler + elif isinstance(handler, GradScalerKwargs): + if self.scaler_handler is not None: + raise ValueError('You can only pass one `GradScalerKwargs` in `kwargs_handler`.') + else: + self.scaler_handler = handler + elif isinstance(handler, InitProcessGroupKwargs): + if self.init_handler is not None: + raise ValueError('You can only pass one `InitProcessGroupKwargs` in `kwargs_handler`.') + else: + self.init_handler = handler + elif isinstance(handler, FP8RecipeKwargs): + if self.fp8_recipe_handler is not None: + raise ValueError('You can only pass one `FP8RecipeKwargs` in `kwargs_handler`.') + else: + self.fp8_recipe_handler = handler + elif isinstance(handler, AutocastKwargs): + if self.autocast_handler is not None: + raise ValueError('You can only pass one `AutocastKwargs` in `kwargs_handler`.') + else: + self.autocast_handler = handler + elif isinstance(handler, ProfileKwargs): + if self.profile_handler is not None: + raise ValueError('You can only pass one `ProfileKwargs` in `kwargs_handler`.') + else: + self.profile_handler = handler + kwargs = self.init_handler.to_kwargs() if self.init_handler is not None else {} + self.state = AcceleratorState(mixed_precision=mixed_precision, cpu=cpu, dynamo_plugin=dynamo_plugin, deepspeed_plugin=deepspeed_plugins, fsdp_plugin=fsdp_plugin, megatron_lm_plugin=megatron_lm_plugin, _from_accelerator=True, **kwargs) + if self.state.mixed_precision == 'fp8' and self.fp8_recipe_handler is None: + self.fp8_recipe_handler = FP8RecipeKwargs() + self.delayed_fp8_autocast = False + if self.fp8_recipe_handler is not None: + if self.state.mixed_precision != 'fp8' and self.distributed_type not in (DistributedType.FSDP, DistributedType.DEEPSPEED): + raise ValueError("Passing in a `FP8RecipeKwargs` object requires setting `mixed_precision='fp8'`.") + self.delayed_fp8_autocast = self.fp8_recipe_handler.backend == 'TE' and self.distributed_type in (DistributedType.MULTI_GPU, DistributedType.FSDP) + trackers = filter_trackers(log_with, self.logging_dir) + if len(trackers) < 1 and log_with is not None: + warnings.warn(f'`log_with={log_with}` was passed but no supported trackers are currently installed.') + self.log_with = trackers + if mixed_precision != 'bf16' and getattr(self.state, 'downcast_bfloat', False) and (self.state.distributedType != DistributedType.XLA): + raise ValueError("Can only use `downcast_bf16` when using `mixed_precision='bf16'` and on a TPU") + if gradient_accumulation_plugin is not None: + if gradient_accumulation_steps != 1: + raise ValueError('You can only pass one of `gradient_accumulation_steps` and `gradient_accumulation_plugin`. Please only pass in the created `GradientAccumulationPlugin` object.') + else: + gradient_accumulation_steps = int(parse_choice_from_env('ACCELERATE_GRADIENT_ACCUMULATION_STEPS', gradient_accumulation_steps)) + gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=gradient_accumulation_steps) + self.gradient_state = GradientState(gradient_accumulation_plugin=gradient_accumulation_plugin) + self.device_placement = device_placement + if dataloader_config is None: + dataloader_config = DataLoaderConfiguration() + self.dataloader_config = dataloader_config + self.step_scheduler_with_optimizer = step_scheduler_with_optimizer + self.scaler = None + self.native_amp = False + if self.state.mixed_precision == 'fp16' and self.device.type != 'cpu' and (self.distributed_type not in (DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM)): + self.native_amp = True + if self.device.type not in ('xpu', 'cuda', 'npu', 'xla', 'mlu', 'musa') or is_torch_xla_available(check_is_tpu=True): + raise ValueError(f'fp16 mixed precision requires a GPU (not {self.device.type!r}).') + kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {} + if self.distributed_type == DistributedType.FSDP: + from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler + self.scaler = ShardedGradScaler(**kwargs) + elif is_torch_xla_available(check_is_gpu=True): + self.scaler = xamp.GradScaler(**kwargs) + elif is_mlu_available(): + self.scaler = torch.mlu.amp.GradScaler(**kwargs) + elif is_musa_available(): + self.scalar = torch.musa.amp.GradScaler(**kwargs) + elif is_npu_available(): + self.scaler = torch.npu.amp.GradScaler(**kwargs) + elif is_xpu_available(): + self.scaler = torch.amp.GradScaler('xpu', **kwargs) + else: + self.scaler = torch.cuda.amp.GradScaler(**kwargs) + elif self.state.mixed_precision == 'bf16' and self.distributed_type not in (DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM): + if self.device.type in ['cpu', 'xpu']: + self.native_amp = True + else: + self.native_amp = is_bf16_available(True) + if mixed_precision == 'bf16' and (not self.native_amp) and (not is_torch_xla_available()): + raise ValueError('bf16 mixed precision requires PyTorch >= 1.10 and a supported device.') + elif self.state.mixed_precision == 'fp8': + self.native_amp = True + if self.fp8_backend == 'MSAMP': + if self.distributed_type == DistributedType.FSDP: + raise NotImplementedError('`accelerate` + `MS-AMP` + `FSDP` is not supported at this time. Please consider using deepspeed, which is supported.') + elif self.distributed_type != DistributedType.DEEPSPEED: + self.scaler = torch.cuda.amp.GradScaler() + self.step = 0 + self._optimizers = [] + self._models = [] + self._schedulers = [] + self._dataloaders = [] + self._custom_objects = [] + self._load_model_state_pre_hook = OrderedDict() + self._save_model_state_pre_hook = OrderedDict() + self.rng_types = rng_types + if self.rng_types is None: + self.rng_types = ['generator'] + self.flag_tensor = None + check_os_kernel() + + @property + def deepspeed_plugin(self): + return self.state.deepspeed_plugin + + @property + def use_distributed(self): + return self.state.use_distributed + + @property + def distributed_type(self): + return self.state.distributed_type + + @property + def num_processes(self): + return self.state.num_processes + + @property + def process_index(self): + return self.state.process_index + + @property + def local_process_index(self): + return self.state.local_process_index + + @property + def device(self): + return self.state.device + + @property + def split_batches(self): + return self.dataloader_config.split_batches + + @property + def dispatch_batches(self): + return self.dataloader_config.dispatch_batches + + @property + def even_batches(self): + return self.dataloader_config.even_batches + + @even_batches.setter + def even_batches(self, value: bool): + self.dataloader_config.even_batches = value + + @property + def use_seedable_sampler(self): + return self.dataloader_config.use_seedable_sampler + + @property + def non_blocking(self): + return self.dataloader_config.non_blocking + + @property + def use_stateful_dataloader(self): + if hasattr(self.dataloader_config, 'use_stateful_dataloader'): + return self.dataloader_config.use_stateful_dataloader + return False + + @property + def project_dir(self): + return self.project_configuration.project_dir + + @property + def logging_dir(self): + return self.project_configuration.logging_dir + + @property + def save_iteration(self): + return self.project_configuration.iteration + + @property + def is_main_process(self): + return self.state.is_main_process + + @property + def is_local_main_process(self): + return self.state.is_local_main_process + + @property + def is_last_process(self): + return self.process_index == self.num_processes - 1 + + @property + def mixed_precision(self): + return self.state.mixed_precision + + @contextmanager + def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool=False): + with PartialState().split_between_processes(inputs, apply_padding=apply_padding) as inputs: + yield inputs + + def on_main_process(self, function: Callable[..., Any]=None): + if function is None: + if 'Accelerator.' in self.__qualname__: + function = self + else: + raise ValueError('The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object.') + + def _inner(*args, **kwargs): + return PartialState().on_main_process(function)(*args, **kwargs) + return _inner + + def on_local_main_process(self, function: Callable[..., Any]=None): + if function is None: + if 'Accelerator.' in self.__qualname__: + function = self + else: + raise ValueError('The `on_local_main_process` decorator must be called with a function on an instantiated `Accelerator` object.') + + def _inner(*args, **kwargs): + return PartialState().on_local_main_process(function)(*args, **kwargs) + return _inner + + def on_last_process(self, function: Callable[..., Any]): + if function is None: + if 'Accelerator.' in self.__qualname__: + function = self + else: + raise ValueError('The `on_last_process` decorator must be called with a function on an instantiated `Accelerator` object.') + + def _inner(*args, **kwargs): + return PartialState().on_last_process(function)(*args, **kwargs) + return _inner + + def on_process(self, function: Callable[..., Any]=None, process_index: int=None): + if self is not None and process_index is not None and (function is None): + return partial(self.on_process, process_index=process_index) + if function is None: + if 'Accelerator.' in self.__qualname__: + function = self + else: + raise ValueError('The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object.') + + def _inner(*args, **kwargs): + return PartialState().on_process(function, process_index)(*args, **kwargs) + return _inner + + def on_local_process(self, function: Callable[..., Any]=None, local_process_index: int=None): + if self is not None and local_process_index is not None and (function is None): + return partial(self.on_local_process, local_process_index=local_process_index) + if function is None: + if 'Accelerator.' in self.__qualname__: + function = self + else: + raise ValueError('The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object.') + + def _inner(*args, **kwargs): + return PartialState().on_local_process(function, local_process_index)(*args, **kwargs) + return _inner + + @contextmanager + def main_process_first(self): + with self.state.main_process_first(): + yield + + @contextmanager + def local_main_process_first(self): + with self.state.local_main_process_first(): + yield + + @contextmanager + def no_sync(self, model): + context = contextlib.nullcontext + if self.use_distributed: + context = getattr(model, 'no_sync', context) + with context(): + yield + + @staticmethod + @contextmanager + def trigger_sync_in_backward(model): + if not isinstance(model, torch.nn.parallel.DistributedDataParallel): + yield + return + old_require_backward_grad_sync = model.require_backward_grad_sync + old_require_forward_param_sync = model.require_forward_param_sync + model.require_backward_grad_sync = True + model.require_forward_param_sync = True + model.reducer.prepare_for_backward([]) + try: + yield + finally: + model.require_backward_grad_sync = old_require_backward_grad_sync + model.require_forward_param_sync = old_require_forward_param_sync + + def _do_sync(self): + if self.gradient_state.sync_with_dataloader and self.gradient_state.end_of_dataloader: + self.step = 0 + self.gradient_state._set_sync_gradients(True) + else: + self.step += 1 + self.gradient_state._set_sync_gradients(self.step % self.gradient_state.num_steps == 0) + + @property + def sync_gradients(self): + return self.gradient_state.sync_gradients + + @sync_gradients.setter + def sync_gradients(self, sync_gradients): + self.gradient_state.sync_gradients = sync_gradients + + @property + def gradient_accumulation_steps(self): + return self.gradient_state.num_steps + + @gradient_accumulation_steps.setter + def gradient_accumulation_steps(self, gradient_accumulation_steps): + self.gradient_state.plugin_kwargs.update({'num_steps': gradient_accumulation_steps}) + + @contextmanager + def accumulate(self, *models): + self._do_sync() + allow_gradient_sync = self.sync_gradients or (self.use_distributed and self.gradient_state.plugin_kwargs.get('sync_each_batch', False)) + with contextlib.ExitStack() as cm_stack: + for m in models: + cm_stack.enter_context(contextlib.nullcontext() if allow_gradient_sync else self.no_sync(m)) + yield + + @contextmanager + def join_uneven_inputs(self, joinables, even_batches=None): + if self.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_XPU): + dl_even_batches_values = [] + if even_batches is not None: + iterable_dl_seen = False + for (dl_idx, dl) in enumerate(self._dataloaders): + if isinstance(dl, DataLoaderDispatcher): + iterable_dl_seen = True + continue + dl_even_batches_values.append((dl_idx, dl.batch_sampler.even_batches)) + dl.batch_sampler.even_batches = even_batches + if iterable_dl_seen: + warnings.warn('Overridding even_batches is only supported for map-style datasets, yet some dataloaders given were iterable') + else: + even_batches = self.even_batches + enable_join = False if even_batches else True + try: + with Join(joinables, enable=enable_join, throw_on_early_termination=False): + yield + finally: + for (dl_idx, even_batches_value) in dl_even_batches_values: + self._dataloaders[dl_idx].batch_sampler.even_batches = even_batches_value + else: + if self.distributed_type != DistributedType.NO: + warnings.warn('Joining uneven inputs is only supported for multi-GPU training, as a result `join_uneven_inputs` will have no effect.') + with contextlib.nullcontext(joinables): + yield + + def print(self, *args, **kwargs): + self.state.print(*args, **kwargs) + + def _prepare_one(self, obj, first_pass=False, device_placement=None): + if first_pass: + if isinstance(obj, torch.utils.data.DataLoader): + return self.prepare_data_loader(obj, device_placement=device_placement) + elif isinstance(obj, torch.nn.Module): + return self.prepare_model(obj, device_placement=device_placement) + elif isinstance(obj, torch.optim.Optimizer): + optimizer = self.prepare_optimizer(obj, device_placement=device_placement) + return optimizer + elif isinstance(obj, LRScheduler): + scheduler = self.prepare_scheduler(obj) + return scheduler + return obj + + def prepare(self, *args, device_placement=None): + if device_placement is None: + device_placement = [None for _ in args] + elif self.distributed_type in (DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM): + raise ValueError("You can't customize device placements with DeepSpeed or Megatron-LM.") + elif len(device_placement) != len(args): + raise ValueError(f'`device_placement` should be a list with {len(args)} elements (the number of objects passed).') + for obj in args: + if isinstance(obj, torch.nn.Module) and self.verify_device_map(obj) and (self.distributed_type != DistributedType.NO) and (os.environ.get('ACCELERATE_BYPASS_DEVICE_MAP', 'false') != 'true'): + raise ValueError("You can't train a model that has been loaded with `device_map='auto'` in any distributed mode. Please rerun your script specifying `--num_processes=1` or by launching with `python {{myscript.py}}`.") + if self.distributed_type == DistributedType.DEEPSPEED: + model_count = 0 + for obj in args: + if isinstance(obj, torch.nn.Module): + model_count += 1 + if model_count > 1: + raise AssertionError("You can't use same `Accelerator()` instance with multiple models when using DeepSpeed") + if self.distributed_type == DistributedType.XLA: + (model_device, optimizer_device) = self._get_devices() + if model_device is not None and optimizer_device is not None and (model_device != optimizer_device): + raise ValueError('The model and the optimizer parameters are not on the same device, which probably means you created an optimizer around your model **before** putting on the device. Make sure the line model.to(device) is before the optimizer creation in your script or remove it entirely and use the flag default value for `device_placement` in your `Accelerator` to let it handle that part for you.') + tpu_should_fix_optimizer = self.device_placement and self.distributed_type == DistributedType.XLA + if tpu_should_fix_optimizer: + old_named_params = self._get_named_parameters(*args) + if self.distributed_type in [DistributedType.MULTI_CPU, DistributedType.MULTI_XPU, DistributedType.NO]: + if self.device.type == 'cpu' and self.state.use_ipex: + args = self._prepare_ipex_or_xpu(*args) + elif self.device.type == 'xpu' and is_xpu_available(): + args = self._prepare_ipex_or_xpu(*args) + if self.fp8_backend == 'TE': + args = self._prepare_te(*args) + if self.distributed_type == DistributedType.DEEPSPEED: + result = self._prepare_deepspeed(*args) + elif self.distributed_type == DistributedType.MEGATRON_LM: + result = self._prepare_megatron_lm(*args) + else: + if self.fp8_backend == 'MSAMP': + (args, device_placement) = self._prepare_msamp(*args, device_placement=device_placement) + result = tuple((self._prepare_one(obj, first_pass=True, device_placement=d) for (obj, d) in zip(args, device_placement))) + result = tuple((self._prepare_one(obj, device_placement=d) for (obj, d) in zip(result, device_placement))) + if tpu_should_fix_optimizer: + new_named_params = self._get_named_parameters(*result) + mapping = {p: new_named_params[n] for (n, p) in old_named_params.items()} + for obj in result: + if isinstance(obj, torch.optim.Optimizer): + obj._switch_parameters(mapping) + for item in result: + if any((item in container for container in (self._dataloaders, self._models, self._optimizers, self._schedulers))): + item._is_accelerate_prepared = True + return result if len(result) > 1 else result[0] + + def prepare_model(self, model: torch.nn.Module, device_placement: bool=None, evaluation_mode: bool=False): + if device_placement is None: + device_placement = self.device_placement and self.distributed_type != DistributedType.FSDP + self._models.append(model) + if self.verify_device_map(model) and self.distributed_type != DistributedType.NO and (os.environ.get('ACCELERATE_BYPASS_DEVICE_MAP', 'false') != 'true'): + raise ValueError("You can't train a model that has been loaded with `device_map='auto'` in any distributed mode. Please rerun your script specifying `--num_processes=1` or by launching with `python {{myscript.py}}`.") + if self.native_amp: + model._original_forward = model.forward + autocast_context = get_mixed_precision_context_manager(self.native_amp, self.autocast_handler) + if self.fp8_backend == 'MSAMP' or not hasattr(model.forward, '__func__'): + model_forward_func = model.forward + model.forward = convert_outputs_to_fp32(autocast_context(model_forward_func)) + else: + model_forward_func = model.forward.__func__ + new_forward = autocast_context(model_forward_func) + model.forward = MethodType(new_forward, model) + model.forward = MethodType(convert_outputs_to_fp32(model.forward.__func__), model) + if self.fp8_backend == 'TE' and (not self.delayed_fp8_autocast): + model = apply_fp8_autowrap(model, self.fp8_recipe_handler) + if (getattr(model, 'is_loaded_in_8bit', False) or getattr(model, 'is_loaded_in_4bit', False)) and getattr(model, 'hf_device_map', False): + model_devices = set(model.hf_device_map.values()) + if len(model_devices) > 1 and self.distributed_type != DistributedType.NO: + raise ValueError("You can't train a model that has been loaded in 8-bit precision on multiple devices in any distributed mode. In order to use 8-bit models that have been loaded across multiple GPUs the solution is to use Naive Pipeline Parallelism. Therefore you should not specify that you are under any distributed regime in your accelerate config.") + elif len(model_devices) == 1: + current_device = list(model_devices)[0] + current_device_index = current_device.index if isinstance(current_device, torch.device) else current_device + if torch.device(current_device_index) != self.device: + if self.device.index is not None or current_device_index != 0: + raise ValueError("You can't train a model that has been loaded in 8-bit precision on a different device than the one you're training on. Make sure you loaded the model on the correct device using for example `device_map={'':torch.cuda.current_device()}` or `device_map={'':torch.xpu.current_device()}`") + if 'cpu' in model_devices or 'disk' in model_devices: + raise ValueError("You can't train a model that has been loaded in 8-bit precision with CPU or disk offload.") + elif device_placement and (not self.verify_device_map(model)): + model = model.to(self.device) + if not evaluation_mode: + if self.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU): + if any((p.requires_grad for p in model.parameters())): + kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {} + if os.environ.get('ACCELERATE_BYPASS_DEVICE_MAP', 'false') != 'true': + (device_ids, output_device) = ([self.local_process_index], self.local_process_index) + else: + (device_ids, output_device) = (None, None) + model = torch.nn.parallel.DistributedDataParallel(model, device_ids=device_ids, output_device=output_device, **kwargs) + if self.ddp_handler is not None: + self.ddp_handler.register_comm_hook(model) + elif self.distributed_type == DistributedType.FSDP: + from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP + is_type_fsdp = isinstance(model, FSDP) or (is_compiled_module(model) and isinstance(model._orig_mod, FSDP)) + if not is_type_fsdp: + self.state.fsdp_plugin.set_auto_wrap_policy(model) + fsdp_plugin = self.state.fsdp_plugin + kwargs = {'sharding_strategy': fsdp_plugin.sharding_strategy, 'cpu_offload': fsdp_plugin.cpu_offload, 'auto_wrap_policy': fsdp_plugin.auto_wrap_policy, 'mixed_precision': fsdp_plugin.mixed_precision_policy, 'sync_module_states': fsdp_plugin.sync_module_states, 'backward_prefetch': fsdp_plugin.backward_prefetch, 'forward_prefetch': fsdp_plugin.forward_prefetch, 'use_orig_params': fsdp_plugin.use_orig_params, 'param_init_fn': fsdp_plugin.param_init_fn, 'ignored_modules': fsdp_plugin.ignored_modules, 'limit_all_gathers': fsdp_plugin.limit_all_gathers, 'device_id': self.device} + model = FSDP(model, **kwargs) + if fsdp_plugin.activation_checkpointing: + from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import CheckpointImpl, apply_activation_checkpointing, checkpoint_wrapper + apply_activation_checkpointing(model, checkpoint_wrapper_fn=functools.partial(checkpoint_wrapper, checkpoint_impl=CheckpointImpl.NO_REENTRANT), auto_wrap_policy=fsdp_plugin.auto_wrap_policy) + if self.mixed_precision != 'no': + upcasted_log = [] + for module in FSDP.fsdp_modules(model): + if not module._has_params: + continue + param = module._flat_param + if param.dtype != torch.float32 and param.device != torch.device('meta') and param.requires_grad: + name_param_log = (module.module.__class__.__name__, ', '.join(module._flat_param._fqns)) + if name_param_log not in upcasted_log: + upcasted_log.append(name_param_log) + param.data = param.data.to(torch.float32) + module._handle._orig_param_dtype = torch.float32 + if self.is_main_process: + for (name_log, param_log) in upcasted_log: + warnings.warn(f'Upcasted low precision parameters in {name_log} because mixed precision turned on in FSDP. Affects: {param_log}.') + if len(upcasted_log) > 0: + warnings.warn('FSDP upcast of low precision parameters may affect the precision of model checkpoints.') + if len(self._models) > 1 and self._models[-2] is self._models[-1]: + del self._models[-2] + self._models[-1] = model + elif self.distributed_type == DistributedType.MULTI_CPU: + kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {} + model = torch.nn.parallel.DistributedDataParallel(model, **kwargs) + if self.ddp_handler is not None: + self.ddp_handler.register_comm_hook(model) + elif self.distributed_type == DistributedType.XLA and self.state.fork_launched: + model = xmp.MpModelWrapper(model).to(self.device) + if self.delayed_fp8_autocast: + model = apply_fp8_autowrap(model, self.fp8_recipe_handler) + if self.state.dynamo_plugin.backend != DynamoBackend.NO and (not is_compiled_module(model)): + if not is_torch_version('>=', '2.0'): + raise ValueError('Using `torch.compile` requires PyTorch 2.0 or higher.') + model = torch.compile(model, **self.state.dynamo_plugin.to_kwargs()) + return model + + def _prepare_te(self, *args): + if not is_transformer_engine_available(): + raise ImportError('`transformer_engine` was not found on your system. Please ensure that `transformer_engine` is installed') + (model, optimizer) = (None, None) + (num_models, num_optimizers) = (0, 0) + result = [obj for obj in args] + for obj in result: + if isinstance(obj, torch.nn.Module): + model = obj + num_models += 1 + elif isinstance(obj, torch.optim.Optimizer): + optimizer = obj + num_optimizers += 1 + if optimizer is None and model is None: + return result + elif optimizer is None or model is None: + raise ValueError('You must pass a model and an optimizer together to `accelerate.prepare()` when using TransformerEngine.') + elif num_models > 1 or num_optimizers > 1: + raise ValueError(f"You can't use multiple models ({num_models}) or optimizers {num_optimizers} with TransformerEngine.") + old_named_params = self._get_named_parameters(model) + with torch.no_grad(): + convert_model(model) + new_named_params = self._get_named_parameters(model) + mapping = {p: new_named_params[n] for (n, p) in old_named_params.items()} + for param_group in optimizer.param_groups: + param_group['params'] = [mapping[p] for p in param_group['params']] + return result + + def _prepare_deepspeed(self, *args): + import deepspeed + ds_initialize = deepspeed.initialize + if self.fp8_backend == 'MSAMP': + from msamp import deepspeed as msamp_deepspeed + ds_initialize = msamp_deepspeed.initialize + deepspeed_plugin = self.deepspeed_plugin + is_dataloader_present = any((isinstance(obj, torch.utils.data.DataLoader) for obj in args)) + result = [self._prepare_one(obj, first_pass=True) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args] + if deepspeed_plugin.is_auto('train_micro_batch_size_per_gpu'): + if is_dataloader_present: + batch_sizes = [obj.batch_size for obj in args if hasattr(obj, 'batch_size')] + if any((bs is None for bs in batch_sizes)): + raise ValueError("At least one of the dataloaders passed to `accelerate.prepare()` has `None` as batch size. Please set an integer value in `train_micro_batch_size_per_gpu` in the deepspeed config file or assign integer value to `AcceleratorState().deepspeed_plugin.deepspeed_config['train_micro_batch_size_per_gpu']`.") + if self.split_batches: + batch_sizes = [batch_size // self.num_processes for batch_size in batch_sizes] + batch_size_per_device = min(batch_sizes) if deepspeed_plugin.is_train_batch_min else max(batch_sizes) + if len(batch_sizes) > 1: + logger.info(f'Since you passed both train and evaluation dataloader, `is_train_batch_min` (here {deepspeed_plugin.is_train_batch_min} will decide the `train_batch_size` ({batch_size_per_device}).') + else: + raise ValueError("When using DeepSpeed, `accelerate.prepare()` requires you to pass at least one of training or evaluation dataloaders with `batch_size` attribute returning an integer value or alternatively set an integer value in `train_micro_batch_size_per_gpu` in the deepspeed config file or assign integer value to `AcceleratorState().deepspeed_plugin.deepspeed_config['train_micro_batch_size_per_gpu']`.") + else: + batch_size_per_device = deepspeed_plugin.get_value('train_micro_batch_size_per_gpu') + deepspeed_plugin.fill_match('gradient_accumulation_steps', must_match=False, gradient_accumulation_steps=self.gradient_accumulation_steps) + config_kwargs = {'gradient_clipping': 1.0, 'zero_optimization.stage3_gather_16bit_weights_on_model_save': False} + if batch_size_per_device is not None: + config_kwargs['train_micro_batch_size_per_gpu'] = batch_size_per_device + config_kwargs['train_batch_size'] = batch_size_per_device * deepspeed_plugin.get_value('gradient_accumulation_steps') * self.num_processes + model = None + optimizer = None + scheduler = None + for obj in result: + if isinstance(obj, torch.nn.Module): + model = obj + elif isinstance(obj, (torch.optim.Optimizer, DummyOptim)): + optimizer = obj + elif isinstance(obj, (LRScheduler, DummyScheduler)) or type(obj).__name__ in deepspeed.runtime.lr_schedules.VALID_LR_SCHEDULES: + scheduler = obj + if optimizer is not None: + if 'optimizer' in deepspeed_plugin.deepspeed_config and (not isinstance(optimizer, DummyOptim)): + raise ValueError('You cannot specify an optimizer in the config file and in the code at the same time. Please remove the optimizer from the config file or create `accelerate.utils.DummyOptim` in the code.') + elif 'optimizer' not in deepspeed_plugin.deepspeed_config and isinstance(optimizer, DummyOptim): + raise ValueError('You cannot create a `DummyOptim` without specifying an optimizer in the config file.') + if isinstance(optimizer, torch.optim.Optimizer): + deepspeed_plugin.deepspeed_config['zero_allow_untested_optimizer'] = True + if scheduler is not None: + if 'scheduler' in deepspeed_plugin.deepspeed_config and (not isinstance(scheduler, DummyScheduler)): + raise ValueError('You cannot specify a scheduler in the config file and in the code at the same time. Please remove the scheduler from the config file or create `accelerate.utils.DummyScheduler` in the code.') + elif 'scheduler' not in deepspeed_plugin.deepspeed_config and isinstance(scheduler, DummyScheduler) and (scheduler.lr_scheduler_callable is None): + raise ValueError('Either specify a scheduler in the config file or pass in the `lr_scheduler_callable` parameter when using `accelerate.utils.DummyScheduler`.') + if optimizer is not None and scheduler is not None: + if isinstance(optimizer, DummyOptim) and (not isinstance(scheduler, DummyScheduler)): + raise ValueError('You can only specify `accelerate.utils.DummyScheduler` in the code when using `accelerate.utils.DummyOptim`.') + if model is not None: + if getattr(self.fp8_recipe_handler, 'backend', None) == 'TE': + model = apply_fp8_autowrap(model, self.fp8_recipe_handler) + deepspeed_plugin.set_moe_leaf_modules(model) + hidden_size_based_keys = ['zero_optimization.reduce_bucket_size', 'zero_optimization.stage3_prefetch_bucket_size', 'zero_optimization.stage3_param_persistence_threshold'] + hidden_size_auto_keys = [x for x in hidden_size_based_keys if deepspeed_plugin.is_auto(x)] + if len(hidden_size_auto_keys) > 0: + reasoning = "therefore it's not possible to automatically fill out the following `auto` entries " + f'in the DeepSpeed config file: {hidden_size_auto_keys}. You can fix that by replacing ' + '`auto` values for these keys with an integer value of your choice.' + if not hasattr(model, 'config'): + raise ValueError("Can't find `model.config` entry, " + reasoning) + if hasattr(model.config, 'hidden_size'): + hidden_size = model.config.hidden_size + elif hasattr(model.config, 'hidden_sizes'): + hidden_size = max(model.config.hidden_sizes) + else: + raise ValueError('Can find neither `model.config.hidden_size` nor `model.config.hidden_sizes`, ' + reasoning) + config_kwargs.update({'zero_optimization.reduce_bucket_size': hidden_size * hidden_size, 'zero_optimization.stage3_prefetch_bucket_size': int(0.9 * hidden_size * hidden_size), 'zero_optimization.stage3_param_persistence_threshold': 10 * hidden_size}) + if isinstance(optimizer, DummyOptim): + config_kwargs.update({'optimizer.params.lr': optimizer.lr, 'optimizer.params.weight_decay': optimizer.weight_decay}) + if isinstance(scheduler, DummyScheduler) and scheduler.lr_scheduler_callable is None: + max_lr = getattr(scheduler.optimizer, 'lr', None) if getattr(scheduler.optimizer, 'defaults', None) is None else scheduler.optimizer.defaults['lr'] + config_kwargs.update({'scheduler.params.warmup_min_lr': 0, 'scheduler.params.warmup_max_lr': max_lr, 'scheduler.params.warmup_num_steps': scheduler.warmup_num_steps}) + if scheduler.total_num_steps is not None: + config_kwargs['scheduler.params.total_num_steps'] = math.ceil(scheduler.total_num_steps / self.num_processes) if not self.split_batches else scheduler.total_num_steps + deepspeed_plugin.deepspeed_config_process(must_match=False, **config_kwargs) + self.deepspeed_config = deepspeed_plugin.deepspeed_config + kwargs = dict(model=model, config_params=self.deepspeed_config) + if optimizer is not None: + if isinstance(optimizer, DummyOptim): + kwargs['model_parameters'] = optimizer.params + if isinstance(scheduler, DummyScheduler) and scheduler.lr_scheduler_callable is not None: + kwargs['lr_scheduler'] = scheduler.lr_scheduler_callable + else: + if self.deepspeed_config['zero_optimization'].get('offload_optimizer', {}).get('device', 'none') != 'none' and self.deepspeed_config.get('zero_force_ds_cpu_optimizer', True): + from deepspeed.ops.adam import DeepSpeedCPUAdam + defaults = {k: v for (k, v) in optimizer.defaults.items() if k in ['lr', 'weight_decay']} + optimizer = DeepSpeedCPUAdam(optimizer.param_groups, **defaults) + kwargs['optimizer'] = optimizer + if scheduler is not None: + if type(scheduler).__name__ in deepspeed.runtime.lr_schedules.VALID_LR_SCHEDULES: + kwargs['lr_scheduler'] = scheduler + (engine, optimizer, _, lr_scheduler) = ds_initialize(**kwargs) + if optimizer is not None: + optimizer = DeepSpeedOptimizerWrapper(optimizer) + if scheduler is not None: + if lr_scheduler is None: + scheduler = AcceleratedScheduler(scheduler, optimizer, step_with_optimizer=self.step_scheduler_with_optimizer, split_batches=self.split_batches) + else: + scheduler = DeepSpeedSchedulerWrapper(lr_scheduler, optimizer) + for i in range(len(result)): + if isinstance(result[i], torch.nn.Module): + result[i] = engine + elif isinstance(result[i], (torch.optim.Optimizer, DummyOptim)): + result[i] = optimizer + elif isinstance(result[i], (LRScheduler, DummyScheduler)) or type(result[i]).__name__ in deepspeed.runtime.lr_schedules.VALID_LR_SCHEDULES: + result[i] = scheduler + if self.deepspeed_engine_wrapped is None: + self.deepspeed_engine_wrapped = DeepSpeedEngineWrapper(engine) + else: + logger.warning('A wrapped DeepSpeed engine reference is currently tied for this `Accelerator()` instance. If you want to call `accelerator.backward()` referencing a new model/engine, please create a separate `Accelerator()` instance and call `accelerator.prepare()` on it.') + self._models.append(engine) + if optimizer is not None: + self._optimizers.append(optimizer) + if scheduler is not None: + self._schedulers.append(scheduler) + return tuple(result) + + def _prepare_megatron_lm(self, *args): + megatron_lm_plugin = self.state.megatron_lm_plugin + micro_batch_size = None + if not megatron_lm_plugin.megatron_dataset_flag: + batch_sizes = [obj.batch_size for obj in args if hasattr(obj, 'batch_size')] + if len(batch_sizes) == 0: + raise ValueError('You must specify a training or evaluation dataloader in `accelerate.prepare()` when using Megatron-LM.') + micro_batch_size = min(batch_sizes) if megatron_lm_plugin.is_train_batch_min else max(batch_sizes) + if len(batch_sizes) > 1: + logger.info(f'Since you passed both train and evaluation dataloader, `is_train_batch_min` (here {megatron_lm_plugin.is_train_batch_min} will decide the `train_batch_size` ({micro_batch_size}).') + else: + for obj in args: + if isinstance(obj, MegatronLMDummyDataLoader): + micro_batch_size = obj.dataset_args['micro_batch_size'] + break + if micro_batch_size is not None: + dp_degree = self.num_processes // (megatron_lm_plugin.tp_degree * megatron_lm_plugin.pp_degree) + megatron_lm_plugin.set_training_args(micro_batch_size, dp_degree) + else: + raise ValueError('When you do not pass the dataloader parameter, the `data_parallel_size`, `micro_batch_size`, and `global_batch_size` megatron parameters will not be updated.') + model = None + optimizer = None + scheduler = None + batch_data = None + for obj in args: + if isinstance(obj, torch.utils.data.DataLoader) and batch_data is None: + batch_data = next(iter(obj)) + elif isinstance(obj, torch.nn.Module): + model = obj + elif isinstance(obj, torch.optim.Optimizer): + optimizer = obj + elif isinstance(obj, (LRScheduler, MegatronLMDummyScheduler)): + scheduler = obj + if model is not None: + megatron_lm_plugin.set_network_size_args(model, batch_data) + if optimizer is not None: + megatron_lm_plugin.set_optimizer_type(optimizer) + if scheduler is not None: + if not isinstance(scheduler, MegatronLMDummyScheduler): + raise ValueError("You can't use a custom scheduler with Megatron-LM. Please use the `accelerate.utils.MegatronLMDummyScheduler` instead.") + megatron_lm_plugin.set_scheduler_args(scheduler) + megatron_lm_initialize(self, args_defaults=megatron_lm_plugin.megatron_lm_default_args) + (model, optimizer, scheduler) = megatron_lm_prepare_model_optimizer_scheduler(self) + self.wait_for_everyone() + counter = 0 + result = [] + for obj in args: + if isinstance(obj, torch.utils.data.DataLoader): + result.append(megatron_lm_prepare_data_loader(self, obj)) + counter += 1 + elif isinstance(obj, MegatronLMDummyDataLoader): + if counter == 0: + obj.set_megatron_data_args() + dataloaders = megatron_lm_prepare_data_loader(self, obj) + result.append(dataloaders[counter]) + counter += 1 + else: + result.append(obj) + if model is not None: + model = MegatronEngine(self, model, optimizer, scheduler) + if optimizer is not None: + optimizer = MegatronLMOptimizerWrapper(optimizer) + if scheduler is not None: + scheduler = MegatronLMSchedulerWrapper(scheduler, optimizer) + for i in range(len(result)): + if isinstance(result[i], torch.nn.Module): + result[i] = model + elif isinstance(result[i], torch.optim.Optimizer): + result[i] = optimizer + elif isinstance(result[i], MegatronLMDummyScheduler): + result[i] = scheduler + if model is not None: + self._models.append(model) + if len(self._models) > 1: + raise AssertionError("You can't use same `Accelerator()` instance with multiple models when using Megatron-LM") + if optimizer is not None: + self._optimizers.append(optimizer) + if scheduler is not None: + self._schedulers.append(scheduler) + return tuple(result) + + def _prepare_ipex_or_xpu(self, *args): + if self.state.use_ipex: + if not is_ipex_available(): + raise ImportError("IPEX is not installed or IPEX's version does not match current PyTorch version. Please refer to https://github.com/intel/intel-extension-for-pytorch.") + model = None + optimizer = None + result = [obj for obj in args] + for obj in result: + if isinstance(obj, torch.nn.Module): + model = obj + model.train() + elif isinstance(obj, torch.optim.Optimizer): + optimizer = obj + if optimizer is not None and model is not None: + dtype = torch.bfloat16 if self.state.mixed_precision == 'bf16' else None + if self.device.type == 'xpu': + model = model.to(self.device) + if is_ipex_available(): + import intel_extension_for_pytorch as ipex + (model, optimizer) = ipex.optimize(model, optimizer=optimizer, dtype=dtype, inplace=True, level='O1') + for i in range(len(result)): + if isinstance(result[i], torch.nn.Module): + result[i] = model + elif isinstance(result[i], torch.optim.Optimizer): + result[i] = optimizer + return tuple(result) + + def _prepare_msamp(self, *args, device_placement): + if not is_msamp_available(): + raise ImportError("MS-AMP was not found on your system. Please ensure that MS-AMP is available or choose `'te'` as the backend for FP8 mixed precision training.") + import msamp + (model, optimizer) = (None, None) + optimizer_index = None + (num_models, num_optimizers) = (0, 0) + result = [obj for obj in args] + for (i, obj) in enumerate(result): + if isinstance(obj, torch.nn.Module): + model = obj + num_models += 1 + elif isinstance(obj, torch.optim.Optimizer): + optimizer = obj + optimizer_index = i + num_optimizers += 1 + if optimizer is None and model is None: + return (result, device_placement) + elif optimizer is None or model is None: + raise ValueError('You must pass a model and an optimizer together to `accelerate.prepare()` when using MS-AMP.') + elif num_models > 1 or num_optimizers > 1: + raise ValueError(f"You can't use multiple models ({num_models}) or optimizers {num_optimizers} with MS-AMP.") + else: + (model, optimizer) = msamp.initialize(model, optimizer, opt_level=self.fp8_recipe_handler.opt_level) + for i in range(len(result)): + if isinstance(result[i], torch.nn.Module): + result[i] = model + elif isinstance(result[i], torch.optim.Optimizer): + result[i] = optimizer + if optimizer_index is not None: + device_placement[optimizer_index] = False + return (tuple(result), device_placement) + + def prepare_data_loader(self, data_loader: torch.utils.data.DataLoader, device_placement=None, slice_fn_for_dispatch=None): + if getattr(data_loader, '_is_accelerate_prepared', False): + if data_loader not in self._dataloaders: + self._dataloaders.append(data_loader) + return data_loader + if device_placement is None: + device_placement = self.device_placement if self.distributed_type != DistributedType.XLA else False + prepared_data_loader = prepare_data_loader(data_loader, self.device, num_processes=self.num_processes, process_index=self.process_index, split_batches=self.split_batches, put_on_device=device_placement, rng_types=self.rng_types.copy(), dispatch_batches=self.dispatch_batches, even_batches=self.even_batches, slice_fn_for_dispatch=slice_fn_for_dispatch, use_seedable_sampler=self.use_seedable_sampler, non_blocking=self.non_blocking, use_stateful_dataloader=self.use_stateful_dataloader) + self._dataloaders.append(prepared_data_loader) + return prepared_data_loader + + def prepare_optimizer(self, optimizer: torch.optim.Optimizer, device_placement=None): + if is_lomo_available(): + from lomo_optim import AdaLomo, Lomo + self.has_lomo_optimizer |= isinstance(optimizer, (Lomo, AdaLomo)) + if getattr(optimizer, '_is_accelerate_prepared', False): + if optimizer not in self._optimizers: + self._optimizers.append(optimizer) + return optimizer + if device_placement is None: + device_placement = self.device_placement + scaler = None if self.fp8_backend == 'MSAMP' else self.scaler + optimizer = AcceleratedOptimizer(optimizer, device_placement=device_placement, scaler=scaler) + self._optimizers.append(optimizer) + return optimizer + + def prepare_scheduler(self, scheduler: LRScheduler): + if getattr(scheduler, '_is_accelerate_prepared', False): + if scheduler not in self._schedulers: + self._schedulers.append(scheduler) + return scheduler + optimizer = self._optimizers + for opt in self._optimizers: + if getattr(scheduler, 'optimizer', None) == opt.optimizer: + optimizer = opt + break + scheduler = AcceleratedScheduler(scheduler, optimizer, step_with_optimizer=self.step_scheduler_with_optimizer, split_batches=self.split_batches) + self._schedulers.append(scheduler) + return scheduler + + def backward(self, loss, **kwargs): + learning_rate = kwargs.get('learning_rate') + if self.distributed_type != DistributedType.DEEPSPEED: + loss = loss / self.gradient_accumulation_steps + if self.distributed_type == DistributedType.DEEPSPEED: + self.deepspeed_engine_wrapped.backward(loss, **kwargs) + elif self.distributed_type == DistributedType.MEGATRON_LM: + return + elif self.scaler is not None: + self.scaler.scale(loss).backward(**kwargs) + elif learning_rate is not None and self.has_lomo_optimizer: + self.lomo_backward(loss, learning_rate) + else: + loss.backward(**kwargs) + + def set_trigger(self): + self.flag_tensor = torch.tensor(1, device=self.device) + + def check_trigger(self): + if self.flag_tensor is None: + self.flag_tensor = torch.tensor(0, device=self.device) + flag_tensor = self.reduce(self.flag_tensor) + if flag_tensor.item() >= 1: + self.flag_tensor = torch.tensor(0, device=self.device) + return True + return False + + def unscale_gradients(self, optimizer=None): + if self.native_amp and self.mixed_precision == 'fp16': + if optimizer is None: + optimizer = self._optimizers + elif not isinstance(optimizer, (tuple, list)): + optimizer = [optimizer] + for opt in optimizer: + while isinstance(opt, AcceleratedOptimizer): + opt = opt.optimizer + self.scaler.unscale_(opt) + + def clip_grad_norm_(self, parameters, max_norm, norm_type=2): + if self.distributed_type == DistributedType.FSDP: + self.unscale_gradients() + parameters = [p for p in parameters] + for model in self._models: + if parameters == [p for p in model.parameters()]: + return model.clip_grad_norm_(max_norm, norm_type) + elif self.distributed_type == DistributedType.DEEPSPEED: + return None + elif self.distributed_type == DistributedType.XLA: + for acc_opt in self._optimizers: + if not acc_opt.gradient_state.is_xla_gradients_synced: + opt = acc_opt + while isinstance(opt, AcceleratedOptimizer): + opt = opt.optimizer + gradients = xm._fetch_gradients(opt) + xm.all_reduce('sum', gradients, scale=1.0 / self.num_processes) + acc_opt.gradient_state.is_xla_gradients_synced = True + if os.environ.get('ACCELERATE_USE_FSDP', 'false') == 'true': + self.unscale_gradients() + parameters = [p for p in parameters] + for model in self._models: + if parameters == [p for p in model.parameters()]: + return model.clip_grad_norm_(max_norm, norm_type) + self.unscale_gradients() + return torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type=norm_type) + + def clip_grad_value_(self, parameters, clip_value): + if self.distributed_type in [DistributedType.DEEPSPEED, DistributedType.FSDP]: + raise Exception('DeepSpeed and FSDP do not support `clip_grad_value_`. Use `clip_grad_norm_` instead.') + self.unscale_gradients() + torch.nn.utils.clip_grad_value_(parameters, clip_value) + + def gather(self, tensor): + return gather(tensor) + + def gather_for_metrics(self, input_data, use_gather_object=False): + try: + recursively_apply(lambda x: x, input_data, error_on_other_type=True) + all_tensors = True + except TypeError: + all_tensors = False + use_gather_object = use_gather_object or not all_tensors + if use_gather_object: + data = gather_object(input_data) + else: + data = self.gather(input_data) + try: + if self.gradient_state.end_of_dataloader: + if self.gradient_state.remainder == -1: + logger.info('The used dataset had no length, returning gathered tensors. You should drop the remainder yourself.') + return data + elif self.gradient_state.remainder > 0: + + def _adjust_samples(tensor): + return tensor[:self.gradient_state.remainder] + if use_gather_object: + return _adjust_samples(data) + else: + return recursively_apply(_adjust_samples, data) + else: + return data + else: + return data + except Exception: + return data + + def reduce(self, tensor, reduction='sum', scale=1.0): + return reduce(tensor, reduction, scale) + + def pad_across_processes(self, tensor, dim=0, pad_index=0, pad_first=False): + return pad_across_processes(tensor, dim=dim, pad_index=pad_index, pad_first=pad_first) + + def unwrap_model(self, model, keep_fp32_wrapper: bool=True): + return extract_model_from_parallel(model, keep_fp32_wrapper) + + def wait_for_everyone(self): + wait_for_everyone() + + @on_main_process + def init_trackers(self, project_name: str, config: dict | None=None, init_kwargs: dict | None={}): + for tracker in self.log_with: + if issubclass(type(tracker), GeneralTracker): + self.trackers.append(tracker) + else: + tracker_init = LOGGER_TYPE_TO_CLASS[str(tracker)] + if tracker_init.requires_logging_directory: + self.trackers.append(tracker_init(project_name, self.logging_dir, **init_kwargs.get(str(tracker), {}))) + else: + self.trackers.append(tracker_init(project_name, **init_kwargs.get(str(tracker), {}))) + if config is not None: + for tracker in self.trackers: + tracker.store_init_configuration(config) + + def get_tracker(self, name: str, unwrap: bool=False): + if len(self.trackers) > 0: + for tracker in self.trackers: + if tracker.name == name: + return tracker.tracker if unwrap else tracker + raise ValueError(f'{name} is not an available tracker stored inside the `Accelerator`.') + return GeneralTracker(_blank=True) + + @on_main_process + def log(self, values: dict, step: int | None=None, log_kwargs: dict | None={}): + for tracker in self.trackers: + tracker.log(values, step=step, **log_kwargs.get(tracker.name, {})) + + def end_training(self): + for tracker in self.trackers: + tracker.finish() + self.state.destroy_process_group() + + def save(self, obj, f, safe_serialization=False): + save(obj, f, save_on_each_node=self.project_configuration.save_on_each_node, safe_serialization=safe_serialization) + + def save_model(self, model: torch.nn.Module, save_directory: Union[str, os.PathLike], max_shard_size: Union[int, str]='10GB', safe_serialization: bool=True): + if os.path.isfile(save_directory): + logger.error(f'Provided path ({save_directory}) should be a directory, not a file') + return + os.makedirs(save_directory, exist_ok=True) + if any([module._hf_hook.offload for module in model.modules() if hasattr(module, '_hf_hook') and isinstance(module._hf_hook, AlignDevicesHook)]): + state_dict = get_state_dict_offloaded_model(model) + else: + if any((param.device == torch.device('meta') for param in model.parameters())): + raise RuntimeError("You can't save the model since some parameters are on the meta device.") + state_dict = self.get_state_dict(model) + if safe_serialization: + state_dict = clean_state_dict_for_safetensors(state_dict) + weights_name = SAFE_WEIGHTS_NAME if safe_serialization else WEIGHTS_NAME + filename_pattern = SAFE_WEIGHTS_PATTERN_NAME if safe_serialization else WEIGHTS_PATTERN_NAME + state_dict_split = split_torch_state_dict_into_shards(state_dict, filename_pattern=filename_pattern, max_shard_size=max_shard_size) + for filename in os.listdir(save_directory): + full_filename = os.path.join(save_directory, filename) + weights_no_suffix = weights_name.replace('.bin', '') + filename_no_suffix = filename.replace('.bin', '') + reg = re.compile('(.*?)-\\d{5}-of-\\d{5}') + if filename.startswith(weights_no_suffix) and os.path.isfile(full_filename) and (filename not in state_dict_split.filename_to_tensors.keys()) and (reg.fullmatch(filename_no_suffix) is not None) and PartialState().is_main_process: + os.remove(full_filename) + for (filename, tensors) in state_dict_split.filename_to_tensors.items(): + shard = {tensor: state_dict[tensor] for tensor in tensors} + self.save(shard, os.path.join(save_directory, filename), safe_serialization=safe_serialization) + if state_dict_split.is_sharded: + index = {'metadata': state_dict_split.metadata, 'weight_map': state_dict_split.tensor_to_filename} + save_index_file = SAFE_WEIGHTS_INDEX_NAME if safe_serialization else WEIGHTS_INDEX_NAME + save_index_file = os.path.join(save_directory, save_index_file) + with open(save_index_file, 'w', encoding='utf-8') as f: + content = json.dumps(index, indent=2, sort_keys=True) + '\n' + f.write(content) + logger.info(f'The model is bigger than the maximum size per checkpoint ({max_shard_size}) and is going to be split in {len(state_dict_split.filename_to_tensors)} checkpoint shards. You can find where each parameters has been saved in the index located at {save_index_file}.') + else: + path_to_weights = os.path.join(save_directory, WEIGHTS_NAME) + logger.info(f'Model weights saved in {path_to_weights}') + + def register_save_state_pre_hook(self, hook: Callable[..., None]) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(self._save_model_state_pre_hook) + self._save_model_state_pre_hook[handle.id] = hook + return handle + + def save_state(self, output_dir: str=None, safe_serialization: bool=True, **save_model_func_kwargs): + if self.project_configuration.automatic_checkpoint_naming: + output_dir = os.path.join(self.project_dir, 'checkpoints') + os.makedirs(output_dir, exist_ok=True) + if self.project_configuration.automatic_checkpoint_naming: + folders = [os.path.join(output_dir, folder) for folder in os.listdir(output_dir)] + if self.project_configuration.total_limit is not None and len(folders) + 1 > self.project_configuration.total_limit and self.is_main_process: + + def _inner(folder): + return list(map(int, re.findall('[\\/]?([0-9]+)(?=[^\\/]*$)', folder)))[0] + folders.sort(key=_inner) + logger.warning(f'Deleting {len(folders) + 1 - self.project_configuration.total_limit} checkpoints to make room for new checkpoint.') + for folder in folders[:len(folders) + 1 - self.project_configuration.total_limit]: + shutil.rmtree(folder) + output_dir = os.path.join(output_dir, f'checkpoint_{self.save_iteration}') + if os.path.exists(output_dir): + raise ValueError(f'Checkpoint directory {output_dir} ({self.save_iteration}) already exists. Please manually override `self.save_iteration` with what iteration to start with.') + self.wait_for_everyone() + os.makedirs(output_dir, exist_ok=True) + logger.info(f'Saving current state to {output_dir}') + if self.distributed_type == DistributedType.XLA: + xm.mark_step() + weights = [] + for (i, model) in enumerate(self._models): + if self.distributed_type == DistributedType.FSDP: + logger.info('Saving FSDP model') + save_fsdp_model(self.state.fsdp_plugin, self, model, output_dir, i) + logger.info(f'FSDP Model saved to output dir {output_dir}') + elif self.distributed_type == DistributedType.DEEPSPEED: + logger.info('Saving DeepSpeed Model and Optimizer') + ckpt_id = f'{MODEL_NAME}' if i == 0 else f'{MODEL_NAME}_{i}' + model.save_checkpoint(output_dir, ckpt_id, **save_model_func_kwargs) + logger.info(f'DeepSpeed Model and Optimizer saved to output dir {os.path.join(output_dir, ckpt_id)}') + elif self.distributed_type == DistributedType.MEGATRON_LM: + logger.info('Saving Megatron-LM Model, Optimizer and Scheduler') + model.save_checkpoint(output_dir) + logger.info(f'Megatron-LM Model , Optimizer and Scheduler saved to output dir {output_dir}') + else: + weights.append(self.get_state_dict(model, unwrap=False)) + optimizers = [] + if self.distributed_type == DistributedType.FSDP: + for (i, opt) in enumerate(self._optimizers): + logger.info('Saving FSDP Optimizer') + save_fsdp_optimizer(self.state.fsdp_plugin, self, opt, self._models[i], output_dir, i) + logger.info(f'FSDP Optimizer saved to output dir {output_dir}') + elif self.distributed_type not in [DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM]: + optimizers = self._optimizers + schedulers = [] + if self.distributed_type == DistributedType.DEEPSPEED: + for (i, scheduler) in enumerate(self._schedulers): + if isinstance(scheduler, DeepSpeedSchedulerWrapper): + continue + schedulers.append(scheduler) + elif self.distributed_type not in [DistributedType.MEGATRON_LM]: + schedulers = self._schedulers + dataloaders = self._dataloaders + for hook in self._save_model_state_pre_hook.values(): + hook(self._models, weights, output_dir) + save_location = save_accelerator_state(output_dir, weights, optimizers, schedulers, dataloaders, self.state.process_index, self.step, self.scaler, save_on_each_node=self.project_configuration.save_on_each_node, safe_serialization=safe_serialization) + for (i, obj) in enumerate(self._custom_objects): + save_custom_state(obj, output_dir, i, save_on_each_node=self.project_configuration.save_on_each_node) + self.project_configuration.iteration += 1 + return save_location + + def register_load_state_pre_hook(self, hook: Callable[..., None]) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(self._load_model_state_pre_hook) + self._load_model_state_pre_hook[handle.id] = hook + return handle + + def load_state(self, input_dir: str=None, **load_model_func_kwargs): + if input_dir is not None: + input_dir = os.path.expanduser(input_dir) + if not os.path.isdir(input_dir): + raise ValueError(f'Tried to find {input_dir} but folder does not exist') + elif self.project_configuration.automatic_checkpoint_naming: + input_dir = os.path.join(self.project_dir, 'checkpoints') + folders = [os.path.join(input_dir, folder) for folder in os.listdir(input_dir)] + + def _inner(folder): + return list(map(int, re.findall('[\\/]?([0-9]+)(?=[^\\/]*$)', folder)))[0] + folders.sort(key=_inner) + input_dir = folders[-1] + else: + raise ValueError('No input_dir provided and automatic checkpoint naming is disabled.') + logger.info(f'Loading states from {input_dir}') + models = [] + for (i, model) in enumerate(self._models): + if self.distributed_type == DistributedType.FSDP: + logger.info('Loading FSDP model') + load_fsdp_model(self.state.fsdp_plugin, self, model, input_dir, i) + logger.info(f'FSDP Model loaded from input dir {input_dir}') + elif self.distributed_type == DistributedType.DEEPSPEED: + logger.info('Loading DeepSpeed Model and Optimizer') + ckpt_id = f'{MODEL_NAME}' if i == 0 else f'{MODEL_NAME}_{i}' + model.load_checkpoint(input_dir, ckpt_id, **load_model_func_kwargs) + logger.info(f'DeepSpeed Model and Optimizer loaded from input dir {os.path.join(input_dir, ckpt_id)}') + elif self.distributed_type == DistributedType.MEGATRON_LM: + logger.info('Loading Megatron-LM Model, Optimizer and Scheduler') + model.load_checkpoint(input_dir) + logger.info(f'Megatron-LM Model , Optimizer and Scheduler loaded from input dir {input_dir}') + else: + models.append(model) + optimizers = [] + if self.distributed_type == DistributedType.FSDP: + for (i, opt) in enumerate(self._optimizers): + logger.info('Loading FSDP Optimizer') + load_fsdp_optimizer(self.state.fsdp_plugin, self, opt, self._models[i], input_dir, i) + logger.info(f'FSDP Optimizer loaded from input dir {input_dir}') + elif self.distributed_type not in [DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM]: + optimizers = self._optimizers + schedulers = [] + if self.distributed_type == DistributedType.DEEPSPEED: + for (i, scheduler) in enumerate(self._schedulers): + if isinstance(scheduler, DeepSpeedSchedulerWrapper): + continue + schedulers.append(scheduler) + elif self.distributed_type not in [DistributedType.MEGATRON_LM]: + schedulers = self._schedulers + dataloaders = self._dataloaders + for hook in self._load_model_state_pre_hook.values(): + hook(models, input_dir) + map_location = load_model_func_kwargs.pop('map_location', None) + if map_location is None: + if self.num_processes > 1 and self.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU): + map_location = 'on_device' + else: + map_location = 'cpu' + override_attributes = load_accelerator_state(input_dir, models, optimizers, schedulers, dataloaders, self.state.process_index, self.scaler, map_location, **load_model_func_kwargs) + if 'step' in override_attributes: + self.step = override_attributes['step'] + custom_checkpoints = [f for f in os.listdir(input_dir) if re.search('^custom_checkpoint_\\d+\\.pkl$', f) is not None] + if len(custom_checkpoints) != len(self._custom_objects): + err = f'Number of custom checkpoints in folder {input_dir} does not match the number of registered objects:' + err += f'\n\tFound checkpoints: {len(custom_checkpoints)}' + err += f'\n\tRegistered objects: {len(self._custom_objects)}\n' + err += 'Please make sure to only load checkpoints from folders that were created with the same set of registered objects,' + err += 'or avoid using `custom_checkpoint` in the filename for files in that same directory and load them in manually.' + raise RuntimeError(err) + else: + logger.info(f'Loading in {len(custom_checkpoints)} custom states') + for (index, obj) in enumerate(self._custom_objects): + load_custom_state(obj, input_dir, index) + + def free_memory(self, *objects): + if hasattr(self, 'deepspeed_engine_wrapped'): + if self.deepspeed_engine_wrapped is not None: + self.deepspeed_engine_wrapped.engine.destroy() + self.deepspeed_engine_wrapped = None + objects = release_memory(*objects) + self._schedulers = [] + self._optimizers = [] + self._models = [] + self._dataloaders = [] + self.step = 0 + return objects + + def clear(self, *objects): + return self.free_memory(*objects) + + def _get_named_parameters(self, *args): + named_parameters = {} + for obj in args: + if isinstance(obj, torch.nn.Module): + obj = extract_model_from_parallel(obj) + named_parameters.update({n: p for (n, p) in obj.named_parameters()}) + return named_parameters + + def _get_devices(self, *args): + model_device = None + optimizer_device = None + for obj in args: + if isinstance(obj, torch.nn.Module): + for param in obj.parameters(): + model_device = param.device + break + if isinstance(obj, torch.optim.Optimizer): + for param_group in obj.param_groups: + if len(param_group['params']) > 0: + optimizer_device = param_group['params'][0].device + break + return (model_device, optimizer_device) + + def get_state_dict(self, model, unwrap=True): + if self.distributed_type == DistributedType.DEEPSPEED: + if self.deepspeed_config['zero_optimization']['stage'] == 3: + if model.zero_gather_16bit_weights_on_model_save(): + state_dict = model._zero3_consolidated_16bit_state_dict() + else: + raise ValueError('Cannot get 16bit model weights because `stage3_gather_16bit_weights_on_model_save` in DeepSpeed config is False. To save the model weights in 16bit, set `stage3_gather_16bit_weights_on_model_save` to True in DeepSpeed config file or set `zero3_save_16bit_model` to True when using `accelerate config`. To save the full checkpoint, run `model.save_checkpoint(save_dir)` and use `zero_to_fp32.py` to recover weights.') + else: + from deepspeed.checkpoint.utils import clone_tensors_for_torch_save + state_dict = clone_tensors_for_torch_save(self.unwrap_model(model).state_dict()) + elif self.distributed_type == DistributedType.FSDP: + from torch.distributed.fsdp import FullStateDictConfig, StateDictType + from torch.distributed.fsdp import FullyShardedDataParallel as FSDP + full_state_dict_config = FullStateDictConfig(offload_to_cpu=True, rank0_only=True) + with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, full_state_dict_config): + state_dict = model.state_dict() + else: + if unwrap: + model = self.unwrap_model(model) + state_dict = model.state_dict() + return state_dict + + def register_for_checkpointing(self, *objects): + invalid_objects = [] + for obj in objects: + if not hasattr(obj, 'state_dict') or not hasattr(obj, 'load_state_dict'): + invalid_objects.append(obj) + if len(invalid_objects) > 0: + err = 'All `objects` must include a `state_dict` and `load_state_dict` function to be stored. The following inputs are invalid:' + for (index, obj) in enumerate(invalid_objects): + err += f'\n\t- Item at index {index}, `{get_pretty_name(obj)}`' + raise ValueError(err) + self._custom_objects.extend(objects) + + @contextmanager + def autocast(self, autocast_handler: AutocastKwargs=None): + if autocast_handler is None: + autocast_handler = self.autocast_handler + autocast_context = get_mixed_precision_context_manager(self.native_amp, autocast_handler) + autocast_context.__enter__() + yield + autocast_context.__exit__(*sys.exc_info()) + + @contextmanager + def profile(self, profile_handler: ProfileKwargs | None=None): + profile_handler = profile_handler or self.profile_handler or ProfileKwargs() + with profile_handler.build() as profiler: + yield profiler + if profile_handler.output_trace_dir is None: + return + os.makedirs(profile_handler.output_trace_dir, exist_ok=True) + profiler.export_chrome_trace(os.path.join(profile_handler.output_trace_dir, PROFILE_PATTERN_NAME.format(suffix=self.process_index))) + self.wait_for_everyone() + + @property + def optimizer_step_was_skipped(self): + for optimizer in self._optimizers: + if optimizer.step_was_skipped: + return True + return False + + def skip_first_batches(self, dataloader, num_batches: int=0): + return skip_first_batches(dataloader, num_batches=num_batches) + + def __deepcopy__(self, memo): + logger.info('Deep copying the `Accelerator` object, note that this will point to the same original object.') + return self + + def verify_device_map(self, model: torch.nn.Module) -> bool: + for m in model.modules(): + if hasattr(m, 'hf_device_map') and len(m.hf_device_map) > 1: + return True + return False + + def lomo_backward(self, loss: torch.Tensor, learning_rate: float) -> None: + if is_lomo_available(): + from lomo_optim import AdaLomo, Lomo + if learning_rate is None: + raise ValueError('A learning rate must be passed in order to call backward pass with LOMO optimizers.') + _backward_called = False + for optimizer in self._optimizers: + if isinstance(optimizer.optimizer, (Lomo, AdaLomo)): + optimizer.optimizer.fused_backward(loss, learning_rate) + _backward_called = True + if not _backward_called: + raise ValueError('Backward pass not properly called on LOMO optimizers. Are you sure you passed a LOMO optimizer in accelerator.prepare()?') + + @property + def fp8_backend(self): + if self.mixed_precision == 'fp8' and self.fp8_recipe_handler is not None: + return self.fp8_recipe_handler.backend + elif self.state.deepspeed_plugin is not None and self.state.deepspeed_plugin.enable_msamp: + return 'MSAMP' + return None + +# File: accelerate-main/src/accelerate/big_modeling.py +import logging +import os +from contextlib import contextmanager +from functools import wraps +from typing import Dict, List, Optional, Union +import torch +import torch.nn as nn +from .hooks import AlignDevicesHook, CpuOffload, UserCpuOffloadHook, add_hook_to_module, attach_align_device_hook, attach_align_device_hook_on_blocks +from .utils import OffloadedWeightsLoader, check_cuda_p2p_ib_support, check_device_map, extract_submodules_state_dict, find_tied_parameters, get_balanced_memory, infer_auto_device_map, is_mlu_available, is_musa_available, is_npu_available, is_torch_version, is_xpu_available, load_checkpoint_in_model, offload_state_dict, parse_flag_from_env, retie_parameters +from .utils.other import recursive_getattr +logger = logging.getLogger(__name__) + +@contextmanager +def init_empty_weights(include_buffers: bool=None): + if include_buffers is None: + include_buffers = parse_flag_from_env('ACCELERATE_INIT_INCLUDE_BUFFERS', False) + with init_on_device(torch.device('meta'), include_buffers=include_buffers) as f: + yield f + +@contextmanager +def init_on_device(device: torch.device, include_buffers: bool=None): + if include_buffers is None: + include_buffers = parse_flag_from_env('ACCELERATE_INIT_INCLUDE_BUFFERS', False) + if is_torch_version('>=', '2.0') and include_buffers: + with device: + yield + return + old_register_parameter = nn.Module.register_parameter + if include_buffers: + old_register_buffer = nn.Module.register_buffer + + def register_empty_parameter(module, name, param): + old_register_parameter(module, name, param) + if param is not None: + param_cls = type(module._parameters[name]) + kwargs = module._parameters[name].__dict__ + kwargs['requires_grad'] = param.requires_grad + module._parameters[name] = param_cls(module._parameters[name].to(device), **kwargs) + + def register_empty_buffer(module, name, buffer, persistent=True): + old_register_buffer(module, name, buffer, persistent=persistent) + if buffer is not None: + module._buffers[name] = module._buffers[name].to(device) + if include_buffers: + tensor_constructors_to_patch = {torch_function_name: getattr(torch, torch_function_name) for torch_function_name in ['empty', 'zeros', 'ones', 'full']} + else: + tensor_constructors_to_patch = {} + + def patch_tensor_constructor(fn): + + def wrapper(*args, **kwargs): + kwargs['device'] = device + return fn(*args, **kwargs) + return wrapper + try: + nn.Module.register_parameter = register_empty_parameter + if include_buffers: + nn.Module.register_buffer = register_empty_buffer + for torch_function_name in tensor_constructors_to_patch.keys(): + setattr(torch, torch_function_name, patch_tensor_constructor(getattr(torch, torch_function_name))) + yield + finally: + nn.Module.register_parameter = old_register_parameter + if include_buffers: + nn.Module.register_buffer = old_register_buffer + for (torch_function_name, old_torch_function) in tensor_constructors_to_patch.items(): + setattr(torch, torch_function_name, old_torch_function) + +def cpu_offload(model: nn.Module, execution_device: Optional[torch.device]=None, offload_buffers: bool=False, state_dict: Optional[Dict[str, torch.Tensor]]=None, preload_module_classes: Optional[List[str]]=None): + if execution_device is None: + execution_device = next(iter(model.parameters())).device + if state_dict is None: + state_dict = {n: p.to('cpu') for (n, p) in model.state_dict().items()} + add_hook_to_module(model, AlignDevicesHook(io_same_device=True), append=True) + attach_align_device_hook(model, execution_device=execution_device, offload=True, offload_buffers=offload_buffers, weights_map=state_dict, preload_module_classes=preload_module_classes) + return model + +def cpu_offload_with_hook(model: torch.nn.Module, execution_device: Optional[Union[int, str, torch.device]]=None, prev_module_hook: Optional[UserCpuOffloadHook]=None): + hook = CpuOffload(execution_device=execution_device, prev_module_hook=prev_module_hook) + add_hook_to_module(model, hook, append=True) + user_hook = UserCpuOffloadHook(model, hook) + return (model, user_hook) + +def disk_offload(model: nn.Module, offload_dir: Union[str, os.PathLike], execution_device: Optional[torch.device]=None, offload_buffers: bool=False, preload_module_classes: Optional[List[str]]=None): + if not os.path.isdir(offload_dir) or not os.path.isfile(os.path.join(offload_dir, 'index.json')): + offload_state_dict(offload_dir, model.state_dict()) + if execution_device is None: + execution_device = next(iter(model.parameters())).device + weights_map = OffloadedWeightsLoader(save_folder=offload_dir) + add_hook_to_module(model, AlignDevicesHook(io_same_device=True), append=True) + attach_align_device_hook(model, execution_device=execution_device, offload=True, offload_buffers=offload_buffers, weights_map=weights_map, preload_module_classes=preload_module_classes) + return model + +def dispatch_model(model: nn.Module, device_map: Dict[str, Union[str, int, torch.device]], main_device: Optional[torch.device]=None, state_dict: Optional[Dict[str, torch.Tensor]]=None, offload_dir: Optional[Union[str, os.PathLike]]=None, offload_index: Optional[Dict[str, str]]=None, offload_buffers: bool=False, skip_keys: Optional[Union[str, List[str]]]=None, preload_module_classes: Optional[List[str]]=None, force_hooks: bool=False): + check_device_map(model, device_map) + is_bnb_quantized = (getattr(model, 'is_quantized', False) or getattr(model, 'is_loaded_in_8bit', False)) and getattr(model, 'quantization_method', 'bitsandbytes') == 'bitsandbytes' + if len(set(device_map.values())) > 1 or is_bnb_quantized or force_hooks: + if main_device is None: + if set(device_map.values()) == {'cpu'} or set(device_map.values()) == {'cpu', 'disk'}: + main_device = 'cpu' + else: + main_device = [d for d in device_map.values() if d not in ['cpu', 'disk']][0] + if main_device != 'cpu': + cpu_modules = [name for (name, device) in device_map.items() if device == 'cpu'] + if state_dict is None and len(cpu_modules) > 0: + state_dict = extract_submodules_state_dict(model.state_dict(), cpu_modules) + disk_modules = [name for (name, device) in device_map.items() if device == 'disk'] + if offload_dir is None and offload_index is None and (len(disk_modules) > 0): + raise ValueError(f"We need an `offload_dir` to dispatch this model according to this `device_map`, the following submodules need to be offloaded: {', '.join(disk_modules)}.") + if len(disk_modules) > 0 and offload_index is None and (not os.path.isdir(offload_dir) or not os.path.isfile(os.path.join(offload_dir, 'index.json'))): + disk_state_dict = extract_submodules_state_dict(model.state_dict(), disk_modules) + offload_state_dict(offload_dir, disk_state_dict) + execution_device = {name: main_device if device in ['cpu', 'disk'] else device for (name, device) in device_map.items()} + execution_device[''] = main_device + offloaded_devices = ['disk'] if main_device == 'cpu' or main_device == 'mps' else ['cpu', 'disk'] + offload = {name: device in offloaded_devices for (name, device) in device_map.items()} + save_folder = offload_dir if len(disk_modules) > 0 else None + if state_dict is not None or save_folder is not None or offload_index is not None: + device = main_device if offload_index is not None else None + weights_map = OffloadedWeightsLoader(state_dict=state_dict, save_folder=save_folder, index=offload_index, device=device) + else: + weights_map = None + tied_params = find_tied_parameters(model) + tied_params_map = {} + for group in tied_params: + for param_name in group: + data_ptr = recursive_getattr(model, param_name).data_ptr() + tied_params_map[data_ptr] = {} + attach_align_device_hook_on_blocks(model, execution_device=execution_device, offload=offload, offload_buffers=offload_buffers, weights_map=weights_map, skip_keys=skip_keys, preload_module_classes=preload_module_classes, tied_params_map=tied_params_map) + offloaded_devices_str = ' and '.join([device for device in set(device_map.values()) if device in ('cpu', 'disk')]) + if len(offloaded_devices_str) > 0: + logger.warning(f'Some parameters are on the meta device because they were offloaded to the {offloaded_devices_str}.') + retie_parameters(model, tied_params) + + def add_warning(fn, model): + + @wraps(fn) + def wrapper(*args, **kwargs): + warning_msg = "You shouldn't move a model that is dispatched using accelerate hooks." + if str(fn.__name__) == 'to': + to_device = torch._C._nn._parse_to(*args, **kwargs)[0] + if to_device is not None: + logger.warning(warning_msg) + else: + logger.warning(warning_msg) + for param in model.parameters(): + if param.device == torch.device('meta'): + raise RuntimeError("You can't move a model that has some modules offloaded to cpu or disk.") + return fn(*args, **kwargs) + return wrapper + model.to = add_warning(model.to, model) + if is_npu_available(): + model.npu = add_warning(model.npu, model) + elif is_mlu_available(): + model.mlu = add_warning(model.mlu, model) + elif is_musa_available(): + model.musa = add_warning(model.musa, model) + elif is_xpu_available(): + model.xpu = add_warning(model.xpu, model) + else: + model.cuda = add_warning(model.cuda, model) + use_multi_gpu = len([device for device in set(device_map.values()) if device not in ('cpu', 'disk')]) > 1 + if use_multi_gpu and (not check_cuda_p2p_ib_support()): + logger.warning("We've detected an older driver with an RTX 4000 series GPU. These drivers have issues with P2P. This can affect the multi-gpu inference when using accelerate device_map.Please make sure to update your driver to the latest version which resolves this.") + else: + device = list(device_map.values())[0] + if is_npu_available() and isinstance(device, int): + device = f'npu:{device}' + elif is_mlu_available() and isinstance(device, int): + device = f'mlu:{device}' + elif is_musa_available() and isinstance(device, int): + device = f'musa:{device}' + elif is_xpu_available() and isinstance(device, int): + device = f'xpu:{device}' + if device != 'disk': + model.to(device) + else: + raise ValueError('You are trying to offload the whole model to the disk. Please use the `disk_offload` function instead.') + model.hf_device_map = dict(device_map) + return model + +def load_checkpoint_and_dispatch(model: nn.Module, checkpoint: Union[str, os.PathLike], device_map: Optional[Union[str, Dict[str, Union[int, str, torch.device]]]]=None, max_memory: Optional[Dict[Union[int, str], Union[int, str]]]=None, no_split_module_classes: Optional[List[str]]=None, offload_folder: Optional[Union[str, os.PathLike]]=None, offload_buffers: bool=False, dtype: Optional[Union[str, torch.dtype]]=None, offload_state_dict: Optional[bool]=None, skip_keys: Optional[Union[str, List[str]]]=None, preload_module_classes: Optional[List[str]]=None, force_hooks: bool=False, strict: bool=False): + if isinstance(device_map, str) and device_map not in ['auto', 'balanced', 'balanced_low_0', 'sequential']: + raise ValueError("If passing a string for `device_map`, please choose 'auto', 'balanced', 'balanced_low_0' or 'sequential'.") + if isinstance(device_map, str): + if device_map != 'sequential': + max_memory = get_balanced_memory(model, max_memory=max_memory, no_split_module_classes=no_split_module_classes, dtype=dtype, low_zero=device_map == 'balanced_low_0') + device_map = infer_auto_device_map(model, max_memory=max_memory, no_split_module_classes=no_split_module_classes, dtype=dtype, offload_buffers=offload_buffers) + if offload_state_dict is None and device_map is not None and ('disk' in device_map.values()): + offload_state_dict = True + load_checkpoint_in_model(model, checkpoint, device_map=device_map, offload_folder=offload_folder, dtype=dtype, offload_state_dict=offload_state_dict, offload_buffers=offload_buffers, strict=strict) + if device_map is None: + return model + return dispatch_model(model, device_map=device_map, offload_dir=offload_folder, offload_buffers=offload_buffers, skip_keys=skip_keys, preload_module_classes=preload_module_classes, force_hooks=force_hooks) + +# File: accelerate-main/src/accelerate/checkpointing.py +import random +from pathlib import Path +from typing import List +import numpy as np +import torch +from safetensors.torch import load_model +from torch.cuda.amp import GradScaler +from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_MODEL_NAME, SAFE_WEIGHTS_NAME, SAMPLER_NAME, SCALER_NAME, SCHEDULER_NAME, WEIGHTS_NAME, get_pretty_name, is_mlu_available, is_torch_xla_available, is_xpu_available, save +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm +from .logging import get_logger +from .state import PartialState +logger = get_logger(__name__) + +def save_accelerator_state(output_dir: str, model_states: List[dict], optimizers: list, schedulers: list, dataloaders: list, process_index: int, step: int, scaler: GradScaler=None, save_on_each_node: bool=False, safe_serialization: bool=True): + output_dir = Path(output_dir) + for (i, state) in enumerate(model_states): + weights_name = WEIGHTS_NAME if not safe_serialization else SAFE_WEIGHTS_NAME + if i > 0: + weights_name = weights_name.replace('.', f'_{i}.') + output_model_file = output_dir.joinpath(weights_name) + save(state, output_model_file, save_on_each_node=save_on_each_node, safe_serialization=safe_serialization) + logger.info(f'Model weights saved in {output_model_file}') + for (i, opt) in enumerate(optimizers): + state = opt.state_dict() + optimizer_name = f'{OPTIMIZER_NAME}.bin' if i == 0 else f'{OPTIMIZER_NAME}_{i}.bin' + output_optimizer_file = output_dir.joinpath(optimizer_name) + save(state, output_optimizer_file, save_on_each_node=save_on_each_node, safe_serialization=False) + logger.info(f'Optimizer state saved in {output_optimizer_file}') + for (i, scheduler) in enumerate(schedulers): + state = scheduler.state_dict() + scheduler_name = f'{SCHEDULER_NAME}.bin' if i == 0 else f'{SCHEDULER_NAME}_{i}.bin' + output_scheduler_file = output_dir.joinpath(scheduler_name) + save(state, output_scheduler_file, save_on_each_node=save_on_each_node, safe_serialization=False) + logger.info(f'Scheduler state saved in {output_scheduler_file}') + for (i, dataloader) in enumerate(dataloaders): + sampler_name = f'{SAMPLER_NAME}.bin' if i == 0 else f'{SAMPLER_NAME}_{i}.bin' + output_sampler_file = output_dir.joinpath(sampler_name) + from .data_loader import IterableDatasetShard, SeedableRandomSampler + if isinstance(dataloader.dataset, IterableDatasetShard): + sampler = dataloader.get_sampler() + if isinstance(sampler, SeedableRandomSampler): + save(sampler, output_sampler_file, save_on_each_node=save_on_each_node, safe_serialization=False) + if getattr(dataloader, 'use_stateful_dataloader', False): + dataloader_state_dict_name = 'dl_state_dict.bin' if i == 0 else f'dl_state_dict_{i}.bin' + output_dataloader_state_dict_file = output_dir.joinpath(dataloader_state_dict_name) + state_dict = dataloader.state_dict() + torch.save(state_dict, output_dataloader_state_dict_file) + logger.info(f'Sampler state for dataloader {i} saved in {output_sampler_file}') + if scaler is not None: + state = scaler.state_dict() + output_scaler_file = output_dir.joinpath(SCALER_NAME) + torch.save(state, output_scaler_file) + logger.info(f'Gradient scaler state saved in {output_scaler_file}') + states = {} + states_name = f'{RNG_STATE_NAME}_{process_index}.pkl' + states['step'] = step + states['random_state'] = random.getstate() + states['numpy_random_seed'] = np.random.get_state() + states['torch_manual_seed'] = torch.get_rng_state() + if is_xpu_available(): + states['torch_xpu_manual_seed'] = torch.xpu.get_rng_state_all() + if is_mlu_available(): + states['torch_mlu_manual_seed'] = torch.mlu.get_rng_state_all() + else: + states['torch_cuda_manual_seed'] = torch.cuda.get_rng_state_all() + if is_torch_xla_available(): + states['xm_seed'] = xm.get_rng_state() + output_states_file = output_dir.joinpath(states_name) + torch.save(states, output_states_file) + logger.info(f'Random states saved in {output_states_file}') + return output_dir + +def load_accelerator_state(input_dir, models, optimizers, schedulers, dataloaders, process_index, scaler=None, map_location=None, **load_model_func_kwargs): + override_attributes = dict() + if map_location not in [None, 'cpu', 'on_device']: + raise TypeError("Unsupported optimizer map location passed, please choose one of `None`, `'cpu'`, or `'on_device'`") + if map_location is None: + map_location = 'cpu' + elif map_location == 'on_device': + map_location = PartialState().device + input_dir = Path(input_dir) + for (i, model) in enumerate(models): + ending = f'_{i}' if i > 0 else '' + input_model_file = input_dir.joinpath(f'{SAFE_MODEL_NAME}{ending}.safetensors') + if input_model_file.exists(): + load_model(model, input_model_file, device=str(map_location), **load_model_func_kwargs) + else: + input_model_file = input_dir.joinpath(f'{MODEL_NAME}{ending}.bin') + state_dict = torch.load(input_model_file, map_location=map_location) + model.load_state_dict(state_dict, **load_model_func_kwargs) + logger.info('All model weights loaded successfully') + for (i, opt) in enumerate(optimizers): + optimizer_name = f'{OPTIMIZER_NAME}.bin' if i == 0 else f'{OPTIMIZER_NAME}_{i}.bin' + input_optimizer_file = input_dir.joinpath(optimizer_name) + optimizer_state = torch.load(input_optimizer_file, map_location=map_location) + optimizers[i].load_state_dict(optimizer_state) + logger.info('All optimizer states loaded successfully') + for (i, scheduler) in enumerate(schedulers): + scheduler_name = f'{SCHEDULER_NAME}.bin' if i == 0 else f'{SCHEDULER_NAME}_{i}.bin' + input_scheduler_file = input_dir.joinpath(scheduler_name) + scheduler.load_state_dict(torch.load(input_scheduler_file)) + logger.info('All scheduler states loaded successfully') + for (i, dataloader) in enumerate(dataloaders): + sampler_name = f'{SAMPLER_NAME}.bin' if i == 0 else f'{SAMPLER_NAME}_{i}.bin' + input_sampler_file = input_dir.joinpath(sampler_name) + from .data_loader import IterableDatasetShard, SeedableRandomSampler + if isinstance(dataloader.dataset, IterableDatasetShard): + sampler = dataloader.get_sampler() + if isinstance(sampler, SeedableRandomSampler): + sampler = dataloader.set_sampler(torch.load(input_sampler_file)) + if getattr(dataloader, 'use_stateful_dataloader', False): + dataloader_state_dict_name = 'dl_state_dict.bin' if i == 0 else f'dl_state_dict_{i}.bin' + input_dataloader_state_dict_file = input_dir.joinpath(dataloader_state_dict_name) + if input_dataloader_state_dict_file.exists(): + state_dict = torch.load(input_dataloader_state_dict_file) + dataloader.load_state_dict(state_dict) + logger.info('All dataloader sampler states loaded successfully') + if scaler is not None: + input_scaler_file = input_dir.joinpath(SCALER_NAME) + scaler.load_state_dict(torch.load(input_scaler_file)) + logger.info('GradScaler state loaded successfully') + try: + states = torch.load(input_dir.joinpath(f'{RNG_STATE_NAME}_{process_index}.pkl')) + if 'step' in states: + override_attributes['step'] = states['step'] + random.setstate(states['random_state']) + np.random.set_state(states['numpy_random_seed']) + torch.set_rng_state(states['torch_manual_seed']) + if is_xpu_available(): + torch.xpu.set_rng_state_all(states['torch_xpu_manual_seed']) + if is_mlu_available(): + torch.mlu.set_rng_state_all(states['torch_mlu_manual_seed']) + else: + torch.cuda.set_rng_state_all(states['torch_cuda_manual_seed']) + if is_torch_xla_available(): + xm.set_rng_state(states['xm_seed']) + logger.info('All random states loaded successfully') + except Exception: + logger.info('Could not load random states') + return override_attributes + +def save_custom_state(obj, path, index: int=0, save_on_each_node: bool=False): + save_location = Path(path) / f'custom_checkpoint_{index}.pkl' + logger.info(f'Saving the state of {get_pretty_name(obj)} to {save_location}') + save(obj.state_dict(), save_location, save_on_each_node=save_on_each_node) + +def load_custom_state(obj, path, index: int=0): + load_location = f'{path}/custom_checkpoint_{index}.pkl' + logger.info(f'Loading the state of {get_pretty_name(obj)} from {load_location}') + obj.load_state_dict(torch.load(load_location, map_location='cpu')) + +# File: accelerate-main/src/accelerate/commands/accelerate_cli.py +from accelerate.commands.config import get_config_parser +from accelerate.commands.env import env_command_parser +from accelerate.commands.estimate import estimate_command_parser +from accelerate.commands.launch import launch_command_parser +from accelerate.commands.merge import merge_command_parser +from accelerate.commands.test import test_command_parser +from accelerate.commands.tpu import tpu_command_parser +from accelerate.commands.utils import CustomArgumentParser + +def main(): + parser = CustomArgumentParser('Accelerate CLI tool', usage='accelerate []', allow_abbrev=False) + subparsers = parser.add_subparsers(help='accelerate command helpers') + get_config_parser(subparsers=subparsers) + estimate_command_parser(subparsers=subparsers) + env_command_parser(subparsers=subparsers) + launch_command_parser(subparsers=subparsers) + merge_command_parser(subparsers=subparsers) + tpu_command_parser(subparsers=subparsers) + test_command_parser(subparsers=subparsers) + args = parser.parse_args() + if not hasattr(args, 'func'): + parser.print_help() + exit(1) + args.func(args) +if __name__ == '__main__': + main() + +# File: accelerate-main/src/accelerate/commands/config/__init__.py +import argparse +from .config import config_command_parser +from .config_args import default_config_file, load_config_from_file +from .default import default_command_parser +from .update import update_command_parser + +def get_config_parser(subparsers=None): + parent_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False) + config_parser = config_command_parser(subparsers) + subcommands = config_parser.add_subparsers(title='subcommands', dest='subcommand') + default_command_parser(subcommands, parents=[parent_parser]) + update_command_parser(subcommands, parents=[parent_parser]) + return config_parser + +def main(): + config_parser = get_config_parser() + args = config_parser.parse_args() + if not hasattr(args, 'func'): + config_parser.print_help() + exit(1) + args.func(args) +if __name__ == '__main__': + main() + +# File: accelerate-main/src/accelerate/commands/config/cluster.py +import os +from ...utils import ComputeEnvironment, DistributedType, is_deepspeed_available, is_fp8_available, is_mlu_available, is_mps_available, is_msamp_available, is_musa_available, is_npu_available, is_transformer_engine_available, is_transformers_available, is_xpu_available +from ...utils.constants import DEEPSPEED_MULTINODE_LAUNCHERS, FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, TORCH_DYNAMO_MODES +from .config_args import ClusterConfig +from .config_utils import DYNAMO_BACKENDS, _ask_field, _ask_options, _convert_distributed_mode, _convert_dynamo_backend, _convert_fp8_backend, _convert_mixed_precision, _convert_yes_no_to_bool + +def get_cluster_input(): + distributed_type = _ask_options('Which type of machine are you using?', ['No distributed training', 'multi-CPU', 'multi-XPU', 'multi-GPU', 'multi-NPU', 'multi-MLU', 'multi-MUSA', 'TPU'], _convert_distributed_mode) + machine_rank = 0 + num_machines = 1 + num_processes = 1 + gpu_ids = None + main_process_ip = None + main_process_port = None + rdzv_backend = 'static' + same_network = True + debug = False + if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU, DistributedType.MULTI_CPU]: + num_machines = _ask_field('How many different machines will you use (use more than 1 for multi-node training)? [1]: ', int, default=1) + if num_machines > 1: + machine_rank = _ask_options('What is the rank of this machine?', list(range(num_machines)), int) + main_process_ip = _ask_field('What is the IP address of the machine that will host the main process? ') + main_process_port = _ask_field('What is the port you will use to communicate with the main process? ', int) + same_network = _ask_field('Are all the machines on the same local network? Answer `no` if nodes are on the cloud and/or on different network hosts [YES/no]: ', _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + if not same_network: + rdzv_backend = _ask_field("What rendezvous backend will you use? ('static', 'c10d', ...): ", default='static') + debug = _ask_field('Should distributed operations be checked while running for errors? This can avoid timeout issues but will be slower. [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if distributed_type == DistributedType.NO: + use_cpu = _ask_field('Do you want to run your training on CPU only (even if a GPU / Apple Silicon / Ascend NPU device is available)? [yes/NO]:', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + elif distributed_type == DistributedType.MULTI_CPU: + use_cpu = True + else: + use_cpu = False + ipex_config = {} + mpirun_config = {} + if use_cpu: + ipex_config['ipex'] = _ask_field('Do you want to use Intel PyTorch Extension (IPEX) to speed up training on CPU? [yes/NO]:', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if distributed_type == DistributedType.MULTI_CPU: + use_mpirun = _ask_field('Do you want accelerate to launch mpirun? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_mpirun: + mpirun_hostfile = _ask_field('Please enter the path to the hostfile to use with mpirun [~/hostfile]: ', str, default='~/hostfile') + mpirun_config['mpirun_hostfile'] = os.path.expanduser(mpirun_hostfile.strip()) + mpirun_config['mpirun_ccl'] = _ask_field('Enter the number of oneCCL worker threads [1]: ', default=1) + if not use_cpu and is_xpu_available() and (distributed_type not in [DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_MLU, DistributedType.XLA, DistributedType.MULTI_MUSA]): + ipex_config['use_xpu'] = _ask_field('Do you want to use XPU plugin to speed up training on XPU? [yes/NO]:', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + dynamo_config = {} + use_dynamo = _ask_field('Do you wish to optimize your script with torch dynamo?[yes/NO]:', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_dynamo: + prefix = 'dynamo_' + dynamo_config[prefix + 'backend'] = _ask_options('Which dynamo backend would you like to use?', [x.lower() for x in DYNAMO_BACKENDS], _convert_dynamo_backend, default=2) + use_custom_options = _ask_field('Do you want to customize the defaults sent to torch.compile? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_custom_options: + dynamo_config[prefix + 'mode'] = _ask_options('Which mode do you want to use?', TORCH_DYNAMO_MODES, lambda x: TORCH_DYNAMO_MODES[int(x)], default=0) + dynamo_config[prefix + 'use_fullgraph'] = _ask_field('Do you want the fullgraph mode or it is ok to break model into several subgraphs? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + dynamo_config[prefix + 'use_dynamic'] = _ask_field('Do you want to enable dynamic shape tracing? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + use_mps = not use_cpu and is_mps_available() + deepspeed_config = {} + if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_XPU, DistributedType.MULTI_NPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.NO] and (not use_mps): + use_deepspeed = _ask_field('Do you want to use DeepSpeed? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_deepspeed: + distributed_type = DistributedType.DEEPSPEED + assert is_deepspeed_available(), 'DeepSpeed is not installed => run `pip3 install deepspeed` or build it from source' + if distributed_type == DistributedType.DEEPSPEED: + use_deepspeed_config = _ask_field('Do you want to specify a json file to a DeepSpeed config? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_deepspeed_config: + deepspeed_config['deepspeed_config_file'] = _ask_field('Please enter the path to the json DeepSpeed config file: ', str, default='none') + else: + deepspeed_config['zero_stage'] = _ask_options("What should be your DeepSpeed's ZeRO optimization stage?", [0, 1, 2, 3], int, default=2) + deepspeed_devices = ['none', 'cpu', 'nvme'] + if deepspeed_config['zero_stage'] >= 2: + deepspeed_config['offload_optimizer_device'] = _ask_options('Where to offload optimizer states?', deepspeed_devices, lambda x: deepspeed_devices[int(x)]) + deepspeed_config['offload_param_device'] = _ask_options('Where to offload parameters?', deepspeed_devices, lambda x: deepspeed_devices[int(x)]) + if deepspeed_config['offload_param_device'] == 'nvme': + deepspeed_config['offload_param_nvme_path'] = _ask_field('Nvme Path to offload parameters?', str, default='/nvme') + if deepspeed_config['offload_optimizer_device'] == 'nvme': + deepspeed_config['offload_optimizer_nvme_path'] = _ask_field('Nvme Path to offload optimizer states?', str, default='/nvme') + deepspeed_config['gradient_accumulation_steps'] = _ask_field("How many gradient accumulation steps you're passing in your script? [1]: ", int, default=1) + use_gradient_clipping = _ask_field('Do you want to use gradient clipping? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_gradient_clipping: + deepspeed_config['gradient_clipping'] = _ask_field('What is the gradient clipping value? [1.0]: ', float, default=1.0) + if deepspeed_config['zero_stage'] == 3: + deepspeed_config['zero3_save_16bit_model'] = _ask_field('Do you want to save 16-bit model weights when using ZeRO Stage-3? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + deepspeed_config['zero3_init_flag'] = _ask_field('Do you want to enable `deepspeed.zero.Init` when using ZeRO Stage-3 for constructing massive models? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if deepspeed_config['zero3_init_flag']: + if not is_transformers_available(): + raise Exception('When `zero3_init_flag` is set, it requires Transformers to be installed. Please run `pip3 install transformers`.') + use_moe = _ask_field('Do you want to enable Mixture-of-Experts training (MoE)? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_moe: + deepspeed_config['deepspeed_moe_layer_cls_names'] = _ask_field('Specify the comma-separated list of transformers MoE layer class names (case-sensitive), e.g : `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention,JetMoEBlock` ... : ', str) + if num_machines > 1: + launcher_query = 'Which Type of launcher do you want to use?' + deepspeed_config['deepspeed_multinode_launcher'] = _ask_options(launcher_query, DEEPSPEED_MULTINODE_LAUNCHERS, lambda x: DEEPSPEED_MULTINODE_LAUNCHERS[int(x)]) + if deepspeed_config['deepspeed_multinode_launcher'] != DEEPSPEED_MULTINODE_LAUNCHERS[1]: + deepspeed_config['deepspeed_hostfile'] = _ask_field('DeepSpeed configures multi-node compute resources with hostfile. Each row is of the format `hostname slots=[num_gpus]`, e.g., `localhost slots=2`; for more information please refer official [documentation](https://www.deepspeed.ai/getting-started/#resource-configuration-multi-node). Please specify the location of hostfile: ', str) + is_exclusion_filter = _ask_field('Do you want to specify exclusion filter string? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if is_exclusion_filter: + deepspeed_config['deepspeed_exclusion_filter'] = _ask_field('DeepSpeed exclusion filter string: ', str) + is_inclusion_filter = _ask_field('Do you want to specify inclusion filter string? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if is_inclusion_filter: + deepspeed_config['deepspeed_inclusion_filter'] = _ask_field('DeepSpeed inclusion filter string: ', str) + fsdp_config = {} + if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_XPU]: + use_fsdp = _ask_field('Do you want to use FullyShardedDataParallel? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_fsdp: + distributed_type = DistributedType.FSDP + if distributed_type == DistributedType.FSDP: + sharding_strategy_query = 'What should be your sharding strategy?' + fsdp_config['fsdp_sharding_strategy'] = _ask_options(sharding_strategy_query, FSDP_SHARDING_STRATEGY, lambda x: FSDP_SHARDING_STRATEGY[int(x)]) + fsdp_config['fsdp_offload_params'] = _ask_field('Do you want to offload parameters and gradients to CPU? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + fsdp_wrap_query = 'What should be your auto wrap policy?' + fsdp_config['fsdp_auto_wrap_policy'] = _ask_options(fsdp_wrap_query, FSDP_AUTO_WRAP_POLICY, lambda x: FSDP_AUTO_WRAP_POLICY[int(x)]) + if fsdp_config['fsdp_auto_wrap_policy'] == FSDP_AUTO_WRAP_POLICY[0]: + use_no_split_modules = _ask_field("Do you want to use the model's `_no_split_modules` to wrap. Only applicable for 🤗 Transformers [yes/NO]: ", _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if not use_no_split_modules: + fsdp_config['fsdp_transformer_layer_cls_to_wrap'] = _ask_field('Specify the comma-separated list of transformer layer class names (case-sensitive) to wrap ,e.g, :`BertLayer`, `GPTJBlock`, `T5Block`, `BertLayer,BertEmbeddings,BertSelfOutput` ...? : ', str) + elif fsdp_config['fsdp_auto_wrap_policy'] == FSDP_AUTO_WRAP_POLICY[1]: + fsdp_config['fsdp_min_num_params'] = _ask_field("What should be your FSDP's minimum number of parameters for Default Auto Wrapping Policy? [1e8]: ", int, default=100000000) + fsdp_backward_prefetch_query = "What should be your FSDP's backward prefetch policy?" + fsdp_config['fsdp_backward_prefetch'] = _ask_options(fsdp_backward_prefetch_query, FSDP_BACKWARD_PREFETCH, lambda x: FSDP_BACKWARD_PREFETCH[int(x)]) + fsdp_state_dict_type_query = "What should be your FSDP's state dict type?" + fsdp_config['fsdp_state_dict_type'] = _ask_options(fsdp_state_dict_type_query, FSDP_STATE_DICT_TYPE, lambda x: FSDP_STATE_DICT_TYPE[int(x)], default=2) + fsdp_config['fsdp_forward_prefetch'] = _ask_field("Do you want to enable FSDP's forward prefetch policy? [yes/NO]: ", _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + fsdp_config['fsdp_use_orig_params'] = _ask_field("Do you want to enable FSDP's `use_orig_params` feature? [YES/no]: ", _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + fsdp_config['fsdp_cpu_ram_efficient_loading'] = _ask_field('Do you want to enable CPU RAM efficient model loading? Only applicable for 🤗 Transformers models. [YES/no]: ', _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + if fsdp_config['fsdp_cpu_ram_efficient_loading']: + fsdp_config['fsdp_sync_module_states'] = True + else: + fsdp_config['fsdp_sync_module_states'] = _ask_field('Do you want each individually wrapped FSDP unit to broadcast module parameters from rank 0 at the start? [YES/no]: ', _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + fsdp_config['fsdp_activation_checkpointing'] = _ask_field('Do you want to enable FSDP activation checkpointing? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + megatron_lm_config = {} + if distributed_type in [DistributedType.MULTI_GPU]: + use_megatron_lm = _ask_field('Do you want to use Megatron-LM ? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_megatron_lm: + distributed_type = DistributedType.MEGATRON_LM + if distributed_type == DistributedType.MEGATRON_LM: + prefix = 'megatron_lm_' + megatron_lm_config[prefix + 'tp_degree'] = _ask_field('What is the Tensor Parallelism degree/size? [1]:', int, default=1, error_message='Please enter an integer.') + if megatron_lm_config[prefix + 'tp_degree'] > 1: + megatron_lm_config[prefix + 'sequence_parallelism'] = _ask_field('Do you want to enable Sequence Parallelism? [YES/no]: ', _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + megatron_lm_config[prefix + 'pp_degree'] = _ask_field('What is the Pipeline Parallelism degree/size? [1]:', int, default=1, error_message='Please enter an integer.') + if megatron_lm_config[prefix + 'pp_degree'] > 1: + megatron_lm_config[prefix + 'num_micro_batches'] = _ask_field('What is the number of micro-batches? [1]:', int, default=1, error_message='Please enter an integer.') + megatron_lm_config[prefix + 'recompute_activations'] = _ask_field('Do you want to enable selective activation recomputation? [YES/no]: ', _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + megatron_lm_config[prefix + 'use_distributed_optimizer'] = _ask_field('Do you want to use distributed optimizer which shards optimizer state and gradients across data parallel ranks? [YES/no]: ', _convert_yes_no_to_bool, default=True, error_message='Please enter yes or no.') + megatron_lm_config[prefix + 'gradient_clipping'] = _ask_field('What is the gradient clipping value based on global L2 Norm (0 to disable)? [1.0]: ', float, default=1.0) + tpu_commands = None + tpu_command_file = None + tpu_downcast_bf16 = 'no' + tpu_env = [] + tpu_name = None + tpu_vm = None + tpu_zone = None + tpu_use_sudo = False + tpu_use_cluster = False + if distributed_type in [DistributedType.MULTI_CPU, DistributedType.MULTI_XPU, DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU, DistributedType.XLA]: + machine_type = str(distributed_type).split('.')[1].replace('MULTI_', '') + if machine_type == 'TPU': + machine_type += ' cores' + elif machine_type == 'CPU': + machine_type = 'processes' + else: + machine_type += '(s)' + num_processes = _ask_field(f'How many {machine_type} should be used for distributed training? [1]:', int, default=1, error_message='Please enter an integer.') + elif distributed_type in [DistributedType.FSDP, DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM]: + num_processes = _ask_field('How many GPU(s) should be used for distributed training? [1]:', int, default=1, error_message='Please enter an integer.') + else: + num_processes = 1 + if distributed_type == DistributedType.MULTI_GPU and num_machines == 1 and (num_processes == 1): + raise ValueError(f'Specified distributed type {distributed_type} but only using 1 GPU on a single machine. Please select `No distributed training` for the type of machine you are using.') + if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU, DistributedType.NO] and (not use_cpu) and (not use_mps): + if is_npu_available(): + machine_type = 'NPU(s)' + elif is_mlu_available(): + machine_type = 'MLU(s)' + elif is_musa_available(): + machine_type = 'MUSA(s)' + else: + machine_type = 'GPU(s)' + gpu_ids = _ask_field(f'What {machine_type} (by id) should be used for training on this machine as a comma-seperated list? [all]:', default='all') + enable_cpu_affinity = False + if distributed_type in (DistributedType.NO, DistributedType.MULTI_GPU) and (not use_cpu) and (not use_mps): + enable_cpu_affinity = _ask_field('Would you like to enable numa efficiency? (Currently only supported on NVIDIA hardware). [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + fp8_config = None + if distributed_type == DistributedType.XLA: + mixed_precision = 'no' + main_training_function = _ask_field('What is the name of the function in your script that should be launched in all parallel scripts? [main]: ', default='main') + tpu_use_cluster = _ask_field('Are you using a TPU cluster? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if tpu_use_cluster: + tpu_name = _ask_field('What is the name of your TPU cluster? ', default=None, error_message='Please enter the name of your TPU cluster.') + tpu_zone = _ask_field('What is the zone of your TPU cluster? ', default=None, error_message='Please enter the zone of your TPU cluster.') + tpu_use_sudo = _ask_field('To run a python script in a TPU pod, should `sudo` be used? [yes/NO]: ', default=False, error_message='Please enter yes or no.') + run_commands = _ask_field('Do you have code you wish to run on startup in each pod? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if run_commands: + use_command_file = _ask_field('Is this code located in a bash script? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_command_file: + tpu_command_file = _ask_field('What is the path to your bash script? ', default=None, error_message='Please enter the path to your bash script.') + tpu_command_file = os.path.abspath(tpu_command_file) + else: + print('Please enter each command seperately you wish to run on startup in each pod.') + tpu_commands = [] + another_command = True + while another_command: + tpu_commands.append(_ask_field('Please enter a single command to be ran ', default=None, error_message='Please enter the commands you wish to run on startup in each pod as a single string.')) + another_command = _ask_field('Do you wish to add another command? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + tpu_vm = _ask_field('If not using an instance group, what are the names of the Compute VM instances to be used, seperated by a comma: ', default='').split(',') + tpu_env = _ask_field('What environment variables do you wish to set in each pod, seperated by a comma: ', default='').split(',') + else: + main_training_function = 'main' + if distributed_type == DistributedType.DEEPSPEED and use_deepspeed_config: + mixed_precision = None + else: + mixed_precision = _ask_options('Do you wish to use mixed precision?', ['no', 'fp16', 'bf16', 'fp8'], _convert_mixed_precision) + if mixed_precision == 'fp8': + if not is_fp8_available(): + raise ValueError('FP8 (either Transformer Engine or MSAMP) is not installed on this machine.') + fp8_config = {} + fp8_config['backend'] = _ask_options('Which FP8 backend do you want to use?', ['te', 'msamp'], _convert_fp8_backend) + if fp8_config['backend'] == 'TE': + if not is_transformer_engine_available(): + raise ValueError('TransformersEngine was selected, but it is not installed on this machine.') + fp8_config['use_autocast_during_eval'] = _ask_field('Do you want to use FP8 autocast during eval mode? Generally better metrics are found when this is disabled [yes/NO]: ', _convert_yes_no_to_bool, default=False) + fp8_config['margin'] = _ask_field('What margin should be used for gradient scaling? [0]: ', int, default=0) + fp8_config['interval'] = _ask_field('What interval should be used for for how often the scaling factor is recomputed? [1]: ', int, default=1) + fp8_config['fp8_format'] = _ask_options('Which weight format should be used?', ['HYBRID', 'E4M3'], lambda x: 'HYBRID' if x == 0 else 'E4M3', default=0) + fp8_config['amax_history_length'] = _ask_field('What length of history should be used for the amax scaling factor computation? [1024]: ', int, default=1024) + fp8_config['amax_compute_algorithm'] = _ask_options('Which algorithm should be used for the amax scaling factor computation?', ['max', 'most_recent'], lambda x: 'max' if x == 0 else 'most_recent', default=0) + fp8_config['override_linear_precision'] = _ask_field('Do you want to to execute `fprop`, `dgrad`, and `wgrad` GEMMS in higher precision? [yes/NO]: ', _convert_yes_no_to_bool, default=False) + if fp8_config['override_linear_precision']: + fprop = _ask_field('Should `fprop` be executed in higher precision? [yes/NO]: ', _convert_yes_no_to_bool, default=False) + dgrad = _ask_field('Should `dgrad` be executed in higher precision? [yes/NO]: ', _convert_yes_no_to_bool, default=False) + wgrad = _ask_field('Should `wgrad` be executed in higher precision? [yes/NO]: ', _convert_yes_no_to_bool, default=False) + fp8_config['override_linear_precision'] = (fprop, dgrad, wgrad) + elif fp8_config['backend'] == 'MSAMP': + if not is_msamp_available(): + raise ValueError('MSAMP was selected, but it is not installed on this machine.') + fp8_config['optimization_level'] = _ask_options('Which optimization level should be used?', ['O1', 'O2'], lambda x: 'O1' if x == 0 else 'O2', default=1) + if use_dynamo and mixed_precision == 'no' and (not use_cpu): + print('Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts.') + if distributed_type == DistributedType.XLA and mixed_precision == 'bf16': + tpu_downcast_bf16 = _ask_field('Should `torch.float` be cast as `bfloat16` and `torch.double` remain `float32` on TPUs?', default='no') + return ClusterConfig(compute_environment=ComputeEnvironment.LOCAL_MACHINE, distributed_type=distributed_type, num_processes=num_processes, gpu_ids=gpu_ids, mixed_precision=mixed_precision, downcast_bf16=tpu_downcast_bf16, machine_rank=machine_rank, num_machines=num_machines, main_process_ip=main_process_ip, main_process_port=main_process_port, main_training_function=main_training_function, fp8_config=fp8_config, deepspeed_config=deepspeed_config, fsdp_config=fsdp_config, megatron_lm_config=megatron_lm_config, ipex_config=ipex_config, mpirun_config=mpirun_config, use_cpu=use_cpu, rdzv_backend=rdzv_backend, same_network=same_network, commands=tpu_commands, command_file=tpu_command_file, tpu_env=tpu_env, tpu_name=tpu_name, tpu_vm=tpu_vm, tpu_zone=tpu_zone, tpu_use_sudo=tpu_use_sudo, tpu_use_cluster=tpu_use_cluster, dynamo_config=dynamo_config, debug=debug, enable_cpu_affinity=enable_cpu_affinity) + +# File: accelerate-main/src/accelerate/commands/config/config.py +import argparse +import os +from accelerate.utils import ComputeEnvironment +from .cluster import get_cluster_input +from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file +from .config_utils import _ask_field, _ask_options, _convert_compute_environment +from .sagemaker import get_sagemaker_input +description = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine' + +def get_user_input(): + compute_environment = _ask_options('In which compute environment are you running?', ['This machine', 'AWS (Amazon SageMaker)'], _convert_compute_environment) + if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER: + config = get_sagemaker_input() + else: + config = get_cluster_input() + return config + +def config_command_parser(subparsers=None): + if subparsers is not None: + parser = subparsers.add_parser('config', description=description) + else: + parser = argparse.ArgumentParser('Accelerate config command', description=description) + parser.add_argument('--config_file', default=None, help="The path to use to store the config file. Will default to a file named default_config.yaml in the cache location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed with 'huggingface'.") + if subparsers is not None: + parser.set_defaults(func=config_command) + return parser + +def config_command(args): + config = get_user_input() + if args.config_file is not None: + config_file = args.config_file + else: + if not os.path.isdir(cache_dir): + os.makedirs(cache_dir) + config_file = default_yaml_config_file + if config_file.endswith('.json'): + config.to_json_file(config_file) + else: + config.to_yaml_file(config_file) + print(f'accelerate configuration saved at {config_file}') + +def main(): + parser = config_command_parser() + args = parser.parse_args() + config_command(args) +if __name__ == '__main__': + main() + +# File: accelerate-main/src/accelerate/commands/config/config_args.py +import json +import os +from dataclasses import dataclass +from enum import Enum +from typing import List, Optional, Union +import yaml +from ...utils import ComputeEnvironment, DistributedType, SageMakerDistributedType +from ...utils.constants import SAGEMAKER_PYTHON_VERSION, SAGEMAKER_PYTORCH_VERSION, SAGEMAKER_TRANSFORMERS_VERSION +hf_cache_home = os.path.expanduser(os.environ.get('HF_HOME', os.path.join(os.environ.get('XDG_CACHE_HOME', '~/.cache'), 'huggingface'))) +cache_dir = os.path.join(hf_cache_home, 'accelerate') +default_json_config_file = os.path.join(cache_dir, 'default_config.yaml') +default_yaml_config_file = os.path.join(cache_dir, 'default_config.yaml') +if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file): + default_config_file = default_yaml_config_file +else: + default_config_file = default_json_config_file + +def load_config_from_file(config_file): + if config_file is not None: + if not os.path.isfile(config_file): + raise FileNotFoundError(f'The passed configuration file `{config_file}` does not exist. Please pass an existing file to `accelerate launch`, or use the default one created through `accelerate config` and run `accelerate launch` without the `--config_file` argument.') + else: + config_file = default_config_file + with open(config_file, encoding='utf-8') as f: + if config_file.endswith('.json'): + if json.load(f).get('compute_environment', ComputeEnvironment.LOCAL_MACHINE) == ComputeEnvironment.LOCAL_MACHINE: + config_class = ClusterConfig + else: + config_class = SageMakerConfig + return config_class.from_json_file(json_file=config_file) + else: + if yaml.safe_load(f).get('compute_environment', ComputeEnvironment.LOCAL_MACHINE) == ComputeEnvironment.LOCAL_MACHINE: + config_class = ClusterConfig + else: + config_class = SageMakerConfig + return config_class.from_yaml_file(yaml_file=config_file) + +@dataclass +class BaseConfig: + compute_environment: ComputeEnvironment + distributed_type: Union[DistributedType, SageMakerDistributedType] + mixed_precision: str + use_cpu: bool + debug: bool + + def to_dict(self): + result = self.__dict__ + + def _convert_enums(value): + if isinstance(value, Enum): + return value.value + if isinstance(value, dict): + if not bool(value): + return None + for (key1, value1) in value.items(): + value[key1] = _convert_enums(value1) + return value + for (key, value) in result.items(): + result[key] = _convert_enums(value) + result = {k: v for (k, v) in result.items() if v is not None} + return result + + @staticmethod + def process_config(config_dict): + if 'compute_environment' not in config_dict: + config_dict['compute_environment'] = ComputeEnvironment.LOCAL_MACHINE + if 'distributed_type' not in config_dict: + raise ValueError('A `distributed_type` must be specified in the config file.') + if 'num_processes' not in config_dict and config_dict['distributed_type'] == DistributedType.NO: + config_dict['num_processes'] = 1 + if 'mixed_precision' not in config_dict: + config_dict['mixed_precision'] = 'fp16' if 'fp16' in config_dict and config_dict['fp16'] else None + if 'fp16' in config_dict: + del config_dict['fp16'] + if 'dynamo_backend' in config_dict: + dynamo_backend = config_dict.pop('dynamo_backend') + config_dict['dynamo_config'] = {} if dynamo_backend == 'NO' else {'dynamo_backend': dynamo_backend} + if 'use_cpu' not in config_dict: + config_dict['use_cpu'] = False + if 'debug' not in config_dict: + config_dict['debug'] = False + if 'enable_cpu_affinity' not in config_dict: + config_dict['enable_cpu_affinity'] = False + return config_dict + + @classmethod + def from_json_file(cls, json_file=None): + json_file = default_json_config_file if json_file is None else json_file + with open(json_file, encoding='utf-8') as f: + config_dict = json.load(f) + config_dict = cls.process_config(config_dict) + extra_keys = sorted(set(config_dict.keys()) - set(cls.__dataclass_fields__.keys())) + if len(extra_keys) > 0: + raise ValueError(f'The config file at {json_file} had unknown keys ({extra_keys}), please try upgrading your `accelerate` version or fix (and potentially remove) these keys from your config file.') + return cls(**config_dict) + + def to_json_file(self, json_file): + with open(json_file, 'w', encoding='utf-8') as f: + content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + '\n' + f.write(content) + + @classmethod + def from_yaml_file(cls, yaml_file=None): + yaml_file = default_yaml_config_file if yaml_file is None else yaml_file + with open(yaml_file, encoding='utf-8') as f: + config_dict = yaml.safe_load(f) + config_dict = cls.process_config(config_dict) + extra_keys = sorted(set(config_dict.keys()) - set(cls.__dataclass_fields__.keys())) + if len(extra_keys) > 0: + raise ValueError(f'The config file at {yaml_file} had unknown keys ({extra_keys}), please try upgrading your `accelerate` version or fix (and potentially remove) these keys from your config file.') + return cls(**config_dict) + + def to_yaml_file(self, yaml_file): + with open(yaml_file, 'w', encoding='utf-8') as f: + yaml.safe_dump(self.to_dict(), f) + + def __post_init__(self): + if isinstance(self.compute_environment, str): + self.compute_environment = ComputeEnvironment(self.compute_environment) + if isinstance(self.distributed_type, str): + if self.compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER: + self.distributed_type = SageMakerDistributedType(self.distributed_type) + else: + self.distributed_type = DistributedType(self.distributed_type) + if getattr(self, 'dynamo_config', None) is None: + self.dynamo_config = {} + +@dataclass +class ClusterConfig(BaseConfig): + num_processes: int = -1 + machine_rank: int = 0 + num_machines: int = 1 + gpu_ids: Optional[str] = None + main_process_ip: Optional[str] = None + main_process_port: Optional[int] = None + rdzv_backend: Optional[str] = 'static' + same_network: Optional[bool] = False + main_training_function: str = 'main' + enable_cpu_affinity: bool = False + fp8_config: dict = None + deepspeed_config: dict = None + fsdp_config: dict = None + megatron_lm_config: dict = None + ipex_config: dict = None + mpirun_config: dict = None + downcast_bf16: bool = False + tpu_name: str = None + tpu_zone: str = None + tpu_use_cluster: bool = False + tpu_use_sudo: bool = False + command_file: str = None + commands: List[str] = None + tpu_vm: List[str] = None + tpu_env: List[str] = None + dynamo_config: dict = None + + def __post_init__(self): + if self.deepspeed_config is None: + self.deepspeed_config = {} + if self.fsdp_config is None: + self.fsdp_config = {} + if self.megatron_lm_config is None: + self.megatron_lm_config = {} + if self.ipex_config is None: + self.ipex_config = {} + if self.mpirun_config is None: + self.mpirun_config = {} + if self.fp8_config is None: + self.fp8_config = {} + return super().__post_init__() + +@dataclass +class SageMakerConfig(BaseConfig): + ec2_instance_type: str + iam_role_name: str + image_uri: Optional[str] = None + profile: Optional[str] = None + region: str = 'us-east-1' + num_machines: int = 1 + gpu_ids: str = 'all' + base_job_name: str = f'accelerate-sagemaker-{num_machines}' + pytorch_version: str = SAGEMAKER_PYTORCH_VERSION + transformers_version: str = SAGEMAKER_TRANSFORMERS_VERSION + py_version: str = SAGEMAKER_PYTHON_VERSION + sagemaker_inputs_file: str = None + sagemaker_metrics_file: str = None + additional_args: dict = None + dynamo_config: dict = None + enable_cpu_affinity: bool = False + +# File: accelerate-main/src/accelerate/commands/config/config_utils.py +import argparse +from ...utils.dataclasses import ComputeEnvironment, DistributedType, DynamoBackend, FP8BackendType, PrecisionType, SageMakerDistributedType +from ..menu import BulletMenu +DYNAMO_BACKENDS = ['EAGER', 'AOT_EAGER', 'INDUCTOR', 'AOT_TS_NVFUSER', 'NVPRIMS_NVFUSER', 'CUDAGRAPHS', 'OFI', 'FX2TRT', 'ONNXRT', 'TENSORRT', 'AOT_TORCHXLA_TRACE_ONCE', 'TORHCHXLA_TRACE_ONCE', 'IPEX', 'TVM'] + +def _ask_field(input_text, convert_value=None, default=None, error_message=None): + ask_again = True + while ask_again: + result = input(input_text) + try: + if default is not None and len(result) == 0: + return default + return convert_value(result) if convert_value is not None else result + except Exception: + if error_message is not None: + print(error_message) + +def _ask_options(input_text, options=[], convert_value=None, default=0): + menu = BulletMenu(input_text, options) + result = menu.run(default_choice=default) + return convert_value(result) if convert_value is not None else result + +def _convert_compute_environment(value): + value = int(value) + return ComputeEnvironment(['LOCAL_MACHINE', 'AMAZON_SAGEMAKER'][value]) + +def _convert_distributed_mode(value): + value = int(value) + return DistributedType(['NO', 'MULTI_CPU', 'MULTI_XPU', 'MULTI_GPU', 'MULTI_NPU', 'MULTI_MLU', 'MULTI_MUSA', 'XLA'][value]) + +def _convert_dynamo_backend(value): + value = int(value) + return DynamoBackend(DYNAMO_BACKENDS[value]).value + +def _convert_mixed_precision(value): + value = int(value) + return PrecisionType(['no', 'fp16', 'bf16', 'fp8'][value]) + +def _convert_sagemaker_distributed_mode(value): + value = int(value) + return SageMakerDistributedType(['NO', 'DATA_PARALLEL', 'MODEL_PARALLEL'][value]) + +def _convert_fp8_backend(value): + value = int(value) + return FP8BackendType(['TE', 'MSAMP'][value]) + +def _convert_yes_no_to_bool(value): + return {'yes': True, 'no': False}[value.lower()] + +class SubcommandHelpFormatter(argparse.RawDescriptionHelpFormatter): + + def _format_usage(self, usage, actions, groups, prefix): + usage = super()._format_usage(usage, actions, groups, prefix) + usage = usage.replace(' [] ', '') + return usage + +# File: accelerate-main/src/accelerate/commands/config/default.py +from pathlib import Path +import torch +from ...utils import is_mlu_available, is_musa_available, is_npu_available, is_xpu_available +from .config_args import ClusterConfig, default_json_config_file +from .config_utils import SubcommandHelpFormatter +description = 'Create a default config file for Accelerate with only a few flags set.' + +def write_basic_config(mixed_precision='no', save_location: str=default_json_config_file, use_xpu: bool=False): + path = Path(save_location) + path.parent.mkdir(parents=True, exist_ok=True) + if path.exists(): + print(f'Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`.') + return False + mixed_precision = mixed_precision.lower() + if mixed_precision not in ['no', 'fp16', 'bf16', 'fp8']: + raise ValueError(f"`mixed_precision` should be one of 'no', 'fp16', 'bf16', or 'fp8'. Received {mixed_precision}") + config = {'compute_environment': 'LOCAL_MACHINE', 'mixed_precision': mixed_precision} + if is_mlu_available(): + num_mlus = torch.mlu.device_count() + config['num_processes'] = num_mlus + config['use_cpu'] = False + if num_mlus > 1: + config['distributed_type'] = 'MULTI_MLU' + else: + config['distributed_type'] = 'NO' + elif is_musa_available(): + num_musas = torch.musa.device_count() + config['num_processes'] = num_musas + config['use_cpu'] = False + if num_musas > 1: + config['distributed_type'] = 'MULTI_MUSA' + else: + config['distributed_type'] = 'NO' + elif torch.cuda.is_available(): + num_gpus = torch.cuda.device_count() + config['num_processes'] = num_gpus + config['use_cpu'] = False + if num_gpus > 1: + config['distributed_type'] = 'MULTI_GPU' + else: + config['distributed_type'] = 'NO' + elif is_xpu_available() and use_xpu: + num_xpus = torch.xpu.device_count() + config['num_processes'] = num_xpus + config['use_cpu'] = False + if num_xpus > 1: + config['distributed_type'] = 'MULTI_XPU' + else: + config['distributed_type'] = 'NO' + elif is_npu_available(): + num_npus = torch.npu.device_count() + config['num_processes'] = num_npus + config['use_cpu'] = False + if num_npus > 1: + config['distributed_type'] = 'MULTI_NPU' + else: + config['distributed_type'] = 'NO' + else: + num_xpus = 0 + config['use_cpu'] = True + config['num_processes'] = 1 + config['distributed_type'] = 'NO' + config['debug'] = False + config['enable_cpu_affinity'] = False + config = ClusterConfig(**config) + config.to_json_file(path) + return path + +def default_command_parser(parser, parents): + parser = parser.add_parser('default', parents=parents, help=description, formatter_class=SubcommandHelpFormatter) + parser.add_argument('--config_file', default=default_json_config_file, help="The path to use to store the config file. Will default to a file named default_config.yaml in the cache location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed with 'huggingface'.", dest='save_location') + parser.add_argument('--mixed_precision', choices=['no', 'fp16', 'bf16'], type=str, help='Whether or not to use mixed precision training. Choose between FP16 and BF16 (bfloat16) training. BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.', default='no') + parser.set_defaults(func=default_config_command) + return parser + +def default_config_command(args): + config_file = write_basic_config(args.mixed_precision, args.save_location) + if config_file: + print(f'accelerate configuration saved at {config_file}') + +# File: accelerate-main/src/accelerate/commands/config/sagemaker.py +import json +import os +from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES, TORCH_DYNAMO_MODES +from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType +from ...utils.imports import is_boto3_available +from .config_args import SageMakerConfig +from .config_utils import DYNAMO_BACKENDS, _ask_field, _ask_options, _convert_dynamo_backend, _convert_mixed_precision, _convert_sagemaker_distributed_mode, _convert_yes_no_to_bool +if is_boto3_available(): + import boto3 + +def _create_iam_role_for_sagemaker(role_name): + iam_client = boto3.client('iam') + sagemaker_trust_policy = {'Version': '2012-10-17', 'Statement': [{'Effect': 'Allow', 'Principal': {'Service': 'sagemaker.amazonaws.com'}, 'Action': 'sts:AssumeRole'}]} + try: + iam_client.create_role(RoleName=role_name, AssumeRolePolicyDocument=json.dumps(sagemaker_trust_policy, indent=2)) + policy_document = {'Version': '2012-10-17', 'Statement': [{'Effect': 'Allow', 'Action': ['sagemaker:*', 'ecr:GetDownloadUrlForLayer', 'ecr:BatchGetImage', 'ecr:BatchCheckLayerAvailability', 'ecr:GetAuthorizationToken', 'cloudwatch:PutMetricData', 'cloudwatch:GetMetricData', 'cloudwatch:GetMetricStatistics', 'cloudwatch:ListMetrics', 'logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:DescribeLogStreams', 'logs:PutLogEvents', 'logs:GetLogEvents', 's3:CreateBucket', 's3:ListBucket', 's3:GetBucketLocation', 's3:GetObject', 's3:PutObject'], 'Resource': '*'}]} + iam_client.put_role_policy(RoleName=role_name, PolicyName=f'{role_name}_policy_permission', PolicyDocument=json.dumps(policy_document, indent=2)) + except iam_client.exceptions.EntityAlreadyExistsException: + print(f'role {role_name} already exists. Using existing one') + +def _get_iam_role_arn(role_name): + iam_client = boto3.client('iam') + return iam_client.get_role(RoleName=role_name)['Role']['Arn'] + +def get_sagemaker_input(): + credentials_configuration = _ask_options('How do you want to authorize?', ['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) '], int) + aws_profile = None + if credentials_configuration == 0: + aws_profile = _ask_field('Enter your AWS Profile name: [default] ', default='default') + os.environ['AWS_PROFILE'] = aws_profile + else: + print('Note you will need to provide AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY when you launch you training script with,`accelerate launch --aws_access_key_id XXX --aws_secret_access_key YYY`') + aws_access_key_id = _ask_field('AWS Access Key ID: ') + os.environ['AWS_ACCESS_KEY_ID'] = aws_access_key_id + aws_secret_access_key = _ask_field('AWS Secret Access Key: ') + os.environ['AWS_SECRET_ACCESS_KEY'] = aws_secret_access_key + aws_region = _ask_field('Enter your AWS Region: [us-east-1]', default='us-east-1') + os.environ['AWS_DEFAULT_REGION'] = aws_region + role_management = _ask_options('Do you already have an IAM Role for executing Amazon SageMaker Training Jobs?', ['Provide IAM Role name', 'Create new IAM role using credentials'], int) + if role_management == 0: + iam_role_name = _ask_field('Enter your IAM role name: ') + else: + iam_role_name = 'accelerate_sagemaker_execution_role' + print(f'Accelerate will create an iam role "{iam_role_name}" using the provided credentials') + _create_iam_role_for_sagemaker(iam_role_name) + is_custom_docker_image = _ask_field('Do you want to use custom Docker image? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + docker_image = None + if is_custom_docker_image: + docker_image = _ask_field('Enter your Docker image: ', lambda x: str(x).lower()) + is_sagemaker_inputs_enabled = _ask_field('Do you want to provide SageMaker input channels with data locations? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + sagemaker_inputs_file = None + if is_sagemaker_inputs_enabled: + sagemaker_inputs_file = _ask_field('Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): ', lambda x: str(x).lower()) + is_sagemaker_metrics_enabled = _ask_field('Do you want to enable SageMaker metrics? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + sagemaker_metrics_file = None + if is_sagemaker_metrics_enabled: + sagemaker_metrics_file = _ask_field('Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): ', lambda x: str(x).lower()) + distributed_type = _ask_options('What is the distributed mode?', ['No distributed training', 'Data parallelism'], _convert_sagemaker_distributed_mode) + dynamo_config = {} + use_dynamo = _ask_field('Do you wish to optimize your script with torch dynamo?[yes/NO]:', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_dynamo: + prefix = 'dynamo_' + dynamo_config[prefix + 'backend'] = _ask_options('Which dynamo backend would you like to use?', [x.lower() for x in DYNAMO_BACKENDS], _convert_dynamo_backend, default=2) + use_custom_options = _ask_field('Do you want to customize the defaults sent to torch.compile? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + if use_custom_options: + dynamo_config[prefix + 'mode'] = _ask_options('Which mode do you want to use?', TORCH_DYNAMO_MODES, lambda x: TORCH_DYNAMO_MODES[int(x)], default='default') + dynamo_config[prefix + 'use_fullgraph'] = _ask_field('Do you want the fullgraph mode or it is ok to break model into several subgraphs? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + dynamo_config[prefix + 'use_dynamic'] = _ask_field('Do you want to enable dynamic shape tracing? [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + ec2_instance_query = 'Which EC2 instance type you want to use for your training?' + if distributed_type != SageMakerDistributedType.NO: + ec2_instance_type = _ask_options(ec2_instance_query, SAGEMAKER_PARALLEL_EC2_INSTANCES, lambda x: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(x)]) + else: + ec2_instance_query += '? [ml.p3.2xlarge]:' + ec2_instance_type = _ask_field(ec2_instance_query, lambda x: str(x).lower(), default='ml.p3.2xlarge') + debug = False + if distributed_type != SageMakerDistributedType.NO: + debug = _ask_field('Should distributed operations be checked while running for errors? This can avoid timeout issues but will be slower. [yes/NO]: ', _convert_yes_no_to_bool, default=False, error_message='Please enter yes or no.') + num_machines = 1 + if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL): + num_machines = _ask_field('How many machines do you want use? [1]: ', int, default=1) + mixed_precision = _ask_options('Do you wish to use FP16 or BF16 (mixed precision)?', ['no', 'fp16', 'bf16', 'fp8'], _convert_mixed_precision) + if use_dynamo and mixed_precision == 'no': + print('Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts.') + return SageMakerConfig(image_uri=docker_image, compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER, distributed_type=distributed_type, use_cpu=False, dynamo_config=dynamo_config, ec2_instance_type=ec2_instance_type, profile=aws_profile, region=aws_region, iam_role_name=iam_role_name, mixed_precision=mixed_precision, num_machines=num_machines, sagemaker_inputs_file=sagemaker_inputs_file, sagemaker_metrics_file=sagemaker_metrics_file, debug=debug) + +# File: accelerate-main/src/accelerate/commands/config/update.py +from pathlib import Path +from .config_args import default_config_file, load_config_from_file +from .config_utils import SubcommandHelpFormatter +description = 'Update an existing config file with the latest defaults while maintaining the old configuration.' + +def update_config(args): + config_file = args.config_file + if config_file is None and Path(default_config_file).exists(): + config_file = default_config_file + elif not Path(config_file).exists(): + raise ValueError(f"The passed config file located at {config_file} doesn't exist.") + config = load_config_from_file(config_file) + if config_file.endswith('.json'): + config.to_json_file(config_file) + else: + config.to_yaml_file(config_file) + return config_file + +def update_command_parser(parser, parents): + parser = parser.add_parser('update', parents=parents, help=description, formatter_class=SubcommandHelpFormatter) + parser.add_argument('--config_file', default=None, help="The path to the config file to update. Will default to a file named default_config.yaml in the cache location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed with 'huggingface'.") + parser.set_defaults(func=update_config_command) + return parser + +def update_config_command(args): + config_file = update_config(args) + print(f'Sucessfully updated the configuration file at {config_file}.') + +# File: accelerate-main/src/accelerate/commands/env.py +import argparse +import os +import platform +import subprocess +import numpy as np +import psutil +import torch +from accelerate import __version__ as version +from accelerate.commands.config import default_config_file, load_config_from_file +from ..utils import is_mlu_available, is_musa_available, is_npu_available, is_xpu_available + +def env_command_parser(subparsers=None): + if subparsers is not None: + parser = subparsers.add_parser('env') + else: + parser = argparse.ArgumentParser('Accelerate env command') + parser.add_argument('--config_file', default=None, help='The config file to use for the default values in the launching script.') + if subparsers is not None: + parser.set_defaults(func=env_command) + return parser + +def env_command(args): + pt_version = torch.__version__ + pt_cuda_available = torch.cuda.is_available() + pt_xpu_available = is_xpu_available() + pt_mlu_available = is_mlu_available() + pt_musa_available = is_musa_available() + pt_npu_available = is_npu_available() + accelerate_config = 'Not found' + if args.config_file is not None or os.path.isfile(default_config_file): + accelerate_config = load_config_from_file(args.config_file).to_dict() + command = None + bash_location = 'Not found' + if os.name == 'nt': + command = ['where', 'accelerate'] + elif os.name == 'posix': + command = ['which', 'accelerate'] + if command is not None: + bash_location = subprocess.check_output(command, text=True, stderr=subprocess.STDOUT).strip() + info = {'`Accelerate` version': version, 'Platform': platform.platform(), '`accelerate` bash location': bash_location, 'Python version': platform.python_version(), 'Numpy version': np.__version__, 'PyTorch version (GPU?)': f'{pt_version} ({pt_cuda_available})', 'PyTorch XPU available': str(pt_xpu_available), 'PyTorch NPU available': str(pt_npu_available), 'PyTorch MLU available': str(pt_mlu_available), 'PyTorch MUSA available': str(pt_musa_available), 'System RAM': f'{psutil.virtual_memory().total / 1024 ** 3:.2f} GB'} + if pt_cuda_available: + info['GPU type'] = torch.cuda.get_device_name() + if pt_mlu_available: + info['MLU type'] = torch.mlu.get_device_name() + if pt_npu_available: + info['CANN version'] = torch.version.cann + print('\nCopy-and-paste the text below in your GitHub issue\n') + print('\n'.join([f'- {prop}: {val}' for (prop, val) in info.items()])) + print('- `Accelerate` default config:' if args.config_file is None else '- `Accelerate` config passed:') + accelerate_config_str = '\n'.join([f'\t- {prop}: {val}' for (prop, val) in accelerate_config.items()]) if isinstance(accelerate_config, dict) else f'\t{accelerate_config}' + print(accelerate_config_str) + info['`Accelerate` configs'] = accelerate_config + return info + +def main() -> int: + parser = env_command_parser() + args = parser.parse_args() + env_command(args) + return 0 +if __name__ == '__main__': + raise SystemExit(main()) + +# File: accelerate-main/src/accelerate/commands/estimate.py +from huggingface_hub import model_info +from huggingface_hub.utils import GatedRepoError, RepositoryNotFoundError +from accelerate import init_empty_weights +from accelerate.commands.utils import CustomArgumentParser +from accelerate.utils import calculate_maximum_sizes, convert_bytes, is_timm_available, is_transformers_available +if is_transformers_available(): + import transformers + from transformers import AutoConfig, AutoModel +if is_timm_available(): + import timm + +def verify_on_hub(repo: str, token: str=None): + try: + return model_info(repo, token=token) + except (OSError, GatedRepoError): + return 'gated' + except RepositoryNotFoundError: + return 'repo' + +def check_has_model(error): + if is_timm_available() and isinstance(error, RuntimeError) and ('Unknown model' in error.args[0]): + return 'timm' + elif is_transformers_available() and isinstance(error, OSError) and ('does not appear to have a file named' in error.args[0]): + return 'transformers' + else: + return 'unknown' + +def create_empty_model(model_name: str, library_name: str, trust_remote_code: bool=False, access_token: str=None): + model_info = verify_on_hub(model_name, access_token) + if model_info == 'gated': + raise GatedRepoError(f'Repo for model `{model_name}` is gated. You must be authenticated to access it. Please run `huggingface-cli login`.') + elif model_info == 'repo': + raise RepositoryNotFoundError(f'Repo for model `{model_name}` does not exist on the Hub. If you are trying to access a private repo, make sure you are authenticated via `huggingface-cli login` and have access.') + if library_name is None: + library_name = getattr(model_info, 'library_name', False) + if not library_name: + raise ValueError(f'Model `{model_name}` does not have any library metadata on the Hub, please manually pass in a `--library_name` to use (such as `transformers`)') + if library_name == 'transformers': + if not is_transformers_available(): + raise ImportError(f'To check `{model_name}`, `transformers` must be installed. Please install it via `pip install transformers`') + print(f'Loading pretrained config for `{model_name}` from `transformers`...') + if model_info.config is None: + raise RuntimeError(f'Tried to load `{model_name}` with `transformers` but it does not have any metadata.') + auto_map = model_info.config.get('auto_map', False) + config = AutoConfig.from_pretrained(model_name, trust_remote_code=trust_remote_code, token=access_token) + with init_empty_weights(): + constructor = AutoModel + if isinstance(auto_map, dict): + value = None + for key in auto_map.keys(): + if key.startswith('AutoModelFor'): + value = key + break + if value is not None: + constructor = getattr(transformers, value) + model = constructor.from_config(config, trust_remote_code=trust_remote_code) + elif library_name == 'timm': + if not is_timm_available(): + raise ImportError(f'To check `{model_name}`, `timm` must be installed. Please install it via `pip install timm`') + print(f'Loading pretrained config for `{model_name}` from `timm`...') + with init_empty_weights(): + model = timm.create_model(model_name, pretrained=False) + else: + raise ValueError(f'Library `{library_name}` is not supported yet, please open an issue on GitHub for us to add support.') + return model + +def create_ascii_table(headers: list, rows: list, title: str): + (sep_char, in_between) = ('│', '─') + column_widths = [] + for i in range(len(headers)): + column_values = [row[i] for row in rows] + [headers[i]] + max_column_width = max((len(value) for value in column_values)) + column_widths.append(max_column_width) + formats = [f'%{column_widths[i]}s' for i in range(len(rows[0]))] + pattern = f'{sep_char}{sep_char.join(formats)}{sep_char}' + diff = 0 + + def make_row(left_char, middle_char, right_char): + return f'{left_char}{middle_char.join([in_between * n for n in column_widths])}{in_between * diff}{right_char}' + separator = make_row('├', '┼', '┤') + if len(title) > sum(column_widths): + diff = abs(len(title) - len(separator)) + column_widths[-1] += diff + separator = make_row('├', '┼', '┤') + initial_rows = [make_row('┌', in_between, '┐'), f'{sep_char}{title.center(len(separator) - 2)}{sep_char}', make_row('├', '┬', '┤')] + table = '\n'.join(initial_rows) + '\n' + column_widths[-1] += diff + centered_line = [text.center(column_widths[i]) for (i, text) in enumerate(headers)] + table += f'{pattern % tuple(centered_line)}\n{separator}\n' + for (i, line) in enumerate(rows): + centered_line = [t.center(column_widths[i]) for (i, t) in enumerate(line)] + table += f'{pattern % tuple(centered_line)}\n' + table += f"└{'┴'.join([in_between * n for n in column_widths])}┘" + return table + +def estimate_command_parser(subparsers=None): + if subparsers is not None: + parser = subparsers.add_parser('estimate-memory') + else: + parser = CustomArgumentParser(description='Model size estimator for fitting a model onto CUDA memory.') + parser.add_argument('model_name', type=str, help='The model name on the Hugging Face Hub.') + parser.add_argument('--library_name', type=str, help='The library the model has an integration with, such as `transformers`, needed only if this information is not stored on the Hub.', choices=['timm', 'transformers']) + parser.add_argument('--dtypes', type=str, nargs='+', default=['float32', 'float16', 'int8', 'int4'], help='The dtypes to use for the model, must be one (or many) of `float32`, `float16`, `int8`, and `int4`', choices=['float32', 'float16', 'int8', 'int4']) + parser.add_argument('--trust_remote_code', action='store_true', help='Whether or not to allow for custom models defined on the Hub in their own modeling files. This flag\n should only be used for repositories you trust and in which you have read the code, as it will execute\n code present on the Hub on your local machine.', default=False) + if subparsers is not None: + parser.set_defaults(func=estimate_command) + return parser + +def estimate_training_usage(bytes: int, mixed_precision: str, msamp_config: str=None) -> dict: + memory_sizes = {'model': -1, 'optimizer': -1, 'gradients': -1, 'step': -1} + fp32_size = bytes + fp16_size = bytes // 2 + if mixed_precision == 'float32': + memory_sizes['model'] = fp32_size + memory_sizes['gradients'] = fp32_size + memory_sizes['optimizer'] = fp32_size * 2 + memory_sizes['step'] = fp32_size * 4 + elif mixed_precision in ('float16', 'bfloat16') or (mixed_precision == 'fp8' and msamp_config is None): + memory_sizes['model'] = fp32_size + memory_sizes['gradients'] = fp32_size + fp16_size + memory_sizes['optimizer'] = fp32_size * 2 + memory_sizes['step'] = memory_sizes['optimizer'] + return memory_sizes + +def gather_data(args): + try: + model = create_empty_model(args.model_name, library_name=args.library_name, trust_remote_code=args.trust_remote_code) + except (RuntimeError, OSError) as e: + library = check_has_model(e) + if library != 'unknown': + raise RuntimeError(f'Tried to load `{args.model_name}` with `{library}` but a possible model to load was not found inside the repo.') + raise e + (total_size, largest_layer) = calculate_maximum_sizes(model) + data = [] + for dtype in args.dtypes: + dtype_total_size = total_size + dtype_largest_layer = largest_layer[0] + dtype_training_size = estimate_training_usage(dtype_total_size, dtype) + if dtype == 'float16': + dtype_total_size /= 2 + dtype_largest_layer /= 2 + elif dtype == 'int8': + dtype_total_size /= 4 + dtype_largest_layer /= 4 + elif dtype == 'int4': + dtype_total_size /= 8 + dtype_largest_layer /= 8 + data.append([dtype, dtype_largest_layer, dtype_total_size, dtype_training_size]) + return data + +def estimate_command(args): + data = gather_data(args) + for row in data: + for (i, item) in enumerate(row): + if isinstance(item, (int, float)): + row[i] = convert_bytes(item) + elif isinstance(item, dict): + training_usage = max(item.values()) + row[i] = convert_bytes(training_usage) if training_usage != -1 else 'N/A' + headers = ['dtype', 'Largest Layer', 'Total Size', 'Training using Adam'] + title = f'Memory Usage for loading `{args.model_name}`' + table = create_ascii_table(headers, data, title) + print(table) + +def main(): + parser = estimate_command_parser() + args = parser.parse_args() + estimate_command(args) +if __name__ == '__main__': + main() + +# File: accelerate-main/src/accelerate/commands/launch.py +import argparse +import importlib +import logging +import os +import subprocess +import sys +from pathlib import Path +import psutil +import torch +from accelerate.commands.config import default_config_file, load_config_from_file +from accelerate.commands.config.config_args import SageMakerConfig +from accelerate.commands.config.config_utils import DYNAMO_BACKENDS +from accelerate.commands.utils import CustomArgumentParser +from accelerate.state import get_int_from_env +from accelerate.utils import ComputeEnvironment, DistributedType, PrepareForLaunch, _filter_args, check_cuda_p2p_ib_support, convert_dict_to_env_variables, is_bf16_available, is_deepspeed_available, is_mlu_available, is_musa_available, is_npu_available, is_rich_available, is_sagemaker_available, is_torch_version, is_torch_xla_available, is_xpu_available, patch_environment, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, str_to_bool +from accelerate.utils.constants import DEEPSPEED_MULTINODE_LAUNCHERS, TORCH_DYNAMO_MODES +if is_rich_available(): + from rich import get_console + from rich.logging import RichHandler + FORMAT = '%(message)s' + logging.basicConfig(format=FORMAT, datefmt='[%X]', handlers=[RichHandler()]) +logger = logging.getLogger(__name__) +options_to_group = {'multi_gpu': 'Distributed GPUs', 'tpu': 'TPU', 'use_deepspeed': 'DeepSpeed Arguments', 'use_fsdp': 'FSDP Arguments', 'use_megatron_lm': 'Megatron-LM Arguments', 'fp8_backend': 'FP8 Arguments'} + +def clean_option(option): + if 'fp8_backend' in option: + option = '--fp8_backend' + if option.startswith('--'): + return option[2:].replace('-', '_') + +class CustomHelpFormatter(argparse.HelpFormatter): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.titles = ['Hardware Selection Arguments', 'Resource Selection Arguments', 'Training Paradigm Arguments', 'positional arguments', 'optional arguments'] + + def add_argument(self, action: argparse.Action): + if 'accelerate' in sys.argv[0] and 'launch' in sys.argv[1:]: + args = sys.argv[2:] + else: + args = sys.argv[1:] + if len(args) > 1: + args = list(map(clean_option, args)) + used_platforms = [arg for arg in args if arg in options_to_group.keys()] + used_titles = [options_to_group[o] for o in used_platforms] + if action.container.title not in self.titles + used_titles: + action.help = argparse.SUPPRESS + elif action.container.title == 'Hardware Selection Arguments': + if set(action.option_strings).isdisjoint(set(args)): + action.help = argparse.SUPPRESS + else: + action.help = action.help + ' (currently selected)' + elif action.container.title == 'Training Paradigm Arguments': + if set(action.option_strings).isdisjoint(set(args)): + action.help = argparse.SUPPRESS + else: + action.help = action.help + ' (currently selected)' + action.option_strings = [s for s in action.option_strings if '-' not in s[2:]] + super().add_argument(action) + + def end_section(self): + if len(self._current_section.items) < 2: + self._current_section.items = [] + self._current_section.heading = '' + super().end_section() + +def launch_command_parser(subparsers=None): + description = 'Launch a python script in a distributed scenario. Arguments can be passed in with either hyphens (`--num-processes=2`) or underscores (`--num_processes=2`)' + if subparsers is not None: + parser = subparsers.add_parser('launch', description=description, add_help=False, allow_abbrev=False, formatter_class=CustomHelpFormatter) + else: + parser = CustomArgumentParser('Accelerate launch command', description=description, add_help=False, allow_abbrev=False, formatter_class=CustomHelpFormatter) + parser.add_argument('-h', '--help', action='help', help='Show this help message and exit.') + parser.add_argument('--config_file', default=None, help='The config file to use for the default values in the launching script.') + parser.add_argument('--quiet', '-q', action='store_true', help='Silence subprocess errors from the launch stack trace and only show the relevant tracebacks. (Only applicable to DeepSpeed and single-process configurations)') + hardware_args = parser.add_argument_group('Hardware Selection Arguments', 'Arguments for selecting the hardware to be used.') + hardware_args.add_argument('--cpu', default=False, action='store_true', help='Whether or not to force the training on the CPU.') + hardware_args.add_argument('--multi_gpu', default=False, action='store_true', help='Whether or not this should launch a distributed GPU training.') + hardware_args.add_argument('--tpu', default=False, action='store_true', help='Whether or not this should launch a TPU training.') + hardware_args.add_argument('--ipex', default=False, action='store_true', help='Whether or not this should launch a Intel PyTorch Extension (IPEX) training.') + resource_args = parser.add_argument_group('Resource Selection Arguments', 'Arguments for fine-tuning how available hardware should be used.') + resource_args.add_argument('--mixed_precision', type=str, choices=['no', 'fp16', 'bf16', 'fp8'], help='Whether or not to use mixed precision training. Choose between FP16 and BF16 (bfloat16) training. BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.') + resource_args.add_argument('--num_processes', type=int, default=None, help='The total number of processes to be launched in parallel.') + resource_args.add_argument('--num_machines', type=int, default=None, help='The total number of machines used in this training.') + resource_args.add_argument('--num_cpu_threads_per_process', type=int, default=None, help='The number of CPU threads per process. Can be tuned for optimal performance.') + resource_args.add_argument('--enable_cpu_affinity', default=False, action='store_true', help='Whether or not CPU affinity and balancing should be enabled. Currently only supported on NVIDIA hardware.') + resource_args.add_argument('--dynamo_backend', type=str, choices=['no'] + [b.lower() for b in DYNAMO_BACKENDS], help='Choose a backend to optimize your training with dynamo, see more at https://github.com/pytorch/torchdynamo.') + resource_args.add_argument('--dynamo_mode', type=str, default='default', choices=TORCH_DYNAMO_MODES, help='Choose a mode to optimize your training with dynamo.') + resource_args.add_argument('--dynamo_use_fullgraph', default=False, action='store_true', help='Whether to use full graph mode for dynamo or it is ok to break model into several subgraphs') + resource_args.add_argument('--dynamo_use_dynamic', default=False, action='store_true', help='Whether to enable dynamic shape tracing.') + paradigm_args = parser.add_argument_group('Training Paradigm Arguments', 'Arguments for selecting which training paradigm to be used.') + paradigm_args.add_argument('--use_deepspeed', default=False, action='store_true', help='Whether to use deepspeed.') + paradigm_args.add_argument('--use_fsdp', default=False, action='store_true', help='Whether to use fsdp.') + paradigm_args.add_argument('--use_megatron_lm', default=False, action='store_true', help='Whether to use Megatron-LM.') + paradigm_args.add_argument('--use_xpu', default=False, action='store_true', help='Whether to use IPEX plugin to speed up training on XPU specifically.') + distributed_args = parser.add_argument_group('Distributed GPUs', 'Arguments related to distributed GPU training.') + distributed_args.add_argument('--gpu_ids', default=None, help='What GPUs (by id) should be used for training on this machine as a comma-seperated list') + distributed_args.add_argument('--same_network', default=False, action='store_true', help='Whether all machines used for multinode training exist on the same local network.') + distributed_args.add_argument('--machine_rank', type=int, default=None, help='The rank of the machine on which this script is launched.') + distributed_args.add_argument('--main_process_ip', type=str, default=None, help='The IP address of the machine of rank 0.') + distributed_args.add_argument('--main_process_port', type=int, default=None, help='The port to use to communicate with the machine of rank 0.') + distributed_args.add_argument('-t', '--tee', default='0', type=str, help='Tee std streams into a log file and also to console.') + distributed_args.add_argument('--log_dir', type=str, default=None, help='Base directory to use for log files when using torchrun/torch.distributed.run as launcher. Use with --tee to redirect std streams info log files.') + distributed_args.add_argument('--role', type=str, default='default', help='User-defined role for the workers.') + distributed_args.add_argument('--rdzv_backend', type=str, default='static', help="The rendezvous method to use, such as 'static' (the default) or 'c10d'") + distributed_args.add_argument('--rdzv_conf', type=str, default='', help='Additional rendezvous configuration (=,=,...).') + distributed_args.add_argument('--max_restarts', type=int, default=0, help='Maximum number of worker group restarts before failing.') + distributed_args.add_argument('--monitor_interval', type=float, default=0.1, help='Interval, in seconds, to monitor the state of workers.') + parser.add_argument('-m', '--module', action='store_true', help="Change each process to interpret the launch script as a Python module, executing with the same behavior as 'python -m'.") + parser.add_argument('--no_python', action='store_true', help="Skip prepending the training script with 'python' - just execute it directly. Useful when the script is not a Python script.") + tpu_args = parser.add_argument_group('TPU', 'Arguments related to TPU.') + tpu_args.add_argument('--tpu_cluster', action='store_true', dest='tpu_use_cluster', help='Whether to use a GCP TPU pod for training.') + tpu_args.add_argument('--no_tpu_cluster', action='store_false', dest='tpu_use_cluster', help='Should not be passed explicitly, this is for internal use only.') + tpu_args.add_argument('--tpu_use_sudo', action='store_true', help='Whether to use `sudo` when running the TPU training script in each pod.') + tpu_args.add_argument('--vm', type=str, action='append', help='List of single Compute VM instance names. If not provided we assume usage of instance groups. For TPU pods.') + tpu_args.add_argument('--env', type=str, action='append', help='List of environment variables to set on the Compute VM instances. For TPU pods.') + tpu_args.add_argument('--main_training_function', type=str, default=None, help='The name of the main function to be executed in your script (only for TPU training).') + tpu_args.add_argument('--downcast_bf16', action='store_true', help='Whether when using bf16 precision on TPUs if both float and double tensors are cast to bfloat16 or if double tensors remain as float32.') + deepspeed_args = parser.add_argument_group('DeepSpeed Arguments', 'Arguments related to DeepSpeed.') + deepspeed_args.add_argument('--deepspeed_config_file', default=None, type=str, help='DeepSpeed config file.') + deepspeed_args.add_argument('--zero_stage', default=None, type=int, help="DeepSpeed's ZeRO optimization stage (useful only when `use_deepspeed` flag is passed). If unspecified, will default to `2`.") + deepspeed_args.add_argument('--offload_optimizer_device', default=None, type=str, help="Decides where (none|cpu|nvme) to offload optimizer states (useful only when `use_deepspeed` flag is passed). If unspecified, will default to 'none'.") + deepspeed_args.add_argument('--offload_param_device', default=None, type=str, help="Decides where (none|cpu|nvme) to offload parameters (useful only when `use_deepspeed` flag is passed). If unspecified, will default to 'none'.") + deepspeed_args.add_argument('--offload_optimizer_nvme_path', default=None, type=str, help="Decides Nvme Path to offload optimizer states (useful only when `use_deepspeed` flag is passed). If unspecified, will default to 'none'.") + deepspeed_args.add_argument('--offload_param_nvme_path', default=None, type=str, help="Decides Nvme Path to offload parameters (useful only when `use_deepspeed` flag is passed). If unspecified, will default to 'none'.") + deepspeed_args.add_argument('--gradient_accumulation_steps', default=None, type=int, help='No of gradient_accumulation_steps used in your training script (useful only when `use_deepspeed` flag is passed). If unspecified, will default to `1`.') + deepspeed_args.add_argument('--gradient_clipping', default=None, type=float, help='gradient clipping value used in your training script (useful only when `use_deepspeed` flag is passed). If unspecified, will default to `1.0`.') + deepspeed_args.add_argument('--zero3_init_flag', default=None, type=str, help='Decides Whether (true|false) to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with DeepSpeed ZeRO Stage-3. If unspecified, will default to `true`.') + deepspeed_args.add_argument('--zero3_save_16bit_model', default=None, type=str, help='Decides Whether (true|false) to save 16-bit model weights when using ZeRO Stage-3. Only applicable with DeepSpeed ZeRO Stage-3. If unspecified, will default to `false`.') + deepspeed_args.add_argument('--deepspeed_hostfile', default=None, type=str, help='DeepSpeed hostfile for configuring multi-node compute resources.') + deepspeed_args.add_argument('--deepspeed_exclusion_filter', default=None, type=str, help='DeepSpeed exclusion filter string when using mutli-node setup.') + deepspeed_args.add_argument('--deepspeed_inclusion_filter', default=None, type=str, help='DeepSpeed inclusion filter string when using mutli-node setup.') + deepspeed_args.add_argument('--deepspeed_multinode_launcher', default=None, type=str, help='DeepSpeed multi-node launcher to use. If unspecified, will default to `pdsh`.') + deepspeed_args.add_argument('--deepspeed_moe_layer_cls_names', default=None, type=str, help='comma-separated list of transformer MoE layer class names (case-sensitive) to wrap ,e.g, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention,JetMoEBlock` ... (useful only when `use_deepspeed` flag is passed).') + fsdp_args = parser.add_argument_group('FSDP Arguments', 'Arguments related to Fully Shared Data Parallelism.') + fsdp_args.add_argument('--fsdp_offload_params', default='false', type=str, help='Decides Whether (true|false) to offload parameters and gradients to CPU. (useful only when `use_fsdp` flag is passed).') + fsdp_args.add_argument('--fsdp_min_num_params', type=int, default=100000000.0, help="FSDP's minimum number of parameters for Default Auto Wrapping. (useful only when `use_fsdp` flag is passed).") + fsdp_args.add_argument('--fsdp_sharding_strategy', type=str, default='FULL_SHARD', help="FSDP's Sharding Strategy. (useful only when `use_fsdp` flag is passed).") + fsdp_args.add_argument('--fsdp_auto_wrap_policy', type=str, default=None, help="FSDP's auto wrap policy. (useful only when `use_fsdp` flag is passed).") + fsdp_args.add_argument('--fsdp_transformer_layer_cls_to_wrap', default=None, type=str, help='Transformer layer class name (case-sensitive) to wrap ,e.g, `BertLayer`, `GPTJBlock`, `T5Block` .... (useful only when `use_fsdp` flag is passed).') + fsdp_args.add_argument('--fsdp_backward_prefetch', default=None, type=str, help="FSDP's backward prefetch policy. (useful only when `use_fsdp` flag is passed).") + fsdp_args.add_argument('--fsdp_state_dict_type', default=None, type=str, help="FSDP's state dict type. (useful only when `use_fsdp` flag is passed).") + fsdp_args.add_argument('--fsdp_forward_prefetch', default='false', type=str, help='If True, then FSDP explicitly prefetches the next upcoming all-gather while executing in the forward pass (useful only when `use_fsdp` flag is passed).') + fsdp_args.add_argument('--fsdp_use_orig_params', default='true', type=str, help='If True, allows non-uniform `requires_grad` during init, which means support for interspersed frozen and trainable paramteres. (useful only when `use_fsdp` flag is passed).') + fsdp_args.add_argument('--fsdp_cpu_ram_efficient_loading', default='true', type=str, help='If True, only the first process loads the pretrained model checkoint while all other processes have empty weights. Only applicable for 🤗 Transformers. When using this, `--fsdp_sync_module_states` needs to True. (useful only when `use_fsdp` flag is passed).') + fsdp_args.add_argument('--fsdp_sync_module_states', default='true', type=str, help='If True, each individually wrapped FSDP unit will broadcast module parameters from rank 0. (useful only when `use_fsdp` flag is passed).') + fsdp_args.add_argument('--fsdp_activation_checkpointing', default='false', type=str, help='Decides Whether (true|false) intermediate activations are freed during the forward pass, and a checkpoint is left as a placeholder. (useful only when `use_fsdp` flag is passed).') + megatron_lm_args = parser.add_argument_group('Megatron-LM Arguments', 'Arguments related to Megatron-LM.') + megatron_lm_args.add_argument('--megatron_lm_tp_degree', type=int, default=1, help="Megatron-LM's Tensor Parallelism (TP) degree. (useful only when `use_megatron_lm` flag is passed).") + megatron_lm_args.add_argument('--megatron_lm_pp_degree', type=int, default=1, help="Megatron-LM's Pipeline Parallelism (PP) degree. (useful only when `use_megatron_lm` flag is passed).") + megatron_lm_args.add_argument('--megatron_lm_num_micro_batches', type=int, default=None, help="Megatron-LM's number of micro batches when PP degree > 1. (useful only when `use_megatron_lm` flag is passed).") + megatron_lm_args.add_argument('--megatron_lm_sequence_parallelism', default=None, type=str, help='Decides Whether (true|false) to enable Sequence Parallelism when TP degree > 1. (useful only when `use_megatron_lm` flag is passed).') + megatron_lm_args.add_argument('--megatron_lm_recompute_activations', default=None, type=str, help='Decides Whether (true|false) to enable Selective Activation Recomputation. (useful only when `use_megatron_lm` flag is passed).') + megatron_lm_args.add_argument('--megatron_lm_use_distributed_optimizer', default=None, type=str, help='Decides Whether (true|false) to use distributed optimizer which shards optimizer state and gradients across Data Pralellel (DP) ranks. (useful only when `use_megatron_lm` flag is passed).') + megatron_lm_args.add_argument('--megatron_lm_gradient_clipping', default=1.0, type=float, help="Megatron-LM's gradient clipping value based on global L2 Norm (0 to disable). (useful only when `use_megatron_lm` flag is passed).") + fp8_args = parser.add_argument_group('FP8 Arguments', 'Arguments related to FP8 training (requires `--mixed_precision=fp8`)') + fp8_args.add_argument('--fp8_backend', type=str, choices=['te', 'msamp'], help='Choose a backend to train with FP8 (te: TransformerEngine, msamp: MS-AMP)') + fp8_args.add_argument('--fp8_use_autocast_during_eval', default=False, action='store_true', help='Whether to use FP8 autocast during eval mode (useful only when `--fp8_backend=te` is passed). Generally better metrics are found when this is not passed.') + fp8_args.add_argument('--fp8_margin', type=int, default=0, help='The margin to use for the gradient scaling (useful only when `--fp8_backend=te` is passed).') + fp8_args.add_argument('--fp8_interval', type=int, default=1, help='The interval to use for how often the scaling factor is recomputed (useful only when `--fp8_backend=te` is passed).') + fp8_args.add_argument('--fp8_format', type=str, default='E4M3', choices=['E4M3', 'HYBRID'], help='The format to use for the FP8 recipe (useful only when `--fp8_backend=te` is passed).') + fp8_args.add_argument('--fp8_amax_history_len', type=int, default=1024, help='The length of the history to use for the scaling factor computation (useful only when `--fp8_backend=te` is passed).') + fp8_args.add_argument('--fp8_amax_compute_algo', type=str, default='most_recent', choices=['max', 'most_recent'], help='The algorithm to use for the scaling factor computation. (useful only when `--fp8_backend=te` is passed).') + fp8_args.add_argument('--fp8_override_linear_precision', type=lambda x: tuple(map(str_to_bool, x.split(','))), default=(False, False, False), help='Whether or not to execute `fprop`, `dgrad`, and `wgrad` GEMMS in higher precision. Should be passed in a comma-seperated string of booleans (useful only when `--fp8_backend=te` is passed).') + fp8_args.add_argument('--fp8_opt_level', type=str, default='O2', choices=['O1', 'O2'], help='What level of 8-bit collective communication should be used with MS-AMP (useful only when `--fp8_backend=msamp` is passed).') + aws_args = parser.add_argument_group('AWS Arguments', 'Arguments related to AWS.') + aws_args.add_argument('--aws_access_key_id', type=str, default=None, help='The AWS_ACCESS_KEY_ID used to launch the Amazon SageMaker training job') + aws_args.add_argument('--aws_secret_access_key', type=str, default=None, help='The AWS_SECRET_ACCESS_KEY used to launch the Amazon SageMaker training job.') + parser.add_argument('--debug', action='store_true', help='Whether to print out the torch.distributed stack trace when something fails.') + parser.add_argument('training_script', type=str, help='The full path to the script to be launched in parallel, followed by all the arguments for the training script.') + mpirun_args = parser.add_argument_group('MPI Arguments', 'Arguments related to mpirun for Multi-CPU') + mpirun_args.add_argument('--mpirun_hostfile', type=str, default=None, help='Location for a hostfile for using Accelerate to launch a multi-CPU training job with mpirun. This will get passed to the MPI --hostfile or -f parameter, depending on which MPI program is installed.') + mpirun_args.add_argument('--mpirun_ccl', type=int, default=1, help='The number of oneCCL worker threads when using Accelerate to launch multi-CPU training with mpirun.') + parser.add_argument('training_script_args', nargs=argparse.REMAINDER, help='Arguments of the training script.') + if subparsers is not None: + parser.set_defaults(func=launch_command) + return parser + +def simple_launcher(args): + (cmd, current_env) = prepare_simple_launcher_cmd_env(args) + process = subprocess.Popen(cmd, env=current_env) + process.wait() + if process.returncode != 0: + if not args.quiet: + raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd) + else: + sys.exit(1) + +def multi_gpu_launcher(args): + import torch.distributed.run as distrib_run + current_env = prepare_multi_gpu_env(args) + if not check_cuda_p2p_ib_support(): + message = "Using RTX 4000 series which doesn't support faster communication speedups. Ensuring P2P and IB communications are disabled." + warn = False + if 'NCCL_P2P_DISABLE' not in current_env: + current_env['NCCL_P2P_DISABLE'] = '1' + warn = True + if 'NCCL_IB_DISABLE' not in current_env: + current_env['NCCL_IB_DISABLE'] = '1' + warn = True + if warn: + logger.warning(message) + debug = getattr(args, 'debug', False) + args = _filter_args(args, distrib_run.get_args_parser(), ['--training_script', args.training_script, '--training_script_args', args.training_script_args]) + with patch_environment(**current_env): + try: + distrib_run.run(args) + except Exception: + if is_rich_available() and debug: + console = get_console() + console.print('\n[bold red]Using --debug, `torch.distributed` Stack Trace:[/bold red]') + console.print_exception(suppress=[__file__], show_locals=False) + else: + raise + +def deepspeed_launcher(args): + import torch.distributed.run as distrib_run + if not is_deepspeed_available(): + raise ImportError('DeepSpeed is not installed => run `pip3 install deepspeed` or build it from source.') + else: + from deepspeed.launcher.runner import DEEPSPEED_ENVIRONMENT_NAME + (cmd, current_env) = prepare_deepspeed_cmd_env(args) + if not check_cuda_p2p_ib_support(): + message = "Using RTX 4000 series which doesn't support faster communication speedups. Ensuring P2P and IB communications are disabled." + warn = False + if 'NCCL_P2P_DISABLE' not in current_env: + current_env['NCCL_P2P_DISABLE'] = '1' + warn = True + if 'NCCL_IB_DISABLE' not in current_env: + current_env['NCCL_IB_DISABLE'] = '1' + warn = True + if warn: + logger.warning(message) + if args.num_machines > 1 and args.deepspeed_multinode_launcher != DEEPSPEED_MULTINODE_LAUNCHERS[1]: + with open(DEEPSPEED_ENVIRONMENT_NAME, 'a') as f: + valid_env_items = convert_dict_to_env_variables(current_env) + if len(valid_env_items) > 1: + f.writelines(valid_env_items) + process = subprocess.Popen(cmd, env=current_env) + process.wait() + if process.returncode != 0: + if not args.quiet: + raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd) + else: + sys.exit(1) + else: + debug = getattr(args, 'debug', False) + args = _filter_args(args, distrib_run.get_args_parser(), ['--training_script', args.training_script, '--training_script_args', args.training_script_args]) + with patch_environment(**current_env): + try: + distrib_run.run(args) + except Exception: + if is_rich_available() and debug: + console = get_console() + console.print('\n[bold red]Using --debug, `torch.distributed` Stack Trace:[/bold red]') + console.print_exception(suppress=[__file__], show_locals=False) + else: + raise + +def tpu_launcher(args): + import torch_xla.distributed.xla_multiprocessing as xmp + if args.no_python: + raise ValueError('--no_python cannot be used with TPU launcher') + (args, current_env) = prepare_tpu(args, {}) + if args.module: + mod_name = args.training_script + else: + script_path = Path(args.training_script) + sys.path.append(str(script_path.parent.resolve())) + mod_name = script_path.stem + mod = importlib.import_module(mod_name) + if not hasattr(mod, args.main_training_function): + raise ValueError(f'Your training script should have a function named {args.main_training_function}, or you should pass a different value to `--main_training_function`.') + sys.argv = [mod.__file__] + args.training_script_args + main_function = getattr(mod, args.main_training_function) + with patch_environment(**current_env): + xmp.spawn(PrepareForLaunch(main_function), args=(), nprocs=args.num_processes) + +def tpu_pod_launcher(args): + from torch_xla.distributed import xla_dist + current_env = {} + (args, current_env) = prepare_tpu(args, current_env, True) + debug = getattr(args, 'debug', False) + training_script = args.training_script + training_script_args = args.training_script_args + new_args = _filter_args(args, xla_dist.get_args_parser(), ['--tpu', args.tpu_name, '--positional', '', '--restart-tpuvm-pod-server']) + if args.tpu_use_sudo: + new_cmd = ['sudo'] + else: + new_cmd = [] + new_cmd += ['accelerate-launch', '--tpu', '--no_tpu_cluster', '--num_machines', '1', '--mixed_precision', 'no', '--dynamo_backend', 'no', '--num_processes', str(args.num_processes), '--main_training_function', str(args.main_training_function), training_script] + training_script_args + new_args.positional = new_cmd + bad_flags = '' + for arg in vars(new_args): + if arg.startswith('docker_'): + value = getattr(new_args, arg) + if value != '' and value is not None: + bad_flags += f'{arg}="{value}"\n' + if bad_flags != '': + raise ValueError(f'Docker containers are not supported for TPU pod launcher currently, please remove the following flags:\n{bad_flags}') + new_args.env = [f'{k}={v}' for (k, v) in current_env.items()] + new_args.env.append('ACCELERATE_IN_TPU_POD=1') + try: + xla_dist.resolve_and_execute(new_args) + except Exception: + if is_rich_available() and debug: + console = get_console() + console.print('\n[bold red]Using --debug, `torch_xla.xla_dist` Stack Trace:[/bold red]') + console.print_exception(suppress=[__file__], show_locals=False) + else: + raise + +def sagemaker_launcher(sagemaker_config: SageMakerConfig, args): + if not is_sagemaker_available(): + raise ImportError('Please install sagemaker to be able to launch training on Amazon SageMaker with `pip install accelerate[sagemaker]`') + if args.module or args.no_python: + raise ValueError('SageMaker requires a python training script file and cannot be used with --module or --no_python') + from sagemaker.huggingface import HuggingFace + (args, sagemaker_inputs) = prepare_sagemager_args_inputs(sagemaker_config, args) + huggingface_estimator = HuggingFace(**args) + huggingface_estimator.fit(inputs=sagemaker_inputs) + print(f'You can find your model data at: {huggingface_estimator.model_data}') + +def _validate_launch_command(args): + if sum([args.multi_gpu, args.cpu, args.tpu, args.use_deepspeed, args.use_fsdp]) > 1: + raise ValueError('You can only use one of `--cpu`, `--multi_gpu`, `--tpu`, `--use_deepspeed`, `--use_fsdp` at a time.') + if args.multi_gpu and args.num_processes is not None and (args.num_processes < 2): + raise ValueError('You need to use at least 2 processes to use `--multi_gpu`.') + defaults = None + warned = [] + mp_from_config_flag = False + if args.config_file is not None or (os.path.isfile(default_config_file) and (not args.cpu)): + defaults = load_config_from_file(args.config_file) + if not args.multi_gpu and (not args.tpu) and (not args.tpu_use_cluster) and (not args.use_deepspeed) and (not args.use_fsdp) and (not args.use_megatron_lm): + args.use_deepspeed = defaults.distributed_type == DistributedType.DEEPSPEED + args.multi_gpu = True if defaults.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_XPU) else False + args.tpu = defaults.distributed_type == DistributedType.XLA + args.use_fsdp = defaults.distributed_type == DistributedType.FSDP + args.use_megatron_lm = defaults.distributed_type == DistributedType.MEGATRON_LM + args.tpu_use_cluster = defaults.tpu_use_cluster if args.tpu else False + if args.gpu_ids is None: + if defaults.gpu_ids is not None: + args.gpu_ids = defaults.gpu_ids + else: + args.gpu_ids = 'all' + if args.multi_gpu and args.num_machines is None: + args.num_machines = defaults.num_machines + if len(args.gpu_ids.split(',')) < 2 and args.gpu_ids != 'all' and args.multi_gpu and (args.num_machines <= 1): + raise ValueError("Less than two GPU ids were configured and tried to run on on multiple GPUs. Please ensure at least two are specified for `--gpu_ids`, or use `--gpu_ids='all'`.") + if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE: + for (name, attr) in defaults.__dict__.items(): + if isinstance(attr, dict): + for k in defaults.deepspeed_config: + setattr(args, k, defaults.deepspeed_config[k]) + for k in defaults.fsdp_config: + arg_to_set = k + if 'fsdp' not in arg_to_set: + arg_to_set = 'fsdp_' + arg_to_set + setattr(args, arg_to_set, defaults.fsdp_config[k]) + for k in defaults.megatron_lm_config: + setattr(args, k, defaults.megatron_lm_config[k]) + for k in defaults.dynamo_config: + setattr(args, k, defaults.dynamo_config[k]) + for k in defaults.ipex_config: + setattr(args, k, defaults.ipex_config[k]) + for k in defaults.mpirun_config: + setattr(args, k, defaults.mpirun_config[k]) + continue + if name not in ['compute_environment', 'mixed_precision', 'distributed_type'] and getattr(args, name, None) is None: + setattr(args, name, attr) + if not args.debug: + args.debug = defaults.debug + if not args.mixed_precision: + if defaults.mixed_precision is None: + args.mixed_precision = 'no' + else: + args.mixed_precision = defaults.mixed_precision + mp_from_config_flag = True + else: + if args.use_cpu or (args.use_xpu and torch.xpu.is_available()): + native_amp = is_torch_version('>=', '1.10') + else: + native_amp = is_bf16_available(True) + if args.mixed_precision == 'bf16' and (not native_amp) and (not (args.tpu and is_torch_xla_available(check_is_tpu=True))): + raise ValueError('bf16 mixed precision requires PyTorch >= 1.10 and a supported device.') + if args.dynamo_backend is None: + args.dynamo_backend = 'no' + if args.num_processes == -1: + raise ValueError('You need to manually pass in `--num_processes` using this config yaml.') + else: + if args.num_processes is None: + if args.use_xpu and is_xpu_available(): + args.num_processes = torch.xpu.device_count() + elif is_mlu_available(): + args.num_processes = torch.mlu.device_count() + elif is_musa_available(): + args.num_processes = torch.musa.device_count() + elif is_npu_available(): + args.num_processes = torch.npu.device_count() + else: + args.num_processes = torch.cuda.device_count() + warned.append(f'\t`--num_processes` was set to a value of `{args.num_processes}`') + if args.debug is None: + args.debug = False + if not args.multi_gpu and args.num_processes > 1 and (args.use_xpu and is_xpu_available() and (torch.xpu.device_count() > 1) or (is_mlu_available() and torch.mlu.device_count() > 1) or (is_musa_available() and torch.musa.device_count() > 1) or (is_npu_available() and torch.npu.device_count() > 1) or (torch.cuda.device_count() > 1)): + warned.append('\t\tMore than one GPU was found, enabling multi-GPU training.\n\t\tIf this was unintended please pass in `--num_processes=1`.') + args.multi_gpu = True + if args.num_machines is None: + warned.append('\t`--num_machines` was set to a value of `1`') + args.num_machines = 1 + if args.mixed_precision is None: + warned.append("\t`--mixed_precision` was set to a value of `'no'`") + args.mixed_precision = 'no' + if not hasattr(args, 'use_cpu'): + args.use_cpu = args.cpu + if args.dynamo_backend is None: + warned.append("\t`--dynamo_backend` was set to a value of `'no'`") + args.dynamo_backend = 'no' + if args.debug: + logger.debug('Running script in debug mode, expect distributed operations to be slightly slower.') + is_aws_env_disabled = defaults is None or (defaults is not None and defaults.compute_environment != ComputeEnvironment.AMAZON_SAGEMAKER) + if is_aws_env_disabled and args.num_cpu_threads_per_process is None: + args.num_cpu_threads_per_process = get_int_from_env(['OMP_NUM_THREADS'], 1) + if args.use_cpu and args.num_processes >= 1 and (get_int_from_env(['OMP_NUM_THREADS'], 0) == 0): + local_size = get_int_from_env(['MPI_LOCALNRANKS', 'OMPI_COMM_WORLD_LOCAL_SIZE', 'MV2_COMM_WORLD_LOCAL_SIZE'], max(int(args.num_processes / args.num_machines), 1)) + threads_per_process = int(psutil.cpu_count(logical=False) / local_size) + if threads_per_process > 1: + args.num_cpu_threads_per_process = threads_per_process + warned.append(f'\t`--num_cpu_threads_per_process` was set to `{args.num_cpu_threads_per_process}` to improve out-of-box performance when training on CPUs') + if any(warned): + message = 'The following values were not passed to `accelerate launch` and had defaults used instead:\n' + message += '\n'.join(warned) + message += '\nTo avoid this warning pass in values for each of the problematic parameters or run `accelerate config`.' + logger.warning(message) + return (args, defaults, mp_from_config_flag) + +def launch_command(args): + (args, defaults, mp_from_config_flag) = _validate_launch_command(args) + if args.use_deepspeed and (not args.cpu): + args.deepspeed_fields_from_accelerate_config = list(defaults.deepspeed_config.keys()) if defaults else [] + if mp_from_config_flag: + args.deepspeed_fields_from_accelerate_config.append('mixed_precision') + args.deepspeed_fields_from_accelerate_config = ','.join(args.deepspeed_fields_from_accelerate_config) + deepspeed_launcher(args) + elif args.use_fsdp and (not args.cpu): + multi_gpu_launcher(args) + elif args.use_megatron_lm and (not args.cpu): + multi_gpu_launcher(args) + elif args.multi_gpu and (not args.cpu): + multi_gpu_launcher(args) + elif args.tpu and (not args.cpu): + if args.tpu_use_cluster: + tpu_pod_launcher(args) + else: + tpu_launcher(args) + elif defaults is not None and defaults.compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER: + sagemaker_launcher(defaults, args) + else: + simple_launcher(args) + +def main(): + parser = launch_command_parser() + args = parser.parse_args() + launch_command(args) +if __name__ == '__main__': + main() + +# File: accelerate-main/src/accelerate/commands/menu/cursor.py +"""""" +import os +import sys +from contextlib import contextmanager +if os.name == 'nt': + import ctypes + import msvcrt + + class CursorInfo(ctypes.Structure): + _fields_ = [('size', ctypes.c_int), ('visible', ctypes.c_byte)] + +def hide_cursor(): + if os.name == 'nt': + ci = CursorInfo() + handle = ctypes.windll.kernel32.GetStdHandle(-11) + ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci)) + ci.visible = False + ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci)) + elif os.name == 'posix': + sys.stdout.write('\x1b[?25l') + sys.stdout.flush() + +def show_cursor(): + if os.name == 'nt': + ci = CursorInfo() + handle = ctypes.windll.kernel32.GetStdHandle(-11) + ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci)) + ci.visible = True + ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci)) + elif os.name == 'posix': + sys.stdout.write('\x1b[?25h') + sys.stdout.flush() + +@contextmanager +def hide(): + try: + hide_cursor() + yield + finally: + show_cursor() + +# File: accelerate-main/src/accelerate/commands/menu/helpers.py +"""""" +import enum +import shutil +import sys +(TERMINAL_WIDTH, _) = shutil.get_terminal_size() +CURSOR_TO_CHAR = {'UP': 'A', 'DOWN': 'B', 'RIGHT': 'C', 'LEFT': 'D'} + +class Direction(enum.Enum): + UP = 0 + DOWN = 1 + +def forceWrite(content, end=''): + sys.stdout.write(str(content) + end) + sys.stdout.flush() + +def writeColor(content, color, end=''): + forceWrite(f'\x1b[{color}m{content}\x1b[0m', end) + +def reset_cursor(): + forceWrite('\r') + +def move_cursor(num_lines: int, direction: str): + forceWrite(f'\x1b[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}') + +def clear_line(): + forceWrite(' ' * TERMINAL_WIDTH) + reset_cursor() + +def linebreak(): + reset_cursor() + forceWrite('-' * TERMINAL_WIDTH) + +# File: accelerate-main/src/accelerate/commands/menu/input.py +"""""" +from typing import List +from .keymap import KEYMAP, get_character + +def mark(key: str): + + def decorator(func): + handle = getattr(func, 'handle_key', []) + handle += [key] + func.handle_key = handle + return func + return decorator + +def mark_multiple(*keys: List[str]): + + def decorator(func): + handle = getattr(func, 'handle_key', []) + handle += keys + func.handle_key = handle + return func + return decorator + +class KeyHandler(type): + + def __new__(cls, name, bases, attrs): + new_cls = super().__new__(cls, name, bases, attrs) + if not hasattr(new_cls, 'key_handler'): + new_cls.key_handler = {} + new_cls.handle_input = KeyHandler.handle_input + for value in attrs.values(): + handled_keys = getattr(value, 'handle_key', []) + for key in handled_keys: + new_cls.key_handler[key] = value + return new_cls + + @staticmethod + def handle_input(cls): + char = get_character() + if char != KEYMAP['undefined']: + char = ord(char) + handler = cls.key_handler.get(char) + if handler: + cls.current_selection = char + return handler(cls) + else: + return None + +def register(cls): + return KeyHandler(cls.__name__, cls.__bases__, cls.__dict__.copy()) + +# File: accelerate-main/src/accelerate/commands/menu/keymap.py +"""""" +import os +import string +import sys +ARROW_KEY_FLAG = 1 << 8 +KEYMAP = {'tab': ord('\t'), 'newline': ord('\r'), 'esc': 27, 'up': 65 + ARROW_KEY_FLAG, 'down': 66 + ARROW_KEY_FLAG, 'right': 67 + ARROW_KEY_FLAG, 'left': 68 + ARROW_KEY_FLAG, 'mod_int': 91, 'undefined': sys.maxsize, 'interrupt': 3, 'insert': 50, 'delete': 51, 'pg_up': 53, 'pg_down': 54} +KEYMAP['arrow_begin'] = KEYMAP['up'] +KEYMAP['arrow_end'] = KEYMAP['left'] +if sys.platform == 'win32': + WIN_CH_BUFFER = [] + WIN_KEYMAP = {b'\xe0H': KEYMAP['up'] - ARROW_KEY_FLAG, b'\x00H': KEYMAP['up'] - ARROW_KEY_FLAG, b'\xe0P': KEYMAP['down'] - ARROW_KEY_FLAG, b'\x00P': KEYMAP['down'] - ARROW_KEY_FLAG, b'\xe0M': KEYMAP['right'] - ARROW_KEY_FLAG, b'\x00M': KEYMAP['right'] - ARROW_KEY_FLAG, b'\xe0K': KEYMAP['left'] - ARROW_KEY_FLAG, b'\x00K': KEYMAP['left'] - ARROW_KEY_FLAG} +for i in range(10): + KEYMAP[str(i)] = ord(str(i)) + +def get_raw_chars(): + if os.name == 'nt': + import msvcrt + encoding = 'mbcs' + while msvcrt.kbhit(): + msvcrt.getch() + if len(WIN_CH_BUFFER) == 0: + ch = msvcrt.getch() + if ch in (b'\x00', b'\xe0'): + ch2 = ch + msvcrt.getch() + try: + chx = chr(WIN_KEYMAP[ch2]) + WIN_CH_BUFFER.append(chr(KEYMAP['mod_int'])) + WIN_CH_BUFFER.append(chx) + if ord(chx) in (KEYMAP['insert'] - 1 << 9, KEYMAP['delete'] - 1 << 9, KEYMAP['pg_up'] - 1 << 9, KEYMAP['pg_down'] - 1 << 9): + WIN_CH_BUFFER.append(chr(126)) + ch = chr(KEYMAP['esc']) + except KeyError: + ch = ch2[1] + else: + ch = ch.decode(encoding) + else: + ch = WIN_CH_BUFFER.pop(0) + elif os.name == 'posix': + import termios + import tty + fd = sys.stdin.fileno() + old_settings = termios.tcgetattr(fd) + try: + tty.setraw(fd) + ch = sys.stdin.read(1) + finally: + termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) + return ch + +def get_character(): + char = get_raw_chars() + if ord(char) in [KEYMAP['interrupt'], KEYMAP['newline']]: + return char + elif ord(char) == KEYMAP['esc']: + combo = get_raw_chars() + if ord(combo) == KEYMAP['mod_int']: + key = get_raw_chars() + if ord(key) >= KEYMAP['arrow_begin'] - ARROW_KEY_FLAG and ord(key) <= KEYMAP['arrow_end'] - ARROW_KEY_FLAG: + return chr(ord(key) + ARROW_KEY_FLAG) + else: + return KEYMAP['undefined'] + else: + return get_raw_chars() + elif char in string.printable: + return char + else: + return KEYMAP['undefined'] + +# File: accelerate-main/src/accelerate/commands/menu/selection_menu.py +"""""" +import builtins +import sys +from ...utils.imports import _is_package_available +from . import cursor, input +from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor +from .keymap import KEYMAP +in_colab = False +try: + in_colab = _is_package_available('google.colab') +except ModuleNotFoundError: + pass + +@input.register +class BulletMenu: + + def __init__(self, prompt: str=None, choices: list=[]): + self.position = 0 + self.choices = choices + self.prompt = prompt + if sys.platform == 'win32': + self.arrow_char = '*' + else: + self.arrow_char = '➔ ' + + def write_choice(self, index, end: str=''): + if sys.platform != 'win32': + writeColor(self.choices[index], 32, end) + else: + forceWrite(self.choices[index], end) + + def print_choice(self, index: int): + if index == self.position: + forceWrite(f' {self.arrow_char} ') + self.write_choice(index) + else: + forceWrite(f' {self.choices[index]}') + reset_cursor() + + def move_direction(self, direction: Direction, num_spaces: int=1): + old_position = self.position + if direction == Direction.DOWN: + if self.position + 1 >= len(self.choices): + return + self.position += num_spaces + else: + if self.position - 1 < 0: + return + self.position -= num_spaces + clear_line() + self.print_choice(old_position) + move_cursor(num_spaces, direction.name) + self.print_choice(self.position) + + @input.mark(KEYMAP['up']) + def move_up(self): + self.move_direction(Direction.UP) + + @input.mark(KEYMAP['down']) + def move_down(self): + self.move_direction(Direction.DOWN) + + @input.mark(KEYMAP['newline']) + def select(self): + move_cursor(len(self.choices) - self.position, 'DOWN') + return self.position + + @input.mark(KEYMAP['interrupt']) + def interrupt(self): + move_cursor(len(self.choices) - self.position, 'DOWN') + raise KeyboardInterrupt + + @input.mark_multiple(*[KEYMAP[str(number)] for number in range(10)]) + def select_row(self): + index = int(chr(self.current_selection)) + movement = index - self.position + if index == self.position: + return + if index < len(self.choices): + if self.position > index: + self.move_direction(Direction.UP, -movement) + elif self.position < index: + self.move_direction(Direction.DOWN, movement) + else: + return + else: + return + + def run(self, default_choice: int=0): + if self.prompt: + linebreak() + forceWrite(self.prompt, '\n') + if in_colab: + forceWrite('Please input a choice index (starting from 0), and press enter', '\n') + else: + forceWrite('Please select a choice using the arrow or number keys, and selecting with enter', '\n') + self.position = default_choice + for i in range(len(self.choices)): + self.print_choice(i) + forceWrite('\n') + move_cursor(len(self.choices) - self.position, 'UP') + with cursor.hide(): + while True: + if in_colab: + try: + choice = int(builtins.input()) + except ValueError: + choice = default_choice + else: + choice = self.handle_input() + if choice is not None: + reset_cursor() + for _ in range(len(self.choices) + 1): + move_cursor(1, 'UP') + clear_line() + self.write_choice(choice, '\n') + return choice + +# File: accelerate-main/src/accelerate/commands/merge.py +from accelerate.commands.utils import CustomArgumentParser +from accelerate.utils import merge_fsdp_weights +description = 'Utility to merge the weights from multiple FSDP checkpoints into a single combined checkpoint. Should be used if\n`SHARDED_STATE_DICT` was used for the model. Weights will be saved to `{output_path}`.\n\nThis is a CPU-bound process and requires enough RAM to load the entire model state dict.' + +def merge_command(args): + merge_fsdp_weights(args.checkpoint_directory, args.output_path, not args.unsafe_serialization, args.remove_checkpoint_dir) + +def merge_command_parser(subparsers=None): + if subparsers is not None: + parser = subparsers.add_parser('merge-weights', description=description) + else: + parser = CustomArgumentParser(description=description) + parser.add_argument('checkpoint_directory', type=str, help='A directory containing sharded weights saved by FSDP.') + parser.add_argument('output_path', type=str, help='The path to save the merged weights. Defaults to the current directory. ') + parser.add_argument('--unsafe_serialization', action='store_false', default=False, help='Whether to save the merged weights as `.bin` rather than `.safetensors` (not recommended).') + parser.add_argument('--remove_checkpoint_dir', action='store_true', help='Whether to remove the checkpoint directory after merging.', default=False) + if subparsers is not None: + parser.set_defaults(func=merge_command) + return parser + +def main(): + parser = merge_command_parser() + args = parser.parse_args() + merge_command(args) +if __name__ == '__main__': + main() + +# File: accelerate-main/src/accelerate/commands/tpu.py +import argparse +import os +import subprocess +from packaging.version import Version, parse +from accelerate.commands.config.config_args import default_config_file, load_config_from_file +_description = 'Run commands across TPU VMs for initial setup before running `accelerate launch`.' + +def tpu_command_parser(subparsers=None): + if subparsers is not None: + parser = subparsers.add_parser('tpu-config', description=_description) + else: + parser = argparse.ArgumentParser('Accelerate tpu-config command', description=_description) + config_args = parser.add_argument_group('Config Arguments', 'Arguments that can be configured through `accelerate config`.') + config_args.add_argument('--config_file', type=str, default=None, help='Path to the config file to use for accelerate.') + config_args.add_argument('--tpu_name', default=None, help='The name of the TPU to use. If not specified, will use the TPU specified in the config file.') + config_args.add_argument('--tpu_zone', default=None, help='The zone of the TPU to use. If not specified, will use the zone specified in the config file.') + pod_args = parser.add_argument_group('TPU Arguments', 'Arguments for options ran inside the TPU.') + pod_args.add_argument('--use_alpha', action='store_true', help='Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.') + pod_args.add_argument('--command_file', default=None, help='The path to the file containing the commands to run on the pod on startup.') + pod_args.add_argument('--command', action='append', nargs='+', help='A command to run on the pod. Can be passed multiple times.') + pod_args.add_argument('--install_accelerate', action='store_true', help='Whether to install accelerate on the pod. Defaults to False.') + pod_args.add_argument('--accelerate_version', default='latest', help="The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify 'dev' to install from GitHub.") + pod_args.add_argument('--debug', action='store_true', help='If set, will print the command that would be run instead of running it.') + if subparsers is not None: + parser.set_defaults(func=tpu_command_launcher) + return parser + +def tpu_command_launcher(args): + defaults = None + if args.config_file is not None or os.path.isfile(default_config_file): + defaults = load_config_from_file(args.config_file) + if not args.command_file and defaults.command_file is not None and (not args.command): + args.command_file = defaults.command_file + if not args.command and defaults.commands is not None: + args.command = defaults.commands + if not args.tpu_name: + args.tpu_name = defaults.tpu_name + if not args.tpu_zone: + args.tpu_zone = defaults.tpu_zone + if args.accelerate_version == 'dev': + args.accelerate_version = 'git+https://github.com/huggingface/accelerate.git' + elif args.accelerate_version == 'latest': + args.accelerate_version = 'accelerate -U' + elif isinstance(parse(args.accelerate_version), Version): + args.accelerate_version = f'accelerate=={args.accelerate_version}' + if not args.command_file and (not args.command): + raise ValueError('You must specify either a command file or a command to run on the pod.') + if args.command_file: + with open(args.command_file) as f: + args.command = [f.read().splitlines()] + if isinstance(args.command[0], list): + args.command = [line for cmd in args.command for line in cmd] + new_cmd = ['cd /usr/share'] + if args.install_accelerate: + new_cmd += [f'pip install {args.accelerate_version}'] + new_cmd += args.command + args.command = '; '.join(new_cmd) + cmd = ['gcloud'] + if args.use_alpha: + cmd += ['alpha'] + cmd += ['compute', 'tpus', 'tpu-vm', 'ssh', args.tpu_name, '--zone', args.tpu_zone, '--command', args.command, '--worker', 'all'] + if args.debug: + print(f"Running {' '.join(cmd)}") + return + subprocess.run(cmd) + print('Successfully setup pod.') + +def main(): + parser = tpu_command_parser() + args = parser.parse_args() + tpu_command_launcher(args) + +# File: accelerate-main/src/accelerate/commands/utils.py +import argparse + +class _StoreAction(argparse.Action): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + new_option_strings = [] + for option_string in self.option_strings: + new_option_strings.append(option_string) + if '_' in option_string[2:]: + new_option_strings.append(option_string.replace('_', '-')) + self.option_strings = new_option_strings + + def __call__(self, parser, namespace, values, option_string=None): + setattr(namespace, self.dest, values) + +class _StoreConstAction(_StoreAction): + + def __init__(self, option_strings, dest, const, default=None, required=False, help=None): + super().__init__(option_strings=option_strings, dest=dest, nargs=0, const=const, default=default, required=required, help=help) + + def __call__(self, parser, namespace, values, option_string=None): + setattr(namespace, self.dest, self.const) + +class _StoreTrueAction(_StoreConstAction): + + def __init__(self, option_strings, dest, default=None, required=False, help=None): + super().__init__(option_strings=option_strings, dest=dest, const=True, default=default, required=required, help=help) + +class CustomArgumentGroup(argparse._ArgumentGroup): + + def _add_action(self, action): + args = vars(action) + if isinstance(action, argparse._StoreTrueAction): + action = _StoreTrueAction(args['option_strings'], args['dest'], args['default'], args['required'], args['help']) + elif isinstance(action, argparse._StoreConstAction): + action = _StoreConstAction(args['option_strings'], args['dest'], args['const'], args['default'], args['required'], args['help']) + elif isinstance(action, argparse._StoreAction): + action = _StoreAction(**args) + action = super()._add_action(action) + return action + +class CustomArgumentParser(argparse.ArgumentParser): + + def add_argument(self, *args, **kwargs): + if 'action' in kwargs: + if kwargs['action'] == 'store_true': + kwargs['action'] = _StoreTrueAction + else: + kwargs['action'] = _StoreAction + super().add_argument(*args, **kwargs) + + def add_argument_group(self, *args, **kwargs): + group = CustomArgumentGroup(self, *args, **kwargs) + self._action_groups.append(group) + return group + +# File: accelerate-main/src/accelerate/data_loader.py +import math +from contextlib import suppress +from typing import Callable, List, Optional, Union +import torch +from torch.utils.data import BatchSampler, DataLoader, IterableDataset, RandomSampler +from .logging import get_logger +from .state import DistributedType, GradientState, PartialState, is_torch_xla_available +from .utils import RNGType, broadcast, broadcast_object_list, concatenate, find_batch_size, get_data_structure, initialize_tensors, is_torch_version, is_torchdata_stateful_dataloader_available, send_to_device, slice_tensors, synchronize_rng_states +logger = get_logger(__name__) +_PYTORCH_DATALOADER_KWARGS = {'batch_size': 1, 'shuffle': False, 'sampler': None, 'batch_sampler': None, 'num_workers': 0, 'collate_fn': None, 'pin_memory': False, 'drop_last': False, 'timeout': 0, 'worker_init_fn': None, 'multiprocessing_context': None, 'generator': None, 'prefetch_factor': 2, 'persistent_workers': False} +_PYTORCH_DATALOADER_ADDITIONAL_KWARGS = {} +for (v, additional_kwargs) in _PYTORCH_DATALOADER_ADDITIONAL_KWARGS.items(): + if is_torch_version('>=', v): + _PYTORCH_DATALOADER_KWARGS.update(additional_kwargs) + +class SeedableRandomSampler(RandomSampler): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.epoch = 0 + self.initial_seed = torch.random.initial_seed() + + def __iter__(self): + if self.generator is None: + self.generator = torch.Generator() + self.generator.manual_seed(self.initial_seed) + seed = self.epoch + self.initial_seed + self.generator.manual_seed(seed) + yield from super().__iter__() + self.set_epoch(self.epoch + 1) + + def set_epoch(self, epoch: int): + self.epoch = epoch + +class BatchSamplerShard(BatchSampler): + + def __init__(self, batch_sampler: BatchSampler, num_processes: int=1, process_index: int=0, split_batches: bool=False, even_batches: bool=True): + if split_batches and batch_sampler.batch_size % num_processes != 0: + raise ValueError(f'To use `BatchSamplerShard` in `split_batches` mode, the batch size ({batch_sampler.batch_size}) needs to be a round multiple of the number of processes ({num_processes}).') + self.batch_sampler = batch_sampler + self.num_processes = num_processes + self.process_index = process_index + self.split_batches = split_batches + self.even_batches = even_batches + self.batch_size = getattr(batch_sampler, 'batch_size', None) + self.drop_last = getattr(batch_sampler, 'drop_last', False) + if self.batch_size is None and self.even_batches: + raise ValueError('You need to use `even_batches=False` when the batch sampler has no batch size. If you are not calling this method directly, set `accelerator.even_batches=False` instead.') + + @property + def total_length(self): + return len(self.batch_sampler) + + def __len__(self): + if self.split_batches: + return len(self.batch_sampler) + if len(self.batch_sampler) % self.num_processes == 0: + return len(self.batch_sampler) // self.num_processes + length = len(self.batch_sampler) // self.num_processes + if self.drop_last: + return length + elif self.even_batches: + return length + 1 + else: + return length + 1 if self.process_index < len(self.batch_sampler) % self.num_processes else length + + def __iter__(self): + return self._iter_with_split() if self.split_batches else self._iter_with_no_split() + + def _iter_with_split(self): + initial_data = [] + batch_length = self.batch_sampler.batch_size // self.num_processes + for (idx, batch) in enumerate(self.batch_sampler): + if idx == 0: + initial_data = batch + if len(batch) == self.batch_size: + yield batch[batch_length * self.process_index:batch_length * (self.process_index + 1)] + if not self.drop_last and len(initial_data) > 0 and (len(batch) < self.batch_size): + if not self.even_batches: + if len(batch) > batch_length * self.process_index: + yield batch[batch_length * self.process_index:batch_length * (self.process_index + 1)] + else: + while len(initial_data) < self.batch_size: + initial_data += initial_data + batch = batch + initial_data + yield batch[batch_length * self.process_index:batch_length * (self.process_index + 1)] + + def _iter_with_no_split(self): + initial_data = [] + batch_to_yield = [] + for (idx, batch) in enumerate(self.batch_sampler): + if not self.drop_last and idx < self.num_processes: + initial_data += batch + if idx % self.num_processes == self.process_index: + batch_to_yield = batch + if idx % self.num_processes == self.num_processes - 1 and (self.batch_size is None or len(batch) == self.batch_size): + yield batch_to_yield + batch_to_yield = [] + if not self.drop_last and len(initial_data) > 0: + if not self.even_batches: + if len(batch_to_yield) > 0: + yield batch_to_yield + else: + if len(batch_to_yield) == self.batch_size: + yield batch_to_yield + while len(initial_data) < self.num_processes * self.batch_size: + initial_data += initial_data + if len(batch) == self.batch_size: + batch = [] + idx += 1 + cycle_index = 0 + while idx % self.num_processes != 0 or len(batch) > 0: + end_index = cycle_index + self.batch_size - len(batch) + batch += initial_data[cycle_index:end_index] + if idx % self.num_processes == self.process_index: + yield batch + cycle_index = end_index + batch = [] + idx += 1 + +class IterableDatasetShard(IterableDataset): + + def __init__(self, dataset: IterableDataset, batch_size: int=1, drop_last: bool=False, num_processes: int=1, process_index: int=0, split_batches: bool=False): + if split_batches and batch_size > 1 and (batch_size % num_processes != 0): + raise ValueError(f'To use `IterableDatasetShard` in `split_batches` mode, the batch size ({batch_size}) needs to be a round multiple of the number of processes ({num_processes}).') + self.dataset = dataset + self.batch_size = batch_size + self.drop_last = drop_last + self.num_processes = num_processes + self.process_index = process_index + self.split_batches = split_batches + + def set_epoch(self, epoch): + self.epoch = epoch + if hasattr(self.dataset, 'set_epoch'): + self.dataset.set_epoch(epoch) + + def __len__(self): + if self.drop_last: + return len(self.dataset) // (self.batch_size * self.num_processes) * self.batch_size + else: + return math.ceil(len(self.dataset) / (self.batch_size * self.num_processes)) * self.batch_size + + def __iter__(self): + if not hasattr(self.dataset, 'set_epoch') and hasattr(self.dataset, 'generator') and isinstance(self.dataset.generator, torch.Generator): + self.dataset.generator.manual_seed(self.epoch) + real_batch_size = self.batch_size if self.split_batches else self.batch_size * self.num_processes + process_batch_size = self.batch_size // self.num_processes if self.split_batches else self.batch_size + process_slice = range(self.process_index * process_batch_size, (self.process_index + 1) * process_batch_size) + first_batch = None + current_batch = [] + for element in self.dataset: + current_batch.append(element) + if len(current_batch) == real_batch_size: + for i in process_slice: + yield current_batch[i] + if first_batch is None: + first_batch = current_batch.copy() + current_batch = [] + if not self.drop_last and len(current_batch) > 0: + if first_batch is None: + first_batch = current_batch.copy() + while len(current_batch) < real_batch_size: + current_batch += first_batch + for i in process_slice: + yield current_batch[i] + +class DataLoaderStateMixin: + + def __init_subclass__(cls, **kwargs): + cls.end_of_dataloader = False + cls.remainder = -1 + + def reset(self): + self.end_of_dataloader = False + self.remainder = -1 + + def begin(self): + self.reset() + with suppress(Exception): + if not self._drop_last: + length = getattr(self.dataset, 'total_dataset_length', len(self.dataset)) + self.remainder = length % self.total_batch_size + self.gradient_state._add_dataloader(self) + + def end(self): + self.gradient_state._remove_dataloader(self) + +class DataLoaderAdapter: + + def __init__(self, dataset, use_stateful_dataloader=False, batch_sampler=None, **kwargs): + self.use_stateful_dataloader = use_stateful_dataloader + if is_torchdata_stateful_dataloader_available(): + from torchdata.stateful_dataloader import StatefulDataLoader + if use_stateful_dataloader and (not is_torchdata_stateful_dataloader_available()): + raise ImportError('StatefulDataLoader is not available. Please install torchdata version 0.8.0 or higher to use it.') + if use_stateful_dataloader: + self.base_dataloader = StatefulDataLoader(dataset, batch_sampler=batch_sampler, **kwargs) + else: + self.base_dataloader = DataLoader(dataset, batch_sampler=batch_sampler, **kwargs) + if hasattr(self.base_dataloader, 'state_dict'): + self.dl_state_dict = self.base_dataloader.state_dict() + + def __getattr__(self, name): + if name == 'base_dataloader': + raise AttributeError() + return getattr(self.base_dataloader, name) + + def state_dict(self): + return self.dl_state_dict + + def load_state_dict(self, state_dict): + self.base_dataloader.load_state_dict(state_dict) + + @property + def __class__(self): + return self.base_dataloader.__class__ + + def __len__(self): + return len(self.base_dataloader) + + def adjust_state_dict_for_prefetch(self): + if PartialState().distributed_type != DistributedType.NO: + factor = PartialState().num_processes - 1 + if self.dl_state_dict['_sampler_iter_yielded'] > 0: + self.dl_state_dict['_sampler_iter_yielded'] -= factor + if self.dl_state_dict['_num_yielded'] > 0: + self.dl_state_dict['_num_yielded'] -= factor + if self.dl_state_dict['_index_sampler_state'] is not None: + if 'samples_yielded' in self.dl_state_dict['_index_sampler_state'] and self.dl_state_dict['_index_sampler_state']['samples_yielded'] > 0: + self.dl_state_dict['_index_sampler_state']['samples_yielded'] -= self.batch_size * factor + + def _update_state_dict(self): + if hasattr(self.base_dataloader, 'state_dict'): + self.dl_state_dict = self.base_dataloader.state_dict() + self.adjust_state_dict_for_prefetch() + self.dl_state_dict['_iterator_finished'] = self.end_of_dataloader + +class DataLoaderShard(DataLoaderAdapter, DataLoaderStateMixin): + + def __init__(self, dataset, device=None, rng_types=None, synchronized_generator=None, skip_batches=0, use_stateful_dataloader=False, _drop_last: bool=False, _non_blocking: bool=False, **kwargs): + super().__init__(dataset, use_stateful_dataloader=use_stateful_dataloader, **kwargs) + self.device = device + self.rng_types = rng_types + self.synchronized_generator = synchronized_generator + self.skip_batches = skip_batches + self.gradient_state = GradientState() + self._drop_last = _drop_last + self._non_blocking = _non_blocking + self.iteration = 0 + + def __iter__(self): + if self.rng_types is not None: + synchronize_rng_states(self.rng_types, self.synchronized_generator) + self.begin() + self.set_epoch(self.iteration) + dataloader_iter = self.base_dataloader.__iter__() + try: + current_batch = next(dataloader_iter) + except StopIteration: + yield + batch_index = 0 + while True: + try: + if self.device is not None: + current_batch = send_to_device(current_batch, self.device, non_blocking=self._non_blocking) + self._update_state_dict() + next_batch = next(dataloader_iter) + if batch_index >= self.skip_batches: + yield current_batch + batch_index += 1 + current_batch = next_batch + except StopIteration: + self.end_of_dataloader = True + self._update_state_dict() + if batch_index >= self.skip_batches: + yield current_batch + break + self.iteration += 1 + self.end() + + def __reduce__(self): + args = super().__reduce__() + return (DataLoaderShard, *args[1:]) + + def set_epoch(self, epoch: int): + if self.iteration != epoch: + self.iteration = epoch + if hasattr(self.batch_sampler, 'sampler') and hasattr(self.batch_sampler.sampler, 'set_epoch'): + self.batch_sampler.sampler.set_epoch(epoch) + elif hasattr(self.dataset, 'set_epoch'): + self.dataset.set_epoch(epoch) + + @property + def total_batch_size(self): + batch_sampler = self.sampler if isinstance(self.sampler, BatchSampler) else self.batch_sampler + return batch_sampler.batch_size if getattr(batch_sampler, 'split_batches', False) else batch_sampler.batch_size * getattr(batch_sampler, 'num_processes', 1) + + @property + def total_dataset_length(self): + if hasattr(self.dataset, 'total_length'): + return self.dataset.total_length + else: + return len(self.dataset) + + def get_sampler(self): + return get_sampler(self) + + def set_sampler(self, sampler): + sampler_is_batch_sampler = isinstance(self.sampler, BatchSampler) + if sampler_is_batch_sampler: + self.sampler.sampler = sampler + else: + self.batch_sampler.sampler = sampler + if hasattr(self.batch_sampler, 'batch_sampler'): + self.batch_sampler.batch_sampler.sampler = sampler +if is_torch_xla_available(): + import torch_xla.distributed.parallel_loader as xpl + + class MpDeviceLoaderWrapper(xpl.MpDeviceLoader): + + def __init__(self, dataloader: DataLoaderShard, device: torch.device): + super().__init__(dataloader, device) + self._rng_types = self._loader.rng_types + self._loader.rng_types = None + self.device = device + + def __iter__(self): + if self._rng_types is not None: + synchronize_rng_states(self._rng_types, self._loader.synchronized_generator) + return super().__iter__() + + def set_epoch(self, epoch: int): + if hasattr(self.dataloader, 'set_epoch'): + self.dataloader.set_epoch(epoch) + + @property + def total_batch_size(self): + return self._loader.total_batch_size + + @property + def total_dataset_length(self): + return self._loader.total_dataset_length + + @property + def batch_sampler(self): + return self._loader.batch_sampler + + @property + def dataloader(self): + return self._loader + +class DataLoaderDispatcher(DataLoaderAdapter, DataLoaderStateMixin): + + def __init__(self, dataset, split_batches: bool=False, skip_batches=0, use_stateful_dataloader=False, _drop_last: bool=False, _non_blocking: bool=False, slice_fn=None, **kwargs): + shuffle = False + if is_torch_version('>=', '1.11.0'): + from torch.utils.data.datapipes.iter.combinatorics import ShufflerIterDataPipe + if isinstance(dataset, ShufflerIterDataPipe): + shuffle = dataset._shuffle_enabled + super().__init__(dataset, use_stateful_dataloader=use_stateful_dataloader, **kwargs) + self.split_batches = split_batches + if shuffle: + torch.utils.data.graph_settings.apply_shuffle_settings(dataset, shuffle=shuffle) + self.gradient_state = GradientState() + self.state = PartialState() + self._drop_last = _drop_last + self._non_blocking = _non_blocking + self.skip_batches = skip_batches + self.slice_fn = slice_tensors if slice_fn is None else slice_fn + self.iteration = 0 + + def _fetch_batches(self, iterator): + (batches, batch) = (None, None) + if self.state.process_index == 0: + try: + if self.split_batches: + self._update_state_dict() + batch = next(iterator) + else: + batches = [] + for _ in range(self.state.num_processes): + self._update_state_dict() + batches.append(next(iterator)) + try: + batch = concatenate(batches, dim=0) + except RuntimeError as e: + raise RuntimeError("You can't use batches of different size with `dispatch_batches=True` or when using an `IterableDataset`.either pass `dispatch_batches=False` and have each process fetch its own batch or pass `split_batches=True`. By doing so, the main process will fetch a full batch and slice it into `num_processes` batches for each process.") from e + batch_info = [get_data_structure(batch), False] + except StopIteration: + batch_info = [None, True] + else: + batch_info = [None, self._stop_iteration] + broadcast_object_list(batch_info) + self._stop_iteration = batch_info[1] + if self._stop_iteration: + if not self.split_batches and (not self._drop_last): + if self.state.process_index == 0 and len(batches) > 0: + batch = concatenate(batches, dim=0) + batch_info = [get_data_structure(batch), False] + else: + batch_info = [None, True] + broadcast_object_list(batch_info) + return (batch, batch_info) + + def __iter__(self): + self.begin() + self.set_epoch(self.iteration) + main_iterator = None + if is_torch_version('>=', '2.0.1'): + main_iterator = self.base_dataloader.__iter__() + elif self.state.process_index == 0: + main_iterator = self.base_dataloader.__iter__() + stop_iteration = False + self._stop_iteration = False + first_batch = None + (next_batch, next_batch_info) = self._fetch_batches(main_iterator) + batch_index = 0 + while not stop_iteration: + (batch, batch_info) = (next_batch, next_batch_info) + if self.state.process_index != 0: + batch = initialize_tensors(batch_info[0]) + batch = send_to_device(batch, self.state.device, non_blocking=self._non_blocking) + batch = broadcast(batch, from_process=0) + if not self._drop_last and first_batch is None: + first_batch = self.slice_fn(batch, slice(0, self.state.num_processes), process_index=self.state.process_index, num_processes=self.state.num_processes) + if batch is None: + raise ValueError(f'Batch does not contain any data (`{batch}`). At the end of all iterable data available before expected stop iteration.') + observed_batch_size = find_batch_size(batch) + batch_size = observed_batch_size // self.state.num_processes + stop_iteration = self._stop_iteration + if not stop_iteration: + (next_batch, next_batch_info) = self._fetch_batches(main_iterator) + if self._stop_iteration and next_batch_info[0] is None: + stop_iteration = True + if not self._drop_last and stop_iteration and (observed_batch_size % self.state.num_processes != 0): + batch = concatenate([batch, first_batch], dim=0) + batch_size += 1 + data_slice = slice(self.state.process_index * batch_size, (self.state.process_index + 1) * batch_size) + batch = self.slice_fn(batch, data_slice, process_index=self.state.process_index, num_processes=self.state.num_processes) + if stop_iteration: + self.end_of_dataloader = True + self._update_state_dict() + self.remainder = observed_batch_size + if batch_index >= self.skip_batches: + yield batch + batch_index += 1 + self.iteration += 1 + self.end() + + def set_epoch(self, epoch: int): + if self.iteration != epoch: + self.iteration = epoch + if hasattr(self.batch_sampler, 'sampler') and hasattr(self.batch_sampler.sampler, 'set_epoch'): + self.batch_sampler.sampler.set_epoch(epoch) + elif hasattr(self.dataset, 'set_epoch'): + self.dataset.set_epoch(epoch) + + def __len__(self): + whole_length = len(self.base_dataloader) + if self.split_batches: + return whole_length + elif self._drop_last: + return whole_length // self.state.num_processes + else: + return math.ceil(whole_length / self.state.num_processes) + + def __reduce__(self): + args = super().__reduce__() + return (DataLoaderDispatcher, *args[1:]) + + @property + def total_batch_size(self): + return self.dataset.batch_size if self.split_batches else self.dataset.batch_size * self.dataset.num_processes + + @property + def total_dataset_length(self): + return len(self.dataset) + + def get_sampler(self): + return get_sampler(self) + + def set_sampler(self, sampler): + sampler_is_batch_sampler = isinstance(self.sampler, BatchSampler) + if sampler_is_batch_sampler: + self.sampler.sampler = sampler + else: + self.batch_sampler.sampler = sampler + if hasattr(self.batch_sampler, 'batch_sampler'): + self.batch_sampler.batch_sampler.sampler = sampler + +def get_sampler(dataloader): + sampler_is_batch_sampler = isinstance(dataloader.sampler, BatchSampler) + if sampler_is_batch_sampler: + sampler = getattr(dataloader.sampler, 'sampler', None) + else: + sampler = getattr(dataloader.batch_sampler, 'sampler', None) + return sampler + +def prepare_data_loader(dataloader: DataLoader, device: Optional[torch.device]=None, num_processes: Optional[int]=None, process_index: Optional[int]=None, split_batches: bool=False, put_on_device: bool=False, rng_types: Optional[List[Union[str, RNGType]]]=None, dispatch_batches: Optional[bool]=None, even_batches: bool=True, slice_fn_for_dispatch: Optional[Callable]=None, use_seedable_sampler: bool=False, non_blocking: bool=False, use_stateful_dataloader: bool=False) -> DataLoader: + if dispatch_batches is None: + if not put_on_device: + dispatch_batches = False + else: + dispatch_batches = isinstance(dataloader.dataset, IterableDataset) + if dispatch_batches and (not put_on_device): + raise ValueError('Using `dispatch_batches=True` requires `put_on_device=True`.') + state = PartialState() + if num_processes is None: + num_processes = state.num_processes + if process_index is None: + process_index = state.process_index + if split_batches: + if dataloader.batch_size is not None: + batch_size_for_check = dataloader.batch_size + elif hasattr(dataloader.batch_sampler, 'batch_size'): + batch_size_for_check = dataloader.batch_sampler.batch_size + else: + raise ValueError(f'In order to use `split_batches==True` you must have a `batch_size` attribute either in the passed `dataloader` or `dataloader.batch_sampler` objects, and it has to return a natural number. Your `dataloader.batch_size` is None and `dataloader.batch_sampler` (`{type(dataloader.batch_sampler)}`) does not have the `batch_size` attribute set.') + if batch_size_for_check > 1 and batch_size_for_check % num_processes != 0: + raise ValueError(f'To use a `DataLoader` in `split_batches` mode, the batch size ({dataloader.batch_size}) needs to be a round multiple of the number of processes ({num_processes}).') + new_dataset = dataloader.dataset + new_batch_sampler = dataloader.batch_sampler if not isinstance(new_dataset, IterableDataset) else None + sampler_is_batch_sampler = isinstance(dataloader.sampler, BatchSampler) + synchronized_generator = None + sampler = get_sampler(dataloader) + if isinstance(sampler, RandomSampler) and use_seedable_sampler: + sampler = SeedableRandomSampler(data_source=sampler.data_source, replacement=sampler.replacement, num_samples=sampler._num_samples, generator=getattr(sampler, 'generator', torch.Generator())) + if isinstance(dataloader.sampler, RandomSampler) and state.distributed_type == DistributedType.XLA: + generator = torch.Generator().manual_seed(42) + dataloader.generator = generator + dataloader.sampler.generator = generator + if (num_processes != 1 or state.distributed_type == DistributedType.MEGATRON_LM) and (not dispatch_batches): + if isinstance(new_dataset, IterableDataset): + if getattr(dataloader.dataset, 'generator', None) is not None: + synchronized_generator = dataloader.dataset.generator + new_dataset = IterableDatasetShard(new_dataset, batch_size=dataloader.batch_size, drop_last=dataloader.drop_last, num_processes=num_processes, process_index=process_index, split_batches=split_batches) + else: + if not use_seedable_sampler and hasattr(sampler, 'generator'): + if sampler.generator is None: + sampler.generator = torch.Generator() + synchronized_generator = sampler.generator + batch_sampler = dataloader.sampler if sampler_is_batch_sampler else dataloader.batch_sampler + new_batch_sampler = BatchSamplerShard(batch_sampler, num_processes=num_processes, process_index=process_index, split_batches=split_batches, even_batches=even_batches) + ignore_kwargs = ['batch_size', 'shuffle', 'sampler', 'batch_sampler', 'drop_last'] + if rng_types is not None and synchronized_generator is None and ('generator' in rng_types): + rng_types.remove('generator') + kwargs = {k: getattr(dataloader, k, _PYTORCH_DATALOADER_KWARGS[k]) for k in _PYTORCH_DATALOADER_KWARGS if k not in ignore_kwargs} + if new_batch_sampler is None: + kwargs['drop_last'] = dataloader.drop_last + kwargs['batch_size'] = dataloader.batch_size // num_processes if split_batches and (not dispatch_batches) else dataloader.batch_size + if dispatch_batches: + kwargs.pop('generator') + dataloader = DataLoaderDispatcher(new_dataset, split_batches=split_batches, batch_sampler=new_batch_sampler, _drop_last=dataloader.drop_last, _non_blocking=non_blocking, slice_fn=slice_fn_for_dispatch, use_stateful_dataloader=use_stateful_dataloader, **kwargs) + elif sampler_is_batch_sampler: + dataloader = DataLoaderShard(new_dataset, device=device if put_on_device and state.distributed_type != DistributedType.XLA else None, sampler=new_batch_sampler, batch_size=dataloader.batch_size, rng_types=rng_types, _drop_last=dataloader.drop_last, _non_blocking=non_blocking, synchronized_generator=synchronized_generator, use_stateful_dataloader=use_stateful_dataloader, **kwargs) + else: + dataloader = DataLoaderShard(new_dataset, device=device if put_on_device and state.distributed_type != DistributedType.XLA else None, batch_sampler=new_batch_sampler, rng_types=rng_types, synchronized_generator=synchronized_generator, _drop_last=dataloader.drop_last, _non_blocking=non_blocking, use_stateful_dataloader=use_stateful_dataloader, **kwargs) + if isinstance(sampler, SeedableRandomSampler) and use_seedable_sampler: + dataloader.set_sampler(sampler) + if state.distributed_type == DistributedType.XLA: + return MpDeviceLoaderWrapper(dataloader, device) + return dataloader + +class SkipBatchSampler(BatchSampler): + + def __init__(self, batch_sampler, skip_batches=0): + self.batch_sampler = batch_sampler + self.skip_batches = skip_batches + + def __iter__(self): + for (index, samples) in enumerate(self.batch_sampler): + if index >= self.skip_batches: + yield samples + + @property + def total_length(self): + return len(self.batch_sampler) + + def __len__(self): + return len(self.batch_sampler) - self.skip_batches + +class SkipDataLoader(DataLoaderAdapter, DataLoaderStateMixin): + + def __init__(self, dataset, skip_batches=0, use_stateful_dataloader=False, **kwargs): + super().__init__(dataset, use_stateful_dataloader=use_stateful_dataloader, **kwargs) + self.skip_batches = skip_batches + self.gradient_state = GradientState() + + def __iter__(self): + self.begin() + for (index, batch) in enumerate(self.base_dataloader.__iter__()): + if index >= self.skip_batches: + self._update_state_dict() + yield batch + self.end() + + def __len__(self): + return len(self.base_dataloader) - self.skip_batches + + def __reduce__(self): + args = super().__reduce__() + return (SkipDataLoader, *args[1:]) + +def skip_first_batches(dataloader, num_batches=0): + state = PartialState() + if state.distributed_type == DistributedType.XLA: + device = dataloader.device + dataloader = dataloader.dataloader + dataset = dataloader.dataset + sampler_is_batch_sampler = False + if isinstance(dataset, IterableDataset): + new_batch_sampler = None + else: + sampler_is_batch_sampler = isinstance(dataloader.sampler, BatchSampler) + batch_sampler = dataloader.sampler if sampler_is_batch_sampler else dataloader.batch_sampler + new_batch_sampler = SkipBatchSampler(batch_sampler, skip_batches=num_batches) + ignore_kwargs = ['batch_size', 'shuffle', 'sampler', 'batch_sampler', 'drop_last'] + kwargs = {k: getattr(dataloader, k, _PYTORCH_DATALOADER_KWARGS[k]) for k in _PYTORCH_DATALOADER_KWARGS if k not in ignore_kwargs} + if new_batch_sampler is None: + kwargs['drop_last'] = dataloader.drop_last + kwargs['batch_size'] = dataloader.batch_size + if isinstance(dataloader, DataLoaderDispatcher): + if new_batch_sampler is None: + kwargs['skip_batches'] = num_batches + dataloader = DataLoaderDispatcher(dataset, split_batches=dataloader.split_batches, batch_sampler=new_batch_sampler, _drop_last=dataloader._drop_last, **kwargs) + elif isinstance(dataloader, DataLoaderShard): + if new_batch_sampler is None: + kwargs['skip_batches'] = num_batches + elif sampler_is_batch_sampler: + kwargs['sampler'] = new_batch_sampler + kwargs['batch_size'] = dataloader.batch_size + else: + kwargs['batch_sampler'] = new_batch_sampler + dataloader = DataLoaderShard(dataset, device=dataloader.device, rng_types=dataloader.rng_types, synchronized_generator=dataloader.synchronized_generator, **kwargs) + elif new_batch_sampler is None: + dataloader = SkipDataLoader(dataset, skip_batches=num_batches, **kwargs) + else: + dataloader = DataLoader(dataset, batch_sampler=new_batch_sampler, **kwargs) + if state.distributed_type == DistributedType.XLA: + dataloader = MpDeviceLoaderWrapper(dataloader, device) + return dataloader + +# File: accelerate-main/src/accelerate/hooks.py +import functools +from typing import Dict, List, Mapping, Optional, Union +import torch +import torch.nn as nn +from .state import PartialState +from .utils import PrefixedDataset, find_device, named_module_tensors, send_to_device, set_module_tensor_to_device +from .utils.memory import clear_device_cache +from .utils.modeling import get_non_persistent_buffers +from .utils.other import recursive_getattr +_accelerate_added_attributes = ['to', 'cuda', 'npu', 'xpu', 'mlu', 'musa'] + +class ModelHook: + no_grad = False + + def init_hook(self, module): + return module + + def pre_forward(self, module, *args, **kwargs): + return (args, kwargs) + + def post_forward(self, module, output): + return output + + def detach_hook(self, module): + return module + +class SequentialHook(ModelHook): + + def __init__(self, *hooks): + self.hooks = hooks + + def init_hook(self, module): + for hook in self.hooks: + module = hook.init_hook(module) + return module + + def pre_forward(self, module, *args, **kwargs): + for hook in self.hooks: + (args, kwargs) = hook.pre_forward(module, *args, **kwargs) + return (args, kwargs) + + def post_forward(self, module, output): + for hook in self.hooks: + output = hook.post_forward(module, output) + return output + + def detach_hook(self, module): + for hook in self.hooks: + module = hook.detach_hook(module) + return module + +def add_hook_to_module(module: nn.Module, hook: ModelHook, append: bool=False): + if append and getattr(module, '_hf_hook', None) is not None: + old_hook = module._hf_hook + remove_hook_from_module(module) + hook = SequentialHook(old_hook, hook) + if hasattr(module, '_hf_hook') and hasattr(module, '_old_forward'): + old_forward = module._old_forward + else: + old_forward = module.forward + module._old_forward = old_forward + module = hook.init_hook(module) + module._hf_hook = hook + + def new_forward(module, *args, **kwargs): + (args, kwargs) = module._hf_hook.pre_forward(module, *args, **kwargs) + if module._hf_hook.no_grad: + with torch.no_grad(): + output = module._old_forward(*args, **kwargs) + else: + output = module._old_forward(*args, **kwargs) + return module._hf_hook.post_forward(module, output) + if 'GraphModuleImpl' in str(type(module)): + module.__class__.forward = functools.update_wrapper(functools.partial(new_forward, module), old_forward) + else: + module.forward = functools.update_wrapper(functools.partial(new_forward, module), old_forward) + return module + +def remove_hook_from_module(module: nn.Module, recurse=False): + if hasattr(module, '_hf_hook'): + module._hf_hook.detach_hook(module) + delattr(module, '_hf_hook') + if hasattr(module, '_old_forward'): + if 'GraphModuleImpl' in str(type(module)): + module.__class__.forward = module._old_forward + else: + module.forward = module._old_forward + delattr(module, '_old_forward') + for attr in _accelerate_added_attributes: + module.__dict__.pop(attr, None) + if recurse: + for child in module.children(): + remove_hook_from_module(child, recurse) + return module + +class AlignDevicesHook(ModelHook): + + def __init__(self, execution_device: Optional[Union[int, str, torch.device]]=None, offload: bool=False, io_same_device: bool=False, weights_map: Optional[Mapping]=None, offload_buffers: bool=False, place_submodules: bool=False, skip_keys: Optional[Union[str, List[str]]]=None, tied_params_map: Optional[Dict[int, Dict[torch.device, torch.Tensor]]]=None): + self.execution_device = execution_device + self.offload = offload + self.io_same_device = io_same_device + self.weights_map = weights_map + self.offload_buffers = offload_buffers + self.place_submodules = place_submodules + self.skip_keys = skip_keys + self.input_device = None + self.param_original_devices = {} + self.buffer_original_devices = {} + self.tied_params_names = set() + self.tied_params_map = tied_params_map + + def __repr__(self): + return f'AlignDevicesHook(execution_device={self.execution_device}, offload={self.offload}, io_same_device={self.io_same_device}, offload_buffers={self.offload_buffers}, place_submodules={self.place_submodules}, skip_keys={repr(self.skip_keys)})' + + def init_hook(self, module): + if self.execution_device == 'meta' or self.execution_device == torch.device('meta'): + self.tied_params_map = None + if not self.offload and self.execution_device is not None: + for (name, _) in named_module_tensors(module, recurse=self.place_submodules): + set_module_tensor_to_device(module, name, self.execution_device, tied_params_map=self.tied_params_map) + elif self.offload: + self.original_devices = {name: param.device for (name, param) in named_module_tensors(module, recurse=self.place_submodules)} + if self.weights_map is None: + self.weights_map = {name: param.to('cpu') for (name, param) in named_module_tensors(module, include_buffers=self.offload_buffers, recurse=self.place_submodules)} + for (name, _) in named_module_tensors(module, include_buffers=self.offload_buffers, recurse=self.place_submodules, remove_non_persistent=True): + if self.tied_params_map is not None and recursive_getattr(module, name).data_ptr() in self.tied_params_map: + self.tied_params_names.add(name) + set_module_tensor_to_device(module, name, 'meta') + if not self.offload_buffers and self.execution_device is not None: + for (name, _) in module.named_buffers(recurse=self.place_submodules): + set_module_tensor_to_device(module, name, self.execution_device, tied_params_map=self.tied_params_map) + elif self.offload_buffers and self.execution_device is not None: + for name in get_non_persistent_buffers(module, recurse=self.place_submodules): + set_module_tensor_to_device(module, name, self.execution_device, tied_params_map=self.tied_params_map) + return module + + def pre_forward(self, module, *args, **kwargs): + if self.io_same_device: + self.input_device = find_device([args, kwargs]) + if self.offload: + self.tied_pointers_to_remove = set() + for (name, _) in named_module_tensors(module, include_buffers=self.offload_buffers, recurse=self.place_submodules, remove_non_persistent=True): + fp16_statistics = None + value = self.weights_map[name] + if 'weight' in name and name.replace('weight', 'SCB') in self.weights_map.keys(): + if value.dtype == torch.int8: + fp16_statistics = self.weights_map[name.replace('weight', 'SCB')] + if name in self.tied_params_names and value.data_ptr() not in self.tied_params_map: + self.tied_params_map[value.data_ptr()] = {} + if value is not None and self.tied_params_map is not None and (value.data_ptr() in self.tied_params_map) and (self.execution_device not in self.tied_params_map[value.data_ptr()]): + self.tied_pointers_to_remove.add((value.data_ptr(), self.execution_device)) + set_module_tensor_to_device(module, name, self.execution_device, value=value, fp16_statistics=fp16_statistics, tied_params_map=self.tied_params_map) + return (send_to_device(args, self.execution_device), send_to_device(kwargs, self.execution_device, skip_keys=self.skip_keys)) + + def post_forward(self, module, output): + if self.offload: + for (name, _) in named_module_tensors(module, include_buffers=self.offload_buffers, recurse=self.place_submodules, remove_non_persistent=True): + set_module_tensor_to_device(module, name, 'meta') + if type(module).__name__ == 'Linear8bitLt': + module.state.SCB = None + module.state.CxB = None + for (value_pointer, device) in self.tied_pointers_to_remove: + del self.tied_params_map[value_pointer][device] + self.tied_pointers_to_remove = set() + if self.io_same_device and self.input_device is not None: + output = send_to_device(output, self.input_device, skip_keys=self.skip_keys) + return output + + def detach_hook(self, module): + if self.offload: + for (name, device) in self.original_devices.items(): + if device != torch.device('meta'): + set_module_tensor_to_device(module, name, device, value=self.weights_map.get(name, None)) + return module + +def attach_execution_device_hook(module: torch.nn.Module, execution_device: Union[int, str, torch.device], skip_keys: Optional[Union[str, List[str]]]=None, preload_module_classes: Optional[List[str]]=None, tied_params_map: Optional[Dict[int, Dict[torch.device, torch.Tensor]]]=None): + if not hasattr(module, '_hf_hook') and len(module.state_dict()) > 0: + add_hook_to_module(module, AlignDevicesHook(execution_device, skip_keys=skip_keys, tied_params_map=tied_params_map)) + if preload_module_classes is not None and module.__class__.__name__ in preload_module_classes: + return + for child in module.children(): + attach_execution_device_hook(child, execution_device, skip_keys=skip_keys, tied_params_map=tied_params_map) + +def attach_align_device_hook(module: torch.nn.Module, execution_device: Optional[torch.device]=None, offload: bool=False, weights_map: Optional[Mapping]=None, offload_buffers: bool=False, module_name: str='', skip_keys: Optional[Union[str, List[str]]]=None, preload_module_classes: Optional[List[str]]=None, tied_params_map: Optional[Dict[int, Dict[torch.device, torch.Tensor]]]=None): + directs = named_module_tensors(module) + full_offload = offload and preload_module_classes is not None and (module.__class__.__name__ in preload_module_classes) + if len(list(directs)) > 0 or full_offload: + if weights_map is not None: + prefix = f'{module_name}.' if len(module_name) > 0 else '' + prefixed_weights_map = PrefixedDataset(weights_map, prefix) + else: + prefixed_weights_map = None + hook = AlignDevicesHook(execution_device=execution_device, offload=offload, weights_map=prefixed_weights_map, offload_buffers=offload_buffers, place_submodules=full_offload, skip_keys=skip_keys, tied_params_map=tied_params_map) + add_hook_to_module(module, hook, append=True) + if full_offload: + return + for (child_name, child) in module.named_children(): + child_name = f'{module_name}.{child_name}' if len(module_name) > 0 else child_name + attach_align_device_hook(child, execution_device=execution_device, offload=offload, weights_map=weights_map, offload_buffers=offload_buffers, module_name=child_name, preload_module_classes=preload_module_classes, skip_keys=skip_keys, tied_params_map=tied_params_map) + +def remove_hook_from_submodules(module: nn.Module): + remove_hook_from_module(module) + for child in module.children(): + remove_hook_from_submodules(child) + +def attach_align_device_hook_on_blocks(module: nn.Module, execution_device: Optional[Union[torch.device, Dict[str, torch.device]]]=None, offload: Union[bool, Dict[str, bool]]=False, weights_map: Mapping=None, offload_buffers: bool=False, module_name: str='', skip_keys: Optional[Union[str, List[str]]]=None, preload_module_classes: Optional[List[str]]=None, tied_params_map: Optional[Dict[int, Dict[torch.device, torch.Tensor]]]=None): + if not isinstance(execution_device, Mapping) and (not isinstance(offload, dict)): + if not offload: + hook = AlignDevicesHook(execution_device=execution_device, io_same_device=True, skip_keys=skip_keys, place_submodules=True, tied_params_map=tied_params_map) + add_hook_to_module(module, hook) + else: + attach_align_device_hook(module, execution_device=execution_device, offload=True, weights_map=weights_map, offload_buffers=offload_buffers, module_name=module_name, skip_keys=skip_keys, tied_params_map=tied_params_map) + return + if not isinstance(execution_device, Mapping): + execution_device = {key: execution_device for key in offload.keys()} + if not isinstance(offload, Mapping): + offload = {key: offload for key in execution_device.keys()} + if module_name in execution_device and module_name in offload and (not offload[module_name]): + hook = AlignDevicesHook(execution_device=execution_device[module_name], offload_buffers=offload_buffers, io_same_device=module_name == '', place_submodules=True, skip_keys=skip_keys, tied_params_map=tied_params_map) + add_hook_to_module(module, hook) + attach_execution_device_hook(module, execution_device[module_name], skip_keys=skip_keys, tied_params_map=tied_params_map) + elif module_name in execution_device and module_name in offload: + attach_align_device_hook(module, execution_device=execution_device[module_name], offload=True, weights_map=weights_map, offload_buffers=offload_buffers, module_name=module_name, skip_keys=skip_keys, preload_module_classes=preload_module_classes, tied_params_map=tied_params_map) + if not hasattr(module, '_hf_hook'): + hook = AlignDevicesHook(execution_device=execution_device[module_name], io_same_device=module_name == '', skip_keys=skip_keys, tied_params_map=tied_params_map) + add_hook_to_module(module, hook) + attach_execution_device_hook(module, execution_device[module_name], preload_module_classes=preload_module_classes, skip_keys=skip_keys, tied_params_map=tied_params_map) + elif module_name == '': + hook = AlignDevicesHook(execution_device=execution_device.get(''), io_same_device=True, skip_keys=skip_keys, tied_params_map=tied_params_map) + add_hook_to_module(module, hook) + for (child_name, child) in module.named_children(): + child_name = f'{module_name}.{child_name}' if len(module_name) > 0 else child_name + attach_align_device_hook_on_blocks(child, execution_device=execution_device, offload=offload, weights_map=weights_map, offload_buffers=offload_buffers, module_name=child_name, preload_module_classes=preload_module_classes, skip_keys=skip_keys, tied_params_map=tied_params_map) + +class CpuOffload(ModelHook): + + def __init__(self, execution_device: Optional[Union[str, int, torch.device]]=None, prev_module_hook: Optional['UserCpuOffloadHook']=None): + self.prev_module_hook = prev_module_hook + self.execution_device = execution_device if execution_device is not None else PartialState().default_device + + def init_hook(self, module): + return module.to('cpu') + + def pre_forward(self, module, *args, **kwargs): + if self.prev_module_hook is not None: + self.prev_module_hook.offload() + clear_device_cache() + module.to(self.execution_device) + return (send_to_device(args, self.execution_device), send_to_device(kwargs, self.execution_device)) + +class UserCpuOffloadHook: + + def __init__(self, model, hook): + self.model = model + self.hook = hook + + def offload(self): + self.hook.init_hook(self.model) + + def remove(self): + remove_hook_from_module(self.model) + +# File: accelerate-main/src/accelerate/inference.py +import math +from types import MethodType +from typing import Any, Dict, List, Optional, Tuple, Union +from .state import PartialState +from .utils import calculate_maximum_sizes, convert_bytes, copy_tensor_to_devices, ignorant_find_batch_size, infer_auto_device_map, is_pippy_available, pad_input_tensors, send_to_device + +def generate_device_map(model, num_processes: int=1, no_split_module_classes=None, max_memory: dict=None): + if num_processes == 1: + return infer_auto_device_map(model, no_split_module_classes=no_split_module_classes, clean_result=False) + if max_memory is None: + (model_size, shared) = calculate_maximum_sizes(model) + memory = (model_size + shared[0]) / num_processes + memory = convert_bytes(memory) + (value, ending) = memory.split(' ') + memory = math.ceil(float(value)) * 1.1 + memory = f'{memory} {ending}' + max_memory = {i: memory for i in range(num_processes)} + device_map = infer_auto_device_map(model, max_memory=max_memory, no_split_module_classes=no_split_module_classes, clean_result=False) + return device_map + +def find_pippy_batch_size(args, kwargs): + found_batch_size = None + if args is not None: + for arg in args: + found_batch_size = ignorant_find_batch_size(arg) + if found_batch_size is not None: + break + if kwargs is not None and found_batch_size is None: + for kwarg in kwargs.values(): + found_batch_size = ignorant_find_batch_size(kwarg) + if found_batch_size is not None: + break + return found_batch_size + +def build_pipeline(model, split_points, args, kwargs, num_chunks): + from torch.distributed.pipelining import ScheduleGPipe, SplitPoint, pipeline + state = PartialState() + split_spec = {split_point: SplitPoint.BEGINNING for split_point in split_points} + pipe = pipeline(model, mb_args=args, mb_kwargs=kwargs, split_spec=split_spec) + stage = pipe.build_stage(state.local_process_index, device=state.device) + schedule = ScheduleGPipe(stage, num_chunks) + return schedule + +def pippy_forward(forward, num_chunks, gather_output, *args, **kwargs): + state = PartialState() + output = None + if state.num_processes == 1: + output = forward(*args, **kwargs) + elif state.is_local_main_process: + found_batch_size = find_pippy_batch_size(args, kwargs) + if found_batch_size is None: + raise ValueError('Could not find batch size from args or kwargs') + elif found_batch_size != num_chunks: + args = pad_input_tensors(args, found_batch_size, num_chunks) + kwargs = pad_input_tensors(kwargs, found_batch_size, num_chunks) + forward(*args, **kwargs) + elif state.is_last_process: + output = forward() + else: + forward() + if gather_output: + output = copy_tensor_to_devices(output) + return output + +def prepare_pippy(model, split_points: Optional[Union[str, List[str]]]='auto', no_split_module_classes: Optional[List[str]]=None, example_args: Optional[Tuple[Any]]=(), example_kwargs: Optional[Dict[str, Any]]=None, num_chunks: Optional[int]=None, gather_output: Optional[bool]=False): + if not is_pippy_available(): + raise ImportError('Using `torch.distributed.pipelining` requires PyTorch 2.4.0 or later.') + state = PartialState() + example_args = send_to_device(example_args, 'cpu') + example_kwargs = send_to_device(example_kwargs, 'cpu') + if num_chunks is None: + num_chunks = state.num_processes + if split_points == 'auto': + device_map = generate_device_map(model, num_chunks, no_split_module_classes=no_split_module_classes) + split_points = [] + for i in range(1, num_chunks): + split_points.append(next((k for (k, v) in device_map.items() if v == i))) + model.hf_split_points = split_points + stage = build_pipeline(model, split_points, example_args, example_kwargs, num_chunks) + model._original_forward = model.forward + model._original_call = model.__call__ + model.pippy_stage = stage + model.hf_split_points = split_points + + def forward(*args, **kwargs): + return pippy_forward(stage.step, num_chunks, gather_output, *args, **kwargs) + model_forward = MethodType(forward, model) + forward.__wrapped__ = model_forward + model.forward = forward + return model + +# File: accelerate-main/src/accelerate/launchers.py +import os +import sys +import tempfile +import torch +from .state import AcceleratorState, PartialState +from .utils import PrecisionType, PrepareForLaunch, are_libraries_initialized, check_cuda_p2p_ib_support, get_gpu_info, is_mps_available, is_torch_version, patch_environment +from .utils.constants import ELASTIC_LOG_LINE_PREFIX_TEMPLATE_PYTORCH_VERSION + +def test_launch(): + _ = PartialState() + +def notebook_launcher(function, args=(), num_processes=None, mixed_precision='no', use_port='29500', master_addr='127.0.0.1', node_rank=0, num_nodes=1, rdzv_backend='static', rdzv_endpoint='', rdzv_conf=None, rdzv_id='none', max_restarts=0, monitor_interval=0.1, log_line_prefix_template=None): + in_colab = False + in_kaggle = False + if any((key.startswith('KAGGLE') for key in os.environ.keys())): + in_kaggle = True + elif 'IPython' in sys.modules: + in_colab = 'google.colab' in str(sys.modules['IPython'].get_ipython()) + try: + mixed_precision = PrecisionType(mixed_precision.lower()) + except ValueError: + raise ValueError(f'Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.') + if (in_colab or in_kaggle) and os.environ.get('TPU_NAME', None) is not None: + import torch_xla.distributed.xla_multiprocessing as xmp + if len(AcceleratorState._shared_state) > 0: + raise ValueError('To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside your training function. Restart your notebook and make sure no cells initializes an `Accelerator`.') + if num_processes is None: + num_processes = 8 + launcher = PrepareForLaunch(function, distributed_type='TPU') + print(f'Launching a training on {num_processes} TPU cores.') + xmp.spawn(launcher, args=args, nprocs=num_processes, start_method='fork') + elif in_colab and get_gpu_info()[1] < 2: + if torch.cuda.is_available(): + print('Launching training on one GPU.') + else: + print('Launching training on one CPU.') + function(*args) + else: + if num_processes is None: + raise ValueError('You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.') + if node_rank >= num_nodes: + raise ValueError('The node_rank must be less than the number of nodes.') + if num_processes > 1: + from torch.distributed.launcher.api import LaunchConfig, elastic_launch + from torch.multiprocessing import start_processes + from torch.multiprocessing.spawn import ProcessRaisedException + if len(AcceleratorState._shared_state) > 0: + raise ValueError('To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized inside your training function. Restart your notebook and make sure no cells initializes an `Accelerator`.') + problematic_imports = are_libraries_initialized('bitsandbytes') + if len(problematic_imports) > 0: + err = 'Could not start distributed process. Libraries known to initialize CUDA upon import have been imported already. Please keep these imports inside your training function to try and help with this:' + for lib_name in problematic_imports: + err += f'\n\t* `{lib_name}`' + raise RuntimeError(err) + patched_env = dict(nproc=num_processes, node_rank=node_rank, world_size=num_nodes * num_processes, master_addr=master_addr, master_port=use_port, mixed_precision=mixed_precision) + if not check_cuda_p2p_ib_support(): + patched_env['nccl_p2p_disable'] = '1' + patched_env['nccl_ib_disable'] = '1' + with patch_environment(**patched_env): + if os.environ.get('ACCELERATE_DEBUG_MODE', 'false').lower() == 'true': + launcher = PrepareForLaunch(test_launch, distributed_type='MULTI_GPU') + try: + start_processes(launcher, args=(), nprocs=num_processes, start_method='fork') + except ProcessRaisedException as e: + err = 'An issue was found when verifying a stable environment for the notebook launcher.' + if 'Cannot re-initialize CUDA in forked subprocess' in e.args[0]: + raise RuntimeError(f'{err}This likely stems from an outside import causing issues once the `notebook_launcher()` is called. Please review your imports and test them when running the `notebook_launcher()` to identify which one is problematic and causing CUDA to be initialized.') from e + else: + raise RuntimeError(f'{err} The following error was raised: {e}') from e + launcher = PrepareForLaunch(function, distributed_type='MULTI_GPU') + print(f'Launching training on {num_processes} GPUs.') + try: + if rdzv_conf is None: + rdzv_conf = {} + if rdzv_backend == 'static': + rdzv_conf['rank'] = node_rank + if not rdzv_endpoint: + rdzv_endpoint = f'{master_addr}:{use_port}' + launch_config_kwargs = dict(min_nodes=num_nodes, max_nodes=num_nodes, nproc_per_node=num_processes, run_id=rdzv_id, rdzv_endpoint=rdzv_endpoint, rdzv_backend=rdzv_backend, rdzv_configs=rdzv_conf, max_restarts=max_restarts, monitor_interval=monitor_interval, start_method='fork') + if is_torch_version('>=', ELASTIC_LOG_LINE_PREFIX_TEMPLATE_PYTORCH_VERSION): + launch_config_kwargs['log_line_prefix_template'] = log_line_prefix_template + elastic_launch(config=LaunchConfig(**launch_config_kwargs), entrypoint=function)(*args) + except ProcessRaisedException as e: + if 'Cannot re-initialize CUDA in forked subprocess' in e.args[0]: + raise RuntimeError('CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. This likely stems from an outside import causing issues once the `notebook_launcher()` is called. Please review your imports and test them when running the `notebook_launcher()` to identify which one is problematic and causing CUDA to be initialized.') from e + else: + raise RuntimeError(f'An issue was found when launching the training: {e}') from e + else: + if is_mps_available(): + os.environ['PYTORCH_ENABLE_MPS_FALLBACK'] = '1' + print('Launching training on MPS.') + elif torch.cuda.is_available(): + print('Launching training on one GPU.') + else: + print('Launching training on CPU.') + function(*args) + +def debug_launcher(function, args=(), num_processes=2): + from torch.multiprocessing import start_processes + with tempfile.NamedTemporaryFile() as tmp_file: + with patch_environment(world_size=num_processes, master_addr='127.0.0.1', master_port='29500', accelerate_mixed_precision='no', accelerate_debug_rdv_file=tmp_file.name, accelerate_use_cpu='yes'): + launcher = PrepareForLaunch(function, debug=True) + start_processes(launcher, args=args, nprocs=num_processes, start_method='fork') + +# File: accelerate-main/src/accelerate/local_sgd.py +import torch +from accelerate import Accelerator, DistributedType + +class LocalSGD: + + def __enter__(self): + if self.enabled: + self.model_sync_obj = self.model.no_sync() + self.model_sync_obj.__enter__() + return self + + def __exit__(self, type, value, tb): + if self.enabled: + self._sync_and_avg_model_params() + self.model_sync_obj.__exit__(type, value, tb) + + def __init__(self, accelerator: Accelerator, model: torch.nn.Module, local_sgd_steps: int, enabled: bool=True): + if accelerator.distributed_type not in [DistributedType.NO, DistributedType.MULTI_CPU, DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU]: + raise NotImplementedError('LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)') + self.enabled = enabled and accelerator.distributed_type != DistributedType.NO + self.num_steps = 0 + if self.enabled: + self.accelerator = accelerator + self.model = model + self.local_sgd_steps = local_sgd_steps + + def step(self): + self.num_steps += 1 + if not self.enabled: + return + if self.num_steps % self.local_sgd_steps == 0: + self._sync_and_avg_model_params() + + def _sync_and_avg_model_params(self): + self.accelerator.wait_for_everyone() + with self.accelerator.autocast(): + for param in self.model.parameters(): + param.data = self.accelerator.reduce(param.data, reduction='mean') + +# File: accelerate-main/src/accelerate/logging.py +import functools +import logging +import os +from .state import PartialState + +class MultiProcessAdapter(logging.LoggerAdapter): + + @staticmethod + def _should_log(main_process_only): + state = PartialState() + return not main_process_only or (main_process_only and state.is_main_process) + + def log(self, level, msg, *args, **kwargs): + if PartialState._shared_state == {}: + raise RuntimeError('You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility.') + main_process_only = kwargs.pop('main_process_only', True) + in_order = kwargs.pop('in_order', False) + kwargs.setdefault('stacklevel', 2) + if self.isEnabledFor(level): + if self._should_log(main_process_only): + (msg, kwargs) = self.process(msg, kwargs) + self.logger.log(level, msg, *args, **kwargs) + elif in_order: + state = PartialState() + for i in range(state.num_processes): + if i == state.process_index: + (msg, kwargs) = self.process(msg, kwargs) + self.logger.log(level, msg, *args, **kwargs) + state.wait_for_everyone() + + @functools.lru_cache(None) + def warning_once(self, *args, **kwargs): + self.warning(*args, **kwargs) + +def get_logger(name: str, log_level: str=None): + if log_level is None: + log_level = os.environ.get('ACCELERATE_LOG_LEVEL', None) + logger = logging.getLogger(name) + if log_level is not None: + logger.setLevel(log_level.upper()) + logger.root.setLevel(log_level.upper()) + return MultiProcessAdapter(logger, {}) + +# File: accelerate-main/src/accelerate/optimizer.py +import inspect +import torch +from .state import AcceleratorState, GradientState +from .utils import DistributedType, honor_type, is_lomo_available, is_torch_xla_available +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm + +def move_to_device(state, device): + if isinstance(state, (list, tuple)): + return honor_type(state, (move_to_device(t, device) for t in state)) + elif isinstance(state, dict): + return type(state)({k: move_to_device(v, device) for (k, v) in state.items()}) + elif isinstance(state, torch.Tensor): + return state.to(device) + return state + +class AcceleratedOptimizer(torch.optim.Optimizer): + + def __init__(self, optimizer, device_placement=True, scaler=None): + self.optimizer = optimizer + self.scaler = scaler + self.accelerator_state = AcceleratorState() + self.gradient_state = GradientState() + self.device_placement = device_placement + self._is_overflow = False + if self.scaler is not None: + self._accelerate_step_called = False + self._optimizer_original_step_method = self.optimizer.step + self._optimizer_patched_step_method = patch_optimizer_step(self, self.optimizer.step) + if device_placement: + state_dict = self.optimizer.state_dict() + if self.accelerator_state.distributed_type == DistributedType.XLA: + xm.send_cpu_data_to_device(state_dict, self.accelerator_state.device) + else: + state_dict = move_to_device(state_dict, self.accelerator_state.device) + self.optimizer.load_state_dict(state_dict) + + @property + def state(self): + return self.optimizer.state + + @state.setter + def state(self, state): + self.optimizer.state = state + + @property + def param_groups(self): + return self.optimizer.param_groups + + @param_groups.setter + def param_groups(self, param_groups): + self.optimizer.param_groups = param_groups + + @property + def defaults(self): + return self.optimizer.defaults + + @defaults.setter + def defaults(self, defaults): + self.optimizer.defaults = defaults + + def add_param_group(self, param_group): + self.optimizer.add_param_group(param_group) + + def load_state_dict(self, state_dict): + if self.accelerator_state.distributed_type == DistributedType.XLA and self.device_placement: + xm.send_cpu_data_to_device(state_dict, self.accelerator_state.device) + self.optimizer.load_state_dict(state_dict) + + def state_dict(self): + return self.optimizer.state_dict() + + def zero_grad(self, set_to_none=None): + if self.gradient_state.sync_gradients: + accept_arg = 'set_to_none' in inspect.signature(self.optimizer.zero_grad).parameters + if accept_arg: + if set_to_none is None: + set_to_none = True + self.optimizer.zero_grad(set_to_none=set_to_none) + else: + if set_to_none is not None: + raise ValueError('`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer.') + self.optimizer.zero_grad() + + def train(self): + if hasattr(self.optimizer, 'train') and callable(self.optimizer.train): + self.optimizer.train() + + def eval(self): + if hasattr(self.optimizer, 'eval') and callable(self.optimizer.eval): + self.optimizer.eval() + + def step(self, closure=None): + if is_lomo_available(): + from lomo_optim import AdaLomo, Lomo + if not self.gradient_state.is_xla_gradients_synced and self.accelerator_state.distributed_type == DistributedType.XLA: + gradients = xm._fetch_gradients(self.optimizer) + xm.all_reduce('sum', gradients, scale=1.0 / xm.xrt_world_size()) + self.gradient_state.is_xla_gradients_synced = True + if is_lomo_available(): + if isinstance(self.optimizer, (Lomo, AdaLomo)): + return + if self.gradient_state.sync_gradients: + if self.scaler is not None: + self.optimizer.step = self._optimizer_patched_step_method + self.scaler.step(self.optimizer, closure) + self.scaler.update() + if not self._accelerate_step_called: + self._is_overflow = True + else: + self._is_overflow = False + self.optimizer.step = self._optimizer_original_step_method + self._accelerate_step_called = False + else: + self.optimizer.step(closure) + if self.accelerator_state.distributed_type == DistributedType.XLA: + self.gradient_state.is_xla_gradients_synced = False + + def _switch_parameters(self, parameters_map): + for param_group in self.optimizer.param_groups: + param_group['params'] = [parameters_map.get(p, p) for p in param_group['params']] + + @property + def step_was_skipped(self): + return self._is_overflow + + def __getstate__(self): + _ignored_keys = ['_accelerate_step_called', '_optimizer_original_step_method', '_optimizer_patched_step_method'] + return {k: v for (k, v) in self.__dict__.items() if k not in _ignored_keys} + + def __setstate__(self, state): + self.__dict__.update(state) + if self.scaler is not None: + self._accelerate_step_called = False + self._optimizer_original_step_method = self.optimizer.step + self._optimizer_patched_step_method = patch_optimizer_step(self, self.optimizer.step) + +def patch_optimizer_step(accelerated_optimizer: AcceleratedOptimizer, method): + + def patched_step(*args, **kwargs): + accelerated_optimizer._accelerate_step_called = True + return method(*args, **kwargs) + return patched_step + +# File: accelerate-main/src/accelerate/scheduler.py +import warnings +from .state import AcceleratorState, GradientState +warnings.filterwarnings('ignore', category=UserWarning, module='torch.optim.lr_scheduler') + +class AcceleratedScheduler: + + def __init__(self, scheduler, optimizers, step_with_optimizer: bool=True, split_batches: bool=False): + self.scheduler = scheduler + self.optimizers = optimizers if isinstance(optimizers, (list, tuple)) else [optimizers] + self.split_batches = split_batches + self.step_with_optimizer = step_with_optimizer + self.gradient_state = GradientState() + + def step(self, *args, **kwargs): + if not self.step_with_optimizer: + self.scheduler.step(*args, **kwargs) + return + if not self.gradient_state.sync_gradients: + if self.gradient_state.adjust_scheduler: + self.scheduler._step_count += 1 + return + for opt in self.optimizers: + if opt.step_was_skipped: + return + if self.split_batches: + self.scheduler.step(*args, **kwargs) + else: + num_processes = AcceleratorState().num_processes + for _ in range(num_processes): + if hasattr(self.scheduler, 'total_steps'): + if self.scheduler._step_count <= self.scheduler.total_steps: + self.scheduler.step(*args, **kwargs) + else: + self.scheduler.step(*args, **kwargs) + + def get_last_lr(self): + return self.scheduler.get_last_lr() + + def state_dict(self): + return self.scheduler.state_dict() + + def load_state_dict(self, state_dict): + self.scheduler.load_state_dict(state_dict) + + def get_lr(self): + return self.scheduler.get_lr() + + def print_lr(self, *args, **kwargs): + return self.scheduler.print_lr(*args, **kwargs) + +# File: accelerate-main/src/accelerate/state.py +from __future__ import annotations +import logging +import os +import threading +import warnings +from contextlib import contextmanager +from functools import partial +from typing import Any, Callable, Optional +import torch +from .utils import DistributedType, DynamoBackend, GradientAccumulationPlugin, check_cuda_p2p_ib_support, check_fp8_capability, deepspeed_required, get_ccl_version, get_cpu_distributed_information, get_int_from_env, is_ccl_available, is_datasets_available, is_deepspeed_available, is_fp8_available, is_ipex_available, is_mlu_available, is_mps_available, is_musa_available, is_npu_available, is_torch_xla_available, is_xpu_available, parse_choice_from_env, parse_flag_from_env, set_numa_affinity +from .utils.dataclasses import SageMakerDistributedType +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm +if is_mlu_available(check_device=False): + import torch_mlu +if is_musa_available(check_device=False): + import torch_musa +if is_npu_available(check_device=False): + import torch_npu +logger = logging.getLogger(__name__) + +def is_initialized() -> bool: + return AcceleratorState._shared_state != {} + +def do_nothing(*args, **kwargs): + return None + +class ThreadLocalSharedDict(threading.local): + + def __init__(self, thread_local: bool=False): + self._storage = {} + + def __get__(self, obj, objtype=None): + return self._storage + + def __set__(self, obj, value): + self._storage = value +SharedDict = dict if not is_torch_xla_available() else ThreadLocalSharedDict + +class PartialState: + _shared_state = SharedDict() + _known_attrs = ['_cpu', '_mixed_precision', '_shared_state', 'backend', 'debug', 'device', 'distributed_type', 'fork_launched', 'local_process_index', 'num_processes', 'process_index'] + + def __init__(self, cpu: bool=False, **kwargs): + self.__dict__ = self._shared_state + if not self.initialized: + self._cpu = cpu + self.backend = None + env_device = os.environ.get('ACCELERATE_TORCH_DEVICE', None) + self.device = torch.device(env_device) if env_device is not None else None + self.debug = parse_flag_from_env('ACCELERATE_DEBUG_MODE') + use_sagemaker_dp = kwargs.pop('_use_sagemaker_dp', None) + dist_information = None + if use_sagemaker_dp is None: + use_sagemaker_dp = os.environ.get('ACCELERATE_USE_SAGEMAKER', 'false') == 'true' and os.environ.get('ACCELERATE_SAGEMAKER_DISTRIBUTED_TYPE') != SageMakerDistributedType.NO + original_backend = kwargs.pop('backend', None) + (backend, distributed_type) = self._prepare_backend(cpu, use_sagemaker_dp, original_backend) + if original_backend is not None and backend != original_backend: + raise ValueError(f'Your assigned backend {original_backend} is not avaliable, please use {backend}') + self.backend = backend + self.distributed_type = distributed_type + use_deepspeed = False + if not cpu and self.backend != 'xla': + if int(os.environ.get('LOCAL_RANK', -1)) != -1: + if os.environ.get('ACCELERATE_USE_DEEPSPEED', 'false') == 'true': + if not is_deepspeed_available(): + raise ImportError('DeepSpeed is not available => install it using `pip3 install deepspeed` or build it from source') + from deepspeed import comm as dist + if not dist.is_initialized(): + dist.init_distributed(dist_backend=self.backend, auto_mpi_discovery=False, **kwargs) + use_deepspeed = True + elif self.distributed_type not in (DistributedType.MULTI_XPU, DistributedType.MULTI_CPU) and (not torch.distributed.is_initialized()): + torch.distributed.init_process_group(backend=self.backend, **kwargs) + if self.distributed_type in (DistributedType.MULTI_XPU, DistributedType.MULTI_CPU): + dist_information = get_cpu_distributed_information() + os.environ['RANK'] = str(dist_information.rank) + os.environ['WORLD_SIZE'] = str(dist_information.world_size) + os.environ['LOCAL_RANK'] = str(dist_information.local_rank) + os.environ['LOCAL_WORLD_SIZE'] = str(dist_information.local_world_size) + if not os.environ.get('MASTER_PORT', None): + os.environ['MASTER_PORT'] = '29500' + if not os.environ.get('MASTER_ADDR', None) and dist_information.local_world_size != dist_information.world_size and (self.backend != 'mpi'): + raise ValueError("Tried to launch on distributed with multinode, but `MASTER_ADDR` env was not set, please try exporting rank 0's hostname as `MASTER_ADDR`") + kwargs['rank'] = dist_information.rank + kwargs['world_size'] = dist_information.world_size + if self.distributed_type == DistributedType.MULTI_CPU and get_int_from_env(['OMP_NUM_THREADS'], 0) == 0: + import psutil + num_cpu_threads_per_process = int(psutil.cpu_count(logical=False) / dist_information.local_world_size) + if num_cpu_threads_per_process == 0: + num_cpu_threads_per_process = 1 + torch.set_num_threads(num_cpu_threads_per_process) + warnings.warn(f'OMP_NUM_THREADS/MKL_NUM_THREADS unset, we set it at {num_cpu_threads_per_process} to improve oob performance.') + if not torch.distributed.is_initialized(): + torch.distributed.init_process_group(backend=self.backend, **kwargs) + if self.backend is None: + self.distributed_type = DistributedType.NO + self.num_processes = 1 + self.process_index = 0 + self.local_process_index = 0 + elif self.backend == 'xla': + self.set_device() + xm.set_replication(self.device, xm.get_xla_supported_devices()) + self.num_processes = xm.xrt_world_size() + self.process_index = xm.get_ordinal() + if is_torch_xla_available(check_is_tpu=True): + self.local_process_index = xm.get_local_ordinal() + else: + self.local_process_index = int(os.environ.get('LOCAL_RANK', -1)) + else: + self.num_processes = torch.distributed.get_world_size() + self.process_index = torch.distributed.get_rank() + self.local_process_index = int(os.environ.get('LOCAL_RANK', -1)) if dist_information is None else dist_information.local_rank + self.set_device() + if use_deepspeed: + self.distributed_type = DistributedType.DEEPSPEED + if parse_flag_from_env('ACCELERATE_CPU_AFFINITY', False): + set_numa_affinity(self.local_process_index) + if self.device.type == 'cuda' and (not check_cuda_p2p_ib_support()): + if 'NCCL_P2P_DISABLE' not in os.environ or 'NCCL_IB_DISABLE' not in os.environ: + raise NotImplementedError('Using RTX 4000 series doesn\'t support faster communication broadband via P2P or IB. Please set `NCCL_P2P_DISABLE="1"` and `NCCL_IB_DISABLE="1" or use `accelerate launch` which will do this automatically.') + self.fork_launched = parse_flag_from_env('FORK_LAUNCHED', 0) + + def __repr__(self) -> str: + return f"Distributed environment: {self.distributed_type}{(' Backend: ' + self.backend if self.backend else '')}\nNum processes: {self.num_processes}\nProcess index: {self.process_index}\nLocal process index: {self.local_process_index}\nDevice: {self.device}\n" + + @staticmethod + def _reset_state(): + PartialState._shared_state.clear() + + @property + def initialized(self) -> bool: + return self._shared_state != {} + + @property + def use_distributed(self): + return self.distributed_type != DistributedType.NO and self.num_processes > 1 + + @property + def is_last_process(self) -> bool: + return self.process_index == self.num_processes - 1 + + @property + def is_main_process(self) -> bool: + return self.process_index == 0 if self.distributed_type != DistributedType.MEGATRON_LM else self.is_last_process + + @property + def is_local_main_process(self) -> bool: + return self.local_process_index == 0 if self.distributed_type != DistributedType.MEGATRON_LM else self.is_last_process + + def wait_for_everyone(self): + if self.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU, DistributedType.MULTI_CPU, DistributedType.DEEPSPEED, DistributedType.FSDP): + torch.distributed.barrier() + elif self.distributed_type == DistributedType.XLA: + xm.rendezvous('accelerate.utils.wait_for_everyone') + + def _goes_first(self, is_main: bool): + if not is_main: + self.wait_for_everyone() + yield + if is_main: + self.wait_for_everyone() + + @contextmanager + def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool=False): + if self.num_processes == 1: + yield inputs + return + length = len(inputs) + if isinstance(inputs, dict): + length = len(inputs[list(inputs.keys())[0]]) + if not all((len(v) == length for v in inputs.values())): + raise ValueError('All values in the dictionary must have the same length') + (num_samples_per_process, num_extras) = divmod(length, self.num_processes) + start_index = self.process_index * num_samples_per_process + min(self.process_index, num_extras) + end_index = start_index + num_samples_per_process + (1 if self.process_index < num_extras else 0) + + def _split_values(inputs, start_index, end_index): + if isinstance(inputs, (list, tuple, torch.Tensor)): + if start_index >= len(inputs): + result = inputs[-1:] + else: + result = inputs[start_index:end_index] + if apply_padding: + if isinstance(result, torch.Tensor): + from accelerate.utils import pad_across_processes, send_to_device + tensorized_result = send_to_device(result, self.device) + result = pad_across_processes(tensorized_result, pad_index=inputs[-1]) + else: + result += [result[-1]] * (num_samples_per_process + 1 - len(result)) + return result + elif isinstance(inputs, dict): + for key in inputs.keys(): + inputs[key] = _split_values(inputs[key], start_index, end_index) + return inputs + else: + if is_datasets_available(): + from datasets import Dataset + if isinstance(inputs, Dataset): + if start_index >= len(inputs): + start_index = len(inputs) - 1 + if end_index > len(inputs): + end_index = len(inputs) + result_idcs = list(range(start_index, end_index)) + if apply_padding: + result_idcs += [end_index - 1] * (num_samples_per_process + 1 - len(result_idcs)) + return inputs.select(result_idcs) + return inputs + yield _split_values(inputs, start_index, end_index) + + @contextmanager + def main_process_first(self): + yield from self._goes_first(self.is_main_process) + + @contextmanager + def local_main_process_first(self): + yield from self._goes_first(self.is_local_main_process) + + def on_main_process(self, function: Callable[..., Any]=None): + if not self.initialized: + raise ValueError('The `PartialState` or `Accelerator` must be initialized before calling this function.') + if self.is_main_process or not self.use_distributed: + return function + return do_nothing + + def on_local_main_process(self, function: Callable[..., Any]=None): + if self.is_local_main_process or not self.use_distributed: + return function + return do_nothing + + def on_last_process(self, function: Callable[..., Any]): + if self.is_last_process or not self.use_distributed: + return function + return do_nothing + + def on_process(self, function: Callable[..., Any]=None, process_index: int=None): + if function is None: + return partial(self.on_process, process_index=process_index) + if self.process_index == process_index or not self.use_distributed: + return function + return do_nothing + + def on_local_process(self, function: Callable[..., Any]=None, local_process_index: int=None): + if function is None: + return partial(self.on_local_process, local_process_index=local_process_index) + if self.local_process_index == local_process_index or not self.use_distributed: + return function + return do_nothing + + def print(self, *args, **kwargs): + if self.is_local_main_process: + print(*args, **kwargs) + + @property + def default_device(self) -> torch.device: + if is_mps_available(): + os.environ['PYTORCH_ENABLE_MPS_FALLBACK'] = '1' + return torch.device('mps') + elif is_mlu_available(): + return torch.device('mlu') + elif is_musa_available(): + return torch.device('musa') + elif is_npu_available(): + return torch.device('npu') + elif torch.cuda.is_available(): + return torch.device('cuda') + elif is_xpu_available(): + return torch.device('xpu:0') + else: + return torch.device('cpu') + + def _prepare_backend(self, cpu: bool=False, sagemaker_dp=False, backend: str=None) -> tuple[str, DistributedType]: + distributed_type = None + if sagemaker_dp: + import smdistributed.dataparallel.torch.torch_smddp + backend = 'smddp' + distributed_type = DistributedType.MULTI_GPU + elif is_torch_xla_available(): + backend = 'xla' + distributed_type = DistributedType.XLA + elif int(os.environ.get('LOCAL_RANK', -1)) != -1 and (not cpu): + if is_mlu_available(): + backend = 'cncl' + distributed_type = DistributedType.MULTI_MLU + elif is_musa_available(): + backend = 'mccl' + distributed_type = DistributedType.MULTI_MUSA + elif is_npu_available(): + backend = 'hccl' + distributed_type = DistributedType.MULTI_NPU + elif torch.cuda.is_available(): + if backend is None: + backend = 'nccl' + distributed_type = DistributedType.MULTI_GPU + if distributed_type is None and (int(os.environ.get('LOCAL_RANK', -1)) != -1 or get_int_from_env(['PMI_SIZE', 'OMPI_COMM_WORLD_SIZE', 'MV2_COMM_WORLD_SIZE', 'WORLD_SIZE'], 1) > 1): + if not cpu and is_xpu_available(): + distributed_type = DistributedType.MULTI_XPU + else: + distributed_type = DistributedType.MULTI_CPU + if backend in (None, 'ccl') and is_ccl_available() and (get_int_from_env(['CCL_WORKER_COUNT'], 0) > 0 or distributed_type == DistributedType.MULTI_XPU): + if get_ccl_version() >= '1.12': + import oneccl_bindings_for_pytorch + else: + import torch_ccl + backend = 'ccl' + elif backend in (None, 'mpi') and torch.distributed.is_mpi_available(): + backend = 'mpi' + else: + backend = 'gloo' + if distributed_type is None: + distributed_type = DistributedType.NO + return (backend, distributed_type) + + def set_device(self): + if self.device is not None: + return + if self.distributed_type == DistributedType.NO: + self.device = torch.device('cpu') if self._cpu else self.default_device + return + device = str(self.distributed_type).split('.')[-1].replace('MULTI_', '').lower() + if device not in ('cpu', 'gpu', 'mlu', 'musa', 'npu', 'xpu', 'xla'): + raise ValueError(f"Can't set device for {self.distributed_type} ({device}), verify we should be calling `_set_device()` for it!") + if device == 'xla': + self.device = xm.xla_device() + else: + if device == 'gpu': + device = 'cuda' + device_module = getattr(torch, device) + device_index = self.local_process_index % device_module.device_count() + self.device = torch.device(device, device_index) + device_module.set_device(self.device) + + def destroy_process_group(self, group=None): + if self.fork_launched and group is None: + return + if torch.distributed.is_initialized(): + torch.distributed.destroy_process_group(group) + + def __getattr__(self, name: str): + if name in self._known_attrs: + raise AttributeError(f'`PartialState` object has no attribute `{name}`. This happens if `PartialState._reset_state()` was called and an `Accelerator` or `PartialState` was not reinitialized.') + raise AttributeError(f"'PartialState' object has no attribute '{name}'") + +class AcceleratorState: + _shared_state = SharedDict() + _known_attrs = PartialState._known_attrs + ['deepspeed_plugin', 'use_ipex', 'fsdp_plugin', 'megatron_lm_plugin', 'dynamo_plugin'] + + def __init__(self, mixed_precision: str=None, cpu: bool=False, dynamo_plugin=None, deepspeed_plugin=None, fsdp_plugin=None, megatron_lm_plugin=None, _from_accelerator: bool=False, **kwargs): + self.__dict__ = self._shared_state + if parse_flag_from_env('ACCELERATE_USE_CPU'): + cpu = True + if PartialState._shared_state == {}: + PartialState(cpu, **kwargs) + self.__dict__.update(PartialState._shared_state) + self._check_initialized(mixed_precision, cpu) + if not self.initialized: + self.deepspeed_plugins = None + self.use_ipex = None + mixed_precision = parse_choice_from_env('ACCELERATE_MIXED_PRECISION', 'no') if mixed_precision is None else mixed_precision.lower() + if mixed_precision == 'fp8': + if not is_fp8_available(): + raise ValueError('Using `fp8` precision requires `transformer_engine` or `MS-AMP` to be installed.') + elif not check_fp8_capability(): + logger.warning(f'The current device has compute capability of {torch.cuda.get_device_capability()} which is insufficient for FP8 mixed precision training (requires a GPU Hopper/Ada Lovelace or higher, compute capability of 8.9 or higher). Will use FP16 instead.') + mixed_precision = 'fp16' + self.dynamo_plugin = dynamo_plugin + if not _from_accelerator: + raise ValueError('Please make sure to properly initialize your accelerator via `accelerator = Accelerator()` before using any functionality from the `accelerate` library.') + self._mixed_precision = 'no' if self.distributed_type == DistributedType.DEEPSPEED else mixed_precision + if self.distributed_type == DistributedType.XLA and is_torch_xla_available(check_is_tpu=True): + if mixed_precision == 'bf16': + if os.environ.get('ACCELERATE_DOWNCAST_BF16'): + os.environ['XLA_USE_BF16'] = str(0) + os.environ['XLA_DOWNCAST_BF16'] = str(1) + self.downcast_bfloat = True + else: + os.environ['XLA_USE_BF16'] = str(1) + os.environ['XLA_DOWNCAST_BF16'] = str(0) + self.downcast_bfloat = False + elif os.environ.get('ACCELERATE_USE_DEEPSPEED', 'false') == 'true' and (not cpu): + self.deepspeed_plugins = deepspeed_plugin + self.distributed_type = DistributedType.DEEPSPEED + elif self.distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_MLU, DistributedType.MULTI_MUSA, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU]: + if os.environ.get('ACCELERATE_USE_FSDP', 'false') == 'true' or fsdp_plugin is not None: + self.distributed_type = DistributedType.FSDP + if self._mixed_precision != 'no': + fsdp_plugin.set_mixed_precision(self._mixed_precision) + self.fsdp_plugin = fsdp_plugin + if os.environ.get('ACCELERATE_USE_MEGATRON_LM', 'false') == 'true' and self.distributed_type not in [DistributedType.MULTI_XPU]: + self.distributed_type = DistributedType.MEGATRON_LM + megatron_lm_plugin.set_mixed_precision(self._mixed_precision) + self.megatron_lm_plugin = megatron_lm_plugin + elif self.distributed_type in [DistributedType.MULTI_CPU, DistributedType.MULTI_XPU, DistributedType.NO]: + if is_ipex_available(): + self.use_ipex = parse_flag_from_env('ACCELERATE_USE_IPEX', default=True) + else: + self.use_ipex = False + if self.dynamo_plugin.backend != DynamoBackend.NO and self._mixed_precision == 'no' and (self.device.type == 'cuda'): + torch.backends.cuda.matmul.allow_tf32 = True + if self.dynamo_plugin.backend != DynamoBackend.NO and self._mixed_precision == 'no' and (self.device.type == 'musa'): + torch.backends.musa.matmul.allow_tf32 = True + PartialState._shared_state['distributed_type'] = self.distributed_type + + @property + def initialized(self) -> bool: + return self._shared_state != PartialState._shared_state + + def __repr__(self): + repr = PartialState().__repr__() + f'\nMixed precision type: {self.mixed_precision}\n' + if self.distributed_type == DistributedType.DEEPSPEED: + repr += f'ds_config: {self.deepspeed_plugin.deepspeed_config}\n' + return repr + + def _check_initialized(self, mixed_precision=None, cpu=None): + if self.initialized: + err = 'AcceleratorState has already been initialized and cannot be changed, restart your runtime completely and pass `{flag}` to `Accelerator()`.' + if cpu and self.device.type != 'cpu': + raise ValueError(err.format(flag='cpu=True')) + if mixed_precision is not None and mixed_precision != self._mixed_precision and (self.distributed_type != DistributedType.DEEPSPEED): + raise ValueError(err.format(flag=f"mixed_precision='{mixed_precision}'")) + + @property + def mixed_precision(self): + if self.distributed_type == DistributedType.DEEPSPEED: + config = self.deepspeed_plugin.deepspeed_config + if config.get('fp16', {}).get('enabled', False): + mixed_precision = 'fp16' + elif config.get('bf16', {}).get('enabled', False): + mixed_precision = 'bf16' + else: + mixed_precision = 'no' + else: + mixed_precision = self._mixed_precision + return mixed_precision + + @staticmethod + def _reset_state(reset_partial_state: bool=False): + AcceleratorState._shared_state.clear() + if reset_partial_state: + PartialState._reset_state() + + def destroy_process_group(self, group=None): + PartialState().destroy_process_group(group) + + @property + def fork_launched(self): + return PartialState().fork_launched + + @property + def use_distributed(self): + return PartialState().use_distributed + + @property + def is_last_process(self) -> bool: + return PartialState().is_last_process + + @property + def is_main_process(self) -> bool: + return PartialState().is_main_process + + @property + def is_local_main_process(self) -> bool: + return PartialState().is_local_main_process + + def wait_for_everyone(self): + PartialState().wait_for_everyone() + + @contextmanager + def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool=False): + with PartialState().split_between_processes(inputs, apply_padding=apply_padding) as inputs: + yield inputs + + @contextmanager + def main_process_first(self): + with PartialState().main_process_first(): + yield + + @contextmanager + def local_main_process_first(self): + with PartialState().local_main_process_first(): + yield + + @property + def deepspeed_plugin(self): + if self.distributed_type != DistributedType.DEEPSPEED: + return None + from accelerate.utils.deepspeed import get_active_deepspeed_plugin + return get_active_deepspeed_plugin(self) + + @deepspeed_required + def get_deepspeed_plugin(self, name: str): + return self.deepspeed_plugins[name] + + @deepspeed_required + def select_deepspeed_plugin(self, name: str=None): + for (key, plugin) in self.deepspeed_plugins.items(): + if key != name: + plugin._unselect() + self.deepspeed_plugins[name].select(_from_accelerator_state=True) + + def print(self, *args, **kwargs): + PartialState().print(*args, **kwargs) + + def __getattr__(self, name: str): + if name in self._known_attrs: + raise AttributeError(f'`AcceleratorState` object has no attribute `{name}`. This happens if `AcceleratorState._reset_state()` was called and an `Accelerator` or `PartialState` was not reinitialized.') + raise AttributeError(f"'AcceleratorState' object has no attribute '{name}'") + +class GradientState: + _shared_state = SharedDict() + + def __init__(self, gradient_accumulation_plugin: Optional[GradientAccumulationPlugin]=None): + self.__dict__ = self._shared_state + if not self.initialized: + self.sync_gradients = True + self.active_dataloader = None + self.dataloader_references = [None] + self.plugin_kwargs = gradient_accumulation_plugin.to_kwargs() if gradient_accumulation_plugin is not None else {} + self._is_xla_gradients_synced = False + if gradient_accumulation_plugin is not None and self.plugin_kwargs != gradient_accumulation_plugin.to_kwargs(): + self.plugin_kwargs = gradient_accumulation_plugin.to_kwargs() + + @property + def num_steps(self) -> int: + return self.plugin_kwargs.get('num_steps', 1) + + @property + def adjust_scheduler(self) -> bool: + return self.plugin_kwargs.get('adjust_scheduler', False) + + @property + def sync_with_dataloader(self) -> bool: + return self.plugin_kwargs.get('sync_with_dataloader', True) + + @property + def initialized(self) -> bool: + return GradientState._shared_state != {} + + @property + def end_of_dataloader(self) -> bool: + if not self.in_dataloader: + return False + return self.active_dataloader.end_of_dataloader + + @property + def remainder(self) -> int: + if not self.in_dataloader: + return -1 + return self.active_dataloader.remainder + + def __repr__(self): + return f'Sync Gradients: {self.sync_gradients}\nAt end of current dataloader: {self.end_of_dataloader}\nExtra samples added: {self.remainder}\nGradient accumulation plugin: {self.plugin_kwargs}\n' + + @property + def is_xla_gradients_synced(self): + if parse_flag_from_env('ACCELERATE_USE_FSDP', default=False): + return True + return self._is_xla_gradients_synced + + @is_xla_gradients_synced.setter + def is_xla_gradients_synced(self, is_synced): + self._is_xla_gradients_synced = is_synced + + def _set_sync_gradients(self, sync_gradients): + self.sync_gradients = sync_gradients + if self.sync_gradients and is_torch_xla_available(check_is_tpu=True) and (PartialState().distributed_type == DistributedType.XLA): + xm.mark_step() + + def _add_dataloader(self, dataloader): + self.active_dataloader = dataloader + self.dataloader_references.append(self.active_dataloader) + + def _remove_dataloader(self, dataloader): + self.dataloader_references.remove(dataloader) + self.active_dataloader = self.dataloader_references[-1] + + @property + def in_dataloader(self) -> bool: + return self.active_dataloader is not None + + @staticmethod + def _reset_state(): + GradientState._shared_state.clear() + +# File: accelerate-main/src/accelerate/tracking.py +import json +import os +import time +from functools import wraps +from typing import Any, Dict, List, Optional, Union +import yaml +from .logging import get_logger +from .state import PartialState +from .utils import LoggerType, is_aim_available, is_clearml_available, is_comet_ml_available, is_dvclive_available, is_mlflow_available, is_tensorboard_available, is_wandb_available, listify +_available_trackers = [] +if is_tensorboard_available(): + _available_trackers.append(LoggerType.TENSORBOARD) +if is_wandb_available(): + _available_trackers.append(LoggerType.WANDB) +if is_comet_ml_available(): + _available_trackers.append(LoggerType.COMETML) +if is_aim_available(): + _available_trackers.append(LoggerType.AIM) +if is_mlflow_available(): + _available_trackers.append(LoggerType.MLFLOW) +if is_clearml_available(): + _available_trackers.append(LoggerType.CLEARML) +if is_dvclive_available(): + _available_trackers.append(LoggerType.DVCLIVE) +logger = get_logger(__name__) + +def on_main_process(function): + + @wraps(function) + def execute_on_main_process(self, *args, **kwargs): + if getattr(self, 'main_process_only', False): + return PartialState().on_main_process(function)(self, *args, **kwargs) + else: + return function(self, *args, **kwargs) + return execute_on_main_process + +def get_available_trackers(): + return _available_trackers + +class GeneralTracker: + main_process_only = True + + def __init__(self, _blank=False): + if not _blank: + err = '' + if not hasattr(self, 'name'): + err += '`name`' + if not hasattr(self, 'requires_logging_directory'): + if len(err) > 0: + err += ', ' + err += '`requires_logging_directory`' + if 'tracker' not in dir(self): + if len(err) > 0: + err += ', ' + err += '`tracker`' + if len(err) > 0: + raise NotImplementedError(f'The implementation for this tracker class is missing the following required attributes. Please define them in the class definition: {err}') + + def store_init_configuration(self, values: dict): + pass + + def log(self, values: dict, step: Optional[int], **kwargs): + pass + + def finish(self): + pass + +class TensorBoardTracker(GeneralTracker): + name = 'tensorboard' + requires_logging_directory = True + + @on_main_process + def __init__(self, run_name: str, logging_dir: Union[str, os.PathLike], **kwargs): + try: + from torch.utils import tensorboard + except ModuleNotFoundError: + import tensorboardX as tensorboard + super().__init__() + self.run_name = run_name + self.logging_dir = os.path.join(logging_dir, run_name) + self.writer = tensorboard.SummaryWriter(self.logging_dir, **kwargs) + logger.debug(f'Initialized TensorBoard project {self.run_name} logging to {self.logging_dir}') + logger.debug('Make sure to log any initial configurations with `self.store_init_configuration` before training!') + + @property + def tracker(self): + return self.writer + + @on_main_process + def store_init_configuration(self, values: dict): + self.writer.add_hparams(values, metric_dict={}) + self.writer.flush() + project_run_name = time.time() + dir_name = os.path.join(self.logging_dir, str(project_run_name)) + os.makedirs(dir_name, exist_ok=True) + with open(os.path.join(dir_name, 'hparams.yml'), 'w') as outfile: + try: + yaml.dump(values, outfile) + except yaml.representer.RepresenterError: + logger.error('Serialization to store hyperparameters failed') + raise + logger.debug('Stored initial configuration hyperparameters to TensorBoard and hparams yaml file') + + @on_main_process + def log(self, values: dict, step: Optional[int]=None, **kwargs): + values = listify(values) + for (k, v) in values.items(): + if isinstance(v, (int, float)): + self.writer.add_scalar(k, v, global_step=step, **kwargs) + elif isinstance(v, str): + self.writer.add_text(k, v, global_step=step, **kwargs) + elif isinstance(v, dict): + self.writer.add_scalars(k, v, global_step=step, **kwargs) + self.writer.flush() + logger.debug('Successfully logged to TensorBoard') + + @on_main_process + def log_images(self, values: dict, step: Optional[int], **kwargs): + for (k, v) in values.items(): + self.writer.add_images(k, v, global_step=step, **kwargs) + logger.debug('Successfully logged images to TensorBoard') + + @on_main_process + def finish(self): + self.writer.close() + logger.debug('TensorBoard writer closed') + +class WandBTracker(GeneralTracker): + name = 'wandb' + requires_logging_directory = False + main_process_only = False + + @on_main_process + def __init__(self, run_name: str, **kwargs): + super().__init__() + self.run_name = run_name + import wandb + self.run = wandb.init(project=self.run_name, **kwargs) + logger.debug(f'Initialized WandB project {self.run_name}') + logger.debug('Make sure to log any initial configurations with `self.store_init_configuration` before training!') + + @property + def tracker(self): + return self.run + + @on_main_process + def store_init_configuration(self, values: dict): + import wandb + wandb.config.update(values, allow_val_change=True) + logger.debug('Stored initial configuration hyperparameters to WandB') + + @on_main_process + def log(self, values: dict, step: Optional[int]=None, **kwargs): + self.run.log(values, step=step, **kwargs) + logger.debug('Successfully logged to WandB') + + @on_main_process + def log_images(self, values: dict, step: Optional[int]=None, **kwargs): + import wandb + for (k, v) in values.items(): + self.log({k: [wandb.Image(image) for image in v]}, step=step, **kwargs) + logger.debug('Successfully logged images to WandB') + + @on_main_process + def log_table(self, table_name: str, columns: List[str]=None, data: List[List[Any]]=None, dataframe: Any=None, step: Optional[int]=None, **kwargs): + import wandb + values = {table_name: wandb.Table(columns=columns, data=data, dataframe=dataframe)} + self.log(values, step=step, **kwargs) + + @on_main_process + def finish(self): + self.run.finish() + logger.debug('WandB run closed') + +class CometMLTracker(GeneralTracker): + name = 'comet_ml' + requires_logging_directory = False + + @on_main_process + def __init__(self, run_name: str, **kwargs): + super().__init__() + self.run_name = run_name + from comet_ml import Experiment + self.writer = Experiment(project_name=run_name, **kwargs) + logger.debug(f'Initialized CometML project {self.run_name}') + logger.debug('Make sure to log any initial configurations with `self.store_init_configuration` before training!') + + @property + def tracker(self): + return self.writer + + @on_main_process + def store_init_configuration(self, values: dict): + self.writer.log_parameters(values) + logger.debug('Stored initial configuration hyperparameters to CometML') + + @on_main_process + def log(self, values: dict, step: Optional[int]=None, **kwargs): + if step is not None: + self.writer.set_step(step) + for (k, v) in values.items(): + if isinstance(v, (int, float)): + self.writer.log_metric(k, v, step=step, **kwargs) + elif isinstance(v, str): + self.writer.log_other(k, v, **kwargs) + elif isinstance(v, dict): + self.writer.log_metrics(v, step=step, **kwargs) + logger.debug('Successfully logged to CometML') + + @on_main_process + def finish(self): + self.writer.end() + logger.debug('CometML run closed') + +class AimTracker(GeneralTracker): + name = 'aim' + requires_logging_directory = True + + @on_main_process + def __init__(self, run_name: str, logging_dir: Optional[Union[str, os.PathLike]]='.', **kwargs): + self.run_name = run_name + from aim import Run + self.writer = Run(repo=logging_dir, **kwargs) + self.writer.name = self.run_name + logger.debug(f'Initialized Aim project {self.run_name}') + logger.debug('Make sure to log any initial configurations with `self.store_init_configuration` before training!') + + @property + def tracker(self): + return self.writer + + @on_main_process + def store_init_configuration(self, values: dict): + self.writer['hparams'] = values + + @on_main_process + def log(self, values: dict, step: Optional[int], **kwargs): + for (key, value) in values.items(): + self.writer.track(value, name=key, step=step, **kwargs) + + @on_main_process + def log_images(self, values: dict, step: Optional[int]=None, kwargs: Optional[Dict[str, dict]]=None): + import aim + aim_image_kw = {} + track_kw = {} + if kwargs is not None: + aim_image_kw = kwargs.get('aim_image', {}) + track_kw = kwargs.get('track', {}) + for (key, value) in values.items(): + if isinstance(value, tuple): + (img, caption) = value + else: + (img, caption) = (value, '') + aim_image = aim.Image(img, caption=caption, **aim_image_kw) + self.writer.track(aim_image, name=key, step=step, **track_kw) + + @on_main_process + def finish(self): + self.writer.close() + +class MLflowTracker(GeneralTracker): + name = 'mlflow' + requires_logging_directory = False + + @on_main_process + def __init__(self, experiment_name: str=None, logging_dir: Optional[Union[str, os.PathLike]]=None, run_id: Optional[str]=None, tags: Optional[Union[Dict[str, Any], str]]=None, nested_run: Optional[bool]=False, run_name: Optional[str]=None, description: Optional[str]=None): + experiment_name = os.environ.get('MLFLOW_EXPERIMENT_NAME', experiment_name) + run_id = os.environ.get('MLFLOW_RUN_ID', run_id) + tags = os.environ.get('MLFLOW_TAGS', tags) + if isinstance(tags, str): + tags = json.loads(tags) + nested_run = os.environ.get('MLFLOW_NESTED_RUN', nested_run) + import mlflow + exps = mlflow.search_experiments(filter_string=f"name = '{experiment_name}'") + if len(exps) > 0: + if len(exps) > 1: + logger.warning('Multiple experiments with the same name found. Using first one.') + experiment_id = exps[0].experiment_id + else: + experiment_id = mlflow.create_experiment(name=experiment_name, artifact_location=logging_dir, tags=tags) + self.active_run = mlflow.start_run(run_id=run_id, experiment_id=experiment_id, run_name=run_name, nested=nested_run, tags=tags, description=description) + logger.debug(f'Initialized mlflow experiment {experiment_name}') + logger.debug('Make sure to log any initial configurations with `self.store_init_configuration` before training!') + + @property + def tracker(self): + return self.active_run + + @on_main_process + def store_init_configuration(self, values: dict): + import mlflow + for (name, value) in list(values.items()): + if len(str(value)) > mlflow.utils.validation.MAX_PARAM_VAL_LENGTH: + logger.warning_once(f'''Accelerate is attempting to log a value of "{value}" for key "{name}" as a parameter. MLflow's log_param() only accepts values no longer than {mlflow.utils.validation.MAX_PARAM_VAL_LENGTH} characters so we dropped this attribute.''') + del values[name] + values_list = list(values.items()) + for i in range(0, len(values_list), mlflow.utils.validation.MAX_PARAMS_TAGS_PER_BATCH): + mlflow.log_params(dict(values_list[i:i + mlflow.utils.validation.MAX_PARAMS_TAGS_PER_BATCH])) + logger.debug('Stored initial configuration hyperparameters to MLflow') + + @on_main_process + def log(self, values: dict, step: Optional[int]): + metrics = {} + for (k, v) in values.items(): + if isinstance(v, (int, float)): + metrics[k] = v + else: + logger.warning_once(f'''MLflowTracker is attempting to log a value of "{v}" of type {type(v)} for key "{k}" as a metric. MLflow's log_metric() only accepts float and int types so we dropped this attribute.''') + import mlflow + mlflow.log_metrics(metrics, step=step) + logger.debug('Successfully logged to mlflow') + + @on_main_process + def finish(self): + import mlflow + mlflow.end_run() + +class ClearMLTracker(GeneralTracker): + name = 'clearml' + requires_logging_directory = False + + @on_main_process + def __init__(self, run_name: str=None, **kwargs): + from clearml import Task + current_task = Task.current_task() + self._initialized_externally = False + if current_task: + self._initialized_externally = True + self.task = current_task + return + kwargs.setdefault('project_name', os.environ.get('CLEARML_PROJECT', run_name)) + kwargs.setdefault('task_name', os.environ.get('CLEARML_TASK', run_name)) + self.task = Task.init(**kwargs) + + @property + def tracker(self): + return self.task + + @on_main_process + def store_init_configuration(self, values: dict): + return self.task.connect_configuration(values) + + @on_main_process + def log(self, values: Dict[str, Union[int, float]], step: Optional[int]=None, **kwargs): + clearml_logger = self.task.get_logger() + for (k, v) in values.items(): + if not isinstance(v, (int, float)): + logger.warning_once(f'''Accelerator is attempting to log a value of "{v}" of type {type(v)} for key "{k}" as a scalar. This invocation of ClearML logger's report_scalar() is incorrect so we dropped this attribute.''') + continue + if step is None: + clearml_logger.report_single_value(name=k, value=v, **kwargs) + continue + (title, series) = ClearMLTracker._get_title_series(k) + clearml_logger.report_scalar(title=title, series=series, value=v, iteration=step, **kwargs) + + @on_main_process + def log_images(self, values: dict, step: Optional[int]=None, **kwargs): + clearml_logger = self.task.get_logger() + for (k, v) in values.items(): + (title, series) = ClearMLTracker._get_title_series(k) + clearml_logger.report_image(title=title, series=series, iteration=step, image=v, **kwargs) + + @on_main_process + def log_table(self, table_name: str, columns: List[str]=None, data: List[List[Any]]=None, dataframe: Any=None, step: Optional[int]=None, **kwargs): + to_report = dataframe + if dataframe is None: + if data is None: + raise ValueError('`ClearMLTracker.log_table` requires that `data` to be supplied if `dataframe` is `None`') + to_report = [columns] + data if columns else data + (title, series) = ClearMLTracker._get_title_series(table_name) + self.task.get_logger().report_table(title=title, series=series, table_plot=to_report, iteration=step, **kwargs) + + @on_main_process + def finish(self): + if self.task and (not self._initialized_externally): + self.task.close() + + @staticmethod + def _get_title_series(name): + for prefix in ['eval', 'test', 'train']: + if name.startswith(prefix + '_'): + return (name[len(prefix) + 1:], prefix) + return (name, 'train') + +class DVCLiveTracker(GeneralTracker): + name = 'dvclive' + requires_logging_directory = False + + @on_main_process + def __init__(self, run_name: Optional[str]=None, live: Optional[Any]=None, **kwargs): + from dvclive import Live + super().__init__() + self.live = live if live is not None else Live(**kwargs) + + @property + def tracker(self): + return self.live + + @on_main_process + def store_init_configuration(self, values: dict): + self.live.log_params(values) + + @on_main_process + def log(self, values: dict, step: Optional[int]=None, **kwargs): + from dvclive.plots import Metric + if step is not None: + self.live.step = step + for (k, v) in values.items(): + if Metric.could_log(v): + self.live.log_metric(k, v, **kwargs) + else: + logger.warning_once(f'''Accelerator attempted to log a value of "{v}" of type {type(v)} for key "{k}" as a scalar. This invocation of DVCLive's Live.log_metric() is incorrect so we dropped this attribute.''') + self.live.next_step() + + @on_main_process + def finish(self): + self.live.end() +LOGGER_TYPE_TO_CLASS = {'aim': AimTracker, 'comet_ml': CometMLTracker, 'mlflow': MLflowTracker, 'tensorboard': TensorBoardTracker, 'wandb': WandBTracker, 'clearml': ClearMLTracker, 'dvclive': DVCLiveTracker} + +def filter_trackers(log_with: List[Union[str, LoggerType, GeneralTracker]], logging_dir: Union[str, os.PathLike]=None): + loggers = [] + if log_with is not None: + if not isinstance(log_with, (list, tuple)): + log_with = [log_with] + if 'all' in log_with or LoggerType.ALL in log_with: + loggers = [o for o in log_with if issubclass(type(o), GeneralTracker)] + get_available_trackers() + else: + for log_type in log_with: + if log_type not in LoggerType and (not issubclass(type(log_type), GeneralTracker)): + raise ValueError(f'Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}') + if issubclass(type(log_type), GeneralTracker): + loggers.append(log_type) + else: + log_type = LoggerType(log_type) + if log_type not in loggers: + if log_type in get_available_trackers(): + tracker_init = LOGGER_TYPE_TO_CLASS[str(log_type)] + if tracker_init.requires_logging_directory: + if logging_dir is None: + raise ValueError(f'Logging with `{log_type}` requires a `logging_dir` to be passed in.') + loggers.append(log_type) + else: + logger.debug(f'Tried adding logger {log_type}, but package is unavailable in the system.') + return loggers +