deepDR/MDA.py at master · ChengF-Lab/deepDR · GitHub

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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
from keras.models import Model
from keras.optimizers import SGD
from keras.layers import Input, Dense, concatenate
from keras import regularizers


def build_AE(input_dim, encoding_dims):
    """
    Function for building autoencoder.
    """
    # input layer
    input_layer = Input(shape=(input_dim, ))
    hidden_layer = input_layer
    for i in range(0, len(encoding_dims)):
        # generate hidden layer
        if i == len(encoding_dims)/2:
            hidden_layer = Dense(encoding_dims[i],
                                 activation='sigmoid',
                                 # activity_regularizer=regularizers.l1(10e-6),
                                 name='middle_layer')(hidden_layer)
        else:
            hidden_layer = Dense(encoding_dims[i],
                                 activation='sigmoid',
                                 name='layer_' + str(i+1))(hidden_layer)

    # reconstruction of the input
    decoded = Dense(input_dim,
                    activation='sigmoid')(hidden_layer)

    # autoencoder model
    sgd = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=False)
    model = Model(inputs=input_layer, outputs=decoded)
    model.compile(optimizer=sgd, loss='binary_crossentropy')
    print (model.summary())

    return model


def build_MDA(input_dims, encoding_dims):
    """
    Function for building multimodal autoencoder.
    """
    # input layers
    input_layers = []
    for dim in input_dims:
        input_layers.append(Input(shape=(dim, )))

    # hidden layers
    hidden_layers = []
    for j in range(0, len(input_dims)):
        hidden_layers.append(Dense(encoding_dims[0]/len(input_dims),
                                   # activity_regularizer=regularizers.l1(gamma[j]),
                                   activation='sigmoid')(input_layers[j]))

    # Concatenate layers
    if len(encoding_dims) == 1:
        hidden_layer = concatenate(hidden_layers, name='middle_layer')
    else:
        hidden_layer = concatenate(hidden_layers)

    # middle layers
    for i in range(1, len(encoding_dims)-1):
        if i == len(encoding_dims)/2:
            hidden_layer = Dense(encoding_dims[i],
                                 name='middle_layer',
                                 # kernel_regularizer=regularizers.l1(1e-5),
                                 activation='sigmoid')(hidden_layer)
        else:
            hidden_layer = Dense(encoding_dims[i],
                                 # kernel_regularizer=regularizers.l1(1e-5),
                                 activation='sigmoid')(hidden_layer)

    if len(encoding_dims) != 1:
        # reconstruction of the concatenated layer
        hidden_layer = Dense(encoding_dims[0],
                             activation='sigmoid')(hidden_layer)

    # hidden layers
    hidden_layers = []
    for j in range(0, len(input_dims)):
        hidden_layers.append(Dense(encoding_dims[-1]/len(input_dims),
                                   activation='sigmoid')(hidden_layer))
    # output layers
    output_layers = []
    for j in range(0, len(input_dims)):
        output_layers.append(Dense(input_dims[j],
                                   activation='sigmoid')(hidden_layers[j]))

    # autoencoder model
    sgd = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=False)
    model = Model(inputs=input_layers, outputs=output_layers)
    model.compile(optimizer=sgd, loss='binary_crossentropy')
    print (model.summary())

    return model


def build_MDA2(input_dims, encoding_dims):
    """
    Function for building mixed multimodal autoencoder.
    """
    # input layers
    input_layers = []
    for dim in input_dims:
        input_layers.append(Input(shape=(dim, )))

    # ENCODER

    # hidden layer
    hidden_layers = input_layers
    for i in range(0, len(encoding_dims)-1):
        tmp_layers = []
        if isinstance(encoding_dims[i], list) and isinstance(encoding_dims[i+1], int):
            tmp1_layers = []
            for j in range(0, len(encoding_dims[i])):
                tmp1_layers.append(Dense(encoding_dims[i][j],
                                         # kernel_initializer='random_uniform',
                                         activation='sigmoid')(hidden_layers[j]))
            tmp_layers.append(concatenate(tmp1_layers))
        elif isinstance(encoding_dims[i], int):
            tmp_layers.append(Dense(encoding_dims[i],
                                    # kernel_initializer='random_uniform',
                                    activation='sigmoid')(hidden_layers[0]))
        else:
            for j in range(0, len(encoding_dims[i])):
                tmp_layers.append(Dense(encoding_dims[i][j],
                                        # kernel_initializer='random_uniform',
                                        # activity_regularizer=regularizers.l1(0.0001),
                                        activation='sigmoid')(hidden_layers[j]))
        hidden_layers = tmp_layers

    # middle layer
    tmp_layers = []
    tmp_layers.append(Dense(encoding_dims[-1],
                            name='middle_layer',
                            # kernel_initializer='random_uniform',
                            # activity_regularizer=regularizers.l1(10e-6),
                            activation='sigmoid')(hidden_layers[0]))
    hidden_layers = tmp_layers

    # DECODER

    # hidden layers
    for i in range(2, len(encoding_dims) + 1):
        tmp_layers = []
        if isinstance(encoding_dims[-i], int):
            tmp_layers.append(Dense(encoding_dims[-i],
                                    # kernel_initializer='random_uniform',
                                    activation='sigmoid')(hidden_layers[0]))
        elif isinstance(encoding_dims[-i], list) and isinstance(encoding_dims[-i+1], int):
            tmp = Dense(sum(encoding_dims[-i]),
                        # kernel_initializer='random_uniform',
                        activation='sigmoid')(hidden_layers[0])
            for j in range(0, len(encoding_dims[-i])):
                tmp_layers.append(Dense(encoding_dims[-i][j],
                                        # kernel_initializer='random_uniform',
                                        activation='sigmoid')(tmp))
        else:
            for j in range(0, len(encoding_dims[-i])):
                tmp_layers.append(Dense(encoding_dims[-i][j],
                                        # kernel_initializer='random_uniform',
                                        activation='sigmoid')(hidden_layers[j]))
        hidden_layers = tmp_layers

    # output layers
    output_layers = []
    for j in range(0, len(input_dims)):
        output_layers.append(Dense(input_dims[j],
                                   # kernel_initializer='random_uniform',
                                   activation='sigmoid')(hidden_layers[j]))

    # autoencoder model
    sgd = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=False)
    model = Model(inputs=input_layers, outputs=output_layers)
    model.compile(optimizer=sgd, loss='binary_crossentropy')
    print (model.summary())

    return model