李宏毅一深度学习 - CSDN
• 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（完整版）国语】机器学习 深度学习

目录
P1ML Lecture 0 - Introduction of Machine Learning
P2ML Lecture 1 - Regression - Case Study
P3ML Lecture 1 - Regression - Demo
P4ML Lecture 2 - Where does the error come from
P5ML Lecture 3-1 - Gradient Descent
P6ML Lecture 3-2 - Gradient Descent (Demo by AOE)
P7ML Lecture 3-3 - Gradient Descent (Demo by Minecraft)
P8ML Lecture 4 - Classification
P9ML Lecture 5 - Logistic Regression
P10ML Lecture 6 - Brief Introduction of Deep Learning-Dr
P11ML Lecture 7 - Backpropagation
P12ML Lecture 8-1 - “Hello world” of deep learning
P13ML Lecture 8-2 - Keras 2.0
P14ML Lecture 8-3 - Keras Demo
P15ML Lecture 9-1 - Tips for Training DNN
P16ML Lecture 9-2 - Keras Demo 2
P17ML Lecture 9-3 - Fizz Buzz in Tensorflow (sequel)
P18ML Lecture 10 - Convolutional Neural Network
P19ML Lecture 11 - Why Deep- P20ML Lecture 12 - Semi-supervised
P21ML Lecture 13 - Unsupervised Learning - Linear Methods
P22ML Lecture 14 - Unsupervised Learning - Word Embedding
P23ML Lecture 15 - Unsupervised Learning - Neighbor Embedding
P24ML Lecture 16 - Unsupervised Learning - Auto-encoder
P25ML Lecture 17 - Unsupervised Learning - Deep Generative Model (Part I)
P26ML Lecture 18 - Unsupervised Learning - Deep Generative Model (Part II)
P27ML Lecture 19 - Transfer Learning
P28ML Lecture 20 - Support Vector Machine (SVM)
P29ML Lecture 21-1 - Recurrent Neural Network (Part I)
P30ML Lecture 21-2 - Recurrent Neural Network (Part II)
P31ML Lecture 22 - Ensemble
P32ML Lecture 23-1 - Deep Reinforcement Learning
P33ML Lecture 23-2 - Policy Gradient (Supplementary Explanation)
P34ML Lecture 23-3 - Reinforcement Learning (including Q-learning)
P35 Structured Learning 1 - Introduction
P36 Structured Learning 2 - Linear Model
P37 Structured Learning 3 - Structured SVM
P38 Structured Learning 4 - Sequence Labeling

相关链接：【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 = -ylogy_{pred}-(1-y)log(1-y_{pred})$
y是数据标签，$y_{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

# 求梯度
y_pred = _f(X, w, b)
pred_error = Y_label - y_pred
w_grad = -np.sum(pred_error * X.T, 1)

训练网络
# 初始化权重矩阵和偏置
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]

# 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:
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

"""

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

# 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)

"""### 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]

# 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:
features = np.array(content)
for i in ind[0:10]:
print(features[i], w[i])

训练结果
损失函数曲线

准确率变化曲线

结果

数据集下载
链接：https://pan.baidu.com/s/1n_cfeSC1mtbQrpJv-5IBDg
提取码：ac3e


展开全文
• 李宏毅机器学习系列-深度学习简介深度学习的概况深度学习的步骤前馈神经网络全连接神经网络数字识别分类总结 深度学习的概况 深度学习从2012年的图像识别比赛开始就复苏了，发展越来越快，越来越好，具体他的发展...
李宏毅机器学习系列-深度学习简介深度学习的概况深度学习的步骤前馈神经网络全连接神经网络数字识别分类总结
深度学习的概况
深度学习从2012年的图像识别比赛开始就复苏了，发展越来越快，越来越好，具体他的发展历史可以百度下，可以追溯到很早时期，还有几个大起大落的阶段：

可以看看这些时间点的重要发展：

深度学习的步骤
那深度学习的步骤是怎么样的呢，其实跟我们前面说的机器学习差不多，就跟把大象放冰箱里的步骤差不多：

我们上次讲到了神经网络就是深度学习的重要部分，是由对个逻辑回归单元组合起来的：

前馈神经网络
先介绍下这个，其实就是前向传播，从输入计算到输出，输入的是向量，每个向量的每个特征都与后一层的每个神经元相连，通过激活函数计算输入，然后继续往后面的层输入，最后到输出层，是一个向量，比如图上的例子输入是[1,-1]，经过第一层的计算后，得到[0.98,0.12]，很明显经过了sigmoid的非线性作用：

那我们继续这样计算，知道计算到最后的输出：

那这整一个网络结构就可以看做是一个模型集合，输入是一个向量，输出也是一个向量：

全连接神经网络
我们来定义下这个网络,输入的向量也看做一层，叫做输入层，最后输出的向量叫输出层，中间的都叫隐藏层，每个层之间的神经网络都是相互连接的，所以叫做全连接神经网络:

当然还有残差神经网络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
• 作业链接:https://blog.csdn.net/iteapoy/article/details/105431738 作业目标：由前9小时的18个feature（包含PM2.5）预测第10个小时的PM2.5 数据:链接：https://pan.baidu.com/s/1vpeNkg13rHtWeg_Mt6v-1w 提取码...
• 深度学习三个步骤 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
• 深度学习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 ...
...