keras：训练前如何获得初始损失函数值

在Keras中，我检查了回调机制。 但是，在开始训练之前，它不提供任何信息。就像输出总是在epoch=1之后。我想第一次检查损失函数的值前馈。我如何实现这一点？ 谢谢

这个答案行不通。 “设置model.trainable=False，然后训练模型”

在编译模型之前，我设置model.trainable=False，但是模型仍然输出不同的损耗函数。这很奇怪。它应该输出一个常量损耗，即执行正向馈电时的损耗

The code is in the following:

from keras import backend as K
from keras.models import Model
from keras.layers import Dense, Input
from keras.models import Sequential
import numpy as np
import random
from keras.layers import Input, Dense
from keras.models import Model
from keras.layers.core import Dropout,Activation,Flatten,Lambda
from keras.layers.normalization import BatchNormalization
import keras
import time
from sklearn.preprocessing import StandardScaler
import tensorflow as tf
from ann_visualizer.visualize import ann_viz;

def gen_x(n,p,rho):
    if abs(rho) < 1 :
        beta=np.sqrt(rho/(1-rho))
        x0=np.random.normal(size=(n,p))
        z=np.random.normal(size=(n,1))
        x=beta*np.repeat(z,repeats=p,axis=1)+x0

    if abs(rho)==1:
        x=np.repeat(z,repeats=p,axis=1)
    return x


## This function creates true survival times as described in section 3 of the paper. In all simulations we set snr (signal to noise ratio) to 3.
def genecoef(p):
    #return list( map(lambda x : np.power(-1,x)*np.exp(-0.1*(x-1)), np.arange(1,p+1,1)) )
    return list( np.random.rand(p) )

def gen_times(x,snr):
    n,p=x.shape
    coef=genecoef(p)
    f=np.matmul(np.matrix(x),np.matrix(coef).T)
    e=np.random.normal(size=(n,1))
    k=np.sqrt(np.var(f)/(snr*np.var(e)))
    y=np.exp(f+k*e)
    return(y)


## This function creates true survival times as described in section 3 of the paper. In all simulations we set snr (signal to noise ratio) to 3.

def gen_times_censor(x,snr):
    n,p=x.shape
    coef=genecoef(p)
    f=np.matmul(np.matrix(x),np.matrix(coef).T)
    e=np.random.normal(size=(n,1))
    k=np.sqrt(np.var(f)/(snr*np.var(e)))
    y=np.exp(k*e)
    return(y)
def nltr(x):
    y1 = x[:,0]*x[:,1]
    y2 = x[:,2]*x[:,3]
    y3 = x[:,4]**2
    y4 = x[:,5]* (x[:,6]**2)
    y5 = x[:,7]*x[:,8]* x[:,9]
    y6 = 0.5 *np.exp(x[:,8]* x[:,9])
    newx = np.column_stack((y1,y2,y3,y4,y5,y6))
    return newx


def survdata(n,p,snr,rho):
    x = gen_x(n,p,rho)
    time = gen_times(x,snr)
    censortime = gen_times_censor(x,snr)
    y = np.apply_along_axis(np.min,1,np.column_stack((time,censortime)))
    y = np.array(y)
    #b==0 censored b ==1 uncensored
    b = np.apply_along_axis(np.argmax,1,np.column_stack((time,censortime)))
    b = np.array(b)
    a = x
    ordery=np.argsort(y)
    a=a[ordery]
    y=y[ordery]
    b=b[ordery]
    Rlist=[]
    event_index=np.argwhere(b==1).ravel().astype(np.int32)
    nsample=len(b)
    nevent=sum(b)
    Rlist=[]
    for j in range(nevent):
        Rlist+=[ list(range(np.argwhere(b==1).ravel()[j],nsample) )]
    bmask = b.astype(bool)
    cumlist=list(reversed(np.append(event_index,n)))
    slarr=np.vectorize(lambda x:(len(x)-1))
    nctrue = np.sum(slarr(Rlist))
    #a:n(#samples)*p(#features) matrix,survival time from short to high
    #y:survival time
    #b censored(0) or not(1)
    #bmask bool(b)
    #nevent #uncensored
    return a,y,b,bmask,nsample,nevent,event_index,Rlist,cumlist,nctrue


