为什么我在使用机器学习中的softmax来进行学习时预测时预测时间太短而且精确度一直为零 40C

是因为我的输入数据较少吗还是算法有问题
图片说明



import math
import pandas as pd
import numpy as np
import random
import time

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score


class Softmax(object):

    def __init__(self):
        self.learning_step = 0.000001           # 学习速率
        self.max_iteration = 100000             # 最大迭代次数
        self.weight_lambda = 0.01               # 衰退权重

    def cal_e(self,x,l):
        '''
        计算博客中的公式3
        '''

        theta_l = self.w[l]
        product = np.dot(theta_l,x)

        return math.exp(product)

    def cal_probability(self,x,j):
        '''
        计算博客中的公式2
        '''

        molecule = self.cal_e(x,j)
        denominator = sum([self.cal_e(x,i) for i in range(self.k)])

        return molecule/denominator


    def cal_partial_derivative(self,x,y,j):
        '''
        计算博客中的公式1
        '''

        first = int(y==j)                           # 计算示性函数
        second = self.cal_probability(x,j)          # 计算后面那个概率

        return -x*(first-second) + self.weight_lambda*self.w[j]

    def predict_(self, x):
        result = np.dot(self.w,x)
        row, column = result.shape

        # 找最大值所在的列
        _positon = np.argmax(result)
        m, n = divmod(_positon, column)

        return m

    def train(self, features, labels):
        self.k = len(set(labels))

        self.w = np.zeros((self.k,len(features[0])+1))
        time = 0

        while time < self.max_iteration:
            print('loop %d' % time)
            time += 1
            index = random.randint(0, len(labels) - 1)

            x = features[index]
            y = labels[index]

            x = list(x)
            x.append(1.0)
            x = np.array(x)

            derivatives = [self.cal_partial_derivative(x,y,j) for j in range(self.k)]

            for j in range(self.k):
                self.w[j] -= self.learning_step * derivatives[j]

    def predict(self,features):
        labels = []
        for feature in features:
            x = list(feature)
            x.append(1)

            x = np.matrix(x)
            x = np.transpose(x)

            labels.append(self.predict_(x))
        return labels


if __name__ == '__main__':

    print('Start read data')

    time_1 = time.time()

    raw_data = pd.read_csv('E:\jiqi\jiqiqiq.CSV', header=0)
    data = raw_data.values

    imgs = data[0::, 1::]
    labels = data[::, 0]

    # 选取 2/3 数据作为训练集, 1/3 数据作为测试集
    train_features, test_features, train_labels, test_labels = train_test_split(
        imgs, labels, test_size=0.33, random_state=23323)
    # print train_features.shape
    # print train_features.shape

    time_2 = time.time()
    print('read data cost '+ str(time_2 - time_1)+' second')

    print('Start training')
    p = Softmax()
    p.train(train_features, train_labels)

    time_3 = time.time()
    print('training cost '+ str(time_3 - time_2)+' second')

    print('Start predicting')
    test_predict = p.predict(test_features)
    time_4 = time.time()
    print('predicting cost ' + str(time_4 - time_3) +' second')

    score = accuracy_score(test_labels, test_predict)
    print("The accruacy socre is " + str(score))

1个回答

