请教一下，我自己写了个resnet，18层跑的结果也只有72%，换成34层了之后，测试集却只有63%了 我拿我自己的4层的简单的CNN都能跑出来75的效果，有什么可以提高的方法吗？那些高准确率，实际上是不是做过数据增强了的啊

我用keras构建了一个[7,200,200,200,200,1]的前向神经网络做回归，7个输入变量，1个输出变量。9000组训练样本，1072组测试样本。训练样本拟合相关系数达到0.98-0.99，测试样本相关系数为0.3-0.4,。后来，我加上dropout,l2正则化，训练样本相关系数降到0.5左右了，测试样本R才升到0.5 这究竟怎么回事？实在没办法了，求帮助啊

 我想从一个预训练的卷积神经网络的不同层中提取特征，然后把这些不同层的特征拼接在一起，实现如上图一样的网络结构，我写的代码如下 ``` base_model = VGGFace(model='resnet50', include_top=False) model1 = base_model model2 = base_model input1 = Input(shape=(197,197,3)) model1_out = model1.layers[-12].output model1_in = model1.layers[0].output model1 = Model(model1_in,model1_out) x1 = model1(input1) x1 = GlobalMaxPool2D()(x1) x2 = model2(input1) x2 = GlobalMaxPool2D()(x2) out = Concatenate(axis=-1)([x1,x2]) out = Dense(1,activation='sigmoid')(out) model3 = Model([input1,input2],out) from keras.utils import plot_model plot_model(model3,"model3.png") import matplotlib.pyplot as plt img = plt.imread('model3.png') plt.imshow(img) ``` 但模型可视化显示如下，两个网络的权值并不共享。

用下面这样的代码测试的时候result都是固定值 之前都是用model.add这样来写结构的 不知道是不是结构写法的问题，model.add这样就没问题 ``` x = load_img(file, target_size=(img_width,img_height)) x = img_to_array(x) x = np.expand_dims(x, axis=0) array = model.predict(x) result = array[0] ``` training.py: ``` # coding=utf-8 from keras.models import Model from keras.layers import Input, Dense, Dropout, BatchNormalization, Conv2D, MaxPooling2D, AveragePooling2D, concatenate, \ Activation, ZeroPadding2D from keras.layers import add, Flatten from keras.utils import plot_model from keras.metrics import top_k_categorical_accuracy from keras.preprocessing.image import ImageDataGenerator from keras.models import load_model from keras import optimizers import os import sys import tensorflow as tf from keras import callbacks config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)) sess = tf.Session(config=config) DEV = False argvs = sys.argv argc = len(argvs) if argc > 1 and (argvs[1] == "--development" or argvs[1] == "-d"): DEV = True if DEV: EPOCH=4 else: EPOCH=1 # Global Constants samples_per_epoch = 3750 validation_steps = 490 NB_CLASS=5 IM_WIDTH=100 IM_HEIGHT=100 train_root='data/train' vaildation_root='data/test' batch_size=16 lr=0.0004 # train data train_datagen = ImageDataGenerator( width_shift_range=0.1, height_shift_range=0.1, shear_range=0.1, zoom_range=0.1, horizontal_flip=True, rescale=1./255 ) train_generator = train_datagen.flow_from_directory( train_root, target_size=(IM_WIDTH, IM_HEIGHT), batch_size=batch_size, shuffle=True ) # vaild data vaild_datagen = ImageDataGenerator( width_shift_range=0.1, height_shift_range=0.1, shear_range=0.1, zoom_range=0.1, horizontal_flip=True, rescale=1./255 ) vaild_generator = train_datagen.flow_from_directory( vaildation_root, target_size=(IM_WIDTH, IM_HEIGHT), batch_size=batch_size, ) def Conv2d_BN(x, nb_filter, kernel_size, strides=(1, 1), padding='same', name=None): if name is not None: bn_name = name + '_bn' conv_name = name + '_conv' else: bn_name = None conv_name = None x = Conv2D(nb_filter, kernel_size, padding=padding, strides=strides, activation='relu', name=conv_name)(x) x = BatchNormalization(axis=3, name=bn_name)(x) return x def identity_Block(inpt, nb_filter, kernel_size, strides=(1, 1), with_conv_shortcut=False): x = Conv2d_BN(inpt, nb_filter=nb_filter, kernel_size=kernel_size, strides=strides, padding='same') x = Conv2d_BN(x, nb_filter=nb_filter, kernel_size=kernel_size, padding='same') if with_conv_shortcut:#shortcut的含义是：将输入层x与最后的输出层y进行连接，如上图所示 shortcut = Conv2d_BN(inpt, nb_filter=nb_filter, strides=strides, kernel_size=kernel_size) x = add([x, shortcut]) return x else: x = add([x, inpt]) return x def resnet_34(width,height,channel,classes): inpt = Input(shape=(width, height, channel)) x = ZeroPadding2D((3, 3))(inpt) #conv1 x = Conv2d_BN(x, nb_filter=64, kernel_size=(7, 7), strides=(2, 2), padding='valid') x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')(x) #conv2_x x = identity_Block(x, nb_filter=64, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=64, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=64, kernel_size=(3, 3)) #conv3_x x = identity_Block(x, nb_filter=128, kernel_size=(3, 3), strides=(2, 2), with_conv_shortcut=True) x = identity_Block(x, nb_filter=128, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=128, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=128, kernel_size=(3, 3)) #conv4_x x = identity_Block(x, nb_filter=256, kernel_size=(3, 3), strides=(2, 2), with_conv_shortcut=True) x = identity_Block(x, nb_filter=256, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=256, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=256, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=256, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=256, kernel_size=(3, 3)) #conv5_x x = identity_Block(x, nb_filter=512, kernel_size=(3, 3), strides=(2, 2), with_conv_shortcut=True) x = identity_Block(x, nb_filter=512, kernel_size=(3, 3)) x = identity_Block(x, nb_filter=512, kernel_size=(3, 3)) x = AveragePooling2D(pool_size=(4, 4))(x) x = Flatten()(x) x = Dense(classes, activation='softmax')(x) model = Model(inputs=inpt, outputs=x) return model if __name__ == '__main__': if (os.path.exists('modelresnet') and DEV): model = load_model('./modelresnet/resnet_50.h5')######## model.load_weights('./modelresnet/weights.h5') else: model = resnet_34(IM_WIDTH,IM_HEIGHT,3,NB_CLASS) model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=lr), metrics=['accuracy']) print ('Model Compiled') model.fit_generator( train_generator, samples_per_epoch=samples_per_epoch, epochs=EPOCH, validation_data=vaild_generator, validation_steps=validation_steps) target_dir = './modelresnet/' if not os.path.exists(target_dir): os.mkdir(target_dir) model.save('./modelresnet/resnet_50.h5') model.save_weights('./modelresnet/weights.h5') #loss,acc,top_acc=model.evaluate_generator(test_generator, steps=test_generator.n / batch_size) #print 'Test result:loss:%f,acc:%f,top_acc:%f' % (loss, acc, top_acc) ```

