run_experiments.py
XD = np.asarray(XD)
array和asarray都可将结构数据转换为ndarray类型。
但是主要区别就是当数据源是ndarray时，array仍会copy出一个副本，占用新的内存，但asarray不会。
例1：当数据源是list时，array和asarray都对原数据进行了复制。
import numpy as np
data = [1,1,1]
arr2 = np.array(data)
arr3 = np.asarray(data)
data[1] = 2
print('data:', data)
print('arr2:', arr2)
print('arr3:', arr3)
输出：
data: [1, 2, 1]
arr2: [1 1 1]
arr3: [1 1 1]
例2：当数据源是ndarray时，array对原数据进行了复制，而asarray没有。
import numpy as np
data = np.ones(3)
arr2 = np.array(data)
arr3 = np.asarray(data)
data[1] = 2
print('data:', data)
print('arr2:', arr2)
print('arr3:', arr3)
输出：
data: [1. 2. 1.]
arr2: [1. 1. 1.]
arr3: [1. 2. 1.]
例3：针对项目中的代码，不管怎么改XD中的Xi，XD只会一直是第一次的数据不会变。
XD = [ X1, X2, X3, … ]
XD是一个列表，其中每一个元素X都是一个一维（有标签）/多维（没标签）的矩阵
import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.array([7,8,9])
X = [a,b,c]
XD = np.asarray(X)
print('a:', a)
print('X:', X)
print('XD:', XD)
print()
a[1] = 99
print('a\':', a)
print('X\':', X)
print('XD\':', XD)
输出：
a: [1 2 3]
X: [array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]
XD: [[1 2 3]
[4 5 6]
[7 8 9]]
a’: [ 1 99 3]
X’: [array([ 1, 99, 3]), array([4, 5, 6]), array([7, 8, 9])]
XD’: [[1 2 3]
[4 5 6]
[7 8 9]]
drugcount = XD.shape[0]
对于numpy中shape;
二维情况：
import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
XD = [a,b]
XD = np.asarray(XD)
print('XD:', XD)
print('XD_shape:',XD.shape)
print('XD_shape[0]:',XD.shape[0])
print('XD_shape[1]:',XD.shape[1])
输出：
XD: [[1 2 3]
[4 5 6]]
XD_shape: (2, 3)
XD_shape[0]: 2
XD_shape[1]: 3
label_row_inds, label_col_inds = np.where(np.isnan(Y) == False)
import numpy as np
a = np.array([1,np.nan,3])
b = np.array([4,5,np.nan])
XD = [a,b]
XD = np.asarray(XD)
print('XD:\n', XD)
x, y = np.where(np.isnan(XD) == False)
print('x: ', x)
print('y: ', y)
输出：
XD:
[[ 1. nan 3.]
[ 4. 5. nan]]
x: [0 0 1 1]
y: [0 2 0 1]
分析：
以(x,y)表示矩阵中行列，那么矩阵XD中为空值的地方有2处——(0,1)(1,2)，其余地方(0,0)(0,2)(1,0)(1,1)都是有值的。
输出的x，y是纵向看坐标点的。
XDinput = Input(shape=(FLAGS.max_smi_len,), dtype='int32')
tf.keras.Input函数：用来实例化一个keras张量，用于向模型中输入数据，并指定数据的形状、数据类型等信息。
Input(
shape=None,
batch_shape=None,
name=None,
dtype=K.floatx(),
sparse=False,
tensor=None
)
参数：
（1）shape: 形状元组（整型），不包括batch size。
例：
import numpy as np
a = np.array([1,2,3]) # 1个3维向量
print(a.shape)
输出：(3,)
（2）batch_shape: 形状元组（整型），包括了batch size。例如,batch_shape=(10,32)表示了预期的输入将是10个32维向量。
（3）name: 对于该层是可选的名字字符串。在一个模型中是独一无二的（同一个名字不能复用2次）。如果没有name，系统会自动生成特指的name。
（4）dtype: 预期的输入数据类型。
（5）sparse: 特定的布尔值，占位符是否为sparse（稀疏）。
（6）tensor: 可选的、存在的向量包装到Input层，如果设置了，该层将不会创建一个占位张量。
返回值： 一个张量
# this is a logistic regression in Keras
x = Input(shape=(32,))
y = Dense(16, activation='softmax')(x)
model = Model(x, y)
encode_smiles = Embedding(input_dim=FLAGS.charsmiset_size + 1, output_dim=128, input_length=FLAGS.max_smi_len)(XDinput)
kears Embedding()函数–嵌入层：
keras.layers.embeddings.Embedding(
input_dim,
output_dim,
embeddings_initializer='uniform',
embeddings_regularizer=None,
activity_regularizer=None,
embeddings_constraint=None,
mask_zero=False,
input_length=None
)
作用：将正整数（下标）转换为固定尺寸的稠密向量。 例如： [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]。Embedding层只能作为模型的第一层。
参数：
（1）input_dim：大或0的整数，字典长度，即输入数据最大下标+1，就是矩阵中的最大值。
（2）output_dim：大于0的整数，代表全连接嵌入的维度。
（3）embeddings_initializer: 嵌入矩阵的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
（4）embeddings_regularizer: 嵌入矩阵的正则项，为Regularizer对象
（5）embeddings_constraint: 嵌入矩阵的约束项，为Constraints对象
（6）mask_zero：布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用递归层处理变长输入时有用。设置为True的话，模型中后续的层必须都支持masking，否则会抛出异常。如果该值为True，则下标0在字典中不可用，input_dim应设置为|vocabulary| + 2。
（7）input_length：当输入序列的长度固定时，该值为其长度。如果要在该层后接Flatten层，然后接Dense层，则必须指定该参数，否则Dense层的输出维度无法自动推断。
encode_smiles = Conv1D(filters=NUM_FILTERS, kernel_size=FILTER_LENGTH1, activation='relu', padding='valid', strides=1)(encode_smiles)
作用：该层是一维卷积层，对层输入进行卷积， 以生成输出张量。
参数：
（1）filters：滤波器的数量。整数，输出空间的维度 （即卷积中滤波器的输出数量）。
（2）kernel_size：一个整数，核数量。
（3）activation：使用的激活函数，若不指定，则不使用激活函数 (即线性激活： a(x) = x)。
（4）padding：“valid” 或 “same” (大小写敏感)。
（5）strides：一个整数，卷积的步长。
encode_interaction = keras.layers.concatenate([encode_smiles, encode_protein], axis=-1)
keras.layers.concatenate([t1,t2], axis=-1)拼接函数：
参数：
（1）[t1,t2]: t1,t2是需要拼接的变量
（2）axis: 相接的轴
import numpy as np
import keras.backend as K
import tensorflow as tf
t1 = K.variable(np.array([[[1, 2],[2,3]],[[4,4], [5,3]]]))
t2 = K.variable(np.array([[[7, 4],[8,4]],[[2,10],[15,11]]]))
d0 = K.concatenate([t1,t2], axis=0)
d1 = K.concatenate([t1,t2], axis=1)
d2 = K.concatenate([t1,t2], axis=2)
d3 = K.concatenate([t1,t2], axis=-1)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print('t1:\n',sess.run(t1))
print('\nt2:\n',sess.run(t2))
print('\nd0:\n',sess.run(d0))
print('\nd1:\n',sess.run(d1))
print('\nd2:\n',sess.run(d2))
print('\nd3:\n',sess.run(d3))
输出：
t1:
[[[1. 2.]
[2. 3.]]
[[4. 4.]
[5. 3.]]]
t2:
[[[ 7. 4.]
[ 8. 4.]]
[[ 2. 10.]
[15. 11.]]]
d0:
[[[ 1. 2.]
[ 2. 3.]]
[[ 4. 4.]
[ 5. 3.]]
[[ 7. 4.]
[ 8. 4.]]
[[ 2. 10.]
[15. 11.]]]
d1:
[[[ 1. 2.]
[ 2. 3.]
[ 7. 4.]
[ 8. 4.]]
[[ 4. 4.]
[ 5. 3.]
[ 2. 10.]
[15. 11.]]]
d2:
[[[ 1. 2. 7. 4.]
[ 2. 3. 8. 4.]]
[[ 4. 4. 2. 10.]
[ 5. 3. 15. 11.]]]
d3:
[[[ 1. 2. 7. 4.]
[ 2. 3. 8. 4.]]
[[ 4. 4. 2. 10.]
[ 5. 3. 15. 11.]]]
FC1 = Dense(1024, activation='relu')(encode_interaction)
kears Dense()函数–全连接层：
keras.layers.core.Dense ( units, activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None )
参数：
（1）units：大于0的整数，代表该层的输出维度。
（2）activation：激活函数，为预定义的激活函数名（参考激活函数），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）
（3）use_bias: 布尔值，是否使用偏置项
（4）kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
（5）bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
（6）kernel_regularizer：施加在权重上的正则项，为Regularizer对象
（7）bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象
（8）activity_regularizer：施加在输出上的正则项，为Regularizer对象
（9）kernel_constraints：施加在权重上的约束项，为Constraints对象
（10）bias_constraints：施加在偏置上的约束项，为Constraints对象
（11）input_dim:可以指定输入数据的维度
interactionModel.compile(optimizer='adam', loss='mean_squared_error', metrics=[cindex_score])
kears model.compile()函数–配置模型
model.compile(
optimizer,
loss,
metrics=None,
sample_weight_mode=None
)
编译用来配置模型的学习过程，其参数有：
（1）optimizer：字符串（预定义优化器名）或优化器对象，参考优化器
（2）loss：字符串（预定义损失函数名）或目标函数，参考损失函数
（3）metrics：列表，包含评估模型在训练和测试时的网络性能的指标，典型用法是metrics=[‘accuracy’]
（4）sample_weight_mode：如果你需要按时间步为样本赋权（2D权矩阵），将该值设为“temporal”。默认为“None”，代表按样本赋权（1D权）。在下面fit函数的解释中有相关的参考内容。
print(interactionModel.summary())
使用keras构建深度学习模型，我们会通过model.summary()输出模型各层的参数状况，如下：
________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
dense_4 (Dense) (None, 7) 35
_________________________________________________________________
activation_4 (Activation) (None, 7) 0
_________________________________________________________________
dense_5 (Dense) (None, 13) 104
_________________________________________________________________
activation_5 (Activation) (None, 13) 0
_________________________________________________________________
dense_6 (Dense) (None, 5) 70
_________________________________________________________________
activation_6 (Activation) (None, 5) 0
=================================================================
Total params: 209
Trainable params: 209
Non-trainable params: 0
_________________________________________________________________
otherfoldsinds = [item for sublist in otherfolds for item in sublist]
sentences=[y for x in sentences for y in x]
等价于：
for x in sentences:
for y in x:
即：子列表中项目的子列表项目。
例1：将列表展平
>>> vec = [[1,2,3],[4,5,6],[7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
例2：
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
等价于：
>>> combs = []
>>> for x in [1,2,3]:
for y in [3,1,4]:
if x!=y:
combs.append((x,y))
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
numpy.stack(arrays, axis=0)
沿着新轴连接数组的序列。
axis参数指定新轴在结果尺寸中的索引。例如，如果axis=0，它将是第一个维度，如果axis=-1，它将是最后一个维度。
参数： 数组：array_like的序列每个数组必须具有相同的形状。axis：int，可选输入数组沿其堆叠的结果数组中的轴。
返回： 堆叠：ndarray堆叠数组比输入数组多一个维。
>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> a.shape
(3,)
>>> b.shape
(3,)
>>> np.stack((a, b), axis=0).shape
(2, 3)
>>> np.stack((a, b), axis=1).shape
(3, 2)
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=15)
EarlyStopping则是用于提前停止训练的callbacks。具体地，可以达到当训练集上的loss不在减小（即减小的程度小于某个阈值）的时候停止继续训练。
即防止过度拟合。
参数：
（1）monitor: 监控的数据接口，有’acc’,’val_acc’,’loss’,’val_loss’等等。正常情况下如果有验证集，就用’val_acc’或者’val_loss’。但是因为笔者用的是5折交叉验证，没有单设验证集，所以只能用’acc’了。
（2）min_delta：增大或减小的阈值，只有大于这个部分才算作improvement。这个值的大小取决于monitor，也反映了你的容忍程度。例如笔者的monitor是’acc’，同时其变化范围在70%-90%之间，所以对于小于0.01%的变化不关心。加上观察到训练过程中存在抖动的情况（即先下降后上升），所以适当增大容忍程度，最终设为0.003%。
（3）patience：能够容忍多少个epoch内都没有improvement。这个设置其实是在抖动和真正的准确率下降之间做tradeoff。如果patience设的大，那么最终得到的准确率要略低于模型可以达到的最高准确率。如果patience设的小，那么模型很可能在前期抖动，还在全图搜索的阶段就停止了，准确率一般很差。patience的大小和learning rate直接相关。在learning rate设定的情况下，前期先训练几次观察抖动的epoch number，比其稍大些设置patience。在learning rate变化的情况下，建议要略小于最大的抖动epoch number。笔者在引入EarlyStopping之前就已经得到可以接受的结果了，EarlyStopping算是锦上添花，所以patience设的比较高，设为抖动epoch number的最大值。
（4）mode: 就’auto’, ‘min’, ‘,max’三个可能。如果知道是要上升还是下降，建议设置一下。笔者的monitor是’acc’，所以mode=’max’。
min_delta和patience都和“避免模型停止在抖动过程中”有关系，所以调节的时候需要互相协调。通常情况下，min_delta降低，那么patience可以适当减少；min_delta增加，那么patience需要适当延长；反之亦然。
- Keras model.fit() 函数
见Keras model.fit() 函数
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
