FilesExpand file tree

main

/

modeling_pytorch_flax_utils.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

161 lines (134 loc) · 6.81 KB

main

/

modeling_pytorch_flax_utils.py

Copy path

Top

File metadata and controls

• Code
• Blame

161 lines (134 loc) · 6.81 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

# coding=utf-8

# Copyright 2024 The HuggingFace Inc. team.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

"""PyTorch - Flax general utilities."""

from pickle import UnpicklingError

import jax

import jax.numpy as jnp

import numpy as np

from flax.serialization import from_bytes

from flax.traverse_util import flatten_dict

from ..utils import logging

logger = logging.get_logger(__name__)

#####################

# Flax => PyTorch #

#####################

# from https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_pytorch_utils.py#L224-L352

def load_flax_checkpoint_in_pytorch_model(pt_model, model_file):

try:

with open(model_file, "rb") as flax_state_f:

flax_state = from_bytes(None, flax_state_f.read())

except UnpicklingError as e:

try:

with open(model_file) as f:

if f.read().startswith("version"):

raise OSError(

"You seem to have cloned a repository without having git-lfs installed. Please"

" install git-lfs and run `git lfs install` followed by `git lfs pull` in the"

" folder you cloned."

)

else:

raise ValueError from e

except (UnicodeDecodeError, ValueError):

raise EnvironmentError(f"Unable to convert {model_file} to Flax deserializable object. ")

return load_flax_weights_in_pytorch_model(pt_model, flax_state)

def load_flax_weights_in_pytorch_model(pt_model, flax_state):

"""Load flax checkpoints in a PyTorch model"""

try:

import torch # noqa: F401

except ImportError:

logger.error(

"Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see"

" https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"

" instructions."

)

raise

# check if we have bf16 weights

is_type_bf16 = flatten_dict(jax.tree_util.tree_map(lambda x: x.dtype == jnp.bfloat16, flax_state)).values()

if any(is_type_bf16):

# convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

# and bf16 is not fully supported in PT yet.

logger.warning(

"Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` "

"before loading those in PyTorch model."

)

flax_state = jax.tree_util.tree_map(

lambda params: params.astype(np.float32) if params.dtype == jnp.bfloat16 else params, flax_state

)

pt_model.base_model_prefix = ""

flax_state_dict = flatten_dict(flax_state, sep=".")

pt_model_dict = pt_model.state_dict()

# keep track of unexpected & missing keys

unexpected_keys = []

missing_keys = set(pt_model_dict.keys())

for flax_key_tuple, flax_tensor in flax_state_dict.items():

flax_key_tuple_array = flax_key_tuple.split(".")

if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:

flax_key_tuple_array = flax_key_tuple_array[:-1] + ["weight"]

flax_tensor = jnp.transpose(flax_tensor, (3, 2, 0, 1))

elif flax_key_tuple_array[-1] == "kernel":

flax_key_tuple_array = flax_key_tuple_array[:-1] + ["weight"]

flax_tensor = flax_tensor.T

elif flax_key_tuple_array[-1] == "scale":

flax_key_tuple_array = flax_key_tuple_array[:-1] + ["weight"]

if "time_embedding" not in flax_key_tuple_array:

for i, flax_key_tuple_string in enumerate(flax_key_tuple_array):

flax_key_tuple_array[i] = (

flax_key_tuple_string.replace("_0", ".0")

.replace("_1", ".1")

.replace("_2", ".2")

.replace("_3", ".3")

.replace("_4", ".4")

.replace("_5", ".5")

.replace("_6", ".6")

.replace("_7", ".7")

.replace("_8", ".8")

.replace("_9", ".9")

)

flax_key = ".".join(flax_key_tuple_array)

if flax_key in pt_model_dict:

if flax_tensor.shape != pt_model_dict[flax_key].shape:

raise ValueError(

f"Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected "

f"to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."

)

else:

# add weight to pytorch dict

flax_tensor = np.asarray(flax_tensor) if not isinstance(flax_tensor, np.ndarray) else flax_tensor

pt_model_dict[flax_key] = torch.from_numpy(flax_tensor)

# remove from missing keys

missing_keys.remove(flax_key)

else:

# weight is not expected by PyTorch model

unexpected_keys.append(flax_key)

pt_model.load_state_dict(pt_model_dict)

# re-transform missing_keys to list

missing_keys = list(missing_keys)

if len(unexpected_keys) > 0:

logger.warning(

"Some weights of the Flax model were not used when initializing the PyTorch model"

f" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"

f" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"

" (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"

f" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"

" to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"

" FlaxBertForSequenceClassification model)."

)

if len(missing_keys) > 0:

logger.warning(

f"Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"

f" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"

" use it for predictions and inference."

)

return pt_model