你这个从哪里找来的代码,整个训练的过程代码就不对,连正向传播、计算梯度、反向传播的代码都没有写

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
tensorflow载入训练好的模型进行预测,同一张图片预测的结果却不一样????
最近在跑deeplabv1,在测试代码的时候,跑通了训练程序,但是用训练好的模型进行与测试却发现相同的图片预测的结果不一样??请问有大神知道怎么回事吗? 用的是saver.restore()方法载入模型。代码如下: ``` def main(): """Create the model and start the inference process.""" args = get_arguments() # Prepare image. img = tf.image.decode_jpeg(tf.read_file(args.img_path), channels=3) # Convert RGB to BGR. img_r, img_g, img_b = tf.split(value=img, num_or_size_splits=3, axis=2) img = tf.cast(tf.concat(axis=2, values=[img_b, img_g, img_r]), dtype=tf.float32) # Extract mean. img -= IMG_MEAN # Create network. net = DeepLabLFOVModel() # Which variables to load. trainable = tf.trainable_variables() # Predictions. pred = net.preds(tf.expand_dims(img, dim=0)) # Set up TF session and initialize variables. config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) #init = tf.global_variables_initializer() sess.run(tf.global_variables_initializer()) # Load weights. saver = tf.train.Saver(var_list=trainable) load(saver, sess, args.model_weights) # Perform inference. preds = sess.run([pred]) print(preds) if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) msk = decode_labels(np.array(preds)[0, 0, :, :, 0]) im = Image.fromarray(msk) im.save(args.save_dir + 'mask1.png') print('The output file has been saved to {}'.format( args.save_dir + 'mask.png')) if __name__ == '__main__': main() ``` 其中load是 ``` def load(saver, sess, ckpt_path): '''Load trained weights. Args: saver: TensorFlow saver object. sess: TensorFlow session. ckpt_path: path to checkpoint file with parameters. ''' ckpt = tf.train.get_checkpoint_state(ckpt_path) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("Restored model parameters from {}".format(ckpt_path)) ``` DeepLabLFOVMode类如下: ``` class DeepLabLFOVModel(object): """DeepLab-LargeFOV model with atrous convolution and bilinear upsampling. This class implements a multi-layer convolutional neural network for semantic image segmentation task. This is the same as the model described in this paper: https://arxiv.org/abs/1412.7062 - please look there for details. """ def __init__(self, weights_path=None): """Create the model. Args: weights_path: the path to the cpkt file with dictionary of weights from .caffemodel. """ self.variables = self._create_variables(weights_path) def _create_variables(self, weights_path): """Create all variables used by the network. This allows to share them between multiple calls to the loss function. Args: weights_path: the path to the ckpt file with dictionary of weights from .caffemodel. If none, initialise all variables randomly. Returns: A dictionary with all variables. """ var = list() index = 0 if weights_path is not None: with open(weights_path, "rb") as f: weights = cPickle.load(f) # Load pre-trained weights. for name, shape in net_skeleton: var.append(tf.Variable(weights[name], name=name)) del weights else: # Initialise all weights randomly with the Xavier scheme, # and # all biases to 0's. for name, shape in net_skeleton: if "/w" in name: # Weight filter. w = create_variable(name, list(shape)) var.append(w) else: b = create_bias_variable(name, list(shape)) var.append(b) return var def _create_network(self, input_batch, keep_prob): """Construct DeepLab-LargeFOV network. Args: input_batch: batch of pre-processed images. keep_prob: probability of keeping neurons intact. Returns: A downsampled segmentation mask. """ current = input_batch v_idx = 0 # Index variable. # Last block is the classification layer. for b_idx in xrange(len(dilations) - 1): for l_idx, dilation in enumerate(dilations[b_idx]): w = self.variables[v_idx * 2] b = self.variables[v_idx * 2 + 1] if dilation == 1: conv = tf.nn.conv2d(current, w, strides=[ 1, 1, 1, 1], padding='SAME') else: conv = tf.nn.atrous_conv2d( current, w, dilation, padding='SAME') current = tf.nn.relu(tf.nn.bias_add(conv, b)) v_idx += 1 # Optional pooling and dropout after each block. if b_idx < 3: current = tf.nn.max_pool(current, ksize=[1, ks, ks, 1], strides=[1, 2, 2, 1], padding='SAME') elif b_idx == 3: current = tf.nn.max_pool(current, ksize=[1, ks, ks, 1], strides=[1, 1, 1, 1], padding='SAME') elif b_idx == 4: current = tf.nn.max_pool(current, ksize=[1, ks, ks, 1], strides=[1, 1, 1, 1], padding='SAME') current = tf.nn.avg_pool(current, ksize=[1, ks, ks, 1], strides=[1, 1, 1, 1], padding='SAME') elif b_idx <= 6: current = tf.nn.dropout(current, keep_prob=keep_prob) # Classification layer; no ReLU. # w = self.variables[v_idx * 2] w = create_variable(name='w', shape=[1, 1, 1024, n_classes]) # b = self.variables[v_idx * 2 + 1] b = create_bias_variable(name='b', shape=[n_classes]) conv = tf.nn.conv2d(current, w, strides=[1, 1, 1, 1], padding='SAME') current = tf.nn.bias_add(conv, b) return current def prepare_label(self, input_batch, new_size): """Resize masks and perform one-hot encoding. Args: input_batch: input tensor of shape [batch_size H W 1]. new_size: a tensor with new height and width. Returns: Outputs a tensor of shape [batch_size h w 18] with last dimension comprised of 0's and 1's only. """ with tf.name_scope('label_encode'): # As labels are integer numbers, need to use NN interp. input_batch = tf.image.resize_nearest_neighbor( input_batch, new_size) # Reducing the channel dimension. input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) input_batch = tf.one_hot(input_batch, depth=n_classes) return input_batch def preds(self, input_batch): """Create the network and run inference on the input batch. Args: input_batch: batch of pre-processed images. Returns: Argmax over the predictions of the network of the same shape as the input. """ raw_output = self._create_network( tf.cast(input_batch, tf.float32), keep_prob=tf.constant(1.0)) raw_output = tf.image.resize_bilinear( raw_output, tf.shape(input_batch)[1:3, ]) raw_output = tf.argmax(raw_output, dimension=3) raw_output = tf.expand_dims(raw_output, dim=3) # Create 4D-tensor. return tf.cast(raw_output, tf.uint8) def loss(self, img_batch, label_batch): """Create the network, run inference on the input batch and compute loss. Args: input_batch: batch of pre-processed images. Returns: Pixel-wise softmax loss. """ raw_output = self._create_network( tf.cast(img_batch, tf.float32), keep_prob=tf.constant(0.5)) prediction = tf.reshape(raw_output, [-1, n_classes]) # Need to resize labels and convert using one-hot encoding. label_batch = self.prepare_label( label_batch, tf.stack(raw_output.get_shape()[1:3])) gt = tf.reshape(label_batch, [-1, n_classes]) # Pixel-wise softmax loss. loss = tf.nn.softmax_cross_entropy_with_logits(logits=prediction, labels=gt) reduced_loss = tf.reduce_mean(loss) return reduced_loss ``` 按理说载入模型应该没有问题,可是不知道为什么结果却不一样? 图片:![图片说明](https://img-ask.csdn.net/upload/201911/15/1573810836_83106.jpg) ![图片说明](https://img-ask.csdn.net/upload/201911/15/1573810850_924663.png) 预测的结果: ![图片说明](https://img-ask.csdn.net/upload/201911/15/1573810884_985680.png) ![图片说明](https://img-ask.csdn.net/upload/201911/15/1573810904_577649.png) 两次结果不一样,与保存的模型算出来的结果也不一样。 我用的是GitHub上这个人的代码: https://github.com/minar09/DeepLab-LFOV-TensorFlow 急急急,请问有大神知道吗???
如何解决Layer type `softmax` is not implemented
第一个问题:我在编译的时候发现`softmax` is not implemented的问题,不知道怎么编写softmax和编写好之后把softmax文件放在哪 第二个问题:如果我把Layer('softmax')删了,编译的时候会显示Mismatch between dataset size and units in output layer.我不知道哪个维数出问题了,大佬可以帮忙解答吗 ``` import numpy as np import urllib.request import pandas as pd from pandas import DataFrame import numpy as np import pandas as pd import xlrd from sklearn import preprocessing def excel_to_matrix(path): table = xlrd.open_workbook(path).sheets()[0] # 获取第一个sheet表 row = table.nrows # 行数 col = table.ncols # 列数 datamatrix = np.zeros((row, col)) for x in range(col): cols = np.matrix(table.col_values(x)) datamatrix[:, x] = cols return datamatrix datafile = u'C:\\Users\\asus\\PycharmProjects\\2\\venv\\Lib\\附件2:数据.xls' datamatrix=excel_to_matrix(datafile) data=pd.DataFrame(datamatrix) y=data[10] data=data.drop(10,1) x=data # print(y.shape) from sklearn import preprocessing x_MinMax=preprocessing.MinMaxScaler() y_MinMax=preprocessing.MinMaxScaler() y.as_matrix(y) y=np.array(y).reshape((len(y),1)) x=np.array(x).reshape((len(x),10)) x=x_MinMax.fit_transform(x) y=y_MinMax.fit_transform(y) x.mean(axis=0) import random from sklearn.cross_validation import train_test_split np.random.seed(2016) x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2) from sknn.mlp import Regressor,Layer #预测模型 fit3=Regressor(layers=[Layer('Tanh',units=45),Layer('Tanh',units=18), Layer('softmax')], learning_rate=0.02, random_state=2016, valid_size=0.25, dropout_rate=0.2, learning_momentum=0.30, batch_size=35, n_iter=10 ) fit3.fit(x_train,y_train) from sklearn.metrics import confusion_matrix predict3_train=fit3.predict(x_train) score3=fit3.score(x_train,y_train) confu3=confusion_matrix(y_train,predict3_train) print(confu3) score_text3=fit3.score(x_test,y_test) print(score_text3) predict3_test=fit3.predict(x_test) confu3_test=confusion_matrix(y_test,predict3_test) print(confu3_test) ```
python如何自定义权重损失函数?
我利用keras的神经网络训练一个模型,被训练的数据是一个很大的二维数组,每一行是一个类别,总共有3种类别。被训练出的模型中包括3种类别(暂且称为A,B,C)。现在B类的预测准确率太高了,而A和C类的预测准确率较低,我想在把B类准确率适当减低的情况下来提高A和C类的预测准确率。请问该怎么操作? 代码如下,我从网上查了一些代码,自己不是特别明白,尝试后,出现了错误。请问该如何修改?下面添加的图片中被划红线圈住的代码是添加上去的,最终运行出错了,请问怎么修改,或者重新帮我写一个权重损失代码代码,跪谢 def custom_loss_4(y_true, y_pred, weights): return K.mean(K.abs(y_true - y_pred) * weights) model = models.Sequential() model.add(layers.Dense(200, activation = "relu", input_shape = (1175, ))) weights = np.random.randn(*X_train.shape) weights_tensor = Input(shape=(3,)) cl4 = partial(custom_loss_4,weights=weights_tensor) model.add(layers.Dropout(0.7)) model.add(layers.Dense(100, activation = "relu")) model.add(layers.Dropout(0.5)) model.add(layers.Dense(3, activation = "softmax")) model.compile(optimizer = "rmsprop", loss = cl4, metrics = ["accuracy"]) model.summary() ![图片说明](https://img-ask.csdn.net/upload/201910/13/1570937131_951272.jpg) ![图片说明](https://img-ask.csdn.net/upload/201910/13/1570936461_762097.png) ![图片说明](https://img-ask.csdn.net/upload/201910/13/1570936605_599703.png) 补充一下:我在前面对数据做过了不平衡调整,定义的函数如下: def calc_class_weight(total_y): my_class_weight = class_weight.compute_class_weight("balanced", np.unique(total_y), total_y) return my_class_weight
python深度学习分类后的 混淆矩阵的显示方式为什么不是单纯的一个矩阵
书里的结果就是一个矩阵,但是我运行后的混淆矩阵上面还有(200,2),我设置的目标值为1或者2,但不知道为什么200后面是2,这个2和设置的1,2有关系吗 ![图片说明](https://img-ask.csdn.net/upload/201909/11/1568131642_681643.png) ``` import numpy as np import urllib.request import pandas as pd from pandas import DataFrame import numpy as np import pandas as pd import xlrd from sklearn import preprocessing def excel_to_matrix(path): table = xlrd.open_workbook(path).sheets()[0] # 获取第一个sheet表 row = table.nrows # 行数 col = table.ncols # 列数 datamatrix = np.zeros((row, col)) for x in range(col): cols = np.matrix(table.col_values(x)) datamatrix[:, x] = cols return datamatrix datafile = u'C:\\Users\\asus\\PycharmProjects\\2\\venv\\Lib\\附件2:数据.xls' datamatrix=excel_to_matrix(datafile) data=pd.DataFrame(datamatrix) y=data[10] data=data.drop(10,1) x=data from sklearn import preprocessing x_MinMax=preprocessing.MinMaxScaler() y=np.array(y).reshape((len(y),1)) x=x_MinMax.fit_transform(x) x.mean(axis=0) import random from sklearn.cross_validation import train_test_split np.random.seed(2016) x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2) from sknn.mlp import Classifier,Layer #预测模型 fit3=Classifier(layers=[Layer('Tanh',units=38),Layer('Tanh',units=45), Layer('Tanh', units=28), Layer('Softmax')], learning_rate=0.02, random_state=2016, n_iter=100, dropout_rate=0.05, batch_size=50, learning_rule=u'adadelta', learning_momentum=0.005 ) fit3.fit(x_train,y_train) from sklearn.metrics import confusion_matrix predict3_train=fit3.predict(x_train) print(predict3_train) predict3_test=fit3.predict(x_test) confu3_test=confusion_matrix(y_test,predict3_test) print(confu3_test) ```
python深度学习分类后的 混淆矩阵的意义
有大佬可以解释混淆矩阵上面还有(200,2)是什么意思吗,我设置的目标值为1或者2,但不知道为什么200后面是2,这个2和设置的1,2有关系吗 ![图片说明](https://img-ask.csdn.net/upload/201909/13/1568362335_282979.png) ``` import numpy as np import urllib.request import pandas as pd from pandas import DataFrame import numpy as np import pandas as pd import xlrd from sklearn import preprocessing def excel_to_matrix(path): table = xlrd.open_workbook(path).sheets()[0] # 获取第一个sheet表 row = table.nrows # 行数 col = table.ncols # 列数 datamatrix = np.zeros((row, col)) for x in range(col): cols = np.matrix(table.col_values(x)) datamatrix[:, x] = cols return datamatrix datafile = u'C:\\Users\\asus\\PycharmProjects\\2\\venv\\Lib\\附件2:数据.xls' datamatrix=excel_to_matrix(datafile) data=pd.DataFrame(datamatrix) y=data[10] data=data.drop(10,1) x=data from sklearn import preprocessing x_MinMax=preprocessing.MinMaxScaler() y=np.array(y).reshape((len(y),1)) x=x_MinMax.fit_transform(x) x.mean(axis=0) import random from sklearn.cross_validation import train_test_split np.random.seed(2016) x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2) from sknn.mlp import Classifier,Layer #预测模型 fit3=Classifier(layers=[Layer('Tanh',units=38),Layer('Tanh',units=45), Layer('Tanh', units=28), Layer('Softmax')], learning_rate=0.02, random_state=2016, n_iter=100, dropout_rate=0.05, batch_size=50, learning_rule=u'adadelta', learning_momentum=0.005 ) fit3.fit(x_train,y_train) from sklearn.metrics import confusion_matrix predict3_train=fit3.predict(x_train) print(predict3_train) predict3_test=fit3.predict(x_test) confu3_test=confusion_matrix(y_test,predict3_test) print(confu3_test) ```
如何解决 cannot reshape array of size 10000 into shape (1000,6)
我把excel数据(纯数字)导入datamatrix,但是在np.array(x).reshape((len(x),6)) 的时候报错了,有哪位大佬可以解释一下吗 ``` import numpy as np import urllib.request import pandas as pd from pandas import DataFrame import numpy as np import pandas as pd import xlrd from sklearn import preprocessing def excel_to_matrix(path): table = xlrd.open_workbook(path).sheets()[0] # 获取第一个sheet表 row = table.nrows # 行数 col = table.ncols # 列数 datamatrix = np.zeros((row, col)) for x in range(col): cols = np.matrix(table.col_values(x)) datamatrix[:, x] = cols return datamatrix datafile = u'C:\\Users\\asus\\PycharmProjects\\2\\venv\\Lib\\附件2:数据.xls' datamatrix=excel_to_matrix(datafile) data=pd.DataFrame(datamatrix) y=data[10] data=data.drop(10,1) x=data from sklearn import preprocessing x_MinMax=preprocessing.MinMaxScaler() y_MinMax=preprocessing.MinMaxScaler() y.as_matrix(y) y=np.array(y).reshape((len(y),1)) x=np.array(x).reshape((len(x),6)) x=x_MinMax.fit_transform(x) y=y_MinMax.fit_transform(y) x.mean(axis=0) import random from sklearn.cross_validation import train_test_split np.random.seed(2016) x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2) from sknn.mlp import Regressor,Layer #预测模型 w_train=x_train[:,0] w_train[y_train==0]=1 w_train[y_train==1]=1.10 fit3=Regressor(layers=[Layer('Tanh',units=45),Layer('Tanh',units=18), Layer('Tanh',units=18), Layer('softmax')], learning_rate=0.02, random_state=2016, valid_size=0.25, dropout_rate=0.2, learning_momentum=0.30, batch_size=35, n_iter=10 ) fit3.fit(x_train,y_train,w_train) from sklearn.metrics import confusion_matrix predict3_train=fit3.predict(x_train) score3=fit3.score(x_train,y_train) confu3=confusion_matrix(y_train,predict3_train) print(confu3) score_text3=fit3.score(x_test,y_test) print(score_text3) predict3_test=fit3.predict(x_test) confu3_test=confusion_matrix(y_test,predict3_test) print(confu3_test) ```
用tensorflow做机器翻译时训练代码有问题
``` # -*- coding:UTF-8 -*- import tensorflow as tf src_path = 'D:/Python37/untitled1/train.tags.en-zh.en.deletehtml' trg_path = 'D:/Python37/untitled1/train.tags.en-zh.zh.deletehtml' SRC_TRAIN_DATA = 'D:/Python37/untitled1/train.tags.en-zh.en.deletehtml.segment' # 源语言输入文件 TRG_TRAIN_DATA = 'D:/Python37/untitled1/train.tags.en-zh.zh.deletehtml.segment' # 目标语言输入文件 CHECKPOINT_PATH = './model/seq2seq_ckpt' # checkpoint保存路径 HIDDEN_SIZE = 1024 # LSTM的隐藏层规模 NUM_LAYERS = 2 # 深层循环神经网络中LSTM结构的层数 SRC_VOCAB_SIZE = 10000 # 源语言词汇表大小 TRG_VOCAB_SIZE = 4000 # 目标语言词汇表大小 BATCH_SIZE = 100 # 训练数据batch的大小 NUM_EPOCH = 5 # 使用训练数据的轮数 KEEP_PROB = 0.8 # 节点不被dropout的概率 MAX_GRAD_NORM = 5 # 用于控制梯度膨胀的梯度大小上限 SHARE_EMB_AND_SOFTMAX = True # 在softmax层和词向量层之间共享参数 MAX_LEN = 50 # 限定句子的最大单词数量 SOS_ID = 1 # 目标语言词汇表中<sos>的ID """ function: 数据batching,产生最后输入数据格式 Parameters: file_path-数据路径 Returns: dataset- 每个句子-对应的长度组成的TextLineDataset类的数据集对应的张量 """ def MakeDataset(file_path): dataset = tf.data.TextLineDataset(file_path) # map(function, sequence[, sequence, ...]) -> list # 通过定义可以看到,这个函数的第一个参数是一个函数,剩下的参数是一个或多个序列,返回值是一个集合。 # function可以理解为是一个一对一或多对一函数,map的作用是以参数序列中的每一个元素调用function函数,返回包含每次function函数返回值的list。 # lambda argument_list: expression # 其中lambda是Python预留的关键字,argument_list和expression由用户自定义 # argument_list参数列表, expression 为函数表达式 # 根据空格将单词编号切分开并放入一个一维向量 dataset = dataset.map(lambda string: tf.string_split([string]).values) # 将字符串形式的单词编号转化为整数 dataset = dataset.map(lambda string: tf.string_to_number(string, tf.int32)) # 统计每个句子的单词数量,并与句子内容一起放入Dataset dataset = dataset.map(lambda x: (x, tf.size(x))) return dataset """ function: 从源语言文件src_path和目标语言文件trg_path中分别读取数据,并进行填充和batching操作 Parameters: src_path-源语言,即被翻译的语言,英语. trg_path-目标语言,翻译之后的语言,汉语. batch_size-batch的大小 Returns: dataset- 每个句子-对应的长度 组成的TextLineDataset类的数据集 """ def MakeSrcTrgDataset(src_path, trg_path, batch_size): # 首先分别读取源语言数据和目标语言数据 src_data = MakeDataset(src_path) trg_data = MakeDataset(trg_path) # 通过zip操作将两个Dataset合并为一个Dataset,现在每个Dataset中每一项数据ds由4个张量组成 # ds[0][0]是源句子 # ds[0][1]是源句子长度 # ds[1][0]是目标句子 # ds[1][1]是目标句子长度 #https://blog.csdn.net/qq_32458499/article/details/78856530这篇博客看一下可以细致了解一下Dataset这个库,以及.map和.zip的用法 dataset = tf.data.Dataset.zip((src_data, trg_data)) # 删除内容为空(只包含<eos>)的句子和长度过长的句子 def FilterLength(src_tuple, trg_tuple): ((src_input, src_len), (trg_label, trg_len)) = (src_tuple, trg_tuple) # tf.logical_and 相当于集合中的and做法,后面两个都为true最终结果才会为true,否则为false # tf.greater Returns the truth value of (x > y),所以以下所说的是句子长度必须得大于一也就是不能为空的句子 # tf.less_equal Returns the truth value of (x <= y),所以所说的是长度要小于最长长度 src_len_ok = tf.logical_and(tf.greater(src_len, 1), tf.less_equal(src_len, MAX_LEN)) trg_len_ok = tf.logical_and(tf.greater(trg_len, 1), tf.less_equal(trg_len, MAX_LEN)) return tf.logical_and(src_len_ok, trg_len_ok) #两个都满足才返回true # filter接收一个函数Func并将该函数作用于dataset的每个元素,根据返回值True或False保留或丢弃该元素,True保留该元素,False丢弃该元素 # 最后得到的就是去掉空句子和过长的句子的数据集 dataset = dataset.filter(FilterLength) # 解码器需要两种格式的目标句子: # 1.解码器的输入(trg_input), 形式如同'<sos> X Y Z' # 2.解码器的目标输出(trg_label), 形式如同'X Y Z <eos>' # 上面从文件中读到的目标句子是'X Y Z <eos>'的形式,我们需要从中生成'<sos> X Y Z'形式并加入到Dataset # 编码器只有输入,没有输出,而解码器有输入也有输出,输入为<sos>+(除去最后一位eos的label列表) # 例如train.en最后都为2,id为2就是eos def MakeTrgInput(src_tuple, trg_tuple): ((src_input, src_len), (trg_label, trg_len)) = (src_tuple, trg_tuple) # tf.concat用法 https://blog.csdn.net/qq_33431368/article/details/79429295 trg_input = tf.concat([[SOS_ID], trg_label[:-1]], axis=0) return ((src_input, src_len), (trg_input, trg_label, trg_len)) dataset = dataset.map(MakeTrgInput) # 随机打乱训练数据 dataset = dataset.shuffle(10000) # 规定填充后的输出的数据维度 padded_shapes = ( (tf.TensorShape([None]), # 源句子是长度未知的向量 tf.TensorShape([])), # 源句子长度是单个数字 (tf.TensorShape([None]), # 目标句子(解码器输入)是长度未知的向量 tf.TensorShape([None]), # 目标句子(解码器目标输出)是长度未知的向量 tf.TensorShape([])) # 目标句子长度(输出)是单个数字 ) # 调用padded_batch方法进行padding 和 batching操作 batched_dataset = dataset.padded_batch(batch_size, padded_shapes) return batched_dataset """ function: seq2seq模型 Parameters: Returns: """ class NMTModel(object): """ function: 模型初始化 Parameters: Returns: """ def __init__(self): # 定义编码器和解码器所使用的LSTM结构 self.enc_cell = tf.nn.rnn_cell.MultiRNNCell( [tf.nn.rnn_cell.LSTMCell(HIDDEN_SIZE) for _ in range(NUM_LAYERS)]) self.dec_cell = tf.nn.rnn_cell.MultiRNNCell( [tf.nn.rnn_cell.LSTMCell(HIDDEN_SIZE) for _ in range(NUM_LAYERS)]) # 为源语言和目标语言分别定义词向量 self.src_embedding = tf.get_variable('src_emb', [SRC_VOCAB_SIZE, HIDDEN_SIZE]) self.trg_embedding = tf.get_variable('trg_emb', [TRG_VOCAB_SIZE, HIDDEN_SIZE]) # 定义softmax层的变量 if SHARE_EMB_AND_SOFTMAX: self.softmax_weight = tf.transpose(self.trg_embedding) else: self.softmax_weight = tf.get_variable('weight', [HIDDEN_SIZE, TRG_VOCAB_SIZE]) self.softmax_bias = tf.get_variable('softmax_loss', [TRG_VOCAB_SIZE]) """ function: 在forward函数中定义模型的前向计算图 Parameters:   MakeSrcTrgDataset函数产生的五种张量如下(全部为张量) src_input: 编码器输入(源数据) src_size : 输入大小 trg_input:解码器输入(目标数据) trg_label:解码器输出(目标数据) trg_size: 输出大小 Returns: """ def forward(self, src_input, src_size, trg_input, trg_label, trg_size): batch_size = tf.shape(src_input)[0] # 将输入和输出单词转为词向量(rnn中输入数据都要转换成词向量) # 相当于input中的每个id对应的embedding中的向量转换 src_emb = tf.nn.embedding_lookup(self.src_embedding, src_input) trg_emb = tf.nn.embedding_lookup(self.trg_embedding, trg_input) # 在词向量上进行dropout src_emb = tf.nn.dropout(src_emb, KEEP_PROB) trg_emb = tf.nn.dropout(trg_emb, KEEP_PROB) # 使用dynamic_rnn构造编码器 # 编码器读取源句子每个位置的词向量,输出最后一步的隐藏状态enc_state # 因为编码器是一个双层LSTM,因此enc_state是一个包含两个LSTMStateTuple类的tuple, # 每个LSTMStateTuple对应编码器中一层的状态 # enc_outputs是顶层LSTM在每一步的输出,它的维度是[batch_size, max_time, HIDDEN_SIZE] # seq2seq模型中不需要用到enc_outputs,而attention模型会用到它 with tf.variable_scope('encoder'): enc_outputs, enc_state = tf.nn.dynamic_rnn(self.enc_cell, src_emb, src_size, dtype=tf.float32) # 使用dynamic_rnn构造解码器 # 解码器读取目标句子每个位置的词向量,输出的dec_outputs为每一步顶层LSTM的输出 # dec_outputs的维度是[batch_size, max_time, HIDDEN_SIZE] # initial_state=enc_state表示用编码器的输出来初始化第一步的隐藏状态 # 编码器最后编码结束最后的状态为解码器初始化的状态 with tf.variable_scope('decoder'): dec_outputs, _ = tf.nn.dynamic_rnn(self.dec_cell, trg_emb, trg_size, initial_state=enc_state) # 计算解码器每一步的log perplexity # 输出重新转换成shape为[,HIDDEN_SIZE] output = tf.reshape(dec_outputs, [-1, HIDDEN_SIZE]) # 计算解码器每一步的softmax概率值 logits = tf.matmul(output, self.softmax_weight) + self.softmax_bias # 交叉熵损失函数,算loss loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.reshape(trg_label, [-1]), logits=logits) # 在计算平均损失时,需要将填充位置的权重设置为0,以避免无效位置的预测干扰模型的训练 label_weights = tf.sequence_mask(trg_size, maxlen=tf.shape(trg_label)[1], dtype=tf.float32) label_weights = tf.reshape(label_weights, [-1]) cost = tf.reduce_sum(loss * label_weights) cost_per_token = cost / tf.reduce_sum(label_weights) # 定义反向传播操作 trainable_variables = tf.trainable_variables() # 控制梯度大小,定义优化方法和训练步骤 # 算出每个需要更新的值的梯度,并对其进行控制 grads = tf.gradients(cost / tf.to_float(batch_size), trainable_variables) grads, _ = tf.clip_by_global_norm(grads, MAX_GRAD_NORM) # 利用梯度下降优化算法进行优化.学习率为1.0 optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.0) # 相当于minimize的第二步,正常来讲所得到的list[grads,vars]由compute_gradients得到,返回的是执行对应变量的更新梯度操作的op train_op = optimizer.apply_gradients(zip(grads, trainable_variables)) return cost_per_token, train_op """ function: 使用给定的模型model上训练一个epoch,并返回全局步数,每训练200步便保存一个checkpoint Parameters: session : 会议 cost_op : 计算loss的操作op train_op: 训练的操作op saver:  保存model的类 step:   训练步数 Returns: """ def run_epoch(session, cost_op, train_op, saver, step): # 训练一个epoch # 重复训练步骤直至遍历完Dataset中所有数据 while True: try: # 运行train_op并计算cost_op的结果也就是损失值,训练数据在main()函数中以Dataset方式提供 cost, _ = session.run([cost_op, train_op]) # 步数为10的倍数进行打印 if step % 10 == 0: print('After %d steps, per token cost is %.3f' % (step, cost)) # 每200步保存一个checkpoint if step % 200 == 0: saver.save(session, CHECKPOINT_PATH, global_step=step) step += 1 except tf.errors.OutOfRangeError: break return step """ function: 主函数 Parameters: Returns: """ def main(): # 定义初始化函数 initializer = tf.random_uniform_initializer(-0.05, 0.05) # 定义训练用的循环神经网络模型 with tf.variable_scope('nmt_model', reuse=None, initializer=initializer): train_model = NMTModel() # 定义输入数据 data = MakeSrcTrgDataset(SRC_TRAIN_DATA, TRG_TRAIN_DATA, BATCH_SIZE) iterator = data.make_initializable_iterator() (src, src_size), (trg_input, trg_label, trg_size) = iterator.get_next() # 定义前向计算图,输入数据以张量形式提供给forward函数 cost_op, train_op = train_model.forward(src, src_size, trg_input, trg_label, trg_size) # 训练模型 # 保存模型 saver = tf.train.Saver() step = 0 with tf.Session() as sess: # 初始化全部变量 tf.global_variables_initializer().run() # 进行NUM_EPOCH轮数 for i in range(NUM_EPOCH): print('In iteration: %d' % (i + 1)) sess.run(iterator.initializer) step = run_epoch(sess, cost_op, train_op, saver, step) if __name__ == '__main__': main() ``` 问题如下,不知道怎么解决,谢谢! Traceback (most recent call last): File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 1334, in _do_call return fn(*args) File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 1319, in _run_fn options, feed_dict, fetch_list, target_list, run_metadata) File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 1407, in _call_tf_sessionrun run_metadata) tensorflow.python.framework.errors_impl.InvalidArgumentError: StringToNumberOp could not correctly convert string: This [[{{node StringToNumber}}]] [[{{node IteratorGetNext}}]] During handling of the above exception, another exception occurred: Traceback (most recent call last): File "D:/Python37/untitled1/train_model.py", line 277, in <module> main() File "D:/Python37/untitled1/train_model.py", line 273, in main step = run_epoch(sess, cost_op, train_op, saver, step) File "D:/Python37/untitled1/train_model.py", line 231, in run_epoch cost, _ = session.run([cost_op, train_op]) File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 929, in run run_metadata_ptr) File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 1152, in _run feed_dict_tensor, options, run_metadata) File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 1328, in _do_run run_metadata) File "D:\Anaconda\envs\tensorflow\lib\site-packages\tensorflow\python\client\session.py", line 1348, in _do_call raise type(e)(node_def, op, message) tensorflow.python.framework.errors_impl.InvalidArgumentError: StringToNumberOp could not correctly convert string: This [[{{node StringToNumber}}]] [[node IteratorGetNext (defined at D:/Python37/untitled1/train_model.py:259) ]]
LSTM神经网络预测值与实际值偏差过大
在使用博主https://blog.csdn.net/u010866505/article/details/74910525 的改编代码进行预测时,发现预测值与实际值相差过大,我用的数据:输入两个10以内的整数,输出为这两个整数的加和,代码如下: ```%接下来就是LSTM的Matlab代码,我也进行了注释,用英文注释的,也比较容易懂: % implementation of LSTM clc % clear close all % %% training dataset generation % binary_dim = 8; % % % largest_number = 2^binary_dim - 1; % binary = cell(largest_number, 1); % % % for i = 1:largest_number + 1 % binary{i} = dec2bin(i-1, binary_dim); % int2binary{i} = binary{i}; % end load('datta.mat') x = datta(:,1:2); Y = datta(:,3); %% input variables alpha = 0.0001; input_dim = 2; hidden_dim = 256; output_dim = 1; allErr = []; %% initialize neural network weights % in_gate = sigmoid(X(t) * X_i + H(t-1) * H_i) ------- (1) X_i = 2 * rand(input_dim, hidden_dim) - 1; H_i = 2 * rand(hidden_dim, hidden_dim) - 1; X_i_update = zeros(size(X_i)); H_i_update = zeros(size(H_i)); bi = 2*rand(1,1) - 1; bi_update = 0; % forget_gate = sigmoid(X(t) * X_f + H(t-1) * H_f) ------- (2) X_f = 2 * rand(input_dim, hidden_dim) - 1; H_f = 2 * rand(hidden_dim, hidden_dim) - 1; X_f_update = zeros(size(X_f)); H_f_update = zeros(size(H_f)); bf = 2*rand(1,1) - 1; bf_update = 0; % out_gate = sigmoid(X(t) * X_o + H(t-1) * H_o) ------- (3) X_o = 2 * rand(input_dim, hidden_dim) - 1; H_o = 2 * rand(hidden_dim, hidden_dim) - 1; X_o_update = zeros(size(X_o)); H_o_update = zeros(size(H_o)); bo = 2*rand(1,1) - 1; bo_update = 0; % g_gate = tanh(X(t) * X_g + H(t-1) * H_g) ------- (4) X_g = 2 * rand(input_dim, hidden_dim) - 1; H_g = 2 * rand(hidden_dim, hidden_dim) - 1; X_g_update = zeros(size(X_g)); H_g_update = zeros(size(H_g)); bg = 2*rand(1,1) - 1; bg_update = 0; out_para = 2 * rand(hidden_dim, output_dim) - 1; out_para_update = zeros(size(out_para)); % C(t) = C(t-1) .* forget_gate + g_gate .* in_gate ------- (5) % S(t) = tanh(C(t)) .* out_gate ------- (6) % Out = sigmoid(S(t) * out_para) ------- (7) % Note: Equations (1)-(6) are cores of LSTM in forward, and equation (7) is % used to transfer hiddent layer to predicted output, i.e., the output layer. % (Sometimes you can use softmax for equation (7)) % train iter = 1000; % training iterations for j = 1:iter % total error overallError = 0; % difference in output layer, i.e., (target - out) output_deltas = []; % values of hidden layer, i.e., S(t) hidden_layer_values = []; cell_gate_values = []; % initialize S(0) as a zero-vector hidden_layer_values = [hidden_layer_values; zeros(1, hidden_dim)]; cell_gate_values = [cell_gate_values; zeros(1, hidden_dim)]; % initialize memory gate % hidden layer H = []; H = [H; zeros(1, hidden_dim)]; % cell gate C = []; C = [C; zeros(1, hidden_dim)]; % in gate I = []; % forget gate F = []; % out gate O = []; % g gate G = []; % start to process a sequence, i.e., a forward pass % Note: the output of a LSTM cell is the hidden_layer, and you need to % transfer it to predicted output for position = 0:length(Y)-1 % X ------> input, size: 1 x input_dim X = x(position + 1,:); % y ------> label, size: 1 x output_dim y = Y(position+ 1); % use equations (1)-(7) in a forward pass. here we do not use bias in_gate = sigmoid(X * X_i + H(end, :) * H_i + bi); % equation (1) forget_gate = sigmoid(X * X_f + H(end, :) * H_f + bf); % equation (2) out_gate = sigmoid(X * X_o + H(end, :) * H_o + bo); % equation (3) g_gate = tan_h(X * X_g + H(end, :) * H_g + bg); % equation (4) C_t = C(end, :) .* forget_gate + g_gate .* in_gate; % equation (5) H_t = tan_h(C_t) .* out_gate; % equation (6) % store these memory gates I = [I; in_gate]; F = [F; forget_gate]; O = [O; out_gate]; G = [G; g_gate]; C = [C; C_t]; H = [H; H_t]; % compute predict output pred_out = sigmoid(H_t * out_para); % compute error in output layer output_error = y - pred_out % compute difference in output layer using derivative 用导数计算输出层的差分 % output_diff = output_error * sigmoid_output_to_derivative(pred_out); output_deltas = [output_deltas; output_error*sigmoid_output_to_derivative(pred_out)]; %output_deltas = [output_deltas; output_error*(pred_out)]; % compute total error % note that if the size of pred_out or target is 1 x n or m x n, % you should use other approach to compute error. here the dimension % of pred_out is 1 x 1 overallError = overallError + abs(output_error(1)); % decode estimate so we can print it out d(length(Y) - position) = round(pred_out); end % from the last LSTM cell, you need a initial hidden layer difference future_H_diff = zeros(1, hidden_dim); % stare back-propagation, i.e., a backward pass % the goal is to compute differences and use them to update weights % start from the last LSTM cell for position = 0:length(Y)-1 X = x(position+1,:); % hidden layer H_t = H(end - position, :); % H(t) % previous hidden layer H_t_1 = H(end- position-1, :); % H(t-1) C_t = C(end-position, :); % C(t) C_t_1 = C(end-position-1, :); % C(t-1) O_t = O(end-position, :); F_t = F(end-position, :); G_t = G(end-position, :); I_t = I(end-position, :); output_diff = output_deltas(end-position, :); % output layer difference % hidden layer difference % note that here we consider one hidden layer is input to both % output layer and next LSTM cell. Thus its difference also comes % from two sources. In some other method, only one source is taken % into consideration. % use the equation: delta(l) = (delta(l+1) * W(l+1)) .* f'(z) to % compute difference in previous layers. look for more about the % proof at http://neuralnetworksanddeeplearning.com/chap2.html % H_t_diff = (future_H_diff * (H_i' + H_o' + H_f' + H_g') + output_diff * out_para') ... % .* sigmoid_output_to_derivative(H_t); H_t_diff = output_diff * (out_para').* sigmoid_output_to_derivative(H_t); % H_t_diff = output_diff * (out_para') .* sigmoid_output_to_derivative(H_t); % future_H_diff = H_t_diff; % out_para_diff = output_diff * (H_t) * sigmoid_output_to_derivative(out_para); out_para_diff = (H_t') * output_diff;%输出层权重 % out_gate diference O_t_diff = H_t_diff .* tan_h(C_t) .* sigmoid_output_to_derivative(O_t); % C_t difference C_t_diff = H_t_diff .* O_t .* tan_h_output_to_derivative(C_t); % % C(t-1) difference % C_t_1_diff = C_t_diff .* F_t; % forget_gate_diffeence F_t_diff = C_t_diff .* C_t_1 .* sigmoid_output_to_derivative(F_t); % in_gate difference I_t_diff = C_t_diff .* G_t .* sigmoid_output_to_derivative(I_t); % g_gate difference G_t_diff = C_t_diff .* I_t .* tan_h_output_to_derivative(G_t); % differences of X_i and H_i X_i_diff = X' * I_t_diff.* sigmoid_output_to_derivative(X_i); H_i_diff = (H_t_1)' * I_t_diff .* sigmoid_output_to_derivative(H_i); % differences of X_o and H_o X_o_diff = X' * O_t_diff .* sigmoid_output_to_derivative(X_o); H_o_diff = (H_t_1)' * O_t_diff .* sigmoid_output_to_derivative(H_o); % differences of X_o and H_o X_f_diff = X' * F_t_diff .* sigmoid_output_to_derivative(X_f); H_f_diff = (H_t_1)' * F_t_diff .* sigmoid_output_to_derivative(H_f); % differences of X_o and H_o X_g_diff = X' * G_t_diff .* tan_h_output_to_derivative(X_g); H_g_diff = (H_t_1)' * G_t_diff.* tan_h_output_to_derivative(H_g); % update X_i_update = X_i_update + X_i_diff; H_i_update = H_i_update + H_i_diff; X_o_update = X_o_update + X_o_diff; H_o_update = H_o_update + H_o_diff; X_f_update = X_f_update + X_f_diff; H_f_update = H_f_update + H_f_diff; X_g_update = X_g_update + X_g_diff; H_g_update = H_g_update + H_g_diff; bi_update = bi_update + I_t_diff; bo_update = bo_update + O_t_diff; bf_update = bf_update + F_t_diff; bg_update = bg_update + G_t_diff; out_para_update = out_para_update + out_para_diff; end X_i = X_i + X_i_update * alpha; H_i = H_i + H_i_update * alpha; X_o = X_o + X_o_update * alpha; H_o = H_o + H_o_update * alpha; X_f = X_f + X_f_update * alpha; H_f = H_f + H_f_update * alpha; X_g = X_g + X_g_update * alpha; H_g = H_g + H_g_update * alpha; bi = bi + bi_update * alpha; bo = bo + bo_update * alpha; bf = bf + bf_update * alpha; bg = bg + bg_update * alpha; out_para = out_para + out_para_update * alpha; X_i_update = X_i_update * 0; H_i_update = H_i_update * 0; X_o_update = X_o_update * 0; H_o_update = H_o_update * 0; X_f_update = X_f_update * 0; H_f_update = H_f_update * 0; X_g_update = X_g_update * 0; H_g_update = H_g_update * 0; bi_update = 0; bf_update = 0; bo_update = 0; bg_update = 0; out_para_update = out_para_update * 0; % if(mod(j,1000) == 0) % if 1%overallError > 1 % err = sprintf('Error:%s\n', num2str(overallError)); fprintf(err); % end allErr = [allErr overallError]; % % try % d = bin2dec(num2str(d)); % % catch % % disp(d); % % end % if 1 % overallError>1 % pred = sprintf('Pred:%s\n',dec2bin(d,8)); fprintf(pred); % Tru = sprintf('True:%s\n', num2str(c)); fprintf(Tru); % end % out = 0; % tmp = dec2bin(d,8); % for i = 1:8 % out = out + str2double(tmp(8-i+1)) * power(2,i-1); % end % if 1 % overallError > 1 % fprintf('%d + %d = %d\n',a_int,b_int,out); % sep = sprintf('-------%d------\n', j); fprintf(sep); % end % end end figure;plot(allErr); function output = sigmoid(x) output = 1./(1+exp(-x)); end function y = sigmoid_output_to_derivative(output) y = output.*(1-output); end function y = tan_h_output_to_derivative(x) y = (1-x.^2); end function y=tan_h(x) y=(exp(x)-exp(-x))./(exp(x)+exp(-x)); end ``` 不知道哪里出了问题,运行误差都是相当大的,看起来不是预测而像是随机输出,同时,通过观测每次输出与实际是之间的误差,发现误差的改变量微乎其微,好像梯度下降并没有起作用。
bp神经网络不能正常分类
``` import numpy as np import sklearn from sklearn import datasets from matplotlib import pyplot as plt class Config: eta=0.003#学习率 input_dim=2#输入层神经元个数,即样本的特征数,这里是横纵坐标 hidden_dim=3#隐层神经元个数 output_dim=2#输出层神经元个数,分别代表P(y=0)与P(y=1),取较大者为数据点的分类 N=200#训练集样本数 def generate_data(): np.random.seed(0) X,Y=sklearn.datasets.make_moons(Config.N,noise=0.20)#大小为N的二分类非线性可分数据集 return X,Y def softmax(z):#输出层softmax函数,输出为yhat。为了数值稳定防止溢出,进行平移。 z-=np.max(z) return np.exp(z)/np.sum(np.exp(z)) def predict(x,model): ''' 得到预测输出 ''' p=np.dot(x,model['v'])+model['b']#隐层输入 a=np.tanh(p)#隐层输出 z=np.dot(a,model['w'])+model['c']#输出层输入 yhat=softmax(z)#输出层输出(概率) return np.argmax(yhat,axis=1),yhat#选概率大的作为分类 def CrossEntropyLoss(y,yhat):#单个样本交叉熵损失函数 return -np.sum(y*np.log(yhat)) def totalLoss(X,Y,model):#训练集总损失 Loss=0.0 for i in range(len(X)): ypred,yhat=predict(X[i],model) Loss+=CrossEntropyLoss(Y[i],yhat) return Loss/len(X) def build_model(X,Y,iters): ''' 在[0,1)区间内随机初始化连接权重与阈值 ''' v=np.random.random((Config.input_dim,Config.hidden_dim))#输入层到隐层的连接权重 w=np.random.random((Config.hidden_dim,Config.output_dim))#隐层到输出层的连接权重 b=np.random.random((1,Config.hidden_dim))#隐层的阈值 c=np.random.random((1,Config.output_dim))#输出层的阈值 model={} for t in range(iters): for i in range(len(X)):#一个训练样本就更新一次参数 #forward propagation p=np.dot(X[i],v)+b#隐层输入 a=np.tanh(p)#隐层输出 z=np.dot(a,w)+c#输出层输入 yhat=softmax(z)#输出层输出(概率) #back propagation g=yhat-Y[i]#输出层梯度 w+=-Config.eta*np.dot(a.transpose(),g)#更新隐层到输出层的连接权重 c+=-Config.eta*g#更新输出层的阈值 h=np.dot(g,w.transpose())*(1-np.power(a,2))#隐层梯度 v+=-Config.eta*np.dot(np.array([X[i]]).transpose(),h)#更新输入层到隐层的连接权重 b+=-Config.eta*h#更新隐层的阈值 model={'v': v, 'w': w, 'b': b, 'c': c} if(t%100==0): print "after",t,"iteration:",totalLoss(X,Y,model) return model def plot_decision_boundary(pred_func,X,Y): #设置最小最大值, 加上一点外边界 x_min,x_max=X[:,0].min()-.5,X[:,0].max()+.5 y_min,y_max=X[:,1].min()-.5,X[:,1].max()+.5 h=0.01 # 根据最小最大值和一个网格距离生成整个网格 xx,yy=np.meshgrid(np.arange(x_min,x_max,h),np.arange(y_min,y_max,h)) # 对整个网格预测边界值 Z,Yhat=pred_func(np.c_[xx.ravel(),yy.ravel()]) Z=Z.reshape(xx.shape) # 绘制边界和数据集的点 plt.contourf(xx,yy,Z,cmap=plt.cm.Spectral) plt.scatter(X[:,0],X[:,1],c=Y,cmap=plt.cm.Spectral) def NN(): X,Y=generate_data()#产生数据集 model=build_model(X,Y,1500)#建立神经网络模型,iters为迭代次数 plot_decision_boundary(lambda x: predict(x,model),X,Y) plt.title("Decision Boundary for hidden layer size %d" %Config.hidden_dim) plt.show() if __name__ == "__main__": NN() ``` 求解!!
在中国程序员是青春饭吗?
今年,我也32了 ,为了不给大家误导,咨询了猎头、圈内好友,以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助,记得帮我点赞哦。 目录: 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时,拿着傲人的工资,想着好好干,以为我们的人生是这样的: 等真到了那一天,你会发现,你的人生很可能是这样的: ...
我在支付宝花了1分钟,查到了女朋友的开房记录!
在大数据时代下,不管你做什么都会留下蛛丝马迹,只要学会把各种软件运用到极致,捉奸简直轻而易举。今天就来给大家分享一下,什么叫大数据抓出轨。据史料证明,马爸爸年轻时曾被...
程序员请照顾好自己,周末病魔差点一套带走我。
程序员在一个周末的时间,得了重病,差点当场去世,还好及时挽救回来了。
卸载 x 雷某度!GitHub 标星 1.5w+,从此我只用这款全能高速下载工具!
作者 | Rocky0429 来源 | Python空间 大家好,我是 Rocky0429,一个喜欢在网上收集各种资源的蒟蒻… 网上资源眼花缭乱,下载的方式也同样千奇百怪,比如 BT 下载,磁力链接,网盘资源等等等等,下个资源可真不容易,不一样的方式要用不同的下载软件,因此某比较有名的 x 雷和某度网盘成了我经常使用的工具。 作为一个没有钱的穷鬼,某度网盘几十 kb 的下载速度让我...
20道你必须要背会的微服务面试题,面试一定会被问到
写在前面: 在学习springcloud之前大家一定要先了解下,常见的面试题有那块,然后我们带着问题去学习这个微服务技术,那么就会更加理解springcloud技术。如果你已经学了springcloud,那么在准备面试的时候,一定要看看看这些面试题。 文章目录1、什么是微服务?2、微服务之间是如何通讯的?3、springcloud 与dubbo有哪些区别?4、请谈谈对SpringBoot 和S...
为什么猝死的都是程序员,基本上不见产品经理猝死呢?
相信大家时不时听到程序员猝死的消息,但是基本上听不到产品经理猝死的消息,这是为什么呢? 我们先百度搜一下:程序员猝死,出现将近700多万条搜索结果: 搜索一下:产品经理猝死,只有400万条的搜索结果,从搜索结果数量上来看,程序员猝死的搜索结果就比产品经理猝死的搜索结果高了一倍,而且从下图可以看到,首页里面的五条搜索结果,其实只有两条才是符合条件。 所以程序员猝死的概率真的比产品经理大,并不是错...
毕业5年,我问遍了身边的大佬,总结了他们的学习方法
我问了身边10个大佬,总结了他们的学习方法,原来成功都是有迹可循的。
推荐10个堪称神器的学习网站
每天都会收到很多读者的私信,问我:“二哥,有什么推荐的学习网站吗?最近很浮躁,手头的一些网站都看烦了,想看看二哥这里有什么新鲜货。” 今天一早做了个恶梦,梦到被老板辞退了。虽然说在我们公司,只有我辞退老板的份,没有老板辞退我这一说,但是还是被吓得 4 点多都起来了。(主要是因为我掌握着公司所有的核心源码,哈哈哈) 既然 4 点多起来,就得好好利用起来。于是我就挑选了 10 个堪称神器的学习网站,推...
这些软件太强了,Windows必装!尤其程序员!
Windows可谓是大多数人的生产力工具,集娱乐办公于一体,虽然在程序员这个群体中都说苹果是信仰,但是大部分不都是从Windows过来的,而且现在依然有很多的程序员用Windows。 所以,今天我就把我私藏的Windows必装的软件分享给大家,如果有一个你没有用过甚至没有听过,那你就赚了????,这可都是提升你幸福感的高效率生产力工具哦! 走起!???? NO、1 ScreenToGif 屏幕,摄像头和白板...
阿里面试,面试官没想到一个ArrayList,我都能跟他扯半小时
我是真的没想到,面试官会这样问我ArrayList。
曾经优秀的人,怎么就突然不优秀了。
职场上有很多辛酸事,很多合伙人出局的故事,很多技术骨干被裁员的故事。说来模板都类似,曾经是名校毕业,曾经是优秀员工,曾经被领导表扬,曾经业绩突出,然而突然有一天,因为种种原因,被裁员了,...
大学四年因为知道了这32个网站,我成了别人眼中的大神!
依稀记得,毕业那天,我们导员发给我毕业证的时候对我说“你可是咱们系的风云人物啊”,哎呀,别提当时多开心啦????,嗯,我们导员是所有导员中最帅的一个,真的???? 不过,导员说的是实话,很多人都叫我大神的,为啥,因为我知道这32个网站啊,你说强不强????,这次是绝对的干货,看好啦,走起来! PS:每个网站都是学计算机混互联网必须知道的,真的牛杯,我就不过多介绍了,大家自行探索,觉得没用的,尽管留言吐槽吧???? 社...
良心推荐,我珍藏的一些Chrome插件
上次搬家的时候,发了一个朋友圈,附带的照片中不小心暴露了自己的 Chrome 浏览器插件之多,于是就有小伙伴评论说分享一下我觉得还不错的浏览器插件。 我下面就把我日常工作和学习中经常用到的一些 Chrome 浏览器插件分享给大家,随便一个都能提高你的“生活品质”和工作效率。 Markdown Here Markdown Here 可以让你更愉快的写邮件,由于支持 Markdown 直接转电子邮...
看完这篇HTTP,跟面试官扯皮就没问题了
我是一名程序员,我的主要编程语言是 Java,我更是一名 Web 开发人员,所以我必须要了解 HTTP,所以本篇文章就来带你从 HTTP 入门到进阶,看完让你有一种恍然大悟、醍醐灌顶的感觉。 最初在有网络之前,我们的电脑都是单机的,单机系统是孤立的,我还记得 05 年前那会儿家里有个电脑,想打电脑游戏还得两个人在一个电脑上玩儿,及其不方便。我就想为什么家里人不让上网,我的同学 xxx 家里有网,每...
2020 年,大火的 Python 和 JavaScript 是否会被取而代之?
Python 和 JavaScript 是目前最火的两大编程语言,但是2020 年,什么编程语言将会取而代之呢? 作者 |Richard Kenneth Eng 译者 |明明如月,责编 | 郭芮 出品 | CSDN(ID:CSDNnews) 以下为译文: Python 和 JavaScript 是目前最火的两大编程语言。然而,他们不可能永远屹立不倒。最终,必将像其他编程语言一...
史上最全的IDEA快捷键总结
现在Idea成了主流开发工具,这篇博客对其使用的快捷键做了总结,希望对大家的开发工作有所帮助。
阿里程序员写了一个新手都写不出的低级bug,被骂惨了。
这种新手都不会范的错,居然被一个工作好几年的小伙子写出来,差点被当场开除了。
谁是华为扫地僧?
是的,华为也有扫地僧!2020年2月11-12日,“养在深闺人不知”的华为2012实验室扫地僧们,将在华为开发者大会2020(Cloud)上,和大家见面。到时,你可以和扫地僧们,吃一个洋...
AI 没让人类失业,搞 AI 的人先失业了
最近和几个 AI 领域的大佬闲聊 根据他们讲的消息和段子 改编出下面这个故事 如有雷同 都是巧合 1. 老王创业失败,被限制高消费 “这里写我跑路的消息实在太夸张了。” 王葱葱哼笑一下,把消息分享给群里。 阿杰也看了消息,笑了笑。在座几位也都笑了。 王葱葱是个有名的人物,21岁那年以全额奖学金进入 KMU 攻读人工智能博士,累计发表论文 40 余篇,个人技术博客更是成为深度学习领域内风向标。 ...
2020年,冯唐49岁:我给20、30岁IT职场年轻人的建议
点击“技术领导力”关注∆每天早上8:30推送 作者|Mr.K 编辑| Emma 来源|技术领导力(ID:jishulingdaoli) 前天的推文《冯唐:职场人35岁以后,方法论比经验重要》,收到了不少读者的反馈,觉得挺受启发。其实,冯唐写了不少关于职场方面的文章,都挺不错的。可惜大家只记住了“春风十里不如你”、“如何避免成为油腻腻的中年人”等不那么正经的文章。 本文整理了冯...
最全最强!世界大学计算机专业排名总结!
我正在参与CSDN200进20,希望得到您的支持,扫码续投票5次。感谢您! (为表示感谢,您投票后私信我,我把我总结的人工智能手推笔记和思维导图发送给您,感谢!) 目录 泰晤士高等教育世界大学排名 QS 世界大学排名 US News 世界大学排名 世界大学学术排名(Academic Ranking of World Universities) 泰晤士高等教育世界大学排名 中国共...
作为一名大学生,如何在B站上快乐的学习?
B站是个宝,谁用谁知道???? 作为一名大学生,你必须掌握的一项能力就是自学能力,很多看起来很牛X的人,你可以了解下,人家私底下一定是花大量的时间自学的,你可能会说,我也想学习啊,可是嘞,该学习啥嘞,不怕告诉你,互联网时代,最不缺的就是学习资源,最宝贵的是啥? 你可能会说是时间,不,不是时间,而是你的注意力,懂了吧! 那么,你说学习资源多,我咋不知道,那今天我就告诉你一个你必须知道的学习的地方,人称...
那些年,我们信了课本里的那些鬼话
教材永远都是有错误的,从小学到大学,我们不断的学习了很多错误知识。 斑羚飞渡 在我们学习的很多小学课文里,有很多是错误文章,或者说是假课文。像《斑羚飞渡》: 随着镰刀头羊的那声吼叫,整个斑羚群迅速分成两拨,老年斑羚为一拨,年轻斑羚为一拨。 就在这时,我看见,从那拨老斑羚里走出一只公斑羚来。公斑羚朝那拨年轻斑羚示意性地咩了一声,一只半大的斑羚应声走了出来。一老一少走到伤心崖,后退了几步,突...
使用 Python 和百度语音识别生成视频字幕
文章目录从视频中提取音频根据静音对音频分段使用百度语音识别获取 Access Token使用 Raw 数据进行合成生成字幕总结 从视频中提取音频 安装 moviepy pip install moviepy 相关代码: audio_file = work_path + '\\out.wav' video = VideoFileClip(video_file) video.audio.write_...
一个程序在计算机中是如何运行的?超级干货!!!
强烈声明:本文很干,请自备茶水!???? 开门见山,咱不说废话! 你有没有想过,你写的程序,是如何在计算机中运行的吗?比如我们搞Java的,肯定写过这段代码 public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } ...
【蘑菇街技术部年会】程序员与女神共舞,鼻血再次没止住。(文末内推)
蘑菇街技术部的年会,别开生面,一样全是美女。
那个在阿里养猪的工程师,5年了……
简介: 在阿里,走过1825天,没有趴下,依旧斗志满满,被称为“五年陈”。他们会被授予一枚戒指,过程就叫做“授戒仪式”。今天,咱们听听阿里的那些“五年陈”们的故事。 下一个五年,猪圈见! 我就是那个在养猪场里敲代码的工程师,一年多前我和20位工程师去了四川的猪场,出发前总架构师慷慨激昂的说:同学们,中国的养猪产业将因为我们而改变。但到了猪场,发现根本不是那么回事:要个WIFI,没有;...
为什么程序猿都不愿意去外包?
分享外包的组织架构,盈利模式,亲身经历,以及根据一些外包朋友的反馈,写了这篇文章 ,希望对正在找工作的老铁有所帮助
Java校招入职华为,半年后我跑路了
何来 我,一个双非本科弟弟,有幸在 19 届的秋招中得到前东家华为(以下简称 hw)的赏识,当时秋招签订就业协议,说是入了某 java bg,之后一系列组织架构调整原因等等让人无法理解的神操作,最终毕业前夕,被通知调往其他 bg 做嵌入式开发(纯 C 语言)。 由于已至于校招末尾,之前拿到的其他 offer 又无法再收回,一时感到无力回天,只得默默接受。 毕业后,直接入职开始了嵌入式苦旅,由于从未...
世界上有哪些代码量很少,但很牛逼很经典的算法或项目案例?
点击上方蓝字设为星标下面开始今天的学习~今天分享四个代码量很少,但很牛逼很经典的算法或项目案例。1、no code 项目地址:https://github.com/kelseyhight...
Python全栈 Linux基础之3.Linux常用命令
Linux对文件(包括目录)有很多常用命令,可以加快开发效率:ls是列出当前目录下的文件列表,选项有-a、-l、-h,还可以使用通配符;c功能是跳转目录,可以使用相对路径和绝对路径;mkdir命令创建一个新的目录,有-p选项,rm删除文件或目录,有-f、-r选项;cp用于复制文件,有-i、-r选项,tree命令可以将目录结构显示出来(树状显示),有-d选项,mv用来移动文件/目录,有-i选项;cat查看文件内容,more分屏显示文件内容,grep搜索内容;>、>>将执行结果重定向到一个文件;|用于管道输出。
​两年前不知如何编写代码的我,现在是一名人工智能工程师
全文共3526字,预计学习时长11分钟 图源:Unsplash 经常有小伙伴私信给小芯,我没有编程基础,不会写代码,如何进入AI行业呢?还能赶上AI浪潮吗? 任何时候努力都不算晚。 下面,小芯就给大家讲一个朋友的真实故事,希望能给那些处于迷茫与徘徊中的小伙伴们一丝启发。(下文以第一人称叙述) 图源:Unsplash 正如Elsa所说,职业转换是...
强烈推荐10本程序员必读的书
很遗憾,这个春节注定是刻骨铭心的,新型冠状病毒让每个人的神经都是紧绷的。那些处在武汉的白衣天使们,尤其值得我们的尊敬。而我们这些窝在家里的程序员,能不外出就不外出,就是对社会做出的最大的贡献。 有些读者私下问我,窝了几天,有点颓丧,能否推荐几本书在家里看看。我花了一天的时间,挑选了 10 本我最喜欢的书,你可以挑选感兴趣的来读一读。读书不仅可以平复恐惧的压力,还可以对未来充满希望,毕竟苦难终将会...
Python实战:抓肺炎疫情实时数据,画2019-nCoV疫情地图
今天,群里白垩老师问如何用python画武汉肺炎疫情地图。白垩老师是研究海洋生态与地球生物的学者,国家重点实验室成员,于不惑之年学习python,实为我等学习楷模。先前我并没有关注武汉肺炎的具体数据,也没有画过类似的数据分布图。于是就拿了两个小时,专门研究了一下,遂成此文。
非典逼出了淘宝和京东,新冠病毒能够逼出什么?
loonggg读完需要5分钟速读仅需 2 分钟大家好,我是你们的校长。我知道大家在家里都憋坏了,大家可能相对于封闭在家里“坐月子”,更希望能够早日上班。今天我带着大家换个思路来聊一个问题...
牛逼!一行代码居然能解决这么多曾经困扰我半天的算法题
春节假期这么长,干啥最好?当然是折腾一些算法题了,下面给大家讲几道一行代码就能解决的算法题,当然,我相信这些算法题你都做过,不过就算做过,也是可以看一看滴,毕竟,你当初大概率不是一行代码解决的。 学会了一行代码解决,以后遇到面试官问起的话,就可以装逼了。 一、2 的幂次方 问题描述:判断一个整数 n 是否为 2 的幂次方 对于这道题,常规操作是不断这把这个数除以 2,然后判断是否有余数,直到 ...
C++内存管理(面试版)
C++的内存管理 一、C++内存管理详解 1、内存的分配方式 (a)(a)(a)栈:编译器分配的内存,用来存储函数的局部变量,函数调用结束后则自动释放内存。 (b)(b)(b)堆:程序员用new分配的内存,一般存储指针;如果程序运行结束的时候没有被释放,则操作系统会自动回收。 (c)(c)(c)自由存储区:程序员用malloc分配的内存,使用free来释放内存。 (d)(d)(d)全局/静态存储区
Spring框架|JdbcTemplate介绍
文章目录一、JdbcTemplate 概述二、创建对象的源码分析三、JdbcTemplate操作数据库 一、JdbcTemplate 概述 在之前的web学习中,学习了手动封装JDBCtemplate,其好处是通过(sql语句+参数)模板化了编程。而真正的JDBCtemplete类,是Spring框架为我们写好的。 它是 Spring 框架中提供的一个对象,是对原始 Jdbc API 对象的简单...
为什么说程序员做外包没前途?
之前做过不到3个月的外包,2020的第一天就被释放了,2019年还剩1天,我从外包公司离职了。我就谈谈我个人的看法吧。首先我们定义一下什么是有前途 稳定的工作环境 不错的收入 能够在项目中不断提升自己的技能(ps:非技术上的认知也算) 找下家的时候能找到一份工资更高的工作 如果你目前还年轻,但高不成低不就,只有外包offer,那请往下看。 外包公司你应该...
B 站上有哪些很好的学习资源?
哇说起B站,在小九眼里就是宝藏般的存在,放年假宅在家时一天刷6、7个小时不在话下,更别提今年的跨年晚会,我简直是跪着看完的!! 最早大家聚在在B站是为了追番,再后来我在上面刷欧美新歌和漂亮小姐姐的舞蹈视频,最近两年我和周围的朋友们已经把B站当作学习教室了,而且学习成本还免费,真是个励志的好平台ヽ(.◕ฺˇд ˇ◕ฺ;)ノ 下面我们就来盘点一下B站上优质的学习资源: 综合类 Oeasy: 综合...
立即提问