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
## Define the Model.
def faceRecoModel(input_shape):
 
    X_input = Input(input_shape)
 
    X = ZeroPadding2D((33))(X_input)
    
    X = Conv2D(64, (77), strides = (22), name = 'conv1')(X)
    X = BatchNormalization(axis = 1, name = 'bn1')(X)
    X = Activation('relu')(X)
    
    X = ZeroPadding2D((11))(X)
    X = MaxPooling2D((33), strides = 2)(X)
    
    X = Conv2D(64, (11), strides = (11), name = 'conv2')(X)
    X = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn2')(X)
    X = Activation('relu')(X)
    
    X = ZeroPadding2D((11))(X)
 
    X = Conv2D(192, (33), strides = (11), name = 'conv3')(X)
    X = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn3')(X)
    X = Activation('relu')(X)
    
    X = ZeroPadding2D((11))(X)
    X = MaxPooling2D(pool_size = 3, strides = 2)(X)
    
    X = inception_block_1a(X)
    X = inception_block_1b(X)
    X = inception_block_1c(X)
    
    X = inception_block_2a(X)
    X = inception_block_2b(X)
    
    X = inception_block_3a(X)
    X = inception_block_3b(X)
    
    X = AveragePooling2D(pool_size=(33), strides=(11), data_format='channels_first')(X)
    X = Flatten()(X)
    X = Dense(128, name='dense_layer')(X)
    
    X = Lambda(lambda  x: K.l2_normalize(x,axis=1))(X)
 
    model = Model(inputs = X_input, outputs = X, name='FaceRecoModel')
        
    return model
 
## Instantiate that Model
FRmodel = faceRecoModel(input_shape=(39696))
 
#############################
 
########### Train ###########
 
#############################
 
## check input node's name and shape
[node.op.name for node in FRmodel.inputs]
FRmodel.input_shape
 
## check output node's name and shape
[node.op.name for node in FRmodel.outputs]
FRmodel.output_shape
 
# off learning phase flag
K.set_learning_phase(0)
 
# function for freeze variables
def freeze_session(session, keep_var_names=None, output_names=None, clear_devices=True):
    graph = session.graph
    with graph.as_default():
        freeze_var_names = list(set(v.op.name for v in tf.global_variables()).difference(keep_var_names or []))
        output_names = output_names or []
        output_names += [v.op.name for v in tf.global_variables()]
        input_graph_def = graph.as_graph_def()
        if clear_devices:
            for node in input_graph_def.node:
                node.device = ""
        frozen_graph = tf.graph_util.convert_variables_to_constants(
            session, input_graph_def, output_names, freeze_var_names)
        return frozen_graph
 
 
# create frozen graph
frozen_graph = freeze_session(K.get_session(),output_names=[out.op.name for out in FRmodel.outputs])
 
# save frozen graph as .proto buff type file
tf.train.write_graph(frozen_graph, "PATH_TO_SAVE""my_model.pb", as_text=False )
 
# confirm
!ls PATH_TO_SAVE
 
 
 
 
cs


+ Recent posts