各位大神好，我是小白，看了一些关于过拟合正则化的文章，文章都说正则化项是加在目标函数/损失函数上的，但我看keras的文档上，正则化都是加在层上的，我不是很理解，难到不能加在损失函数上吗。其次正则化的参数 lamda值要是过拟合的话大致通常设置多少比较好，或者你们都拿多少开始试的。谢谢各位大神。

刚刚开始学习keras，今天在测试非线性函数拟合的时候发现即便用了‘relu’激活函数还是没有办法很好的拟合结果，这已经困扰我很久了，而且更奇怪的是有一句看起来和结果毫无关系的语句居然会直接改变结果的分布 就是这一句： ``` print(y_pred) ``` 没有加的时候的结果：  加了之后的结果：  或者  代码如下： ``` import keras import numpy as np import matplotlib.pyplot as plt #按顺序构成的模型 from keras.models import Sequential #全连接层 from keras.layers import Dense,Activation from keras.optimizers import SGD #使用numpy生成随机数据 x_data = np.linspace(-0.5,0.5,200) noise = np.random.normal(0,0.02,x_data.shape) y_data = np.square(x_data) + noise #显示随机点 plt.scatter(x_data,y_data) plt.show() # 构建一个顺序模型 model = Sequential() # 在模型中添加一个全连接层 model.add(Dense(units=10,input_dim=1,activation='relu')) # model.add(Activation("relu"))不行? #model.add(Activation("relu")) model.add(Dense(units=1,activation='relu')) # model.add(Activation("relu"))不行 #model.add(Activation("relu")) # 定义优化算法 sgd = SGD(lr=0.3) model.compile(optimizer=sgd,loss="mse") for step in range(3000): cost = model.train_on_batch(x_data,y_data) if step%500==0: print("cost: ",cost) W,b = model.layers[0].get_weights() print("W: ",W,"b: ",b) # x_data输入网络中，得到预测值 y_pred = model.predict(x_data) # 加不加这一句会对结果造成直接影响 print(y_pred) plt.scatter(x_data,y_pred) plt.plot(x_data,y_pred,"r-",lw=3) plt.show() ```

 各位大神，如图所示，在训练过程中，第二轮开始出现问题，这是什么原因呢？ 代码如下： ------------------------------------------------- ``` import random import keras import numpy as np import cv2 from sklearn.model_selection import train_test_split from keras.preprocessing.image import ImageDataGenerator from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D from keras.optimizers import SGD from keras.utils import np_utils from keras.models import load_model from keras import backend as K from source_data import load_dataset,resize_img #定义数据集格式 class Dataset: def __init__(self, path_name): #训练数据集 self.train_images = None self.train_labels = None #测试集 self.valid_images = None self.valid_labels = None #样本数据 self.test_images = None self.test_labels = None #load路径 self.path_name = path_name #维度顺序 self.input_shape = None #加载数据集并按照交叉验证的原则划分数据集，完成数据预处理 def load(self,img_rows=64, img_cols=64,img_channels = 3,nb_classes = 2): #加载数据集到内存 images,labels=load_dataset(self.path_name)#函数调用 train_images, valid_images, train_labels, valid_labels= train_test_split(images, labels, test_size = 0.3, random_state = random.randint(0, 100)) _, test_images, _, test_labels = train_test_split(images, labels, test_size = 0.5, random_state = random.randint(0, 100)) #根据backend类型确定输入图片数据时的顺序为：channels,rows,cols，否则:rows,cols,channels #这部分代码就是根据keras库要求的维度顺序重组训练数据集 train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, img_channels) valid_images = valid_images.reshape(valid_images.shape[0], img_rows, img_cols, img_channels) test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, img_channels) self.input_shape = (img_rows, img_cols, img_channels) #输出训练集、验证集、测试集的数量 print(train_images.shape[0], 'train samples') print(valid_images.shape[0], 'valid samples') print(test_images.shape[0], 'test samples') #我们的模型使用categorical_crossentropy作为损失函数，因此需要根据类别数量nb_classes将 #类别标签进行one-hot编码使其向量化，在这里我们的类别只有两种，经过转化后标签数据变为二维 train_labels = np_utils.to_categorical(train_labels, nb_classes) valid_labels = np_utils.to_categorical(valid_labels, nb_classes) test_labels = np_utils.to_categorical(test_labels, nb_classes) #像素数据浮点化以便归一化 train_images = train_images.astype('float32') valid_images = valid_images.astype('float32') test_images = test_images.astype('float32') #将其归一化,图像的各像素值归一化到0—1区间 train_images /= 255 valid_images /= 255 test_images /= 255 self.train_images = train_images self.valid_images = valid_images self.test_images = test_images self.train_labels = train_labels self.valid_labels = valid_labels self.test_labels = test_labels class Model: def __init__(self): self.model = None #建立keras模型 def build_model(self, dataset, nb_classes = 2): #构建一个空的网络模型，序贯模型或线性堆叠模型，添加各个layer self.model = Sequential() #以下代码将顺序添加CNN网络需要的各层，一个add就是一个网络层 self.model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape = dataset.input_shape)) #1 2维卷积层 self.model.add(Activation('relu')) #2 激活函数层 self.model.add(Convolution2D(32, 3, 3)) #3 2维卷积层 self.model.add(Activation('relu')) #4 激活函数层 self.model.add(MaxPooling2D(pool_size=(2, 2))) #5 池化层 self.model.add(Dropout(0.25)) #6 Dropout层 self.model.add(Convolution2D(64, 3, 3, border_mode='same')) #7 2维卷积层 self.model.add(Activation('relu')) #8 激活函数层 self.model.add(Convolution2D(64, 3, 3)) #9 2维卷积层 self.model.add(Activation('relu')) #10 激活函数层 self.model.add(MaxPooling2D(pool_size=(2, 2))) #11 池化层 self.model.add(Dropout(0.25)) #12 Dropout层 self.model.add(Flatten()) #13 Flatten层 self.model.add(Dense(512)) #14 Dense层,又被称作全连接层 self.model.add(Activation('relu')) #15 激活函数层 self.model.add(Dropout(0.5)) #16 Dropout层 self.model.add(Dense(nb_classes)) #17 Dense层 self.model.add(Activation('softmax')) #18 分类层，输出最终结果 #Prints a string summary of the network self.model.summary() #训练模型 def train(self, dataset, batch_size = 20, nb_epoch = 10, data_augmentation = True): sgd = SGD(lr = 0.01, decay = 1e-6, momentum = 0.9, nesterov = True) #采用随机梯度下降优化器进行训练，首先生成一个优化器对象 self.model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy']) #完成实际的模型配置 #不使用数据提升，所谓的提升就是从我们提供的训练数据中利用旋转、翻转、加噪声等方法提升训练数据规模，增加模型训练量 if not data_augmentation: self.model.fit(dataset.train_images, dataset.train_labels, batch_size = batch_size, epochs = nb_epoch, validation_data = (dataset.valid_images, dataset.valid_labels), shuffle = True) #使用实时数据提升 else: #定义数据生成器用于数据提升，其返回一个生成器对象datagen，datagen每被调用一 #次其生成一组数据（顺序生成），节省内存，其实就是python的数据生成器 datagen = ImageDataGenerator( featurewise_center = False, #是否使输入数据去中心化（均值为0）， samplewise_center = False, #是否使输入数据的每个样本均值为0 featurewise_std_normalization = False, #是否数据标准化（输入数据除以数据集的标准差） samplewise_std_normalization = False, #是否将每个样本数据除以自身的标准差 zca_whitening = False, #是否对输入数据施以ZCA白化 rotation_range = 20, #数据提升时图片随机转动的角度(范围为0～180) width_shift_range = 0.2, #数据提升时图片水平偏移的幅度（单位为图片宽度的占比，0~1之间的浮点数） height_shift_range = 0.2, #同上，只不过这里是垂直 horizontal_flip = True, #是否进行随机水平翻转 vertical_flip = False) #是否进行随机垂直翻转 #计算整个训练样本集的数量以用于特征值归一化等处理 datagen.fit(dataset.train_images) #利用生成器开始训练模型—0.7*N self.model.fit_generator(datagen.flow(dataset.train_images, dataset.train_labels, batch_size = batch_size), steps_per_epoch = dataset.train_images.shape[0], epochs = nb_epoch, validation_data = (dataset.valid_images, dataset.valid_labels)) if __name__ == '__main__': dataset = Dataset('e:\saving') dataset.load()#实例操作，完成实际数据加载和预处理 model = Model() model.build_model(dataset) #训练数据 model.train(dataset) ```

