李宏毅一深度学习 - CSDN
  • 台湾李宏毅教授深度学习

    千次阅读 2016-11-13 12:13:54
    1、深度学习,是个矩阵计算过程,输入层,隐含层,输出层 2、神经元层层计算 3、链接视频

    1、深度学习,是一个矩阵计算过程,输入层,隐含层,输出层



    2、神经元一层层计算




    3、链接视频








    展开全文
  • 台大教授李宏毅深度学习课程 2017中文视频讲解PPT。
  • 李宏毅-深度学习Note 视频链接:机器学习-李宏毅(2019) Machine Learning 参考:李宏毅 深度学习19(完整版)国语】机器学习 深度学习 目录 P1ML Lecture 0 - Introduction of Machine Learning P2ML Lecture 1 -...

    李宏毅-深度学习Note

    视频链接:机器学习-李宏毅(2019) Machine Learning

    参考:李宏毅 深度学习19(完整版)国语】机器学习 深度学习



    相关链接:【1】李宏毅-深度学习Note(Lecture 0-2 Introduction Regression)

    展开全文
  • 李宏毅2020深度学习作业2 问题描述:给定个人的年龄、学历等信息,判断其工资是否大于5000元,是个典型的二分类问题。 训练数据训练集包含了54256个人的信息。 最后列是数据的标签。没有验证集,所以需要自己...

    李宏毅2020深度学习作业2

    问题描述

    给定一个人的年龄、学历等信息,判断其工资是否大于5000元,是一个典型的二分类问题。

    **训练数据:**训练集包含了48830个人的信息。
    在这里插入图片描述
    最后一列是数据的标签。没有验证集,所以需要自己将验证集分割出来,这里所使用的训练数据并不是原始的.CSV文件,而是经过one-hot编码之后生成的。所以训练集用的是X_train里面的数据:
    在这里插入图片描述

    代码实现

    数据处理
    定义路径,导入训练数据将数据结尾的换行符去除、以逗号为分隔符分割数据,数据转化为数组的形式。数据的处理是很重要的一步,这里因为使用的数据集是提前经过处理的,所以导入之后只需简单的清洗即可。

    import numpy as np
    
    np.random.seed(0)
    X_train_fpath = './data/X_train'
    Y_train_fpath = './data/Y_train'
    X_test_fpath = './data/X_test'
    output_fpath = './output_{}.csv'
    
    # 导入训练数据
    with open(X_train_fpath) as f:
        next(f) # 第一行不需要,所以从第二行开始
        X_train = np.array([line.strip('\n').split(',')[1:] for line in f], dtype = float) #第一列ID不需要,所以从1开始
    with open(Y_train_fpath) as f:
        next(f)
        Y_train = np.array([line.strip('\n').split(',')[1] for line in f], dtype = float)
    with open(X_test_fpath) as f:
        next(f)
        X_test = np.array([line.strip('\n').split(',')[1:] for line in f], dtype = float)
    

    函数定义

    1.正则化函数
    包含5个输入的参数,X,train,sepcified_column,X_mean,X_std。
    X指的输入数据,train等于ture或者false,等于ture时,归一化的是训练集数据;等于false时,归一化的是测试数据。sepcified_column指归一化哪一列,当等于None时,则是归一化整个数据集。X_mean,当train=false时,训练集的均值。X_std,当train=false时,训练集的方差。
    2.训练集分割函数
    将训练的数据分割为训练集和验证集
    3.乱序函数
    因为数据中的数据可能存在前一部全部是男的,后一部分全部是女的等关系,为了减弱这种关系,将数据集的顺序打乱
    4.激活函数
    这里使用的是sigmoid函数,用于计算概率
    5.逻辑回归方程
    该网络只有一层,定义这一层中权重和数据的运算
    6.预测函数
    输出预测结果
    7.准确率函数
    计算准确率
    8.求交叉熵
    求损失函数,二分类问题使用的是交叉熵函数
    Loss=ylogypred(1y)log(1ypred)Loss = -ylogy_{pred}-(1-y)log(1-y_{pred})
    y是数据标签,ypredy_{pred}是预测值
    9.梯度下降函数
    用梯度下降的方式改变权重,使网络和数据集拟合

    def _normalize(X, train = True, specified_column = None, X_mean = None, X_std = None): # 正则化函数
        if specified_column == None:
            specified_column = np.arange(X.shape[1]) # 得到X的列数,输出的是一个矩阵
        if train:
            X_mean = np.mean(X[:, specified_column] ,0).reshape(1, -1) #求每列的均值,变成一个行向量
            X_std  = np.std(X[:, specified_column], 0).reshape(1, -1)  #求每列的方差
    
        X[:,specified_column] = (X[:, specified_column] - X_mean) / (X_std + 1e-8) #归一化
         
        return X, X_mean, X_std
    
    def _train_dev_split(X, Y, dev_ratio = 0.25):
        train_size = int(len(X) * (1 - dev_ratio))
        return X[:train_size], Y[:train_size], X[train_size:], Y[train_size:]
    
    # 正则化训练数据和测试数据
    X_train, X_mean, X_std = _normalize(X_train, train = True)
    X_test, _, _= _normalize(X_test, train = False, specified_column = None, X_mean = X_mean, X_std = X_std)
        
    # 将数据分割为训练集和验证集
    dev_ratio = 0.1
    X_train, Y_train, X_dev, Y_dev = _train_dev_split(X_train, Y_train, dev_ratio = dev_ratio)
    
    train_size = X_train.shape[0] #训练集共有多少行
    dev_size = X_dev.shape[0]
    test_size = X_test.shape[0]
    data_dim = X_train.shape[1] #训练集共有多少列
    
    def _shuffle(X, Y): # 使数据集中的数据乱序排列
        randomize = np.arange(len(X)) #得到的是一个列表
        np.random.shuffle(randomize) # 将数组里面的数随机排列
        return (X[randomize], Y[randomize])
    
    def _sigmoid(z): #神经元的激活函数
        return np.clip(1 / (1.0 + np.exp(-z)), 1e-8, 1 - (1e-8))
    
    # 逻辑回归方程
    def _f(X, w, b):
        return _sigmoid(np.matmul(X, w) + b)
    
    # 预测函数,根据输入的数据预测输出
    def _predict(X, w, b):
        return np.round(_f(X, w, b)).astype(np.int)
        
    def _accuracy(Y_pred, Y_label): #求准确率
        acc = 1 - np.mean(np.abs(Y_pred - Y_label))
        return acc
    
    # 求loss函数
    def _cross_entropy_loss(y_pred, Y_label):
        cross_entropy = -np.dot(Y_label, np.log(y_pred)) - np.dot((1 - Y_label), np.log(1 - y_pred))
        return cross_entropy
    
    # 求梯度
    def _gradient(X, Y_label, w, b):
        y_pred = _f(X, w, b)
        pred_error = Y_label - y_pred
        w_grad = -np.sum(pred_error * X.T, 1)
        b_grad = -np.sum(pred_error)
        return w_grad, b_grad
    

    训练网络

    # 初始化权重矩阵和偏置
    w = np.zeros((data_dim,)) 
    b = np.zeros((1,))
    
    # 训练数据的参数    
    max_iter = 30 #最大训练次数
    batch_size = 8 #每次训练所使用的数据量
    learning_rate = 0.2 #学习率
    
    # 记录每一步的数据用于绘制图像
    train_loss = []
    dev_loss = []
    train_acc = []
    dev_acc = []
    
    # 记录参数更新的次数
    step = 1
    
    # Iterative training
    for epoch in range(max_iter):
        # Random shuffle at the begging of each epoch
        X_train, Y_train = _shuffle(X_train, Y_train)
            
        # Mini-batch training
        for idx in range(int(np.floor(train_size / batch_size))):
            X = X_train[idx*batch_size:(idx+1)*batch_size]
            Y = Y_train[idx*batch_size:(idx+1)*batch_size]
    
            # Compute the gradient
            w_grad, b_grad = _gradient(X, Y, w, b)
                
            # gradient descent update
            # learning rate decay with time
            w = w - learning_rate/np.sqrt(step) * w_grad
            b = b - learning_rate/np.sqrt(step) * b_grad
    
            step = step + 1
                
        # 计算损失函数和准确率,可以看出该网络只有一层
        y_train_pred = _f(X_train, w, b)
        Y_train_pred = np.round(y_train_pred) # 使得预测的结果只有0和1,成为一个二分类问题
        train_acc.append(_accuracy(Y_train_pred, Y_train))
        train_loss.append(_cross_entropy_loss(y_train_pred, Y_train) / train_size)
    
        y_dev_pred = _f(X_dev, w, b)
        Y_dev_pred = np.round(y_dev_pred)
        dev_acc.append(_accuracy(Y_dev_pred, Y_dev))
        dev_loss.append(_cross_entropy_loss(y_dev_pred, Y_dev) / dev_size)
    
    print('Training loss: {}'.format(train_loss[-1]))
    print('Development loss: {}'.format(dev_loss[-1]))
    print('Training accuracy: {}'.format(train_acc[-1]))
    print('Development accuracy: {}'.format(dev_acc[-1]))
    

    预测测试集数据

    # 预测测试集数据标签
    predictions = _predict(X_test, w, b)
    with open(output_fpath.format('logistic'), 'w') as f:
        f.write('id,label\n')
        for i, label in  enumerate(predictions):
            f.write('{},{}\n'.format(i, label))
    
    # 输出最重要的一部分权重
    ind = np.argsort(np.abs(w))[::-1]
    with open(X_test_fpath) as f:
        content = f.readline().strip('\n').split(',')
    features = np.array(content)
    for i in ind[0:10]:
        print(features[i], w[i])
    

    完整代码

    # -*- coding: utf-8 -*-
    """
    Load and normalize data, and then split training data into training set and development set.
    """
    import numpy as np
    
    np.random.seed(0)
    X_train_fpath = './data/X_train'
    Y_train_fpath = './data/Y_train'
    X_test_fpath = './data/X_test'
    output_fpath = './output_{}.csv'
    
    # Parse csv files to numpy array
    with open(X_train_fpath) as f:
        next(f) # 第一行不需要,所以从第二行开始
        X_train = np.array([line.strip('\n').split(',')[1:] for line in f], dtype = float) #第一列ID不需要,所以从1开始
    with open(Y_train_fpath) as f:
        next(f)
        Y_train = np.array([line.strip('\n').split(',')[1] for line in f], dtype = float)
    with open(X_test_fpath) as f:
        next(f)
        X_test = np.array([line.strip('\n').split(',')[1:] for line in f], dtype = float)
    
    def _normalize(X, train = True, specified_column = None, X_mean = None, X_std = None): # 正则化函数
        # This function normalizes specific columns of X.
        # The mean and standard variance of training data will be reused when processing testing data.
        #
        # Arguments:
        #     X: data to be processed
        #     train: 'True' when processing training data, 'False' for testing data
        #     specific_column: indexes of the columns that will be normalized. If 'None', all columns
        #         will be normalized.
        #     X_mean: mean value of training data, used when train = 'False'
        #     X_std: standard deviation of training data, used when train = 'False'
        # Outputs:
        #     X: normalized data
        #     X_mean: computed mean value of training data
        #     X_std: computed standard deviation of training data
    
        if specified_column == None:
            specified_column = np.arange(X.shape[1]) # 得到X的列数,输出的是一个矩阵
        if train:
            X_mean = np.mean(X[:, specified_column] ,0).reshape(1, -1) #求每列的均值,变成一个行向量
            X_std  = np.std(X[:, specified_column], 0).reshape(1, -1)  #求每列的方差
    
        X[:,specified_column] = (X[:, specified_column] - X_mean) / (X_std + 1e-8) #归一化
         
        return X, X_mean, X_std
    
    def _train_dev_split(X, Y, dev_ratio = 0.25):
        # This function spilts data into training set and development set.
        train_size = int(len(X) * (1 - dev_ratio))
        return X[:train_size], Y[:train_size], X[train_size:], Y[train_size:]
    
    # Normalize training and testing data
    X_train, X_mean, X_std = _normalize(X_train, train = True)
    X_test, _, _= _normalize(X_test, train = False, specified_column = None, X_mean = X_mean, X_std = X_std)
        
    # Split data into training set and development set将数据分割为训练集和验证集
    dev_ratio = 0.1
    X_train, Y_train, X_dev, Y_dev = _train_dev_split(X_train, Y_train, dev_ratio = dev_ratio)
    
    train_size = X_train.shape[0] #训练集共有多少行
    dev_size = X_dev.shape[0]
    test_size = X_test.shape[0]
    data_dim = X_train.shape[1] #训练集共有多少列
    print('Size of training set: {}'.format(train_size))
    print('Size of development set: {}'.format(dev_size))
    print('Size of testing set: {}'.format(test_size))
    print('Dimension of data: {}'.format(data_dim))
    
    """###Some Useful Functions
    
    Some functions that will be repeatedly used when iteratively updating the parameters.
    """
    
    def _shuffle(X, Y): # 使数据集中的数据乱序排列
        # This function shuffles two equal-length list/array, X and Y, together.
        randomize = np.arange(len(X)) #得到的是一个列表
        np.random.shuffle(randomize) # 将数组里面的数随机排列
        return (X[randomize], Y[randomize])
    
    def _sigmoid(z): #神经元的激活函数
        # Sigmoid function can be used to calculate probability.
        # To avoid overflow, minimum/maximum output value is set.
        return np.clip(1 / (1.0 + np.exp(-z)), 1e-8, 1 - (1e-8))
    
    def _f(X, w, b):
        # This is the logistic regression function, parameterized by w and b
        #
        # Arguements:
        #     X: input data, shape = [batch_size, data_dimension]
        #     w: weight vector, shape = [data_dimension, ]
        #     b: bias, scalar
        # Output:
        #     predicted probability of each row of X being positively labeled, shape = [batch_size, ]
        return _sigmoid(np.matmul(X, w) + b)
    
    def _predict(X, w, b):
        # This function returns a truth value prediction for each row of X 
        # by rounding the result of logistic regression function.
        return np.round(_f(X, w, b)).astype(np.int)
        
    def _accuracy(Y_pred, Y_label): #求准确率
        # This function calculates prediction accuracy
        acc = 1 - np.mean(np.abs(Y_pred - Y_label))
        return acc
    
    """### Functions about gradient and loss
    """
    
    def _cross_entropy_loss(y_pred, Y_label):
        # This function computes the cross entropy.
        #
        # Arguements:
        #     y_pred: probabilistic predictions, float vector
        #     Y_label: ground truth labels, bool vector
        # Output:
        #     cross entropy, scalar
        cross_entropy = -np.dot(Y_label, np.log(y_pred)) - np.dot((1 - Y_label), np.log(1 - y_pred))
        return cross_entropy
    
    def _gradient(X, Y_label, w, b):
        # This function computes the gradient of cross entropy loss with respect to weight w and bias b.
        y_pred = _f(X, w, b)
        pred_error = Y_label - y_pred
        w_grad = -np.sum(pred_error * X.T, 1)
        b_grad = -np.sum(pred_error)
        return w_grad, b_grad
    
    """### Training
    
    Everything is prepared, let's start training! 
    
    Mini-batch gradient descent is used here, in which training data are split into several mini-batches and each batch is fed into the model sequentially for losses and gradients computation. Weights and bias are updated on a mini-batch basis.
    
    Once we have gone through the whole training set,  the data have to be re-shuffled and mini-batch gradient desent has to be run on it again. We repeat such process until max number of iterations is reached.
    """
    
    # Zero initialization for weights ans bias
    w = np.zeros((data_dim,)) 
    b = np.zeros((1,))
    
    # Some parameters for training    
    max_iter = 30
    batch_size = 8
    learning_rate = 0.2
    
    # Keep the loss and accuracy at every iteration for plotting
    train_loss = []
    dev_loss = []
    train_acc = []
    dev_acc = []
    
    # Calcuate the number of parameter updates
    step = 1
    
    # Iterative training
    for epoch in range(max_iter):
        # Random shuffle at the begging of each epoch
        X_train, Y_train = _shuffle(X_train, Y_train)
            
        # Mini-batch training
        for idx in range(int(np.floor(train_size / batch_size))):
            X = X_train[idx*batch_size:(idx+1)*batch_size]
            Y = Y_train[idx*batch_size:(idx+1)*batch_size]
    
            # Compute the gradient
            w_grad, b_grad = _gradient(X, Y, w, b)
                
            # gradient descent update
            # learning rate decay with time
            w = w - learning_rate/np.sqrt(step) * w_grad
            b = b - learning_rate/np.sqrt(step) * b_grad
    
            step = step + 1
                
        # Compute loss and accuracy of training set and development set,可以看出该网络只有一层
        y_train_pred = _f(X_train, w, b)
        Y_train_pred = np.round(y_train_pred) # 使得预测的结果只有0和1,成为一个二分类问题
        train_acc.append(_accuracy(Y_train_pred, Y_train))
        train_loss.append(_cross_entropy_loss(y_train_pred, Y_train) / train_size)
    
        y_dev_pred = _f(X_dev, w, b)
        Y_dev_pred = np.round(y_dev_pred)
        dev_acc.append(_accuracy(Y_dev_pred, Y_dev))
        dev_loss.append(_cross_entropy_loss(y_dev_pred, Y_dev) / dev_size)
    
    print('Training loss: {}'.format(train_loss[-1]))
    print('Development loss: {}'.format(dev_loss[-1]))
    print('Training accuracy: {}'.format(train_acc[-1]))
    print('Development accuracy: {}'.format(dev_acc[-1]))
    
    """### Plotting Loss and accuracy curve"""
    
    import matplotlib.pyplot as plt
    
    # Loss curve
    plt.plot(train_loss)
    plt.plot(dev_loss)
    plt.title('Loss')
    plt.legend(['train', 'dev'])
    plt.savefig('loss.png')
    plt.show()
    
    # Accuracy curve
    plt.plot(train_acc)
    plt.plot(dev_acc)
    plt.title('Accuracy')
    plt.legend(['train', 'dev'])
    plt.savefig('acc.png')
    plt.show()
    
    """###Predicting testing labels
    
    Predictions are saved to *output_logistic.csv*.
    
    預測測試集的資料標籤並且存在 *output_logistic.csv* 中。
    """
    
    # Predict testing labels
    predictions = _predict(X_test, w, b)
    with open(output_fpath.format('logistic'), 'w') as f:
        f.write('id,label\n')
        for i, label in  enumerate(predictions):
            f.write('{},{}\n'.format(i, label))
    
    # Print out the most significant weights
    ind = np.argsort(np.abs(w))[::-1]
    with open(X_test_fpath) as f:
        content = f.readline().strip('\n').split(',')
    features = np.array(content)
    for i in ind[0:10]:
        print(features[i], w[i])
    

    训练结果

    损失函数曲线
    在这里插入图片描述

    准确率变化曲线
    在这里插入图片描述
    结果
    在这里插入图片描述
    数据集下载
    链接:https://pan.baidu.com/s/1n_cfeSC1mtbQrpJv-5IBDg
    提取码:ac3e

    展开全文
  • 李宏毅机器学习系列-深度学习简介

    千次阅读 2019-08-16 14:08:10
    李宏毅机器学习系列-深度学习简介深度学习的概况深度学习的步骤前馈神经网络全连接神经网络数字识别分类总结 深度学习的概况 深度学习从2012年的图像识别比赛开始就复苏了,发展越来越快,越来越好,具体他的发展...

    深度学习的概况

    深度学习从2012年的图像识别比赛开始就复苏了,发展越来越快,越来越好,具体他的发展历史可以百度下,可以追溯到很早时期,还有几个大起大落的阶段:
    在这里插入图片描述
    可以看看这些时间点的重要发展:
    在这里插入图片描述

    深度学习的步骤

    那深度学习的步骤是怎么样的呢,其实跟我们前面说的机器学习差不多,就跟把大象放冰箱里的步骤差不多:
    在这里插入图片描述
    我们上次讲到了神经网络就是深度学习的重要部分,是由对个逻辑回归单元组合起来的:
    在这里插入图片描述

    前馈神经网络

    先介绍下这个,其实就是前向传播,从输入计算到输出,输入的是向量,每个向量的每个特征都与后一层的每个神经元相连,通过激活函数计算输入,然后继续往后面的层输入,最后到输出层,是一个向量,比如图上的例子输入是[1,-1],经过第一层的计算后,得到[0.98,0.12],很明显经过了sigmoid的非线性作用:
    在这里插入图片描述
    那我们继续这样计算,知道计算到最后的输出:
    在这里插入图片描述
    那这整一个网络结构就可以看做是一个模型集合,输入是一个向量,输出也是一个向量:
    在这里插入图片描述

    全连接神经网络

    我们来定义下这个网络,输入的向量也看做一层,叫做输入层,最后输出的向量叫输出层,中间的都叫隐藏层,每个层之间的神经网络都是相互连接的,所以叫做全连接神经网络:
    在这里插入图片描述
    所以深度学习的深度可以看做隐藏层的层数很多,所以看上去很深,比如经典的一些模型AlexNet,VGG,GoogleNet:
    在这里插入图片描述
    当然还有残差神经网络Residual Net:
    在这里插入图片描述
    其实神经网络的计算,我们可以用矩阵,这样就可以在GPU上计算,可以大大缩短时间,比如:
    在这里插入图片描述
    上面的值是一层,其实每一层都是这么计算的,计算出的结果向量又作为下一层的输入:
    在这里插入图片描述
    所以输出可以看成一个个sigmoid函数叠起来的结果,有点像递归调用啊:
    在这里插入图片描述
    通常我们把最后的输出层当做多分类器,中间的隐藏层其实就变成了特征提取器了:
    在这里插入图片描述

    数字识别分类

    我们来举一个识别数字的例子:
    我们希望输入一张数字的图片,输出是一个数字:
    在这里插入图片描述
    我们的输入是16x16像素的图,如果是填充颜色的就是1,没有就是0,因此有256个点也就是256个特征输入:
    在这里插入图片描述
    我们的输出是一个10维的向量,每一个维度代表一个数字的概率,取概率最大的为分类的数字,如下,2的概率有0.7,所以这个图片的数字被预测为2:
    在这里插入图片描述
    然后我们需要设计一些隐藏层来组成这个模型:
    在这里插入图片描述
    那么问题来了,隐藏层多少层好呢,每一层的神经元个数多少好呢,这个没有很准确的答案,很多的是根据经验试错和直觉得来的,也就是实际结果得出来的,当然也有让机器自动选择要多少层,另外网络的结构能不能变呢,可以的,可以用CNN或者RNN或者其他的:
    在这里插入图片描述
    接下来要定义模型的好坏了,我们拿真实的预测值和预测的值做交叉熵作为损失函数,为什么不用均方差前面一篇将过了,梯度为0的地方可能是远离最小点的:
    在这里插入图片描述
    于是我们拿很多的样本来进行训练,计算总的损失,我们希望损失越小越好,最小的损失的参数模型就是我们要找的:
    在这里插入图片描述
    那怎么样找出这个损失最小的模型呢,还是我们的梯度下降法:

    在这里插入图片描述
    其实这个过程就是反向传播,具体是用链式法则求导的,也就是一个计算梯度更新参数的过程,当然当参数很复杂的时候我们不可能手动去算,现在有很多的框架,当然下面列的可能是比较老的了,现在一般有keras,pytorch,tensorflow,mxnet等等:
    在这里插入图片描述
    至此,深度学习怎么训练最基本的步骤讲完了。

    总结

    本篇简单介绍了深度学习的基本框架,介绍全连接神经网络的架构,介绍了前向传播和反向传播,其实如果考虑特征空间问题,那么隐藏层在做的是就是把原始的特征空间不断的进行扭曲变形,生成新的特征空间,也就是特征被映射到新的特征空间,就是坐标变换,用来做分类或者回归,而每一层的神经元的个数就是特征空间的维度,维度越高越容易区分。附上思维导图:
    在这里插入图片描述
    好了,今天就到这里了,希望对学习理解有帮助,大神看见勿喷,仅为自己的学习理解,能力有限,请多包涵,图片来自李宏毅课件,侵删。

    展开全文
  • 1、Keras在这里我们推荐使用keras进行深度学习编程,比起tensorflow来说更容易学习,操作简单,2、手写识别实例这里手写识别的数据集来自于minst,个非常常用的数据集,从keras里可以直接导入第步,定义方程,...
  • 视频链接:https://www.bilibili.com/video/av9770190/?p=6深度学习分为三部分:定义系列方程,计算方程的loss,然后选出最好的方程深度学习神经网络类似于人类的大脑的神经网络,每个方程可以看做个神经元,...
  • 李宏毅深度学习》卷积神经网络CNN:https://www.bilibili.com/video/av9770190/?p=10卷积神经网络CNN常用于影像处理,每个神经元就是classify,但是用fully connected来进行的时候参数会太多假如3万的维度,1000个...
  • 台大李宏毅教授深度学习公开课天搞懂深度学习全部课件,这里是pdf版,还有ppt版,也会发布。这是公认的入门深度学习最好的学习资料之。同时也会上传深度学习李宏毅全部的视频资料。
  • 李老师的视频教程相对比较系统的介绍了深度学习相关的理论。该视频教程共分成5个部分:李宏毅机器学习...amp;seid=456509998694502607李宏毅深度学习(2017)https://www.bilibili.com/video/av9770302?from=search...
  • 李宏毅深度学习课程作业2

    千次阅读 2019-04-11 09:54:13
    李宏毅深度学习作业2
  • 作业链接:https://blog.csdn.net/iteapoy/article/details/105431738 作业目标:由前9小时的18个feature(包含PM2.5)预测第10个小时的PM2.5 数据:链接:https://pan.baidu.com/s/1vpeNkg13rHtWeg_Mt6v-1w 提取码...
  • 李宏毅2020深度学习课程作业

    千次阅读 2020-03-31 23:52:07
    李宏毅老师个人网站链接:http://speech.ee.ntu.edu.tw/~tlkagk/courses_ML20.html 课程b站链接:https://www.bilibili.com/video/av94519857 作业说明YouTube链接:https://www.youtube.com/watch?v=QfU...
  • 深度学习三个步骤 1、neural network 2、损失函数 3、优化器 二、各概念关系 机器学习分类:监督学习、半监督学习、无监督学习、强化学习、迁移学习等。 其中,监督学习包括回归和分类,分类又分为线性模型和非...
  • 很直观 入门很好! Lecture I: Introduction of Deep Learning Lecture II: Tips for Training Deep Neural Network Lecture III: Variants of Neural Network Lecture IV: Next Wave
  • 本文是李宏毅深度学习 (2015)的学习笔记,主要介绍了神经网络Backpropagation算法的推导过程。本文所用到的图示均来自课堂ppt。 原视频地址:[李宏毅深度学习 (2015)][1]
  • 周后要进行深度学习考试。十几周的课程下来,基础部分掌握不是很扎实,高阶应用部分更是N头雾水。 在这种情况下,我阅读了李宏毅老师的文章。通过这篇精悍之文,可以提纲挈领地把握深度学习的主体框架,可以对...
  • 李宏毅深度学习2019讲义。19年最新的课程,Attact, Mete learning, GAN, Bert, Transformer
  • 李宏毅深度学习ppt总结

    千次阅读 2019-06-21 15:18:24
    深度学习3步骤: 1.定义神经网络 2.loss 评价 预测值和真实的测试数据的目标值进行比对,它们的差距就是Loss。个好的神经网络应该使loss尽可能小。 3.获取最佳的神经网络参数(学习方法) 采用梯度下降算法 ...
  • 李宏毅2020深度学习笔记——classification_1 ref:Bishop chapter4.2.2 通过输入model的object x的分析其各特征,将其分如对应的class中 eg:金融贷款: 输入:income, saving, profession, age, past financial ...
1 2 3 4 5 ... 20
收藏数 2,926
精华内容 1,170
热门标签
关键字:

李宏毅一深度学习