n=50
p=10
snr=1
rho=0.1
a,y,b,bmask,nsample,nevent,event_index,Rlist,cumlist,nctrue= survdata(n,p,snr,rho)

sc=StandardScaler()

a=nltr(a)
a=sc.fit_transform(a)




def ploss(y_true,y_pred):
    #y_pred for sample x_i is the value of np.dot(x_i,beta) in the linear cox case
    #y_pred is the loss for sample i
    z = 0
    #for j in event_index:
        #z = z + K.sum(y_pred[j,0])
        #z = z + K.constant(y_pred[j,0])
    #z = K.sum(tf.boolean_mask(y_pred,bmask) )   
    #iz = K.print_tensor(tf.boolean_mask(y_pred,bmask),'y_pred_mask is')
    #gz = K.print_tensor(K.gather(y_pred,event_index),'y_pred_gather is')
    z = K.sum(K.gather(y_pred,event_index))
    currentsum = 0
    for j in range(nevent):
        currentsum = currentsum + K.sum(K.exp(K.gather(y_pred,\
        np.array(range(cumlist[j+1],cumlist[j])))))
        z = z - K.log(currentsum)
        #tempz=0
        #for i in j:
            #tempz = tempz + K.exp(y_pred[i,0])
        #z = z - K.log(tempz)
    z = -z    
    return z





def c_index_func(y_true, y_pred):
    #y_pred is the loss for sample i
    c_hat = 0
    for i in range(nevent-1):
        c_hat = c_hat + K.sum(K.cast(y_pred[event_index[i]+1:,0]\
        <y_pred[event_index[i],0],tf.float32))
        #c_hat = c_hat + K.sum(K.cast(y_pred[event_index[i]+1:,0]\
                                             #<y_pred[event_index[i],0],float32))

    return c_hat/nctrue 


model=Sequential()
model.add(Dense(1,activation='linear',kernel_initializer='one',\
                batch_input_shape=(a.shape[0],a.shape[1])))

#model.add(Dropout(0.2))

#model.compile(loss=ploss,optimizer='newton-raphson')

#model.compile(loss=ploss,optimizer=keras.optimizers.Adam(lr=0, beta_1=0.9, beta_2=0.999, \
#epsilon=None, decay=0.0, amsgrad=False),metrics=[c_index_func])
model.trainable=False
model.compile(loss=ploss,optimizer=keras.optimizers.SGD(lr=0.001, momentum=0.0, \
decay=0.0, nesterov=False),metrics=[c_index_func])

model.fit(x=a,y=y,batch_size=len(a),epochs=3,verbose=2)

