
TREE_GUARD_MANAGER:
+- RootGuardManager
| +- LAMBDA_GUARD: torch._functorch.aot_autograd.utils.top_saved_tensors_hooks ids == None  # _dynamo/output_graph.py:1194 in init_ambient_guards
| +- GLOBAL_STATE: ___check_global_state() against {"allow_bf16_reduce":0,"allow_fp16_reduce":0,"allow_tf32":false,"autocast_state":{"cached_enabled":true,"dtype":[15,5,5,15,5,5,15,15,5,5],"enabled":[false,false,false,false,false,false,false,false,false,false]},"default_dtype":6,"deterministic_algorithms":false,"deterministic_algorithms_warn_only":false,"grad_mode":false,"num_threads":1,"torch_function":true,"torch_function_all_disabled":false}
| +- TORCH_FUNCTION_MODE_STACK: ___check_torch_function_mode_stack()
| +- DEFAULT_DEVICE: utils_device.CURRENT_DEVICE == None                           # _dynamo/output_graph.py:1181 in init_ambient_guards
| +- GuardManager: source=L['args'], accessed_by=FrameLocalsGuardAccessor(key='args', framelocals_idx=1), type=<class 'tuple'>, tag_safe=(False, False)
| | +- TYPE_MATCH: ___check_type_id(L['args'], 4343077424), type=<class 'tuple'>  # output = func(self, *args, **kwargs)  # transformers/utils/generic.py:903 in wrapper (HINT: type tuple)
| | +- LENGTH_CHECK: not L['args']                                                 # output = func(self, *args, **kwargs)  # transformers/utils/generic.py:903 in wrapper
| +- GuardManager: source=L['func'], accessed_by=FrameLocalsGuardAccessor(key='func', framelocals_idx=6), type=<class 'function'>, tag_safe=(False, False)
| | +- GuardManager: source=L['func'].__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(L['func'].__code__, 43119974016), type=<class 'code'>  # output = func(self, *args, **kwargs)  # transformers/utils/generic.py:903 in wrapper
| | +- GuardManager: source=L['func'].__defaults__, accessed_by=GetAttrGuardAccessor(__defaults__), type=<class 'tuple'>, tag_safe=(False, False)
| | | +- TYPE_MATCH: ___check_type_id(L['func'].__defaults__, 4343077424), type=<class 'tuple'>  # output = func(self, *args, **kwargs)  # transformers/utils/generic.py:903 in wrapper (HINT: type tuple)
| | | +- LENGTH_CHECK: len(L['func'].__defaults__) == 8                              # output = func(self, *args, **kwargs)  # transformers/utils/generic.py:903 in wrapper
| | +- GuardManager: source=L['func'], accessed_by=FuncDefaultsGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | +- GuardManager: source=L['func'].__defaults__[4], accessed_by=GetItemGuardAccessor(4), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | +- NONE_MATCH: L['func'].__defaults__[4] is None                             # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- GuardManager: source=L['func'].__defaults__[5], accessed_by=GetItemGuardAccessor(5), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | +- NONE_MATCH: L['func'].__defaults__[5] is None                             # if labels is not None:  # transformers/models/llama/modeling_llama.py:490 in forward
| +- GuardManager: source=L['kwargs'], accessed_by=FrameLocalsGuardAccessor(key='kwargs', framelocals_idx=2), type=<class 'dict'>, tag_safe=(False, False)
| | +- TYPE_MATCH: ___check_type_id(L['kwargs'], 4343051680), type=<class 'dict'>  # return_dict_passed = kwargs.pop("return_dict", return_dict)  # transformers/utils/generic.py:900 in wrapper (HINT: type dict)
| | +- DICT_LENGTH: len(L['kwargs']) == 7                                         # output = func(self, *args, **kwargs)  # transformers/utils/generic.py:903 in wrapper
| | +- GuardManager: source=L['kwargs']['input_ids'], accessed_by=DictGetItemGuardAccessor('input_ids'), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | +- TENSOR_MATCH: check_tensor(L['kwargs']['input_ids'], Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.int64, device=None, requires_grad=False, size=[1, 8], stride=[8, 1])  # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['input_ids'], '_dynamo_dynamic_indices') == False  # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['input_ids'], '_dynamo_weak_dynamic_indices') == False  # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['input_ids'], '_dynamo_unbacked_indices') == False  # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['input_ids'], '_dynamo_strict_unbacked_indices') == False  # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['input_ids'], '_dynamo_static_indices') == False  # if (input_ids is None) ^ (inputs_embeds is not None):  # transformers/models/llama/modeling_llama.py:385 in forward
| | | +- NO_TENSOR_ALIASING: check_no_aliasing(L['kwargs']['input_ids'], L['kwargs']['position_ids'], L['kwargs']['attention_mask'], L['kwargs']['past_key_values'].layers[0].keys, L['kwargs']['past_key_values'].layers[1].keys, L['kwargs']['past_key_values'].layers[0].values, L['kwargs']['past_key_values'].layers[1].values, L['kwargs']['past_key_values'].layers[0].cumulative_length, L['kwargs']['past_key_values'].layers[1].cumulative_length, L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'])
| | +- GuardManager: source=L['kwargs']['past_key_values'], accessed_by=DictGetItemGuardAccessor('past_key_values'), type=<class 'transformers.cache_utils.StaticCache'>, tag_safe=(False, False)
| | | +- TYPE_MATCH: ___check_type_id(L['kwargs']['past_key_values'], 43102883856), type=<class 'transformers.cache_utils.StaticCache'>  # if use_cache and past_key_values is None:  # transformers/models/llama/modeling_llama.py:391 in forward (HINT: type StaticCache)
| | | +- GuardManager: source=L['kwargs']['past_key_values'], accessed_by=GetAttrGuardAccessor(is_sliding), type=<class 'list'>, tag_safe=(False, False)
| | | +- GuardManager: source=L['kwargs']['past_key_values'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | +- DICT_CONTAINS: not ___dict_contains('update', L['kwargs']['past_key_values'].__dict__)  # key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)  # transformers/models/llama/modeling_llama.py:270 in forward
| | | +- GuardManager: source=L['kwargs']['past_key_values'].layers, accessed_by=GetAttrGuardAccessor(layers), type=<class 'list'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(L['kwargs']['past_key_values'].layers, 4343043024), type=<class 'list'>  # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding (HINT: type list)
| | | | +- LENGTH_CHECK: len(L['kwargs']['past_key_values'].layers) == 2               # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding
| | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0], accessed_by=ListGetItemGuardAccessor(0), type=<class 'transformers.cache_utils.StaticLayer'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['kwargs']['past_key_values'].layers[0], 43099531280), type=<class 'transformers.cache_utils.StaticLayer'>  # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding (HINT: type StaticLayer)
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0], accessed_by=GetAttrGuardAccessor(is_sliding), type=<class 'bool'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | +- DICT_CONTAINS: not ___dict_contains('is_sliding', L['kwargs']['past_key_values'].layers[0].__dict__)  # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding
| | | | | | +- DICT_CONTAINS: not ___dict_contains('update', L['kwargs']['past_key_values'].layers[0].__dict__)  # keys, values = self.layers[layer_idx].update(key_states, value_states, *args, **kwargs)  # transformers/cache_utils.py:993 in update
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0].keys, accessed_by=GetAttrGuardAccessor(keys), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | +- TENSOR_MATCH: check_tensor(L['kwargs']['past_key_values'].layers[0].keys, Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=False, size=[1, 2, 16, 8], stride=[256, 128, 8, 1])  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].keys, '_dynamo_dynamic_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].keys, '_dynamo_weak_dynamic_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].keys, '_dynamo_unbacked_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].keys, '_dynamo_strict_unbacked_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].keys, '_dynamo_static_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- NO_TENSOR_ALIASING
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0].device, accessed_by=GetAttrGuardAccessor(device), type=<class 'torch.device'>, tag_safe=(False, False)
| | | | | | +- EQUALS_MATCH: L['kwargs']['past_key_values'].layers[0].device == device(type='cpu')  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0].values, accessed_by=GetAttrGuardAccessor(values), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | +- TENSOR_MATCH: check_tensor(L['kwargs']['past_key_values'].layers[0].values, Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=False, size=[1, 2, 16, 8], stride=[256, 128, 8, 1])  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].values, '_dynamo_dynamic_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].values, '_dynamo_weak_dynamic_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].values, '_dynamo_unbacked_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].values, '_dynamo_strict_unbacked_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].values, '_dynamo_static_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- NO_TENSOR_ALIASING
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0].is_initialized, accessed_by=GetAttrGuardAccessor(is_initialized), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | +- TRUE_MATCH: L['kwargs']['past_key_values'].layers[0].is_initialized == True  # if not self.is_initialized:  # transformers/cache_utils.py:352 in update
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[0].cumulative_length, accessed_by=GetAttrGuardAccessor(cumulative_length), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | +- TENSOR_MATCH: check_tensor(L['kwargs']['past_key_values'].layers[0].cumulative_length, Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.int64, device=None, requires_grad=False, size=[1], stride=[1])  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].cumulative_length, '_dynamo_dynamic_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].cumulative_length, '_dynamo_weak_dynamic_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].cumulative_length, '_dynamo_unbacked_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].cumulative_length, '_dynamo_strict_unbacked_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[0].cumulative_length, '_dynamo_static_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- NO_TENSOR_ALIASING
| | | | | +- GuardManager: source=type(L['kwargs']['past_key_values'].layers[0]), accessed_by=TypeGuardAccessor, type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | | | | +- GuardManager: source=dict(type(L['kwargs']['past_key_values'].layers[0]).__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- GuardManager: source=dict(type(L['kwargs']['past_key_values'].layers[0]).__dict__)['is_sliding'], accessed_by=DictGetItemGuardAccessor('is_sliding'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | +- TYPE_MATCH: ___check_type_id(dict(type(L['kwargs']['past_key_values'].layers[0]).__dict__)['is_sliding'], 4342973520), type=<class 'bool'>  # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding (HINT: type bool)
| | | | | | | | +- FALSE_MATCH: dict(type(L['kwargs']['past_key_values'].layers[0]).__dict__)['is_sliding'] == False  # if hasattr(past_key_values, "is_sliding") and False in past_key_values.is_sliding:  # transformers/masking_utils.py:947 in create_causal_mask
| | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1], accessed_by=ListGetItemGuardAccessor(1), type=<class 'transformers.cache_utils.StaticLayer'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['kwargs']['past_key_values'].layers[1], 43099531280), type=<class 'transformers.cache_utils.StaticLayer'>  # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding (HINT: type StaticLayer)
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1], accessed_by=GetAttrGuardAccessor(is_sliding), type=<class 'bool'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | +- DICT_CONTAINS: not ___dict_contains('is_sliding', L['kwargs']['past_key_values'].layers[1].__dict__)  # return [getattr(layer, "is_sliding", False) for layer in self.layers]  # transformers/cache_utils.py:1218 in is_sliding
| | | | | | +- DICT_CONTAINS: not ___dict_contains('update', L['kwargs']['past_key_values'].layers[1].__dict__)  # keys, values = self.layers[layer_idx].update(key_states, value_states, *args, **kwargs)  # transformers/cache_utils.py:993 in update
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1].keys, accessed_by=GetAttrGuardAccessor(keys), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | +- TENSOR_MATCH: check_tensor(L['kwargs']['past_key_values'].layers[1].keys, Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=False, size=[1, 2, 16, 8], stride=[256, 128, 8, 1])  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].keys, '_dynamo_dynamic_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].keys, '_dynamo_weak_dynamic_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].keys, '_dynamo_unbacked_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].keys, '_dynamo_strict_unbacked_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].keys, '_dynamo_static_indices') == False  # self.keys.index_copy_(2, cache_position, key_states)  # transformers/cache_utils.py:363 in update
| | | | | | +- NO_TENSOR_ALIASING
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1].device, accessed_by=GetAttrGuardAccessor(device), type=<class 'torch.device'>, tag_safe=(False, False)
| | | | | | +- EQUALS_MATCH: L['kwargs']['past_key_values'].layers[1].device == device(type='cpu')  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1].values, accessed_by=GetAttrGuardAccessor(values), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | +- TENSOR_MATCH: check_tensor(L['kwargs']['past_key_values'].layers[1].values, Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=False, size=[1, 2, 16, 8], stride=[256, 128, 8, 1])  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].values, '_dynamo_dynamic_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].values, '_dynamo_weak_dynamic_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].values, '_dynamo_unbacked_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].values, '_dynamo_strict_unbacked_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].values, '_dynamo_static_indices') == False  # self.values.index_copy_(2, cache_position, value_states)  # transformers/cache_utils.py:364 in update
| | | | | | +- NO_TENSOR_ALIASING
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1].is_initialized, accessed_by=GetAttrGuardAccessor(is_initialized), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | +- TRUE_MATCH: L['kwargs']['past_key_values'].layers[1].is_initialized == True  # if not self.is_initialized:  # transformers/cache_utils.py:352 in update
| | | | | +- GuardManager: source=L['kwargs']['past_key_values'].layers[1].cumulative_length, accessed_by=GetAttrGuardAccessor(cumulative_length), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | +- TENSOR_MATCH: check_tensor(L['kwargs']['past_key_values'].layers[1].cumulative_length, Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.int64, device=None, requires_grad=False, size=[1], stride=[1])  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].cumulative_length, '_dynamo_dynamic_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].cumulative_length, '_dynamo_weak_dynamic_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].cumulative_length, '_dynamo_unbacked_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].cumulative_length, '_dynamo_strict_unbacked_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['past_key_values'].layers[1].cumulative_length, '_dynamo_static_indices') == False  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | | | +- NO_TENSOR_ALIASING
| | | +- GuardManager: source=L['kwargs']['past_key_values'].offloading, accessed_by=GetAttrGuardAccessor(offloading), type=<class 'bool'>, tag_safe=(False, False)
| | | | +- FALSE_MATCH: L['kwargs']['past_key_values'].offloading == False            # if self.offloading:  # transformers/cache_utils.py:988 in update
| | | +- GuardManager: source=L['kwargs']['past_key_values'].layer_class_to_replicate, accessed_by=GetAttrGuardAccessor(layer_class_to_replicate), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | +- NONE_MATCH: L['kwargs']['past_key_values'].layer_class_to_replicate is None  # if self.layer_class_to_replicate is not None:  # transformers/cache_utils.py:984 in update
| | | +- GuardManager: source=type(L['kwargs']['past_key_values']), accessed_by=TypeGuardAccessor, type=<class 'type'>, tag_safe=(False, False)
| | | | +- GuardManager: source=type(L['kwargs']['past_key_values']).__mro__, accessed_by=TypeMROGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=type(L['kwargs']['past_key_values']).__mro__[1], accessed_by=TupleGetItemGuardAccessor(1), type=<class 'type'>, tag_safe=(False, False)
| | | | | | +- GuardManager: source=dict(type(L['kwargs']['past_key_values']).__mro__[1].__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- GuardManager: source=dict(type(L['kwargs']['past_key_values']).__mro__[1].__dict__)['is_sliding'], accessed_by=DictGetItemGuardAccessor('is_sliding'), type=<class 'property'>, tag_safe=(False, False)
| | | | | | | | +- GuardManager: source=dict(type(L['kwargs']['past_key_values']).__mro__[1].__dict__)['is_sliding'].fget, accessed_by=GetAttrGuardAccessor(fget), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | +- GuardManager: source=dict(type(L['kwargs']['past_key_values']).__mro__[1].__dict__)['is_sliding'].fget.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['kwargs']['past_key_values']).__mro__[1].__dict__)['is_sliding'].fget.__code__, 4537139856), type=<class 'code'>  # if hasattr(past_key_values, "is_sliding") and False in past_key_values.is_sliding:  # transformers/masking_utils.py:947 in create_causal_mask
| | +- GuardManager: source=L['kwargs']['position_ids'], accessed_by=DictGetItemGuardAccessor('position_ids'), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | +- TENSOR_MATCH: check_tensor(L['kwargs']['position_ids'], Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.int64, device=None, requires_grad=False, size=[1, 8], stride=[8, 1])  # if position_ids is None:  # transformers/models/llama/modeling_llama.py:394 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['position_ids'], '_dynamo_dynamic_indices') == False  # if position_ids is None:  # transformers/models/llama/modeling_llama.py:394 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['position_ids'], '_dynamo_weak_dynamic_indices') == False  # if position_ids is None:  # transformers/models/llama/modeling_llama.py:394 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['position_ids'], '_dynamo_unbacked_indices') == False  # if position_ids is None:  # transformers/models/llama/modeling_llama.py:394 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['position_ids'], '_dynamo_strict_unbacked_indices') == False  # if position_ids is None:  # transformers/models/llama/modeling_llama.py:394 in forward
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['position_ids'], '_dynamo_static_indices') == False  # if position_ids is None:  # transformers/models/llama/modeling_llama.py:394 in forward
| | | +- NO_TENSOR_ALIASING
| | +- GuardManager: source=L['kwargs']['attention_mask'], accessed_by=DictGetItemGuardAccessor('attention_mask'), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | +- TENSOR_MATCH: check_tensor(L['kwargs']['attention_mask'], Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=False, size=[1, 1, 8, 16], stride=[128, 128, 16, 1])  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['attention_mask'], '_dynamo_dynamic_indices') == False  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['attention_mask'], '_dynamo_weak_dynamic_indices') == False  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['attention_mask'], '_dynamo_unbacked_indices') == False  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['attention_mask'], '_dynamo_strict_unbacked_indices') == False  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['kwargs']['attention_mask'], '_dynamo_static_indices') == False  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- NO_TENSOR_ALIASING
| | +- GuardManager: source=L['kwargs']['logits_to_keep'], accessed_by=DictGetItemGuardAccessor('logits_to_keep'), type=<class 'int'>, tag_safe=(False, False)
| | | +- EQUALS_MATCH: L['kwargs']['logits_to_keep'] == 1                            # slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep  # transformers/models/llama/modeling_llama.py:486 in forward
| | +- GuardManager: source=L['kwargs']['use_cache'], accessed_by=DictGetItemGuardAccessor('use_cache'), type=<class 'bool'>, tag_safe=(False, False)
| | | +- TRUE_MATCH: L['kwargs']['use_cache'] == True                              # elif kwargs.get(arg_name) is not None:  # transformers/utils/generic.py:985 in wrapper
| | +- GuardManager: source=L['kwargs']['return_dict'], accessed_by=DictGetItemGuardAccessor('return_dict'), type=<class 'bool'>, tag_safe=(False, False)
| | | +- TRUE_MATCH: L['kwargs']['return_dict'] == True                            # if return_dict_passed is not None:  # transformers/utils/generic.py:901 in wrapper
| +- GuardManager: source=G, accessed_by=GlobalsGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | +- GuardManager: source=G['fields'], accessed_by=DictGetItemGuardAccessor('fields'), type=<class 'function'>, tag_safe=(False, False)
| | | +- GuardManager: source=G['fields'].__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['fields'].__code__, 4442052144), type=<class 'code'>  # field_names = {field.name for field in fields(self)}  # transformers/utils/generic.py:493 in __setattr__
| | +- GuardManager: source=G['nullcontext'], accessed_by=DictGetItemGuardAccessor('nullcontext'), type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['nullcontext'], 43043201040), type=<class 'contextlib.nullcontext'>  # return nullcontext()  # transformers/utils/generic.py:245 in maybe_autocast
| | +- GuardManager: source=G['_is_torch_available'], accessed_by=DictGetItemGuardAccessor('_is_torch_available'), type=<class 'bool'>, tag_safe=(False, False)
| | | +- TRUE_MATCH: G['_is_torch_available'] == True                              # if not _is_torch_available:  # transformers/utils/generic.py:235 in maybe_autocast
| | +- GuardManager: source=G['__import_torch'], accessed_by=DictGetItemGuardAccessor('__import_torch'), type=<class 'module'>, tag_safe=(False, False)
| | | +- GuardManager: source=G['__import_torch'].compiler, accessed_by=GetAttrGuardAccessor(compiler), type=<class 'module'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch'].compiler, 4507075024), type=<class 'module'>  # return torch.compiler.is_compiling()  # transformers/utils/import_utils.py:1438 in is_torchdynamo_compiling
| | | | +- GuardManager: source=G['__import_torch'].compiler.is_compiling, accessed_by=GetAttrGuardAccessor(is_compiling), type=<class 'function'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=G['__import_torch'].compiler.is_compiling.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch'].compiler.is_compiling.__code__, 4512420688), type=<class 'code'>  # return torch.compiler.is_compiling()  # transformers/utils/import_utils.py:1438 in is_torchdynamo_compiling
| | | +- GuardManager: source=G['__import_torch'].is_autocast_enabled, accessed_by=GetAttrGuardAccessor(is_autocast_enabled), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch'].is_autocast_enabled, 4423923360), type=<class 'builtin_function_or_method'>  # if torch.is_autocast_enabled(device_type) or enabled:  # transformers/utils/generic.py:242 in maybe_autocast
| | +- GuardManager: source=G['__builtins_dict___4'], accessed_by=DictGetItemGuardAccessor('__builtins_dict___4'), type=<class 'dict'>, tag_safe=(False, False)
| | | +- GuardManager: source=G['__builtins_dict___4']['all'], accessed_by=DictGetItemGuardAccessor('all'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['all'], 4417493392), type=<class 'builtin_function_or_method'>  # if not all(field.default is None for field in class_fields[1:]):  # transformers/utils/generic.py:428 in __post_init__
| | | +- GuardManager: source=G['__builtins_dict___4']['int'], accessed_by=DictGetItemGuardAccessor('int'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['int'], 4343045584), type=<class 'int'>  # for i, module in enumerate(modules):  # nn/modules/container.py:504 in extend
| | | +- GuardManager: source=G['__builtins_dict___4']['len'], accessed_by=DictGetItemGuardAccessor('len'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['len'], 4417495392), type=<class 'builtin_function_or_method'>  # if len(collected_outputs) > 0:  # transformers/utils/output_capturing.py:245 in wrapper
| | | +- GuardManager: source=G['__builtins_dict___4']['set'], accessed_by=DictGetItemGuardAccessor('set'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['set'], 4343074392), type=<class 'set'>  # super().__setattr__("_non_persistent_buffers_set", set())  # nn/modules/module.py:508 in __init__
| | | +- GuardManager: source=G['__builtins_dict___4']['str'], accessed_by=DictGetItemGuardAccessor('str'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['str'], 4343097952), type=<class 'str'>  # capturable_flags = _CAN_RECORD_REGISTRY.get(str(self.__class__)) or {}  # transformers/utils/output_capturing.py:227 in wrapper
| | | +- GuardManager: source=G['__builtins_dict___4']['bool'], accessed_by=DictGetItemGuardAccessor('bool'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['bool'], 4342973520), type=<class 'bool'>  # if self.call_super_init is False and bool(kwargs):  # nn/modules/module.py:487 in __init__
| | | +- GuardManager: source=G['__builtins_dict___4']['iter'], accessed_by=DictGetItemGuardAccessor('iter'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['iter'], 4417495232), type=<class 'builtin_function_or_method'>  # return iter(self._modules.values())  # nn/modules/container.py:416 in __iter__
| | | +- GuardManager: source=G['__builtins_dict___4']['list'], accessed_by=DictGetItemGuardAccessor('list'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['list'], 4343043024), type=<class 'list'>  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__
| | | +- GuardManager: source=G['__builtins_dict___4']['type'], accessed_by=DictGetItemGuardAccessor('type'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['type'], 4343086320), type=<class 'type'>  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__
| | | +- GuardManager: source=G['__builtins_dict___4']['slice'], accessed_by=DictGetItemGuardAccessor('slice'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['slice'], 4343075976), type=<class 'slice'>  # if isinstance(idx, slice):  # nn/modules/container.py:389 in __getitem__
| | | +- GuardManager: source=G['__builtins_dict___4']['super'], accessed_by=DictGetItemGuardAccessor('super'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['super'], 4343085904), type=<class 'super'>  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | +- GuardManager: source=G['__builtins_dict___4']['getattr'], accessed_by=DictGetItemGuardAccessor('getattr'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['getattr'], 4417494512), type=<class 'builtin_function_or_method'>  # if getattr(self, "gradient_checkpointing", False) and self.training and arg_value:  # transformers/utils/generic.py:993 in wrapper
| | | +- GuardManager: source=G['__builtins_dict___4']['hasattr'], accessed_by=DictGetItemGuardAccessor('hasattr'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['hasattr'], 4417494672), type=<class 'builtin_function_or_method'>  # return_dict = self.config.return_dict if hasattr(self, "config") else True  # transformers/utils/generic.py:899 in wrapper
| | | +- GuardManager: source=G['__builtins_dict___4']['KeyError'], accessed_by=DictGetItemGuardAccessor('KeyError'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['KeyError'], 4343012232), type=<class 'KeyError'>  #   # <frozen _collections_abc>:812 in get
| | | +- GuardManager: source=G['__builtins_dict___4']['enumerate'], accessed_by=DictGetItemGuardAccessor('enumerate'), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['enumerate'], 4342994160), type=<class 'enumerate'>  # for i, module in enumerate(modules):  # nn/modules/container.py:504 in extend
| | | +- GuardManager: source=G['__builtins_dict___4']['isinstance'], accessed_by=DictGetItemGuardAccessor('isinstance'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['isinstance'], 4417495072), type=<class 'builtin_function_or_method'>  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- GuardManager: source=G['__builtins_dict___4']['issubclass'], accessed_by=DictGetItemGuardAccessor('issubclass'), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__builtins_dict___4']['issubclass'], 4417495152), type=<class 'builtin_function_or_method'>  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__
| | +- GuardManager: source=G['_register_model_output_pytree_node'], accessed_by=DictGetItemGuardAccessor('_register_model_output_pytree_node'), type=<class 'function'>, tag_safe=(False, False)
| | | +- GuardManager: source=G['_register_model_output_pytree_node'].__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['_register_model_output_pytree_node'].__code__, 4517049904), type=<class 'code'>  # _register_model_output_pytree_node(type(self))  # transformers/utils/generic.py:422 in __post_init__
| | +- GuardManager: source=G['__import_transformers_dot_activations'], accessed_by=DictGetItemGuardAccessor('__import_transformers_dot_activations'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_activations'], 4536238784), type=<class 'module'>  # return nn.functional.silu(input)  # transformers/activations.py:103 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_activations'].nn, accessed_by=GetAttrGuardAccessor(nn), type=<class 'module'>, tag_safe=(False, False)
| | | | +- OBJECT_ALIASING: G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].nn is G['__import_transformers_dot_activations'].nn  # return nn.functional.silu(input)  # transformers/activations.py:103 in forward
| | +- GuardManager: source=G['__import_transformers_dot_cache_utils'], accessed_by=DictGetItemGuardAccessor('__import_transformers_dot_cache_utils'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_cache_utils'], 4536920928), type=<class 'module'>  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | +- GuardManager: source=G['__import_transformers_dot_cache_utils'].torch, accessed_by=GetAttrGuardAccessor(torch), type=<class 'module'>, tag_safe=(False, False)
| | | | +- OBJECT_ALIASING: G['__import_transformers_dot_masking_utils'].torch is G['__import_transformers_dot_cache_utils'].torch  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | +- GuardManager: source=G['__import_transformers_dot_masking_utils'], accessed_by=DictGetItemGuardAccessor('__import_transformers_dot_masking_utils'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'], 4537224864), type=<class 'module'>  # _preprocess_mask_arguments(config, inputs_embeds, attention_mask, past_key_values, position_ids, layer_idx)  # transformers/masking_utils.py:953 in create_causal_mask
| | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch, accessed_by=GetAttrGuardAccessor(torch), type=<class 'module'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch, 4420422048), type=<class 'module'>  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | | +- OBJECT_ALIASING
| | | | +- OBJECT_ALIASING: G['__import_transformers_dot_masking_utils'].torch is G['__import_torch_dot_nn_dot_modules_dot_module'].torch  # torch._C._log_api_usage_once("python.nn_module")  # nn/modules/module.py:484 in __init__
| | | | +- OBJECT_ALIASING: G['__import_transformers_dot_masking_utils'].torch is G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].torch  # emb = torch.cat((freqs, freqs), dim=-1)  # transformers/models/llama/modeling_llama.py:131 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch._C, accessed_by=GetAttrGuardAccessor(_C), type=<class 'module'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch._C, 4423121424), type=<class 'module'>  # torch._C._log_api_usage_once("python.nn_module")  # nn/modules/module.py:484 in __init__
| | | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch._C._get_tracing_state, accessed_by=GetAttrGuardAccessor(_get_tracing_state), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch._C._get_tracing_state, 4435520352), type=<class 'builtin_function_or_method'>  # forward_call = (self._slow_forward if torch._C._get_tracing_state() else self.forward)  # nn/modules/module.py:1788 in _call_impl
| | | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch._C._log_api_usage_once, accessed_by=GetAttrGuardAccessor(_log_api_usage_once), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch._C._log_api_usage_once, 4423121584), type=<class 'builtin_function_or_method'>  # torch._C._log_api_usage_once("python.nn_module")  # nn/modules/module.py:484 in __init__
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch.cat, accessed_by=GetAttrGuardAccessor(cat), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch.cat, 4424154336), type=<class 'builtin_function_or_method'>  # emb = torch.cat((freqs, freqs), dim=-1)  # transformers/models/llama/modeling_llama.py:131 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch.rsqrt, accessed_by=GetAttrGuardAccessor(rsqrt), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch.rsqrt, 4424102224), type=<class 'builtin_function_or_method'>  # hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)  # transformers/models/llama/modeling_llama.py:66 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch.Tensor, accessed_by=GetAttrGuardAccessor(Tensor), type=<class 'torch._C._TensorMeta'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch.Tensor, 43083013136), type=<class 'torch.Tensor'>  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch.arange, accessed_by=GetAttrGuardAccessor(arange), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch.arange, 4424030768), type=<class 'builtin_function_or_method'>  # cache_position = torch.arange(kv_length, device=self.device) + self.cumulative_length  # transformers/cache_utils.py:357 in update
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch.matmul, accessed_by=GetAttrGuardAccessor(matmul), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].torch.matmul, 4424038448), type=<class 'builtin_function_or_method'>  # attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling  # transformers/models/llama/modeling_llama.py:212 in eager_attention_forward
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].torch.float32, accessed_by=GetAttrGuardAccessor(float32), type=<class 'torch.dtype'>, tag_safe=(False, False)
| | | | | +- EQUALS_MATCH: G['__import_transformers_dot_masking_utils'].torch.float32 == torch.float32  # hidden_states = hidden_states.to(torch.float32)  # transformers/models/llama/modeling_llama.py:64 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_masking_utils'].BlockMask, accessed_by=GetAttrGuardAccessor(BlockMask), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils'].BlockMask, 43118428176), type=<class 'torch.nn.attention.flex_attention.BlockMask'>  # if isinstance(attention_mask, (torch.Tensor, BlockMask)) and len(attention_mask.shape) == 4:  # transformers/masking_utils.py:840 in _preprocess_mask_arguments
| | | +- GuardManager: source=G['__import_transformers_dot_masking_utils']._preprocess_mask_arguments, accessed_by=GetAttrGuardAccessor(_preprocess_mask_arguments), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils']._preprocess_mask_arguments.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_masking_utils']._preprocess_mask_arguments.__code__, 43102911488), type=<class 'code'>  # _preprocess_mask_arguments(config, inputs_embeds, attention_mask, past_key_values, position_ids, layer_idx)  # transformers/masking_utils.py:953 in create_causal_mask
| | | | +- GuardManager: source=G['__import_transformers_dot_masking_utils']._preprocess_mask_arguments.__defaults__, accessed_by=GetAttrGuardAccessor(__defaults__), type=<class 'tuple'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_masking_utils']._preprocess_mask_arguments.__defaults__, 4343077424), type=<class 'tuple'>  # _preprocess_mask_arguments(config, inputs_embeds, attention_mask, past_key_values, position_ids, layer_idx)  # transformers/masking_utils.py:953 in create_causal_mask (HINT: type tuple)
| | | | | +- LENGTH_CHECK: len(G['__import_transformers_dot_masking_utils']._preprocess_mask_arguments.__defaults__) == 1  # _preprocess_mask_arguments(config, inputs_embeds, attention_mask, past_key_values, position_ids, layer_idx)  # transformers/masking_utils.py:953 in create_causal_mask
| | +- GuardManager: source=G['__import_torch_dot__dynamo_dot_polyfills'], accessed_by=DictGetItemGuardAccessor('__import_torch_dot__dynamo_dot_polyfills'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot__dynamo_dot_polyfills'], 4580562304), type=<class 'module'>  # super().__setattr__("_backward_pre_hooks", OrderedDict())  # nn/modules/module.py:509 in __init__
| | | +- GuardManager: source=G['__import_torch_dot__dynamo_dot_polyfills'].Mapping, accessed_by=GetAttrGuardAccessor(Mapping), type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot__dynamo_dot_polyfills'].Mapping, 43042173968), type=<class 'collections.abc.Mapping'>  # super().__setattr__("_backward_pre_hooks", OrderedDict())  # nn/modules/module.py:509 in __init__
| | | +- GuardManager: source=G['__import_torch_dot__dynamo_dot_polyfills'].Iterable, accessed_by=GetAttrGuardAccessor(Iterable), type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot__dynamo_dot_polyfills'].Iterable, 43042161680), type=<class 'collections.abc.Iterable'>  # super().__setattr__("_backward_pre_hooks", OrderedDict())  # nn/modules/module.py:509 in __init__
| | | | +- OBJECT_ALIASING: G['__import_torch_dot__dynamo_dot_polyfills'].Iterable is G['__import_torch_dot_nn_dot_modules_dot_container'].container_abcs.Iterable  # if not isinstance(modules, container_abcs.Iterable):  # nn/modules/container.py:498 in extend
| | | +- GuardManager: source=G['__import_torch_dot__dynamo_dot_polyfills'].mutable_mapping_update, accessed_by=GetAttrGuardAccessor(mutable_mapping_update), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_torch_dot__dynamo_dot_polyfills'].mutable_mapping_update.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot__dynamo_dot_polyfills'].mutable_mapping_update.__code__, 43119367168), type=<class 'code'>  # super().__setattr__("_backward_pre_hooks", OrderedDict())  # nn/modules/module.py:509 in __init__
| | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_linear'], accessed_by=DictGetItemGuardAccessor('__import_torch_dot_nn_dot_modules_dot_linear'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_linear'], 4450087168), type=<class 'module'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_linear'].F, accessed_by=GetAttrGuardAccessor(F), type=<class 'module'>, tag_safe=(False, False)
| | | | +- OBJECT_ALIASING: G['__import_torch_dot_nn_dot_modules_dot_sparse'].F is G['__import_torch_dot_nn_dot_modules_dot_linear'].F  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module'], accessed_by=DictGetItemGuardAccessor('__import_torch_dot_nn_dot_modules_dot_module'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_module'], 4445853616), type=<class 'module'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module'].Module, accessed_by=GetAttrGuardAccessor(Module), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_module'].Module, 43085244432), type=<class 'torch.nn.modules.module.Module'>  # if not isinstance(module, Module) and module is not None:  # nn/modules/module.py:652 in add_module
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module'].OrderedDict, accessed_by=GetAttrGuardAccessor(OrderedDict), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_module'].OrderedDict, 4343055520), type=<class 'collections.OrderedDict'>  # super().__setattr__("_backward_pre_hooks", OrderedDict())  # nn/modules/module.py:509 in __init__
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module']._global_forward_hooks, accessed_by=GetAttrGuardAccessor(_global_forward_hooks), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_torch_dot_nn_dot_modules_dot_module']._global_forward_hooks, 4343055520), type=<class 'collections.OrderedDict'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type OrderedDict)
| | | | +- DICT_LENGTH: not G['__import_torch_dot_nn_dot_modules_dot_module']._global_forward_hooks  # or _global_forward_hooks or _global_forward_pre_hooks):  # nn/modules/module.py:1793 in _call_impl
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module']._global_backward_hooks, accessed_by=GetAttrGuardAccessor(_global_backward_hooks), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_torch_dot_nn_dot_modules_dot_module']._global_backward_hooks, 4343055520), type=<class 'collections.OrderedDict'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type OrderedDict)
| | | | +- DICT_LENGTH: not G['__import_torch_dot_nn_dot_modules_dot_module']._global_backward_hooks  # or _global_backward_pre_hooks or _global_backward_hooks  # nn/modules/module.py:1792 in _call_impl
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module']._global_forward_pre_hooks, accessed_by=GetAttrGuardAccessor(_global_forward_pre_hooks), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_torch_dot_nn_dot_modules_dot_module']._global_forward_pre_hooks, 4343055520), type=<class 'collections.OrderedDict'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type OrderedDict)
| | | | +- DICT_LENGTH: not G['__import_torch_dot_nn_dot_modules_dot_module']._global_forward_pre_hooks  # or _global_forward_hooks or _global_forward_pre_hooks):  # nn/modules/module.py:1793 in _call_impl
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module']._global_backward_pre_hooks, accessed_by=GetAttrGuardAccessor(_global_backward_pre_hooks), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_torch_dot_nn_dot_modules_dot_module']._global_backward_pre_hooks, 4343055520), type=<class 'collections.OrderedDict'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type OrderedDict)
| | | | +- DICT_LENGTH: not G['__import_torch_dot_nn_dot_modules_dot_module']._global_backward_pre_hooks  # or _global_backward_pre_hooks or _global_backward_hooks  # nn/modules/module.py:1792 in _call_impl
| | | +- DictGuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module']._global_module_registration_hooks, accessed_by=GetAttrGuardAccessor(_global_module_registration_hooks), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_module'].torch, accessed_by=GetAttrGuardAccessor(torch), type=<class 'module'>, tag_safe=(False, False)
| | | | +- OBJECT_ALIASING
| | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'], accessed_by=DictGetItemGuardAccessor('__import_torch_dot_nn_dot_modules_dot_sparse'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'], 4454881600), type=<class 'module'>  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F, accessed_by=GetAttrGuardAccessor(F), type=<class 'module'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'].F, 4450087088), type=<class 'module'>  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | | | +- OBJECT_ALIASING
| | | | +- OBJECT_ALIASING: G['__import_torch_dot_nn_dot_modules_dot_sparse'].F is G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].nn.functional  # attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)  # transformers/models/llama/modeling_llama.py:216 in eager_attention_forward
| | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.silu, accessed_by=GetAttrGuardAccessor(silu), type=<class 'function'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.silu.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.silu.__code__, 4448040560), type=<class 'code'>  # return nn.functional.silu(input)  # transformers/activations.py:103 in forward
| | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.linear, accessed_by=GetAttrGuardAccessor(linear), type=<class 'builtin_function_or_method'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.linear, 4436197680), type=<class 'builtin_function_or_method'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.dropout, accessed_by=GetAttrGuardAccessor(dropout), type=<class 'function'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.dropout.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.dropout.__code__, 4449638784), type=<class 'code'>  # attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)  # transformers/models/llama/modeling_llama.py:217 in eager_attention_forward
| | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.softmax, accessed_by=GetAttrGuardAccessor(softmax), type=<class 'function'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.softmax.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.softmax.__code__, 4448316432), type=<class 'code'>  # attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)  # transformers/models/llama/modeling_llama.py:216 in eager_attention_forward
| | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.embedding, accessed_by=GetAttrGuardAccessor(embedding), type=<class 'function'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.embedding.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_sparse'].F.embedding.__code__, 43089917056), type=<class 'code'>  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_container'], accessed_by=DictGetItemGuardAccessor('__import_torch_dot_nn_dot_modules_dot_container'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_container'], 4453950192), type=<class 'module'>  # if not isinstance(modules, container_abcs.Iterable):  # nn/modules/container.py:498 in extend
| | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_container'].container_abcs, accessed_by=GetAttrGuardAccessor(container_abcs), type=<class 'module'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_torch_dot_nn_dot_modules_dot_container'].container_abcs, 4418088896), type=<class 'module'>  # if not isinstance(modules, container_abcs.Iterable):  # nn/modules/container.py:498 in extend
| | | | +- GuardManager: source=G['__import_torch_dot_nn_dot_modules_dot_container'].container_abcs.Iterable, accessed_by=GetAttrGuardAccessor(Iterable), type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | | | +- OBJECT_ALIASING
| | +- GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing'], accessed_by=DictGetItemGuardAccessor('__import_transformers_dot_utils_dot_output_capturing'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_utils_dot_output_capturing'], 4601528240), type=<class 'module'>  # capturable_flags = _CAN_RECORD_REGISTRY.get(str(self.__class__)) or {}  # transformers/utils/output_capturing.py:227 in wrapper
| | | +- GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing']._active_collector, accessed_by=GetAttrGuardAccessor(_active_collector), type=<class 'transformers.utils.output_capturing.CompileableContextVar'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_utils_dot_output_capturing']._active_collector, 43120093200), type=<class 'transformers.utils.output_capturing.CompileableContextVar'>  # output_token = _active_collector.set(collected_outputs)  # transformers/utils/output_capturing.py:248 in wrapper (HINT: type CompileableContextVar)
| | | | +- GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing']._active_collector.__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | +- DICT_CONTAINS: not ___dict_contains('set', G['__import_transformers_dot_utils_dot_output_capturing']._active_collector.__dict__)  # output_token = _active_collector.set(collected_outputs)  # transformers/utils/output_capturing.py:248 in wrapper
| | | | | +- DICT_CONTAINS: not ___dict_contains('reset', G['__import_transformers_dot_utils_dot_output_capturing']._active_collector.__dict__)  # _active_collector.reset(output_token)  # transformers/utils/output_capturing.py:255 in wrapper
| | | +- GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY, accessed_by=GetAttrGuardAccessor(_CAN_RECORD_REGISTRY), type=<class 'dict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY, 4343051680), type=<class 'dict'>  # capturable_flags = _CAN_RECORD_REGISTRY.get(str(self.__class__)) or {}  # transformers/utils/output_capturing.py:227 in wrapper (HINT: type dict)
| | | | +- DictGuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"], accessed_by=DictGetItemGuardAccessor("<class 'transformers.models.llama.modeling_llama.LlamaModel'>"), type=<class 'dict'>, tag_safe=(False, False)
| | | | | +- DICT_CONTAINS: not ___dict_contains('cross_attentions', G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"])  # if "cross_attentions" in capturable_flags:  # transformers/utils/output_capturing.py:233 in wrapper
| | | | | +- DICT_CONTAINS: not ___dict_contains('mask_decoder_attentions', G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"])  # if "mask_decoder_attentions" in capturable_flags:  # transformers/utils/output_capturing.py:238 in wrapper
| | | | | +- KeyValueManager pair at index=0
| | | | | | +- KeyManager: GuardManager: source=list(dict.keys(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]))[0], type=<class 'str'>, tag_safe=(False, False)
| | | | | | | +- EQUALS_MATCH: list(dict.keys(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]))[0] == 'hidden_states'  # for k in capturable_flags  # transformers/utils/output_capturing.py:230 in wrapper
| | | | | | +- ValueManager: GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]['hidden_states'], type=<class 'type'>, tag_safe=(False, False)
| | | | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]['hidden_states'], 43125402640), type=<class 'transformers.models.llama.modeling_llama.LlamaDecoderLayer'>  # capturable_flags = _CAN_RECORD_REGISTRY.get(str(self.__class__)) or {}  # transformers/utils/output_capturing.py:227 in wrapper
| | | | | +- KeyValueManager pair at index=1
| | | | | | +- KeyManager: GuardManager: source=list(dict.keys(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]))[1], type=<class 'str'>, tag_safe=(False, False)
| | | | | | | +- EQUALS_MATCH: list(dict.keys(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]))[1] == 'attentions'  # for k in capturable_flags  # transformers/utils/output_capturing.py:230 in wrapper
| | | | | | +- ValueManager: GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]['attentions'], type=<class 'type'>, tag_safe=(False, False)
| | | | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_utils_dot_output_capturing']._CAN_RECORD_REGISTRY["<class 'transformers.models.llama.modeling_llama.LlamaModel'>"]['attentions'], 43125401616), type=<class 'transformers.models.llama.modeling_llama.LlamaAttention'>  # capturable_flags = _CAN_RECORD_REGISTRY.get(str(self.__class__)) or {}  # transformers/utils/output_capturing.py:227 in wrapper
| | | +- GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing'].is_torchdynamo_compiling, accessed_by=GetAttrGuardAccessor(is_torchdynamo_compiling), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_utils_dot_output_capturing'].is_torchdynamo_compiling.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_utils_dot_output_capturing'].is_torchdynamo_compiling.__code__, 4528883056), type=<class 'code'>  # if is_torchdynamo_compiling():  # transformers/utils/output_capturing.py:81 in set
| | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'], accessed_by=DictGetItemGuardAccessor('__import_transformers_dot_models_dot_llama_dot_modeling_llama'), type=<class 'module'>, tag_safe=(False, False)
| | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'], 4598521968), type=<class 'module'>  # causal_mask = create_causal_mask(  # transformers/models/llama/modeling_llama.py:399 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].nn, accessed_by=GetAttrGuardAccessor(nn), type=<class 'module'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].nn, 4445848576), type=<class 'module'>  # attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)  # transformers/models/llama/modeling_llama.py:216 in eager_attention_forward
| | | | +- OBJECT_ALIASING
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].nn.functional, accessed_by=GetAttrGuardAccessor(functional), type=<class 'module'>, tag_safe=(False, False)
| | | | | +- OBJECT_ALIASING
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].repeat_kv, accessed_by=GetAttrGuardAccessor(repeat_kv), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].repeat_kv.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].repeat_kv.__code__, 4596381392), type=<class 'code'>  # key_states = repeat_kv(key, module.num_key_value_groups)  # transformers/models/llama/modeling_llama.py:209 in eager_attention_forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].rotate_half, accessed_by=GetAttrGuardAccessor(rotate_half), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].rotate_half.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].rotate_half.__code__, 4596526832), type=<class 'code'>  # q_embed = (q * cos) + (rotate_half(q) * sin)  # transformers/models/llama/modeling_llama.py:166 in apply_rotary_pos_emb
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].maybe_autocast, accessed_by=GetAttrGuardAccessor(maybe_autocast), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].maybe_autocast.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].maybe_autocast.__code__, 4517169952), type=<class 'code'>  # with maybe_autocast(device_type=device_type, enabled=False):  # Force float32  # transformers/models/llama/modeling_llama.py:129 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].maybe_autocast.__defaults__, accessed_by=GetAttrGuardAccessor(__defaults__), type=<class 'tuple'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].maybe_autocast.__defaults__, 4343077424), type=<class 'tuple'>  # with maybe_autocast(device_type=device_type, enabled=False):  # Force float32  # transformers/models/llama/modeling_llama.py:129 in forward (HINT: type tuple)
| | | | | +- LENGTH_CHECK: len(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].maybe_autocast.__defaults__) == 3  # with maybe_autocast(device_type=device_type, enabled=False):  # Force float32  # transformers/models/llama/modeling_llama.py:129 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].create_causal_mask, accessed_by=GetAttrGuardAccessor(create_causal_mask), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].create_causal_mask.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].create_causal_mask.__code__, 43102921472), type=<class 'code'>  # causal_mask = create_causal_mask(  # transformers/models/llama/modeling_llama.py:399 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].create_causal_mask.__defaults__, accessed_by=GetAttrGuardAccessor(__defaults__), type=<class 'tuple'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].create_causal_mask.__defaults__, 4343077424), type=<class 'tuple'>  # causal_mask = create_causal_mask(  # transformers/models/llama/modeling_llama.py:399 in forward (HINT: type tuple)
| | | | | +- LENGTH_CHECK: len(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].create_causal_mask.__defaults__) == 4  # causal_mask = create_causal_mask(  # transformers/models/llama/modeling_llama.py:399 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb, accessed_by=GetAttrGuardAccessor(apply_rotary_pos_emb), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__code__, 4596527184), type=<class 'code'>  # query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)  # transformers/models/llama/modeling_llama.py:267 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__defaults__, accessed_by=GetAttrGuardAccessor(__defaults__), type=<class 'tuple'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__defaults__, 4343077424), type=<class 'tuple'>  # query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)  # transformers/models/llama/modeling_llama.py:267 in forward (HINT: type tuple)
| | | | | +- LENGTH_CHECK: len(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__defaults__) == 1  # query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)  # transformers/models/llama/modeling_llama.py:267 in forward
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb, accessed_by=FuncDefaultsGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__defaults__[0], accessed_by=GetItemGuardAccessor(0), type=<class 'int'>, tag_safe=(False, False)
| | | | | | +- EQUALS_MATCH: G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].apply_rotary_pos_emb.__defaults__[0] == 1  # cos = cos.unsqueeze(unsqueeze_dim)  # transformers/models/llama/modeling_llama.py:164 in apply_rotary_pos_emb
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].CausalLMOutputWithPast, accessed_by=GetAttrGuardAccessor(CausalLMOutputWithPast), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].CausalLMOutputWithPast, 43120012304), type=<class 'transformers.modeling_outputs.CausalLMOutputWithPast'>  # return CausalLMOutputWithPast(  # transformers/models/llama/modeling_llama.py:493 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS, accessed_by=GetAttrGuardAccessor(ALL_ATTENTION_FUNCTIONS), type=<class 'transformers.modeling_utils.AttentionInterface'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS, 43120098320), type=<class 'transformers.modeling_utils.AttentionInterface'>  # attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(  # transformers/models/llama/modeling_llama.py:272 in forward (HINT: type AttentionInterface)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS.__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | +- DICT_CONTAINS: not ___dict_contains('get_interface', G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS.__dict__)  # attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(  # transformers/models/llama/modeling_llama.py:272 in forward
| | | | | +- DICT_CONTAINS: not ___dict_contains('__getitem__', G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS.__dict__)  #   # <frozen _collections_abc>:811 in get
| | | | | +- DICT_CONTAINS: not ___dict_contains('_global_mapping', G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS.__dict__)  # return self._global_mapping[key]  # transformers/utils/generic.py:1071 in __getitem__
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS._local_mapping, accessed_by=GetAttrGuardAccessor(_local_mapping), type=<class 'dict'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS._local_mapping, 4343051680), type=<class 'dict'>  # if key in self._local_mapping:  # transformers/utils/generic.py:1069 in __getitem__ (HINT: type dict)
| | | | | +- DICT_LENGTH: not G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS._local_mapping  # if key in self._local_mapping:  # transformers/utils/generic.py:1069 in __getitem__
| | | | +- GuardManager: source=type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS), accessed_by=TypeGuardAccessor, type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__mro__, accessed_by=TypeMROGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | +- GuardManager: source=type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__mro__[3], accessed_by=TupleGetItemGuardAccessor(3), type=<class 'abc.ABCMeta'>, tag_safe=(False, False)
| | | | | | | +- GuardManager: source=type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__mro__[3].get, accessed_by=GetAttrGuardAccessor(get), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | +- GuardManager: source=type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__mro__[3].get.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | +- ID_MATCH: ___check_obj_id(type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__mro__[3].get.__code__, 4418117936), type=<class 'code'>  # return super().get(attn_implementation, default)  # transformers/modeling_utils.py:5106 in get_interface
| | | | | +- GuardManager: source=dict(type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | +- GuardManager: source=dict(type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__dict__)['_global_mapping'], accessed_by=DictGetItemGuardAccessor('_global_mapping'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- TYPE_MATCH: ___check_type_id(dict(type(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].ALL_ATTENTION_FUNCTIONS).__dict__)['_global_mapping'], 4343051680), type=<class 'dict'>  # return self._global_mapping[key]  # transformers/utils/generic.py:1071 in __getitem__ (HINT: type dict)
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].BaseModelOutputWithPast, accessed_by=GetAttrGuardAccessor(BaseModelOutputWithPast), type=<class 'type'>, tag_safe=(False, False)
| | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].BaseModelOutputWithPast, 43120001040), type=<class 'transformers.modeling_outputs.BaseModelOutputWithPast'>  # return BaseModelOutputWithPast(  # transformers/models/llama/modeling_llama.py:422 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].eager_attention_forward, accessed_by=GetAttrGuardAccessor(eager_attention_forward), type=<class 'function'>, tag_safe=(False, False)
| | | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].eager_attention_forward.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | +- ID_MATCH: ___check_obj_id(G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].eager_attention_forward.__code__, 42984509952), type=<class 'code'>  # attn_output, attn_weights = attention_interface(  # transformers/models/llama/modeling_llama.py:276 in forward
| | | +- GuardManager: source=G['__import_transformers_dot_models_dot_llama_dot_modeling_llama'].torch, accessed_by=GetAttrGuardAccessor(torch), type=<class 'module'>, tag_safe=(False, False)
| | | | +- OBJECT_ALIASING
| +- GuardManager: source=L['self'], accessed_by=FrameLocalsGuardAccessor(key='self', framelocals_idx=0), type=<class 'transformers.models.llama.modeling_llama.LlamaForCausalLM'>, tag_safe=(False, False)
| | +- TYPE_MATCH: ___check_type_id(L['self'], 43125405712), type=<class 'transformers.models.llama.modeling_llama.LlamaForCausalLM'>  # return_dict = self.config.return_dict if hasattr(self, "config") else True  # transformers/utils/generic.py:899 in wrapper (HINT: type LlamaForCausalLM)
| | +- GuardManager: source=L['self'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | +- GuardManager: source=L['self'].config, accessed_by=DictGetItemGuardAccessor('config'), type=<class 'transformers.models.llama.configuration_llama.LlamaConfig'>, tag_safe=(False, False)
| | | | +- NO_HASATTR: not hasattr(L['self'].config, 'vision_feature_layer')         # arg_value = getattr(self.config, arg_name, None)  # transformers/utils/generic.py:988 in wrapper
| | | | +- NO_HASATTR: not hasattr(L['self'].config, 'vision_feature_select_strategy')  # arg_value = getattr(self.config, arg_name, None)  # transformers/utils/generic.py:988 in wrapper
| | | | +- NO_HASATTR: not hasattr(L['self'].config, 'vision_aspect_ratio')          # arg_value = getattr(self.config, arg_name, None)  # transformers/utils/generic.py:988 in wrapper
| | | | +- NO_HASATTR: not hasattr(L['self'].config, 'is_causal')                    # is_causal = kwargs.get("is_causal", getattr(self.config, "is_causal", None))  # transformers/utils/generic.py:1013 in wrapper
| | | | +- TYPE_MATCH: ___check_type_id(L['self'].config, 43102838800), type=<class 'transformers.models.llama.configuration_llama.LlamaConfig'>  # return_dict = self.config.return_dict if hasattr(self, "config") else True  # transformers/utils/generic.py:899 in wrapper (HINT: type LlamaConfig)
| | | | +- OBJECT_ALIASING: L['self'].config is L['self']._modules['model'].config        # arg_value = getattr(self.config, arg_name, None)  # transformers/utils/generic.py:988 in wrapper
| | | | +- OBJECT_ALIASING: L['self'].config is L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].config  # self.config._attn_implementation, eager_attention_forward  # transformers/models/llama/modeling_llama.py:273 in forward
| | | | +- OBJECT_ALIASING: L['self'].config is L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].config  # self.config._attn_implementation, eager_attention_forward  # transformers/models/llama/modeling_llama.py:273 in forward
| | | | +- GuardManager: source=L['self'].config, accessed_by=GetAttrGuardAccessor(return_dict), type=<class 'bool'>, tag_safe=(False, False)
| | | | +- GuardManager: source=L['self'].config, accessed_by=GetAttrGuardAccessor(output_hidden_states), type=<class 'bool'>, tag_safe=(False, False)
| | | | +- GuardManager: source=L['self'].config, accessed_by=GetAttrGuardAccessor(output_attentions), type=<class 'bool'>, tag_safe=(False, False)
| | | | +- GuardManager: source=L['self'].config.__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | +- DICT_CONTAINS: not ___dict_contains('attribute_map', L['self'].config.__dict__)  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | +- GuardManager: source=L['self'].config.return_dict, accessed_by=GetAttrGuardAccessor(return_dict), type=<class 'bool'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['self'].config.return_dict, 4342973520), type=<class 'bool'>  # return_dict = kwargs.pop("return_dict", getattr(self.config, "return_dict", True))  # transformers/utils/output_capturing.py:224 in wrapper (HINT: type bool)
| | | | | +- TRUE_MATCH: L['self'].config.return_dict == True                          # if return_dict is False:  # transformers/utils/output_capturing.py:280 in wrapper
| | | | +- GuardManager: source=L['self'].config.num_hidden_layers, accessed_by=GetAttrGuardAccessor(num_hidden_layers), type=<class 'int'>, tag_safe=(False, False)
| | | | | +- EQUALS_MATCH: L['self'].config.num_hidden_layers == 2                       # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__ (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | +- GuardManager: source=L['self'].config._output_attentions, accessed_by=GetAttrGuardAccessor(_output_attentions), type=<class 'bool'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['self'].config._output_attentions, 4342973520), type=<class 'bool'>  # f"output_{k}": kwargs.get(f"output_{k}", getattr(self.config, f"output_{k}", False))  # transformers/utils/output_capturing.py:229 in wrapper (HINT: type bool)
| | | | | +- FALSE_MATCH: L['self'].config._output_attentions == False                  # collected_outputs = {k.replace("output_", ""): [] for k, v in recordable_keys.items() if v}  # transformers/utils/output_capturing.py:243 in wrapper
| | | | +- GuardManager: source=L['self'].config.output_hidden_states, accessed_by=GetAttrGuardAccessor(output_hidden_states), type=<class 'bool'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['self'].config.output_hidden_states, 4342973520), type=<class 'bool'>  # f"output_{k}": kwargs.get(f"output_{k}", getattr(self.config, f"output_{k}", False))  # transformers/utils/output_capturing.py:229 in wrapper (HINT: type bool)
| | | | | +- FALSE_MATCH: L['self'].config.output_hidden_states == False                # collected_outputs = {k.replace("output_", ""): [] for k, v in recordable_keys.items() if v}  # transformers/utils/output_capturing.py:243 in wrapper
| | | | +- GuardManager: source=L['self'].config._attn_implementation_internal, accessed_by=GetAttrGuardAccessor(_attn_implementation_internal), type=<class 'str'>, tag_safe=(False, False)
| | | | | +- EQUALS_MATCH: L['self'].config._attn_implementation_internal == 'eager'     # if attn_implementation is None:  # transformers/modeling_utils.py:5096 in get_interface
| | | | +- GuardManager: source=type(L['self'].config), accessed_by=TypeGuardAccessor, type=<class 'type'>, tag_safe=(False, False)
| | | | | +- GuardManager: source=type(L['self'].config).__mro__, accessed_by=TypeMROGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | +- GuardManager: source=type(L['self'].config).__mro__[1], accessed_by=TupleGetItemGuardAccessor(1), type=<class 'type'>, tag_safe=(False, False)
| | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'], accessed_by=DictGetItemGuardAccessor('attribute_map'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | +- TYPE_MATCH: ___check_type_id(dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'], 4343051680), type=<class 'dict'>  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__ (HINT: type dict)
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('return_dict', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('vision_feature_layer', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('vision_feature_select_strategy', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('vision_aspect_ratio', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('is_causal', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('output_hidden_states', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('output_attentions', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('__class__', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_output_attentions', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('num_hidden_layers', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_attn_implementation', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_attn_implementation_internal', dict(type(L['self'].config).__mro__[1].__dict__)['attribute_map'])  # if key != "attribute_map" and key in super().__getattribute__("attribute_map"):  # transformers/configuration_utils.py:432 in __getattribute__
| | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['output_attentions'], accessed_by=DictGetItemGuardAccessor('output_attentions'), type=<class 'property'>, tag_safe=(False, False)
| | | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['output_attentions'].fget, accessed_by=GetAttrGuardAccessor(fget), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['output_attentions'].fget.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['self'].config).__mro__[1].__dict__)['output_attentions'].fget.__code__, 4531461200), type=<class 'code'>  # return super().__getattribute__(key)  # transformers/configuration_utils.py:434 in __getattribute__
| | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['_attn_implementation'], accessed_by=DictGetItemGuardAccessor('_attn_implementation'), type=<class 'property'>, tag_safe=(False, False)
| | | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['_attn_implementation'].fget, accessed_by=GetAttrGuardAccessor(fget), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | +- GuardManager: source=dict(type(L['self'].config).__mro__[1].__dict__)['_attn_implementation'].fget.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['self'].config).__mro__[1].__dict__)['_attn_implementation'].fget.__code__, 4531461440), type=<class 'code'>  # return super().__getattribute__(key)  # transformers/configuration_utils.py:434 in __getattribute__
| | | +- GuardManager: source=L['self']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules, 4343051680), type=<class 'dict'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type dict)
| | | | +- GuardManager: source=L['self']._modules['model'], accessed_by=DictGetItemGuardAccessor('model'), type=<class 'transformers.models.llama.modeling_llama.LlamaModel'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model'], 43125404688), type=<class 'transformers.models.llama.modeling_llama.LlamaModel'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type LlamaModel)
| | | | | +- GuardManager: source=L['self']._modules['model'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model'].__dict__)  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward
| | | | | | +- GuardManager: source=L['self']._modules['model'].gradient_checkpointing, accessed_by=DictGetItemGuardAccessor('gradient_checkpointing'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | +- FALSE_MATCH: L['self']._modules['model'].gradient_checkpointing == False   # if getattr(self, "gradient_checkpointing", False) and self.training and arg_value:  # transformers/utils/generic.py:993 in wrapper
| | | | | | +- GuardManager: source=L['self']._modules['model']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules, 4343051680), type=<class 'dict'>  # inputs_embeds: torch.Tensor = self.embed_tokens(input_ids)  # transformers/models/llama/modeling_llama.py:389 in forward (HINT: type dict)
| | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['norm'], accessed_by=DictGetItemGuardAccessor('norm'), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>, tag_safe=(False, False)
| | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['norm'], 43125398544), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>  # hidden_states = self.norm(hidden_states)  # transformers/models/llama/modeling_llama.py:421 in forward (HINT: type LlamaRMSNorm)
| | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['norm'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['norm'].__dict__)  # hidden_states = self.norm(hidden_states)  # transformers/models/llama/modeling_llama.py:421 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['norm']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['norm']._parameters, 4343051680), type=<class 'dict'>  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward (HINT: type dict)
| | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['norm']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['norm']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32], stride=[1])  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['norm']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['norm']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['norm']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['norm']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['norm']._parameters['weight'], '_dynamo_static_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['norm'].variance_epsilon, accessed_by=DictGetItemGuardAccessor('variance_epsilon'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['norm'].variance_epsilon == 1e-06  # hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)  # transformers/models/llama/modeling_llama.py:66 in forward
| | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers'], accessed_by=DictGetItemGuardAccessor('layers'), type=<class 'torch.nn.modules.container.ModuleList'>, tag_safe=(False, False)
| | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers'], 43090380816), type=<class 'torch.nn.modules.container.ModuleList'>  # for decoder_layer in self.layers[: self.config.num_hidden_layers]:  # transformers/models/llama/modeling_llama.py:410 in forward (HINT: type ModuleList)
| | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('__getitem__', L['self']._modules['model']._modules['layers'].__dict__)  # for decoder_layer in self.layers[: self.config.num_hidden_layers]:  # transformers/models/llama/modeling_llama.py:410 in forward
| | | | | | | | | +- DictGuardManager: source=L['self']._modules['model']._modules['layers']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- KeyValueManager pair at index=0
| | | | | | | | | | | +- KeyManager: GuardManager: source=list(dict.keys(L['self']._modules['model']._modules['layers']._modules))[0], type=<class 'str'>, tag_safe=(False, False)
| | | | | | | | | | | | +- EQUALS_MATCH: list(dict.keys(L['self']._modules['model']._modules['layers']._modules))[0] == '0'  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__
| | | | | | | | | | | +- ValueManager: GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0'], type=<class 'transformers.models.llama.modeling_llama.LlamaDecoderLayer'>, tag_safe=(False, False)
| | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0'], 43125402640), type=<class 'transformers.models.llama.modeling_llama.LlamaDecoderLayer'>  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__ (HINT: type LlamaDecoderLayer)
| | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('__call__', L['self']._modules['model']._modules['layers']._modules['0'].__dict__)  # hidden_states = decoder_layer(  # transformers/models/llama/modeling_llama.py:411 in forward
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0'].__dict__)  # hidden_states = decoder_layer(  # transformers/models/llama/modeling_llama.py:411 in forward
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('gradient_checkpointing', L['self']._modules['model']._modules['layers']._modules['0'].__dict__)  # if self.gradient_checkpointing and self.training:  # transformers/modeling_layers.py:60 in __call__
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_compiled_call_impl', L['self']._modules['model']._modules['layers']._modules['0'].__dict__)  # if self._compiled_call_impl is not None:  # nn/modules/module.py:1780 in _wrapped_call_impl
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_call_impl', L['self']._modules['model']._modules['layers']._modules['0'].__dict__)  # return self._call_impl(*args, **kwargs)  # nn/modules/module.py:1783 in _wrapped_call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules, 4343051680), type=<class 'dict'>  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward (HINT: type dict)
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp'], accessed_by=DictGetItemGuardAccessor('mlp'), type=<class 'transformers.models.llama.modeling_llama.LlamaMLP'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp'], 43125400592), type=<class 'transformers.models.llama.modeling_llama.LlamaMLP'>  # hidden_states = self.mlp(hidden_states)  # transformers/models/llama/modeling_llama.py:330 in forward (HINT: type LlamaMLP)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp'].__dict__)  # hidden_states = self.mlp(hidden_states)  # transformers/models/llama/modeling_llama.py:330 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules, 4343051680), type=<class 'dict'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['act_fn'], accessed_by=DictGetItemGuardAccessor('act_fn'), type=<class 'transformers.activations.SiLUActivation'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['act_fn'], 43102810128), type=<class 'transformers.activations.SiLUActivation'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type SiLUActivation)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['act_fn'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['act_fn'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj'], accessed_by=DictGetItemGuardAccessor('up_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[64, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj'], accessed_by=DictGetItemGuardAccessor('down_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32, 64], stride=[64, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj'], accessed_by=DictGetItemGuardAccessor('gate_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[64, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['mlp']._parameters, 4343051680), type=<class 'dict'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type dict)
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'], accessed_by=DictGetItemGuardAccessor('self_attn'), type=<class 'transformers.models.llama.modeling_llama.LlamaAttention'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'], 43125401616), type=<class 'transformers.models.llama.modeling_llama.LlamaAttention'>  # hidden_states, _ = self.self_attn(  # transformers/models/llama/modeling_llama.py:316 in forward (HINT: type LlamaAttention)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].__dict__)  # hidden_states, _ = self.self_attn(  # transformers/models/llama/modeling_llama.py:316 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].scaling, accessed_by=DictGetItemGuardAccessor('scaling'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].scaling == 0.3535533905932738  # attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling  # transformers/models/llama/modeling_llama.py:212 in eager_attention_forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules, 4343051680), type=<class 'dict'>  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj'], accessed_by=DictGetItemGuardAccessor('k_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:263 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj'].__dict__)  # key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:263 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[16, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj'], accessed_by=DictGetItemGuardAccessor('o_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # attn_output = self.o_proj(attn_output)  # transformers/models/llama/modeling_llama.py:288 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj'].__dict__)  # attn_output = self.o_proj(attn_output)  # transformers/models/llama/modeling_llama.py:288 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj'], accessed_by=DictGetItemGuardAccessor('q_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj'].__dict__)  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj'], accessed_by=DictGetItemGuardAccessor('v_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:264 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj'].__dict__)  # value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:264 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[16, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].head_dim, accessed_by=DictGetItemGuardAccessor('head_dim'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].head_dim == 8  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].training, accessed_by=DictGetItemGuardAccessor('training'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- FALSE_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].training == False  # dropout=0.0 if not self.training else self.attention_dropout,  # transformers/models/llama/modeling_llama.py:282 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].layer_idx, accessed_by=DictGetItemGuardAccessor('layer_idx'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].layer_idx == 0  # keys, values = self.layers[layer_idx].update(key_states, value_states, *args, **kwargs)  # transformers/cache_utils.py:993 in update (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn']._parameters, 4343051680), type=<class 'dict'>  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].num_key_value_groups, accessed_by=DictGetItemGuardAccessor('num_key_value_groups'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].num_key_value_groups == 2  # if n_rep == 1:  # transformers/models/llama/modeling_llama.py:193 in repeat_kv (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['self_attn'].config, accessed_by=DictGetItemGuardAccessor('config'), type=<class 'transformers.models.llama.configuration_llama.LlamaConfig'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- OBJECT_ALIASING
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm'], accessed_by=DictGetItemGuardAccessor('input_layernorm'), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm'], 43125398544), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward (HINT: type LlamaRMSNorm)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm'].__dict__)  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters, 4343051680), type=<class 'dict'>  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32], stride=[1])  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm']._parameters['weight'], '_dynamo_static_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm'].variance_epsilon, accessed_by=DictGetItemGuardAccessor('variance_epsilon'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['input_layernorm'].variance_epsilon == 1e-06  # hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)  # transformers/models/llama/modeling_llama.py:66 in forward
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm'], accessed_by=DictGetItemGuardAccessor('post_attention_layernorm'), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm'], 43125398544), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>  # hidden_states = self.post_attention_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:329 in forward (HINT: type LlamaRMSNorm)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm'].__dict__)  # hidden_states = self.post_attention_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:329 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters, 4343051680), type=<class 'dict'>  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32], stride=[1])  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_static_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm'].variance_epsilon, accessed_by=DictGetItemGuardAccessor('variance_epsilon'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['0']._modules['post_attention_layernorm'].variance_epsilon == 1e-06  # hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)  # transformers/models/llama/modeling_llama.py:66 in forward
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['0']._parameters, 4343051680), type=<class 'dict'>  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward (HINT: type dict)
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._forward_hooks, accessed_by=DictGetItemGuardAccessor('_forward_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['0']._forward_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._backward_hooks, accessed_by=DictGetItemGuardAccessor('_backward_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['0']._backward_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._forward_pre_hooks, accessed_by=DictGetItemGuardAccessor('_forward_pre_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['0']._forward_pre_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['0']._backward_pre_hooks, accessed_by=DictGetItemGuardAccessor('_backward_pre_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['0']._backward_pre_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['0']), accessed_by=TypeGuardAccessor, type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__, accessed_by=TypeMROGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2], accessed_by=TupleGetItemGuardAccessor(2), type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2].__call__, accessed_by=GetAttrGuardAccessor(__call__), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2].__call__.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- ID_MATCH: ___check_obj_id(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2].__call__.__code__, 4444072992), type=<class 'code'>  # return super().__call__(*args, **kwargs)  # transformers/modeling_layers.py:93 in __call__
| | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2].__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2].__dict__)['_compiled_call_impl'], accessed_by=DictGetItemGuardAccessor('_compiled_call_impl'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- NONE_MATCH: dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[2].__dict__)['_compiled_call_impl'] is None  # if self._compiled_call_impl is not None:  # nn/modules/module.py:1780 in _wrapped_call_impl
| | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[1], accessed_by=TupleGetItemGuardAccessor(1), type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[1].__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_compiled_call_impl', dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[1].__dict__))  # if self._compiled_call_impl is not None:  # nn/modules/module.py:1780 in _wrapped_call_impl
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_call_impl', dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[1].__dict__))  # return self._call_impl(*args, **kwargs)  # nn/modules/module.py:1783 in _wrapped_call_impl
| | | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[1].__dict__)['gradient_checkpointing'], accessed_by=DictGetItemGuardAccessor('gradient_checkpointing'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- FALSE_MATCH: dict(type(L['self']._modules['model']._modules['layers']._modules['0']).__mro__[1].__dict__)['gradient_checkpointing'] == False  # if self.gradient_checkpointing and self.training:  # transformers/modeling_layers.py:60 in __call__
| | | | | | | | | | +- KeyValueManager pair at index=1
| | | | | | | | | | | +- KeyManager: GuardManager: source=list(dict.keys(L['self']._modules['model']._modules['layers']._modules))[1], type=<class 'str'>, tag_safe=(False, False)
| | | | | | | | | | | | +- EQUALS_MATCH: list(dict.keys(L['self']._modules['model']._modules['layers']._modules))[1] == '1'  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__
| | | | | | | | | | | +- ValueManager: GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1'], type=<class 'transformers.models.llama.modeling_llama.LlamaDecoderLayer'>, tag_safe=(False, False)
| | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1'], 43125402640), type=<class 'transformers.models.llama.modeling_llama.LlamaDecoderLayer'>  # if not isinstance(module, Module) and module is not None:  # nn/modules/module.py:652 in add_module (HINT: type LlamaDecoderLayer)
| | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('__call__', L['self']._modules['model']._modules['layers']._modules['1'].__dict__)  # hidden_states = decoder_layer(  # transformers/models/llama/modeling_llama.py:411 in forward
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1'].__dict__)  # hidden_states = decoder_layer(  # transformers/models/llama/modeling_llama.py:411 in forward
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('gradient_checkpointing', L['self']._modules['model']._modules['layers']._modules['1'].__dict__)  # if self.gradient_checkpointing and self.training:  # transformers/modeling_layers.py:60 in __call__
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_compiled_call_impl', L['self']._modules['model']._modules['layers']._modules['1'].__dict__)  # if self._compiled_call_impl is not None:  # nn/modules/module.py:1780 in _wrapped_call_impl
| | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('_call_impl', L['self']._modules['model']._modules['layers']._modules['1'].__dict__)  # return self._call_impl(*args, **kwargs)  # nn/modules/module.py:1783 in _wrapped_call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules, 4343051680), type=<class 'dict'>  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward (HINT: type dict)
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp'], accessed_by=DictGetItemGuardAccessor('mlp'), type=<class 'transformers.models.llama.modeling_llama.LlamaMLP'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp'], 43125400592), type=<class 'transformers.models.llama.modeling_llama.LlamaMLP'>  # hidden_states = self.mlp(hidden_states)  # transformers/models/llama/modeling_llama.py:330 in forward (HINT: type LlamaMLP)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp'].__dict__)  # hidden_states = self.mlp(hidden_states)  # transformers/models/llama/modeling_llama.py:330 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules, 4343051680), type=<class 'dict'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['act_fn'], accessed_by=DictGetItemGuardAccessor('act_fn'), type=<class 'transformers.activations.SiLUActivation'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['act_fn'], 43102810128), type=<class 'transformers.activations.SiLUActivation'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type SiLUActivation)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['act_fn'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['act_fn'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj'], accessed_by=DictGetItemGuardAccessor('up_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[64, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['up_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj'], accessed_by=DictGetItemGuardAccessor('down_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32, 64], stride=[64, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['down_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj'], accessed_by=DictGetItemGuardAccessor('gate_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj'].__dict__)  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[64, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._modules['gate_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['mlp']._parameters, 4343051680), type=<class 'dict'>  # down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))  # transformers/models/llama/modeling_llama.py:183 in forward (HINT: type dict)
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'], accessed_by=DictGetItemGuardAccessor('self_attn'), type=<class 'transformers.models.llama.modeling_llama.LlamaAttention'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'], 43125401616), type=<class 'transformers.models.llama.modeling_llama.LlamaAttention'>  # hidden_states, _ = self.self_attn(  # transformers/models/llama/modeling_llama.py:316 in forward (HINT: type LlamaAttention)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].__dict__)  # hidden_states, _ = self.self_attn(  # transformers/models/llama/modeling_llama.py:316 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].scaling, accessed_by=DictGetItemGuardAccessor('scaling'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].scaling == 0.3535533905932738  # attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling  # transformers/models/llama/modeling_llama.py:212 in eager_attention_forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules, 4343051680), type=<class 'dict'>  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj'], accessed_by=DictGetItemGuardAccessor('k_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:263 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj'].__dict__)  # key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:263 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[16, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['k_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj'], accessed_by=DictGetItemGuardAccessor('o_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # attn_output = self.o_proj(attn_output)  # transformers/models/llama/modeling_llama.py:288 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj'].__dict__)  # attn_output = self.o_proj(attn_output)  # transformers/models/llama/modeling_llama.py:288 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['o_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj'], accessed_by=DictGetItemGuardAccessor('q_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj'].__dict__)  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['q_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj'], accessed_by=DictGetItemGuardAccessor('v_proj'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:264 in forward (HINT: type Linear)
| | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj'].__dict__)  # value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:264 in forward
| | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['bias'] is None  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[16, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._modules['v_proj']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].head_dim, accessed_by=DictGetItemGuardAccessor('head_dim'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].head_dim == 8  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].training, accessed_by=DictGetItemGuardAccessor('training'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- FALSE_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].training == False  # dropout=0.0 if not self.training else self.attention_dropout,  # transformers/models/llama/modeling_llama.py:282 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].layer_idx, accessed_by=DictGetItemGuardAccessor('layer_idx'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].layer_idx == 1  # keys, values = self.layers[layer_idx].update(key_states, value_states, *args, **kwargs)  # transformers/cache_utils.py:993 in update (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn']._parameters, 4343051680), type=<class 'dict'>  # query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)  # transformers/models/llama/modeling_llama.py:262 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].num_key_value_groups, accessed_by=DictGetItemGuardAccessor('num_key_value_groups'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].num_key_value_groups == 2  # if n_rep == 1:  # transformers/models/llama/modeling_llama.py:193 in repeat_kv (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['self_attn'].config, accessed_by=DictGetItemGuardAccessor('config'), type=<class 'transformers.models.llama.configuration_llama.LlamaConfig'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- OBJECT_ALIASING
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm'], accessed_by=DictGetItemGuardAccessor('input_layernorm'), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm'], 43125398544), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward (HINT: type LlamaRMSNorm)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm'].__dict__)  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters, 4343051680), type=<class 'dict'>  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32], stride=[1])  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm']._parameters['weight'], '_dynamo_static_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm'].variance_epsilon, accessed_by=DictGetItemGuardAccessor('variance_epsilon'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['input_layernorm'].variance_epsilon == 1e-06  # hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)  # transformers/models/llama/modeling_llama.py:66 in forward
| | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm'], accessed_by=DictGetItemGuardAccessor('post_attention_layernorm'), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm'], 43125398544), type=<class 'transformers.models.llama.modeling_llama.LlamaRMSNorm'>  # hidden_states = self.post_attention_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:329 in forward (HINT: type LlamaRMSNorm)
| | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm'].__dict__)  # hidden_states = self.post_attention_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:329 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters, 4343051680), type=<class 'dict'>  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward (HINT: type dict)
| | | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[32], stride=[1])  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm']._parameters['weight'], '_dynamo_static_indices') == False  # return self.weight * hidden_states.to(input_dtype)  # transformers/models/llama/modeling_llama.py:67 in forward
| | | | | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm'].variance_epsilon, accessed_by=DictGetItemGuardAccessor('variance_epsilon'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['layers']._modules['1']._modules['post_attention_layernorm'].variance_epsilon == 1e-06  # hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)  # transformers/models/llama/modeling_llama.py:66 in forward
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['layers']._modules['1']._parameters, 4343051680), type=<class 'dict'>  # hidden_states = self.input_layernorm(hidden_states)  # transformers/models/llama/modeling_llama.py:314 in forward (HINT: type dict)
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._forward_hooks, accessed_by=DictGetItemGuardAccessor('_forward_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['1']._forward_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._backward_hooks, accessed_by=DictGetItemGuardAccessor('_backward_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['1']._backward_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._forward_pre_hooks, accessed_by=DictGetItemGuardAccessor('_forward_pre_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['1']._forward_pre_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers']._modules['1']._backward_pre_hooks, accessed_by=DictGetItemGuardAccessor('_backward_pre_hooks'), type=<class 'collections.OrderedDict'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- DICT_LENGTH: not L['self']._modules['model']._modules['layers']._modules['1']._backward_pre_hooks  # if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks  # nn/modules/module.py:1791 in _call_impl
| | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['1']), accessed_by=TypeGuardAccessor, type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['1']).__mro__, accessed_by=TypeMROGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['1']).__mro__[2], accessed_by=TupleGetItemGuardAccessor(2), type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['1']).__mro__[2].__call__, accessed_by=GetAttrGuardAccessor(__call__), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['layers']._modules['1']).__mro__[2].__call__.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- ID_MATCH: ___check_obj_id(type(L['self']._modules['model']._modules['layers']._modules['1']).__mro__[2].__call__.__code__, 4444072992), type=<class 'code'>  # return super().__call__(*args, **kwargs)  # transformers/modeling_layers.py:93 in __call__
| | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers'].__class__, accessed_by=GetAttrGuardAccessor(__class__), type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | +- ID_MATCH: ___check_obj_id(L['self']._modules['model']._modules['layers'].__class__, 43090380816), type=<class 'torch.nn.modules.container.ModuleList'>  # return self.__class__(list(self._modules.values())[idx])  # nn/modules/container.py:390 in __getitem__
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['layers'].__class__.call_super_init, accessed_by=GetAttrGuardAccessor(call_super_init), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | | | +- FALSE_MATCH: L['self']._modules['model']._modules['layers'].__class__.call_super_init == False  # if self.call_super_init is False and bool(kwargs):  # nn/modules/module.py:487 in __init__
| | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb'], accessed_by=DictGetItemGuardAccessor('rotary_emb'), type=<class 'transformers.models.llama.modeling_llama.LlamaRotaryEmbedding'>, tag_safe=(False, False)
| | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['rotary_emb'], 43125399568), type=<class 'transformers.models.llama.modeling_llama.LlamaRotaryEmbedding'>  # position_embeddings = self.rotary_emb(hidden_states, position_ids=position_ids)  # transformers/models/llama/modeling_llama.py:408 in forward (HINT: type LlamaRotaryEmbedding)
| | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['rotary_emb'].__dict__)  # position_embeddings = self.rotary_emb(hidden_states, position_ids=position_ids)  # transformers/models/llama/modeling_llama.py:408 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb']._buffers, accessed_by=DictGetItemGuardAccessor('_buffers'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['rotary_emb']._buffers, 4343051680), type=<class 'dict'>  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward (HINT: type dict)
| | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], accessed_by=DictGetItemGuardAccessor('inv_freq'), type=<class 'torch.Tensor'>, tag_safe=(False, False)
| | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], Tensor, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=False, size=[4], stride=[1])  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], '_dynamo_dynamic_indices') == False  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], '_dynamo_weak_dynamic_indices') == False  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], '_dynamo_unbacked_indices') == False  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], '_dynamo_strict_unbacked_indices') == False  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['rotary_emb']._buffers['inv_freq'], '_dynamo_static_indices') == False  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward
| | | | | | | | | | | +- NO_TENSOR_ALIASING
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb']._modules, accessed_by=DictGetItemGuardAccessor('_modules'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['rotary_emb']._modules, 4343051680), type=<class 'dict'>  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward (HINT: type dict)
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb'].rope_type, accessed_by=DictGetItemGuardAccessor('rope_type'), type=<class 'str'>, tag_safe=(False, False)
| | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['rotary_emb'].rope_type == 'default'  # if "dynamic" in rope_type:  # transformers/modeling_rope_utils.py:124 in wrapper
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['rotary_emb']._parameters, 4343051680), type=<class 'dict'>  # inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)  # transformers/models/llama/modeling_llama.py:125 in forward (HINT: type dict)
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['rotary_emb'].attention_scaling, accessed_by=DictGetItemGuardAccessor('attention_scaling'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['rotary_emb'].attention_scaling == 1.0  # cos = emb.cos() * self.attention_scaling  # transformers/models/llama/modeling_llama.py:132 in forward
| | | | | | | | +- GuardManager: source=type(L['self']._modules['model']._modules['rotary_emb']), accessed_by=TypeGuardAccessor, type=<class 'type'>, tag_safe=(False, False)
| | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'], accessed_by=DictGetItemGuardAccessor('forward'), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__, accessed_by=ClosureGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[0], accessed_by=TupleGetItemGuardAccessor(0), type=<class 'cell'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[0].cell_contents, accessed_by=GetAttrGuardAccessor(cell_contents), type=<class 'method'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[0].cell_contents, 4342983704), type=<class 'method'>  # with ctx_factory():  # utils/_contextlib.py:123 in decorate_context (HINT: guard on "ctx_factory", type method)
| | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1], accessed_by=TupleGetItemGuardAccessor(1), type=<class 'cell'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents, accessed_by=GetAttrGuardAccessor(cell_contents), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__code__, 4541754384), type=<class 'code'>  # return func(*args, **kwargs)  # utils/_contextlib.py:124 in decorate_context (HINT: guard on "func".__code__)
| | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__defaults__, accessed_by=GetAttrGuardAccessor(__defaults__), type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__defaults__, 4343077424), type=<class 'tuple'>  # return func(*args, **kwargs)  # utils/_contextlib.py:124 in decorate_context (HINT: guard on "func".__defaults__, type tuple)
| | | | | | | | | | | | | | | +- LENGTH_CHECK: len(dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__defaults__) == 1  # return func(*args, **kwargs)  # utils/_contextlib.py:124 in decorate_context (HINT: guard on "func".__defaults__)
| | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents, accessed_by=FuncDefaultsGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__defaults__[0], accessed_by=GetItemGuardAccessor(0), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- NONE_MATCH: dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__defaults__[0] is None  # rope_type = self.rope_type if layer_type is None else self.rope_type[layer_type]  # transformers/modeling_rope_utils.py:122 in wrapper (HINT: guard on "func".__defaults__[0])
| | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__closure__, accessed_by=ClosureGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__closure__[2], accessed_by=TupleGetItemGuardAccessor(2), type=<class 'cell'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__closure__[2].cell_contents, accessed_by=GetAttrGuardAccessor(cell_contents), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__closure__[2].cell_contents.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['self']._modules['model']._modules['rotary_emb']).__dict__)['forward'].__closure__[1].cell_contents.__closure__[2].cell_contents.__code__, 43123627008), type=<class 'code'>  # return rope_forward(self, x, position_ids, **kwargs)  # transformers/modeling_rope_utils.py:128 in wrapper (HINT: guard on "rope_forward".__code__)
| | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'], accessed_by=DictGetItemGuardAccessor('embed_tokens'), type=<class 'torch.nn.modules.sparse.Embedding'>, tag_safe=(False, False)
| | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['embed_tokens'], 43086197776), type=<class 'torch.nn.modules.sparse.Embedding'>  # inputs_embeds: torch.Tensor = self.embed_tokens(input_ids)  # transformers/models/llama/modeling_llama.py:389 in forward (HINT: type Embedding)
| | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['model']._modules['embed_tokens'].__dict__)  # inputs_embeds: torch.Tensor = self.embed_tokens(input_ids)  # transformers/models/llama/modeling_llama.py:389 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'].sparse, accessed_by=DictGetItemGuardAccessor('sparse'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | | | +- FALSE_MATCH: L['self']._modules['model']._modules['embed_tokens'].sparse == False  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'].max_norm, accessed_by=DictGetItemGuardAccessor('max_norm'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | | | +- NONE_MATCH: L['self']._modules['model']._modules['embed_tokens'].max_norm is None  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'].norm_type, accessed_by=DictGetItemGuardAccessor('norm_type'), type=<class 'float'>, tag_safe=(False, False)
| | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['embed_tokens'].norm_type == 2.0  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._modules['embed_tokens']._parameters, 4343051680), type=<class 'dict'>  # self.weight,  # nn/modules/sparse.py:191 in forward (HINT: type dict)
| | | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[64, 32], stride=[32, 1])  # self.weight,  # nn/modules/sparse.py:191 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], '_dynamo_dynamic_indices') == False  # self.weight,  # nn/modules/sparse.py:191 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # self.weight,  # nn/modules/sparse.py:191 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], '_dynamo_unbacked_indices') == False  # self.weight,  # nn/modules/sparse.py:191 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # self.weight,  # nn/modules/sparse.py:191 in forward
| | | | | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['model']._modules['embed_tokens']._parameters['weight'], '_dynamo_static_indices') == False  # self.weight,  # nn/modules/sparse.py:191 in forward
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'].padding_idx, accessed_by=DictGetItemGuardAccessor('padding_idx'), type=<class 'int'>, tag_safe=(False, False)
| | | | | | | | | | +- EQUALS_MATCH: L['self']._modules['model']._modules['embed_tokens'].padding_idx == 0  # return F.embedding(  # nn/modules/sparse.py:189 in forward (HINT: torch.compile considers integer attributes of the nn.Module to be static. If you are observing recompilation, you might want to make this integer dynamic using torch._dynamo.config.allow_unspec_int_on_nn_module = True, or convert this integer into a tensor.)
| | | | | | | | | +- GuardManager: source=L['self']._modules['model']._modules['embed_tokens'].scale_grad_by_freq, accessed_by=DictGetItemGuardAccessor('scale_grad_by_freq'), type=<class 'bool'>, tag_safe=(False, False)
| | | | | | | | | | +- FALSE_MATCH: L['self']._modules['model']._modules['embed_tokens'].scale_grad_by_freq == False  # return F.embedding(  # nn/modules/sparse.py:189 in forward
| | | | | | +- GuardManager: source=L['self']._modules['model']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['model']._parameters, 4343051680), type=<class 'dict'>  # inputs_embeds: torch.Tensor = self.embed_tokens(input_ids)  # transformers/models/llama/modeling_llama.py:389 in forward (HINT: type dict)
| | | | | | +- GuardManager: source=L['self']._modules['model'].config, accessed_by=DictGetItemGuardAccessor('config'), type=<class 'transformers.models.llama.configuration_llama.LlamaConfig'>, tag_safe=(False, False)
| | | | | | | +- OBJECT_ALIASING
| | | | | +- GuardManager: source=L['self']._modules['model'].__class__, accessed_by=GetAttrGuardAccessor(__class__), type=<class 'type'>, tag_safe=(False, False)
| | | | | | +- ID_MATCH: ___check_obj_id(L['self']._modules['model'].__class__, 43125404688), type=<class 'transformers.models.llama.modeling_llama.LlamaModel'>  # capturable_flags = _CAN_RECORD_REGISTRY.get(str(self.__class__)) or {}  # transformers/utils/output_capturing.py:227 in wrapper
| | | | | +- GuardManager: source=type(L['self']._modules['model']), accessed_by=TypeGuardAccessor, type=<class 'type'>, tag_safe=(False, False)
| | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__), accessed_by=TypeDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'], accessed_by=DictGetItemGuardAccessor('forward'), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__, accessed_by=ClosureGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0], accessed_by=TupleGetItemGuardAccessor(0), type=<class 'cell'>, tag_safe=(False, False)
| | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents, accessed_by=GetAttrGuardAccessor(cell_contents), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__code__, 42975892736), type=<class 'code'>  # if arg_name in func.__code__.co_varnames:  # transformers/utils/generic.py:980 in wrapper (HINT: guard on "func".__code__)
| | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__code__.co_varnames, accessed_by=GetAttrGuardAccessor(co_varnames), type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- EQUALS_MATCH: dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__code__.co_varnames == ('self', 'args', 'kwargs', 'return_dict', 'capturable_flags', 'k', 'recordable_keys', 'v', 'collected_outputs', 'output_token', 'outputs', 'key')  # if arg_name in func.__code__.co_varnames:  # transformers/utils/generic.py:980 in wrapper (HINT: guard on "func".__code__.co_varnames)
| | | | | | | | | | | | | +- TYPE_MATCH: ___check_type_id(dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__code__.co_varnames, 4343077424), type=<class 'tuple'>  # if arg_name in func.__code__.co_varnames:  # transformers/utils/generic.py:980 in wrapper (HINT: guard on "func".__code__.co_varnames, type tuple)
| | | | | | | | | | | | | +- LENGTH_CHECK: len(dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__code__.co_varnames) == 12  # if arg_name in func.__code__.co_varnames:  # transformers/utils/generic.py:980 in wrapper (HINT: guard on "func".__code__.co_varnames)
| | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__closure__, accessed_by=ClosureGuardAccessor, type=<class 'tuple'>, tag_safe=(False, False)
| | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__closure__[0], accessed_by=TupleGetItemGuardAccessor(0), type=<class 'cell'>, tag_safe=(False, False)
| | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__closure__[0].cell_contents, accessed_by=GetAttrGuardAccessor(cell_contents), type=<class 'function'>, tag_safe=(False, False)
| | | | | | | | | | | | | | +- GuardManager: source=dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__closure__[0].cell_contents.__code__, accessed_by=CodeGuardAccessor, type=<class 'code'>, tag_safe=(False, False)
| | | | | | | | | | | | | | | +- ID_MATCH: ___check_obj_id(dict(type(L['self']._modules['model']).__dict__)['forward'].__closure__[0].cell_contents.__closure__[0].cell_contents.__code__, 42972119040), type=<class 'code'>  # outputs = func(self, *args, **kwargs)  # transformers/utils/output_capturing.py:252 in wrapper (HINT: guard on "func".__code__)
| | | | +- GuardManager: source=L['self']._modules['lm_head'], accessed_by=DictGetItemGuardAccessor('lm_head'), type=<class 'torch.nn.modules.linear.Linear'>, tag_safe=(False, False)
| | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['lm_head'], 43085772816), type=<class 'torch.nn.modules.linear.Linear'>  # logits = self.lm_head(hidden_states[:, slice_indices, :])  # transformers/models/llama/modeling_llama.py:487 in forward (HINT: type Linear)
| | | | | +- GuardManager: source=L['self']._modules['lm_head'].__dict__, accessed_by=GetGenericDictGuardAccessor, type=<class 'dict'>, tag_safe=(False, False)
| | | | | | +- DICT_CONTAINS: not ___dict_contains('forward', L['self']._modules['lm_head'].__dict__)  # logits = self.lm_head(hidden_states[:, slice_indices, :])  # transformers/models/llama/modeling_llama.py:487 in forward
| | | | | | +- GuardManager: source=L['self']._modules['lm_head']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | | | | +- TYPE_MATCH: ___check_type_id(L['self']._modules['lm_head']._parameters, 4343051680), type=<class 'dict'>  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward (HINT: type dict)
| | | | | | | +- GuardManager: source=L['self']._modules['lm_head']._parameters['bias'], accessed_by=DictGetItemGuardAccessor('bias'), type=<class 'NoneType'>, tag_safe=(False, False)
| | | | | | | | +- NONE_MATCH: L['self']._modules['lm_head']._parameters['bias'] is None     # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | +- GuardManager: source=L['self']._modules['lm_head']._parameters['weight'], accessed_by=DictGetItemGuardAccessor('weight'), type=<class 'torch.nn.parameter.Parameter'>, tag_safe=(False, False)
| | | | | | | | +- TENSOR_MATCH: check_tensor(L['self']._modules['lm_head']._parameters['weight'], Parameter, DispatchKeySet(CPU, BackendSelect, ADInplaceOrView, AutogradCPU), torch.float32, device=None, requires_grad=True, size=[64, 32], stride=[32, 1])  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['lm_head']._parameters['weight'], '_dynamo_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['lm_head']._parameters['weight'], '_dynamo_weak_dynamic_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['lm_head']._parameters['weight'], '_dynamo_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['lm_head']._parameters['weight'], '_dynamo_strict_unbacked_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | | | | | | +- DIMENSION_DYNAMIC_MARKING_GUARD: hasattr(L['self']._modules['lm_head']._parameters['weight'], '_dynamo_static_indices') == False  # return F.linear(input, self.weight, self.bias)  # nn/modules/linear.py:134 in forward
| | | +- GuardManager: source=L['self']._parameters, accessed_by=DictGetItemGuardAccessor('_parameters'), type=<class 'dict'>, tag_safe=(False, False)
| | | | +- TYPE_MATCH: ___check_type_id(L['self']._parameters, 4343051680), type=<class 'dict'>  # outputs: BaseModelOutputWithPast = self.model(  # transformers/models/llama/modeling_llama.py:474 in forward (HINT: type dict)

Guard latency = 135.67 us