已经训练好的model，比如想在后面再添加lstm或者全连接层应该怎么做呢？

keras搭的模型，训练时候，使用相同的loss和metrics，但是输出却不一样，为什么会出现这种情况呀

还没入门的新手，看了一些论文，都用resnet50和VGG16训练网络模型，然而结论不同，有的是VGG16精度高，有的是Resnet50精度高。自己做训练集，用两种网络去训练模型时结果显示VGG16精度更高，用的是Keras retinanet。按说resnet50网络更深，且解决了梯度爆炸的问题，为什么mAP不如VGG16？求大神告知。。。 并且，Keras retinanet和fast r-cnn、faster r-cnn或者YOLO2等检测网络是什么关系？。。。

做的8推1的时序预测，但是不管怎么修改模型，一直都是过拟合的状态，loss下降 val loss上升，val loss一点下降趋势也没有，直接往上走， 已经用了dropout(0.5)也试过用BatchNormalization()，但都没办法完全改善 想知道到底问题出在哪里 训练集和测试集（x，y）大小是(80000, 10, 8) (25000, 10, 8) (80000,) (25000,) ``` #数据整理 train = values[0:timestep*num] valid =values[timestep*num:] time_stamp = 10 scaled_data = scaler.fit_transform(train) x_train, y_train = [], [] for i in range(time_stamp, len(train)): x_train.append(scaled_data[i - time_stamp:i,0:8]) y_train.append(scaled_data[i, 8]) # y_train.append(scaled_data[i - time_stamp, 8]) # y_train.append(scaled_data[i - time_stamp:i, 8]) x_train, y_train = np.array(x_train), np.array(y_train) scaled_data = scaler.fit_transform(valid) x_valid, y_valid = [], [] for i in range(time_stamp, len(valid)): x_valid.append(scaled_data[i - time_stamp:i,0:8]) y_valid.append(scaled_data[i, 8]) # y_valid.append(scaled_data[i - time_stamp, 8]) # y_valid.append(scaled_data[i - time_stamp:i, 8]) x_valid, y_valid = np.array(x_valid), np.array(y_valid) print(x_train.shape,x_valid.shape, y_train.shape, y_valid.shape) #lstm模型 epochs = 60 batch_size = 256 model = Sequential() model.add(LSTM(units=128, return_sequences=True, input_dim=x_train.shape[-1], input_length=x_train.shape[1])) model.add(Dropout(0.5)) model.add(LSTM(units=64)) model.add(Dropout(0.5)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='rmsprop') history =model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size,validation_data=(x_valid,y_valid), verbose=2) ```  上图中蓝色为loss曲线，黄色为val loss