代码如下所示：
从keras导入后端为K
从keras.models导入模型
从keras.layers导入稠密，输入
从keras.models导入顺序
将numpy作为np导入
随机输入
从keras.layers导入输入，密集
从keras.models导入模型
从keras.layers.core导入退出、激活、展平、Lambda
从keras.layers.normalization导入批处理normalization
进口干酪
导入时间
从sklearn.preprocessing导入StandardScaler
导入tensorflow作为tf
从ann_visualizer.visualize导入ann_viz；
def gen_x（n、p、rho）：
如果abs（rho）<1：
β=np.sqrt（rho/（1-rho））
x0=np.随机.正态（大小=（n，p））
z=np.random.normal（大小=（n，1））
x=beta*np.重复（z，重复=p，轴=1）+x0
如果abs（rho）==1：
x=np.重复（z，重复=p，轴=1）
返回x
##该函数可创建本文第3节所述的真实生存时间。在所有的模拟中，我们将信噪比设置为3。
def genecoef（p）：
#返回列表（映射（lambda x:np.power（-1，x）*np.exp（-0.1*（x-1）），np.arange（1，p+1,1）））
返回列表（np.random.rand（p））
def gen_次数（x，信噪比）：
n、 p=x.形状
系数=基因系数（p）
f=np.matmul（np.matrix（x），np.matrix（coef）.T）
e=np.随机.正常（大小=（n，1））
k=np.sqrt（np.var（f）/（snr*np.var（e）））
y=np.exp（f+k*e）
返回（y）
##该函数可创建本文第3节所述的真实生存时间。在所有的模拟中，我们将信噪比设置为3。
def gen_times_审查员（x，snr）：
n、 p=x.形状
系数=基因系数（p）
f=np.matmul（np.matrix（x），np.matrix（coef）.T）
e=np.随机.正常（大小=（n，1））
k=np.sqrt（np.var（f）/（snr*np.var（e）））
y=np.exp（k*e）
返回（y）
def nltr（x）：
y1=x[：，0]*x[：，1]
y2=x[：，2]*x[：，3]
y3=x[：，4]**2
y4=x[：，5]*（x[：，6]**2）
y5=x[：，7]*x[：，8]*x[：，9]
y6=0.5*np.exp（x[：，8]*x[：，9]）
newx=np.列_堆栈（（y1，y2，y3，y4，y5，y6））
返回newx
def survdata（n、p、snr、rho）：
x=gen_x（n，p，rho）
时间=发电次数（x，信噪比）
censtortime=gen_乘以censtor（x，snr）
y=np.沿_轴应用_（np.min，1，np.column_堆栈（（时间，截取时间）））
y=np.数组（y）
#b==0已审查b==1未审查
b=np.apply_沿_轴（np.argmax，1，np.column_堆栈（（time，censtortime）））
b=np.数组（b）
a=x
ordery=np.argsort（y）
a=a[有序]
y=y[ordery]
b=b[ordery]
Rlist=[]
event_index=np.argwhere（b==1.ravel（）.astype（np.int32）
nsample=len（b）
nevent=总和（b）
Rlist=[]
对于范围内的j（无）：
Rlist+=[list（范围（np.argwhere（b==1.ravel（）[j]，nsample））]
b任务=b.astype（bool）
cumlist=list（反向（np.append（事件索引，n）））
slarr=np.矢量化（λx：（len（x）-1））
nctrue=np.和（slarr（Rlist））
#a:n（#样本）*p（#特征）矩阵，生存时间由短到高
#y：生存时间
#b被删失（0）或未删失（1）
#b任务布尔（b）
#从未未经审查
返回a、y、b、bmask、nsample、nevent、事件索引、Rlist、cumlist、nctrue
n=50
p=10
信噪比=1
rho=0.1
a、 y，b，b任务，nsample，nevent，event_索引，Rlist，cumlist，nctrue=survdata（n，p，snr，rho）
sc=StandardScaler（）
a=nltr（a）
a=sc.fit_变换（a）
def ploss（y_true，y_pred）：
#样本x_i的y_pred是线性cox情况下np.dot（x_i，beta）的值
#y_pred是样本i的损失
z=0
#对于事件索引中的j：
#z=z+K.sum（y_pred[j，0]）
#z=z+K.常数（y_pred[j，0]）
#z=K.sum（tf.boolean_掩码（y_pred，bmask））
#iz=K.print_张量（tf.boolean_mask（y_pred，bmask），'y_pred_mask is'）
#gz=K.print\u张量（K.gather（y\u pred，event\u index），'y\u pred\u gather is'）
z=K.sum（K.gather（y_pred，event_index））
currentsum=0
对于范围内的j（无）：
currentsum=currentsum+K.sum\
np.数组（范围（cumlist[j+1]，cumlist[j]()())）
z=z-K.log（当前总和）
#tempz=0
#对于j中的i：
#tempz=tempz+K.exp（y_pred[i，0]）
#z=z-K.log（tempz）
z=-z
返回z
def c_index_func（y_true，y_pred）：
#y_pred是样本i的损失
c_hat=0
对于范围内的i（nevent-1）：
c_hat=c_hat+K.sum（K.cast）（y_pred[event_index[i]+1:0]\
为此，您可以使用
model.evaluate（x，y）
它将返回一个包含损失和度量的数组。该数组的第一个元素是给定数据的损失。只需在培训之前执行此操作，它将为您提供初始损失。
非常简单，只需将学习速率设置为0

并培训DNN，然后所有损失都是初始损失

如何输出损失乐趣在epoch=0时的Action？这真的很有帮助。