├── .DS_Store ├── 01-Python学习 ├── .DS_Store ├── .ipynb_checkpoints │ └── Pandas-checkpoint.ipynb ├── Data │ └── p.json ├── Numpy基础.ipynb ├── Pandas.ipynb ├── Scipy中的稀疏矩阵运算.ipynb ├── nanargmax.ipynb ├── 基于Numpy.convolve实现滑动平均滤波.ipynb ├── 操作Json文件操作.ipynb └── 角度弧度转换.ipynb ├── 03-最优化 ├── .DS_Store ├── .ipynb_checkpoints │ └── 梯度下降、加速梯度下降、随机梯度下降、随机坐标下降-checkpoint.ipynb ├── 拟牛顿法实现(DFP,BFGS).ipynb ├── 梯度下降.ipynb └── 梯度下降、加速梯度下降、随机梯度下降、随机坐标下降.ipynb ├── 04-传统机器学习 ├── 01-绪论.ipynb ├── 01_线性模型导论.ipynb ├── 02-模型评估.ipynb ├── 03-线性模型.ipynb ├── 04-决策树.ipynb ├── 05-神经网络.ipynb ├── 06-支持向量机.ipynb ├── 07-贝叶斯分类器.ipynb ├── 08-集成学习.ipynb ├── 09-聚类.ipynb ├── 10-降维与稀疏学习.ipynb ├── 11-特征选择与稀疏学习.ipynb ├── 12-计算学习理论.ipynb ├── 13-半监督学习.ipynb ├── 14-概率图模型.ipynb ├── 15-规则学习.ipynb ├── EM算法.ipynb ├── K近邻模型.ipynb ├── PCA.ipynb ├── 分布.ipynb └── 逻辑斯蒂回归.ipynb ├── 05-概率论机器学习 ├── 01-高斯混合模型.ipynb └── 02-概率分布.ipynb ├── 06-深度学习框架 ├── PyTorch教程1-Tensor核心知识点.ipynb ├── PyTorch教程2-DataSet与DataLoaders.ipynb ├── PyTorch教程3-DataSet与DataLoaders源码解析.ipynb ├── PyTorch教程4-神经网络基础功能模块.ipynb ├── PyTorch教程5-nn.Module类的源码讲解.ipynb ├── PyTorch教程6-自动微分以及autograd的使用.ipynb ├── PyTorch教程7-神经网络整体训练流程.ipynb └── PyTorch教程8-保存与加载PyTorch训练模型和超参数.ipynb ├── 07-深度学习 ├── 01-深度学习基础 │ ├── .ipynb_checkpoints │ │ ├── PyTorch的交叉熵、信息熵、二分类交叉熵、负对数似然、KL散度的原理与代码讲解-checkpoint.ipynb │ │ ├── 单机多卡、多GPU、分布式-checkpoint.ipynb │ │ └── 多种归一化原理与实现-checkpoint.ipynb │ ├── 01-数据操作+数据预处理.ipynb │ ├── 02-线性代数.ipynb │ ├── 03-矩阵运算、自动求导、计算图、自动求导实现.ipynb │ ├── 05-线性回归+基础优化算法.ipynb │ ├── 06-Softmax回归+损失函数+图片分类数据集.ipynb │ ├── 07-多层感知机+激活函数+代码实现.ipynb │ ├── 08-模型选择+过拟合和欠拟合.ipynb │ ├── 18-批量归一化.ipynb │ ├── PyTorch教程9-处理网络中的过拟合问题.ipynb │ ├── PyTorch的交叉熵、信息熵、二分类交叉熵、负对数似然、KL散度的原理与代码讲解.ipynb │ ├── 单机多卡、多GPU、分布式.ipynb │ ├── 多种归一化原理与实现.ipynb │ ├── 深度学习优化算法，SGD、Adam等.ipynb │ ├── 线性数据.csv │ └── 项目实战常用函数功能.ipynb ├── 02-卷积神经网络 │ ├── .DS_Store │ ├── .ipynb_checkpoints │ │ ├── 01-卷积网络代码级原理理解-checkpoint.ipynb │ │ ├── 02-卷积操作在PyTorch中实现与使用-checkpoint.ipynb │ │ └── 03-卷积算子融合-checkpoint.ipynb │ ├── 01-卷积网络代码级原理理解.ipynb │ ├── 02-卷积操作在PyTorch中实现与使用.ipynb │ └── 03-卷积算子融合.ipynb ├── 03-循环神经网络 │ ├── .DS_Store │ ├── .ipynb_checkpoints │ │ ├── 01-序列模型、语言模型-checkpoint.ipynb │ │ ├── 02-RNN原理与Numpy实现-checkpoint.ipynb │ │ ├── 03-LSTM原理与Numpy实现-checkpoint.ipynb │ │ ├── 04-GRU原理与Numpy实现-checkpoint.ipynb │ │ └── 05-PyTorch文本分类项目实战-checkpoint.ipynb │ ├── 01-序列模型、语言模型.ipynb │ ├── 02-RNN原理与Numpy实现.ipynb │ ├── 03-LSTM原理与Numpy实现.ipynb │ ├── 04-GRU原理与Numpy实现.ipynb │ └── consumer.h ├── 04-Transformer │ ├── .DS_Store │ ├── .ipynb_checkpoints │ │ ├── 01-Transformer-API详解-checkpoint.ipynb │ │ ├── 02-Attention机制-checkpoint.ipynb │ │ ├── 03-Transformer全流程代码-checkpoint.ipynb │ │ ├── 04-Vision-Transformer原理及实现-checkpoint.ipynb │ │ ├── 05-Swin-Transformer-checkpoint.ipynb │ │ ├── 06-基于Attention的Seq2Seq-checkpoint.ipynb │ │ └── 指针网络-checkpoint.ipynb │ ├── 01-Transformer-API详解.ipynb │ ├── 02-Attention机制.ipynb │ └── 03-Transformer全流程代码.ipynb ├── 05-图网络 │ ├── 01-PyG介绍.ipynb │ ├── 02-消息传递网络.ipynb │ ├── 03-创建自己的数据集.ipynb │ ├── 04-异构图.ipynb │ ├── 05-从CSV加载图形.ipynb │ └── 图神经网络.ipynb ├── 06-生成对抗学习 │ ├── .DS_Store │ ├── .ipynb_checkpoints │ │ ├── 01-生成对抗网络-checkpoint.ipynb │ │ ├── 02-条件生成对抗网络-checkpoint.ipynb │ │ └── 03-均方最小化生成对抗网络-checkpoint.ipynb │ ├── 01-生成对抗网络.ipynb │ ├── 02-条件生成对抗网络.ipynb │ └── 03-均方最小化生成对抗网络.ipynb └── 07-多任务学习 │ └── 多任务学习.ipynb ├── 08-自然语言处理 ├── .ipynb_checkpoints │ └── 01-Word Embedding原理及其PyTorch API-checkpoint.ipynb ├── 01-Word Embedding原理及其PyTorch API.ipynb ├── 05-PyTorch文本分类项目实战.ipynb ├── 06-基于Attention的Seq2Seq.ipynb ├── 10-编解码、Seq2seq.ipynb └── 11-束搜索、爬山算法.ipynb ├── 11-强化学习 ├── .DS_Store ├── 1-控制问题描述与进化算法 │ ├── 1.1-控制问题描述.ipynb │ ├── 1.2-Gym环境简介.ipynb │ ├── 1.3-创建自定义的强化学习优化环境.ipynb │ └── 1.4-网格环境求解.ipynb ├── 2-动态规划 │ ├── .ipynb_checkpoints │ │ ├── 2.02-值迭代-checkpoint.ipynb │ │ ├── 2.03-策略迭代-checkpoint.ipynb │ │ ├── 2.06-QLearning用于连续和离散动作空间-checkpoint.ipynb │ │ └── 2.07-Sarsa-checkpoint.ipynb │ ├── 2.01-马尔可夫决策过程.ipynb │ ├── 2.02-值迭代.ipynb │ ├── 2.03-策略迭代.ipynb │ ├── 2.04-MonteCarlo.ipynb │ ├── 2.05-OffPolicyMonteCarloControl.ipynb │ ├── 2.06-QLearning用于连续和离散动作空间.ipynb │ ├── 2.07-Sarsa.ipynb │ ├── 2.07-经验回放Q-Learning.ipynb │ ├── 2.08-DoubleQLearning.ipynb │ ├── 2.09-NStepSarsa.ipynb │ ├── 2.10-值迭代网络.ipynb │ ├── RL-第七章随机游走.ipynb │ ├── RL-第九章.ipynb │ ├── RL十三章.ipynb │ ├── RL第八章.ipynb │ ├── RL第六章.ipynb │ ├── RL第十一章.ipynb │ ├── RL第十二章.ipynb │ ├── RL第十章.ipynb │ └── 动态规划.ipynb ├── 3-深度Q网络系列 │ ├── .ipynb_checkpoints │ │ ├── 3.01-DQN倒立摆-checkpoint.ipynb │ │ └── 3.8-rainbow_dqn-checkpoint.ipynb │ ├── 3.01-DQN倒立摆.ipynb │ ├── 3.01-DQN像素游戏.ipynb │ ├── 3.10-GAE.ipynb │ ├── 3.10-her.ipynb │ ├── 3.2-DoubleDQN.ipynb │ ├── 3.3-DuelingDQN.ipynb │ ├── 3.4-NoiseDQN.ipynb │ ├── 3.5-PER.ipynb │ ├── 3.6-CategoricalDQN.ipynb │ ├── 3.7-quantile regression dqn.ipynb │ ├── 3.8-rainbow_dqn.ipynb │ └── 3.9-hierarchical dqn.ipynb ├── 4-策略优化 │ ├── .DS_Store │ ├── 1.6-进化策略.ipynb │ ├── 1.7-Cross-Entropy-Method.ipynb │ ├── 4-策略优化.ipynb │ ├── 4.2-NES.ipynb │ ├── 4.3-Policy Gradient.ipynb │ ├── 4.4-Reinforce.ipynb │ ├── 4.5-SVG.ipynb │ ├── 4.6-TRPO.ipynb │ ├── 4.7-PPO-.ipynb │ ├── 4.7-PPO.ipynb │ ├── 4.8-DDPG-.ipynb │ ├── 4.8-DDPG.ipynb │ └── POMDP.ipynb ├── 5-演员评论家 │ ├── 5-演员评论家.ipynb │ ├── 5.1-ActorCritic.ipynb │ ├── 5.1-sac.ipynb │ ├── 5.1-td3.ipynb │ ├── 5.2-acer.ipynb │ └── multiprocessing_env.py ├── 6-模仿学习与逆强化学习 │ ├── 6-模仿与逆强化学习.ipynb │ ├── 6.1-从观测中模仿.ipynb │ ├── 6.1-模仿学习(Behavior Cloning).ipynb │ └── 6.2-GAIL.ipynb ├── 7-基于模型的强化学习 │ └── 7-基于模型的强化学习.ipynb ├── 8-规划算法 │ ├── 8-蒙特卡洛采样.ipynb │ ├── 8.1-MCCFR.ipynb │ ├── 8.1-MCTS.ipynb │ ├── 8.1-Multi-Armed Bandit.ipynb │ ├── 8.1-虚拟遗憾最小化.ipynb │ ├── 8.2-AlphaZero.ipynb │ └── 探索与利用.ipynb ├── 9-分布式强化学习 │ ├── 9-分布式强化学习.ipynb │ └── 9.1-IMPALA.ipynb ├── GAIL.ipynb ├── actions_expert_Pendulum.npy ├── reward_exprt_TRPO.npy ├── reward_mean_pendulum_expert.npy ├── reward_mean_pendulum_random.npy └── reward_mean_walker_random.npy ├── 12-组合优化 ├── .DS_Store ├── Guribo │ ├── .DS_Store │ ├── 01-Gurobi基本操作 │ │ ├── 01-Gurobi基本操作.ipynb │ │ ├── 02-Gurobi的数据结构.ipynb │ │ └── 03-Gurobi中的Infeasible model问题.ipynb │ ├── 02-Gurobi功能和操作进阶 │ │ ├── .DS_Store │ │ ├── .ipynb_checkpoints │ │ │ └── 02-Gurobi功能和操作进阶-checkpoint.ipynb │ │ └── 02-Gurobi功能和操作进阶.ipynb │ ├── 03-Gurobi高级操作和使用方法 │ │ ├── .DS_Store │ │ ├── .ipynb_checkpoints │ │ │ └── 03-Gurobi高级操作和使用方法-checkpoint.ipynb │ │ ├── 03-Gurobi高级操作和使用方法.ipynb │ │ └── class3_pic1.jpg │ ├── 04-Gurobi的列生成和Benders分解 │ │ ├── .ipynb_checkpoints │ │ │ └── 04-Gurobi的列生成和Benders分解-checkpoint.ipynb │ │ └── 04-Gurobi的列生成和Benders分解.ipynb │ ├── 05-Gurobi供应链物流案例-波次优化-订单配送优化 │ │ ├── .DS_Store │ │ ├── .ipynb_checkpoints │ │ │ └── 05-Gurobi 供应链物流案例(波次优化、订单配送优化)-checkpoint.ipynb │ │ ├── 05-Gurobi 供应链物流案例(波次优化、订单配送优化).ipynb │ │ ├── class5_物流供应商信息.xlsx │ │ └── class5_订单信息.xlsx │ ├── GurobiClass5 │ │ ├── .DS_Store │ │ ├── BatchOpt │ │ │ ├── .DS_Store │ │ │ ├── BatchOpt_按仓库_Model(V2).py │ │ │ ├── BatchOpt_按库区_Model(V2+V4).py │ │ │ └── BatchOpt_按库区_Model(V2+V5).py │ │ └── 订单配送优化 │ │ │ ├── 物流供应商信息.xlsx │ │ │ ├── 订单信息.xlsx │ │ │ └── 订单配送优化.py │ ├── GurobiClass6 │ │ ├── .DS_Store │ │ ├── ATP │ │ │ ├── ATP.py │ │ │ ├── ATP数据.xlsx │ │ │ └── ATP方案.xlsx │ │ └── PDPTW │ │ │ ├── PDPTW.py │ │ │ ├── PDPTW数据.xlsx │ │ │ └── PDPTW方案.xlsx │ ├── GurobiClass7 │ │ ├── .DS_Store │ │ ├── 排产问题.py │ │ ├── 排班问题.py │ │ ├── 案例1 数据.xlsx │ │ ├── 案例1 结果.xlsx │ │ ├── 案例2 数据.xlsx │ │ └── 案例2 结果.xlsx │ └── Gurobi建模范式.ipynb ├── 分支定界.ipynb ├── 指针网络.ipynb └── 遗传算法求解TSP问题.ipynb ├── 14-深度视觉 ├── .DS_Store ├── 01-数据处理 │ ├── 20-数据增广.ipynb │ └── 21-微调.ipynb ├── 02-网络模型 │ ├── 04-Vision-Transformer原理及实现.ipynb │ ├── 05-Swin-Transformer.ipynb │ ├── 13-LeNet实现.ipynb │ ├── 14-AlexNet网络实现.ipynb │ ├── 15-VGG实现.ipynb │ ├── 16-NiN实现.ipynb │ ├── 17-GoogLeNet实现.ipynb │ └── 19-ResNet网络.ipynb └── 03-目标检测 │ ├── 22-目标检测和边界框.ipynb │ ├── 23-物体检测算法：R-CNN，SSD， YOLO.ipynb │ ├── 24-多尺度目标检测.ipynb │ └── 25-SSD实现.ipynb ├── 18-自动驾驶 └── 01-三个坐标系与运动学方程.ipynb ├── 20-TensorRT └── 未命名.ipynb ├── 21-Kaggle └── 01-房价预测.ipynb ├── LICENSE ├── README.md ├── d2l ├── __init__.py ├── mxnet.py ├── tensorflow.py └── torch.py ├── data ├── house_tiny.csv └── timemachine.txt └── images ├── .DS_Store ├── 06-jisuantu.png ├── 07-juanji.png ├── 11-Markov_Decision_Process_example.png ├── 11-connect2.png ├── 11-kuhnPoker.png ├── 11-policy-iteratioin.png ├── 11-value_iteration.png ├── 12-graph_example1.png ├── 12-graph_example_message_pass_1.png ├── 12-graph_message_pass.png ├── 12-graph_message_pass_1.png ├── 12-hg_example.svg ├── 18-donglixue.png ├── 18-hangxiangjiao.png ├── 18-qita.png ├── 18-youshouxi.png ├── 18-zuobiaoxi.png ├── GNN.png ├── GNN_data.png ├── MCTS.png ├── Transformer-decoder.png ├── Transformer-encoder.png ├── beta分布的超参数.png ├── com_graph.jpeg ├── confusion_matrix.jpeg ├── gamma分布.png ├── multi_head_attention.png ├── pca.png ├── pca_algorithms.png ├── pointer_network.png ├── scaled-dot-product-attention.png ├── scaled_attention.png ├── tinyzqh.jpg ├── transformer.png ├── zixingchemoxing.png ├── 凹函数的性质.png ├── 单纯形.png ├── 概率分布.png ├── 概率分布之间的关系.png ├── 狄利克雷分布.png ├── 高斯分布_均值的贝叶斯推断.png └── 高斯条件概率与边缘概率.png /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/.DS_Store -------------------------------------------------------------------------------- /01-Python学习/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/01-Python学习/.DS_Store -------------------------------------------------------------------------------- /01-Python学习/Data/p.json: -------------------------------------------------------------------------------- 1 | [1, 2, 3] 2 | [1, 2, 3] 3 | -------------------------------------------------------------------------------- /01-Python学习/nanargmax.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "54f09ee6", 6 | "metadata": {}, 7 | "source": [ 8 | "## Numpy中取非0下标" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "dec8ed21", 14 | "metadata": {}, 15 | "source": [ 16 | "  有时候在`numpy array`数组中会存在`nan`的元素，直接取`argmax`的话，取到的下标会是第一个`nan`的下标：" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "id": "86259453", 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "import numpy as np" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 2, 32 | "id": "115e8d08", 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "data = np.random.rand(5) # 生成“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1。 " 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "id": "384d139f", 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "data": { 47 | "text/plain": [ 48 | "array([[ nan, 0.9161768 , 0.65700317, 0.7531956 , 0.79048068]])" 49 | ] 50 | }, 51 | "execution_count": 3, 52 | "metadata": {}, 53 | "output_type": "execute_result" 54 | } 55 | ], 56 | "source": [ 57 | "data[np.random.randint(5, size=(1,))] = np.nan # 从[low,high)中随机生成整数，size表示生成一个什么样的数组。\n", 58 | "data = data.reshape(1, 5)\n", 59 | "data" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "id": "1fdc7ad6", 65 | "metadata": {}, 66 | "source": [ 67 | "  直接取值对应到的下标最大的索引将会取到nan对应的index。" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 4, 73 | "id": "e605ce84", 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "0" 80 | ] 81 | }, 82 | "execution_count": 4, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "data.argmax()" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 5, 94 | "id": "988c1612", 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [ 98 | "def nanargmax(data):\n", 99 | " idx = np.argmax(data, axis=None)\n", 100 | " if np.isnan(data[idx]):\n", 101 | " nan_count = np.sum(np.isnan(data))\n", 102 | " # In numpy < 1.8 use idx = np.argsort(a, axis=None)[-nan_count-1]\n", 103 | " idx = np.argpartition(data, -nan_count-1, axis=None)[-nan_count-1]\n", 104 | " return idx" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 6, 110 | "id": "81d17427", 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "data": { 115 | "text/plain": [ 116 | "1" 117 | ] 118 | }, 119 | "execution_count": 6, 120 | "metadata": {}, 121 | "output_type": "execute_result" 122 | } 123 | ], 124 | "source": [ 125 | "nanargmax(data[0])\n" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "id": "86114de0", 132 | "metadata": {}, 133 | "outputs": [], 134 | "source": [] 135 | } 136 | ], 137 | "metadata": { 138 | "kernelspec": { 139 | "display_name": "ACG", 140 | "language": "python", 141 | "name": "acg" 142 | }, 143 | "language_info": { 144 | "codemirror_mode": { 145 | "name": "ipython", 146 | "version": 3 147 | }, 148 | "file_extension": ".py", 149 | "mimetype": "text/x-python", 150 | "name": "python", 151 | "nbconvert_exporter": "python", 152 | "pygments_lexer": "ipython3", 153 | "version": "3.6.13" 154 | }, 155 | "toc": { 156 | "base_numbering": 1, 157 | "nav_menu": {}, 158 | "number_sections": true, 159 | "sideBar": true, 160 | "skip_h1_title": false, 161 | "title_cell": "Table of Contents", 162 | "title_sidebar": "Contents", 163 | "toc_cell": false, 164 | "toc_position": {}, 165 | "toc_section_display": true, 166 | "toc_window_display": false 167 | } 168 | }, 169 | "nbformat": 4, 170 | "nbformat_minor": 5 171 | } 172 | -------------------------------------------------------------------------------- /01-Python学习/操作Json文件操作.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "2d930a74", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import os\n", 11 | "import json" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "id": "1ef0d3dc", 17 | "metadata": {}, 18 | "source": [ 19 | "## Json保存文件" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 6, 25 | "id": "07e961d6", 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "data_wait_to_save = [1, 2, 3]\n", 30 | "\n", 31 | "filename = \"./Data/p.json\"\n", 32 | "if not os.path.exists(filename):\n", 33 | " os.system(r\"touch {}\".format(filename)) #调用系统命令行来创建文件\n", 34 | "\n", 35 | "with open(filename, 'a') as f:\n", 36 | " json.dump(data_wait_to_save, f)\n", 37 | " f.write('\\n')" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "id": "806282d2", 43 | "metadata": {}, 44 | "source": [ 45 | "## 加载Json文件" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 7, 51 | "id": "07998528", 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "name": "stdout", 56 | "output_type": "stream", 57 | "text": [ 58 | "[[1, 2, 3], [1, 2, 3]]\n" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "datas = []\n", 64 | "with open(filename, 'r') as f:\n", 65 | " data_list = f.read().split('\\n')[:-1]\n", 66 | " for x in data_list:\n", 67 | " list2 = json.loads(x)\n", 68 | " datas.append(list2)\n", 69 | "print(datas)" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": null, 75 | "id": "fce8ea0a", 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [] 79 | } 80 | ], 81 | "metadata": { 82 | "kernelspec": { 83 | "display_name": "ACG", 84 | "language": "python", 85 | "name": "acg" 86 | }, 87 | "language_info": { 88 | "codemirror_mode": { 89 | "name": "ipython", 90 | "version": 3 91 | }, 92 | "file_extension": ".py", 93 | "mimetype": "text/x-python", 94 | "name": "python", 95 | "nbconvert_exporter": "python", 96 | "pygments_lexer": "ipython3", 97 | "version": "3.6.13" 98 | } 99 | }, 100 | "nbformat": 4, 101 | "nbformat_minor": 5 102 | } 103 | -------------------------------------------------------------------------------- /01-Python学习/角度弧度转换.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "c9d9f87b", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import math\n", 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "id": "8f44494e", 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "def radian2angle(radian):\n", 22 | " \"\"\"\n", 23 | " 弧度值转化为角度值\n", 24 | " \"\"\"\n", 25 | " radian = np.clip(radian, -math.pi, math.pi)\n", 26 | " return radian / math.pi * 180" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 3, 32 | "id": "9c594e0c", 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "def angle2radian(angle):\n", 37 | " \"\"\"\n", 38 | " 角度值转化为弧度值\n", 39 | " \"\"\"\n", 40 | " angle = np.clip(angle, -180, 180)\n", 41 | " return angle / 180 * math.pi" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 4, 47 | "id": "4e45f765", 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "name": "stdout", 52 | "output_type": "stream", 53 | "text": [ 54 | "1.9883672055458734\n" 55 | ] 56 | } 57 | ], 58 | "source": [ 59 | "print(angle2radian(113.925049))" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 6, 65 | "id": "75f714c8", 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "name": "stdout", 70 | "output_type": "stream", 71 | "text": [ 72 | "0.31264445919458844\n" 73 | ] 74 | } 75 | ], 76 | "source": [ 77 | "print(angle2radian(17.913208))" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "id": "daced032", 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [] 87 | } 88 | ], 89 | "metadata": { 90 | "kernelspec": { 91 | "display_name": "ACG", 92 | "language": "python", 93 | "name": "acg" 94 | }, 95 | "language_info": { 96 | "codemirror_mode": { 97 | "name": "ipython", 98 | "version": 3 99 | }, 100 | "file_extension": ".py", 101 | "mimetype": "text/x-python", 102 | "name": "python", 103 | "nbconvert_exporter": "python", 104 | "pygments_lexer": "ipython3", 105 | "version": "3.6.13" 106 | } 107 | }, 108 | "nbformat": 4, 109 | "nbformat_minor": 5 110 | } 111 | -------------------------------------------------------------------------------- /03-最优化/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/03-最优化/.DS_Store -------------------------------------------------------------------------------- /03-最优化/梯度下降.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "972bb2f4", 6 | "metadata": {}, 7 | "source": [ 8 | "## 梯度下降" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 1, 14 | "id": "430c6977", 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "import scipy.sparse as sp\n", 19 | "import numpy as np" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "id": "946bb7f6", 25 | "metadata": {}, 26 | "source": [ 27 | "定义一个凸目标函数：\n", 28 | "$$\n", 29 | "\\min_{x} \\frac{1}{2} ||Ax-b||^{2}\n", 30 | "$$" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "id": "af954496", 36 | "metadata": {}, 37 | "source": [ 38 | "定义一个读取数据的函数`Fun()`, 读取参数$A$和$b$, 以及计算目标函数值的`min_f`:" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 2, 44 | "id": "c59e8d43", 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "class Fun(object):\n", 49 | " def __init__(self, path_a, path_b):\n", 50 | " self.file_a_path = path_a\n", 51 | " self.file_b_path = path_b\n", 52 | " self.A, self.b = self._get_parameter() # 获取到参数A和b的值\n", 53 | " self.A_T = self.A.transpose()\n", 54 | " self.x_init = sp.eye(self.A.shape[-1], self.b.shape[-1]).tocsr() # 设置初始解\n", 55 | "\n", 56 | " def min_f(self, x):\n", 57 | " y = self.A * x - self.b # 得到目标函数的值\n", 58 | " return np.linalg.norm(y.toarray(), ord=2) # 得到目标函数的二范数\n", 59 | "\n", 60 | " def _get_parameter(self):\n", 61 | " self.A = sp.load_npz(self.file_a_path).tocsr() # shape = (15935, 62061)\n", 62 | " self.b = sp.load_npz(self.file_b_path).tocsr() # shape = (15935, 1)\n", 63 | " return self.A, self.b" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "id": "1713433e", 69 | "metadata": {}, 70 | "source": [ 71 | "梯度下降的迭代公式：\n", 72 | "\n", 73 | "$$\n", 74 | "x_{k+1} = x_{k} - \\eta A^{T}(Ax_{k}-b)\n", 75 | "$$\n", 76 | "\n", 77 | "因为$A$的维度为`(15935, 62061)`，$b$的维度为`(15935, 1)`。所以$x$的维度为`(62061, 1)`，$x_{k}$的维度为`(62061, 1)`。$Ax_{k}-b$的纬度为`(15935, 1)`。$A^{T}$的维度为`(62061, 15935)`, $A^{T}(Ax_{k}-b)$的维度`(62061, 1)`能够与$x_{k}$对齐。\n", 78 | "\n" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 3, 84 | "id": "871f9e0f", 85 | "metadata": {}, 86 | "outputs": [], 87 | "source": [ 88 | "class GradientDescent(Fun):\n", 89 | " def __init__(self, path_a, path_b):\n", 90 | " super(GradientDescent, self).__init__(path_a, path_b)\n", 91 | "\n", 92 | " def gradient_decs(self, eta=0.002, iter_times=1, x_input=None):\n", 93 | " x_output = None\n", 94 | " y_input = self.min_f(x_input)\n", 95 | " for i in range(iter_times):\n", 96 | " x_output = x_input - eta * self.A_T * (self.A * x_input - self.b)\n", 97 | " x_input = x_output # 更新 x 的值\n", 98 | " y_output = self.min_f(x_output)\n", 99 | " print(\"pre_y is {} and y is {}\".format(y_input, y_output))\n", 100 | " y_input = y_output\n", 101 | " return x_output" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 4, 107 | "id": "8a39e3eb", 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "pre_y is 15.722300259397239 and y is 13.255437472728753\n", 115 | "pre_y is 13.255437472728753 and y is 12.830725844332473\n", 116 | "pre_y is 12.830725844332473 and y is 12.51692906968907\n", 117 | "pre_y is 12.51692906968907 and y is 12.27197839958532\n", 118 | "pre_y is 12.27197839958532 and y is 12.071656835698864\n", 119 | "pre_y is 12.071656835698864 and y is 11.900847835979816\n", 120 | "pre_y is 11.900847835979816 and y is 11.750127725254952\n", 121 | "pre_y is 11.750127725254952 and y is 11.613593698606474\n", 122 | "pre_y is 11.613593698606474 and y is 11.487508355089918\n", 123 | "pre_y is 11.487508355089918 and y is 11.369465105891495\n", 124 | "pre_y is 11.369465105891495 and y is 11.25787798929786\n", 125 | "pre_y is 11.25787798929786 and y is 11.151670710977404\n", 126 | "pre_y is 11.151670710977404 and y is 11.05008706842521\n", 127 | "pre_y is 11.05008706842521 and y is 10.9525750410614\n", 128 | "pre_y is 10.9525750410614 and y is 10.858715532640206\n", 129 | "pre_y is 10.858715532640206 and y is 10.768178203651498\n", 130 | "pre_y is 10.768178203651498 and y is 10.680693783528262\n", 131 | "pre_y is 10.680693783528262 and y is 10.596036453533646\n", 132 | "pre_y is 10.596036453533646 and y is 10.51401242388456\n", 133 | "pre_y is 10.51401242388456 and y is 10.43445235441449\n", 134 | "\n" 135 | ] 136 | } 137 | ], 138 | "source": [ 139 | "if __name__ == \"__main__\":\n", 140 | "\n", 141 | " GD = GradientDescent(path_a='./news20_A.npz', path_b='./news20_b.npz')\n", 142 | "\n", 143 | " GD.gradient_decs(eta=0.002, iter_times=20, x_input=GD.x_init)\n", 144 | "\n", 145 | " print('')" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "id": "6f0a6e9b", 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [] 155 | } 156 | ], 157 | "metadata": { 158 | "kernelspec": { 159 | "display_name": "ACG", 160 | "language": "python", 161 | "name": "acg" 162 | }, 163 | "language_info": { 164 | "codemirror_mode": { 165 | "name": "ipython", 166 | "version": 3 167 | }, 168 | "file_extension": ".py", 169 | "mimetype": "text/x-python", 170 | "name": "python", 171 | "nbconvert_exporter": "python", 172 | "pygments_lexer": "ipython3", 173 | "version": "3.6.13" 174 | } 175 | }, 176 | "nbformat": 4, 177 | "nbformat_minor": 5 178 | } 179 | -------------------------------------------------------------------------------- /04-传统机器学习/01-绪论.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "d41ae5f2", 6 | "metadata": {}, 7 | "source": [ 8 | "## 机器学习基本框架" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "adb50939", 14 | "metadata": {}, 15 | "source": [ 16 | "**基于知识-经验的机器学习基础框架可以描述为**：利用先验知识设计一个合理的学习结构，学习算法从数据中归纳出新的经验，并利用这些经验对学习结构进行调节、优化和更新，这些修正使得系统得以更好地完成目标任务。\n", 17 | "\n", 18 | "### 学习目标\n", 19 | "\n", 20 | "从应用角度分，学习任务可以分为：感知任务、归纳任务、生成任务等。\n", 21 | "\n", 22 | "从技术角度分，学习任务可以分为：预测任务、描述任务。预测任务包括回归和分类，描述任务包括聚类和概率估计。\n", 23 | "\n", 24 | "对于每个学习任务回定义一个优化目标，如在回归任务中一般采用均方误差，在分类任务中一般采用交叉熵。其它常用的目标函数包括Fisher准则、稀疏性、信息量等。\n", 25 | "\n", 26 | "### 学习结构\n", 27 | "\n", 28 | "函数、神经网络、概率图、规则集、有限状态自动机。\n", 29 | "\n", 30 | "定义学习结构，本身即是对先验知识进行形式化的过程，如贝叶斯网络里的相关性和条件概率，神经网络里的节点大小和激活函数等。\n", 31 | "\n", 32 | "### 训练数据\n", 33 | "\n", 34 | "通常需要关注数据是否完整，是否有动态性、不同数据间的相关性如何。另外我们一般不直接使用原始数据，而是通过数据选择、特征提取、预处理等抽取最有价值的数据进行学习。\n", 35 | "\n", 36 | "### 学习方法\n", 37 | "\n", 38 | "一般将算法根据是否需要人为标注分为有监督学习、无监督学习、半监督学习和增强学习。\n", 39 | "\n", 40 | "根据优化方法分类，可分为**直接求解**(如PCA模型中求解数据协方差矩阵的特征向量)、**数值优化**(如神经网络中的梯度下降算法)和**遗传进化**(如群体学习中的蚁群算法)等。" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "id": "6fb1f811", 46 | "metadata": {}, 47 | "source": [ 48 | "## 机器学习方法分类\n", 49 | "\n", 50 | "### 监督学习与非监督学习\n", 51 | "\n", 52 | "非监督学习是发现数据本身的分布规律，如聚类、流形学。\n", 53 | "\n", 54 | "半监督学习中，少量数据有标注，大部分数据没有标注，因此需要设计合理的算法对这些未标注数据进行有效利用。\n", 55 | "\n", 56 | "\n", 57 | "### 线性模型与非线性模型\n", 58 | "\n", 59 | "处理问题的时候，一般首选线性模型，对问题有了初步的探索之后，再扩展到非线性模型上去。\n", 60 | "\n", 61 | "### 参数模型与非参数模型\n", 62 | "\n", 63 | "1. 参数模型是结构固定，可由一组参数确定的模型。典型的参数模型包括高斯混合模型(GMM), 人工神经网络。\n", 64 | "\n", 65 | "2. 非参数模型没有固定结构，参数通常和训练数据有关。像KNN、高斯过程等。\n", 66 | "\n", 67 | "一般来说，参数模型包含固定的假设，因此需要的训练数据比较少，非参数模型对测试数据的表达依赖数据本身，往往需要较多数据覆盖数据空间。\n", 68 | "\n", 69 | "### 生成模型与判别模型\n", 70 | "\n", 71 | "1. **生成模型**：建立对数据的描述模型，再基于该描述模型完成目标任务。以分类任务为例，生成模型建立每一类的概率模型，再依据贝叶斯公示得到分类模型。\n", 72 | "\n", 73 | "2. **判别模型**：不以描述数据作为中间步骤，而是直接对条件概率进行建模。\n", 74 | "\n", 75 | "一般来说，生成模型有较强的模型假设，如果数据符合这一假设，则得到的分类模型较好。反之，如果数据和假设不符，则得到的分类模型较差。\n", 76 | "\n", 77 | "如果数据量比较少，一般选择生成模型，利用模型中的人为假设来减少数据稀疏的影响；\n", 78 | "\n", 79 | "如果数据量较大，一般选择判别模型，利用数据本身学习复杂的映射关系或分类面。\n", 80 | "\n", 81 | "### 概率模型与神经模型\n", 82 | "\n", 83 | "1. 概率模型：通过变量本身的概率分布及变量之间的概率关系来表示知识。\n", 84 | "2. 神经模型：不对变量建立明确的概率形式，而是通过同质化因子(神经元)之间的连接关系来表示知识。" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "id": "78ab7616", 90 | "metadata": {}, 91 | "source": [ 92 | "## 假设空间归纳偏好\n", 93 | "\n", 94 | "  科学的推理手段有两种:\n", 95 | "\n", 96 | "1. **归纳**：特殊到一般。\n", 97 | " - 狭义：从训练数据中得到概念。比如布尔概念：是或不是，假设就是各种情况。\n", 98 | " - 广义：从样本中学习。\n", 99 | "\n", 100 | "2. **演绎**：一般到特殊。" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "id": "b40e6576", 106 | "metadata": {}, 107 | "source": [ 108 | "## 归纳偏好\n", 109 | "\n", 110 | "  同一个数据集训练出了不同的模型，如何选择模型呢？\n", 111 | "\n", 112 | "  我们遵循奥卡姆剃刀原则，就是选择最简单的那个，因为越简单，抓住的东西就越本质，大道至简原则。" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": null, 118 | "id": "e7a3a705", 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [] 122 | } 123 | ], 124 | "metadata": { 125 | "kernelspec": { 126 | "display_name": "Python 3", 127 | "language": "python", 128 | "name": "python3" 129 | }, 130 | "language_info": { 131 | "codemirror_mode": { 132 | "name": "ipython", 133 | "version": 3 134 | }, 135 | "file_extension": ".py", 136 | "mimetype": "text/x-python", 137 | "name": "python", 138 | "nbconvert_exporter": "python", 139 | "pygments_lexer": "ipython3", 140 | "version": "3.8.8" 141 | }, 142 | "toc": { 143 | "base_numbering": 1, 144 | "nav_menu": {}, 145 | "number_sections": true, 146 | "sideBar": true, 147 | "skip_h1_title": false, 148 | "title_cell": "Table of Contents", 149 | "title_sidebar": "Contents", 150 | "toc_cell": false, 151 | "toc_position": {}, 152 | "toc_section_display": true, 153 | "toc_window_display": true 154 | } 155 | }, 156 | "nbformat": 4, 157 | "nbformat_minor": 5 158 | } 159 | -------------------------------------------------------------------------------- /04-传统机器学习/04-决策树.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "305edf5a", 6 | "metadata": {}, 7 | "source": [ 8 | "## 基本流程" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "c2181e9f", 14 | "metadata": {}, 15 | "source": [ 16 | "  概念：基于树模型做决策；**每个节点对应某个属性**；每个分支对应可能的结果；叶子结点对应预测结果。\n", 17 | "\n", 18 | "  每个节点对应的判断属性只是一个性质，就是我们依据什么分叉。" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "id": "0f47cdc0", 24 | "metadata": {}, 25 | "source": [ 26 | "## 划分选择" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "id": "40c690ac", 32 | "metadata": {}, 33 | "source": [ 34 | "### 信息增益(ID3)" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "798d3af1", 40 | "metadata": {}, 41 | "source": [ 42 | "\n", 43 | "#### 信息熵的概念与度量\n", 44 | "\n", 45 | "##### 概念\n", 46 | "\n", 47 | "1. **熵**\n", 48 | "\n", 49 | "  一种事物的不确定性叫做熵。\n", 50 | "\n", 51 | "2. **信息**\n", 52 | "\n", 53 | "  信息说的是一种能够消除不确定性的事物，能够用来调整概率、排除干扰。\n", 54 | "\n", 55 | "  **确定情况**是：比如卖瓜的人说了一句，保熟保甜，开了不甜算我的。\n", 56 | "\n", 57 | "3. **噪音**\n", 58 | "\n", 59 | "  不能消除某人对某件事物的不确定性。\n", 60 | "\n", 61 | "4. **数据**\n", 62 | "\n", 63 | "  我们所能拿到的数据就是噪音加上信息。\n", 64 | "\n", 65 | "##### 熵如何量化\n", 66 | "\n", 67 | "  以抛硬币为例，假设不确定性有`8`种，那么抛硬币就需要抛$log_{2}^{8} = 3$种。取完对数之后就能够去衡量这个熵了。\n", 68 | "\n", 69 | "  如果是每种情况概率不想等的话，一般分布可以描述为:\n", 70 | "\n", 71 | "$$\n", 72 | "\\operatorname{Ent}(D)=-\\sum_{k=1}^{|\\mathcal{Y}|} p_{k} \\log _{2} p_{k}\n", 73 | "$$\n", 74 | "\n", 75 | "#### 信息如何量化\n", 76 | "\n", 77 | "  当知道了熵如何量化之后，我们就能够去知道说知道了多少信息。\n", 78 | "\n", 79 | "  在得知信息的前后，我的不确定性的变化。也就是**对这个信息不确定性的差额就是信息提供的信息量**。\n", 80 | "\n" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "id": "38e50318", 86 | "metadata": {}, 87 | "source": [ 88 | "  拿到一个数据集之后，根节点的信息增益，就是依据标签计算出来的。\n", 89 | "\n", 90 | "  之后再计算每个特征划分完之后，里面有多少正例、里面有多少反例。比如依据色泽划分完之后，里面有**青绿**、**乌黑**和**浅白**。\n", 91 | "\n", 92 | "1. 青绿的有六分之三的正样本，六分之三的负样本；\n", 93 | "\n", 94 | "2. 乌黑的有六分之四的正样本，六分之二的负样本；\n", 95 | "\n", 96 | "3. 浅白的里面有五分之一的正样本，五分之四的负样本。\n", 97 | "\n", 98 | "  然后计算熵减了多少即可，减少最多的就说明信息越多。\n", 99 | "\n", 100 | "  **熵减最大**：\n", 101 | "\n", 102 | "$$\n", 103 | "\\Delta_{Entropy Reduction} = Entropy(parent) - \\sum_{j=1}^{k} \\frac{N(j)}{N}Entropy(j)\n", 104 | "$$\n", 105 | "\n", 106 | "  $k$是划分属性取值的个数。$N$是父亲结点上样本的总数，$N(j)$是第$j$个儿子结点上样本的数目。\n", 107 | "\n" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "id": "c2082266", 113 | "metadata": {}, 114 | "source": [ 115 | "### 增益率(C4.5)\n", 116 | "\n", 117 | "  如果以信息增益率为划分依据，存在偏向选择**特征取值较多的特征**，信息增益比是对这一问题进行矫正。比如划分用户的时候，依据用户`ID`划分的话，只需要一层决策树就够了。\n", 118 | "\n", 119 | "- 实际上，信息增益准则对可取数目较多的属性有所偏好，`C4.5`决策树算法不直接使用信息增益，而是使用**增益率**(`gain ratio`)来选择最优划分属性。增益率定义为:\n", 120 | "\n", 121 | "$$\n", 122 | "\\operatorname{Gain} \\operatorname{ratio}(D, a)=\\frac{\\operatorname{Gain}(D, a)}{\\operatorname{IV}(a)}\n", 123 | "$$\n", 124 | "\n", 125 | "  其中:\n", 126 | "\n", 127 | "$$\n", 128 | "\\operatorname{IV}(a)=-\\sum_{v=1}^{V} \\frac{\\left|D^{v}\\right|}{|D|} \\log _{2} \\frac{\\left|D^{v}\\right|}{|D|}\n", 129 | "$$\n", 130 | "\n", 131 | "  属性$a$的可能取值数目越多(即V越大)，则$IV(a)$的取值通常会越大。" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "id": "d368436d", 137 | "metadata": {}, 138 | "source": [ 139 | "  在具体使用的时候，先从候选划分属性中找出信息增益高于平均水平的属性，再从中选择增益率最高的。" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "id": "2c36f897", 145 | "metadata": {}, 146 | "source": [ 147 | "### 基尼指数(CART)\n", 148 | "\n", 149 | "  我们也可以将纯度的计算换成基尼指数：\n", 150 | "\n", 151 | "$$\n", 152 | "Gini(t)=1-\\sum_{i=1}^{c}p(i)^{2}\n", 153 | "$$\n", 154 | "\n", 155 | "  假设我们依据`Chest Pain`特征划分，之后得到是否患心脏病的统计数字为: `yes-105`，`no-39`；`yes-34`，`no-125`。" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 1, 161 | "id": "a2699ad5", 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "name": "stdout", 166 | "output_type": "stream", 167 | "text": [ 168 | "0.39\n", 169 | "0.36\n" 170 | ] 171 | } 172 | ], 173 | "source": [ 174 | "def gini_index_single(a, b):\n", 175 | " single_gini = 1 - ((a / (a + b))**2) - ((b / (a + b))**2)\n", 176 | " return round(single_gini, 2)\n", 177 | "\n", 178 | "def gini_index(a, b, c, d):\n", 179 | " left = gini_index_single(a, b)\n", 180 | " right = gini_index_single(c, d)\n", 181 | " \n", 182 | " # 算出左边和右边之后再进行加权平均。\n", 183 | " gini_index = left * ((a + b) / (a + b + c + d)) + right * ((c + d) / (a + b + c + d))\n", 184 | " return round(gini_index, 2)\n", 185 | "\n", 186 | "print(gini_index_single(105, 39))\n", 187 | "print(gini_index(105, 39, 34, 125))" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "id": "f620be62", 193 | "metadata": {}, 194 | "source": [ 195 | "#### 分类树\n", 196 | "\n", 197 | "  基尼指数最小准则。与熵减最小类似。" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "id": "e7b38240", 203 | "metadata": {}, 204 | "source": [ 205 | "#### 回归树\n", 206 | "\n", 207 | "  平方误差最小准则。" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "id": "8bdde82f", 213 | "metadata": {}, 214 | "source": [ 215 | "## 剪枝处理\n", 216 | "\n", 217 | "  剪枝的目的就是为了对付过拟合。" 218 | ] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "id": "c5745790", 223 | "metadata": {}, 224 | "source": [ 225 | "### 预剪枝\n", 226 | "\n", 227 | "  选择一个特征，在不分的时候，查看一下验证集上的精度(依据训练集上的正负样本的比例来判断)。如果划分之后，精度有提升的话，就划分，不然就不划分。" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "id": "33323983", 233 | "metadata": {}, 234 | "source": [ 235 | "### 后剪枝\n", 236 | "\n", 237 | "  就是全部分完，之后再看能不剪枝。如果剪枝前后没有变化，就不剪了。预剪枝是能剪的全部剪掉。" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "id": "d6e8a151", 243 | "metadata": {}, 244 | "source": [ 245 | "## 连续与缺失值" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "id": "0fe3fe88", 251 | "metadata": {}, 252 | "source": [ 253 | "### 连续值处理" 254 | ] 255 | }, 256 | { 257 | "cell_type": "markdown", 258 | "id": "d41e0271", 259 | "metadata": {}, 260 | "source": [ 261 | "  使用二分法，找到能够使得信息增益减最大的阈值。" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "id": "d4468458", 267 | "metadata": {}, 268 | "source": [ 269 | "### 缺失值处理" 270 | ] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "id": "2d4c8ac1", 275 | "metadata": {}, 276 | "source": [ 277 | "  属性里面有一些缺失值如何处理？\n", 278 | "\n", 279 | "1. **C4.5例子**: 去掉有缺失值的样本，计算一遍信息增益。然后再乘上权重(去掉有缺失值的样本 / 全部样本)。\n", 280 | "\n", 281 | "2. **离散值**：\n", 282 | " - 众数填充；\n", 283 | " - 相关性最高的列填充；\n", 284 | "\n", 285 | "3. **连续值**：\n", 286 | " - 中位数；\n", 287 | " - 相关性最高的列做线性回归进行估计；" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "id": "eec4697c", 293 | "metadata": {}, 294 | "source": [ 295 | "## 多变量决策树\n", 296 | "\n", 297 | "  多变量决策树里面判断节点分叉的地方可能是多个属性的组合。里面存在属性的线性组合，分割曲线会比较平滑。" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "id": "74a0b59d", 303 | "metadata": {}, 304 | "source": [ 305 | "## 参考资料" 306 | ] 307 | }, 308 | { 309 | "cell_type": "markdown", 310 | "id": "a050138e", 311 | "metadata": {}, 312 | "source": [] 313 | } 314 | ], 315 | "metadata": { 316 | "kernelspec": { 317 | "display_name": "Python 3 (ipykernel)", 318 | "language": "python", 319 | "name": "python3" 320 | }, 321 | "language_info": { 322 | "codemirror_mode": { 323 | "name": "ipython", 324 | "version": 3 325 | }, 326 | "file_extension": ".py", 327 | "mimetype": "text/x-python", 328 | "name": "python", 329 | "nbconvert_exporter": "python", 330 | "pygments_lexer": "ipython3", 331 | "version": "3.9.4" 332 | }, 333 | "toc": { 334 | "base_numbering": 1, 335 | "nav_menu": {}, 336 | "number_sections": true, 337 | "sideBar": true, 338 | "skip_h1_title": false, 339 | "title_cell": "Table of Contents", 340 | "title_sidebar": "Contents", 341 | "toc_cell": false, 342 | "toc_position": {}, 343 | "toc_section_display": true, 344 | "toc_window_display": true 345 | } 346 | }, 347 | "nbformat": 4, 348 | "nbformat_minor": 5 349 | } 350 | -------------------------------------------------------------------------------- /04-传统机器学习/07-贝叶斯分类器.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "cfae71e7", 6 | "metadata": {}, 7 | "source": [] 8 | }, 9 | { 10 | "cell_type": "markdown", 11 | "id": "69d5bdf2", 12 | "metadata": {}, 13 | "source": [ 14 | "## 贝叶斯决策论" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "049d77d1", 20 | "metadata": {}, 21 | "source": [ 22 | "1. 条件概率: $P(y | x)$, 给定$x$的条件下，是$y$的概率。\n", 23 | "\n", 24 | "2. 贝叶斯概率: $P(y|x) = \\frac{P(xy)}{P(x)} = \\frac{P(x|y)P(y)}{P(x)}$\n", 25 | "\n", 26 | "3. 3门问题" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "id": "eb5ffcee", 32 | "metadata": {}, 33 | "source": [ 34 | "## 为什么贝叶斯可以解决分类问题" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "edd88a97", 40 | "metadata": {}, 41 | "source": [ 42 | "\n", 43 | "1. **直观理解**:\n", 44 | "\n", 45 | "  假设有一个手写数据集，里面有100条记录，其中第0-9条记录是10个人分别写的0。10-19条是10个人分别写的1。····。第90-99条是10个人分别写的10。\n", 46 | "\n", 47 | "  这个时候来了一个数字$x$,怎么判断是数字几呢？\n", 48 | "\n", 49 | "  朴素贝叶斯工作原理: 找到$Y$等于各个值的概率: $P(Y=0|X)=?$, $P(Y=1|X)=?$, ···, $P(Y=10|X)=?$，找到概率值最高的，就是对应的数字。\n", 50 | "\n", 51 | "2. **数学理解**: \n", 52 | "\n", 53 | "  假设数字的类别为$C_{k}$, 则$C_{0}$表示数字0，···。刚才数字判别公式可以修改为$P(Y=C_{k}|X=x)$。\n", 54 | " \n", 55 | "$$\n", 56 | "P(Y=C_{k}|X=x)=\\frac{P(X=x | Y=C_{k})P(Y=C_{k})}{P(X=x)} \\\\\n", 57 | "= \\frac{P(X=x | Y=C_{k})P(Y=C_{k})}{\\sum_{k}P(X=x, Y=C_{k})} \\\\\n", 58 | "= \\frac{P(X=x | Y=C_{k})P(Y=C_{k})}{\\sum_{k}P(X=x | Y=C_{k})P(Y=C_{k}))} \\\\\n", 59 | "= \\frac{P(Y=C_{k}) \\prod_{j} P(X^{(j)}=x^{(j)} | Y=C_{k})}{\\sum_{k} P(Y=C_{k}) \\prod_{j} P(X^{(j)}=x^{(j)} | Y=C_{k}))}\n", 60 | "$$\n", 61 | "\n", 62 | "  上述等式最后一个等式推倒有一个很强的假设：样本不同特征之间(变量)都是强相互独立的。如果不这样假设的话，运算量就会很大。希望求解到对应标签概率最大的那个值：\n", 63 | "\n", 64 | "$$\n", 65 | "f(x) = arg\\max_{c_{k}}P(Y=C_{k} | X=x)=\\frac{P(Y=C_{k}) \\prod_{j} P(X^{(j)}=x^{(j)} | Y=C_{k})}{\\sum_{k} P(Y=C_{k}) \\prod_{j} P(X^{(j)}=x^{(j)} | Y=C_{k}))} \\\\\n", 66 | "= P(Y=C_{k}) \\prod_{j} P(X^{(j)}=x^{(j)} | Y=C_{k})\n", 67 | "$$\n", 68 | "\n", 69 | "  上述中分母是一个常数，就是$P(X=x)$，与标签$Y$没有关系。之后我们就需要去计算每一项对应的概率：\n", 70 | "\n", 71 | "$$\n", 72 | "P(Y=C_{k}) = \\frac{\\sum_{i=1}^{N}I(y_{i}=C_{k})}{N}, k=1,2,\\cdots,K\n", 73 | "$$\n", 74 | "\n", 75 | "  上式中说的是某一类样本的概率。比如总共有`100`个样本，标签为`0`的样本有`5`个，标签为`1`的样本有`90`个，标签为`2`的样本有`5`个的话，则：$P(Y=0)=0.05$, $P(Y=1)=0.9$, $P(Y=2)=0.05$。\n", 76 | "\n", 77 | "  第二项：\n", 78 | "\n", 79 | "$$\n", 80 | "P(X^{(j)}=a_{jl} | Y = C_{k}) = \\frac{\\sum_{i=1}^{N} I(x_{i}^{(j)}=a_{jl}, y_{i}=C_{k} )}{\\sum_{i=1}^{N} I(y_{i}=C_{k})}\n", 81 | "$$\n", 82 | "\n", 83 | "  比如总共有`100`个样本，标签为`0`的样本有`5`个，标签为`1`的样本有`90`个，标签为`2`的样本有`5`个的话。当$C_{k}=1$时，需要统计的就是当前`label`为`1`的样本当中，$X$中特征为$j$位置上等于$a_{jl}$的概率。比如有`20`条满足$j$位置上等于$a_{jl}$，那么概率值就是$\\frac{20}{90}$。\n", 84 | "\n", 85 | "  可以看到**上述过程没有一个显示计算的过程**。" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "id": "1673629d", 91 | "metadata": {}, 92 | "source": [ 93 | "## 贝叶斯怎样解决问题\n", 94 | "\n", 95 | "- https://zhiqianghe.blog.csdn.net/article/details/102654676\n", 96 | "\n", 97 | "### 贝叶斯估计\n", 98 | "\n", 99 | "### 朴素贝叶斯的极大似然估计\n", 100 | "\n", 101 | "### 后验概率最大化含义：期望风险最小化。" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "id": "60374355", 107 | "metadata": {}, 108 | "source": [] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "id": "4adb07ad", 113 | "metadata": {}, 114 | "source": [ 115 | "### 半贝叶斯算法" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "id": "6a135240", 121 | "metadata": {}, 122 | "source": [ 123 | "### 贝叶斯网络" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "id": "0ab009eb", 129 | "metadata": {}, 130 | "source": [ 131 | "## 其他" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "id": "8c38711a", 137 | "metadata": {}, 138 | "source": [ 139 | "### EM算法" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "id": "1e88d006", 146 | "metadata": {}, 147 | "outputs": [], 148 | "source": [] 149 | } 150 | ], 151 | "metadata": { 152 | "kernelspec": { 153 | "display_name": "Python 3 (ipykernel)", 154 | "language": "python", 155 | "name": "python3" 156 | }, 157 | "language_info": { 158 | "codemirror_mode": { 159 | "name": "ipython", 160 | "version": 3 161 | }, 162 | "file_extension": ".py", 163 | "mimetype": "text/x-python", 164 | "name": "python", 165 | "nbconvert_exporter": "python", 166 | "pygments_lexer": "ipython3", 167 | "version": "3.9.4" 168 | }, 169 | "toc": { 170 | "base_numbering": 1, 171 | "nav_menu": {}, 172 | "number_sections": true, 173 | "sideBar": true, 174 | "skip_h1_title": false, 175 | "title_cell": "Table of Contents", 176 | "title_sidebar": "Contents", 177 | "toc_cell": false, 178 | "toc_position": {}, 179 | "toc_section_display": true, 180 | "toc_window_display": true 181 | } 182 | }, 183 | "nbformat": 4, 184 | "nbformat_minor": 5 185 | } 186 | -------------------------------------------------------------------------------- /04-传统机器学习/08-集成学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "4e2e41d3", 6 | "metadata": {}, 7 | "source": [ 8 | "原则是选择好而不同的学习器：\n", 9 | "\n", 10 | "\n", 11 | "  集成学习主要两个类别：\n", 12 | "\n", 13 | "1. 序列方法\n", 14 | "2. 并行方法\n", 15 | "\n", 16 | "  其中**提升方法是集成学习的一种**。提升方法的基本思路是：将弱可学习算法提升为强可学习算法。" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "id": "84b29dc5", 22 | "metadata": {}, 23 | "source": [ 24 | "## 提升方法" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "id": "c82b7502", 30 | "metadata": {}, 31 | "source": [ 32 | "### Adaboost\n", 33 | "\n", 34 | "- https://zhuanlan.zhihu.com/p/27126737" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "d96fe635", 40 | "metadata": {}, 41 | "source": [ 42 | "  `Adaboost`算法解决的是分类问题，$y \\in [-1, 1]$。\n", 43 | "\n", 44 | "1. 在训练数据上训练得到模型，查看模型在整体数据和单个数据的分类效果。\n", 45 | "2. 在整体数据上分类效果较好，则该模型在最后的模型中占较大比例，反之。\n", 46 | "3. 在单个数据上分类效果较好，那么在训练下一个模型时，调小该单个数据的权值，反之。\n", 47 | "\n", 48 | "  在上面过程迭代$N$次之后，直到最后的分类结果达到预期目标。将所有的模型组合，得到强可学习模型。\n", 49 | "\n", 50 | "  `Adaboost`算法：\n", 51 | "\n", 52 | "  **输入**：训练数据集$T=\\{(x_{1}, y_{1}), (x_{2}, y_{2}), \\cdots, (x_{N}, y_{N})\\}$, 其中$x_{i} \\in X$, $y_{i} \\in Y = \\{-1, +1\\}$；\n", 53 | "\n", 54 | "  **输出**：最终分类器$G_{(x)}$。\n" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "id": "000c64d1", 60 | "metadata": {}, 61 | "source": [ 62 | "1. 初始化训练数据的权值分布：$D_{1}=(w_{11}, \\cdots, w_{1i}), \\ \\ w_{1i}=\\frac{1}{N}, \\ i=1,2,\\cdots, N$。\n", 63 | "2. 对不同的基分类器: $m=1,2,\\cdots, M$:\n", 64 | "\n", 65 | " (a) 使用具有权值分布$D_{m}$的训练数据集学习，得到基本分类器。$G_{m}(x):X\\rightarrow \\{-1, 1\\}$。\n", 66 | " \n", 67 | " (b)计算$G_{m}(x)$在训练数据集上的分类误差率(所有分错了的样本对应的权值加起来)。\n", 68 | " $$\n", 69 | " e_{m} = \\sum_{i=1}^{N} P(G_{m}(x_{i} \\neq y_{i})) = \\sum_{i=1}^{N} w_{mi} I(G_{m}(x_{i} \\neq y_{i}))\n", 70 | " $$\n", 71 | " \n", 72 | " (c)计算$G_{m}(x)$在训练数据集上的分类误差。\n", 73 | " $$\n", 74 | " \\alpha_{m} = \\frac{1}{2} log \\frac{1 - e_{m}}{e_{m}}\n", 75 | " $$\n", 76 | " (d)更新训练数据集的权值分布。\n", 77 | " $$\n", 78 | " D_{m+1}=(w_{m+1, 1}, \\cdots, w_{m+1, i}, \\cdots, w_{m+1, N})\n", 79 | " $$\n", 80 | " $$\n", 81 | " w_{m+1, i}=\\frac{w_{mi}}{Z_{m}}exp(-\\alpha_{m} y_{i} G_{m}(x_{i})), \\ \\ i=1,2,\\cdots, N\n", 82 | " $$\n", 83 | " 这里$Z_{m}$是规范化因子，它使$D_{m+1}$成为一个概率分布。$Z_{m}=\\sum_{i=1}^{N}w_{mi}exp(-\\alpha_{m}y_{i}G_{m}(x_{i}))$。" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "id": "a86bd084", 89 | "metadata": {}, 90 | "source": [ 91 | "3. 构建基本分类器的先行组合\n", 92 | "\n", 93 | "$$\n", 94 | "f(x) = \\sum_{m=1}^{M}\\alpha_{m}G_{m}(x)\n", 95 | "$$\n", 96 | "\n", 97 | "  得到最终分类器。\n", 98 | "\n", 99 | "$$\n", 100 | "G(x)=sign(f(x))\\\\\n", 101 | "= sign(\\sum_{m=1}^{M}\\alpha_{m}G_{m}(x))\n", 102 | "$$" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "id": "0d95fc0e", 108 | "metadata": {}, 109 | "source": [ 110 | "### 提升树(Boosting Tree)\n", 111 | "\n", 112 | "  提升树中的每一个分类器都属于分类树，或者回归树(基分类器是决策树)。`Adaboost`的基分类器就是一个二分类。提升树模型的基分类器是决策树。\n", 113 | "\n", 114 | "1. **提升树模型**：\n", 115 | "\n", 116 | "$$\n", 117 | "f_{M}(x)=\\sum_{m=1}^{M} T\\left(x, \\Theta_{m}\\right)\n", 118 | "$$\n", 119 | "\n", 120 | "  比如需要去预测37摄氏度，第一颗树预测出来的结果是15摄氏度，第二颗树需要预测的是$37-15=22$摄氏度。但是第二颗树也不能预测准确，依次做下去。\n", 121 | "\n", 122 | "2. **前向分步算法**：\n", 123 | "\n", 124 | "$$\n", 125 | "f_{m}(x)=f_{m-1}(x)+T\\left(x, \\Theta_{m}\\right)\n", 126 | "$$\n", 127 | "\n", 128 | "  在构建第$m$颗树的时候，前面$m-1$颗树固定不动。对决策树的参数$\\Theta$的确定采用经验风险最小化来确定：\n", 129 | "\n", 130 | "$$\n", 131 | "\\hat{\\Theta}=\\arg \\min _{\\Theta_{m}} \\sum_{i=1}^{N} L\\left(y_{i}, f_{m-1}(x)+T\\left(x_{i} ; \\Theta_{m}\\right)\\right)\n", 132 | "$$\n", 133 | "\n", 134 | "  它整体的过程是在不停地减小偏差。" 135 | ] 136 | }, 137 | { 138 | "cell_type": "markdown", 139 | "id": "945b573c", 140 | "metadata": {}, 141 | "source": [ 142 | "- 算法(**回归问题的提升树方法**)\n", 143 | "\n", 144 | "  输入：训练数据集$T=\\{(x_{1}, y_{1}), (x_{2}, y_{2}), \\cdots, (x_{N}, y_{N})\\}$。\n", 145 | "\n", 146 | "  输出：提升树$f_{M}(x)$。\n", 147 | "\n", 148 | "1. 初始化$f_{0}(x)=0$\n", 149 | "\n", 150 | "2. 对$m=1,2,\\cdots, M$\n", 151 | "\n", 152 | " (a) 计算残差：\n", 153 | " $$\n", 154 | " r_{mi}=y_{i}-f_{m-1}(x_{i}), \\ \\ i=1,2,\\cdots, N\n", 155 | " $$\n", 156 | " (b) 拟合残差$r_{mi}$学习一个回归树，得到$T(x;\\Theta)$\n", 157 | " \n", 158 | " (c) 更新$f_{m}(x)=f_{m-1}(x) + T(x;\\Theta)$\n", 159 | "3. 得到回归问题提升树\n", 160 | "\n", 161 | " $$\n", 162 | " f_{M}(x) = \\sum_{m=1}^{M}T(x;\\Theta)\n", 163 | " $$\n", 164 | "\n", 165 | " 至于拟合残差的原因：对于任意样本点$y$和拟合值$f(x)$的损失$L(y, f(x))=[y-f(x)]^{2}$。在前项分布算法中：\n", 166 | " $$\n", 167 | " f_{m}(x)=[y-f_{m-1}(x)-T(x;\\Theta_{m})]^{2}\\\\\n", 168 | " = [\\gamma_{m-1}-T(x;\\Theta_{m})]^{2}\\\\\n", 169 | " = L(\\gamma_{m-1}, T(x;\\Theta))\n", 170 | " $$" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "id": "2059992b", 176 | "metadata": {}, 177 | "source": [ 178 | "### GBDT" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "id": "41db3ec7", 184 | "metadata": {}, 185 | "source": [ 186 | "  对于梯度提升树其学习流程与提升树类似只是不再使用残差作为新的训练数据而是使用损失函数的梯度作为新的训练数据的$y$值，具体的来说就是使用损失函数对$f(x)$求梯度然后带入$f_{m-1}(x)$计算：\n", 187 | "\n", 188 | "- 算法(**梯度提升算法**)\n", 189 | "\n", 190 | "  输入：训练数据集$T=\\{(x_{1}, y_{1}), (x_{2}, y_{2}), \\cdots, (x_{N}, y_{N})\\}$。\n", 191 | "\n", 192 | "  输出：回归树$\\hat{f}(x)$。\n", 193 | "\n", 194 | "1. 初始化: 寻找一个常数$c$来使得$f(x)$最小：\n", 195 | "\n", 196 | "$$\n", 197 | "f_{0}(x) = arg\\min_{c} \\sum_{i=1}^{N} L(y_{i}, c)\n", 198 | "$$\n", 199 | "\n", 200 | "2. 对于$m=1,2,\\cdots, M$\n", 201 | "\n", 202 | " (a) 对$i=1,2,\\cdots, N$计算\n", 203 | " $$\n", 204 | " r_{mi}=-\\left[\\frac{\\partial L\\left(y_{i}, f\\left(x_{i}\\right)\\right)}{\\partial f\\left(x_{i}\\right)}\\right]_{f(x)=f_{m-1}(x)}\n", 205 | " $$\n", 206 | " (b) 对$r_{mi}$拟合一个回归树，得到第$m$颗树的叶节点区域$R_{mj}, j=1,2,\\cdots, J$。\n", 207 | " (c) 对$j=1,2,\\cdots, J$计算:\n", 208 | " $$\n", 209 | " c_{mj}=arg\\min_{c} \\sum_{x_{i} \\in R_{mj}} L(y_{i}, f_{m-1}(x_{i}) + c)\n", 210 | " $$\n", 211 | " (d) 更新$f_{m}(x)=f_{m-1}(x) + \\sum_{j=1}^{J}c_{mj}I(x \\in R_{mj})$。\n", 212 | "\n", 213 | "3. 得到回归树\n", 214 | "\n", 215 | "$$\n", 216 | "\\hat{f}(x) = f_{M}(x) = \\sum_{m=1}^{M}\\sum_{j=1}^{J} c_{mj}I(x \\in R_{mj})\n", 217 | "$$\n", 218 | "\n", 219 | "  在使用平方误差损失函数和指数损失函数时，提升树的残差求解比较简单，但是在使用一般的损失误差函数时，残差求解起来不是那么容易，所以就是用损失函数的负梯度在当前模型的值作为回归问题中残差的近似值。 " 220 | ] 221 | }, 222 | { 223 | "cell_type": "markdown", 224 | "id": "caabf84a", 225 | "metadata": {}, 226 | "source": [ 227 | "### XGB" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "id": "d559e4e9", 233 | "metadata": {}, 234 | "source": [ 235 | "### XGBoost\n", 236 | "\n", 237 | "梯度提升树。" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "id": "e3719c05", 243 | "metadata": {}, 244 | "source": [ 245 | "### LightBoost" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "id": "e4869ba6", 251 | "metadata": {}, 252 | "source": [ 253 | "## Bagging方法\n", 254 | "\n", 255 | "  直接训练多个并行的分类器。对于最后的结果，如果是分类问题就做一个投票，如果是一个回归问题就做一个加权平均。它可以显著减小方差。\n", 256 | "\n", 257 | "  整体模型的方差可以用公式表示：\n", 258 | "\n", 259 | "$$\n", 260 | "\\sigma^{2} = \\rho \\sigma^{2} + (1-\\rho)\\frac{\\sigma^{2}}{n}\n", 261 | "$$\n", 262 | "\n", 263 | "  因为每次是从数据集合中随机抽样，那么假设数据之间的相关性$\\rho=0$, 那么最后的方差则可以表示为$\\sigma^{2}= + \\frac{\\sigma^{2}}{n}$。\n", 264 | "\n", 265 | "  `Boosting`方法假设其强相关，那么$\\sigma^{2}= \\sigma^{2}$，并没有一个方差的显著降低。" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": null, 271 | "id": "fc03eb18", 272 | "metadata": {}, 273 | "outputs": [], 274 | "source": [] 275 | } 276 | ], 277 | "metadata": { 278 | "kernelspec": { 279 | "display_name": "Python 3", 280 | "language": "python", 281 | "name": "python3" 282 | }, 283 | "language_info": { 284 | "codemirror_mode": { 285 | "name": "ipython", 286 | "version": 3 287 | }, 288 | "file_extension": ".py", 289 | "mimetype": "text/x-python", 290 | "name": "python", 291 | "nbconvert_exporter": "python", 292 | "pygments_lexer": "ipython3", 293 | "version": "3.8.8" 294 | }, 295 | "toc": { 296 | "base_numbering": 1, 297 | "nav_menu": {}, 298 | "number_sections": true, 299 | "sideBar": true, 300 | "skip_h1_title": false, 301 | "title_cell": "Table of Contents", 302 | "title_sidebar": "Contents", 303 | "toc_cell": false, 304 | "toc_position": {}, 305 | "toc_section_display": true, 306 | "toc_window_display": true 307 | } 308 | }, 309 | "nbformat": 4, 310 | "nbformat_minor": 5 311 | } 312 | -------------------------------------------------------------------------------- /04-传统机器学习/09-聚类.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "be5f548b", 6 | "metadata": {}, 7 | "source": [ 8 | "## 聚类理论基础" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "a53fea23", 14 | "metadata": {}, 15 | "source": [ 16 | "### 聚类任务-整体介绍聚类算法" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "id": "17c6b02f", 22 | "metadata": {}, 23 | "source": [ 24 | "### 性能度量-衡量聚类的有效性" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "id": "b32f9e1c", 30 | "metadata": {}, 31 | "source": [ 32 | "### 距离计算" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "id": "d04dfd76", 38 | "metadata": {}, 39 | "source": [ 40 | "## 聚类方法" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "id": "9c9e5ee7", 46 | "metadata": {}, 47 | "source": [ 48 | "### 原型聚类" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "id": "0321d17f", 54 | "metadata": {}, 55 | "source": [ 56 | "1. kmeans\n", 57 | "2. 学习向量化\n", 58 | "3. 高斯混合聚类" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "id": "d895d372", 64 | "metadata": {}, 65 | "source": [ 66 | "### 密度聚类" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "id": "6745c86b", 72 | "metadata": {}, 73 | "source": [ 74 | "DBSCAN" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "id": "6d21d6d3", 80 | "metadata": {}, 81 | "source": [ 82 | "### 层次聚类" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "id": "bb7e753e", 88 | "metadata": {}, 89 | "source": [ 90 | "AGNES" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "id": "0e648611", 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | } 101 | ], 102 | "metadata": { 103 | "kernelspec": { 104 | "display_name": "Python 3", 105 | "language": "python", 106 | "name": "python3" 107 | }, 108 | "language_info": { 109 | "codemirror_mode": { 110 | "name": "ipython", 111 | "version": 3 112 | }, 113 | "file_extension": ".py", 114 | "mimetype": "text/x-python", 115 | "name": "python", 116 | "nbconvert_exporter": "python", 117 | "pygments_lexer": "ipython3", 118 | "version": "3.8.8" 119 | }, 120 | "toc": { 121 | "base_numbering": 1, 122 | "nav_menu": {}, 123 | "number_sections": true, 124 | "sideBar": true, 125 | "skip_h1_title": false, 126 | "title_cell": "Table of Contents", 127 | "title_sidebar": "Contents", 128 | "toc_cell": false, 129 | "toc_position": {}, 130 | "toc_section_display": true, 131 | "toc_window_display": true 132 | } 133 | }, 134 | "nbformat": 4, 135 | "nbformat_minor": 5 136 | } 137 | -------------------------------------------------------------------------------- /04-传统机器学习/11-特征选择与稀疏学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "5cc2d133", 6 | "metadata": {}, 7 | "source": [ 8 | "## 特征选择\n", 9 | "\n", 10 | "### 步骤\n", 11 | "\n", 12 | "1. 子集搜索->子集评价\n", 13 | "2. 过滤式(Relief)方法\n", 14 | "3. 包裹式(LVW)\n", 15 | "4. 嵌入式(L1正则化)\n", 16 | "\n", 17 | "### 方法\n", 18 | "\n", 19 | "## 稀疏学习\n", 20 | "\n", 21 | "### 稀疏表示与字典学习\n", 22 | "\n", 23 | "### 压缩感知" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "id": "1917131c", 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [] 33 | } 34 | ], 35 | "metadata": { 36 | "kernelspec": { 37 | "display_name": "Python 3", 38 | "language": "python", 39 | "name": "python3" 40 | }, 41 | "language_info": { 42 | "codemirror_mode": { 43 | "name": "ipython", 44 | "version": 3 45 | }, 46 | "file_extension": ".py", 47 | "mimetype": "text/x-python", 48 | "name": "python", 49 | "nbconvert_exporter": "python", 50 | "pygments_lexer": "ipython3", 51 | "version": "3.8.8" 52 | }, 53 | "toc": { 54 | "base_numbering": 1, 55 | "nav_menu": {}, 56 | "number_sections": true, 57 | "sideBar": true, 58 | "skip_h1_title": false, 59 | "title_cell": "Table of Contents", 60 | "title_sidebar": "Contents", 61 | "toc_cell": false, 62 | "toc_position": {}, 63 | "toc_section_display": true, 64 | "toc_window_display": true 65 | } 66 | }, 67 | "nbformat": 4, 68 | "nbformat_minor": 5 69 | } 70 | -------------------------------------------------------------------------------- /04-传统机器学习/12-计算学习理论.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "0db10d9c", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "ACG", 15 | "language": "python", 16 | "name": "acg" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.6.13" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /04-传统机器学习/13-半监督学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "9464e372", 6 | "metadata": {}, 7 | "source": [ 8 | "## 什么是半监督学习\n", 9 | "\n", 10 | "### 定义\n", 11 | "\n", 12 | "不依赖外界交互，自动利用未标记的样本。\n", 13 | "\n", 14 | "### 方法\n", 15 | "\n", 16 | "相似样本具有相似输出。\n", 17 | "\n", 18 | "### 分类\n", 19 | "\n", 20 | "纯半监督学习和直推学习。\n", 21 | "\n", 22 | "\n", 23 | "\n", 24 | "## 半监督的学习的方法\n", 25 | "\n", 26 | "### 生成式方法\n", 27 | "\n", 28 | "- 高斯混合模型\n", 29 | "\n", 30 | "### 半监督SVM\n", 31 | "\n", 32 | "### 图半监督学习\n", 33 | "\n", 34 | "\n", 35 | "### 基于分歧的方法\n", 36 | "\n", 37 | "\n", 38 | "### 半监督聚类" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": null, 44 | "id": "7c56954a", 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [] 48 | } 49 | ], 50 | "metadata": { 51 | "kernelspec": { 52 | "display_name": "Python 3", 53 | "language": "python", 54 | "name": "python3" 55 | }, 56 | "language_info": { 57 | "codemirror_mode": { 58 | "name": "ipython", 59 | "version": 3 60 | }, 61 | "file_extension": ".py", 62 | "mimetype": "text/x-python", 63 | "name": "python", 64 | "nbconvert_exporter": "python", 65 | "pygments_lexer": "ipython3", 66 | "version": "3.8.8" 67 | }, 68 | "toc": { 69 | "base_numbering": 1, 70 | "nav_menu": {}, 71 | "number_sections": true, 72 | "sideBar": true, 73 | "skip_h1_title": false, 74 | "title_cell": "Table of Contents", 75 | "title_sidebar": "Contents", 76 | "toc_cell": false, 77 | "toc_position": {}, 78 | "toc_section_display": true, 79 | "toc_window_display": true 80 | } 81 | }, 82 | "nbformat": 4, 83 | "nbformat_minor": 5 84 | } 85 | -------------------------------------------------------------------------------- /04-传统机器学习/14-概率图模型.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "7070369d", 6 | "metadata": {}, 7 | "source": [ 8 | "## 有向图\n", 9 | "\n", 10 | "### 隐马尔可夫模型\n", 11 | "\n", 12 | "## 无向图\n", 13 | "\n", 14 | "### 马尔可夫随机场\n", 15 | "\n", 16 | "### 条件随机场\n", 17 | "\n", 18 | "## 其他\n", 19 | "\n", 20 | "### 学习与推断\n", 21 | "\n", 22 | "### topic model" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "id": "39a1844e", 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [] 32 | } 33 | ], 34 | "metadata": { 35 | "kernelspec": { 36 | "display_name": "Python 3", 37 | "language": "python", 38 | "name": "python3" 39 | }, 40 | "language_info": { 41 | "codemirror_mode": { 42 | "name": "ipython", 43 | "version": 3 44 | }, 45 | "file_extension": ".py", 46 | "mimetype": "text/x-python", 47 | "name": "python", 48 | "nbconvert_exporter": "python", 49 | "pygments_lexer": "ipython3", 50 | "version": "3.8.8" 51 | }, 52 | "toc": { 53 | "base_numbering": 1, 54 | "nav_menu": {}, 55 | "number_sections": true, 56 | "sideBar": true, 57 | "skip_h1_title": false, 58 | "title_cell": "Table of Contents", 59 | "title_sidebar": "Contents", 60 | "toc_cell": false, 61 | "toc_position": {}, 62 | "toc_section_display": true, 63 | "toc_window_display": true 64 | } 65 | }, 66 | "nbformat": 4, 67 | "nbformat_minor": 5 68 | } 69 | -------------------------------------------------------------------------------- /04-传统机器学习/15-规则学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "249387a6", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "ACG", 15 | "language": "python", 16 | "name": "acg" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.6.13" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /04-传统机器学习/EM算法.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "b4ed0546", 6 | "metadata": {}, 7 | "source": [ 8 | "https://zhuanlan.zhihu.com/p/36331115" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "ed64d47e", 14 | "metadata": {}, 15 | "source": [ 16 | "  比如有两个高斯分布, 其均值和方差分别为：$\\mu_{1}, \\mu_{2},\\sigma_{1}, \\sigma_{2}$。它的数据混合起来了，得到了一个整体的分布，`EM`算法就是从混合的这个数据中获取$\\mu_{1}, \\mu_{2},\\sigma_{1}, \\sigma_{2}$。" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "id": "36cd18df", 22 | "metadata": {}, 23 | "source": [ 24 | "## EM算法" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "id": "470152bf", 30 | "metadata": {}, 31 | "source": [ 32 | "- **三硬币模型**\n", 33 | "\n", 34 | "  有三枚硬币$A, B, C$, 它们抛出正面的概率分别是:$\\pi, p, q$。$A$抛出正面的话，之后就去抛$B$，$A$抛出反面的话，之后就去抛$C$。如何依据观测到的数据，比如硬币的正反序列，反推$\\pi, p, q$呢？于此相对的，这里还有一个不可观测数据，或者称之为隐变量$z$, 它表示$A$的结果。\n", 35 | "\n", 36 | "  比如说看到一个最终结果是正面，这个正面我们并不知道是由$A$抛出正面继而让$B$产生正面得到的，还是$A$抛出反面继而让$C$产生得到的。这个事情就叫做隐变量。" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "id": "68f0b53a", 42 | "metadata": {}, 43 | "source": [ 44 | "  随机变量$z$(观测不到的数据)满足概率分布：$z \\sim b(1, \\pi)$。则依据隐变量产生的数据可以表示为：$(z_{1}, y_{1})(z_{2}, y_{2}),\\cdots, (z_{N}, y_{N})$。\n", 45 | "\n", 46 | "1. $z_{1}=1, y_{1} \\sim b(1, p)$;\n", 47 | "2. $z_{1}=0, y_{1} \\sim b(1, q)$。" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "id": "6891b922", 53 | "metadata": {}, 54 | "source": [ 55 | "$$\n", 56 | "\\prod_{i=1}^{N} p(y_{i} | \\theta) = \\prod_{i=1}^{N}[\\sum_{Z}p(y_{i}, z|\\theta)] = \\prod_{i=1}^{N}[\\pi p^{y_{i}}(1-p)^{1-y_{i}} + (1-\\pi)q^{y_{i}}(1-q)^{1-y_{i}}]\n", 57 | "$$\n", 58 | "\n", 59 | "  上述公示由于是连乘，在计算机语言中，可能会造成下溢出。所以我们一般将其取个$ln$。\n", 60 | "\n", 61 | "$$\n", 62 | "p(y,z|\\theta) = max(ln\\prod_{i=1}^{N}p(y_{i},z_{i}|\\theta))\n", 63 | "$$\n", 64 | "\n", 65 | "  上述公示中由于存在隐变量，所以没办法用之前的求极大似然的方法对其进行直接计算。" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "id": "3ef5cf03", 71 | "metadata": {}, 72 | "source": [ 73 | "### EM算法的引入\n", 74 | "\n", 75 | "- **EM算法**\n", 76 | "\n", 77 | "输入：观测变量数据$Y$, 隐变量数据$Z$, 联合分布$P(Y,Z|\\theta)$, 条件分布$P(Z|Y, \\theta)$。\n", 78 | "\n", 79 | "输出：模型参数$\\theta$ (三币问题中就是$\\pi, p, q$)。\n", 80 | "\n", 81 | "(1) 选择参数的初值$\\theta^{0}$, 开始迭代；\n", 82 | "\n", 83 | "(2) $E$步：记$\\theta^{i}$为第$i$次迭代参数$\\theta$的估计值，在第$i+1$次迭代的$E$步，计算：\n", 84 | "\n", 85 | "$$\n", 86 | "Q(\\theta, \\theta^{i}) = E_{Z}[logP(Y,Z|\\theta) | Y, \\theta^{i}]\n", 87 | "$$\n", 88 | "\n", 89 | "(3) $M$步：求使$Q(\\theta, \\theta^{i})$极大化的$\\theta$, 确定第$i+1$次迭代的参数估计值$\\theta^{(i+1)}$。\n", 90 | "\n", 91 | "$$\n", 92 | "\\theta^{(i+1)} = arg\\max_{\\theta}Q(\\theta, \\theta^{(i)})\n", 93 | "$$\n", 94 | "\n", 95 | "(4) 重复第(2)步和第(3)步，直到收敛。" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "id": "9afa7ff1", 101 | "metadata": {}, 102 | "source": [ 103 | "### EM算法的导出" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "id": "7f760643", 109 | "metadata": {}, 110 | "source": [ 111 | "  我们是期望依据观测样本使得整个数据产生的概率最大：\n", 112 | "\n", 113 | "$$\n", 114 | "L(\\theta)=\\ln P(Y \\mid \\theta)=\\ln \\sum_{z} P(Y, Z \\mid \\theta)=\\ln \\left(\\sum_{Z} P(Z \\mid \\theta) P(Y \\mid Z, \\theta)\\right)\n", 115 | "$$" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "id": "5dac79e4", 121 | "metadata": {}, 122 | "source": [ 123 | "  如何来计算呢？我们让每次迭代更新之后，它的值都会变大就好：\n", 124 | "\n", 125 | "$$\n", 126 | "\\begin{aligned}\n", 127 | "L(\\theta)-L\\left(\\theta^{(i)}\\right) &=\\ln \\left(\\sum_{z} P(Z \\mid \\theta) P(Y \\mid Z, \\theta)\\right)-\\ln P\\left(Y \\mid \\theta^{(i)}\\right) \\\\\n", 128 | "&=\\ln \\left(\\sum_{z} P\\left(Z \\mid Y, \\theta^{(i)}\\right) \\frac{P(Z \\mid \\theta) P(Y \\mid Z, \\theta)}{P\\left(Z \\mid Y, \\theta^{(i)}\\right)}\\right)-\\ln P\\left(Y \\mid \\theta^{(i)}\\right) \\\\\n", 129 | "& \\geq \\sum_{Z} P\\left(Z \\mid Y, \\theta^{(i)}\\right) \\ln \\left(\\frac{P(Z \\mid \\theta) P(Y \\mid Z, \\theta)}{P\\left(Z \\mid Y, \\theta^{(i)}\\right)}\\right)-\\sum_{z} P\\left(Z \\mid Y, \\theta^{(i)}\\right) \\ln P\\left(Y \\mid \\theta^{(i)}\\right) \\\\\n", 130 | "&=\\sum_{Z} P\\left(Z \\mid Y, \\theta^{(i)}\\right) \\ln \\left(\\frac{P(Z \\mid \\theta) P(Y \\mid Z, \\theta)}{P\\left(Z \\mid Y, \\theta^{(i)}\\right) P\\left(Y \\mid \\theta^{(i)}\\right)}\\right)\n", 131 | "\\end{aligned}\n", 132 | "$$\n", 133 | "\n", 134 | "  上述公式的不等式推倒用到了`Jensen`不等式，定义如下：如果$f$是凸函数，$X$是随机变量，那么：$E[f(X)] \\geq f(E[X])$。当且仅当$X$是常量时，该式取等号。其中，$E(X)$表示$X$的数学期望。$ln$为凹函数。\n", 135 | "\n", 136 | "  我们是期望下面这个式子越大越好：\n", 137 | "\n", 138 | "$$\n", 139 | "L(\\theta)-L\\left(\\theta^{(i)}\\right) = \\sum_{Z} P\\left(Z \\mid Y, \\theta^{(i)}\\right) \\ln \\left(\\frac{P(Z \\mid \\theta) P(Y \\mid Z, \\theta)}{P\\left(Z \\mid Y, \\theta^{(i)}\\right) P\\left(Y \\mid \\theta^{(i)}\\right)}\\right)\n", 140 | "$$\n", 141 | "\n", 142 | "  但是上述式子中$\\theta^{(i)}$是固定不动的，我们需要调整的是$\\theta$。\n", 143 | "\n", 144 | "$$\n", 145 | "L(\\theta)-L\\left(\\theta^{(i)}\\right) = \\sum_{Z} P\\left(Z \\mid Y, \\theta^{(i)}\\right) \\ln \\left(P(Z \\mid \\theta) P(Y \\mid Z, \\theta)\\right) = B(\\theta, \\theta^{(i)})\n", 146 | "$$\n", 147 | "\n", 148 | "  求解: \n", 149 | "\n", 150 | "$$\n", 151 | "\\begin{aligned}\n", 152 | "\\theta^{(i+1)} &=\\operatorname{argmax}_{\\theta} B\\left(\\theta, \\theta^{(i)}\\right) \\\\\n", 153 | "&=\\operatorname{argmax}_{\\theta} \\sum_{Z} P\\left(Z \\mid Y, \\theta^{(i)}\\right)(\\ln P(Z \\mid \\theta) P(Y \\mid Z, \\theta)) \\\\\n", 154 | "&=\\operatorname{argmax}_{\\theta} \\sum_{Z} P\\left(Z \\mid Y, \\theta^{(i)}\\right)(\\ln P(Y, Z \\mid \\theta)) \\\\\n", 155 | "&=\\operatorname{argmax}_{\\theta} Q\\left(\\theta, \\theta^{(i)}\\right)\n", 156 | "\\end{aligned}\n", 157 | "$$" 158 | ] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "id": "f82c169c", 163 | "metadata": {}, 164 | "source": [ 165 | "- 小结\n", 166 | "\n", 167 | "1. `EM`算法通过迭代逐步近似极大化$L$;\n", 168 | "2. 为了每次都能够极大化$L$, 需保证每个步骤中$L(\\theta)-L(\\theta^{(i)})$大于0。\n", 169 | "3. 通过找到当前$L(\\theta)-L(\\theta^{(i)})$的下界，不断提高该下界。" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "id": "c477e43c", 175 | "metadata": {}, 176 | "source": [ 177 | "### EM算法收敛性证明" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "id": "513a7525", 183 | "metadata": {}, 184 | "source": [] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "id": "51ce529e", 189 | "metadata": {}, 190 | "source": [ 191 | "## 高斯混合模型" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "id": "c5f72517", 197 | "metadata": {}, 198 | "source": [ 199 | "## EM算法的推广" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "id": "a5cb5de2", 205 | "metadata": {}, 206 | "source": [ 207 | "### F函数的极大-极大算法" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "id": "b7a39f73", 213 | "metadata": {}, 214 | "source": [ 215 | "### GEM算法" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": null, 221 | "id": "4212ffe5", 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [] 225 | } 226 | ], 227 | "metadata": { 228 | "kernelspec": { 229 | "display_name": "ACG", 230 | "language": "python", 231 | "name": "acg" 232 | }, 233 | "language_info": { 234 | "codemirror_mode": { 235 | "name": "ipython", 236 | "version": 3 237 | }, 238 | "file_extension": ".py", 239 | "mimetype": "text/x-python", 240 | "name": "python", 241 | "nbconvert_exporter": "python", 242 | "pygments_lexer": "ipython3", 243 | "version": "3.6.13" 244 | }, 245 | "toc": { 246 | "base_numbering": 1, 247 | "nav_menu": {}, 248 | "number_sections": true, 249 | "sideBar": true, 250 | "skip_h1_title": false, 251 | "title_cell": "Table of Contents", 252 | "title_sidebar": "Contents", 253 | "toc_cell": false, 254 | "toc_position": {}, 255 | "toc_section_display": true, 256 | "toc_window_display": false 257 | } 258 | }, 259 | "nbformat": 4, 260 | "nbformat_minor": 5 261 | } 262 | -------------------------------------------------------------------------------- /04-传统机器学习/PCA.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "bf9ef79d", 6 | "metadata": {}, 7 | "source": [ 8 | "## 基础知识\n", 9 | "\n", 10 | "研究泛化误差和经验误差之间的逼近程度。\n", 11 | "\n", 12 | "\n", 13 | "## PAC可学习\n", 14 | "\n", 15 | "以较大概率预测到满足预测误差上限的模型。\n", 16 | "\n", 17 | "\n", 18 | "## 量化假设空间的复杂度的方法\n", 19 | "\n", 20 | "- VC维\n", 21 | "\n", 22 | "- Rademacher复杂度\n", 23 | "\n", 24 | "## 稳定性\n", 25 | "\n", 26 | "根据具体的算法计算对应的学习问题的衡量" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "id": "dffc92c4", 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [] 36 | } 37 | ], 38 | "metadata": { 39 | "kernelspec": { 40 | "display_name": "Python 3", 41 | "language": "python", 42 | "name": "python3" 43 | }, 44 | "language_info": { 45 | "codemirror_mode": { 46 | "name": "ipython", 47 | "version": 3 48 | }, 49 | "file_extension": ".py", 50 | "mimetype": "text/x-python", 51 | "name": "python", 52 | "nbconvert_exporter": "python", 53 | "pygments_lexer": "ipython3", 54 | "version": "3.8.8" 55 | }, 56 | "toc": { 57 | "base_numbering": 1, 58 | "nav_menu": {}, 59 | "number_sections": true, 60 | "sideBar": true, 61 | "skip_h1_title": false, 62 | "title_cell": "Table of Contents", 63 | "title_sidebar": "Contents", 64 | "toc_cell": false, 65 | "toc_position": {}, 66 | "toc_section_display": true, 67 | "toc_window_display": true 68 | } 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 5 72 | } 73 | -------------------------------------------------------------------------------- /07-深度学习/01-深度学习基础/08-模型选择+过拟合和欠拟合.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "3d8866e4", 6 | "metadata": {}, 7 | "source": [ 8 | "## 模型选择" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "58207585", 14 | "metadata": {}, 15 | "source": [ 16 | "在机器学习中，我们通常在评估几个候选模型后选择最终的模型。这个过程叫做模型选择。有时，需要进行比较的模型在本质上是完全不同的（比如，决策树与线性模型）。又有时，我们需要比较不同的超参数设置下的同一类模型。\n", 17 | "\n", 18 | "例如，训练多层感知机模型时，我们可能希望比较具有不同数量的隐藏层、不同数量的隐藏单元以及不同的的激活函数组合的模型。为了确定候选模型中的最佳模型，我们通常会使用验证集。" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "id": "1022a2b8", 24 | "metadata": {}, 25 | "source": [ 26 | "### 𝐾折交叉验证" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "id": "24622ee3", 32 | "metadata": {}, 33 | "source": [ 34 | "当训练数据稀缺时，我们甚至可能无法提供足够的数据来构成一个合适的验证集。这个问题的一个流行的解决方案是采用 𝐾 折交叉验证。这里，原始训练数据被分成 𝐾 个不重叠的子集。然后执行 𝐾 次模型训练和验证，每次在 𝐾−1 个子集上进行训练，并在剩余的一个子集（在该轮中没有用于训练的子集）上进行验证。最后，通过对 𝐾 次实验的结果取平均来估计训练和验证误差。" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "d96d64ca", 40 | "metadata": {}, 41 | "source": [] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "id": "0bf9d6ab", 46 | "metadata": {}, 47 | "source": [] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "id": "5bd7e423", 52 | "metadata": {}, 53 | "source": [] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "id": "81b664f9", 58 | "metadata": {}, 59 | "source": [] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "id": "6603f56a", 64 | "metadata": {}, 65 | "source": [] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "id": "78898898", 70 | "metadata": {}, 71 | "source": [] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "id": "27ba76a3", 76 | "metadata": {}, 77 | "source": [] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "id": "a6279b8d", 82 | "metadata": {}, 83 | "source": [ 84 | "## 代码" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "id": "c4623bdc", 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "id": "c09a6ab5", 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [] 102 | } 103 | ], 104 | "metadata": { 105 | "kernelspec": { 106 | "display_name": "Python 3 (ipykernel)", 107 | "language": "python", 108 | "name": "python3" 109 | }, 110 | "language_info": { 111 | "codemirror_mode": { 112 | "name": "ipython", 113 | "version": 3 114 | }, 115 | "file_extension": ".py", 116 | "mimetype": "text/x-python", 117 | "name": "python", 118 | "nbconvert_exporter": "python", 119 | "pygments_lexer": "ipython3", 120 | "version": "3.9.4" 121 | }, 122 | "toc": { 123 | "base_numbering": 1, 124 | "nav_menu": {}, 125 | "number_sections": true, 126 | "sideBar": true, 127 | "skip_h1_title": false, 128 | "title_cell": "Table of Contents", 129 | "title_sidebar": "Contents", 130 | "toc_cell": false, 131 | "toc_position": {}, 132 | "toc_section_display": true, 133 | "toc_window_display": true 134 | } 135 | }, 136 | "nbformat": 4, 137 | "nbformat_minor": 5 138 | } 139 | -------------------------------------------------------------------------------- /07-深度学习/02-卷积神经网络/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/07-深度学习/02-卷积神经网络/.DS_Store -------------------------------------------------------------------------------- /07-深度学习/02-卷积神经网络/.ipynb_checkpoints/02-卷积操作在PyTorch中实现与使用-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "ad2059c8", 6 | "metadata": {}, 7 | "source": [ 8 | "## CONV2D\n", 9 | "\n", 10 | "`PyTorch`中二维卷积的`PyTorch`官网地址为[CONV2D](https://pytorch.org/docs/master/generated/torch.nn.Conv2d.html#torch.nn.Conv2d)\n", 11 | "\n", 12 | "```python\n", 13 | "torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)\n", 14 | "```" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "7cf13857", 20 | "metadata": {}, 21 | "source": [ 22 | "参数理解：\n", 23 | "\n", 24 | "1. in_channels : 输入图片的通道数。\n", 25 | "2. out_channels : 做完卷积之后，输出的通道数。\n", 26 | "3. kernel_size : 卷积核的大小，可以是一个整数或者是一个元组，如果是一个整数，那么`kernel_size`就是一个正方形。\n", 27 | "4. stride : 步长，滑动卷积窗口的步长。\n", 28 | "5. padding : 填充，一般选择：{‘valid’, ‘same’}。‘valid’不做padding操作。\n", 29 | "6. dilation : 空洞，\n", 30 | "7. groups : 把通道分为好几组，需要被in_channels和out_channels整除。会把输入通道和输出通道同时分为很多组做卷积，这样做的好处在于，并没有把通道做一个完全的mix，比如有8个通道，分为2组，也就是前面4个通道为一组，后面4个通道为1组。groups大于1的计算量是要比groups等于1的计算量小一点的。\n", 31 | "8. bias : 输出的每个通道是否加bias。\n", 32 | "9. padding_mode : padding的值默认都为0。\n", 33 | "10. device : \n", 34 | "11. dtype : " 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "4941cf9e", 40 | "metadata": {}, 41 | "source": [ 42 | "在其源码中，其是继承自`_ConvNd`，本质是调用`F.conv2d()`函数实现。" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "id": "c87a2a49", 48 | "metadata": {}, 49 | "source": [ 50 | "## Conv2d调用示例" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "id": "f2cb1dee", 56 | "metadata": {}, 57 | "source": [ 58 | "定义一个卷积层：输入通道是`2`，输出通道是`2`，卷积核大小是`3 x 3`的，padding选择为same" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 1, 64 | "id": "102cccd8", 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "import torch.nn as nn\n", 69 | "conv_layer = nn.Conv2d(2, 2, 3, padding=\"same\")" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "id": "6a1039a9", 75 | "metadata": {}, 76 | "source": [ 77 | "打印`conv_layer`层的参数：" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 4, 83 | "id": "8d4d75c6", 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "name": "stdout", 88 | "output_type": "stream", 89 | "text": [ 90 | "('weight', Parameter containing:\n", 91 | "tensor([[[[-0.1107, -0.1877, -0.1124],\n", 92 | " [-0.0339, -0.0805, 0.0609],\n", 93 | " [ 0.1046, -0.1687, -0.1202]],\n", 94 | "\n", 95 | " [[-0.1517, -0.0760, 0.1202],\n", 96 | " [-0.2310, 0.2295, -0.1341],\n", 97 | " [-0.0842, 0.0501, -0.0899]]],\n", 98 | "\n", 99 | "\n", 100 | " [[[ 0.2317, 0.2311, 0.0098],\n", 101 | " [-0.1075, -0.1141, -0.0069],\n", 102 | " [ 0.1095, -0.1667, -0.0108]],\n", 103 | "\n", 104 | " [[-0.0392, -0.1846, 0.0636],\n", 105 | " [-0.1200, 0.0341, 0.1114],\n", 106 | " [-0.0710, 0.0413, 0.1739]]]], requires_grad=True))\n", 107 | "('bias', Parameter containing:\n", 108 | "tensor([0.0031, 0.2097], requires_grad=True))\n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "for i in conv_layer.named_parameters():\n", 114 | " print(i)" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "id": "b385a638", 120 | "metadata": {}, 121 | "source": [ 122 | "可以看到卷积层中有两个参数：weight和bias。weight的大小应该是[2, 2, 3, 3], 3x3代表的是卷积核的那个核的参数，第一个2是输出通道，对于输入的任意一个通道都有一个核去卷积，再求和，就得到输出的第一个通道特征值，有两个输出通道就是两个。第2个是输入通道有两个，一个通道上有一个卷积核，两个就是两个3 x 3的卷积核。" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 5, 128 | "id": "861dbce1", 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "data": { 133 | "text/plain": [ 134 | "torch.Size([2, 2, 3, 3])" 135 | ] 136 | }, 137 | "execution_count": 5, 138 | "metadata": {}, 139 | "output_type": "execute_result" 140 | } 141 | ], 142 | "source": [ 143 | "conv_layer.weight.size()" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 6, 149 | "id": "638c9547", 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "text/plain": [ 155 | "torch.Size([2])" 156 | ] 157 | }, 158 | "execution_count": 6, 159 | "metadata": {}, 160 | "output_type": "execute_result" 161 | } 162 | ], 163 | "source": [ 164 | "conv_layer.bias.size()" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": null, 170 | "id": "9d543dc6", 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [] 174 | } 175 | ], 176 | "metadata": { 177 | "kernelspec": { 178 | "display_name": "Python 3 (ipykernel)", 179 | "language": "python", 180 | "name": "python3" 181 | }, 182 | "language_info": { 183 | "codemirror_mode": { 184 | "name": "ipython", 185 | "version": 3 186 | }, 187 | "file_extension": ".py", 188 | "mimetype": "text/x-python", 189 | "name": "python", 190 | "nbconvert_exporter": "python", 191 | "pygments_lexer": "ipython3", 192 | "version": "3.9.4" 193 | }, 194 | "toc": { 195 | "base_numbering": 1, 196 | "nav_menu": {}, 197 | "number_sections": true, 198 | "sideBar": true, 199 | "skip_h1_title": false, 200 | "title_cell": "Table of Contents", 201 | "title_sidebar": "Contents", 202 | "toc_cell": false, 203 | "toc_position": {}, 204 | "toc_section_display": true, 205 | "toc_window_display": true 206 | } 207 | }, 208 | "nbformat": 4, 209 | "nbformat_minor": 5 210 | } 211 | -------------------------------------------------------------------------------- /07-深度学习/02-卷积神经网络/02-卷积操作在PyTorch中实现与使用.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "ad2059c8", 6 | "metadata": {}, 7 | "source": [ 8 | "## CONV2D\n", 9 | "\n", 10 | "`PyTorch`中二维卷积的`PyTorch`官网地址为[CONV2D](https://pytorch.org/docs/master/generated/torch.nn.Conv2d.html#torch.nn.Conv2d)\n", 11 | "\n", 12 | "```python\n", 13 | "torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)\n", 14 | "```" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "7cf13857", 20 | "metadata": {}, 21 | "source": [ 22 | "参数理解：\n", 23 | "\n", 24 | "1. in_channels : 输入图片的通道数。\n", 25 | "2. out_channels : 做完卷积之后，输出的通道数。\n", 26 | "3. kernel_size : 卷积核的大小，可以是一个整数或者是一个元组，如果是一个整数，那么`kernel_size`就是一个正方形。\n", 27 | "4. stride : 步长，滑动卷积窗口的步长。\n", 28 | "5. padding : 填充，一般选择：{‘valid’, ‘same’}。‘valid’不做padding操作。\n", 29 | "6. dilation : 空洞，\n", 30 | "7. groups : 把通道分为好几组，需要被in_channels和out_channels整除。会把输入通道和输出通道同时分为很多组做卷积，这样做的好处在于，并没有把通道做一个完全的mix，比如有8个通道，分为2组，也就是前面4个通道为一组，后面4个通道为1组。groups大于1的计算量是要比groups等于1的计算量小一点的。\n", 31 | "8. bias : 输出的每个通道是否加bias。\n", 32 | "9. padding_mode : padding的值默认都为0。\n", 33 | "10. device : \n", 34 | "11. dtype : " 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "4941cf9e", 40 | "metadata": {}, 41 | "source": [ 42 | "在其源码中，其是继承自`_ConvNd`，本质是调用`F.conv2d()`函数实现。" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "id": "c87a2a49", 48 | "metadata": {}, 49 | "source": [ 50 | "## Conv2d调用示例" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "id": "f2cb1dee", 56 | "metadata": {}, 57 | "source": [ 58 | "定义一个卷积层：输入通道是`2`，输出通道是`2`，卷积核大小是`3 x 3`的，padding选择为same" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 1, 64 | "id": "102cccd8", 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "import torch.nn as nn\n", 69 | "conv_layer = nn.Conv2d(2, 2, 3, padding=\"same\")" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "id": "6a1039a9", 75 | "metadata": {}, 76 | "source": [ 77 | "打印`conv_layer`层的参数：" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 4, 83 | "id": "8d4d75c6", 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "name": "stdout", 88 | "output_type": "stream", 89 | "text": [ 90 | "('weight', Parameter containing:\n", 91 | "tensor([[[[-0.1107, -0.1877, -0.1124],\n", 92 | " [-0.0339, -0.0805, 0.0609],\n", 93 | " [ 0.1046, -0.1687, -0.1202]],\n", 94 | "\n", 95 | " [[-0.1517, -0.0760, 0.1202],\n", 96 | " [-0.2310, 0.2295, -0.1341],\n", 97 | " [-0.0842, 0.0501, -0.0899]]],\n", 98 | "\n", 99 | "\n", 100 | " [[[ 0.2317, 0.2311, 0.0098],\n", 101 | " [-0.1075, -0.1141, -0.0069],\n", 102 | " [ 0.1095, -0.1667, -0.0108]],\n", 103 | "\n", 104 | " [[-0.0392, -0.1846, 0.0636],\n", 105 | " [-0.1200, 0.0341, 0.1114],\n", 106 | " [-0.0710, 0.0413, 0.1739]]]], requires_grad=True))\n", 107 | "('bias', Parameter containing:\n", 108 | "tensor([0.0031, 0.2097], requires_grad=True))\n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "for i in conv_layer.named_parameters():\n", 114 | " print(i)" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "id": "b385a638", 120 | "metadata": {}, 121 | "source": [ 122 | "可以看到卷积层中有两个参数：weight和bias。weight的大小应该是[2, 2, 3, 3], 3x3代表的是卷积核的那个核的参数，第一个2是输出通道，对于输入的任意一个通道都有一个核去卷积，再求和，就得到输出的第一个通道特征值，有两个输出通道就是两个。第2个是输入通道有两个，一个通道上有一个卷积核，两个就是两个3 x 3的卷积核。" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 5, 128 | "id": "861dbce1", 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "data": { 133 | "text/plain": [ 134 | "torch.Size([2, 2, 3, 3])" 135 | ] 136 | }, 137 | "execution_count": 5, 138 | "metadata": {}, 139 | "output_type": "execute_result" 140 | } 141 | ], 142 | "source": [ 143 | "conv_layer.weight.size()" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 6, 149 | "id": "638c9547", 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "text/plain": [ 155 | "torch.Size([2])" 156 | ] 157 | }, 158 | "execution_count": 6, 159 | "metadata": {}, 160 | "output_type": "execute_result" 161 | } 162 | ], 163 | "source": [ 164 | "conv_layer.bias.size()" 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "id": "15cf4422", 170 | "metadata": {}, 171 | "source": [ 172 | "所以卷积权重张量维度其实是[输出通道数，输入通道数，高，宽]，输入的第一个维度是一个batch size，卷积网络的调用示例如下：" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 2, 178 | "id": "9838f5bf", 179 | "metadata": {}, 180 | "outputs": [ 181 | { 182 | "name": "stdout", 183 | "output_type": "stream", 184 | "text": [ 185 | "tensor([[[[-0.6392, 0.4568],\n", 186 | " [ 0.1312, -0.1756]]]], grad_fn=)\n" 187 | ] 188 | } 189 | ], 190 | "source": [ 191 | "import torch\n", 192 | "import torch.nn as nn\n", 193 | "import torch.nn.functional as F\n", 194 | "\n", 195 | "in_channels = 1\n", 196 | "out_channels = 1\n", 197 | "kernel_size = 3\n", 198 | "batch_size = 1\n", 199 | "bias = False\n", 200 | "input_size = [batch_size, in_channels, 4, 4]\n", 201 | "\n", 202 | "conv_layer = nn.Conv2d(in_channels, out_channels, kernel_size, bias=bias)\n", 203 | "input_feature_map = torch.randn(input_size)\n", 204 | "output_feature_map = conv_layer(input_feature_map)\n", 205 | "\n", 206 | "print(output_feature_map)" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "id": "07f43323", 212 | "metadata": {}, 213 | "source": [ 214 | "而上述nn.Conv2d调用卷积的方法和F.conv2d调用的方式是一样的：" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 3, 220 | "id": "850f2d73", 221 | "metadata": {}, 222 | "outputs": [ 223 | { 224 | "name": "stdout", 225 | "output_type": "stream", 226 | "text": [ 227 | "tensor([[[[-0.6392, 0.4568],\n", 228 | " [ 0.1312, -0.1756]]]], grad_fn=)\n" 229 | ] 230 | } 231 | ], 232 | "source": [ 233 | "output_feature_map1 = F.conv2d(input_feature_map, conv_layer.weight)\n", 234 | "print(output_feature_map1)" 235 | ] 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "id": "1a6aa90f", 240 | "metadata": {}, 241 | "source": [ 242 | "可以看到其输出结果是一样的。" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "id": "3993ebab", 249 | "metadata": {}, 250 | "outputs": [], 251 | "source": [] 252 | } 253 | ], 254 | "metadata": { 255 | "kernelspec": { 256 | "display_name": "Python 3 (ipykernel)", 257 | "language": "python", 258 | "name": "python3" 259 | }, 260 | "language_info": { 261 | "codemirror_mode": { 262 | "name": "ipython", 263 | "version": 3 264 | }, 265 | "file_extension": ".py", 266 | "mimetype": "text/x-python", 267 | "name": "python", 268 | "nbconvert_exporter": "python", 269 | "pygments_lexer": "ipython3", 270 | "version": "3.9.4" 271 | }, 272 | "toc": { 273 | "base_numbering": 1, 274 | "nav_menu": {}, 275 | "number_sections": true, 276 | "sideBar": true, 277 | "skip_h1_title": false, 278 | "title_cell": "Table of Contents", 279 | "title_sidebar": "Contents", 280 | "toc_cell": false, 281 | "toc_position": {}, 282 | "toc_section_display": true, 283 | "toc_window_display": true 284 | } 285 | }, 286 | "nbformat": 4, 287 | "nbformat_minor": 5 288 | } 289 | -------------------------------------------------------------------------------- /07-深度学习/03-循环神经网络/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/07-深度学习/03-循环神经网络/.DS_Store -------------------------------------------------------------------------------- /07-深度学习/04-Transformer/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/07-深度学习/04-Transformer/.DS_Store -------------------------------------------------------------------------------- /07-深度学习/04-Transformer/.ipynb_checkpoints/04-Vision-Transformer原理及实现-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /07-深度学习/04-Transformer/.ipynb_checkpoints/指针网络-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "2a321625", 6 | "metadata": {}, 7 | "source": [ 8 | "https://github.com/ccjjxx99/PointerNetworks-pytorch-tsp\n", 9 | "\n", 10 | "https://github.com/aurelienbibaut/Actor_CriticPointer_Network-TSP\n", 11 | "\n", 12 | "https://github.com/zifeiyu0531/PointerNetwork-RL-TSP\n", 13 | "\n", 14 | "https://colab.research.google.com/drive/1lobspU9b7dTO_HuoX-3nibZspTwfa5aX?usp=sharing#scrollTo=UMntU4jUu_v1" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "887188d0", 20 | "metadata": {}, 21 | "source": [ 22 | "## 指针网络" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "id": "53a738fb", 28 | "metadata": {}, 29 | "source": [ 30 | "`RNN`的输入和输出长度是被限制成一样的了，`seq2seq`的方式通过`RNN`编码和另外一个`RNN`解码的方式能够解除掉这个限制，典型的就是注意力机制`Transformer`网络。但是还是存在一个问题：不能够解决输出字典长度不固定的问题，比如英语单词字典就定`n=8000`个单词，那么`RNN`一个时间步的输出就是一个长度为`8000`的向量，是定死的，这类问题对于处理文本类的问题是没有问题的，但是对于一些特定问题，比如组合优化问题\n", 31 | "\n", 32 | "如果这个长度也是改变的那怎么办呢？指针网络提出了一种能够解决上述问题的网络结构：\n", 33 | "\n", 34 | "" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "98d59d02", 40 | "metadata": {}, 41 | "source": [ 42 | "https://github.com/ast0414/pointer-networks-pytorch：解决整数排序问题\n", 43 | " I expand upon earlier work by solving the planar convex hull problem and replace the LSTM-based encoder and decoder with transformers." 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "id": "3cbf0570", 49 | "metadata": {}, 50 | "source": [ 51 | "`pointer network`的核心公示如下：\n", 52 | "\n", 53 | "$$\n", 54 | "u_{j}^{i} = v^{T}tanh(W_{1}e_{j} + W_{2}d_{i}) j \\in (1, \\cdots, n)\n", 55 | "$$\n", 56 | "\n", 57 | "$$\n", 58 | "p(C_{i}|C_{1},\\cdots,C_{i-1}, P) = softmax(u^{i})\n", 59 | "$$\n", 60 | "\n", 61 | "它由两个可学习的权重$W_{1}$和$W_{2}$与编码、解码网络的输出相乘。之后再经过一个非线性变换与另一个学习权重$v$相乘。" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "id": "ea89a7f2", 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": null, 75 | "id": "b61a2d53", 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "id": "9e2ff213", 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [] 87 | } 88 | ], 89 | "metadata": { 90 | "kernelspec": { 91 | "display_name": "Python 3 (ipykernel)", 92 | "language": "python", 93 | "name": "python3" 94 | }, 95 | "language_info": { 96 | "codemirror_mode": { 97 | "name": "ipython", 98 | "version": 3 99 | }, 100 | "file_extension": ".py", 101 | "mimetype": "text/x-python", 102 | "name": "python", 103 | "nbconvert_exporter": "python", 104 | "pygments_lexer": "ipython3", 105 | "version": "3.9.4" 106 | }, 107 | "toc": { 108 | "base_numbering": 1, 109 | "nav_menu": {}, 110 | "number_sections": true, 111 | "sideBar": true, 112 | "skip_h1_title": false, 113 | "title_cell": "Table of Contents", 114 | "title_sidebar": "Contents", 115 | "toc_cell": false, 116 | "toc_position": {}, 117 | "toc_section_display": true, 118 | "toc_window_display": false 119 | } 120 | }, 121 | "nbformat": 4, 122 | "nbformat_minor": 5 123 | } 124 | -------------------------------------------------------------------------------- /07-深度学习/05-图网络/04-异构图.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "a9933915", 6 | "metadata": {}, 7 | "source": [ 8 | "## 异构图学习(heterogeneous graph learning)" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "4a12b832", 14 | "metadata": {}, 15 | "source": [ 16 | "- **同构图**：节点和边的类型均只有一种，比如社交网络中只存在一种节点类型（用户节点）和一种边类型（用户-用户的连边）。\n", 17 | "\n", 18 | "- **异构图**：节点的类型或者边的类型有多种，比如论文引用网络，节点有两种类型（作者节点和文章节点），边的类型有作者-作者间的共同创作关系，作者-文章间的从属关系，文章-文章间的引用关系。\n", 19 | "\n", 20 | "- **属性图**：图的节点上存在初始属性，可以用作后续节点的特征。\n", 21 | "\n", 22 | "- **动态图**：图中的节点或者边都是随着时间变化的，可能增加也可能减少，每个时刻用一个图表示。\n", 23 | "\n", 24 | "- **关系图**：图表示了一种节点之间的隐含关系，比如知识图谱。" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "id": "4aeec198", 30 | "metadata": {}, 31 | "source": [ 32 | "## 示例图\n", 33 | "\n", 34 | "  看一下来自[OGB](https://ogb.stanford.edu/)数据集的异构[ogbn-mag](https://ogb.stanford.edu/docs/nodeprop/)网络：\n", 35 | "\n", 36 | "" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 5, 42 | "id": "a68487f4", 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "node_nums\n", 50 | " 1939743\n", 51 | "edge_nums\n", 52 | " 21111007\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "node_nums = 59965 + 736389 + 1134649 + 8740\n", 58 | "edge_nums = 7505078 + 5416271 + 7145660 + 1043998\n", 59 | "print(\"node_nums\\n\", node_nums)\n", 60 | "print('edge_nums\\n', edge_nums)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "id": "c514388f", 66 | "metadata": {}, 67 | "source": [ 68 | "  给定的异构图有 1,939,743 个节点，分为作者、论文、机构和研究领域四种节点类型。\n", 69 | "\n", 70 | "  它还有 21,111,007 条边，它们也是以下四种类型之一：\n", 71 | "\n", 72 | "- writes：作者写了一篇特定的论文\n", 73 | "\n", 74 | "- 隶属于：作者隶属于特定机构\n", 75 | "\n", 76 | "- cites：一篇论文引用了另一篇论文\n", 77 | "\n", 78 | "- has topic : 一篇论文有一个特定研究领域的主题\n", 79 | "\n", 80 | "  该图的任务是根据存储在图中的信息推断每篇论文所在的场所venue（会议或者期刊），在ogbn-mag中总共有349个不同的venue，使任务成为349类的分类问题；" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "id": "77197bf7", 86 | "metadata": {}, 87 | "source": [ 88 | "## 创建异构图\n", 89 | "\n", 90 | "  我们可以创建一个类型`torch_geometric.data.HeteroData`的数据对象，为每个类型分别定义节点特征张量、边缘索引张量和边缘特征张量。\n", 91 | "\n", 92 | "```python\n", 93 | "data = HeteroData()\n", 94 | "\n", 95 | "data['paper'].x = ... # [num_papers, num_features_paper]\n", 96 | "data['author'].x = ... # [num_authors, num_features_author]\n", 97 | "data['institution'].x = ... # [num_institutions, num_features_institution]\n", 98 | "data['field_of_study'].x = ... # [num_field, num_features_field]\n", 99 | "\n", 100 | "data['paper', 'cites', 'paper'].edge_index = ... # [2, num_edges_cites]\n", 101 | "data['author', 'writes', 'paper'].edge_index = ... # [2, num_edges_writes]\n", 102 | "data['author', 'affiliated_with', 'institution'].edge_index = ... # [2, num_edges_affiliated]\n", 103 | "data['author', 'has_topic', 'institution'].edge_index = ... # [2, num_edges_topic]\n", 104 | "\n", 105 | "data['paper', 'cites', 'paper'].edge_attr = ... # [num_edges_cites, num_features_cites]\n", 106 | "data['author', 'writes', 'paper'].edge_attr = ... # [num_edges_writes, num_features_writes]\n", 107 | "data['author', 'affiliated_with', 'institution'].edge_attr = ... # [num_edges_affiliated, num_features_affiliated]\n", 108 | "data['paper', 'has_topic', 'field_of_study'].edge_attr = ... # [num_edges_topic, num_features_topic]\n", 109 | "```" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "id": "81d2a43f", 115 | "metadata": {}, 116 | "source": [ 117 | "  节点或边张量将在第一次访问时自动创建并由字符串键索引。节点类型由单个字符串标识，而边类型使用三元组字符串标识：边类型标识符和边类型可以存在的两个节点类型。因此，数据对象允许每种类型具有不同的特征维度。(source_node_type, edge_type, destination_node_type)。" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "id": "97fa79fc", 123 | "metadata": {}, 124 | "source": [ 125 | "  包含按属性名称而不是按节点或边类型分组的异构信息的字典可以直接访问，`data.{attribute_name}_dict`并在以后作为`GNN`模型的输入：\n", 126 | "\n", 127 | "```python\n", 128 | "model = HeteroGNN(...)\n", 129 | "\n", 130 | "output = model(data.x_dict, data.edge_index_dict, data.edge_attr_dict)\n", 131 | "```" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 7, 137 | "id": "b8647ba2", 138 | "metadata": {}, 139 | "outputs": [ 140 | { 141 | "ename": "ImportError", 142 | "evalue": "cannot import name 'OGB_MAG' from 'torch_geometric.datasets' (/Users/hezhiqiang01/Desktop/anaconda/anaconda3/envs/ecole/lib/python3.9/site-packages/torch_geometric/datasets/__init__.py)", 143 | "output_type": "error", 144 | "traceback": [ 145 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 146 | "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", 147 | "\u001b[0;32m/var/folders/62/8d2vj9r962zftg9n42v8j4n40000gn/T/ipykernel_88876/2945034426.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mtorch_geometric\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdatasets\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mOGB_MAG\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 148 | "\u001b[0;31mImportError\u001b[0m: cannot import name 'OGB_MAG' from 'torch_geometric.datasets' (/Users/hezhiqiang01/Desktop/anaconda/anaconda3/envs/ecole/lib/python3.9/site-packages/torch_geometric/datasets/__init__.py)" 149 | ] 150 | } 151 | ], 152 | "source": [ 153 | "from torch_geometric.datasets import OGB_MAG\n", 154 | "\n", 155 | "dataset = OGB_MAG(root='./data', preprocess='metapath2vec')\n", 156 | "data = dataset[0]" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "id": "6d68546e", 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": null, 170 | "id": "12f3781c", 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "id": "d273d2e7", 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "id": "2f607e80", 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": null, 194 | "id": "3f4d7e1c", 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "id": "899e2e26", 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [] 206 | } 207 | ], 208 | "metadata": { 209 | "kernelspec": { 210 | "display_name": "ecole", 211 | "language": "python", 212 | "name": "ecole" 213 | }, 214 | "language_info": { 215 | "codemirror_mode": { 216 | "name": "ipython", 217 | "version": 3 218 | }, 219 | "file_extension": ".py", 220 | "mimetype": "text/x-python", 221 | "name": "python", 222 | "nbconvert_exporter": "python", 223 | "pygments_lexer": "ipython3", 224 | "version": "3.9.6" 225 | }, 226 | "toc": { 227 | "base_numbering": 1, 228 | "nav_menu": {}, 229 | "number_sections": true, 230 | "sideBar": true, 231 | "skip_h1_title": false, 232 | "title_cell": "Table of Contents", 233 | "title_sidebar": "Contents", 234 | "toc_cell": false, 235 | "toc_position": {}, 236 | "toc_section_display": true, 237 | "toc_window_display": true 238 | } 239 | }, 240 | "nbformat": 4, 241 | "nbformat_minor": 5 242 | } 243 | -------------------------------------------------------------------------------- /07-深度学习/05-图网络/图神经网络.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "3150d8fe", 6 | "metadata": {}, 7 | "source": [ 8 | "## 什么是图神经网络中的状态更新" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "664cef0e", 14 | "metadata": {}, 15 | "source": [ 16 | "对于图神经网络中的基础定义，我们通常用$G=(V, E)$来表示，其中$G$表示图，$V$表示节点，$E$表示边。\n", 17 | "\n", 18 | "`GNN`的学习目标目标：**学习图结构中每个节点的状态信息**。\n" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "id": "8fa80cc5", 24 | "metadata": {}, 25 | "source": [ 26 | "" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "id": "b71a6812", 32 | "metadata": {}, 33 | "source": [ 34 | "定义节点状态更新的过程来描述整张图结构：" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "id": "e2b1d76a", 40 | "metadata": {}, 41 | "source": [ 42 | "$$\n", 43 | "h_{v}^{t} = f(x_{v}, x_{c}O[v], h_{n}^{t-1}e[v], x_{n})\n", 44 | "$$" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "id": "e6cf62e8", 50 | "metadata": {}, 51 | "source": [ 52 | "节点$v$在$t$时刻的节点状态$h_{v}^{t}$，是由节点信息 = (节点信息，边信息，邻节点状态，邻节点)所构成的。\n", 53 | "\n", 54 | "以节点$p1$为例，节点$p1$的相邻节点有$p1$和$p3$，$h_{p1}$的节点状态信息由$p1$节点的信息，与$p1$相邻的两条边$p_{(1,2)},p_{(1,3)}$组成。还有邻节点的状态$h_{p2},h_{p3}$，这个节点状态是上一个时刻的节点状态。最后还有邻节点信息。" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "id": "7defe67f", 60 | "metadata": {}, 61 | "source": [ 62 | "$$h_{p1} = f(p_{1}, p_{(1,2)}, p_{(1,3)}, h_{p2}, h_{p3}, p2, p3, \\cdots)$$" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "id": "7d848324", 68 | "metadata": {}, 69 | "source": [ 70 | "$f$:是状态更新函数，当我们神经网络能够拟合$f$, 我们就能得到图的状态。这个状态更新函数只是GNN最早期最早期的一个模型。" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "id": "fc2c0d78", 76 | "metadata": {}, 77 | "source": [ 78 | "## 开发环境&图描述" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "id": "60a1a0df", 84 | "metadata": {}, 85 | "source": [ 86 | "" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "id": "6c7bf60e", 92 | "metadata": {}, 93 | "source": [ 94 | "上图中是一个有向图网络结构，其中包含了四个顶点。其中A和C是一组顶点，B和D是一组顶点。用y的取值来进行区分。在顶点旁边有顶点的数据，顶点A旁边的数据是[2, 1]。" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 1, 100 | "id": "f49f7942", 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [ 104 | "import torch\n", 105 | "from torch_geometric.data import Data" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 2, 111 | "id": "9c18020a", 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "x = torch.tensor([[2, 1], [5, 6], [3, 7], [12, 0]], dtype=torch.float) # data的特征矩阵\n", 116 | "y = torch.tensor([0, 1, 0, 1], dtype=torch.float) # 图节点的target\n", 117 | "# 边的关系，从0号顶点到1号顶点； 1号顶点到0号顶点；0号顶点到3号顶点，2号顶点到1号顶点; 3号点到2号点。\n", 118 | "edge_index = torch.tensor([[0, 1, 0, 2, 3],\n", 119 | " [1, 0, 3, 1, 2]], dtype=torch.long) # 边的索引数据。" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 4, 125 | "id": "ecd9509d", 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "data": { 130 | "text/plain": [ 131 | "Data(edge_index=[2, 5], x=[4, 2], y=[4])" 132 | ] 133 | }, 134 | "execution_count": 4, 135 | "metadata": {}, 136 | "output_type": "execute_result" 137 | } 138 | ], 139 | "source": [ 140 | "data = Data(x=x, y=y, edge_index=edge_index)\n", 141 | "data" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "id": "6b785cc0", 147 | "metadata": {}, 148 | "source": [ 149 | "查看节点数量：" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 5, 155 | "id": "24ea809c", 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "data": { 160 | "text/plain": [ 161 | "4" 162 | ] 163 | }, 164 | "execution_count": 5, 165 | "metadata": {}, 166 | "output_type": "execute_result" 167 | } 168 | ], 169 | "source": [ 170 | "data.num_nodes # 查看节点数量" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": 6, 176 | "id": "f41039db", 177 | "metadata": {}, 178 | "outputs": [ 179 | { 180 | "data": { 181 | "text/plain": [ 182 | "5" 183 | ] 184 | }, 185 | "execution_count": 6, 186 | "metadata": {}, 187 | "output_type": "execute_result" 188 | } 189 | ], 190 | "source": [ 191 | "data.num_edges # 查看边" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 7, 197 | "id": "ab304815", 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "data": { 202 | "text/plain": [ 203 | "2" 204 | ] 205 | }, 206 | "execution_count": 7, 207 | "metadata": {}, 208 | "output_type": "execute_result" 209 | } 210 | ], 211 | "source": [ 212 | "data.num_node_features # 查看节点特征唯独" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 8, 218 | "id": "01256323", 219 | "metadata": {}, 220 | "outputs": [ 221 | { 222 | "data": { 223 | "text/plain": [ 224 | "False" 225 | ] 226 | }, 227 | "execution_count": 8, 228 | "metadata": {}, 229 | "output_type": "execute_result" 230 | } 231 | ], 232 | "source": [ 233 | "data.contains_isolated_nodes() # 是否有独立节点" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 9, 239 | "id": "88b9fcf8", 240 | "metadata": {}, 241 | "outputs": [ 242 | { 243 | "data": { 244 | "text/plain": [ 245 | "False" 246 | ] 247 | }, 248 | "execution_count": 9, 249 | "metadata": {}, 250 | "output_type": "execute_result" 251 | } 252 | ], 253 | "source": [ 254 | "data.contains_self_loops() # 是否有环" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": 10, 260 | "id": "af1064b5", 261 | "metadata": {}, 262 | "outputs": [ 263 | { 264 | "data": { 265 | "text/plain": [ 266 | "True" 267 | ] 268 | }, 269 | "execution_count": 10, 270 | "metadata": {}, 271 | "output_type": "execute_result" 272 | } 273 | ], 274 | "source": [ 275 | "data.is_directed() # 是否是有向图" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "id": "fb48f866", 281 | "metadata": {}, 282 | "source": [ 283 | "## Geometric构建数据集" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "id": "ca328f67", 289 | "metadata": {}, 290 | "source": [ 291 | "构建数据集有两种：\n", 292 | "\n", 293 | "1. 继承InMemoryDataset，一次性加载所有数据到内存；\n", 294 | "2. 继承Dataset，分次加载到内存。\n", 295 | "\n", 296 | "在自定义的Dataset的初始化方法中传入数据存放的路径，然后PyG会在这个路径下再划分两个文件夹：\n", 297 | "\n", 298 | "1. raw_dir: 存放原始数据的路径，(一般是CSV、mat等格式)。\n", 299 | "2. processed_dir: 存放处理后的数据，一般是pt格式，由process()方法实现。\n", 300 | "\n", 301 | "但是在Pytorch中，实际上是没有这两个文件夹的。\n", 302 | "\n", 303 | "Mini-Batching: 将一组样本组合成一个统一的表示形式，进行并行处理。" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": null, 309 | "id": "e87ae834", 310 | "metadata": {}, 311 | "outputs": [], 312 | "source": [] 313 | } 314 | ], 315 | "metadata": { 316 | "kernelspec": { 317 | "display_name": "ecole", 318 | "language": "python", 319 | "name": "ecole" 320 | }, 321 | "language_info": { 322 | "codemirror_mode": { 323 | "name": "ipython", 324 | "version": 3 325 | }, 326 | "file_extension": ".py", 327 | "mimetype": "text/x-python", 328 | "name": "python", 329 | "nbconvert_exporter": "python", 330 | "pygments_lexer": "ipython3", 331 | "version": "3.9.6" 332 | }, 333 | "toc": { 334 | "base_numbering": 1, 335 | "nav_menu": {}, 336 | "number_sections": true, 337 | "sideBar": true, 338 | "skip_h1_title": false, 339 | "title_cell": "Table of Contents", 340 | "title_sidebar": "Contents", 341 | "toc_cell": false, 342 | "toc_position": {}, 343 | "toc_section_display": true, 344 | "toc_window_display": false 345 | } 346 | }, 347 | "nbformat": 4, 348 | "nbformat_minor": 5 349 | } 350 | -------------------------------------------------------------------------------- /07-深度学习/06-生成对抗学习/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/07-深度学习/06-生成对抗学习/.DS_Store -------------------------------------------------------------------------------- /07-深度学习/06-生成对抗学习/.ipynb_checkpoints/01-生成对抗网络-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "51c676ec", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "49792ccf", 14 | "metadata": {}, 15 | "source": [ 16 | "## 生成对抗网络\n", 17 | "\n", 18 | "$$\n", 19 | "\\min _{G} \\max _{D} V(D, G)=\\mathbb{E}_{\\boldsymbol{x} \\sim p_{\\text {data }}(\\boldsymbol{x})}[\\log D(\\boldsymbol{x})]+\\mathbb{E}_{\\boldsymbol{z} \\sim p_{\\boldsymbol{z}}(\\boldsymbol{z})}[\\log (1-D(G(\\boldsymbol{z})))]\n", 20 | "$$" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "id": "26ef7eb5", 26 | "metadata": {}, 27 | "source": [ 28 | "对判别器而言，给定输入数据$\\boldsymbol{x}$，期望判别器$D$能够最大化其输出结果，也就是将其预测正确。对于生成器生成的数据$G(z)$而言，是期望最大化$V$, 也就是最大化$-D(G(z))$, 也就是最小化$D(G(z))$, 也就是期望判别器$D$能够将其预测出是假样本。\n", 29 | "\n", 30 | "对于生成器而言，期望生成器能够最小化$V$, 也就是最小化$-D(G(z))$, 也就是最大化$D(G(z))$，也就是期望能够骗过判别器，使得判别器对其输出结果期望是正样本。" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "id": "8ff92261", 36 | "metadata": {}, 37 | "source": [ 38 | "## GAN代码实现" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "id": "defee324", 44 | "metadata": {}, 45 | "source": [ 46 | "### 首先查看一下数据集" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 6, 52 | "id": "31328cc8", 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "import torch\n", 57 | "import torchvision\n", 58 | "import torch.nn as nn" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 17, 64 | "id": "97f5fcf1", 65 | "metadata": {}, 66 | "outputs": [ 67 | { 68 | "name": "stdout", 69 | "output_type": "stream", 70 | "text": [ 71 | "60000\n" 72 | ] 73 | } 74 | ], 75 | "source": [ 76 | "dataset = torchvision.datasets.MNIST(\"../../data\", train=True, download=True,\n", 77 | " transform=torchvision.transforms.Compose(\n", 78 | " [\n", 79 | " torchvision.transforms.Resize(28),\n", 80 | " torchvision.transforms.ToTensor()\n", 81 | " ]\n", 82 | " ))\n", 83 | "print(len(dataset))" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 21, 89 | "id": "6488191d", 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "torch.Size([1, 28, 28])\n", 97 | "torch.Size([1, 28, 28])\n", 98 | "torch.Size([1, 28, 28])\n", 99 | "torch.Size([1, 28, 28])\n", 100 | "torch.Size([1, 28, 28])\n", 101 | "torch.Size([1, 28, 28])\n" 102 | ] 103 | } 104 | ], 105 | "source": [ 106 | "for i in range(len(dataset)):\n", 107 | " if i <= 5:\n", 108 | " print(dataset[i][0].shape, )\n", 109 | " else:\n", 110 | " pass" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "id": "eae8663e", 116 | "metadata": {}, 117 | "source": [ 118 | "这里最前面的`1`是通道数。" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "id": "e3166dd4", 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [] 128 | } 129 | ], 130 | "metadata": { 131 | "kernelspec": { 132 | "display_name": "Python 3 (ipykernel)", 133 | "language": "python", 134 | "name": "python3" 135 | }, 136 | "language_info": { 137 | "codemirror_mode": { 138 | "name": "ipython", 139 | "version": 3 140 | }, 141 | "file_extension": ".py", 142 | "mimetype": "text/x-python", 143 | "name": "python", 144 | "nbconvert_exporter": "python", 145 | "pygments_lexer": "ipython3", 146 | "version": "3.9.4" 147 | }, 148 | "toc": { 149 | "base_numbering": 1, 150 | "nav_menu": {}, 151 | "number_sections": true, 152 | "sideBar": true, 153 | "skip_h1_title": false, 154 | "title_cell": "Table of Contents", 155 | "title_sidebar": "Contents", 156 | "toc_cell": false, 157 | "toc_position": {}, 158 | "toc_section_display": true, 159 | "toc_window_display": false 160 | } 161 | }, 162 | "nbformat": 4, 163 | "nbformat_minor": 5 164 | } 165 | -------------------------------------------------------------------------------- /07-深度学习/06-生成对抗学习/.ipynb_checkpoints/02-条件生成对抗网络-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /07-深度学习/06-生成对抗学习/.ipynb_checkpoints/03-均方最小化生成对抗网络-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /07-深度学习/06-生成对抗学习/02-条件生成对抗网络.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "6d19cc6a", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "70a7949e", 14 | "metadata": {}, 15 | "source": [ 16 | "原始`GAN`的公式如下:\n", 17 | "\n", 18 | "$$\n", 19 | "\\min _{G} \\max _{D} V(D, G)=\\mathbb{E}_{\\boldsymbol{x} \\sim p_{\\text {data }}(\\boldsymbol{x})}[\\log D(\\boldsymbol{x})]+\\mathbb{E}_{\\boldsymbol{z} \\sim p_{\\boldsymbol{z}}(\\boldsymbol{z})}[\\log (1-D(G(\\boldsymbol{z})))]\n", 20 | "$$\n", 21 | "\n", 22 | "引入条件信息，我们可以得到`cGAN`的公式如下：\n", 23 | "\n", 24 | "$$\n", 25 | "\\min _{G} \\max _{D} V(D, G)=\\mathbb{E}_{\\boldsymbol{x} \\sim p_{\\text {data }}(\\boldsymbol{x})}[\\log D(\\boldsymbol{x} \\mid \\boldsymbol{y})]+\\mathbb{E}_{\\boldsymbol{z} \\sim p_{z}(\\boldsymbol{z})}[\\log (1-D(G(\\boldsymbol{z} \\mid \\boldsymbol{y})))]\n", 26 | "$$" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "id": "e676c95b", 32 | "metadata": {}, 33 | "source": [ 34 | "其中$y$就是条件信息，此时生成器的输入除了隐变量$z$之外，还有条件信息$y$, 条件信息可以是连续的变量，也可以是离散的变量。比如像手写字识别中，条件信息就是提供的手写字的类别。对于条件信息，我们可以直接穿入条件信息的`one-hot`变量，但是那样太稀疏了，我们也可以传入`one-hot`向量的`embedding`信息。\n", 35 | "\n", 36 | "同样的，判别器也可以引入条件信息。这里的条件信息同样可以转换成`embedding`信息再与图像信息拼接在一起。" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "id": "32f526ea", 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [] 46 | } 47 | ], 48 | "metadata": { 49 | "kernelspec": { 50 | "display_name": "Python 3 (ipykernel)", 51 | "language": "python", 52 | "name": "python3" 53 | }, 54 | "language_info": { 55 | "codemirror_mode": { 56 | "name": "ipython", 57 | "version": 3 58 | }, 59 | "file_extension": ".py", 60 | "mimetype": "text/x-python", 61 | "name": "python", 62 | "nbconvert_exporter": "python", 63 | "pygments_lexer": "ipython3", 64 | "version": "3.9.4" 65 | }, 66 | "toc": { 67 | "base_numbering": 1, 68 | "nav_menu": {}, 69 | "number_sections": true, 70 | "sideBar": true, 71 | "skip_h1_title": false, 72 | "title_cell": "Table of Contents", 73 | "title_sidebar": "Contents", 74 | "toc_cell": false, 75 | "toc_position": {}, 76 | "toc_section_display": true, 77 | "toc_window_display": false 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 5 82 | } 83 | -------------------------------------------------------------------------------- /07-深度学习/06-生成对抗学习/03-均方最小化生成对抗网络.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "f0b6a99e", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "79f4bf5e", 14 | "metadata": {}, 15 | "source": [ 16 | "原始`GAN`的公式如下:\n", 17 | "\n", 18 | "$$\n", 19 | "\\min _{G} \\max _{D} V(D, G)=\\mathbb{E}_{\\boldsymbol{x} \\sim p_{\\text {data }}(\\boldsymbol{x})}[\\log D(\\boldsymbol{x})]+\\mathbb{E}_{\\boldsymbol{z} \\sim p_{\\boldsymbol{z}}(\\boldsymbol{z})}[\\log (1-D(G(\\boldsymbol{z})))]\n", 20 | "$$\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "id": "2155aa63", 26 | "metadata": {}, 27 | "source": [ 28 | "## Sigmoid函数在GAN中存在的梯度消失问题" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "id": "6f98948c", 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "id": "84f1b880", 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "id": "91592747", 50 | "metadata": {}, 51 | "source": [ 52 | "引入均方最小化，我们可以得到`LSGAN`的公式如下：\n", 53 | "\n", 54 | "$$\n", 55 | "\\min _{G} \\max _{D} V(D, G)=\\mathbb{E}_{\\boldsymbol{x} \\sim p_{\\text {data }}(\\boldsymbol{x})}[\\log D(\\boldsymbol{x} \\mid \\boldsymbol{y})]+\\mathbb{E}_{\\boldsymbol{z} \\sim p_{z}(\\boldsymbol{z})}[\\log (1-D(G(\\boldsymbol{z} \\mid \\boldsymbol{y})))]\n", 56 | "$$\n" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "id": "800eef90", 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [] 66 | } 67 | ], 68 | "metadata": { 69 | "kernelspec": { 70 | "display_name": "Python 3 (ipykernel)", 71 | "language": "python", 72 | "name": "python3" 73 | }, 74 | "language_info": { 75 | "codemirror_mode": { 76 | "name": "ipython", 77 | "version": 3 78 | }, 79 | "file_extension": ".py", 80 | "mimetype": "text/x-python", 81 | "name": "python", 82 | "nbconvert_exporter": "python", 83 | "pygments_lexer": "ipython3", 84 | "version": "3.9.4" 85 | }, 86 | "toc": { 87 | "base_numbering": 1, 88 | "nav_menu": {}, 89 | "number_sections": true, 90 | "sideBar": true, 91 | "skip_h1_title": false, 92 | "title_cell": "Table of Contents", 93 | "title_sidebar": "Contents", 94 | "toc_cell": false, 95 | "toc_position": {}, 96 | "toc_section_display": true, 97 | "toc_window_display": false 98 | } 99 | }, 100 | "nbformat": 4, 101 | "nbformat_minor": 5 102 | } 103 | -------------------------------------------------------------------------------- /11-强化学习/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/.DS_Store -------------------------------------------------------------------------------- /11-强化学习/1-控制问题描述与进化算法/1.1-控制问题描述.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "e5e9e83d", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/2-动态规划/2.09-NStepSarsa.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "703b65ca", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "episode 0 avg_score 18.0 epsilon 1.00\n", 14 | "episode 1000 avg_score 22.9 epsilon 0.96\n", 15 | "episode 2000 avg_score 24.5 epsilon 0.92\n", 16 | "episode 3000 avg_score 27.0 epsilon 0.88\n", 17 | "episode 4000 avg_score 30.4 epsilon 0.84\n", 18 | "episode 5000 avg_score 33.2 epsilon 0.80\n", 19 | "episode 6000 avg_score 35.9 epsilon 0.76\n", 20 | "episode 7000 avg_score 41.1 epsilon 0.72\n", 21 | "episode 8000 avg_score 46.6 epsilon 0.68\n", 22 | "episode 9000 avg_score 52.6 epsilon 0.64\n", 23 | "episode 10000 avg_score 58.7 epsilon 0.60\n", 24 | "episode 11000 avg_score 67.9 epsilon 0.56\n", 25 | "episode 12000 avg_score 78.0 epsilon 0.52\n", 26 | "episode 13000 avg_score 88.9 epsilon 0.48\n", 27 | "episode 14000 avg_score 96.2 epsilon 0.44\n", 28 | "episode 15000 avg_score 106.5 epsilon 0.40\n", 29 | "episode 16000 avg_score 112.3 epsilon 0.36\n", 30 | "episode 17000 avg_score 116.9 epsilon 0.32\n", 31 | "episode 18000 avg_score 125.3 epsilon 0.28\n", 32 | "episode 19000 avg_score 130.6 epsilon 0.24\n", 33 | "episode 20000 avg_score 134.4 epsilon 0.20\n", 34 | "episode 21000 avg_score 136.3 epsilon 0.16\n", 35 | "episode 22000 avg_score 147.1 epsilon 0.12\n", 36 | "episode 23000 avg_score 143.5 epsilon 0.08\n", 37 | "episode 24000 avg_score 149.7 epsilon 0.04\n", 38 | "episode 25000 avg_score 166.6 epsilon 0.00\n", 39 | "episode 26000 avg_score 135.0 epsilon 0.00\n", 40 | "episode 27000 avg_score 133.7 epsilon 0.00\n", 41 | "episode 28000 avg_score 138.4 epsilon 0.00\n", 42 | "episode 29000 avg_score 136.2 epsilon 0.00\n", 43 | "episode 30000 avg_score 136.2 epsilon 0.00\n", 44 | "episode 31000 avg_score 132.0 epsilon 0.00\n", 45 | "episode 32000 avg_score 133.1 epsilon 0.00\n", 46 | "episode 33000 avg_score 132.5 epsilon 0.00\n", 47 | "episode 34000 avg_score 130.9 epsilon 0.00\n", 48 | "episode 35000 avg_score 133.4 epsilon 0.00\n", 49 | "episode 36000 avg_score 135.7 epsilon 0.00\n", 50 | "episode 37000 avg_score 132.1 epsilon 0.00\n", 51 | "episode 38000 avg_score 133.5 epsilon 0.00\n", 52 | "episode 39000 avg_score 132.4 epsilon 0.00\n", 53 | "episode 40000 avg_score 131.5 epsilon 0.00\n", 54 | "episode 41000 avg_score 130.4 epsilon 0.00\n", 55 | "episode 42000 avg_score 130.5 epsilon 0.00\n", 56 | "episode 43000 avg_score 128.7 epsilon 0.00\n", 57 | "episode 44000 avg_score 129.7 epsilon 0.00\n", 58 | "episode 45000 avg_score 130.0 epsilon 0.00\n", 59 | "episode 46000 avg_score 128.9 epsilon 0.00\n", 60 | "episode 47000 avg_score 128.5 epsilon 0.00\n", 61 | "episode 48000 avg_score 129.6 epsilon 0.00\n", 62 | "episode 49000 avg_score 128.9 epsilon 0.00\n" 63 | ] 64 | } 65 | ], 66 | "source": [ 67 | "import numpy as np\n", 68 | "import gym\n", 69 | "\n", 70 | "poleThetaSpace = np.linspace(-0.209, 0.209, 10)\n", 71 | "poleThetaVelSpace = np.linspace(-4, 4, 10)\n", 72 | "cartPosSpace = np.linspace(-2.4, 2.4, 10)\n", 73 | "cartVelSpace = np.linspace(-4, 4, 10)\n", 74 | "\n", 75 | "def get_state(observation):\n", 76 | " cartX, cartXdot, cartTheta, cartThetaDot = observation\n", 77 | " cartX = int(np.digitize(cartX, cartPosSpace))\n", 78 | " cartXdot = int(np.digitize(cartXdot, cartVelSpace))\n", 79 | " cartTheta = int(np.digitize(cartTheta, poleThetaSpace))\n", 80 | " cartThetaDot = int(np.digitize(cartThetaDot, poleThetaVelSpace))\n", 81 | "\n", 82 | " return (cartX, cartXdot, cartTheta, cartThetaDot)\n", 83 | "\n", 84 | "def choose_action(q, obs, eps, n_actions=2):\n", 85 | " state = get_state(obs)\n", 86 | " if np.random.random() < eps:\n", 87 | " action = np.random.choice([i for i in range(n_actions)])\n", 88 | " else:\n", 89 | " action_values = [q[(state, a)] for a in range(n_actions)]\n", 90 | " action = np.argmax(action_values)\n", 91 | " return action\n", 92 | "\n", 93 | "if __name__ == '__main__':\n", 94 | " env = gym.make('CartPole-v0')\n", 95 | " alpha = 0.1\n", 96 | " gamma = 0.9\n", 97 | " epsilon = 1.0\n", 98 | "\n", 99 | " states = []\n", 100 | " for i in range(len(cartPosSpace)+1):\n", 101 | " for j in range(len(cartVelSpace)+1):\n", 102 | " for k in range(len(poleThetaSpace)+1):\n", 103 | " for l in range(len(poleThetaVelSpace)+1):\n", 104 | " states.append((i,j,k,l))\n", 105 | "\n", 106 | " Q = {}\n", 107 | " for s in states:\n", 108 | " for a in range(2):\n", 109 | " Q[(s, a)] = 0.0\n", 110 | "\n", 111 | " n = 16\n", 112 | " state_memory = np.zeros((n, 4))\n", 113 | " action_memory = np.zeros(n)\n", 114 | " reward_memory = np.zeros(n)\n", 115 | "\n", 116 | " scores = []\n", 117 | " n_episodes = 50000\n", 118 | " for i in range(n_episodes):\n", 119 | " done = False\n", 120 | " score = 0\n", 121 | " t = 0\n", 122 | " T = np.inf\n", 123 | " observation = env.reset()\n", 124 | " action = choose_action(Q, observation, epsilon)\n", 125 | " action_memory[t%n] = action\n", 126 | " state_memory[t%n] = observation\n", 127 | " while not done:\n", 128 | " observation, reward, done, info = env.step(action)\n", 129 | " score += reward\n", 130 | " state_memory[(t+1)%n] = observation\n", 131 | " reward_memory[(t+1)%n] = reward\n", 132 | " if done:\n", 133 | " T = t + 1\n", 134 | " #print('episode ends at step', t)\n", 135 | " action = choose_action(Q, observation, epsilon)\n", 136 | " action_memory[(t+1)%n] = action\n", 137 | " tau = t - n + 1\n", 138 | " if tau >= 0:\n", 139 | " G = [gamma**(j-tau-1)*reward_memory[j%n] \\\n", 140 | " for j in range(tau+1, min(tau+n, T)+1)]\n", 141 | " G = np.sum(G)\n", 142 | " if tau + n < T:\n", 143 | " s = get_state(state_memory[(tau+n)%n])\n", 144 | " a = int(action_memory[(tau+n)%n])\n", 145 | " G += gamma**n * Q[(s,a)]\n", 146 | " s = get_state(state_memory[tau%n])\n", 147 | " a = action_memory[tau%n]\n", 148 | " Q[(s,a)] += alpha*(G-Q[(s,a)])\n", 149 | " #print('tau ', tau, '| Q %.2f' % \\\n", 150 | " # Q[(get_state(state_memory[tau%n]), action_memory[tau%n])])\n", 151 | "\n", 152 | " t += 1\n", 153 | "\n", 154 | " for tau in range(t-n+1, T):\n", 155 | " G = [gamma**(j-tau-1)*reward_memory[j%n] \\\n", 156 | " for j in range(tau+1, min(tau+n, T)+1)]\n", 157 | " G = np.sum(G)\n", 158 | " if tau + n < T:\n", 159 | " s = get_state(state_memory[(tau+n)%n])\n", 160 | " a = int(action_memory[(tau+n)%n])\n", 161 | " G += gamma**n * Q[(s,a)]\n", 162 | " s = get_state(state_memory[tau%n])\n", 163 | " a = action_memory[tau%n]\n", 164 | " Q[(s,a)] += alpha*(G-Q[(s,a)])\n", 165 | " #print('tau ', tau, '| Q %.2f' % \\\n", 166 | " # Q[(get_state(state_memory[tau%n]), action_memory[tau%n])])\n", 167 | " scores.append(score)\n", 168 | " avg_score = np.mean(scores[-1000:])\n", 169 | " epsilon = epsilon -2 / n_episodes if epsilon > 0 else 0\n", 170 | " if i % 1000 == 0:\n", 171 | " print('episode ', i, 'avg_score %.1f' % avg_score,\n", 172 | " 'epsilon %.2f' % epsilon)\n", 173 | "\n" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "id": "0d6f4a3a", 180 | "metadata": {}, 181 | "outputs": [], 182 | "source": [] 183 | } 184 | ], 185 | "metadata": { 186 | "kernelspec": { 187 | "display_name": "Python 3 (ipykernel)", 188 | "language": "python", 189 | "name": "python3" 190 | }, 191 | "language_info": { 192 | "codemirror_mode": { 193 | "name": "ipython", 194 | "version": 3 195 | }, 196 | "file_extension": ".py", 197 | "mimetype": "text/x-python", 198 | "name": "python", 199 | "nbconvert_exporter": "python", 200 | "pygments_lexer": "ipython3", 201 | "version": "3.9.4" 202 | }, 203 | "toc": { 204 | "base_numbering": 1, 205 | "nav_menu": {}, 206 | "number_sections": true, 207 | "sideBar": true, 208 | "skip_h1_title": false, 209 | "title_cell": "Table of Contents", 210 | "title_sidebar": "Contents", 211 | "toc_cell": false, 212 | "toc_position": {}, 213 | "toc_section_display": true, 214 | "toc_window_display": false 215 | } 216 | }, 217 | "nbformat": 4, 218 | "nbformat_minor": 5 219 | } 220 | -------------------------------------------------------------------------------- /11-强化学习/2-动态规划/2.10-值迭代网络.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "4aea39ec", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "1eb180f6", 14 | "metadata": {}, 15 | "source": [ 16 | "- [Value Iteration Networks](https://arxiv.org/abs/1602.02867)\n", 17 | "\n", 18 | "- https://github.com/kentsommer/pytorch-value-iteration-networks" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "id": "135fc986", 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "id": "4b7196ea", 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [] 36 | } 37 | ], 38 | "metadata": { 39 | "kernelspec": { 40 | "display_name": "Python 3 (ipykernel)", 41 | "language": "python", 42 | "name": "python3" 43 | }, 44 | "language_info": { 45 | "codemirror_mode": { 46 | "name": "ipython", 47 | "version": 3 48 | }, 49 | "file_extension": ".py", 50 | "mimetype": "text/x-python", 51 | "name": "python", 52 | "nbconvert_exporter": "python", 53 | "pygments_lexer": "ipython3", 54 | "version": "3.9.4" 55 | }, 56 | "toc": { 57 | "base_numbering": 1, 58 | "nav_menu": {}, 59 | "number_sections": true, 60 | "sideBar": true, 61 | "skip_h1_title": false, 62 | "title_cell": "Table of Contents", 63 | "title_sidebar": "Contents", 64 | "toc_cell": false, 65 | "toc_position": {}, 66 | "toc_section_display": true, 67 | "toc_window_display": false 68 | } 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 5 72 | } 73 | -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/4-策略优化/.DS_Store -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/1.6-进化策略.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "410c237a", 6 | "metadata": {}, 7 | "source": [ 8 | "- [Evolution Strategies as a Scalable Alternative to Reinforcement Learning](https://arxiv.org/abs/1703.03864)" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": null, 14 | "id": "282b5395", 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "id": "ed0b41bc", 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [] 26 | } 27 | ], 28 | "metadata": { 29 | "kernelspec": { 30 | "display_name": "Python 3 (ipykernel)", 31 | "language": "python", 32 | "name": "python3" 33 | }, 34 | "language_info": { 35 | "codemirror_mode": { 36 | "name": "ipython", 37 | "version": 3 38 | }, 39 | "file_extension": ".py", 40 | "mimetype": "text/x-python", 41 | "name": "python", 42 | "nbconvert_exporter": "python", 43 | "pygments_lexer": "ipython3", 44 | "version": "3.9.4" 45 | }, 46 | "toc": { 47 | "base_numbering": 1, 48 | "nav_menu": {}, 49 | "number_sections": true, 50 | "sideBar": true, 51 | "skip_h1_title": false, 52 | "title_cell": "Table of Contents", 53 | "title_sidebar": "Contents", 54 | "toc_cell": false, 55 | "toc_position": {}, 56 | "toc_section_display": true, 57 | "toc_window_display": false 58 | } 59 | }, 60 | "nbformat": 4, 61 | "nbformat_minor": 5 62 | } 63 | -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/4-策略优化.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "69492d31", 6 | "metadata": {}, 7 | "source": [ 8 | "Policy Optimization" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": null, 14 | "id": "a9507cda", 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "id": "c2f30169", 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [] 26 | } 27 | ], 28 | "metadata": { 29 | "kernelspec": { 30 | "display_name": "Python 3 (ipykernel)", 31 | "language": "python", 32 | "name": "python3" 33 | }, 34 | "language_info": { 35 | "codemirror_mode": { 36 | "name": "ipython", 37 | "version": 3 38 | }, 39 | "file_extension": ".py", 40 | "mimetype": "text/x-python", 41 | "name": "python", 42 | "nbconvert_exporter": "python", 43 | "pygments_lexer": "ipython3", 44 | "version": "3.9.4" 45 | }, 46 | "toc": { 47 | "base_numbering": 1, 48 | "nav_menu": {}, 49 | "number_sections": true, 50 | "sideBar": true, 51 | "skip_h1_title": false, 52 | "title_cell": "Table of Contents", 53 | "title_sidebar": "Contents", 54 | "toc_cell": false, 55 | "toc_position": {}, 56 | "toc_section_display": true, 57 | "toc_window_display": false 58 | } 59 | }, 60 | "nbformat": 4, 61 | "nbformat_minor": 5 62 | } 63 | -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/4.2-NES.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "eb8bdc99", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/4.3-Policy Gradient.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "273993dd", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/4.5-SVG.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "2bdbfca6", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/4-策略优化/4.7-PPO.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "9e8fcc58", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/5-演员评论家/5-演员评论家.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "f8b47c52", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/5-演员评论家/multiprocessing_env.py: -------------------------------------------------------------------------------- 1 | #This code is from openai baseline 2 | #https://github.com/openai/baselines/tree/master/baselines/common/vec_env 3 | 4 | import numpy as np 5 | from multiprocessing import Process, Pipe 6 | 7 | def worker(remote, parent_remote, env_fn_wrapper): 8 | parent_remote.close() 9 | env = env_fn_wrapper.x() 10 | while True: 11 | cmd, data = remote.recv() 12 | if cmd == 'step': 13 | ob, reward, done, info = env.step(data) 14 | if done: 15 | ob = env.reset() 16 | remote.send((ob, reward, done, info)) 17 | elif cmd == 'reset': 18 | ob = env.reset() 19 | remote.send(ob) 20 | elif cmd == 'reset_task': 21 | ob = env.reset_task() 22 | remote.send(ob) 23 | elif cmd == 'close': 24 | remote.close() 25 | break 26 | elif cmd == 'get_spaces': 27 | remote.send((env.observation_space, env.action_space)) 28 | else: 29 | raise NotImplementedError 30 | 31 | class VecEnv(object): 32 | """ 33 | An abstract asynchronous, vectorized environment. 34 | """ 35 | def __init__(self, num_envs, observation_space, action_space): 36 | self.num_envs = num_envs 37 | self.observation_space = observation_space 38 | self.action_space = action_space 39 | 40 | def reset(self): 41 | """ 42 | Reset all the environments and return an array of 43 | observations, or a tuple of observation arrays. 44 | If step_async is still doing work, that work will 45 | be cancelled and step_wait() should not be called 46 | until step_async() is invoked again. 47 | """ 48 | pass 49 | 50 | def step_async(self, actions): 51 | """ 52 | Tell all the environments to start taking a step 53 | with the given actions. 54 | Call step_wait() to get the results of the step. 55 | You should not call this if a step_async run is 56 | already pending. 57 | """ 58 | pass 59 | 60 | def step_wait(self): 61 | """ 62 | Wait for the step taken with step_async(). 63 | Returns (obs, rews, dones, infos): 64 | - obs: an array of observations, or a tuple of 65 | arrays of observations. 66 | - rews: an array of rewards 67 | - dones: an array of "episode done" booleans 68 | - infos: a sequence of info objects 69 | """ 70 | pass 71 | 72 | def close(self): 73 | """ 74 | Clean up the environments' resources. 75 | """ 76 | pass 77 | 78 | def step(self, actions): 79 | self.step_async(actions) 80 | return self.step_wait() 81 | 82 | 83 | class CloudpickleWrapper(object): 84 | """ 85 | Uses cloudpickle to serialize contents (otherwise multiprocessing tries to use pickle) 86 | """ 87 | def __init__(self, x): 88 | self.x = x 89 | def __getstate__(self): 90 | import cloudpickle 91 | return cloudpickle.dumps(self.x) 92 | def __setstate__(self, ob): 93 | import pickle 94 | self.x = pickle.loads(ob) 95 | 96 | 97 | class SubprocVecEnv(VecEnv): 98 | def __init__(self, env_fns, spaces=None): 99 | """ 100 | envs: list of gym environments to run in subprocesses 101 | """ 102 | self.waiting = False 103 | self.closed = False 104 | nenvs = len(env_fns) 105 | self.nenvs = nenvs 106 | self.remotes, self.work_remotes = zip(*[Pipe() for _ in range(nenvs)]) 107 | self.ps = [Process(target=worker, args=(work_remote, remote, CloudpickleWrapper(env_fn))) 108 | for (work_remote, remote, env_fn) in zip(self.work_remotes, self.remotes, env_fns)] 109 | for p in self.ps: 110 | p.daemon = True # if the main process crashes, we should not cause things to hang 111 | p.start() 112 | for remote in self.work_remotes: 113 | remote.close() 114 | 115 | self.remotes[0].send(('get_spaces', None)) 116 | observation_space, action_space = self.remotes[0].recv() 117 | VecEnv.__init__(self, len(env_fns), observation_space, action_space) 118 | 119 | def step_async(self, actions): 120 | for remote, action in zip(self.remotes, actions): 121 | remote.send(('step', action)) 122 | self.waiting = True 123 | 124 | def step_wait(self): 125 | results = [remote.recv() for remote in self.remotes] 126 | self.waiting = False 127 | obs, rews, dones, infos = zip(*results) 128 | return np.stack(obs), np.stack(rews), np.stack(dones), infos 129 | 130 | def reset(self): 131 | for remote in self.remotes: 132 | remote.send(('reset', None)) 133 | return np.stack([remote.recv() for remote in self.remotes]) 134 | 135 | def reset_task(self): 136 | for remote in self.remotes: 137 | remote.send(('reset_task', None)) 138 | return np.stack([remote.recv() for remote in self.remotes]) 139 | 140 | def close(self): 141 | if self.closed: 142 | return 143 | if self.waiting: 144 | for remote in self.remotes: 145 | remote.recv() 146 | for remote in self.remotes: 147 | remote.send(('close', None)) 148 | for p in self.ps: 149 | p.join() 150 | self.closed = True 151 | 152 | def __len__(self): 153 | return self.nenvs -------------------------------------------------------------------------------- /11-强化学习/6-模仿学习与逆强化学习/6-模仿与逆强化学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "67fea1b9", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/7-基于模型的强化学习/7-基于模型的强化学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "3b5f0e0b", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/8-规划算法/8.1-MCCFR.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "f1eeac84", 6 | "metadata": {}, 7 | "source": [ 8 | "## MCCFR\n", 9 | "\n", 10 | "改进CFR用于大规模游戏环境中。Monte Carlo CFR +\n", 11 | "\n", 12 | "- https://www.youtube.com/channel/UCbCoz3MxHc2Ixcfq-xLCigw\n", 13 | "\n", 14 | "- [Monte Carlo Sampling for Regret Minimization in Extensive Games](http://mlanctot.info/files/papers/nips09mccfr.pdf)\n", 15 | "\n", 16 | "- [Solving Heads-up Limit Texas Hold’em](https://poker.cs.ualberta.ca/publications/2015-ijcai-cfrplus.pdf)\n", 17 | "\n", 18 | "改进点:\n", 19 | "\n", 20 | "1. In van" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "id": "d69a8845", 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [] 30 | } 31 | ], 32 | "metadata": { 33 | "kernelspec": { 34 | "display_name": "Python 3 (ipykernel)", 35 | "language": "python", 36 | "name": "python3" 37 | }, 38 | "language_info": { 39 | "codemirror_mode": { 40 | "name": "ipython", 41 | "version": 3 42 | }, 43 | "file_extension": ".py", 44 | "mimetype": "text/x-python", 45 | "name": "python", 46 | "nbconvert_exporter": "python", 47 | "pygments_lexer": "ipython3", 48 | "version": "3.9.4" 49 | }, 50 | "toc": { 51 | "base_numbering": 1, 52 | "nav_menu": {}, 53 | "number_sections": true, 54 | "sideBar": true, 55 | "skip_h1_title": false, 56 | "title_cell": "Table of Contents", 57 | "title_sidebar": "Contents", 58 | "toc_cell": false, 59 | "toc_position": {}, 60 | "toc_section_display": true, 61 | "toc_window_display": false 62 | } 63 | }, 64 | "nbformat": 4, 65 | "nbformat_minor": 5 66 | } 67 | -------------------------------------------------------------------------------- /11-强化学习/9-分布式强化学习/9-分布式强化学习.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "id": "6be64dcf", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /11-强化学习/actions_expert_Pendulum.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/actions_expert_Pendulum.npy -------------------------------------------------------------------------------- /11-强化学习/reward_exprt_TRPO.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/reward_exprt_TRPO.npy -------------------------------------------------------------------------------- /11-强化学习/reward_mean_pendulum_expert.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/reward_mean_pendulum_expert.npy -------------------------------------------------------------------------------- /11-强化学习/reward_mean_pendulum_random.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/reward_mean_pendulum_random.npy -------------------------------------------------------------------------------- /11-强化学习/reward_mean_walker_random.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/11-强化学习/reward_mean_walker_random.npy -------------------------------------------------------------------------------- /12-组合优化/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/01-Gurobi基本操作/03-Gurobi中的Infeasible model问题.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "4caeac6b", 6 | "metadata": {}, 7 | "source": [ 8 | "导致gurobi报出infeasible model错误的原因有两种:\n", 9 | "\n", 10 | "1. 模型约束条件里面有互相矛盾的地方，这个模型本身并没有可行解。\n", 11 | "2. 模型本身没有问题，把数学模型输入到gurobi的过程中，编程错误或者参数输入不正确导致模型不可行。" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 3, 17 | "id": "3e21fc07", 18 | "metadata": {}, 19 | "outputs": [ 20 | { 21 | "name": "stdout", 22 | "output_type": "stream", 23 | "text": [ 24 | "Gurobi Optimizer version 9.1.2 build v9.1.2rc0 (mac64)\n", 25 | "Thread count: 2 physical cores, 4 logical processors, using up to 4 threads\n", 26 | "Optimize a model with 3 rows, 2 columns and 6 nonzeros\n", 27 | "Model fingerprint: 0x737daf1e\n", 28 | "Coefficient statistics:\n", 29 | " Matrix range [1e+00, 1e+00]\n", 30 | " Objective range [1e+00, 2e+00]\n", 31 | " Bounds range [1e+00, 1e+00]\n", 32 | " RHS range [1e-01, 1e+00]\n", 33 | "Presolve removed 1 rows and 1 columns\n", 34 | "Presolve time: 0.01s\n", 35 | "\n", 36 | "Solved in 0 iterations and 0.01 seconds\n", 37 | "Infeasible model\n", 38 | "Iteration Objective Primal Inf. Dual Inf. Time\n", 39 | " 0 0.0000000e+00 1.300000e+00 0.000000e+00 0s\n", 40 | "\n", 41 | "IIS computed: 2 constraints and 0 bounds\n", 42 | "IIS runtime: 0.00 seconds\n" 43 | ] 44 | } 45 | ], 46 | "source": [ 47 | "import gurobi as gp\n", 48 | "m = gp.Model(\"test\")\n", 49 | "x = m.addVars(2, lb = 0.0, ub = 1.0, name = 'x')\n", 50 | "m.addConstr(x[0] + x[1] >= 1.2, 'c1')\n", 51 | "m.addConstr(x[0] + x[1] <= 1.1, 'c2')\n", 52 | "m.addConstr(x[0] + x[1] >= 0.1, 'c3')\n", 53 | "\n", 54 | "m.setObjective(x[0] + 2 * x[1])\n", 55 | "m.optimize()\n", 56 | "\n", 57 | "m.computeIIS()\n", 58 | "m.write('model1.ilp')" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "id": "dee51a93", 64 | "metadata": {}, 65 | "source": [ 66 | "## 处理冲突约束的思路\n", 67 | "\n", 68 | "1. 从上面的代码容易看到第一条约束x0+x1>=1.2和第二条约束x0+x1<=1.1是互相矛盾的，因此该模型不存在可行解。\n", 69 | "\n", 70 | "2. 所以当我们求解这个模型的时候，gurobi会报出 infeasible model 的错误信息，此时我们可以调用computeIIS()即可得到哪些约束是互相矛盾的，即去掉这些矛盾约束剩下的约束构成的问题是可行的。\n", 71 | "\n", 72 | "3. 为了方便观察computellS()的输出结果，可以用m.write('model1.ilp')输出一个扩展名为ilp的文件，里边会包含所有矛盾约束。\n", 73 | "\n", 74 | "```bash\n", 75 | "Minimize\n", 76 | " \n", 77 | "Subject To\n", 78 | " c1: x[0] + x[1] >= 1.2\n", 79 | " c2: x[0] + x[1] <= 1.1\n", 80 | "Bounds\n", 81 | " x[0] free\n", 82 | " x[1] free\n", 83 | "End\n", 84 | "```\n", 85 | "\n", 86 | "可以看到其输出了前两个造成矛盾的约束，而第三个约束没有矛盾，所以没有输出在`.ilp`文件内。\n", 87 | "\n", 88 | "但是大规模问题用不了`computeIIS()`，会非常慢。" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "id": "f85c0ea6", 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [] 98 | } 99 | ], 100 | "metadata": { 101 | "kernelspec": { 102 | "display_name": "ACG", 103 | "language": "python", 104 | "name": "acg" 105 | }, 106 | "language_info": { 107 | "codemirror_mode": { 108 | "name": "ipython", 109 | "version": 3 110 | }, 111 | "file_extension": ".py", 112 | "mimetype": "text/x-python", 113 | "name": "python", 114 | "nbconvert_exporter": "python", 115 | "pygments_lexer": "ipython3", 116 | "version": "3.6.13" 117 | }, 118 | "toc": { 119 | "base_numbering": 1, 120 | "nav_menu": {}, 121 | "number_sections": true, 122 | "sideBar": true, 123 | "skip_h1_title": false, 124 | "title_cell": "Table of Contents", 125 | "title_sidebar": "Contents", 126 | "toc_cell": false, 127 | "toc_position": {}, 128 | "toc_section_display": true, 129 | "toc_window_display": false 130 | } 131 | }, 132 | "nbformat": 4, 133 | "nbformat_minor": 5 134 | } 135 | -------------------------------------------------------------------------------- /12-组合优化/Guribo/02-Gurobi功能和操作进阶/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/02-Gurobi功能和操作进阶/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/03-Gurobi高级操作和使用方法/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/03-Gurobi高级操作和使用方法/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/03-Gurobi高级操作和使用方法/class3_pic1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/03-Gurobi高级操作和使用方法/class3_pic1.jpg -------------------------------------------------------------------------------- /12-组合优化/Guribo/05-Gurobi供应链物流案例-波次优化-订单配送优化/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/05-Gurobi供应链物流案例-波次优化-订单配送优化/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/05-Gurobi供应链物流案例-波次优化-订单配送优化/class5_物流供应商信息.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/05-Gurobi供应链物流案例-波次优化-订单配送优化/class5_物流供应商信息.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/05-Gurobi供应链物流案例-波次优化-订单配送优化/class5_订单信息.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/05-Gurobi供应链物流案例-波次优化-订单配送优化/class5_订单信息.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass5/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass5/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass5/BatchOpt/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass5/BatchOpt/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass5/BatchOpt/BatchOpt_按仓库_Model(V2).py: -------------------------------------------------------------------------------- 1 | 2 | # -*- coding: utf-8 -*- 3 | """ 4 | @author: Optimization Lanjian.zhu 5 | 6 | """ 7 | from gurobipy import * 8 | import xlrd 9 | import xlsxwriter 10 | from xlrd import xldate_as_tuple 11 | from collections import OrderedDict 12 | import time 13 | 14 | def ReadData(DataPath, Packages, Warehouse, Areas, Patterns, Record): 15 | print ("ReadData !") 16 | data = xlrd.open_workbook(DataPath) 17 | table = data.sheets()[0] 18 | nrows = table.nrows #行数 19 | AreasCnt = 0 20 | WarehouseCnt = 0 21 | PackagesCnt = 0 22 | PatternsCnt = 0 23 | for i in range(1,nrows): 24 | row = table.row_values(i) #抓取行 25 | Record.append(row) 26 | if row[1] not in Areas.keys(): 27 | Areas[row[1]] = [AreasCnt, []] 28 | AreasCnt += 1 29 | temp = row[1].split('-') #统计仓库 30 | if temp[0] not in Warehouse.keys(): 31 | Warehouse[temp[0]] = [WarehouseCnt, []] 32 | WarehouseCnt += 1 33 | 34 | if row[0] in Packages.keys(): 35 | Packages[row[0]][1] += row[2] 36 | if Warehouse[temp[0]][0] not in Packages[row[0]][2]: 37 | Packages[row[0]][2].append(Warehouse[temp[0]][0]) 38 | 39 | if Areas[row[1]][0] not in Packages[row[0]][3]: 40 | Packages[row[0]][3].append(Areas[row[1]][0]) 41 | else: 42 | Packages[row[0]] = [PackagesCnt, row[2], [Warehouse[temp[0]][0]], [Areas[row[1]][0]]] 43 | PackagesCnt += 1 44 | 45 | WarehouseSort = list(Warehouse.keys()) 46 | for i in Packages.keys(): 47 | temp = list(Packages[i][2]) 48 | temp.sort() 49 | temp.insert(0, Packages[i][1]) 50 | CheckPatterns = tuple(temp) 51 | if CheckPatterns in Patterns: 52 | Patterns[CheckPatterns].append(i) 53 | else: 54 | Patterns[CheckPatterns] = [PatternsCnt, i] 55 | for j in range(len(Packages[i][2])): 56 | Warehouse[WarehouseSort[Packages[i][2][j]]][1].append(CheckPatterns) 57 | PatternsCnt += 1 58 | 59 | def BuildFirstStageModel(Packages, Warehouse, Patterns, Batches, PackageLimit, GoodsLimit, BatchePattern, SolveTime): 60 | print ("BuildModel Version 2!") 61 | XINDEX = {} #变量下标 62 | YINDEX = {} #变量下标 63 | for j in range(1, Batches[1]+1): 64 | for i in Patterns.keys(): 65 | XINDEX[Patterns[i][0],j] = i[0] 66 | for k in range(len(Warehouse)): 67 | YINDEX[j,k] = 1 68 | 69 | model = Model() 70 | x = model.addVars(XINDEX.keys(), vtype=GRB.INTEGER, name='x') #变量x_{pj} 71 | y = model.addVars(YINDEX.keys(), obj=YINDEX, vtype=GRB.BINARY, name='y') #变量y_{jk} 72 | z = model.addVars(Batches[1], vtype=GRB.BINARY, name='z') #变量z_{j} 73 | 74 | #约束(1) 保证分配的波次数量 75 | if Batches[0] == Batches[1]: 76 | model.addConstr(z.sum('*') == Batches[0]) 77 | else: 78 | model.addConstr(z.sum('*') >= Batches[0]) 79 | model.addConstr(z.sum('*') <= Batches[1]) 80 | 81 | #约束(2) 保证模式使用次数和其包裹数量匹配 82 | for i in Patterns.keys(): 83 | model.addConstr(x.sum(Patterns[i][0],'*') == len(Patterns[i])-1) 84 | 85 | #约束(3) 保证单一波次商品件数在区间[G1,G2]中 86 | for j in range(1, Batches[1]+1): 87 | model.addConstr(x.prod(XINDEX,'*',j) >= z[j-1]*GoodsLimit[0]) 88 | model.addConstr(x.prod(XINDEX,'*',j) <= z[j-1]*GoodsLimit[1]) 89 | 90 | #约束(4) 保证单一波次包裹数量在区间[P1,P2]中 91 | for j in range(1, Batches[1]+1): 92 | model.addConstr(x.sum('*',j) >= z[j-1]*PackageLimit[0]) 93 | model.addConstr(x.sum('*',j) <= z[j-1]*PackageLimit[1]) 94 | 95 | #约束(5) 确认波次j是否用到仓库k 96 | WarehouseSort = list(Warehouse.keys()) 97 | for j in range(1, Batches[1]+1): 98 | for k in range(len(Warehouse)): 99 | expr = LinExpr() 100 | for p in range(len(Warehouse[WarehouseSort[k]][1])): 101 | expr += x[Patterns[Warehouse[WarehouseSort[k]][1][p]][0],j] 102 | model.addConstr(y[j,k] >= 0.001*expr) 103 | 104 | 105 | model.setParam(GRB.Param.TimeLimit, SolveTime) #求解时间 106 | model.optimize() 107 | 108 | batchnum = 1 109 | #获取求解结果 110 | for j in range(1, Batches[1]+1): 111 | if z[j-1].x != 0: 112 | for i in Patterns.keys(): 113 | value = x[Patterns[i][0],j].x 114 | if value != 0: 115 | for ii in range(1, round(value) + 1): 116 | Solutions[Patterns[i][ii]] = batchnum 117 | del Patterns[i][1:round(value) + 1] 118 | batchnum += 1 119 | print ("batchnum = ", batchnum) 120 | 121 | 122 | def OutputResult(Solutions, Record): 123 | workbook = xlsxwriter.Workbook('Result_按仓库(V2).xlsx') 124 | worksheet = workbook.add_worksheet('方案') 125 | worksheet.write(0, 0, 'pakage_no') 126 | worksheet.write(0, 1, 'warehouse') 127 | worksheet.write(0, 2, 'goods_qty') 128 | worksheet.write(0, 3, '波次') 129 | 130 | for i in range(len(Record)): 131 | worksheet.write(i+1, 0, Record[i][0]) 132 | worksheet.write(i+1, 1, Record[i][1]) 133 | worksheet.write(i+1, 2, Record[i][2]) 134 | worksheet.write(i+1, 3, Solutions[Record[i][0]]) 135 | workbook.close() 136 | 137 | try: 138 | DataPath = '测试案例.xlsx' #数据 139 | Packages = OrderedDict() #包裹信息 140 | Warehouse = OrderedDict() #仓库信息 141 | Areas = OrderedDict() #区域信息 142 | Patterns = OrderedDict() #模式 143 | Record = [] #数据记录 144 | BatchePattern = {} #第一阶段波次-模式对应关系 145 | Solutions = {} #解 146 | Batches = [107, 107] #波次数量 147 | PackageLimit = [500, 550] #单一波次包裹限制 148 | GoodsLimit = [1800,3000] #单一波次商品件数限制 149 | SolveTime = 100 #求解时间 150 | 151 | starttime = time.time() 152 | ReadData(DataPath, Packages, Warehouse, Areas, Patterns, Record) 153 | BuildFirstStageModel(Packages, Warehouse, Patterns, Batches, PackageLimit, GoodsLimit, BatchePattern, SolveTime) 154 | OutputResult(Solutions, Record) 155 | endtime = time.time() 156 | print ("over ! time = ", endtime-starttime) 157 | 158 | except GurobiError as exception: 159 | print('Error code ' + str(exception.errno) + ": " + str(exception)) 160 | 161 | except AttributeError: 162 | print('Encountered an attribute error') 163 | 164 | -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass5/订单配送优化/物流供应商信息.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass5/订单配送优化/物流供应商信息.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass5/订单配送优化/订单信息.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass5/订单配送优化/订单信息.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass6/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass6/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass6/ATP/ATP数据.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass6/ATP/ATP数据.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass6/ATP/ATP方案.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass6/ATP/ATP方案.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass6/PDPTW/PDPTW数据.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass6/PDPTW/PDPTW数据.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass6/PDPTW/PDPTW方案.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass6/PDPTW/PDPTW方案.xlsx -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass7/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/12-组合优化/Guribo/GurobiClass7/.DS_Store -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass7/排产问题.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: ZHU LANJIAN 4 | """ 5 | 6 | from gurobipy import * 7 | import xlrd, xlsxwriter, datetime, math 8 | from xlrd import xldate_as_datetime 9 | from collections import OrderedDict 10 | 11 | def ReadData(DataPath, Production): 12 | print ("ReadData !") 13 | data = xlrd.open_workbook(DataPath) 14 | table = data.sheets()[0] # Matrixdata 15 | nrows = table.nrows 16 | for i in range(1,nrows): 17 | row = table.row_values(i) 18 | if i not in Production.keys(): 19 | Production[i-1] = row[:] 20 | 21 | 22 | def BuildModel(Production, workingHours, workingHoursLimt, weighted1, weighted2, weighted3, bestX, bestY, bestE, bestU, bestV, bestW): 23 | xindex = {} #第t天生产第i种产品的数量 24 | yindex = {} #第t天是否生产第i种产品 25 | Nindex = {} #整数值，保证生产产品数量是材料批量的整数倍 26 | Eindex = {} #第t天生产的第i种产品调用了第j种产品的货架数量 27 | Uindex = {} #第t天单班生产 28 | Vindex = {} #第t天双班生产 29 | Windex = {} #第t天加班时间 30 | 31 | for t in range(7): 32 | Uindex[t] = 0 33 | Vindex[t] = 0 34 | Windex[t] = 0 35 | for i in range(len(Production)): 36 | xindex[i,t] = 1/Production[i][2] 37 | yindex[i,t] = 0 38 | Nindex[i,t] = 0 39 | for j in range(len(Production)): 40 | if i!=j and Production[i][1] == Production[j][1]: 41 | Eindex[i,j,t] = 0 42 | 43 | try: 44 | m = Model() 45 | x = m.addVars(xindex.keys(), vtype=GRB.INTEGER, name='x') #变量x_{it} 46 | y = m.addVars(yindex.keys(), obj=weighted2, vtype=GRB.BINARY, name='y') #变量y_{it} 47 | z = m.addVar(obj=1, vtype=GRB.CONTINUOUS, name='z') #变量z 48 | e = m.addVars(Eindex.keys(), vtype=GRB.INTEGER, name='e') #变量e_{ijt} 49 | n = m.addVars(Nindex.keys(), vtype=GRB.INTEGER, name='n') #变量n_{it} 50 | u = m.addVars(Uindex.keys(), obj=weighted3, vtype=GRB.BINARY, name='u') #变量u_{t} 51 | v = m.addVars(Vindex.keys(), obj=2*weighted3, vtype=GRB.BINARY, name='v') #变量v_{t} 52 | w = m.addVars(Windex.keys(), obj=weighted1, vtype=GRB.CONTINUOUS, name='w') #变量w_{t} 53 | 54 | #(1) 工时大于0.9 55 | for i in xindex.keys(): 56 | m.addConstr(x[i] >= 0.9*Production[i[0]][2]*y[i]) 57 | m.addConstr(x[i] <= (workingHoursLimt+1)*Production[i[0]][2]*y[i]) 58 | 59 | #(2) 每天的工时不超过 workingHoursLimt 小时 60 | for t in range(7): 61 | m.addConstr(x.prod(xindex, '*', t) <= 0.5*u[t]*workingHoursLimt+v[t]*workingHoursLimt) 62 | 63 | 64 | #(3) 生产产品数量要为原料批量的整数倍 65 | for i in xindex.keys(): 66 | m.addConstr(x[i] == Production[i[0]][3]*n[i]) 67 | 68 | 69 | #(4)(5) 每天产品库存数量不超过料架数量，且不得低于安全库存 70 | for i in xindex.keys(): 71 | expr = LinExpr() 72 | for j in range(i[1]+1): 73 | expr += x[i[0], j] - Production[i[0]][6+j] 74 | 75 | m.addConstr(Production[i[0]][5] + expr <= Production[i[0]][3]*10 + e.sum(i[0],'*', i[1]) - e.sum('*', i[0], i[1])) 76 | m.addConstr(Production[i[0]][5] + expr >= Production[i[0]][7+j]*Production[i[0]][4]) 77 | 78 | #(6) 某产品能被调用料架的数量不能超过对应的料架数 79 | for t in range(7): 80 | for i in range(len(Production)): 81 | m.addConstr(e.sum('*', i, t)<=Production[i][3]*10) 82 | 83 | #(7) Z值表示产品日库存最大值 84 | for t in range(7): 85 | expr = LinExpr() 86 | for i in range(len(Production)): 87 | expr += Production[i][6] 88 | for j in range(t+1): 89 | expr += x[i,j] - Production[i][7+j] 90 | m.addConstr(z >= expr) 91 | 92 | #(8)(9)(10) 93 | for t in range(7): 94 | m.addConstr(y.sum('*',t) >= u[t]) 95 | m.addConstr(y.sum('*',t) >= v[t]) 96 | m.addConstr(u[t] + v[t] <= 1) 97 | m.addConstr(y.sum('*',t) <= 10000*u[t] + 10000*v[t]) 98 | 99 | #(11) 加班时间 100 | for t in range(7): 101 | m.addConstr(x.prod(xindex, '*', t) - workingHours*u[t] - 2*workingHours*v[t] <= w[t]) 102 | 103 | m.optimize() 104 | 105 | #获得优化结果 106 | for i in xindex.keys(): 107 | bestX[i] = x[i].x 108 | bestY[i] = y[i].x 109 | 110 | for i in Uindex.keys(): 111 | bestU[i] = u[i].x 112 | bestV[i] = v[i].x 113 | bestW[i] = w[i].x 114 | 115 | for i in Eindex.keys(): 116 | bestE[i] = e[i].x 117 | 118 | except GurobiError as exception: 119 | print('Error code ' + str(exception.errno) + ": " + str(exception)) 120 | 121 | except AttributeError: 122 | print('Encountered an attribute error') 123 | 124 | def OutputResult(Production, workingHours, bestX, bestY, bestE, bestU, bestV, bestW): 125 | hours = [0]*7 126 | overtime = [0]*7 127 | inventory = [0]*7 128 | week = ['周一', '周二', '周三', '周四', '周五', '周六', '周日'] 129 | workbook = xlsxwriter.Workbook('案例1 结果.xlsx') 130 | 131 | ##################################### 132 | worksheet = workbook.add_worksheet('排产方案') 133 | worksheet.write(0, 0, '产品编号') 134 | for t in range(7): 135 | if bestU[t] == 1: 136 | week[t] += '（单班）' 137 | worksheet.write(0, t + 1, week[t]) 138 | overtime[t] = workingHours 139 | elif bestV[t] == 1: 140 | week[t] += '（双班）' 141 | worksheet.write(0, t + 1, week[t]) 142 | overtime[t] = 2*workingHours 143 | else: 144 | week[t] += '（---）' 145 | worksheet.write(0, t + 1, week[t]) 146 | 147 | rows = 1 148 | for i in range(len(Production)): 149 | worksheet.write(rows, 0, Production[i][0]) 150 | for t in range(7): 151 | worksheet.write(rows, t + 1, bestX[i,t]) 152 | rows += 1 153 | 154 | ##################################### 155 | worksheet = workbook.add_worksheet('生产工时') 156 | worksheet.write(0, 0, '产品编号') 157 | for t in range(7): 158 | worksheet.write(0, t + 1, week[t]) 159 | 160 | rows = 1 161 | for i in range(len(Production)): 162 | worksheet.write(rows, 0, Production[i][0]) 163 | for t in range(7): 164 | worksheet.write(rows, t + 1, bestX[i,t]/Production[i][2]) 165 | hours[t] += bestX[i,t]/Production[i][2] 166 | rows += 1 167 | 168 | worksheet.write(rows, 0, '工作时间') 169 | worksheet.write(rows+1, 0, '加班时间') 170 | for t in range(7): 171 | worksheet.write(rows, t+1, hours[t]) 172 | if overtime[t] < hours[t]: 173 | worksheet.write(rows+1, t+1, hours[t] - overtime[t]) 174 | else: 175 | worksheet.write(rows+1, t+1, 0) 176 | 177 | ##################################### 178 | worksheet = workbook.add_worksheet('产品库存') 179 | worksheet.write(0, 0, '产品编号') 180 | for t in range(7): 181 | worksheet.write(0, t + 1, week[t]) 182 | 183 | rows = 1 184 | for i in range(len(Production)): 185 | sumInventory = Production[i][5] 186 | worksheet.write(rows, 0, Production[i][0]) 187 | for t in range(7): 188 | sumInventory += bestX[i,t] - Production[i][7+t] 189 | inventory[t] += sumInventory 190 | worksheet.write(rows, t + 1, sumInventory) 191 | rows += 1 192 | 193 | worksheet.write(rows, 0, '库存合计') 194 | for t in range(7): 195 | worksheet.write(rows, t+1, inventory[t]) 196 | 197 | workbook.close() 198 | 199 | try: 200 | DataPath = '案例1 数据.xlsx' #数据 201 | Production = OrderedDict() 202 | bestX = {} 203 | bestY = {} 204 | bestZ = {} 205 | bestE = {} 206 | bestU = {} 207 | bestV = {} 208 | bestW = {} 209 | 210 | weighted1 = 1 #加班所占权重 211 | weighted2 = 1 #更换模具次数所占的权重 212 | weighted3 = 1 #班次所占的权重 213 | workingHours = 8 #工作时长 214 | workingHoursLimt = 20 #最长工作时间 215 | 216 | ReadData(DataPath, Production) 217 | BuildModel(Production, workingHours, workingHoursLimt, weighted1, weighted2, weighted3, bestX, bestY, bestE, bestU, bestV, bestW) 218 | OutputResult(Production, workingHours, bestX, bestY, bestE, bestU, bestV, bestW) 219 | print ('Over.') 220 | 221 | except GurobiError as exception: 222 | print('Error code ' + str(exception.errno) + ": " + str(exception)) 223 | 224 | except AttributeError: 225 | print('Encountered an attribute error') -------------------------------------------------------------------------------- /12-组合优化/Guribo/GurobiClass7/排班问题.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: ZHU LANJIAN 4 | """ 5 | 6 | from gurobipy import * 7 | import xlrd, xlsxwriter, datetime, math 8 | from xlrd import xldate_as_datetime 9 | from collections import OrderedDict 10 | 11 | def ReadData(DataPath, Unit): 12 | print ("ReadData !") 13 | data = xlrd.open_workbook(DataPath) 14 | table = data.sheets()[0] # Matrixdata 15 | nrows = table.nrows 16 | for i in range(1,nrows): 17 | row = table.row_values(i) 18 | if i not in Unit.keys(): 19 | index1 = row[1].find(':') 20 | index2 = row[2].find(':') 21 | row[1] = [float(row[1][:index1]),float(row[1][index1+1:])] 22 | row[2] = [float(row[2][:index2]),float(row[2][index2+1:])] 23 | Unit[i] = row[:] 24 | 25 | def BuildModel(Unit, groupNum, workingHours, weighted1, weighted2, weighted3, bestX, bestY, bestZ, bestU, bestV): 26 | xindex = {} #班组k完成生产块i后紧接着完成生产块j 27 | yindex = {} #班组k是否参与生产 28 | zindex = {} #班组k的加班时间 29 | 30 | for k in range(groupNum): 31 | yindex[k] = 0 32 | zindex[k] = 0 33 | xindex[0,len(Unit)+1, k] = 0 34 | for i in Unit.keys(): 35 | xindex[0,i,k] = 0 36 | xindex[i,len(Unit)+1,k] = Unit[i][5] 37 | for j in Unit.keys(): 38 | if i != j and Unit[i][2][0]*60 + Unit[i][2][1] <= Unit[j][1][0]*60 + Unit[j][1][1] and Unit[i][4] == Unit[j][3]: 39 | xindex[i,j,k] = Unit[i][5] 40 | 41 | try: 42 | m = Model() 43 | x = m.addVars(xindex.keys(), vtype=GRB.BINARY, name='x') #变量x_{ijk} 44 | y = m.addVars(yindex.keys(), obj=weighted1, vtype=GRB.BINARY, name='y') #变量y_{k} 45 | z = m.addVars(zindex.keys(), obj=weighted2, vtype=GRB.CONTINUOUS, name='z') #变量z_{k} 46 | u = m.addVar(obj=weighted3, vtype=GRB.CONTINUOUS, name='u') #变量u 47 | v = m.addVar(obj=-weighted2, vtype=GRB.CONTINUOUS, name='v') #变量v 48 | 49 | #(1) 每一个生产块都被分配 50 | for i in Unit.keys(): 51 | m.addConstr(x.sum(i,'*','*') == 1) 52 | 53 | #(2) 预处理，消减变量 54 | 55 | #(3) 班组是否参与生产 56 | for i in xindex.keys(): 57 | if i[0]!=0 or i[1]!=len(Unit)+1: 58 | m.addConstr(x[i]<=y[i[2]]) 59 | 60 | #(4) 生产块连接约束 61 | for k in range(groupNum): 62 | m.addConstr(x.sum(0, '*', k) == 1) 63 | m.addConstr(x.sum('*', len(Unit)+1, k) == 1) 64 | for i in Unit.keys(): 65 | m.addConstr(x.sum(i, '*', k) == x.sum('*', i, k)) 66 | 67 | #(5)(6)(7)最长和最短工作时间 加班时间 68 | for k in range(groupNum): 69 | m.addConstr(u >= x.prod(xindex, '*', '*', k)) 70 | m.addConstr(v <= (1-y[k])*24 + x.prod(xindex, '*', '*', k)) 71 | m.addConstr(z[k] >= x.prod(xindex, '*', '*', k)-8) 72 | 73 | 74 | #m.params.TimeLimit = 100 75 | m.optimize() 76 | #m.write('model.lp') 77 | 78 | #获得优化结果 79 | for i in xindex.keys(): 80 | if x[i].x-0.5 > 0 and (i[0]!=0 or i[1]!= len(Unit)+1): 81 | bestX[i] = x[i].x 82 | 83 | for k in range(groupNum): 84 | bestY[k] = y[k].x 85 | bestZ[k] = z[k].x 86 | 87 | bestU[0] = u.x 88 | bestV[0] = v.x 89 | 90 | except GurobiError as exception: 91 | print('Error code ' + str(exception.errno) + ": " + str(exception)) 92 | 93 | except AttributeError: 94 | print('Encountered an attribute error') 95 | 96 | def OutputResult(Unit, workingHours, bestX, bestY, bestZ, bestU, bestV): 97 | groupSet = {} 98 | for i in bestX.keys(): 99 | if i[2] not in groupSet.keys(): 100 | groupSet[i[2]] = [(i[0], i[1])] 101 | else: 102 | groupSet[i[2]].append((i[0], i[1])) 103 | 104 | for i in groupSet.keys(): 105 | count = 0 106 | while countGurobi Tutorial\n", 9 | "\n", 10 | "\n", 11 | "\n", 12 | "## 1. Gurobi 建模基本流程概念\n", 13 | "\n", 14 | "### 1. 建模基本流程\n", 15 | "\n", 16 | "1. Problem Instance: 待优化的问题\n", 17 | "2. Model Gnerator: 将数据组合成模型，产生计算机模型对象\n", 18 | "\n", 19 | "3. Model Instance: 存在于内存的一个完整数学模型\n", 20 | "4. Gurobi Optimizer: Gurobi 优化求解\n", 21 | "5. Solution Retrieval: 根据需要读取优化结果\n", 22 | "6. Analysis: 对结果进行分析 (敏感度分型等)\n", 23 | "7. 重复Step1-6，直到获得理想结果\n", 24 | "\n", 25 | "\n", 26 | "\n", 27 | "### 2. 建模基本概念\n", 28 | "\n", 29 | "1. Parameter\n", 30 | "\n", 31 | "\t- 控制优化器的行为，需要在优化启动前设置\n", 32 | "2. Attributes\n", 33 | "\n", 34 | "\t- 控制模型(包括模型、变量、约束、目标等对象)的特性\n", 35 | "\t- 例如，一个模型里面有`Constraints` 、 `Variables` 、 `Special Ordered Sets` 这些Attributes，而这些东西自己本身也有一些Attributes\n", 36 | "3. Enviroment\n", 37 | "\n", 38 | "\t- 一个环境内可以有多个模型\n", 39 | "\t- 包含模型和全局参数的一个容器，也是许可控制的节点\n", 40 | "\t- 在Python中，环境会根据默认参数自动建立，也可手动更改这些环境\n", 41 | "\n", 42 | "\n", 43 | "\n", 44 | "### 3. 建模过程\n", 45 | "\n", 46 | "​\t所有建模流程均以一下流程进行，不建议混合在一起。若混合在一起则会导致模型运行变慢。\n", 47 | "\n", 48 | "1. 创建模型\n", 49 | "\t- m = gp.Model()\n", 50 | "2. 创建所有变量\t\n", 51 | "\t- m.addVar()\n", 52 | "\t- m.addVars()\n", 53 | "3. 设置目标函数\n", 54 | " - m.setObjective()\n", 55 | "4. 创建所有限制条件\n", 56 | " - m.addConstr()\n", 57 | " - m.addConstrs()\n", 58 | "5. 运行求解器\n", 59 | " - m.optimize()\n", 60 | "\n", 61 | "\n", 62 | "\n", 63 | "\n", 64 | "\n", 65 | "## 2. Tuplelist / Tupledict\n", 66 | "\n", 67 | "### 1. 简介\n", 68 | "\n", 69 | "​\t在优化建模过程中，经常需要对下标数据进行挑选组合。但是Python的 list / tuple / dict 用来做这件事情的时候，就需要用到循环+if进行筛选，效率非常低，所以需要采用Gurobi的扩展对象 `Tuplelist` 和 `Tupledict` 来做这件事情\n", 70 | "\n", 71 | "\n", 72 | "\n", 73 | "### 2. 特点\n", 74 | "\n", 75 | "1. `tuplelist` \n", 76 | " - 用于建立下标的完整集合\n", 77 | " - 可以使用 `.select()` 去搜索所需的内容\n", 78 | " - '*' 代表任意匹配项\n", 79 | " - ['X', 'Y'] 代表可以匹配 [] 内任意一个元素\n", 80 | " - 如 `.select([1,2], '*')` 即代表搜索出第一个元素为1或2，第二元素任意的下标组合\n", 81 | "\n", 82 | "2. `tupledict`\n", 83 | " - 用于建立变量\n", 84 | " - 可用使用 `.quicksum()` / `.prod()` 对变量进行加减乘的操作\n", 85 | "- `quicksum` 其实就是相当于一个$\\sum$符号, 其函数里面的就是在这个$\\sum$循环内\n", 86 | " \n", 87 | "3. List Comprehension\n", 88 | " - 用于列表解析for语句，即我们常在限制条件里写的 $\\forall$\n", 89 | " - 例如\n", 90 | " - $\\sum_{i \\in I} x_{i,j} <= 1 \\ \\ \\ \\forall j \\in J$\n", 91 | " - m.addConstrs( (x.sum('*', j <= 1 for j in J)), name = 'con' )\n", 92 | "\n", 93 | "\n", 94 | "\n", 95 | "## 3. SOS - Special Ordered Set\n", 96 | "\n", 97 | "- SOS1\n", 98 | " - 在集合内的一系列变量中，只有一个为非零变量\n", 99 | " - 即$\\{y_1, y_2,...,y_m\\}$为SOS1时，仅有一个$y_j$非0\n", 100 | " - 在线性规划中使用SOS能使得求解的速度更快\n", 101 | " - 例子\n", 102 | " - 现在要从5个仓库中选一个出来，每一个仓库有各自的cost和size\n", 103 | " - 设x1, x2, ...., x5为是否选对应仓库 (则xi为SOS1)\n", 104 | " - 式子\n", 105 | " - $cost = 100x_1 + 180x_2 + 320x_3 + 450x_4 + 600x_5$\n", 106 | " - $size = 10x_1 + 20x_2 + 40_x3 + 60x_4 + 80x_5$\n", 107 | " - $x_1 + x_2 + x_3 + x_4 + x_5 = 1$ (即SOS Constraint)\n", 108 | "\n", 109 | "- SOS2\n", 110 | " - 在集合内的一系列变量中，最多只有两个非零变量， 如果存在两个非零变量，则他们必须在集合内是邻近的\n", 111 | " - 即$\\{y_1, y_2,...,y_m\\}$为SOS2时，最多有两个相邻的$y_j, y_{j+1}$非0；当然，只有一个非零或没有非0亦可存在\n", 112 | "\n", 113 | "\n", 114 | "\n", 115 | "- 仅支持最多两个变量相乘(或二次方)\n", 116 | "\n", 117 | "\n", 118 | "\n", 119 | "\n", 120 | "\n", 121 | "\n", 122 | "\n", 123 | "\n" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "id": "01b287a3", 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [] 133 | } 134 | ], 135 | "metadata": { 136 | "kernelspec": { 137 | "display_name": "ACG", 138 | "language": "python", 139 | "name": "acg" 140 | }, 141 | "language_info": { 142 | "codemirror_mode": { 143 | "name": "ipython", 144 | "version": 3 145 | }, 146 | "file_extension": ".py", 147 | "mimetype": "text/x-python", 148 | "name": "python", 149 | "nbconvert_exporter": "python", 150 | "pygments_lexer": "ipython3", 151 | "version": "3.6.13" 152 | }, 153 | "toc": { 154 | "base_numbering": 1, 155 | "nav_menu": {}, 156 | "number_sections": true, 157 | "sideBar": true, 158 | "skip_h1_title": false, 159 | "title_cell": "Table of Contents", 160 | "title_sidebar": "Contents", 161 | "toc_cell": false, 162 | "toc_position": {}, 163 | "toc_section_display": true, 164 | "toc_window_display": false 165 | } 166 | }, 167 | "nbformat": 4, 168 | "nbformat_minor": 5 169 | } 170 | -------------------------------------------------------------------------------- /12-组合优化/分支定界.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e2678f28", 6 | "metadata": {}, 7 | "source": [ 8 | "## 分枝定界" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "a78ea262", 14 | "metadata": {}, 15 | "source": [ 16 | "整数规划的模型与线性规划基本相同，只是额外的添加了部分变量为整数的约束。假设问题为：\n", 17 | "\n", 18 | "$$\n", 19 | "\\min cx \\\\\n", 20 | "s.t. Ax \\geq b \\\\\n", 21 | "A_{eq}x = b_{eq} \\\\\n", 22 | "x \\in z\n", 23 | "$$\n", 24 | "\n", 25 | "整数规划求解的基本框架是分支定界法（`Branch and bound，B&B`）。首先去除整数约束得到“松弛模型”，使用线性规划的方法求解。若有某个变量不是整数，在松弛模型上分别添加约束：$x ≤ floor(A)$和$x ≥ ceil(A)$。\n", 26 | "\n", 27 | "然后再分别求解，这个过程叫做分支。当节点求解结果中所有变量都是整数时，停止分支。这样不断迭代，形成了一棵树。\n", 28 | "所谓的定界，指的是叶子节点产生后，相当于给问题定了一个下界。之后在求解过程中一旦某个节点的目标函数值小于这个下界，那就直接pass，不用再进行分支了；每次新产生叶子节点，则更新下界。\n" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 1, 34 | "id": "78cfe876", 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "from scipy.optimize import linprog\n", 39 | "import numpy as np\n", 40 | "import math\n", 41 | "import sys\n", 42 | "from queue import Queue" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 2, 48 | "id": "7e86eaa3", 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [ 52 | "class ILP():\n", 53 | " def __init__(self, c, A_ub, b_ub, A_eq, b_eq, bounds):\n", 54 | " # 全局参数\n", 55 | " self.LOWER_BOUND = -sys.maxsize\n", 56 | " self.UPPER_BOUND = sys.maxsize\n", 57 | " self.opt_val = None\n", 58 | " self.opt_x = None\n", 59 | " self.Q = Queue()\n", 60 | " \n", 61 | " # 这些参数在每轮计算中都不会改变\n", 62 | " self.c = -c\n", 63 | " self.A_eq = A_eq\n", 64 | " self.b_eq = b_eq\n", 65 | " self.bounds = bounds\n", 66 | " \n", 67 | " # 首先计算一下初始问题\n", 68 | " r = linprog(-c, A_ub, b_ub, A_eq, b_eq, bounds)\n", 69 | " \n", 70 | " # 若最初问题线性不可解\n", 71 | " if not r.success:\n", 72 | " raise ValueError('Not a feasible problem!')\n", 73 | " \n", 74 | " # 将解和约束参数放入队列\n", 75 | " self.Q.put((r, A_ub, b_ub))\n", 76 | " \n", 77 | " def solve(self):\n", 78 | " while not self.Q.empty():\n", 79 | " # 取出当前问题\n", 80 | " res, A_ub, b_ub = self.Q.get(block=False)\n", 81 | " \n", 82 | " # 当前最优值小于总下界，则排除此区域\n", 83 | " if -res.fun < self.LOWER_BOUND:\n", 84 | " continue\n", 85 | " \n", 86 | " # 若结果 x 中全为整数，则尝试更新全局下界、全局最优值和最优解\n", 87 | " if all(list(map(lambda f: f.is_integer(), res.x))):\n", 88 | " if self.LOWER_BOUND < -res.fun:\n", 89 | " self.LOWER_BOUND = -res.fun\n", 90 | " \n", 91 | " if self.opt_val is None or self.opt_val < -res.fun:\n", 92 | " self.opt_val = -res.fun\n", 93 | " self.opt_x = res.x\n", 94 | " \n", 95 | " continue\n", 96 | " \n", 97 | " # 进行分枝\n", 98 | " else:\n", 99 | " # 寻找 x 中第一个不是整数的，取其下标 idx\n", 100 | " idx = 0\n", 101 | " for i, x in enumerate(res.x):\n", 102 | " if not x.is_integer():\n", 103 | " break\n", 104 | " idx += 1\n", 105 | " \n", 106 | " # 构建新的约束条件（分割\n", 107 | " new_con1 = np.zeros(A_ub.shape[1])\n", 108 | " new_con1[idx] = -1\n", 109 | " new_con2 = np.zeros(A_ub.shape[1])\n", 110 | " new_con2[idx] = 1\n", 111 | " new_A_ub1 = np.insert(A_ub, A_ub.shape[0], new_con1, axis=0)\n", 112 | " new_A_ub2 = np.insert(A_ub, A_ub.shape[0], new_con2, axis=0)\n", 113 | " new_b_ub1 = np.insert(\n", 114 | " b_ub, b_ub.shape[0], -math.ceil(res.x[idx]), axis=0)\n", 115 | " new_b_ub2 = np.insert(\n", 116 | " b_ub, b_ub.shape[0], math.floor(res.x[idx]), axis=0)\n", 117 | " \n", 118 | " # 将新约束条件加入队列，先加最优值大的那一支\n", 119 | " r1 = linprog(self.c, new_A_ub1, new_b_ub1, self.A_eq,\n", 120 | " self.b_eq, self.bounds)\n", 121 | " r2 = linprog(self.c, new_A_ub2, new_b_ub2, self.A_eq,\n", 122 | " self.b_eq, self.bounds)\n", 123 | " if not r1.success and r2.success:\n", 124 | " self.Q.put((r2, new_A_ub2, new_b_ub2))\n", 125 | " elif not r2.success and r1.success:\n", 126 | " self.Q.put((r1, new_A_ub1, new_b_ub1))\n", 127 | " elif r1.success and r2.success:\n", 128 | " if -r1.fun > -r2.fun:\n", 129 | " self.Q.put((r1, new_A_ub1, new_b_ub1))\n", 130 | " self.Q.put((r2, new_A_ub2, new_b_ub2))\n", 131 | " else:\n", 132 | " self.Q.put((r2, new_A_ub2, new_b_ub2))\n", 133 | " self.Q.put((r1, new_A_ub1, new_b_ub1))\n" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 3, 139 | "id": "30907612", 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "Test 1's result: 340.0 [4. 2.]\n", 147 | "Test 1's true optimal x: [4, 2]\n", 148 | "\n" 149 | ] 150 | } 151 | ], 152 | "source": [ 153 | "def test1():\n", 154 | " \"\"\" 此测试的真实最优解为 [4, 2] \"\"\"\n", 155 | " c = np.array([40, 90])\n", 156 | " A = np.array([[9, 7], [7, 20]])\n", 157 | " b = np.array([56, 70])\n", 158 | " Aeq = None\n", 159 | " beq = None\n", 160 | " bounds = [(0, None), (0, None)]\n", 161 | " \n", 162 | " solver = ILP(c, A, b, Aeq, beq, bounds)\n", 163 | " solver.solve()\n", 164 | " \n", 165 | " print(\"Test 1's result:\", solver.opt_val, solver.opt_x)\n", 166 | " print(\"Test 1's true optimal x: [4, 2]\\n\")\n", 167 | "test1()" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 4, 173 | "id": "a29b65a7", 174 | "metadata": {}, 175 | "outputs": [ 176 | { 177 | "name": "stdout", 178 | "output_type": "stream", 179 | "text": [ 180 | "Test 2's result: 58.0 [2. 4.]\n", 181 | "Test 2's true optimal x: [2, 4]\n", 182 | "\n" 183 | ] 184 | } 185 | ], 186 | "source": [ 187 | "def test2():\n", 188 | " \"\"\" 此测试的真实最优解为 [2, 4] \"\"\"\n", 189 | " c = np.array([3, 13])\n", 190 | " A = np.array([[2, 9], [11, -8]])\n", 191 | " b = np.array([40, 82])\n", 192 | " Aeq = None\n", 193 | " beq = None\n", 194 | " bounds = [(0, None), (0, None)]\n", 195 | " \n", 196 | " solver = ILP(c, A, b, Aeq, beq, bounds)\n", 197 | " solver.solve()\n", 198 | " \n", 199 | " print(\"Test 2's result:\", solver.opt_val, solver.opt_x)\n", 200 | " print(\"Test 2's true optimal x: [2, 4]\\n\")\n", 201 | "test2()" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": null, 207 | "id": "f977beab", 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [] 211 | } 212 | ], 213 | "metadata": { 214 | "kernelspec": { 215 | "display_name": "ACG", 216 | "language": "python", 217 | "name": "acg" 218 | }, 219 | "language_info": { 220 | "codemirror_mode": { 221 | "name": "ipython", 222 | "version": 3 223 | }, 224 | "file_extension": ".py", 225 | "mimetype": "text/x-python", 226 | "name": "python", 227 | "nbconvert_exporter": "python", 228 | "pygments_lexer": "ipython3", 229 | "version": "3.6.13" 230 | } 231 | }, 232 | "nbformat": 4, 233 | "nbformat_minor": 5 234 | } 235 | -------------------------------------------------------------------------------- /14-深度视觉/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/14-深度视觉/.DS_Store -------------------------------------------------------------------------------- /14-深度视觉/03-目标检测/23-物体检测算法：R-CNN，SSD， YOLO.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "03ad462c", 6 | "metadata": {}, 7 | "source": [ 8 | "## 区域卷积神经网络(R-CNN)\n", 9 | "\n", 10 | "\n", 11 | "\n", 12 | "1. 使用启发式搜索算法来选择锚框。\n", 13 | "\n", 14 | "2. 选出来锚框之后，对每一个锚框当作一张图片，然后用预训练模型来对每个锚框抽取特征。\n", 15 | "\n", 16 | "3. 抽出来特征之后，用SVM来对类别进行分类。\n", 17 | "\n", 18 | "4. 再训练一个线性回归模型来预测边缘框的偏移。" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "id": "293f24bf", 24 | "metadata": {}, 25 | "source": [ 26 | "### 兴趣区域(ROI)池化层\n", 27 | "\n", 28 | "锚框每次选到的大小是不一样的，这就没办法做成一个`batch size`, 因此这里提出是: 给定一个锚框，均匀分割成$n \\times m$块，输出每块里的最大值。这样，不管锚框多大，总是会输出$nm$个值。 " 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "id": "00e272d2", 34 | "metadata": {}, 35 | "source": [ 36 | "## Fast RCNN\n", 37 | "\n", 38 | "R-CNN里面的问题就是对每个锚框都抽特征，如果有1000个锚框的话，就需要抽一千次，这个计算量太大了。\n", 39 | "\n", 40 | "使用CNN对整张图片(不是锚框)抽取特征，然后再在原始图像上选择锚框，锚款选择好之后，再将其映射到CNN的输出上面， 这样就得到了原始图像锚框对应的CNN特征图上的特征。\n", 41 | "\n", 42 | "之后再使用ROI池化层对每个锚框生成固定长度的特征。\n", 43 | "\n", 44 | "之后再进入全连接层，也不需要SVM。" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "id": "e4a9e256", 50 | "metadata": {}, 51 | "source": [ 52 | "## Faster R-CNN\n", 53 | "\n", 54 | "使用一个区域提议网络(Region Proposal Network)来替代启发式搜索来获得更好的锚框。区域提议网络是加在卷积网络之后，ROI之前，用于给出一些比较糙的锚框。" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "id": "14f62a7f", 60 | "metadata": {}, 61 | "source": [ 62 | "## Mask R-CNN\n", 63 | "\n", 64 | "Mask R-CNN和Faster R-CNN基本上没有什么区别，如果有像素级别的编号的话，我们是可以使用FCN来利用这些信息的，比如COCO数据集就有像素级别的标号。" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "id": "f7dbeab5", 70 | "metadata": {}, 71 | "source": [ 72 | "## 单发多框检测 (SSD)\n", 73 | "\n", 74 | "核心思想是解决`Faster R-CNN`序列将其分成两部分，一部分`Region Proposal Network`选锚框，一部分做预测的问题。`SSD`就是做一次就够了。\n", 75 | "\n", 76 | "### 生成锚框\n", 77 | "\n", 78 | "对每个像素，生成多个以它为中心的锚框。给定$n$个大小$s_{1}, \\cdots, s_{n}$和$m$个高宽比，那么生成$n + m -1$个锚框，其大小和高宽比分别为:\n", 79 | "\n", 80 | "$$\n", 81 | "(s_{1}, r_{1}), (s_{2}, r_{2}), \\cdots, (s_{n}, r_{1}), (s_{1}, r_{2}), \\cdots, (s_{1}, r_{m})\n", 82 | "$$\n", 83 | "\n", 84 | "一个基础网络来抽取特征，然后多个卷积层来减半高宽。在每段都生成锚框，底部段来拟合小物体，顶部段来你和大物体。对每个锚框预测类别和边缘框。\n", 85 | "\n", 86 | "`SSD`通过单神经网络来检测模型，以每个像素为中心，产生多个锚框，在多个段的输出上进行多尺度的检测。" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "id": "7ab52960", 92 | "metadata": {}, 93 | "source": [ 94 | "## YOLO\n", 95 | "\n", 96 | "`SSD`中锚框大量重叠，因此浪费了很多计算。YOLO将图片均分成$S \\times S$个锚框，每个锚框预测$B$个边缘框。" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "id": "f9e4f376", 102 | "metadata": {}, 103 | "source": [] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "id": "a705aa5e", 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "id": "ed9217ca", 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "id": "9acacf54", 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": null, 132 | "id": "113b54d2", 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [] 136 | } 137 | ], 138 | "metadata": { 139 | "kernelspec": { 140 | "display_name": "Python 3 (ipykernel)", 141 | "language": "python", 142 | "name": "python3" 143 | }, 144 | "language_info": { 145 | "codemirror_mode": { 146 | "name": "ipython", 147 | "version": 3 148 | }, 149 | "file_extension": ".py", 150 | "mimetype": "text/x-python", 151 | "name": "python", 152 | "nbconvert_exporter": "python", 153 | "pygments_lexer": "ipython3", 154 | "version": "3.9.4" 155 | }, 156 | "toc": { 157 | "base_numbering": 1, 158 | "nav_menu": {}, 159 | "number_sections": true, 160 | "sideBar": true, 161 | "skip_h1_title": false, 162 | "title_cell": "Table of Contents", 163 | "title_sidebar": "Contents", 164 | "toc_cell": false, 165 | "toc_position": {}, 166 | "toc_section_display": true, 167 | "toc_window_display": true 168 | } 169 | }, 170 | "nbformat": 4, 171 | "nbformat_minor": 5 172 | } 173 | -------------------------------------------------------------------------------- /14-深度视觉/03-目标检测/25-SSD实现.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "334a758a", 6 | "metadata": {}, 7 | "source": [] 8 | }, 9 | { 10 | "cell_type": "code", 11 | "execution_count": 1, 12 | "id": "eb58cb39", 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import torch\n", 17 | "import torchvision\n", 18 | "from torch import nn\n", 19 | "from torch.nn import functional as F" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 2, 25 | "id": "1adb5240", 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "def cls_predictor(num_inputs, num_anchors, num_classes):\n", 30 | " \"\"\"\n", 31 | " # 预测一个锚框的类别。\n", 32 | " \"\"\"\n", 33 | " return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1), kernel_size=3, padding=1)" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "id": "b233d41f", 40 | "metadata": {}, 41 | "outputs": [], 42 | "source": [] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "id": "ef6dfefd", 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [] 51 | } 52 | ], 53 | "metadata": { 54 | "kernelspec": { 55 | "display_name": "Python 3 (ipykernel)", 56 | "language": "python", 57 | "name": "python3" 58 | }, 59 | "language_info": { 60 | "codemirror_mode": { 61 | "name": "ipython", 62 | "version": 3 63 | }, 64 | "file_extension": ".py", 65 | "mimetype": "text/x-python", 66 | "name": "python", 67 | "nbconvert_exporter": "python", 68 | "pygments_lexer": "ipython3", 69 | "version": "3.9.4" 70 | }, 71 | "toc": { 72 | "base_numbering": 1, 73 | "nav_menu": {}, 74 | "number_sections": true, 75 | "sideBar": true, 76 | "skip_h1_title": false, 77 | "title_cell": "Table of Contents", 78 | "title_sidebar": "Contents", 79 | "toc_cell": false, 80 | "toc_position": {}, 81 | "toc_section_display": true, 82 | "toc_window_display": false 83 | } 84 | }, 85 | "nbformat": 4, 86 | "nbformat_minor": 5 87 | } 88 | -------------------------------------------------------------------------------- /20-TensorRT/未命名.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "5adf122c", 6 | "metadata": {}, 7 | "source": [ 8 | "详解TensorRT的C++/Python高性能部署，实战应用到项目:https://www.bilibili.com/video/BV1Xw411f7FW/?spm_id_from=333.788.recommend_more_video.1" 9 | ] 10 | } 11 | ], 12 | "metadata": { 13 | "kernelspec": { 14 | "display_name": "Python 3 (ipykernel)", 15 | "language": "python", 16 | "name": "python3" 17 | }, 18 | "language_info": { 19 | "codemirror_mode": { 20 | "name": "ipython", 21 | "version": 3 22 | }, 23 | "file_extension": ".py", 24 | "mimetype": "text/x-python", 25 | "name": "python", 26 | "nbconvert_exporter": "python", 27 | "pygments_lexer": "ipython3", 28 | "version": "3.9.4" 29 | }, 30 | "toc": { 31 | "base_numbering": 1, 32 | "nav_menu": {}, 33 | "number_sections": true, 34 | "sideBar": true, 35 | "skip_h1_title": false, 36 | "title_cell": "Table of Contents", 37 | "title_sidebar": "Contents", 38 | "toc_cell": false, 39 | "toc_position": {}, 40 | "toc_section_display": true, 41 | "toc_window_display": false 42 | } 43 | }, 44 | "nbformat": 4, 45 | "nbformat_minor": 5 46 | } 47 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 tinyzqh 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Algorithms_Note 2 | 算法工程师技术栈学习笔记 3 | 4 | ## [01-Python学习](./01-Python学习) 5 | 6 | - [Scipy处理稀疏矩阵](./01-Python学习/Scipy中的稀疏矩阵运算.ipynb) 7 | - [Pandas](./01-Python学习/Pandas.ipynb) 8 | - [操作Json文件](./01-Python学习/操作Json文件操作.ipynb) 9 | 10 | ## [02-线性代数](./02-线性代数) 11 | 12 | ## [03-最优化](./03-最优化) 13 | 14 | - [梯度下降、加速梯度下降、随机梯度下降、随机坐标下降](./03-最优化/梯度下降、加速梯度下降、随机梯度下降、随机坐标下降.ipynb) 15 | 16 | ## [04-传统机器学习](./04-传统机器学习) 17 | 18 | - [1. 线性回归](./04-传统机器学习/01_线性回归.ipynb) 19 | - [2. 感知机](./04-传统机器学习/02_感知机.ipynb) 20 | - [3. K近邻](./04-传统机器学习/03_K近邻.ipynb) 21 | 22 | ## [05-概率论机器学习](./05-概率论机器学习) 23 | 24 | ## [06-深度学习框架](./06-深度学习框架) 25 | 26 | - [PyTorch教程1-Tensor核心知识点](./06-深度学习框架/PyTorch教程1-Tensor核心知识点.ipynb) 27 | - [PyTorch教程2-DataSet与DataLoaders](./06-深度学习框架/PyTorch教程2-DataSet与DataLoaders.ipynb) 28 | - [PyTorch教程3-DataSet与DataLoaders源码解析](./06-深度学习框架/PyTorch教程3-DataSet与DataLoaders源码解析.ipynb) 29 | - [PyTorch教程4-神经网络基础功能模块](./06-深度学习框架/PyTorch教程4-神经网络基础功能模块.ipynb) 30 | - [PyTorch教程5-nn.Module类的源码讲解](./06-深度学习框架/PyTorch教程5-nn.Module类的源码讲解.ipynb) 31 | - [PyTorch教程6-自动微分以及autograd的使用.ipynb](./06-深度学习框架/PyTorch教程6-自动微分以及autograd的使用.ipynb) 32 | - [PyTorch教程7-神经网络整体训练流程](./06-深度学习框架/PyTorch教程7-神经网络整体训练流程.ipynb) 33 | - [PyTorch教程8-保存与加载PyTorch训练模型和超参数](./06-深度学习框架/PyTorch教程8-保存与加载PyTorch训练模型和超参数.ipynb) 34 | 35 | ## [07-深度学习](./07-深度学习) 36 | 37 | ### [01-深度学习基础](./07-深度学习/01-深度学习基础) 38 | 39 | 40 | ### [02-卷积神经网络](./07-深度学习/02-卷积神经网络) 41 | 42 | 43 | - [01-卷积网络代码级原理理解](./07-深度学习/02-卷积神经网络/01-卷积网络代码级原理理解.ipynb) 44 | - [02-卷积操作在PyTorch中实现与使用](./07-深度学习/02-卷积神经网络/02-卷积操作在PyTorch中实现与使用.ipynb) 45 | - [03-卷积算子融合](./07-深度学习/02-卷积神经网络/03-卷积算子融合.ipynb) 46 | 47 | ### [03-循环神经网络](./07-深度学习/03-循环神经网络) 48 | 49 | - [01-序列模型、语言模型](./07-深度学习/03-循环神经网络/01-序列模型、语言模型.ipynb) 50 | - [02-RNN原理与Numpy实现](./07-深度学习/03-循环神经网络/02-RNN原理与Numpy实现.ipynb) 51 | - [03-LSTM原理与Numpy实现](./07-深度学习/03-循环神经网络/03-LSTM原理与Numpy实现.ipynb) 52 | - [04-GRU原理与Numpy实现](./07-深度学习/03-循环神经网络/04-GRU原理与Numpy实现.ipynb) 53 | 54 | ### [04-Transformer](./07-深度学习/04-Transformer) 55 | 56 | - [01-Transformer-API详解](./07-深度学习/04-Transformer/01-Transformer-API详解.ipynb) 57 | - [02-Attention机制](./07-深度学习/04-Transformer/02-Attention机制.ipynb) 58 | - [03-Transformer全流程代码](./07-深度学习/04-Transformer/03-Transformer全流程代码.ipynb) 59 | 60 | ### [05-图网络](./07-深度学习/05-图网络) 61 | ### [06-生成对抗学习](./07-深度学习/06-生成对抗学习) 62 | ### [07-多任务学习](./07-深度学习/07-多任务学习) 63 | ### [08-少样本学习](./07-深度学习/08-少样本学习) 64 | 65 | ## [08-自然语言处理](./08-自然语言处理) 66 | 67 | 68 | 69 | ## [09-推荐系统](./09-推荐系统) 70 | 71 | ## [10-语音处理](./10-语音处理) 72 | 73 | ## [11-强化学习](./11-强化学习) 74 | 75 | ## [12-组合优化](./12-组合优化) 76 | 77 | - [遗传算法求解TSP问题](./12-组合优化/遗传算法求解TSP问题.ipynb) 78 | - [分支定界](./12-组合优化/分支定界.ipynb) 79 | 80 | ## [13-机器视觉](./13-机器视觉) 81 | 82 | ## [14-深度视觉](./14-深度视觉) 83 | 84 | ## [15-迁移学习](./15-迁移学习) 85 | 86 | ## [16-联邦学习](./16-联邦学习) 87 | 88 | ## [17-机器博弈](./17-机器博弈) 89 | 90 | 91 | ## 参考 92 | 93 | - [nlp_notes](https://github.com/YangBin1729/nlp_notes) 94 | 95 | -------------------------------------------------------------------------------- /d2l/__init__.py: -------------------------------------------------------------------------------- 1 | """Saved source code for "Dive into Deep Learing" (https://d2l.ai). 2 | 3 | Please import d2l by one of the following ways: 4 | 5 | from d2l import mxnet as d2l # Use MXNet as the backend 6 | from d2l import torch as d2l # Use PyTorch as the backend 7 | from d2l import tensorflow as d2l # Use TensorFlow as the backend 8 | 9 | """ 10 | 11 | __version__ = "2.0.0-alpha2" 12 | -------------------------------------------------------------------------------- /data/house_tiny.csv: -------------------------------------------------------------------------------- 1 | NumRooms,Alley,Price 2 | NA,Pave,127500 3 | 2,NA,106000 4 | 4,NA,178100 5 | NA,NA,140000 6 | -------------------------------------------------------------------------------- /images/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/.DS_Store -------------------------------------------------------------------------------- /images/06-jisuantu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/06-jisuantu.png -------------------------------------------------------------------------------- /images/07-juanji.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/07-juanji.png -------------------------------------------------------------------------------- /images/11-Markov_Decision_Process_example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/11-Markov_Decision_Process_example.png -------------------------------------------------------------------------------- /images/11-connect2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/11-connect2.png -------------------------------------------------------------------------------- /images/11-kuhnPoker.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/11-kuhnPoker.png -------------------------------------------------------------------------------- /images/11-policy-iteratioin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/11-policy-iteratioin.png -------------------------------------------------------------------------------- /images/11-value_iteration.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/11-value_iteration.png -------------------------------------------------------------------------------- /images/12-graph_example1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/12-graph_example1.png -------------------------------------------------------------------------------- /images/12-graph_example_message_pass_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/12-graph_example_message_pass_1.png -------------------------------------------------------------------------------- /images/12-graph_message_pass.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/12-graph_message_pass.png -------------------------------------------------------------------------------- /images/12-graph_message_pass_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/12-graph_message_pass_1.png -------------------------------------------------------------------------------- /images/18-donglixue.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/18-donglixue.png -------------------------------------------------------------------------------- /images/18-hangxiangjiao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/18-hangxiangjiao.png -------------------------------------------------------------------------------- /images/18-qita.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/18-qita.png -------------------------------------------------------------------------------- /images/18-youshouxi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/18-youshouxi.png -------------------------------------------------------------------------------- /images/18-zuobiaoxi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/18-zuobiaoxi.png -------------------------------------------------------------------------------- /images/GNN.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/GNN.png -------------------------------------------------------------------------------- /images/GNN_data.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/GNN_data.png -------------------------------------------------------------------------------- /images/MCTS.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/MCTS.png -------------------------------------------------------------------------------- /images/Transformer-decoder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/Transformer-decoder.png -------------------------------------------------------------------------------- /images/Transformer-encoder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/Transformer-encoder.png -------------------------------------------------------------------------------- /images/beta分布的超参数.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/beta分布的超参数.png -------------------------------------------------------------------------------- /images/com_graph.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/com_graph.jpeg -------------------------------------------------------------------------------- /images/confusion_matrix.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/confusion_matrix.jpeg -------------------------------------------------------------------------------- /images/gamma分布.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/gamma分布.png -------------------------------------------------------------------------------- /images/multi_head_attention.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/multi_head_attention.png -------------------------------------------------------------------------------- /images/pca.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/pca.png -------------------------------------------------------------------------------- /images/pca_algorithms.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/pca_algorithms.png -------------------------------------------------------------------------------- /images/pointer_network.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/pointer_network.png -------------------------------------------------------------------------------- /images/scaled-dot-product-attention.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/scaled-dot-product-attention.png -------------------------------------------------------------------------------- /images/scaled_attention.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/scaled_attention.png -------------------------------------------------------------------------------- /images/tinyzqh.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/tinyzqh.jpg -------------------------------------------------------------------------------- /images/transformer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/transformer.png -------------------------------------------------------------------------------- /images/zixingchemoxing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/zixingchemoxing.png -------------------------------------------------------------------------------- /images/凹函数的性质.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/凹函数的性质.png -------------------------------------------------------------------------------- /images/单纯形.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/单纯形.png -------------------------------------------------------------------------------- /images/概率分布.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/概率分布.png -------------------------------------------------------------------------------- /images/概率分布之间的关系.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/概率分布之间的关系.png -------------------------------------------------------------------------------- /images/狄利克雷分布.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/狄利克雷分布.png -------------------------------------------------------------------------------- /images/高斯分布_均值的贝叶斯推断.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/高斯分布_均值的贝叶斯推断.png -------------------------------------------------------------------------------- /images/高斯条件概率与边缘概率.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tinyzqh/Algorithms_Note/8342fa18eeb03651fe0a605ab20b3b8f8aed0e24/images/高斯条件概率与边缘概率.png --------------------------------------------------------------------------------