**cifar-10分类问题，同样的模型结构以及损失函数还有学习率参数等超参数，分别用TensorFlow和keras实现。 20个epochs后在测试集上进行预测，准确率总是差好几个百分点，不知道问题出在哪里？代码如下： 这个是TF的代码：** import tensorflow as tf import numpy as np import pickle as pk tf.reset_default_graph() batch_size = 64 test_size = 10000 img_size = 32 num_classes = 10 training_epochs = 10 test_size=200 ############################################################################### def unpickle(filename): '''解压数据''' with open(filename, 'rb') as f: d = pk.load(f, encoding='latin1') return d def onehot(labels): '''one-hot 编码''' n_sample = len(labels) n_class = max(labels) + 1 onehot_labels = np.zeros((n_sample, n_class)) onehot_labels[np.arange(n_sample), labels] = 1 return onehot_labels # 训练数据集 data1 = unpickle('data_batch_1') data2 = unpickle('data_batch_2') data3 = unpickle('data_batch_3') data4 = unpickle('data_batch_4') data5 = unpickle('data_batch_5') X_train = np.concatenate((data1['data'], data2['data'], data3['data'], data4['data'], data5['data']), axis=0)/255.0 y_train = np.concatenate((data1['labels'], data2['labels'], data3['labels'], data4['labels'], data5['labels']), axis=0) y_train = onehot(y_train) # 测试数据集 test = unpickle('test_batch') X_test = test['data']/255.0 y_test = onehot(test['labels']) del test,data1,data2,data3,data4,data5 ############################################################################### w = tf.Variable(tf.random_normal([5, 5, 3, 32], stddev=0.01)) w_c= tf.Variable(tf.random_normal([32* 16* 16, 512], stddev=0.1)) w_o =tf.Variable(tf.random_normal([512, num_classes], stddev=0.1)) def init_bias(shape): return tf.Variable(tf.constant(0.0, shape=shape)) b=init_bias([32]) b_c=init_bias([512]) b_o=init_bias([10]) def model(X, w, w_c,w_o, p_keep_conv, p_keep_hidden,b,b_c,b_o): conv1 = tf.nn.conv2d(X, w,strides=[1, 1, 1, 1],padding='SAME')#32x32x32 conv1=tf.nn.bias_add(conv1,b) conv1 = tf.nn.relu(conv1) conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1],padding='SAME')#16x16x32 conv1 = tf.nn.dropout(conv1, p_keep_conv) FC_layer = tf.reshape(conv1, [-1, 32 * 16 * 16]) out_layer=tf.matmul(FC_layer, w_c)+b_c out_layer=tf.nn.relu(out_layer) out_layer = tf.nn.dropout(out_layer, p_keep_hidden) result = tf.matmul(out_layer, w_o)+b_o return result trX, trY, teX, teY = X_train,y_train,X_test,y_test trX = trX.reshape(-1, img_size, img_size, 3) teX = teX.reshape(-1, img_size, img_size, 3) X = tf.placeholder("float", [None, img_size, img_size, 3]) Y = tf.placeholder("float", [None, num_classes]) p_keep_conv = tf.placeholder("float") p_keep_hidden = tf.placeholder("float") py_x = model(X, w, w_c,w_o, p_keep_conv, p_keep_hidden,b,b_c,b_o) Y_ = tf.nn.softmax_cross_entropy_with_logits_v2(logits=py_x, labels=Y) cost = tf.reduce_mean(Y_) optimizer = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost) predict_op = tf.argmax(py_x, 1) with tf.Session() as sess: tf.global_variables_initializer().run() for i in range(training_epochs): training_batch = zip(range(0, len(trX),batch_size),range(batch_size, len(trX)+1,batch_size)) perm=np.arange(len(trX)) np.random.shuffle(perm) trX=trX[perm] trY=trY[perm] for start, end in training_batch: sess.run(optimizer, feed_dict={X: trX[start:end],Y: trY[start:end],p_keep_conv:0.75,p_keep_hidden: 0.5}) test_batch = zip(range(0, len(teX),test_size),range(test_size, len(teX)+1,test_size)) accuracyResult=0 for start, end in test_batch: accuracyResult=accuracyResult+sum(np.argmax(teY[start:end], axis=1) ==sess.run(predict_op, feed_dict={X: teX[start:end],Y: teY[start:end],p_keep_conv: 1,p_keep_hidden: 1})) print(i, accuracyResult/10000) **这个是keras代码：** from keras import initializers from keras.datasets import cifar10 from keras.utils import np_utils from keras.models import Sequential from keras.layers.core import Dense, Dropout, Activation, Flatten from keras.layers.convolutional import Conv2D, MaxPooling2D from keras.optimizers import SGD, Adam, RMSprop #import matplotlib.pyplot as plt # CIFAR_10 is a set of 60K images 32x32 pixels on 3 channels IMG_CHANNELS = 3 IMG_ROWS = 32 IMG_COLS = 32 #constant BATCH_SIZE = 64 NB_EPOCH = 10 NB_CLASSES = 10 VERBOSE = 1 VALIDATION_SPLIT = 0 OPTIM = RMSprop() #load dataset (X_train, y_train), (X_test, y_test) = cifar10.load_data() #print('X_train shape:', X_train.shape) #print(X_train.shape[0], 'train samples') #print(X_test.shape[0], 'test samples') # convert to categorical Y_train = np_utils.to_categorical(y_train, NB_CLASSES) Y_test = np_utils.to_categorical(y_test, NB_CLASSES) # float and normalization X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 # network model = Sequential() model.add(Conv2D(32, (3, 3), padding='same',input_shape=(IMG_ROWS, IMG_COLS, IMG_CHANNELS),kernel_initializer=initializers.random_normal(stddev=0.01),bias_initializer=initializers.Zeros())) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) #0<参数<1才会有用 model.add(Flatten()) model.add(Dense(512,kernel_initializer=initializers.random_normal(stddev=0.1),bias_initializer=initializers.Zeros())) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(NB_CLASSES,kernel_initializer=initializers.random_normal(stddev=0.1),bias_initializer=initializers.Zeros())) model.add(Activation('softmax')) model.summary() # train model.compile(loss='categorical_crossentropy', optimizer=OPTIM,metrics=['accuracy']) model.fit(X_train, Y_train, batch_size=BATCH_SIZE,epochs=NB_EPOCH, validation_split=VALIDATION_SPLIT,verbose=VERBOSE) score = model.evaluate(X_test, Y_test,batch_size=200, verbose=VERBOSE) print("Test score:", score[0]) print('Test accuracy:', score[1])

希望给出一个能运行的详细的自动编码器的示例代码（有注释）， 只写核心部分真的不会用。 我想实现这样的： 演示样本随意，比如：{(1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)} 1.从文本文档中导入样本(可选) 2.利用自动编码器取出特征(必须) 3.把编码得出的特征保存到一个文本文档中(说明怎么取编码得到的特征也行) 另外我想知道一个： 训练自动编码器是样本越多越好吗？比如我有30万个样本，全部用来训练自动编码器吗，还是说只取其中一部分来训练呢？ 我的开发环境是： 

已经按multi_gpu_model进行了设置 但是运行的时候还是只能调用一个GPU，另一张计算卡完全没用，是什么原因呢？ ``` from keras.utils import multi_gpu_model ... model = build_model() optimizer = keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06) model_parallel=multi_gpu_model(model,2) model_parallel.compile(loss='mse', optimizer=optimizer, metrics=['mae']) ... history = model_parallel.fit(train_data, y_train, epochs=EPOCHS, validation_split=0.2, verbose=1,callbacks=[PrintDot()]) ```  

我在学习神经网络 在做的时候我想让GPU来进行训练网络 所以如何调用GPU跑程序（keras框架）？？？

神经网络就是一个简单的lstm神经网络，调用了keras模块，现在想比较不同训练方法的效率，如何在训练完成后显示每一步训练以及最后训练完的总时间？

我在训练模型的过程中，训练集表现很好，loss很低，acc很高。但测试的时候测试集的loss一直在降低，但acc反而也降低了，没有提高，这是过拟合了么？

在用keras+gym测试policy gradient进行小车杆平衡时模型搭建如下： ``` inputs = Input(shape=(4,),name='ob_inputs') x = Dense(16,activation='relu')(inputs) x = Dense(16,activation='relu')(x) x = Dense(1,activation='sigmoid')(x) model = Model(inputs=inputs,outputs = x) ``` 这里输出层是一个神经元，输出一个[0,1]之间的数，表示小车动作的概率 但是在代码训练过程中，模型的训练代码为： ``` X = np.array(states) y = np.array(list(zip(actions,discount_rewards))) loss = self.model.train_on_batch(X,y) ``` 这里的target data（y）是一个2维的列表数组，第一列是对应执行的动作，第二列是折扣奖励，那么在训练的时候，神经网络的输出数据和target data的维度不一致，是如何计算loss的呢？会自动去拟合y的第一列数据吗？

 更改了keras的版本号，依然报错

大学四年，看课本是不可能一直看课本的了，对于学习，特别是自学，善于搜索网上的一些资源来辅助，还是非常有必要的，下面我就把这几年私藏的各种资源，网站贡献出来给你们。主要有：电子书搜索、实用工具、在线视频学习网站、非视频学习网站、软件下载、面试/求职必备网站。 注意：文中提到的所有资源，文末我都给你整理好了，你们只管拿去，如果觉得不错，转发、分享就是最大的支持了。 一、电子书搜索 对于大部分程序员...

今年，我也32了 ，为了不给大家误导，咨询了猎头、圈内好友，以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助，记得帮我点赞哦。 目录： 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时，拿着傲人的工资，想着好好干，以为我们的人生是这样的： 等真到了那一天，你会发现，你的人生很可能是这样的： ...

程序员在一个周末的时间，得了重病，差点当场去世，还好及时挽救回来了。

ArrayList源码分析 前言： 写这篇博客的主要原因是，在我上一次参加千牵科技Java实习生面试时，有被面试官问到ArrayList为什么查找的速度较快，插入和删除的速度较慢？当时我回答得不好，很大的一部分原因是因为我没有阅读过ArrayList源码，虽然最后收到Offer了，但我拒绝了，打算寒假学得再深入些再广泛些，下学期开学后再去投递其他更好的公司。为了更加深入理解ArrayList，也为

数据结构与算法思维导图

老生常谈的一个梗，到2020了还在争论，你们一天天的，哎哎哎，我不是针对你一个，我是说在座的各位都是人才！ 上图红色的这3个箭头，对于通过new产生一个字符串（”宜春”）时，会先去常量池中查找是否已经有了”宜春”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”宜春”对象的拷贝对象。 也就是说准确答案是产生了一个或两个对象，如果常量池中原来没有 ”宜春” ,就是两个。...

昨天早上通过远程的方式 review 了两名新来同事的代码，大部分代码都写得很漂亮，严谨的同时注释也很到位，这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时，还是忍不住破口大骂：“我擦，小王，你丫写的 switch 语句也太老土了吧！” 来看看小王写的代码吧，看完不要骂我装逼啊。 private static String createPlayer(PlayerTypes p...

互联网公司工作，很难避免不和黑客们打交道，我呆过的两家互联网公司，几乎每月每天每分钟都有黑客在公司网站上扫描。有的是寻找 Sql 注入的缺口，有的是寻找线上服务器可能存在的漏洞，大部分都...

loonggg读完需要3分钟速读仅需 1 分钟大家好，我是你们的校长。我之前讲过，这年头，只要肯动脑，肯行动，程序员凭借自己的技术，赚钱的方式还是有很多种的。仅仅靠在公司出卖自己的劳动时...

最近有个老铁，告诉我说，上班一个月，后悔当初着急入职现在公司了。他之前在美图做手机研发，今年美图那边今年也有一波组织优化调整，他是其中一个，在协商离职后，当时捉急找工作上班，因为有房贷供着，不能没有收入来源。所以匆忙选了一家公司，实际上是一个大型外包公司，主要派遣给其他手机厂商做外包项目。**当时承诺待遇还不错，所以就立马入职去上班了。但是后面入职后，发现薪酬待遇这块并不是HR所说那样，那个HR自...

昨天看到一档综艺节目，讨论了两个话题：（1）中国学生的数学成绩，平均下来看，会比国外好？为什么？（2）男生的数学成绩，平均下来看，会比女生好？为什么？同时，我又联想到了一个技术圈经常讨...

提到“程序员”，多数人脑海里首先想到的大约是：为人木讷、薪水超高、工作枯燥…… 然而，当离开工作岗位，撕去层层标签，脱下“程序员”这身外套，有的人生动又有趣，马上展现出了完全不同的A/B面人生！ 不论是简单的爱好，还是正经的副业，他们都干得同样出色。偶尔，还能和程序员的特质结合，产生奇妙的“化学反应”。 @Charlotte：平日素颜示人，周末美妆博主 大家都以为程序媛也个个不修边幅，但我们也许...

文章目录数据库基础知识为什么要使用数据库什么是SQL？什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式？分别有什么区别？数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别？InnoDB引擎的4大特性存储引擎选择索引什么是索引？索引有哪些优缺点？索引使用场景（重点）...

有个好朋友ZS，是技术总监，昨天问我：“有一个老下属，跟了我很多年，做事勤勤恳恳，主动性也很好。但随着公司的发展，他的进步速度，跟不上团队的步伐了，有点...

私下里，有不少读者问我：“二哥，如何才能写出一份专业的技术简历呢？我总感觉自己写的简历太烂了，所以投了无数份，都石沉大海了。”说实话，我自己好多年没有写过简历了，但我认识的一个同行，他在阿里，给我说了一些他当年写简历的方法论，我感觉太牛逼了，实在是忍不住，就分享了出来，希望能够帮助到你。 01、简历的本质 作为简历的撰写者，你必须要搞清楚一点，简历的本质是什么，它就是为了来销售你的价值主张的。往深...

最近接手了一个springboot项目，不是不熟悉这个框架，启动时打印的信息吸引了我。 这不是我熟悉的常用springboot的打印信息啊，我打开自己的项目： 还真是的，不用默认的感觉也挺高大上的。一时兴起，就去研究了一下源代码，还正是有些收获，稍后我会总结一下。正常情况下做为一个老程序员，是不会对这种小儿科感兴趣的，不就是一个控制台打印嘛。哈哈！ 于是出于最初的好奇，研究了项目的源代码。看到

即将毕业的应届毕业生一枚，现在只拿到了两家offer，但最近听到一些消息，其中一个offer，我这个组据说客户很少，很有可能整组被裁掉。 想问大家： 如果我刚入职这个组就被裁了怎么办呢？ 大家都是什么时候知道自己要被裁了的？ 面试软技能指导: BQ/Project/Resume 试听内容： 除了刷题，还有哪些技能是拿到offer不可或缺的要素 如何提升面试软实力：简历, 行为面试，沟通能...

有小伙伴问松哥这个问题，他在上海某公司，在离职了几个月后，前公司的领导联系到他，希望他能够返聘回去，他很纠结要不要回去？ 俗话说好马不吃回头草，但是这个小伙伴既然感到纠结了，我觉得至少说明了两个问题：1.曾经的公司还不错；2.现在的日子也不是很如意。否则应该就不会纠结了。 老实说，松哥之前也有过类似的经历，今天就来和小伙伴们聊聊回头草到底吃不吃。 首先一个基本观点，就是离职了也没必要和老东家弄的苦...

往往，我们看不进去大段大段的逻辑。深刻的哲理，往往短而精悍，一阵见血。问：产品经理挺漂亮的，有点心动，但不知道合不合得来。男生更看重女生的身材脸蛋，还是...

二哥，有个事想询问下您的意见，您觉得应届生值得去外包吗？公司虽然挺大的，中xx，但待遇感觉挺低，马上要报到，挺纠结的。

当HR压你价，说你只值7K时，你可以流畅地回答，记住，是流畅，不能犹豫。 礼貌地说：“7K是吗？了解了。嗯~其实我对贵司的面试官印象很好。只不过，现在我的手头上已经有一份11K的offer。来面试，主要也是自己对贵司挺有兴趣的，所以过来看看……”（未完） 这段话主要是陪HR互诈的同时，从公司兴趣，公司职员印象上，都给予对方正面的肯定，既能提升HR的好感度，又能让谈判气氛融洽，为后面的发挥留足空间。...

HashMap底层实现原理，红黑树，B+树，B树的结构原理 Spring的AOP和IOC是什么？它们常见的使用场景有哪些？Spring事务，事务的属性，传播行为，数据库隔离级别 Spring和SpringMVC，MyBatis以及SpringBoot的注解分别有哪些？SpringMVC的工作原理，SpringBoot框架的优点，MyBatis框架的优点 SpringCould组件有哪些，他们...

面试阿里p7被问到的问题(当时我只知道第一个)：@Conditional是做什么的?@Conditional多个条件是什么逻辑关系？条件判断在什么时候执...

终于懂了TCP和UDP协议区别

我们程序员应该抱着尝鲜、猎奇的心态，否则就容易固步自封，技术停滞不前。

编程语言层出不穷，从最初的机器语言到如今2500种以上的高级语言，程序员们大呼“学到头秃”。程序员一边面临编程语言不断推陈出新，一边面临由于许多代码已存在，程序员编写新应用程序时存在重复“搬砖”的现象。 无代码/低代码编程应运而生。无代码/低代码是一种创建应用的方法，它可以让开发者使用最少的编码知识来快速开发应用程序。开发者通过图形界面中，可视化建模来组装和配置应用程序。这样一来，开发者直...

最近面试了一个31岁8年经验的程序猿，让我有点感慨，大龄程序猿该何去何从。

说实话，自己的算法，我一个不会，太难了吧

已经连续五年参加大厂校招、社招的技术面试工作，简历看的不下于万份 这篇文章会用实例告诉你，什么是差的程序员简历！ 疫情快要结束了，各个公司也都开始春招了，作为即将红遍大江南北的新晋UP主，那当然要为小伙伴们做点事（手动狗头）。 就在公众号里公开征简历，义务帮大家看，并一一点评。《启舰：春招在即，义务帮大家看看简历吧》 一石激起千层浪，三天收到两百多封简历。 花光了两个星期的所有空闲时...

我们都玩过Windows操作系统中的经典游戏扫雷（Minesweeper），如果把质数当作一颗雷，那么，表格中红色的数字哪些是雷（质数）？您能找出多少个呢？文中用列表的方式罗列了10000以内的自然数、质数（素数），6的倍数等，方便大家观察质数的分布规律及特性，以便对算法求解有指导意义。另外，判断质数是初学算法，理解算法重要性的一个非常好的案例。